using System;
|
using System.Collections.Generic;
|
using System.Linq.Expressions;
|
using System.Reflection;
|
using DynamicExpresso.Reflection;
|
|
namespace DynamicExpresso
|
{
|
public class Identifier
|
{
|
public Expression Expression { get; private set; }
|
public string Name { get; private set; }
|
|
public Identifier(string name, Expression expression)
|
{
|
if (string.IsNullOrWhiteSpace(name))
|
throw new ArgumentNullException("name");
|
|
if (expression == null)
|
throw new ArgumentNullException("expression");
|
|
Expression = expression;
|
Name = name;
|
}
|
}
|
|
internal class FunctionIdentifier : Identifier
|
{
|
internal FunctionIdentifier(string name, Delegate value) : base(name, new MethodGroupExpression(value))
|
{
|
}
|
|
internal void AddOverload(Delegate overload)
|
{
|
((MethodGroupExpression)Expression).AddOverload(overload);
|
}
|
}
|
|
/// <summary>
|
/// Custom expression that simulates a method group (ie. a group of methods with the same name).
|
/// It's used when custom functions are added to the interpreter via <see cref="Interpreter.SetFunction(string, Delegate)"/>.
|
/// </summary>
|
internal class MethodGroupExpression : Expression
|
{
|
public class Overload
|
{
|
public Delegate Delegate { get; }
|
|
private MethodBase _method;
|
public MethodBase Method
|
{
|
get
|
{
|
if (_method == null)
|
_method = Delegate.Method;
|
|
return _method;
|
}
|
}
|
|
// we'll most likely never need this: it was needed before https://github.com/dotnet/roslyn/pull/53402
|
private MethodBase _invokeMethod;
|
public MethodBase InvokeMethod
|
{
|
get
|
{
|
if (_invokeMethod == null)
|
_invokeMethod = MemberFinder.FindInvokeMethod(Delegate.GetType());
|
|
return _invokeMethod;
|
}
|
}
|
|
public Overload(Delegate @delegate)
|
{
|
Delegate = @delegate;
|
}
|
}
|
|
private readonly List<Overload> _overloads = new List<Overload>();
|
|
internal IReadOnlyCollection<Overload> Overloads
|
{
|
get
|
{
|
return _overloads.AsReadOnly();
|
}
|
}
|
|
internal MethodGroupExpression(Delegate overload)
|
{
|
AddOverload(overload);
|
}
|
|
internal void AddOverload(Delegate overload)
|
{
|
// remove any existing delegate with the exact same signature
|
RemoveDelegateSignature(overload);
|
_overloads.Add(new Overload(overload));
|
}
|
|
private void RemoveDelegateSignature(Delegate overload)
|
{
|
_overloads.RemoveAll(del => HasSameSignature(overload.Method, del.Delegate.Method));
|
}
|
|
private static bool HasSameSignature(MethodInfo method, MethodInfo other)
|
{
|
if (method.ReturnType != other.ReturnType)
|
return false;
|
|
var param = method.GetParameters();
|
var oParam = other.GetParameters();
|
if (param.Length != oParam.Length)
|
return false;
|
|
for (var i = 0; i < param.Length; i++)
|
{
|
var p = param[i];
|
var q = oParam[i];
|
if (p.ParameterType != q.ParameterType || p.HasDefaultValue != q.HasDefaultValue)
|
return false;
|
}
|
|
return true;
|
}
|
|
/// <summary>
|
/// The resolution process will find the best overload for the given arguments,
|
/// which we then need to match to the correct delegate.
|
/// </summary>
|
internal Delegate FindUsedOverload(bool usedInvokeMethod, MethodData methodData)
|
{
|
foreach (var overload in _overloads)
|
{
|
if (usedInvokeMethod)
|
{
|
if (methodData.MethodBase == overload.InvokeMethod)
|
return overload.Delegate;
|
}
|
else
|
{
|
if (methodData.MethodBase == overload.Method)
|
return overload.Delegate;
|
}
|
}
|
|
// this should never happen
|
throw new InvalidOperationException("No overload matches the method");
|
}
|
}
|
}
|
