fixed: #310 Ensure that FEC.LightExpression.ILGeneratorHacks does not crash if some method is not reflected

Author: maximv

src/DryIoc/FastExpressionCompiler.cs

@@ -4620,12 +4620,11 @@ public static T GetFirst<T>(this T[] source)
         }
     }
 
-    /// Hey
+    /// <summary>Reflecting the internal methods to access the more performant for defining the local variable</summary>
     public static class ILGeneratorHacks
     {
+        // The original ILGenerator methods we are trying to hack without allocating the `LocalBuilder`
         /*
-        // Original methods from ILGenerator.cs
-        
         public virtual LocalBuilder DeclareLocal(Type localType)
         {
             return this.DeclareLocal(localType, false);
@@ -4649,56 +4648,72 @@ public virtual LocalBuilder DeclareLocal(Type localType, bool pinned)
         }
         */
 
-        /// Not allocating the LocalBuilder class
-        /// emitting this:
-        /// il.m_localSignature.AddArgument(type);
-        /// return PostInc(ref il.LocalCount);
-        public static Func<ILGenerator, Type, int> CompileGetNextLocalVarIndex()
+        private static readonly Func<ILGenerator, Type, int> _getNextLocalVarIndex;
+
+        internal static int PostInc(ref int i) => i++;
+
+        static ILGeneratorHacks() 
         {
-            if (LocalCountField == null || LocalSignatureField == null || AddArgumentMethod == null)
-                return (i, t) => i.DeclareLocal(t).LocalIndex;
+             // the default allocatee method
+            _getNextLocalVarIndex = (il, type) => il.DeclareLocal(type).LocalIndex;
+
+            // now let's try to acquire the more efficient less allocating method
+            var ilGenTypeInfo = typeof(ILGenerator).GetTypeInfo();
+            var localSignatureField = ilGenTypeInfo.GetDeclaredField("m_localSignature");
+            if (localSignatureField == null)
+                return;
+
+            var localCountField = ilGenTypeInfo.GetDeclaredField("m_localCount");
+            if (localCountField == null)
+                return;
+
+            // looking for the `SignatureHelper.AddArgument(Type argument, bool pinned)`
+            MethodInfo addArgumentMethod = null;
+            foreach (var m in typeof(SignatureHelper).GetTypeInfo().GetDeclaredMethods("AddArgument"))
+            {
+                var ps = m.GetParameters();
+                if (ps.Length == 2 && ps[0].ParameterType == typeof(Type) && ps[1].ParameterType == typeof(bool))
+                {
+                    addArgumentMethod = m;
+                    break;
+                }
+            }
 
-            var method = new DynamicMethod(string.Empty,
+            if (addArgumentMethod == null)
+                return;
+
+            // our own helper - always available
+            var postIncMethod = typeof(ILGeneratorHacks).GetTypeInfo().GetDeclaredMethod(nameof(PostInc));
+
+            // now let's compile the following method without allocating the LocalBuilder class:
+            /*
+                 il.m_localSignature.AddArgument(type);
+                 return PostInc(ref il.LocalCount);
+            */
+            var efficientMethod = new DynamicMethod(string.Empty,
                 typeof(int), new[] { typeof(ExpressionCompiler.ArrayClosure), typeof(ILGenerator), typeof(Type) },
                 typeof(ExpressionCompiler.ArrayClosure), skipVisibility: true);
+            var il = efficientMethod.GetILGenerator();
 
-            var il = method.GetILGenerator();
-
-            il.Emit(OpCodes.Ldarg_1); // load `il` argument
-            il.Emit(OpCodes.Ldfld, LocalSignatureField);
-            il.Emit(OpCodes.Ldarg_2); // load `type` argument
+            // emitting `il.m_localSignature.AddArgument(type);`
+            il.Emit(OpCodes.Ldarg_1);  // load `il` argument (arg_0 is the empty closure object)
+            il.Emit(OpCodes.Ldfld, localSignatureField);
+            il.Emit(OpCodes.Ldarg_2);  // load `type` argument
             il.Emit(OpCodes.Ldc_I4_0); // load `pinned: false` argument
-            il.Emit(OpCodes.Call, AddArgumentMethod);
+            il.Emit(OpCodes.Call, addArgumentMethod);
 
+            // emitting `return PostInc(ref il.LocalCount);`
             il.Emit(OpCodes.Ldarg_1); // load `il` argument
-            il.Emit(OpCodes.Ldflda, LocalCountField);
-            il.Emit(OpCodes.Call, PostIncMethod);
+            il.Emit(OpCodes.Ldflda, localCountField);
+            il.Emit(OpCodes.Call, postIncMethod);
 
             il.Emit(OpCodes.Ret);
 
-            return (Func<ILGenerator, Type, int>)method.CreateDelegate(typeof(Func<ILGenerator, Type, int>), ExpressionCompiler.EmptyArrayClosure);
+            _getNextLocalVarIndex = (Func<ILGenerator, Type, int>)efficientMethod.CreateDelegate(
+                typeof(Func<ILGenerator, Type, int>), ExpressionCompiler.EmptyArrayClosure);
         }
 
-        internal static int PostInc(ref int i) => i++;
-
-        public static readonly MethodInfo PostIncMethod = typeof(ILGeneratorHacks).GetTypeInfo()
-            .GetDeclaredMethod(nameof(PostInc));
-
-        /// Get via reflection
-        public static readonly FieldInfo LocalSignatureField = typeof(ILGenerator).GetTypeInfo()
-            .GetDeclaredField("m_localSignature");
-
-        /// Get via reflection
-        public static readonly FieldInfo LocalCountField = typeof(ILGenerator).GetTypeInfo()
-            .GetDeclaredField("m_localCount");
-
-        /// Get via reflection
-        public static readonly MethodInfo AddArgumentMethod = typeof(SignatureHelper).GetTypeInfo()
-            .GetDeclaredMethods(nameof(SignatureHelper.AddArgument)).First(m => m.GetParameters().Length == 2);
-
-        private static readonly Func<ILGenerator, Type, int> _getNextLocalVarIndex = CompileGetNextLocalVarIndex();
-
-        /// Does the job
+        /// <summary>Efficiently returns the next variable index, hopefully without unnecessary allocations.</summary>
         public static int GetNextLocalVarIndex(this ILGenerator il, Type t) => _getNextLocalVarIndex(il, t);
     }