add support for interface extension methods

Author: umutozel

src/Jokenizer.Net/ExtensionMethods.cs

@@ -31,24 +31,40 @@ public static IList<MethodInfo> ScanType(Type type) {
         return methods;
     }
 
-    internal static MethodInfo? Find(Type forType, string name, Expression?[] args) {
+    internal static (MethodInfo, ParameterInfo[])? Find(Type forType, string name, Expression?[] args) {
         var genericArgs = forType.IsConstructedGenericType ? forType.GetGenericArguments() : [];
 
         foreach (var extension in _extensions.Where(e => e.Name == name)) {
             var m = extension;
+
+            var prmType = m.GetParameters()[0].ParameterType;
+            if (prmType.IsConstructedGenericType) {
+                prmType = prmType.GetGenericTypeDefinition();
+            }
+            if (!prmType.IsAssignableFrom(forType)) {
+                if (!prmType.IsGenericType) continue;
+
+                if (!forType.IsConstructedGenericType || forType.GetGenericTypeDefinition() != prmType) {
+                    var interfaces = forType.GetInterfaces();
+                    var forGeneric = interfaces
+                        .FirstOrDefault(i => i == prmType || (i.IsGenericType && i.GetGenericTypeDefinition() == prmType));
+
+                    if (forGeneric == null) continue;
+
+                    genericArgs = forGeneric.GetGenericArguments();
+                }
+            }
+
             if (m.IsGenericMethodDefinition) {
                 if (m.GetGenericArguments().Length != genericArgs.Length) continue;
 
                 m = m.MakeGenericMethod(genericArgs);
             }
 
-            var allPrms = m.GetParameters();
-            if (!allPrms[0].ParameterType.IsAssignableFrom(forType)) continue;
-
-            var prms = allPrms.Skip(1).ToArray();
+            var prms = m.GetParameters().Skip(1).ToArray();
             if (!Helper.IsSuitable(prms, args)) continue;
 
-            return m;
+            return (m, prms);
         }
 
         return null;

src/Jokenizer.Net/TokenVisitor.cs

@@ -218,15 +218,19 @@ protected MethodCallExpression GetMethodCall(Expression owner, string methodName
                 .FirstOrDefault(m => m.Name == methodName && Helper.IsSuitable(m.GetParameters(), methodArgs));
         }
 
+        ParameterInfo[] methodPrms;
         if (method == null) {
             isExtension = true;
-            method = ExtensionMethods.Find(owner.Type, methodName, methodArgs);
-        }
+            var extResult = ExtensionMethods.Find(owner.Type, methodName, methodArgs);
+            if (extResult == null)
+                throw new InvalidTokenException($"Could not find instance or extension method for {methodName} for {owner.Type}");
 
-        if (method == null)
-            throw new InvalidTokenException($"Could not find instance or extension method for {methodName} for {owner.Type}");
+            (method, methodPrms) = extResult.Value;
+        }
+        else {
+            methodPrms = method.GetParameters();
+        }
 
-        var methodPrms = method.GetParameters();
         // we might need to cast to target types
         for (var i = 0; i < methodArgs.Length; i++) {
             var prm = methodPrms[i];

test/Jokenizer.Net.Tests/EvaluatorTests.cs

@@ -264,8 +264,7 @@ public void ShouldThrowForUnknownToken() {
     [Fact]
     public void ShouldThrowForInvalidToken() {
         Assert.Throws<InvalidTokenException>(() => Evaluator.ToLambda<string>(new AssignToken("Name", new LiteralToken("Netflix"))));
-        Assert.Throws<InvalidTokenException>(() => Evaluator.ToLambda<string>(new GroupToken([new LiteralToken("Netflix"), new LiteralToken("Google")
-        ])));
+        Assert.Throws<InvalidTokenException>(() => Evaluator.ToLambda<string>(new GroupToken([new LiteralToken("Netflix"), new LiteralToken("Google")])));
         Assert.Throws<InvalidTokenException>(() => Evaluator.ToLambda<string>("a < b => b*2"));
     }
 
@@ -362,4 +361,19 @@ public void SettingTests() {
         Assert.True(settings.ContainsUnary('!'));
         Assert.True(settings.ContainsBinary("%"));
     }
+
+    [Fact]
+    public void ShouldHandleEnumerableParameter() {
+        var source = new[] { 1, 2, 3, 4, 5 };
+        var sample = new[] { 2, 4 };
+
+        var f = Evaluator.ToFunc<IEnumerable<int>>(
+            "source.Where(x => @0.Contains(x))",
+            new Dictionary<string, object?> { { "source", source } },
+            sample
+        );
+
+        var result = f();
+        Assert.Equal([2, 4], result);
+    }
 }