Fix check for invocation of async infrastructure methods via reflection

Author: jkotas

src/coreclr/vm/reflectioninvocation.cpp

@@ -342,11 +342,6 @@ extern "C" void QCALLTYPE RuntimeMethodHandle_InvokeMethod(
         COMPlusThrow(kNotSupportedException, W("NotSupported_Type"));
     }
 
-    if (pMeth->IsAsyncMethod())
-    {
-        COMPlusThrow(kNotSupportedException, W("NotSupported_Async"));
-    }
-
 #ifdef _DEBUG
     if (g_pConfig->ShouldInvokeHalt(pMeth))
     {

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

@@ -32,6 +32,12 @@ internal InvocationFlags ComputeAndUpdateInvocationFlags()
                     {
                         invocationFlags = InvocationFlags.NoInvoke;
                     }
+                    // This check assumes that all MethodImplAttributes.Async methods on AsyncHelpers are the only non-task returning async methods
+                    // with special calling convention
+                    else if (declaringType == typeof(AsyncHelpers) && (GetMethodImplementationFlags() & MethodImplAttributes.Async) != 0)
+                    {
+                        invocationFlags = InvocationFlags.NoInvoke;
+                    }
                     else if (declaringType.IsByRefLike) // Check for byref-like types
                     {
                         invocationFlags |= InvocationFlags.ContainsStackPointers;
@@ -60,6 +66,8 @@ static bool IsDisallowedByRefType(Type type)
         [DoesNotReturn]
         internal void ThrowNoInvokeException()
         {
+            Type? declaringType = DeclaringType;
+
             // method is on a class that contains stack pointers
             if ((InvocationFlags & InvocationFlags.ContainsStackPointers) != 0)
             {
@@ -71,7 +79,7 @@ internal void ThrowNoInvokeException()
                 throw new NotSupportedException();
             }
             // method is generic or on a generic class
-            else if (DeclaringType!.ContainsGenericParameters || ContainsGenericParameters)
+            else if ((declaringType != null && declaringType.ContainsGenericParameters) || ContainsGenericParameters)
             {
                 throw new InvalidOperationException(SR.Arg_UnboundGenParam);
             }
@@ -88,6 +96,10 @@ internal void ThrowNoInvokeException()
                 if (elementType == typeof(void))
                     throw new NotSupportedException(SR.NotSupported_ByRefToVoidReturn);
             }
+            else if (declaringType == typeof(AsyncHelpers) && (GetMethodImplementationFlags() & MethodImplAttributes.Async) != 0)
+            {
+                throw new NotSupportedException(SR.NotSupported_Async);
+            }
 
             throw new TargetException();
         }

src/tests/async/reflection/reflection-simple.cs

@@ -27,7 +27,7 @@ public static void MethodInfo_Invoke_AsyncHelper()
     {
         var mi = typeof(System.Runtime.CompilerServices.AsyncHelpers).GetMethod("Await", BindingFlags.Static | BindingFlags.Public, new Type[] { typeof(Task) })!;
         Assert.NotNull(mi);
-        Assert.Throws<TargetInvocationException>(() => mi.Invoke(null, new object[] { FooTask() }));
+        Assert.Throws<NotSupportedException>(() => mi.Invoke(null, new object[] { FooTask() }));
 
         // Sadly the following does not throw and results in UB
         // We cannot completely prevent putting a token of an Async method into IL stream.