No longer store MethodData in MethodGroupExpression. (#366)

Fix #361

Author: metoule

src/DynamicExpresso.Core/Identifier.cs

@@ -46,21 +46,21 @@ public class Overload
 		{
 			public Delegate Delegate { get; }
 
-			private MethodData _methodData;
-			public MethodData Method
+			private MethodBase _method;
+			public MethodBase Method
 			{
 				get
 				{
-					if (_methodData == null)
-						_methodData = MethodData.Gen(Delegate.Method);
+					if (_method == null)
+						_method = Delegate.Method;
 
-					return _methodData;
+					return _method;
 				}
 			}
 
 			// we'll most likely never need this: it was needed before https://github.com/dotnet/roslyn/pull/53402
-			private MethodData _invokeMethod;
-			public MethodData InvokeMethod
+			private MethodBase _invokeMethod;
+			public MethodBase InvokeMethod
 			{
 				get
 				{
@@ -135,12 +135,12 @@ internal Delegate FindUsedOverload(bool usedInvokeMethod, MethodData methodData)
 			{
 				if (usedInvokeMethod)
 				{
-					if (overload.InvokeMethod.MethodBase == methodData.MethodBase)
+					if (methodData.MethodBase == overload.InvokeMethod)
 						return overload.Delegate;
 				}
 				else
 				{
-					if (overload.Method.MethodBase == methodData.MethodBase)
+					if (methodData.MethodBase == overload.Method)
 						return overload.Delegate;
 				}
 			}

src/DynamicExpresso.Core/Parsing/Parser.cs

@@ -1349,10 +1349,14 @@ private Expression ParseInvocation(Expression expr, int errorPos, string error)
 			var args = ParseArgumentList();
 
 			var invokeMethod = MemberFinder.FindInvokeMethod(expr.Type);
-			if (invokeMethod == null || !MethodResolution.CheckIfMethodIsApplicableAndPrepareIt(invokeMethod, args))
-				throw ParseException.Create(errorPos, error);
+			if (invokeMethod != null)
+			{
+				var invokeMethodData = MethodData.Gen(invokeMethod);
+				if (MethodResolution.CheckIfMethodIsApplicableAndPrepareIt(invokeMethodData, args))
+					return Expression.Invoke(expr, invokeMethodData.PromotedParameters);
+			}
 
-			return Expression.Invoke(expr, invokeMethod.PromotedParameters);
+			throw ParseException.Create(errorPos, error);
 		}
 
 		private Expression ParseMethodGroupInvocation(MethodGroupExpression methodGroup, int errorPos)
@@ -1378,7 +1382,7 @@ private Expression ParseMethodGroupInvocation(MethodGroupExpression methodGroup,
 				if (args.Any(IsDynamicExpression))
 				{
 					// TODO: we could try to find the best method by using the dynamic binder
-					var candidatesWithSameArgumentCount = candidates.Where(_ => _.Method.Parameters.Count == args.Length).ToList();
+					var candidatesWithSameArgumentCount = candidates.Where(_ => _.Method.GetParameters().Length == args.Length).ToList();
 					if (candidatesWithSameArgumentCount.Count == 1)
 						return ParseDynamicMethodGroupInvocation(candidatesWithSameArgumentCount[0].Delegate, args);
 				}

src/DynamicExpresso.Core/Reflection/MemberFinder.cs

@@ -52,7 +52,7 @@ public IList<MethodData> FindMethods(Type type, string methodName, bool staticAc
 
 		// this method is static, because we know that the Invoke method of a delegate always has this exact name
 		// and therefore we never need to search for it in case-insensitive mode
-		public static MethodData FindInvokeMethod(Type type)
+		public static MethodBase FindInvokeMethod(Type type)
 		{
 			var flags = BindingFlags.Public | BindingFlags.DeclaredOnly |
 						BindingFlags.Instance;
@@ -63,7 +63,7 @@ public static MethodData FindInvokeMethod(Type type)
 					.SingleOrDefault();
 
 				if (method != null)
-					return MethodData.Gen(method);
+					return method;
 			}
 
 			return null;

test/DynamicExpresso.UnitTest/ThreadingTest.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
@@ -92,5 +93,20 @@ public void Should_Fail_Parallel_Eval()
 				Assert.That(target.Eval(exp, parameters), Is.True);
 			});
 		}
+
+		[Test]
+		public void Should_Pass_Parallel_Invoke_MethodGroup()
+		{
+			var interpreter = new Interpreter();
+
+			Func<IEnumerable<int>, int> minFunc = Enumerable.Min;
+			interpreter.SetFunction("min", minFunc);
+
+			Parallel.ForEach(Enumerable.Range(1, 25), i =>
+			{
+				var arguments = new[] { i, i + 1, i + 2 };
+				Assert.That(interpreter.Eval("min(x)", new Parameter("x", arguments)), Is.EqualTo(i));
+			});
+		}
 	}
 }