Improve invocation support (#188)

Author: TheConstructor

src/LinqKit.Core/ExpressionExpander.cs

@@ -34,14 +34,7 @@ protected LambdaExpression EvaluateTarget(Expression target)
                 }
             }
 
-            var lambda = target.EvaluateExpression() as LambdaExpression;
-
-            if (lambda == null)
-            {
-                throw new InvalidOperationException($"Invoke cannot evaluate LambdaExpression from '{target}'. Ensure that your function/property/member returns LambdaExpression");
-            }
-
-            return lambda;
+            return target.EvaluateExpression() as LambdaExpression;
         }
 
         /// <summary>
@@ -53,6 +46,10 @@ protected override Expression VisitInvocation(InvocationExpression iv)
             var target = iv.Expression;
 
             var lambda = EvaluateTarget(target);
+            if (lambda == null)
+            {
+                return base.VisitInvocation(iv);
+            }
 
             var body = ExpressionReplacer.GetBody(lambda, iv.Arguments);
 
@@ -118,6 +115,11 @@ protected override Expression VisitMethodCall(MethodCallExpression m)
                 var target = m.Arguments[0];
                 var lambda = EvaluateTarget(target);
 
+                if (lambda == null)
+                {
+                    throw new InvalidOperationException($"Invoke cannot evaluate LambdaExpression from '{target}'. Ensure that your function/property/member returns LambdaExpression");
+                }
+
                 var replaceVars = new Dictionary<Expression, Expression>();
                 for (int i = 0; i < lambda.Parameters.Count; i++)
                 {
@@ -129,6 +131,25 @@ protected override Expression VisitMethodCall(MethodCallExpression m)
                 return Visit(body);
             }
 
+            if (m.Method.Name == nameof(Action.Invoke)
+                && m.Method.DeclaringType.GetTypeInfo().IsSubclassOf(typeof(Delegate)))
+            {
+                var lambda = EvaluateTarget(m.Object);
+
+                if (lambda != null)
+                {
+                    var replaceVars = new Dictionary<Expression, Expression>();
+                    for (int i = 0; i < lambda.Parameters.Count; i++)
+                    {
+                        replaceVars.Add(lambda.Parameters[i], Visit(m.Arguments[i]));
+                    }
+
+                    var body = ExpressionReplacer.Replace(lambda.Body, replaceVars);
+
+                    return Visit(body);
+                }
+            }
+
             if (GetExpandLambda(m.Method, out var methodLambda))
             {
                 var replaceVars = new Dictionary<Expression, Expression>();

tests/LinqKit.Tests.Net452/ExpandableAttributeTests.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations.Schema;
 using System.Linq;
 using System.Linq.Expressions;
 using Xunit;
@@ -247,4 +248,37 @@ public void ExpandableAttribute_FilteredDetailsNoImpl()
         }
 
     }
+
+    public class MyEntity
+    {
+        public Guid ID { get; set; }
+        public string Code { get; set; }
+        public string Description { get; set; }
+        [NotMapped]
+        [Expandable(nameof(CodeAndDescriptionExpr))]
+        public string CodeAndDescription => Code + " / " + Description;
+        internal static Expression<Func<MyEntity, string>> CodeAndDescriptionExpr() => e => e.Code + " / " + e.Description;
+    }
+    
+    public class ExpressionBuilderTest {
+
+        [Fact]
+        public void ExpressionIsAppliedToMappedProperties()
+        {
+            var predicate = PredicateBuilder.New<MyEntity>(true);
+            var keywords = "?";
+
+            predicate = predicate.And(x => x.CodeAndDescription.ToLower().Replace("İ", "i").Replace("ı", "i").Contains(keywords));
+            predicate = predicate.Or(x => MyEntity.CodeAndDescriptionExpr().Invoke(x).ToLower().Contains(keywords));
+
+            Assert.Equal(
+                $"x => (x.CodeAndDescription.ToLower().Replace(\"İ\", \"i\").Replace(\"ı\", \"i\").Contains(value(LinqKit.Tests.Net452.ExpressionBuilderTest+<>c__DisplayClass0_0).keywords) OrElse CodeAndDescriptionExpr().Invoke(x).ToLower().Contains(value(LinqKit.Tests.Net452.ExpressionBuilderTest+<>c__DisplayClass0_0).keywords))",
+                predicate.ToString());
+
+            var expanded = predicate.Expand();
+            Assert.Equal(
+                $"x => (((x.Code + \" / \") + x.Description).ToLower().Replace(\"İ\", \"i\").Replace(\"ı\", \"i\").Contains(value({typeof(ExpressionBuilderTest).FullName}+<>c__DisplayClass0_0).keywords) OrElse ((x.Code + \" / \") + x.Description).ToLower().Contains(value({typeof(ExpressionBuilderTest).FullName}+<>c__DisplayClass0_0).keywords))",
+                expanded.ToString());
+        }
+    }
 }

tests/LinqKit.Tests.Net452/ExpressionExpanderTests.cs

@@ -64,6 +64,68 @@ public void ExpressionExpander_Expression_Block()
             Assert.Equal(lambda.Invoke(42), expandedLambda.Invoke(42));
         }
 
+        [Fact]
+        public void ExpressionExpander_Expression_InvokeExpressionRemoved()
+        {
+            Expression<Func<object, object>> lambda = o => o;
+
+            var expandedLambda = Linq.Expr((object o) => lambda.Invoke(o))
+                .Expand();
+            Assert.Equal(ExpressionType.Parameter, expandedLambda.Body.NodeType);
+            Assert.Equal(lambda.ToString(), expandedLambda.ToString());
+            Assert.Equal(lambda.Invoke(42), expandedLambda.Invoke(42));
+        }
+
+        [Fact]
+        public void ExpressionExpander_Expression_CompileAndInvokeExpressionRemoved()
+        {
+            Expression<Func<object, object>> lambda = o => o;
+
+            var expandedLambda = Linq.Expr((object o) => lambda.Compile()(o))
+                .Expand();
+            Assert.Equal(ExpressionType.Parameter, expandedLambda.Body.NodeType);
+            Assert.Equal(lambda.ToString(), expandedLambda.ToString());
+            Assert.Equal(lambda.Invoke(42), expandedLambda.Invoke(42));
+        }
+
+        [Fact]
+        public void ExpressionExpander_Expression_CompileAndInvokeOnExpressionRemoved()
+        {
+            Expression<Func<object, object>> lambda = o => o;
+
+            var expandedLambda = Linq.Expr((object o) => lambda.Compile().Invoke(o))
+                .Expand();
+            Assert.Equal(ExpressionType.Parameter, expandedLambda.Body.NodeType);
+            Assert.Equal(lambda.ToString(), expandedLambda.ToString());
+            Assert.Equal(lambda.Invoke(42), expandedLambda.Invoke(42));
+        }
+
+        [Fact]
+        public void ExpressionExpander_Expression_InvokeDelegate()
+        {
+            Func<object, string> func = o => o.ToString();
+
+            Expression<Func<object, string>> lambda = o => func(o);
+
+            var expandedLambda = Linq.Expr((object o) => lambda.Invoke(o))
+                .Expand();
+            Assert.Equal(lambda.ToString(), expandedLambda.ToString());
+            Assert.Equal(lambda.Invoke(42), expandedLambda.Invoke(42));
+        }
+
+        [Fact]
+        public void ExpressionExpander_Expression_InvokeOnDelegate()
+        {
+            Func<object, string> func = o => o.ToString();
+
+            Expression<Func<object, string>> lambda = o => func.Invoke(o);
+
+            var expandedLambda = Linq.Expr((object o) => lambda.Invoke(o))
+                .Expand();
+            Assert.Equal(lambda.ToString(), expandedLambda.ToString());
+            Assert.Equal(lambda.Invoke(42), expandedLambda.Invoke(42));
+        }
+
         [Fact]
         public void ExpressionExpander_Expression_Throw()
         {