[RuntimeAsync] Tweak some reflection scenarios around async methods. (#118045)

VSadov · web-flow · commit 1752b9664ecc · 2025-08-01T20:31:13.000Z
diff --git a/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CoreCLR.cs
@@ -2736,20 +2736,30 @@ public override InterfaceMapping GetInterfaceMap([DynamicallyAccessedMembers(Dyn
             im.InterfaceMethods = new MethodInfo[ifaceVirtualMethodCount];
             im.TargetMethods = new MethodInfo[ifaceVirtualMethodCount];
 
+            int actualCount = 0;
             for (int i = 0; i < ifaceVirtualMethodCount; i++)
             {
                 RuntimeMethodHandleInternal ifaceRtMethodHandle = RuntimeTypeHandle.GetMethodAt(ifaceRtType, i);
 
+                // GetMethodAt may return null handle for methods that do not exist or are not supposed
+                // to be seen in reflection. One example is async variant methods.
+                // We do not record mapping for interface methods that do not exist.
+                if (ifaceRtMethodHandle.IsNullHandle())
+                    continue;
+
                 // GetMethodBase will convert this to the instantiating/unboxing stub if necessary
                 MethodBase ifaceMethodBase = GetMethodBase(ifaceRtType, ifaceRtMethodHandle)!;
                 Debug.Assert(ifaceMethodBase is RuntimeMethodInfo);
-                im.InterfaceMethods[i] = (MethodInfo)ifaceMethodBase;
+                im.InterfaceMethods[actualCount] = (MethodInfo)ifaceMethodBase;
 
                 // If the impl is null, then virtual stub dispatch is active.
                 RuntimeMethodHandleInternal classRtMethodHandle = TypeHandle.GetInterfaceMethodImplementation(ifaceRtTypeHandle, ifaceRtMethodHandle);
 
                 if (classRtMethodHandle.IsNullHandle())
+                {
+                    actualCount++;
                     continue;
+                }
 
                 // If we resolved to an interface method, use the interface type as reflected type. Otherwise use `this`.
                 RuntimeType reflectedType = RuntimeMethodHandle.GetDeclaringType(classRtMethodHandle);
@@ -2764,10 +2774,16 @@ public override InterfaceMapping GetInterfaceMap([DynamicallyAccessedMembers(Dyn
                 // the TargetMethod provided to us by runtime internals may be a generic method instance,
                 //  potentially with invalid arguments. TargetMethods in the InterfaceMap should never be
                 //  instances, only definitions.
-                im.TargetMethods[i] = (targetMethod is { IsGenericMethod: true, IsGenericMethodDefinition: false })
+                im.TargetMethods[actualCount++] = (targetMethod is { IsGenericMethod: true, IsGenericMethodDefinition: false })
                     ? targetMethod.GetGenericMethodDefinition() : targetMethod!;
             }
 
+            if (actualCount != ifaceVirtualMethodCount)
+            {
+                Array.Resize(ref im.InterfaceMethods, actualCount);
+                Array.Resize(ref im.TargetMethods, actualCount);
+            }
+
             return im;
         }
         #endregion
diff --git a/src/coreclr/vm/asyncthunks.cpp b/src/coreclr/vm/asyncthunks.cpp
@@ -18,7 +18,7 @@ bool MethodDesc::TryGenerateAsyncThunk(DynamicResolver** resolver, COR_ILMETHOD_
     _ASSERTE(methodILDecoder != NULL);
     _ASSERTE(*resolver == NULL && *methodILDecoder == NULL);
     _ASSERTE(IsIL());
-    _ASSERTE(GetRVA() == 0);
+    _ASSERTE(!HasILHeader());
 
     if (!IsAsyncThunkMethod())
     {
diff --git a/src/coreclr/vm/codeversion.cpp b/src/coreclr/vm/codeversion.cpp
@@ -913,7 +913,7 @@ PTR_COR_ILMETHOD ILCodeVersion::GetIL() const
     {
         PTR_Module pModule = GetModule();
         PTR_MethodDesc pMethodDesc = dac_cast<PTR_MethodDesc>(pModule->LookupMethodDef(GetMethodDef()));
-        if (pMethodDesc != NULL)
+        if (pMethodDesc != NULL && pMethodDesc->MayHaveILHeader())
         {
             pIL = dac_cast<PTR_COR_ILMETHOD>(pMethodDesc->GetILHeader());
         }
diff --git a/src/coreclr/vm/dwbucketmanager.hpp b/src/coreclr/vm/dwbucketmanager.hpp
@@ -326,7 +326,6 @@ class BaseBucketParamsManager
     void GetExceptionName(_Out_writes_(maxLength) WCHAR* targetParam, int maxLength);
     void GetPackageMoniker(_Out_writes_(maxLength) WCHAR* targetParam, int maxLength);
     void GetPRAID(_Out_writes_(maxLength) WCHAR* targetParam, int maxLength);
-    void GetIlRva(_Out_writes_(maxLength) WCHAR* targetParam, int maxLength);
 
 public:
     BaseBucketParamsManager(GenericModeBlock* pGenericModeBlock, TypeOfReportedError typeOfError, PCODE initialFaultingPc, Thread* pFaultingThread, OBJECTREF* pThrownException);
@@ -810,31 +809,6 @@ void BaseBucketParamsManager::GetPRAID(_Out_writes_(maxLength) WCHAR* targetPara
     _ASSERTE(!"PRAID support NYI for CoreCLR");
 }
 
-void BaseBucketParamsManager::GetIlRva(_Out_writes_(maxLength) WCHAR* targetParam, int maxLength)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    DWORD ilOffset = GetILOffset();
-
-    if (ilOffset == MAXDWORD)
-        ilOffset = 0;
-
-    if (m_pFaultingMD)
-        ilOffset += m_pFaultingMD->GetRVA();
-
-    _snwprintf_s(targetParam,
-                maxLength,
-                _TRUNCATE,
-                W("%x"),
-                ilOffset);
-}
-
 // helper functions
 
 DWORD BaseBucketParamsManager::GetILOffset()
diff --git a/src/coreclr/vm/eedbginterface.h b/src/coreclr/vm/eedbginterface.h
@@ -264,8 +264,6 @@ class EEDebugInterface
 
     virtual COR_ILMETHOD* MethodDescGetILHeader(MethodDesc *pFD) = 0;
 
-    virtual ULONG MethodDescGetRVA(MethodDesc *pFD) = 0;
-
     virtual void MarkDebuggerAttached(void) = 0;
 
     virtual void MarkDebuggerUnattached(void) = 0;
diff --git a/src/coreclr/vm/eedbginterfaceimpl.cpp b/src/coreclr/vm/eedbginterfaceimpl.cpp
@@ -721,19 +721,6 @@ COR_ILMETHOD* EEDbgInterfaceImpl::MethodDescGetILHeader(MethodDesc *pFD)
     RETURN NULL;
 }
 
-ULONG EEDbgInterfaceImpl::MethodDescGetRVA(MethodDesc *pFD)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        PRECONDITION(CheckPointer(pFD));
-    }
-    CONTRACTL_END;
-
-    return pFD->GetRVA();
-}
-
 MethodDesc *EEDbgInterfaceImpl::FindLoadedMethodRefOrDef(Module* pModule,
                                                           mdToken memberRef)
 {
diff --git a/src/coreclr/vm/eedbginterfaceimpl.h b/src/coreclr/vm/eedbginterfaceimpl.h
@@ -156,8 +156,6 @@ class EEDbgInterfaceImpl : public EEDebugInterface
 
     COR_ILMETHOD* MethodDescGetILHeader(MethodDesc *pFD);
 
-    ULONG MethodDescGetRVA(MethodDesc *pFD);
-
     MethodDesc *FindLoadedMethodRefOrDef(Module* pModule,
                                           mdToken memberRef);
 
diff --git a/src/coreclr/vm/jitinterface.cpp b/src/coreclr/vm/jitinterface.cpp
@@ -7680,20 +7680,16 @@ CEEInfo::getMethodInfo(
     JIT_TO_EE_TRANSITION();
 
     MethodDesc* ftn = GetMethod(ftnHnd);
-    if (ftn->IsDynamicMethod())
-    {
-        getMethodInfoWorker(ftn, NULL, methInfo, context);
-        result = true;
-    }
-    else if (!ftn->IsWrapperStub() && ftn->HasILHeader())
+    if (ftn->HasILHeader())
     {
         // Get the IL header and set it.
         COR_ILMETHOD_DECODER header(ftn->GetILHeader(), ftn->GetMDImport(), NULL);
         getMethodInfoWorker(ftn, &header, methInfo, context);
         result = true;
     }
-    else if (ftn->IsIL() && ftn->GetRVA() == 0) // IL methods with no RVA indicate there is no implementation defined in metadata.
+    else if (ftn->IsIL() || ftn->IsDynamicMethod())
     {
+        // IL methods with no IL header indicate there is no implementation defined in metadata.
         getMethodInfoWorker(ftn, NULL, methInfo, context);
         result = true;
     }
@@ -7875,7 +7871,7 @@ CorInfoInline CEEInfo::canInline (CORINFO_METHOD_HANDLE hCaller,
                     goto exit;
                 }
             }
-            else if (pCallee->IsIL() && pCallee->GetRVA() == 0)
+            else if (pCallee->IsIL())
             {
                 CORINFO_METHOD_INFO methodInfo;
                 getMethodInfoWorker(pCallee, NULL, &methodInfo);
@@ -12788,7 +12784,7 @@ void CEECodeGenInfo::getEHinfo(
         COR_ILMETHOD_DECODER header(pMD->GetILHeader(), pMD->GetMDImport(), NULL);
         getEHinfoHelper(ftn, EHnumber, clause, &header);
     }
-    else if (pMD->IsIL() && pMD->GetRVA() == 0)
+    else if (pMD->IsIL())
     {
         TransientMethodDetails* details;
         if (!FindTransientMethodDetails(pMD, &details))
diff --git a/src/coreclr/vm/method.cpp b/src/coreclr/vm/method.cpp
@@ -1123,8 +1123,10 @@ BOOL MethodDesc::HasRetBuffArg()
 }
 
 //*******************************************************************************
-// This returns the offset of the IL.
-// The offset is relative to the base of the IL image.
+// This typically returns the offset of the IL.
+// Another case when a method may have an RVA is earlybound IJW PInvokes,
+// in which case the RVA is referring to native code.
+// The offset is relative to the base of the image.
 ULONG MethodDesc::GetRVA()
 {
     CONTRACTL
@@ -1133,27 +1135,11 @@ ULONG MethodDesc::GetRVA()
         GC_NOTRIGGER;
         FORBID_FAULT;
         SUPPORTS_DAC;
+        PRECONDITION((IsIL() && MayHaveILHeader()) ||
+            (IsPInvoke() && ((PInvokeMethodDesc*)this)->IsEarlyBound()));
     }
     CONTRACTL_END
 
-    if (IsRuntimeSupplied())
-    {
-        return 0;
-    }
-
-    // Methods without metadata don't have an RVA.  Examples are IL stubs and LCG methods.
-    if (IsNoMetadata())
-    {
-        return 0;
-    }
-
-    // Between two Async variants of the same method only one represents the actual IL.
-    // It is the variant that is not a thunk.
-    if (IsAsyncThunkMethod())
-    {
-        return 0;
-    }
-
     if (GetMemberDef() & 0x00FFFFFF)
     {
         Module *pModule = GetModule();
@@ -1198,8 +1184,7 @@ COR_ILMETHOD* MethodDesc::GetILHeader()
     {
         THROWS;
         GC_NOTRIGGER;
-        PRECONDITION(IsIL());
-        PRECONDITION(!IsUnboxingStub());
+        PRECONDITION(MayHaveILHeader());
     }
     CONTRACTL_END
 
diff --git a/src/coreclr/vm/method.hpp b/src/coreclr/vm/method.hpp
@@ -901,7 +901,8 @@ class MethodDesc
             MODE_ANY;
         }
         CONTRACTL_END;
-        return IsIL() && !IsUnboxingStub() && GetRVA();
+
+        return MayHaveILHeader() && GetRVA();
     }
 
     COR_ILMETHOD* GetILHeader();
@@ -1499,6 +1500,14 @@ class MethodDesc
 
     BOOL MayHaveNativeCode();
 
+    BOOL MayHaveILHeader()
+    {
+        LIMITED_METHOD_DAC_CONTRACT;
+
+        // methods with transient IL bodies do not have IL headers
+        return IsIL() && !IsUnboxingStub() && !IsAsyncThunkMethod();
+    }
+
     ULONG GetRVA();
 
 public:
diff --git a/src/coreclr/vm/prestub.cpp b/src/coreclr/vm/prestub.cpp
@@ -706,15 +706,20 @@ namespace
         _ASSERTE(pConfig != NULL);
         _ASSERTE(pDecoderMemory != NULL);
 
+        if (!pMD->MayHaveILHeader())
+            return NULL;
+
         COR_ILMETHOD_DECODER* pHeader = NULL;
+
         COR_ILMETHOD* ilHeader = pConfig->GetILHeader();
 
         // For a Runtime Async method the methoddef maps to a Task-returning thunk with runtime-provided implementation,
         // while the default IL belongs to the Async implementation variant.
         // By default the config captures the default methoddesc, which would be a thunk, thus no IL header.
         // So, if config provides no header and we see an implementation method desc, then just ask the method desc itself.
-        if (ilHeader == NULL && pMD->IsAsyncVariantMethod() && !pMD->IsAsyncThunkMethod())
+        if (ilHeader == NULL && pMD->IsAsyncVariantMethod())
         {
+            _ASSERTE(!pMD->IsAsyncThunkMethod());
             ilHeader = pMD->GetILHeader();
         }
 
diff --git a/src/coreclr/vm/reflectioninvocation.cpp b/src/coreclr/vm/reflectioninvocation.cpp
@@ -342,6 +342,11 @@ 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))
     {
diff --git a/src/coreclr/vm/runtimehandles.cpp b/src/coreclr/vm/runtimehandles.cpp
@@ -441,6 +441,15 @@ extern "C" MethodDesc* QCALLTYPE RuntimeTypeHandle_GetMethodAt(MethodTable* pMT,
         }
     }
 
+    if (pRetMethod != NULL && pRetMethod->IsAsyncVariantMethod())
+    {
+        // do not return methoddescs for async variants.
+        // NOTE: The only scenario where this is relevant is when caller iterates through all slots.
+        //       If GetMethodAt is used to find a method associated with another one,
+        //       then we would be starting with "real" method and will get a "real" method here.
+        pRetMethod = NULL;
+    }
+
     END_QCALL;
 
     return pRetMethod;
diff --git a/src/coreclr/vm/unsafeaccessors.cpp b/src/coreclr/vm/unsafeaccessors.cpp
@@ -1019,7 +1019,7 @@ bool MethodDesc::TryGenerateUnsafeAccessor(DynamicResolver** resolver, COR_ILMET
     _ASSERTE(methodILDecoder != NULL);
     _ASSERTE(*resolver == NULL && *methodILDecoder == NULL);
     _ASSERTE(IsIL());
-    _ASSERTE(GetRVA() == 0);
+    _ASSERTE(!HasILHeader());
 
     // The UnsafeAccessorAttribute is applied to methods with an
     // RVA of 0 (for example, C#'s extern keyword).
diff --git a/src/libraries/System.Private.CoreLib/src/Resources/Strings.resx b/src/libraries/System.Private.CoreLib/src/Resources/Strings.resx
@@ -2987,6 +2987,9 @@
   <data name="NotSupported_ByRefToVoidReturn" xml:space="preserve">
     <value>ByRef to void return values are not supported in reflection invocation.</value>
   </data>
+  <data name="NotSupported_Async" xml:space="preserve">
+    <value>Async infrastructure methods are not supported in reflection invocation.</value>
+  </data>
   <data name="NotSupported_CallToVarArg" xml:space="preserve">
     <value>Vararg calling convention not supported.</value>
   </data>
diff --git a/src/tests/async/reflection/reflection-simple.cs b/src/tests/async/reflection/reflection-simple.cs

Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ bool MethodDesc::TryGenerateAsyncThunk(DynamicResolver** resolver, COR_ILMETHOD_`
`18`	`18`	`_ASSERTE(methodILDecoder != NULL);`
`19`	`19`	`_ASSERTE(resolver == NULL && methodILDecoder == NULL);`
`20`	`20`	`_ASSERTE(IsIL());`
`21`		`- _ASSERTE(GetRVA() == 0);`
	`21`	`+ _ASSERTE(!HasILHeader());`
`22`	`22`
`23`	`23`	`if (!IsAsyncThunkMethod())`
`24`	`24`	`{`
Original file line number	Diff line number	Diff line change
`@@ -913,7 +913,7 @@ PTR_COR_ILMETHOD ILCodeVersion::GetIL() const`
`913`	`913`	`{`
`914`	`914`	`PTR_Module pModule = GetModule();`
`915`	`915`	`PTR_MethodDesc pMethodDesc = dac_cast<PTR_MethodDesc>(pModule->LookupMethodDef(GetMethodDef()));`
`916`		`- if (pMethodDesc != NULL)`
	`916`	`+ if (pMethodDesc != NULL && pMethodDesc->MayHaveILHeader())`
`917`	`917`	`{`
`918`	`918`	`pIL = dac_cast<PTR_COR_ILMETHOD>(pMethodDesc->GetILHeader());`
`919`	`919`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7680,20 +7680,16 @@ CEEInfo::getMethodInfo(`
`7680`	`7680`	`JIT_TO_EE_TRANSITION();`
`7681`	`7681`
`7682`	`7682`	`MethodDesc* ftn = GetMethod(ftnHnd);`
`7683`		`- if (ftn->IsDynamicMethod())`
`7684`		`- {`
`7685`		`- getMethodInfoWorker(ftn, NULL, methInfo, context);`
`7686`		`- result = true;`
`7687`		`- }`
`7688`		`- else if (!ftn->IsWrapperStub() && ftn->HasILHeader())`
	`7683`	`+ if (ftn->HasILHeader())`
`7689`	`7684`	`{`
`7690`	`7685`	`// Get the IL header and set it.`
`7691`	`7686`	`COR_ILMETHOD_DECODER header(ftn->GetILHeader(), ftn->GetMDImport(), NULL);`
`7692`	`7687`	`getMethodInfoWorker(ftn, &header, methInfo, context);`
`7693`	`7688`	`result = true;`
`7694`	`7689`	`}`
`7695`		`- else if (ftn->IsIL() && ftn->GetRVA() == 0) // IL methods with no RVA indicate there is no implementation defined in metadata.`
	`7690`	`+ else if (ftn->IsIL() \|\| ftn->IsDynamicMethod())`
`7696`	`7691`	`{`
	`7692`	`+ // IL methods with no IL header indicate there is no implementation defined in metadata.`
`7697`	`7693`	`getMethodInfoWorker(ftn, NULL, methInfo, context);`
`7698`	`7694`	`result = true;`
`7699`	`7695`	`}`
`@@ -7875,7 +7871,7 @@ CorInfoInline CEEInfo::canInline (CORINFO_METHOD_HANDLE hCaller,`
`7875`	`7871`	`goto exit;`
`7876`	`7872`	`}`
`7877`	`7873`	`}`
`7878`		`- else if (pCallee->IsIL() && pCallee->GetRVA() == 0)`
	`7874`	`+ else if (pCallee->IsIL())`
`7879`	`7875`	`{`
`7880`	`7876`	`CORINFO_METHOD_INFO methodInfo;`
`7881`	`7877`	`getMethodInfoWorker(pCallee, NULL, &methodInfo);`
`@@ -12788,7 +12784,7 @@ void CEECodeGenInfo::getEHinfo(`
`12788`	`12784`	`COR_ILMETHOD_DECODER header(pMD->GetILHeader(), pMD->GetMDImport(), NULL);`
`12789`	`12785`	`getEHinfoHelper(ftn, EHnumber, clause, &header);`
`12790`	`12786`	`}`
`12791`		`- else if (pMD->IsIL() && pMD->GetRVA() == 0)`
	`12787`	`+ else if (pMD->IsIL())`
`12792`	`12788`	`{`
`12793`	`12789`	`TransientMethodDetails* details;`
`12794`	`12790`	`if (!FindTransientMethodDetails(pMD, &details))`