Add support of method invocation with dynamic arguments (#347)

Add support of method invocation with dynamic arguments

Fix #295

Author: metoule

src/DynamicExpresso.Core/Identifier.cs

@@ -37,6 +37,7 @@ internal void AddOverload(Delegate 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
 	{

src/DynamicExpresso.Core/Parsing/Parser.cs

@@ -1377,7 +1377,17 @@ private Expression ParseMethodGroupInvocation(MethodGroupExpression methodGroup,
 				applicableMethods = MethodResolution.FindBestMethod(candidates.Select(_ => _.InvokeMethod), args);
 
 			if (applicableMethods.Length == 0)
+			{
+				if (args.Any(IsDynamicExpression))
+				{
+					// TODO: we could try to find the best method by using the dynamic binder
+					var candidatesWithSameArgumentCount = candidates.Where(_ => _.Method.GetParameters().Length == args.Length).ToList();
+					if (candidatesWithSameArgumentCount.Count == 1)
+						return ParseDynamicMethodGroupInvocation(candidatesWithSameArgumentCount[0].Delegate, args);
+				}
+
 				throw ParseException.Create(errorPos, ErrorMessages.ArgsIncompatibleWithDelegate);
+			}
 
 			if (applicableMethods.Length > 1)
 				throw ParseException.Create(errorPos, ErrorMessages.AmbiguousDelegateInvocation);
@@ -1691,21 +1701,21 @@ private Expression ParseMethodInvocation(Type type, Expression instance, int err
 			if (methodInvocationExpression != null)
 				return methodInvocationExpression;
 
-			if (TypeUtils.IsDynamicType(type) || IsDynamicExpression(instance))
+			if (TypeUtils.IsDynamicType(type) || IsDynamicExpression(instance) || args.Any(IsDynamicExpression))
 				return ParseDynamicMethodInvocation(type, instance, methodName, args);
 
 			throw new NoApplicableMethodException(methodName, TypeUtils.GetTypeName(type), errorPos);
 		}
 
-		private Expression ParseExtensionMethodInvocation(Type type, Expression instance, int errorPos, string id, Expression[] args)
+		private Expression ParseExtensionMethodInvocation(Type type, Expression instance, int errorPos, string methodName, Expression[] args)
 		{
 			var extensionMethodsArguments = new Expression[args.Length + 1];
 			extensionMethodsArguments[0] = instance;
 			args.CopyTo(extensionMethodsArguments, 1);
 
-			var extensionMethods = _memberFinder.FindExtensionMethods(id, extensionMethodsArguments);
+			var extensionMethods = _memberFinder.FindExtensionMethods(methodName, extensionMethodsArguments);
 			if (extensionMethods.Length > 1)
-				throw ParseException.Create(errorPos, ErrorMessages.AmbiguousMethodInvocation, id, TypeUtils.GetTypeName(type));
+				throw ParseException.Create(errorPos, ErrorMessages.AmbiguousMethodInvocation, methodName, TypeUtils.GetTypeName(type));
 
 			if (extensionMethods.Length == 1)
 			{
@@ -1719,11 +1729,11 @@ private Expression ParseExtensionMethodInvocation(Type type, Expression instance
 			return null;
 		}
 
-		private Expression ParseNormalMethodInvocation(Type type, Expression instance, int errorPos, string id, Expression[] args)
+		private Expression ParseNormalMethodInvocation(Type type, Expression instance, int errorPos, string methodName, Expression[] args)
 		{
-			var applicableMethods = _memberFinder.FindMethods(type, id, instance == null, args);
+			var applicableMethods = _memberFinder.FindMethods(type, methodName, instance == null, args);
 			if (applicableMethods.Length > 1)
-				throw ParseException.Create(errorPos, ErrorMessages.AmbiguousMethodInvocation, id, TypeUtils.GetTypeName(type));
+				throw ParseException.Create(errorPos, ErrorMessages.AmbiguousMethodInvocation, methodName, TypeUtils.GetTypeName(type));
 
 			if (applicableMethods.Length == 1)
 			{
@@ -1791,8 +1801,16 @@ private static Expression ParseDynamicProperty(Type type, Expression instance, s
 		private static Expression ParseDynamicMethodInvocation(Type type, Expression instance, string methodName, Expression[] args)
 		{
 			var argsDynamic = args.ToList();
-			argsDynamic.Insert(0, instance);
-			return Expression.Dynamic(new LateInvokeMethodCallSiteBinder(methodName), typeof(object), argsDynamic);
+			var isStatic = instance == null;
+			argsDynamic.Insert(0, !isStatic ? instance : Expression.Constant(type));
+			return Expression.Dynamic(new LateInvokeMethodCallSiteBinder(methodName, isStatic), typeof(object), argsDynamic);
+		}
+
+		private Expression ParseDynamicMethodGroupInvocation(Delegate @delegate, Expression[] args)
+		{
+			var argsDynamic = args.ToList();
+			argsDynamic.Insert(0, Expression.Constant(@delegate));
+			return Expression.Dynamic(new LateInvokeDelegateCallSiteBinder(), typeof(object), argsDynamic);
 		}
 
 		private static Expression ParseDynamicIndex(Type type, Expression instance, Expression[] args)

src/DynamicExpresso.Core/Resolution/LateBinders.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Collections.ObjectModel;
 using System.Linq;
 using System.Linq.Expressions;
@@ -34,20 +35,59 @@ public override Expression Bind(object[] args, ReadOnlyCollection<ParameterExpre
 	internal class LateInvokeMethodCallSiteBinder : CallSiteBinder
 	{
 		private readonly string _methodName;
+		private readonly bool _isStatic;
 
-		public LateInvokeMethodCallSiteBinder(string methodName)
+		public LateInvokeMethodCallSiteBinder(string methodName, bool isStatic)
 		{
 			_methodName = methodName;
+			_isStatic = isStatic;
 		}
 
 		public override Expression Bind(object[] args, ReadOnlyCollection<ParameterExpression> parameters, LabelTarget returnLabel)
 		{
+			// if the method is static, the first argument is the type containing the method,
+			// otherwise it's the instance on which the method is called
+			var context = _isStatic ? (Type)args[0] : args[0]?.GetType();
+			var argumentInfo = parameters.Select(x => CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null)).ToArray();
+			if (_isStatic)
+			{
+				// instruct the compiler that we already know the containing type of the method
+				argumentInfo[0] = CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.UseCompileTimeType | CSharpArgumentInfoFlags.IsStaticType, null);
+			}
+
 			var binderM = Binder.InvokeMember(
 				CSharpBinderFlags.None,
 				_methodName,
 				null,
-				TypeUtils.RemoveArrayType(args[0]?.GetType()),
-				parameters.Select(x => CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null))
+				TypeUtils.RemoveArrayType(context),
+				argumentInfo
+			);
+			return binderM.Bind(args, parameters, returnLabel);
+		}
+	}
+
+	/// <summary>
+	/// Binds to a delegate invocation as late as possible.  This allows the use of delegates with dynamic arguments.
+	/// </summary>
+	internal class LateInvokeDelegateCallSiteBinder : CallSiteBinder
+	{
+		public LateInvokeDelegateCallSiteBinder()
+		{
+		}
+
+		public override Expression Bind(object[] args, ReadOnlyCollection<ParameterExpression> parameters, LabelTarget returnLabel)
+		{
+			// the first argument is the delegate to invoke
+			var _delegate = (Delegate)args[0];
+			var argumentInfo = parameters.Select(x => CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null)).ToArray();
+
+			// instruct the compiler that we already know the delegate's type
+			argumentInfo[0] = CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.UseCompileTimeType, null);
+
+			var binderM = Binder.Invoke(
+				CSharpBinderFlags.None,
+				null,
+				argumentInfo
 			);
 			return binderM.Bind(args, parameters, returnLabel);
 		}

test/DynamicExpresso.UnitTest/DynamicTest.cs

@@ -435,9 +435,44 @@ public void Unary_with_dynamic_properties()
 
 			Assert.That(interpreter.Eval("!dyn.Foo"), Is.EqualTo(!dyn.Foo));
 			Assert.That(interpreter.Eval("-dyn.Bar"), Is.EqualTo(-dyn.Bar));
+		}
+
+		[Test]
+		public void Static_method_call_with_dynamic_arg()
+		{
+			dynamic dyn = new ExpandoObject();
+			dyn.Foo = "test";
+
+			var myClass = new MyClass();
+
+			var interpreter = new Interpreter()
+				.SetVariable("dyn", (object)dyn);
+
+			Assert.That(interpreter.Eval("string.IsNullOrEmpty(dyn.Foo)"), Is.EqualTo(string.IsNullOrEmpty(dyn.Foo)));
+		}
 
 
+		[Test]
+		public void Method_call_with_dynamic_arg()
+		{
+			dynamic dyn = new ExpandoObject();
+			dyn.Foo = "test";
+
+			var myClass = new MyClass();
+
+			var interpreter = new Interpreter()
+				.SetVariable("dyn", (object)dyn)
+				.SetVariable("myClass", myClass);
 
+			Assert.That(interpreter.Eval("myClass.MyMethod(dyn.Foo)"), Is.EqualTo(myClass.MyMethod(dyn.Foo)));
+		}
+
+		public class MyClass
+		{
+			public string MyMethod(string input)
+			{
+				return input;
+			}
 		}
 
 		public class TestDynamicClass : DynamicObject

test/DynamicExpresso.UnitTest/GithubIssues.cs

@@ -775,7 +775,6 @@ public void GitHub_Issue_292()
 		}
 
 		[Test]
-		[Ignore("The fix suggested in #296 break other use cases, so let's ignore this test for now")]
 		public void GitHub_Issue_295()
 		{
 			var evaluator = new Interpreter();
@@ -789,11 +788,11 @@ public void GitHub_Issue_295()
 			globalSettings.MyTestPath = "C:\\delme\\";
 			evaluator.SetVariable("GlobalSettings", globalSettings);
 
-			var works = (string)evaluator.Eval("StringConcat((string)GlobalSettings.MyTestPath,\"test.txt\")");
-			Assert.That(works, Is.EqualTo("C:\\delme\\test.txt"));
+			var worksWithCast = (string)evaluator.Eval("StringConcat((string)GlobalSettings.MyTestPath,\"test.txt\")");
+			Assert.That(worksWithCast, Is.EqualTo("C:\\delme\\test.txt"));
 
-			var doesntWork = (string)evaluator.Eval("StringConcat(GlobalSettings.MyTestPath,\"test.txt\")");
-			Assert.That(doesntWork, Is.EqualTo("C:\\delme\\test.txt"));
+			var worksWithoutCast = (string)evaluator.Eval("StringConcat(GlobalSettings.MyTestPath,\"test.txt\")");
+			Assert.That(worksWithoutCast, Is.EqualTo("C:\\delme\\test.txt"));
 		}
 
 		#region GitHub_Issue_305