optimize EmitMethodCall to call the ILGenerator.EmitCall where available

Author: maximv

src/FastExpressionCompiler/FastExpressionCompiler.cs

@@ -37,6 +37,9 @@ THE SOFTWARE.
 #if LIGHT_EXPRESSION || !NET45
 #define SUPPORTS_ARGUMENT_PROVIDER
 #endif
+#if !NETSTANDARD2_0
+#define SUPPORTS_EMITCALL
+#endif
 #if LIGHT_EXPRESSION
 using static FastExpressionCompiler.LightExpression.Expression;
 using PE = FastExpressionCompiler.LightExpression.ParameterExpression;
@@ -2077,11 +2080,11 @@ private static bool TryEmitIndex(IndexExpression indexExpr, IReadOnlyList<PE>  p
                 if (indexerPropGetter != null)
                     return EmitMethodCall(il, indexerPropGetter);
 
-                if (indexArgCount == 1) // one dimensional array
+                if (indexArgCount == 1) // one-dimensional array
                     return TryEmitArrayIndex(indexExpr.Type, il, parent, ref closure);
 
-                // multi dimensional array
-                return EmitMethodCall(il, indexExpr.Object?.Type.FindMethod("Get"));
+                indexerPropGetter = indexExpr.Object?.Type.FindMethod("Get"); // multi-dimensional array
+                return indexerPropGetter != null && EmitMethodCall(il, indexerPropGetter);
             }
 
 #if LIGHT_EXPRESSION
@@ -3313,11 +3316,7 @@ private static bool EmitMemberAssign(ILGenerator il, MemberInfo member)
                 if (member is PropertyInfo prop)
                 {
                     var method = prop.DeclaringType.FindPropertySetMethod(prop.Name);
-                    if (method == null)
-                        return false;
-
-                    il.Emit(method.IsVirtual ? OpCodes.Callvirt : OpCodes.Call, method);
-                    return true;
+                    return method != null && EmitMethodCall(il, method);
                 }
                 if (member is FieldInfo field)
                 {
@@ -3400,7 +3399,7 @@ private static bool TryEmitListInit(ListInitExpression expr, IReadOnlyList<PE> p
                             return false;
 
                         if (!exprType.IsValueType)
-                            il.Emit(method.IsVirtual ? OpCodes.Callvirt : OpCodes.Call, method);
+                            EmitMethodCall(il, method);
                         else if (!method.IsVirtual) // #251 - no need for constrain or virtual call because it is already by-ref
                             il.Emit(OpCodes.Call, method);
                         else if (method.DeclaringType == exprType)
@@ -3837,8 +3836,8 @@ private static bool TryEmitIndexAssign(IndexExpression indexExpr, Type instType,
                     return true;
                 }
 
-                // multi dimensional array
-                return EmitMethodCall(il, instType?.FindMethod("Set"));
+                var setter = instType?.FindMethod("Set");
+                return setter != null && EmitMethodCall(il, setter); // multi dimensional array
             }
 
 #if LIGHT_EXPRESSION
@@ -3883,7 +3882,7 @@ private static bool TryEmitMethodCall(Expression expr, IReadOnlyList<PE>  paramE
                 }
 
                 if (!objIsValueType) 
-                    il.Emit(method.IsVirtual ? OpCodes.Callvirt : OpCodes.Call, method);
+                    EmitMethodCall(il, method);
                 else if (!method.IsVirtual || objExpr is ParameterExpression p && p.IsByRef)
                     il.Emit(OpCodes.Call, method);
                 else if (method.DeclaringType == objExpr.Type)
@@ -4496,7 +4495,7 @@ private static bool TryEmitArithmetic(BinaryExpression expr, ExpressionType expr
                 if (!TryEmitArithmeticOperation(expr, exprNodeType, exprType, il))
                     return false;
 
-                if (leftIsNullable || rightIsNullable)
+                if (leftIsNullable || rightIsNullable) // todo: @clarify that the code emitted is correct
                 {
                     var valueLabel = il.DefineLabel();
                     il.Emit(OpCodes.Br, valueLabel);
@@ -4581,10 +4580,7 @@ var methodName
                             }
                         }
 
-                        if (method == null)
-                            return false;
-                        il.Emit(method.IsVirtual ? OpCodes.Callvirt : OpCodes.Call, method);
-                        return true;
+                        return method != null && EmitMethodCall(il, method);
                     }
                 }
 
@@ -4855,15 +4851,14 @@ private static Expression TryReduceCondition(Expression testExpr)
                 return testExpr;
             }
 
-            private static bool EmitMethodCall(ILGenerator il, MethodInfo method, ParentFlags parent = ParentFlags.Empty)
+            [MethodImpl((MethodImplOptions)256)]
+            private static bool EmitMethodCall(ILGenerator il, MethodInfo method)
             {
-                if (method == null)
-                    return false;
-
+#if SUPPORTS_EMITCALL
+                il.EmitCall(method.IsVirtual ? OpCodes.Callvirt : OpCodes.Call, method, null);
+#else
                 il.Emit(method.IsVirtual ? OpCodes.Callvirt : OpCodes.Call, method);
-
-                if ((parent & ParentFlags.IgnoreResult) != 0 && method.ReturnType != typeof(void))
-                    il.Emit(OpCodes.Pop);
+#endif
                 return true;
             }
 

test/FastExpressionCompiler.IssueTests/Issue274_Failing_Expressions_in_Linq2DB.cs

@@ -21,6 +21,8 @@ public class Issue274_Failing_Expressions_in_Linq2DB : ITest
     {
         public int Run()
         {
+            Test_287_Case2_SimpleDelegate_as_nested_lambda_in_TesCollection_test();
+
             Test_287_Case1_ConvertTests_NullableParameterInOperatorConvert_VerificationException();
 
             Test_283_Case6_MappingSchemaTests_CultureInfo_VerificationException();
@@ -41,7 +43,7 @@ public int Run()
             Test_case_1_Full_AccessViolationException();
             The_expression_with_anonymous_class_should_output_without_special_symbols();
 
-            return 16;
+            return 17;
         }
 
         [Test]
@@ -545,8 +547,7 @@ public void Test_287_Case2_SimpleDelegate_as_nested_lambda_in_TesCollection_test
             var p = new ParameterExpression[3]; // the parameter expressions 
             var e = new Expression[8]; // the unique expressions 
             var l = new LabelTarget[0]; // the labels 
-            var expr = Lambda( // $
-              typeof(Dynamic.SimpleDelegate),
+            var expr = Lambda<Action<SampleClass, string>>( // $
               e[0] = Block(
                 typeof(void),
                 new[] {
@@ -569,18 +570,20 @@ public void Test_287_Case2_SimpleDelegate_as_nested_lambda_in_TesCollection_test
                     p[2] = Parameter(typeof(string))),
                   e[7] = Empty(),
                   typeof(void))),
-              p[2 // (string string__41619574)
-                ]);
+                p[1 // (SampleClass)
+                  ],
+                p[2 // (string string__41619574)
+                  ]);
 
             expr.PrintCSharp();
 
             var fs = expr.CompileSys();
             fs.PrintIL();
-            // Assert.AreEqual(new CustomMoneyType { Amount = 1.11m }, fs(1.11m));
+            fs(new SampleClass(), "43");
 
             var fx = expr.CompileFast(true);
             fx.PrintIL();
-            // Assert.AreEqual(new CustomMoneyType { Amount = 1.11m }, fx(1.11m));
+            fx(new SampleClass(), "43");
         }
 
         [Test]

test/FastExpressionCompiler.IssueTests/Issue83_linq2db.cs

@@ -1235,9 +1235,15 @@ public void AddNullTest()
             var p = Parameter(typeof(int?));
             var body = Add(Constant(4, typeof(int?)), p);
             var expr = Lambda<Func<int?, int?>>(body, p);
-            var compiled = expr.CompileFast(true);
-            Assert.AreEqual(9, compiled(5));
-            Assert.AreEqual(null, compiled(null));
+
+            var fs = expr.CompileSys();
+            fs.PrintIL();
+
+            var fx = expr.CompileFast(true);
+            fx.PrintIL();
+
+            Assert.AreEqual(9, fx(5));
+            Assert.AreEqual(null, fx(null));
         }
 
         [Test]