Add IL Emit support for MethodInfo.Invoke() and friends

src/coreclr/vm/appdomain.cpp

@@ -1523,10 +1523,19 @@ bool SystemDomain::IsReflectionInvocationMethod(MethodDesc* pMeth)
 
     MethodTable* pCaller = pMeth->GetMethodTable();
 
-    // All Reflection Invocation methods are defined in CoreLib
+    // All reflection invocation methods are defined in CoreLib.
     if (!pCaller->GetModule()->IsSystem())
         return false;
 
+    // Check for dynamically generated Invoke methods.
+    if (pMeth->IsLCGMethod())
+    {
+        // Even if a user-created DynamicMethod uses the same naming convention, it will likely not
+        // get here since since DynamicMethods by default are created in a special (non-system) module.
+        // If this is not sufficient for conflict prevention, we can create a new private module.
+        return (strncmp(pMeth->GetName(), "InvokeStub_", ARRAY_SIZE("InvokeStub_") - 1) == 0);
+    }
+
     /* List of types that should be skipped to identify true caller */
     static const BinderClassID reflectionInvocationTypes[] = {
         CLASS__METHOD,
@@ -1579,13 +1588,6 @@ bool SystemDomain::IsReflectionInvocationMethod(MethodDesc* pMeth)
             if (CoreLibBinder::GetExistingClass(reflectionInvocationTypes[i]) == pCaller)
                 return true;
         }
-
-        // Check for dynamically generated Invoke methods.
-        if (pMeth->IsDynamicMethod())
-        {
-            if (strncmp(pMeth->GetName(), "InvokeStub_", ARRAY_SIZE("InvokeStub_") - 1) == 0)
-                return true;
-        }
     }
 
     return false;

src/libraries/System.Private.CoreLib/src/System/Reflection/InvokerEmitUtil.cs

@@ -29,7 +29,8 @@ public static unsafe InvokeFunc CreateInvokeDelegate(MethodBase method)
                 InvokeStubPrefix + declaringTypeName + method.Name,
                 returnType: typeof(object),
                 delegateParameters,
-                restrictedSkipVisibility: true);
+                typeof(object).Module, // Use system module to identify our DynamicMethods.
+                skipVisibility: true);
 
             ILGenerator il = dm.GetILGenerator();
 
@@ -64,6 +65,11 @@ public static unsafe InvokeFunc CreateInvokeDelegate(MethodBase method)
             }
 
             // Invoke the method.
+#if !MONO
+            il.Emit(OpCodes.Call, Methods.NextCallReturnAddress()); // For CallStack reasons, don't inline target method.
+            il.Emit(OpCodes.Pop);
+#endif
+
             if (emitNew)
             {
                 il.Emit(OpCodes.Newobj, (ConstructorInfo)method);
@@ -182,6 +188,13 @@ public static MethodInfo Pointer_Box() =>
             public static MethodInfo Type_GetTypeFromHandle() =>
                                       s_Type_GetTypeFromHandle ??
                                      (s_Type_GetTypeFromHandle = typeof(Type).GetMethod(nameof(Type.GetTypeFromHandle), new[] { typeof(RuntimeTypeHandle) })!);
+
+#if !MONO
+            private static MethodInfo? s_NextCallReturnAddress;
+            public static MethodInfo NextCallReturnAddress() =>
+                                      s_NextCallReturnAddress ??
+                                     (s_NextCallReturnAddress = typeof(System.StubHelpers.StubHelpers).GetMethod(nameof(System.StubHelpers.StubHelpers.NextCallReturnAddress), BindingFlags.NonPublic | BindingFlags.Static)!);
+#endif
         }
     }
 }

src/libraries/System.Reflection/tests/ExceptionTests.cs

@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Runtime.CompilerServices;
 using Xunit;
 
 namespace System.Reflection.Tests

src/libraries/System.Reflection/tests/MethodInfoTests.cs

@@ -2,7 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Linq;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
@@ -771,6 +770,32 @@ public void CopyBackWithByRefArgs()
             Assert.Null(args[0]);
         }
 
+        [Fact]
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/50957", typeof(PlatformDetection), nameof(PlatformDetection.IsMonoInterpreter))]
+        public static void CallStackFrame_AggressiveInlining()
+        {
+            MethodInfo mi = typeof(System.Reflection.TestAssembly.ClassToInvoke).GetMethod(nameof(System.Reflection.TestAssembly.ClassToInvoke.CallMe_AggressiveInlining),
+                BindingFlags.Public | BindingFlags.Static)!;
+
+            // Although the target method has AggressiveInlining, currently reflection should not inline the target into any generated IL.
+            FirstCall(mi);
+            SecondCall(mi);
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)] // Separate non-inlineable method to aid any test failures
+        private static void FirstCall(MethodInfo mi)
+        {
+            Assembly asm = (Assembly)mi.Invoke(null, null);
+            Assert.Contains("TestAssembly", asm.ToString());
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)] // Separate non-inlineable method to aid any test failures
+        private static void SecondCall(MethodInfo mi)
+        {
+            Assembly asm = (Assembly)mi.Invoke(null, null);
+            Assert.Contains("TestAssembly", asm.ToString());
+        }
+
         //Methods for Reflection Metadata
         private void DummyMethod1(string str, int iValue, long lValue)
         {

src/libraries/System.Reflection/tests/TestAssembly/ClassToInvoke.cs

@@ -0,0 +1,22 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Runtime.CompilerServices;
+
+namespace System.Reflection.TestAssembly
+{
+    public sealed class ClassToInvoke
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Assembly CallMe_AggressiveInlining()
+        {
+            return CallMeActual();
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        private static Assembly CallMeActual()
+        {
+            return Assembly.GetCallingAssembly();
+        }
+    }
+}

src/libraries/System.Reflection/tests/TestAssembly/TestAssembly.csproj

@@ -1,9 +1,10 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
     <TargetFramework>netstandard2.0</TargetFramework>
   </PropertyGroup>
   <ItemGroup>
+    <Compile Include="ClassToInvoke.cs" />
     <Compile Include="TestAssembly.cs" />
   </ItemGroup>
 </Project>