Allow a params parameter to have a generic type (#192)

* Allow a params parameter to have a generic type.

* Throw a ParseException when a method's type parameters can't be inferred.

src/DynamicExpresso.Core/Parsing/Parser.cs

@@ -1943,7 +1943,15 @@ private static bool CheckIfMethodIsApplicableAndPrepareIt(MethodData method, Exp
 
 				if (paramsArrayTypeFound != null)
 				{
-					var promoted = PromoteExpression(currentArgument, paramsArrayTypeFound.GetElementType(), true);
+					var paramsArrayElementType = paramsArrayTypeFound.GetElementType();
+					if (paramsArrayElementType.IsGenericParameter)
+					{
+						paramsArrayPromotedArgument = paramsArrayPromotedArgument ?? new List<Expression>();
+						paramsArrayPromotedArgument.Add(currentArgument);
+						continue;
+					}
+
+					var promoted = PromoteExpression(currentArgument, paramsArrayElementType, true);
 					if (promoted != null)
 					{
 						paramsArrayPromotedArgument = paramsArrayPromotedArgument ?? new List<Expression>();
@@ -1960,7 +1968,17 @@ private static bool CheckIfMethodIsApplicableAndPrepareIt(MethodData method, Exp
 				method.HasParamsArray = true;
 				var paramsArrayElementType = paramsArrayTypeFound.GetElementType();
 				if (paramsArrayElementType == null)
-					throw new Exception("Type is not an array, element not found");
+					throw CreateParseException(-1, ErrorMessages.ParamsArrayTypeNotAnArray);
+
+				if (paramsArrayElementType.IsGenericParameter)
+				{
+					var actualTypes = paramsArrayPromotedArgument.Select(_ => _.Type).Distinct().ToArray();
+					if (actualTypes.Length != 1)
+						throw CreateParseException(-1, ErrorMessages.MethodTypeParametersCantBeInferred, method.MethodBase);
+
+					paramsArrayElementType = actualTypes[0];
+				}
+
 				promotedArgs.Add(Expression.NewArrayInit(paramsArrayElementType, paramsArrayPromotedArgument));
 			}
 
@@ -2030,6 +2048,16 @@ private static Dictionary<string, Type> ExtractActualGenericArguments(
 					if (!actualType.IsGenericParameter)
 						extractedGenericTypes[requestedType.Name] = actualType;
 				}
+				else if (requestedType.IsArray && actualType.IsArray)
+				{
+					var innerGenericTypes = ExtractActualGenericArguments(
+						new[] { requestedType.GetElementType() },
+						new[] { actualType.GetElementType()
+					});
+
+					foreach (var innerGenericType in innerGenericTypes)
+						extractedGenericTypes[innerGenericType.Key] = innerGenericType.Value;
+				}
 				else if (requestedType.ContainsGenericParameters)
 				{
 					if (actualType.IsGenericParameter)

src/DynamicExpresso.Core/Resources/ErrorMessages.resx

@@ -255,4 +255,10 @@
   <data name="CloseTypeArgumentListExpected" xml:space="preserve">
     <value>'&gt;' expected</value>
   </data>
+  <data name="MethodTypeParametersCantBeInferred" xml:space="preserve">
+    <value>The type arguments for method '{0}' cannot be inferred from the usage.</value>
+  </data>
+  <data name="ParamsArrayTypeNotAnArray" xml:space="preserve">
+    <value>Params array type is not an array, element not found</value>
+  </data>
 </root>

test/DynamicExpresso.UnitTest/MemberInvocationTest.cs

@@ -1,6 +1,7 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
+using DynamicExpresso.Exceptions;
 using NUnit.Framework;
 
 namespace DynamicExpresso.UnitTest
@@ -370,7 +371,21 @@ public void Overload_paramsArray_methods_with_compatible_type_params()
 			target.SetVariable("x", x);
 			Assert.AreEqual(3, target.Eval("x.OverloadMethodWithParamsArray(2, 3, 1)"));
 		}
-
+
+
+		[Test]
+		public void Generic_method_with_params()
+		{
+			var target = new Interpreter();
+			target.Reference(typeof(Utils));
+
+			var listInt = target.Eval<List<int>>("Utils.Array(1, 2, 3)");
+			Assert.AreEqual(new[] { 1, 2, 3 }, listInt);
+
+			// type parameter can't be inferred from usage
+			Assert.Throws<ParseException>(() => target.Eval<List<int>>("Utils.Array(1,\"str\", 3)"));
+		}
+
 		[Test]
 		public void Method_with_optional_param()
 		{
@@ -555,5 +570,13 @@ public string AMethod()
 				return "Ciao mondo";
 			}
 		}
+
+		private static class Utils
+		{
+			public static List<T> Array<T>(params T[] array)
+			{
+				return new List<T>(array);
+			}
+		}
 	}
 }