Allow default values for generic parameters

src/DynamicExpresso.Core/Parsing/Parser.cs

@@ -2004,6 +2004,37 @@ private static MethodData[] FindBestMethod(IEnumerable<MethodData> methods, Expr
 			return applicable;
 		}
 
+		private static Type GetConcreteTypeForGenericMethod(Type type, List<Expression> promotedArgs, MethodData method)
+		{
+			if (type.IsGenericType)
+			{
+				//Generic<T> type
+				var genericArguments = type.GetGenericArguments();
+				var concreteTypeParameters = new Type[genericArguments.Length];
+
+				for (var i = 0; i < genericArguments.Length; i++)
+				{
+					concreteTypeParameters[i] = GetConcreteTypeForGenericMethod(genericArguments[i], promotedArgs,method);
+				}
+
+				return type.GetGenericTypeDefinition().MakeGenericType(concreteTypeParameters);
+			}
+			else if (type.ContainsGenericParameters)
+			{
+				//T case
+				//try finding an actual parameter for the generic
+				for (var i = 0; i < promotedArgs.Count; i++)
+				{
+					if (method.Parameters[i].ParameterType == type)
+					{						
+						return promotedArgs[i].Type;
+					}
+				}
+			}
+
+			return type;//already a concrete type
+		}
+
 		private static bool CheckIfMethodIsApplicableAndPrepareIt(MethodData method, Expression[] args)
 		{
 			if (method.Parameters.Count(y => !y.HasDefaultValue && !HasParamsArrayType(y)) > args.Length)
@@ -2111,7 +2142,12 @@ private static bool CheckIfMethodIsApplicableAndPrepareIt(MethodData method, Exp
 			promotedArgs.AddRange(method.Parameters.Skip(promotedArgs.Count).Select<ParameterInfo, Expression>(x =>
 			{
 				if (x.HasDefaultValue)
-					return Expression.Constant(x.DefaultValue, x.ParameterType);
+				{
+					var parameterType = GetConcreteTypeForGenericMethod(x.ParameterType, promotedArgs, method);
+
+					return Expression.Constant(x.DefaultValue, parameterType);
+				}
+
 
 				if (HasParamsArrayType(x))
 				{

test/DynamicExpresso.UnitTest/MemberInvocationTest.cs

@@ -322,6 +322,14 @@ public void Method_with_generic_param()
 			Assert.AreEqual(x.MethodWithGenericParam(y, y), target.Eval("x.MethodWithGenericParam(y, y)", parameters));
 			Assert.AreEqual(x.MethodWithGenericParam(y, z), target.Eval("x.MethodWithGenericParam(y, z)", parameters));
 			Assert.AreEqual(x.MethodWithGenericParam(y, w), target.Eval("x.MethodWithGenericParam(y, w)", parameters));
+
+			Assert.AreEqual(x.MethodWithGenericParamAndDefault(y,y), target.Eval("x.MethodWithGenericParamAndDefault(y,y)", parameters));
+			Assert.AreEqual(x.MethodWithGenericParamAndDefault(y), target.Eval("x.MethodWithGenericParamAndDefault(y)", parameters));
+			Assert.AreEqual(x.MethodWithGenericParamAndDefault1Levels(y), target.Eval("x.MethodWithGenericParamAndDefault1Levels(y)", parameters));
+			Assert.AreEqual(x.MethodWithGenericParamAndDefault2Levels(y), target.Eval("x.MethodWithGenericParamAndDefault2Levels(y)", parameters));
+			Assert.AreEqual(x.MethodWithGenericParamAndDefault2Levels(y, w), target.Eval("x.MethodWithGenericParamAndDefault2Levels(y, w)", parameters));
+
+
 		}
 
 		[Test]
@@ -559,6 +567,26 @@ public string MethodWithGenericParam<T>(string a, T p)
 				return string.Format("{0} {1}", a, p);
 			}
 
+			public T MethodWithGenericParamAndDefault<T>(T a, T b = default)
+			{
+				return a;
+			}
+
+			public T MethodWithGenericParamAndDefault1Levels<T>(T a, List<T> b = default)
+			{
+				return a;
+			}
+
+			public T MethodWithGenericParamAndDefault2Levels<T>(T a, List<List<T>> b = default)
+			{
+				return a;
+			}
+
+			public T MethodWithGenericParamAndDefault2Levels<T, T2>(T a, T2 b, List<T> c = default, List<List<T2>> d = default)
+			{
+				return a;
+			}
+
 			public string MethodWithOptionalParam(string param1, string param2 = "2", string param3 = "3")
 			{
 				return string.Format("{0} {1} {2}", param1, param2, param3);