GetInterfaceMap

Author: VSadov

src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CoreCLR.cs

@@ -2736,14 +2736,21 @@ 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.
+                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);
@@ -2764,8 +2771,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!;
+
+                actualCount++;
+            }
+
+            if (actualCount != ifaceVirtualMethodCount)
+            {
+                Array.Resize(ref im.InterfaceMethods, actualCount);
+                Array.Resize(ref im.TargetMethods, actualCount);
             }
 
             return im;

src/coreclr/vm/runtimehandles.cpp

@@ -443,6 +443,15 @@ extern "C" MethodDesc* QCALLTYPE RuntimeTypeHandle_GetMethodAt(MethodTable* pMT,
 
     END_QCALL;
 
+    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.
+        return NULL;
+    }
+
     return pRetMethod;
 }
 

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

@@ -69,4 +69,62 @@ static async Task AwaitF<T>(T expected, Func<Task<T>> f)
         var res = await f.Invoke();
         Assert.Equal(expected, res);
     }
+
+    public interface IExample<T>
+    {
+        Task TaskReturning();
+        T TReturning();
+    }
+
+    public class ExampleClass : IExample<Task>
+    {
+        public Task TaskReturning()
+        {
+            return null;
+        }
+
+        public Task TReturning()
+        {
+            return null;
+        }
+    }
+
+    public struct ExampleStruct : IExample<Task>
+    {
+        public Task TaskReturning()
+        {
+            return null;
+        }
+
+        public Task TReturning()
+        {
+            return null;
+        }
+    }
+
+    [Fact]
+    public static void GetInterfaceMap()
+    {
+        Type interfaceType = typeof(IExample<Task>);
+        Type classType = typeof(ExampleClass);
+
+        InterfaceMapping map = classType.GetInterfaceMap(interfaceType);
+
+        Assert.Equal(2, map.InterfaceMethods.Length);
+        Assert.Equal("System.Threading.Tasks.Task TaskReturning() --> System.Threading.Tasks.Task TaskReturning()",
+            $"{map.InterfaceMethods[0]?.ToString()} --> {map.TargetMethods[0]?.ToString()}");
+
+        Assert.Equal("System.Threading.Tasks.Task TReturning() --> System.Threading.Tasks.Task TReturning()",
+            $"{map.InterfaceMethods[1]?.ToString()} --> {map.TargetMethods[1]?.ToString()}");
+
+        Type structType = typeof(ExampleStruct);
+
+        map = structType.GetInterfaceMap(interfaceType);
+        Assert.Equal(2, map.InterfaceMethods.Length);
+        Assert.Equal("System.Threading.Tasks.Task TaskReturning() --> System.Threading.Tasks.Task TaskReturning()",
+            $"{map.InterfaceMethods[0]?.ToString()} --> {map.TargetMethods[0]?.ToString()}");
+
+        Assert.Equal("System.Threading.Tasks.Task TReturning() --> System.Threading.Tasks.Task TReturning()",
+            $"{map.InterfaceMethods[1]?.ToString()} --> {map.TargetMethods[1]?.ToString()}");
+    }
 }