Allow a params parameter to have a generic type

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);
+ }
+ }
  }
 }