Fix variant interface GVM resolution in managed type system

src/coreclr/tools/Common/Compiler/DevirtualizationManager.cs

@@ -100,7 +100,9 @@ protected virtual MethodDesc ResolveVirtualMethod(MethodDesc declMethod, DefType
                     return null;
                 }
 
-                impl = implType.ResolveInterfaceMethodTargetWithVariance(declMethod);
+                // Strip the method instantation as interface slot resolution works on method definitions.
+                // Method instantiation will be applied again after resolution.
+                impl = implType.ResolveInterfaceMethodTargetWithVariance(declMethod.GetMethodDefinition());
 
                 if (impl != null)
                 {

src/coreclr/tools/aot/ILCompiler.Compiler.Tests/DevirtualizationTests.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Collections.Generic;
+using System.Linq;
 
 using Internal.IL;
 using Internal.TypeSystem;
@@ -66,5 +67,40 @@ public void TestDevirtualizeAbstract()
 
             Assert.False(scanDevirt.IsEffectivelySealed(testType.GetNestedType("Abstract"u8)));
         }
+
+        [Fact]
+        public void TestVariantInterfaceGenericMethodResolution()
+        {
+            DefType objectType = _context.GetWellKnownType(WellKnownType.Object);
+            MetadataType baseType = _testModule.GetType("GvmVariantInterface"u8, "GvmVariantBase"u8);
+            MetadataType derivedType = _testModule.GetType("GvmVariantInterface"u8, "GvmVariantDerived"u8);
+            MetadataType implementationType = _testModule.GetType("GvmVariantInterface"u8, "ClassWithVariantGvms"u8);
+
+            MetadataType inVariantType = _testModule.GetType("GvmVariantInterface"u8, "IInVariantGvm`1"u8);
+            MetadataType outVariantType = _testModule.GetType("GvmVariantInterface"u8, "IOutVariantGvm`1"u8);
+
+            MethodDesc inObjectMethod = inVariantType.MakeInstantiatedType(objectType).GetMethods().Single(m => m.GetName() == "Func").MakeInstantiatedMethod(objectType);
+            MethodDesc inBaseMethod = inVariantType.MakeInstantiatedType(baseType).GetMethods().Single(m => m.GetName() == "Func").MakeInstantiatedMethod(objectType);
+            MethodDesc inDerivedMethod = inVariantType.MakeInstantiatedType(derivedType).GetMethods().Single(m => m.GetName() == "Func").MakeInstantiatedMethod(objectType);
+            MethodDesc outObjectMethod = outVariantType.MakeInstantiatedType(objectType).GetMethods().Single(m => m.GetName() == "Func").MakeInstantiatedMethod(objectType);
+            MethodDesc outBaseMethod = outVariantType.MakeInstantiatedType(baseType).GetMethods().Single(m => m.GetName() == "Func").MakeInstantiatedMethod(objectType);
+            MethodDesc outDerivedMethod = outVariantType.MakeInstantiatedType(derivedType).GetMethods().Single(m => m.GetName() == "Func").MakeInstantiatedMethod(objectType);
+
+            MethodImplRecord[] methodImpls = implementationType.FindMethodsImplWithMatchingDeclName(inObjectMethod.Name);
+            Assert.NotNull(methodImpls);
+
+            MethodDesc inObjectImpl = methodImpls.Single(m => m.Decl.GetMethodDefinition() == inObjectMethod.GetMethodDefinition()).Body.MakeInstantiatedMethod(objectType);
+            MethodDesc inBaseImpl = methodImpls.Single(m => m.Decl.GetMethodDefinition() == inBaseMethod.GetMethodDefinition()).Body.MakeInstantiatedMethod(objectType);
+            MethodDesc outDerivedImpl = methodImpls.Single(m => m.Decl.GetMethodDefinition() == outDerivedMethod.GetMethodDefinition()).Body.MakeInstantiatedMethod(objectType);
+            MethodDesc outBaseImpl = methodImpls.Single(m => m.Decl.GetMethodDefinition() == outBaseMethod.GetMethodDefinition()).Body.MakeInstantiatedMethod(objectType);
+
+            var devirt = new DevirtualizationManager();
+            Assert.Equal(inObjectImpl, devirt.ResolveVirtualMethod(inObjectMethod, implementationType, out _));
+            Assert.Equal(inBaseImpl, devirt.ResolveVirtualMethod(inBaseMethod, implementationType, out _));
+            Assert.Equal(inObjectImpl, devirt.ResolveVirtualMethod(inDerivedMethod, implementationType, out _));
+            Assert.Equal(outDerivedImpl, devirt.ResolveVirtualMethod(outObjectMethod, implementationType, out _));
+            Assert.Equal(outBaseImpl, devirt.ResolveVirtualMethod(outBaseMethod, implementationType, out _));
+            Assert.Equal(outDerivedImpl, devirt.ResolveVirtualMethod(outDerivedMethod, implementationType, out _));
+        }
     }
 }

src/coreclr/tools/aot/ILCompiler.Compiler.Tests/ILCompiler.Compiler.Tests.Assets/GvmVariantInterface.cs

@@ -0,0 +1,31 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace GvmVariantInterface
+{
+    class GvmVariantBase
+    {
+    }
+
+    class GvmVariantDerived : GvmVariantBase
+    {
+    }
+
+    interface IInVariantGvm<in T>
+    {
+        string Func<U>(T t);
+    }
+
+    interface IOutVariantGvm<out T>
+    {
+        string Func<U>();
+    }
+
+    class ClassWithVariantGvms : IInVariantGvm<object>, IInVariantGvm<GvmVariantBase>, IOutVariantGvm<GvmVariantDerived>, IOutVariantGvm<GvmVariantBase>
+    {
+        string IInVariantGvm<object>.Func<U>(object t) => "CallOnObject";
+        string IInVariantGvm<GvmVariantBase>.Func<U>(GvmVariantBase t) => "CallOnBase";
+        string IOutVariantGvm<GvmVariantDerived>.Func<U>() => "CallOnDerived";
+        string IOutVariantGvm<GvmVariantBase>.Func<U>() => "CallOnBase";
+    }
+}

src/coreclr/tools/aot/ILCompiler.TypeSystem.Tests/CoreTestAssembly/CoreTestAssembly.csproj

@@ -16,4 +16,8 @@
     <!-- This assembly has no LibraryImports and is used as a custom corelib, so disable the generator. -->
     <EnableLibraryImportGenerator>false</EnableLibraryImportGenerator>
   </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Include="..\..\ILCompiler.Compiler.Tests\ILCompiler.Compiler.Tests.Assets\GvmVariantInterface.cs" Link="GvmVariantInterface.cs" />
+  </ItemGroup>
 </Project>

src/coreclr/tools/aot/ILCompiler.TypeSystem.Tests/VirtualFunctionOverrideTests.cs

@@ -72,6 +72,40 @@ public void TestGenericMethodInterfaceMethodImplOverride()
             Assert.Equal(expectedVirtualMethod, objectType.ResolveInterfaceMethodToVirtualMethodOnType(interfaceMethod));
         }
 
+        [Fact]
+        public void TestVariantInterfaceGenericMethodResolution()
+        {
+            DefType objectType = _context.GetWellKnownType(WellKnownType.Object);
+            MetadataType baseType = _testModule.GetType("GvmVariantInterface"u8, "GvmVariantBase"u8);
+            MetadataType derivedType = _testModule.GetType("GvmVariantInterface"u8, "GvmVariantDerived"u8);
+            MetadataType implementationType = _testModule.GetType("GvmVariantInterface"u8, "ClassWithVariantGvms"u8);
+
+            MetadataType inVariantType = _testModule.GetType("GvmVariantInterface"u8, "IInVariantGvm`1"u8);
+            MetadataType outVariantType = _testModule.GetType("GvmVariantInterface"u8, "IOutVariantGvm`1"u8);
+
+            MethodDesc inObjectMethod = inVariantType.MakeInstantiatedType(objectType).GetMethods().Single(m => m.GetName() == "Func");
+            MethodDesc inBaseMethod = inVariantType.MakeInstantiatedType(baseType).GetMethods().Single(m => m.GetName() == "Func");
+            MethodDesc inDerivedMethod = inVariantType.MakeInstantiatedType(derivedType).GetMethods().Single(m => m.GetName() == "Func");
+            MethodDesc outObjectMethod = outVariantType.MakeInstantiatedType(objectType).GetMethods().Single(m => m.GetName() == "Func");
+            MethodDesc outBaseMethod = outVariantType.MakeInstantiatedType(baseType).GetMethods().Single(m => m.GetName() == "Func");
+            MethodDesc outDerivedMethod = outVariantType.MakeInstantiatedType(derivedType).GetMethods().Single(m => m.GetName() == "Func");
+
+            MethodImplRecord[] methodImpls = implementationType.FindMethodsImplWithMatchingDeclName(inObjectMethod.Name);
+            Assert.NotNull(methodImpls);
+
+            MethodDesc inObjectImpl = methodImpls.Single(m => m.Decl.GetMethodDefinition() == inObjectMethod.GetMethodDefinition()).Body;
+            MethodDesc inBaseImpl = methodImpls.Single(m => m.Decl.GetMethodDefinition() == inBaseMethod.GetMethodDefinition()).Body;
+            MethodDesc outDerivedImpl = methodImpls.Single(m => m.Decl.GetMethodDefinition() == outDerivedMethod.GetMethodDefinition()).Body;
+            MethodDesc outBaseImpl = methodImpls.Single(m => m.Decl.GetMethodDefinition() == outBaseMethod.GetMethodDefinition()).Body;
+
+            Assert.Equal(inObjectImpl, implementationType.ResolveVariantInterfaceMethodToVirtualMethodOnType(inObjectMethod));
+            Assert.Equal(inBaseImpl, implementationType.ResolveVariantInterfaceMethodToVirtualMethodOnType(inBaseMethod));
+            Assert.Equal(inObjectImpl, implementationType.ResolveVariantInterfaceMethodToVirtualMethodOnType(inDerivedMethod));
+            Assert.Equal(outDerivedImpl, implementationType.ResolveVariantInterfaceMethodToVirtualMethodOnType(outObjectMethod));
+            Assert.Equal(outBaseImpl, implementationType.ResolveVariantInterfaceMethodToVirtualMethodOnType(outBaseMethod));
+            Assert.Equal(outDerivedImpl, implementationType.ResolveVariantInterfaceMethodToVirtualMethodOnType(outDerivedMethod));
+        }
+
         [Fact]
         public void TestVirtualDispatchOnGenericType()
         {

src/tests/JIT/Generics/Variance/variance_generic_virtual.cs

@@ -0,0 +1,62 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+
+using Xunit;
+
+class Base
+{
+
+}
+
+class Derived : Base
+{
+
+}
+
+interface IInVariant<in T>
+{
+    string Func<U>(T t);
+}
+
+interface IOutVariant<out T>
+{
+    string Func<U>();
+}
+
+class ClassWithVariantGvms : IInVariant<object>, IInVariant<Base>, IOutVariant<Derived>, IOutVariant<Base>
+{
+    string IInVariant<object>.Func<U>(object t)
+    {
+        return "CallOnObject";
+    }
+    string IInVariant<Base>.Func<U>(Base t)
+    {
+        return "CallOnBase";
+    }
+    string IOutVariant<Derived>.Func<U>()
+    {
+        return "CallOnDerived";
+    }
+    string IOutVariant<Base>.Func<U>()
+    {
+        return "CallOnBase";
+    }
+}
+
+public class VarianceGenericVirtual
+{
+    [Fact]
+    public static void TestEntryPoint()
+    {
+        ClassWithVariantGvms testClass = new ClassWithVariantGvms();
+
+        Assert.Equal("CallOnObject", ((IInVariant<object>)testClass).Func<object>(new Derived()));
+        Assert.Equal("CallOnBase", ((IInVariant<Base>)testClass).Func<object>(new Derived()));
+        Assert.Equal("CallOnObject", ((IInVariant<Derived>)testClass).Func<object>(new Derived()));
+
+        Assert.Equal("CallOnDerived", ((IOutVariant<object>)testClass).Func<object>());
+        Assert.Equal("CallOnBase", ((IOutVariant<Base>)testClass).Func<object>());
+        Assert.Equal("CallOnDerived", ((IOutVariant<Derived>)testClass).Func<object>());
+    }
+}

src/tests/JIT/Generics/Variance/variance_generic_virtual.csproj

@@ -0,0 +1,10 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <DebugType>PdbOnly</DebugType>
+    <CLRTestPriority>1</CLRTestPriority>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="variance_generic_virtual.cs" />
+    <ProjectReference Include="$(TestLibraryProjectPath)" />
+  </ItemGroup>
+</Project>

src/tests/JIT/Generics/Variance/variance_generic_virtual_o.csproj

@@ -0,0 +1,11 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <DebugType>PdbOnly</DebugType>
+    <Optimize>True</Optimize>
+    <CLRTestPriority>1</CLRTestPriority>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="variance_generic_virtual.cs" />
+    <ProjectReference Include="$(TestLibraryProjectPath)" />
+  </ItemGroup>
+</Project>