Crossgen2 support for static virtual method resolution (take 2)

src/coreclr/tools/Common/JitInterface/CorInfoTypes.cs

@@ -1365,6 +1365,9 @@ public enum CorInfoTokenKind
 
         // token comes from devirtualizing a method
         CORINFO_TOKENKIND_DevirtualizedMethod = 0x800 | CORINFO_TOKENKIND_Method,
+
+        // token comes from resolved static virtual method
+        CORINFO_TOKENKIND_ResolvedStaticVirtualMethod = 0x1000 | CORINFO_TOKENKIND_Method,
     };
 
     // These are error codes returned by CompileMethod

src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/DelegateCtorSignature.cs

@@ -42,12 +42,20 @@ public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)
             {
                 SignatureContext innerContext = builder.EmitFixup(factory, ReadyToRunFixupKind.DelegateCtor, _methodToken.Token.Module, factory.SignatureContext);
 
+                bool needsInstantiatingStub = _targetMethod.Method.HasInstantiation;
+                if (_targetMethod.Method.IsVirtual && _targetMethod.Method.Signature.IsStatic)
+                {
+                    // For static virtual methods, we always require an instantiating stub as the method may resolve to a canonical representation
+                    // at runtime without us being able to detect that at compile time.
+                    needsInstantiatingStub |= (_targetMethod.Method.OwningType.HasInstantiation || _methodToken.ConstrainedType != null);
+                }
+
                 builder.EmitMethodSignature(
                     _methodToken,
                     enforceDefEncoding: false,
                     enforceOwningType: false,
                     innerContext,
-                    isInstantiatingStub: _targetMethod.Method.HasInstantiation);
+                    isInstantiatingStub: needsInstantiatingStub);
 
                 builder.EmitTypeSignature(_delegateType, innerContext);
             }

src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/GCRefMapNode.cs

@@ -88,12 +88,13 @@ public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)
                 }
                 else
                 {
-                    bool isUnboxingStub = false;
+                    bool isStub = false;
                     if (methodNode is DelayLoadHelperImport methodImport)
                     {
-                        isUnboxingStub = ((MethodFixupSignature)methodImport.ImportSignature.Target).IsUnboxingStub;
+                        MethodFixupSignature signature = (MethodFixupSignature)methodImport.ImportSignature.Target;
+                        isStub = signature.IsUnboxingStub || signature.IsInstantiatingStub;
                     }
-                    builder.GetCallRefMap(methodNode.Method, isUnboxingStub);
+                    builder.GetCallRefMap(methodNode.Method, isStub);
                 }
                 if (methodIndex >= nextMethodIndex)
                 {

src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/Import.cs

@@ -19,6 +19,8 @@ public class Import : EmbeddedObjectNode, ISymbolDefinitionNode, ISortableSymbol
 
         internal readonly MethodDesc CallingMethod;
 
+        public Signature Signature => ImportSignature.Target;
+
         public Import(ImportSectionNode tableNode, Signature importSignature, MethodDesc callingMethod = null)
         {
             Table = tableNode;

src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/MethodFixupSignature.cs

@@ -35,7 +35,7 @@ public MethodFixupSignature(
             compilerContext.EnsureLoadableMethod(method.Method);
             compilerContext.EnsureLoadableType(_method.OwningType);
 
-            if (method.ConstrainedType != null)
+            if (method.ConstrainedType != null && !method.ConstrainedType.IsRuntimeDeterminedSubtype)
                 compilerContext.EnsureLoadableType(method.ConstrainedType);
         }
 
@@ -46,6 +46,10 @@ public MethodFixupSignature(
 
         public bool IsUnboxingStub => _method.Unboxing;
 
+        public TypeDesc ConstrainedType => _method.ConstrainedType;
+
+        public bool NeedsInstantiationArg => _method.ConstrainedType?.IsCanonicalSubtype(CanonicalFormKind.Any) ?? false;
+
         protected override DependencyList ComputeNonRelocationBasedDependencies(NodeFactory factory)
         {
             DependencyList list = base.ComputeNonRelocationBasedDependencies(factory);

src/coreclr/vm/methodtable.cpp

@@ -9242,7 +9242,7 @@ MethodTable::TryResolveConstraintMethodApprox(
     {
         _ASSERTE(!thInterfaceType.IsTypeDesc());
         _ASSERTE(thInterfaceType.IsInterface());
-        BOOL uniqueResolution;
+        BOOL uniqueResolution = TRUE;
 
         ResolveVirtualStaticMethodFlags flags = ResolveVirtualStaticMethodFlags::AllowVariantMatches
                                               | ResolveVirtualStaticMethodFlags::InstantiateResultOverFinalMethodDesc;
@@ -9255,7 +9255,8 @@ MethodTable::TryResolveConstraintMethodApprox(
             thInterfaceType.GetMethodTable(),
             pInterfaceMD,
             flags,
-            &uniqueResolution);
+            (pfForceUseRuntimeLookup != NULL ? &uniqueResolution : NULL));
+
         if (result == NULL || !uniqueResolution)
         {
             _ASSERTE(pfForceUseRuntimeLookup != NULL);

src/tests/Loader/classloader/StaticVirtualMethods/NegativeTestCases/MethodBodyOnUnrelatedType.ilproj

@@ -1,6 +1,9 @@
 <Project Sdk="Microsoft.NET.Sdk.IL">
   <PropertyGroup>
     <OutputType>Exe</OutputType>
+
+    <!-- Crossgen2 currently doesn't support this negative check - that should be fine as runtime behavior is undefined in the presence of invalid IL. -->
+    <CrossGenTest>false</CrossGenTest>
   </PropertyGroup>
   <PropertyGroup>
     <DebugType>Full</DebugType>

src/tests/Loader/classloader/StaticVirtualMethods/Regression/GitHub_70385.il

@@ -15,7 +15,7 @@
   .publickeytoken = (B0 3F 5F 7F 11 D5 0A 3A )                         // .?_....:
   .ver 7:0:0:0
 }
-.assembly RecursiveGeneric
+.assembly GitHub_70385
 {
   .custom instance void [System.Runtime]System.Runtime.CompilerServices.CompilationRelaxationsAttribute::.ctor(int32) = ( 01 00 08 00 00 00 00 00 ) 
   .custom instance void [System.Runtime]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78   // ....T..WrapNonEx
@@ -27,7 +27,7 @@
   .hash algorithm 0x00008004
   .ver 0:0:0:0
 }
-.module RecursiveGeneric.dll
+.module GitHub_70385.dll
 // MVID: {10541B0F-16D6-4F9A-B0EB-E793F524F163}
 .imagebase 0x00400000
 .file alignment 0x00000200

src/tests/readytorun/tests/main.cs

@@ -441,6 +441,19 @@ static void TestILBodyChange()
         Assert.AreEqual(ILInliningTest.TestDifferentIntValue(), actualMethodCallResult);
     }
 
+    private class CallDefaultVsExactStaticVirtual<T> where T : IDefaultVsExactStaticVirtual
+    {
+        public static string CallMethodOnGenericType() => T.Method();
+    }
+
+    [MethodImplAttribute(MethodImplOptions.NoInlining)]
+    static void TestDefaultVsExactStaticVirtualMethodImplementation()
+    {
+        Assert.AreEqual(CallDefaultVsExactStaticVirtual<DefaultVsExactStaticVirtualClass>.CallMethodOnGenericType(), "DefaultVsExactStaticVirtualMethod");
+        // Naively one would expect that the following should do, however Roslyn fails to compile it claiming that the type DVESVC doesn't contain 'Method':
+        // Assert.AreEqual(DefaultVsExactStaticVirtualClass.Method(), "DefaultVsExactStaticVirtualMethod");
+    }
+
     static void RunAllTests()
     {
         Console.WriteLine("TestVirtualMethodCalls");
@@ -527,6 +540,10 @@ static void RunAllTests()
 
         Console.WriteLine("TestILBodyChange");
         TestILBodyChange();
+
+        Console.WriteLine("TestDefaultVsExactStaticVirtualMethodImplementation");
+        TestDefaultVsExactStaticVirtualMethodImplementation();
+
         ILInliningVersioningTest<LocallyDefinedStructure>.RunAllTests(typeof(Program).Assembly);
     }
 

src/tests/readytorun/tests/test.cs

@@ -438,6 +438,24 @@ public static string OpenClosedDelegateTarget(this string x, string foo)
     }
 }
 
+public interface IDefaultVsExactStaticVirtual
+{
+    static virtual string Method() =>
+#if V2
+        "Error - IDefaultVsExactStaticVirtual.Method shouldn't be used in V2"
+#else
+        "DefaultVsExactStaticVirtualMethod"
+#endif
+    ;
+}
+
+public class DefaultVsExactStaticVirtualClass : IDefaultVsExactStaticVirtual
+{
+#if V2
+    static string IDefaultVsExactStaticVirtual.Method() => "DefaultVsExactStaticVirtualMethod";
+#endif
+}
+
 // Test dependent versioning details
 public class ILInliningVersioningTest<T>
 {