Don't report dependency on canonical forms just because there's GVMs

src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/DependencyAnalysis/EETypeNode.cs

@@ -234,8 +234,7 @@ public static int GetMinimumObjectSize(TypeSystemContext typeSystemContext)
 
         protected virtual bool EmitVirtualSlots => false;
 
-        public override bool InterestingForDynamicDependencyAnalysis
-            => (_virtualMethodAnalysisFlags & VirtualMethodAnalysisFlags.InterestingForDynamicDependencies) != 0;
+        public override bool InterestingForDynamicDependencyAnalysis => false;
 
         internal bool HasOptionalFields
         {
@@ -624,10 +623,11 @@ protected override DependencyList ComputeNonRelocationBasedDependencies(NodeFact
                     dependencies.Add(new DependencyListEntry(factory.TypeGVMEntries(_type.GetTypeDefinition()), "Type with generic virtual methods"));
 
                     AddDependenciesForUniversalGVMSupport(factory, _type, ref dependencies);
+                }
 
-                    TypeDesc canonicalType = _type.ConvertToCanonForm(CanonicalFormKind.Specific);
-                    if (canonicalType != _type)
-                        dependencies.Add(factory.ConstructedTypeSymbol(canonicalType), "Type with generic virtual methods");
+                if ((_virtualMethodAnalysisFlags & VirtualMethodAnalysisFlags.InterestingForDynamicDependencies) != 0)
+                {
+                    dependencies.Add(factory.TypeWithGenericVirtualMethods(_type), "Type with generic virtual methods");
                 }
             }
 

src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/DependencyAnalysis/GVMDependenciesNode.cs

@@ -73,21 +73,10 @@ public override IEnumerable<CombinedDependencyListEntry> SearchDynamicDependenci
             for (int i = firstNode; i < markedNodes.Count; i++)
             {
                 DependencyNodeCore<NodeFactory> entry = markedNodes[i];
-                EETypeNode entryAsEETypeNode;
-
-                // This method is often called with a long list of ScannedMethodNode
-                // or MethodCodeNode nodes. We are not interested in those. In order
-                // to make the type check as cheap as possible we check for specific
-                // *sealed* types instead of doing `entry is EETypeNode` which has
-                // to walk the whole class hierarchy for the non matching nodes.
-                if (entry is ConstructedEETypeNode constructedEETypeNode)
-                    entryAsEETypeNode = constructedEETypeNode;
-                else if (entry is CanonicalEETypeNode canonicalEETypeNode)
-                    entryAsEETypeNode = canonicalEETypeNode;
-                else
+                if (entry is not TypeWithGenericVirtualMethodsNode gvmType)
                     continue;
 
-                TypeDesc potentialOverrideType = entryAsEETypeNode.Type;
+                TypeDesc potentialOverrideType = gvmType.Type;
                 if (!potentialOverrideType.IsDefType || potentialOverrideType.IsInterface)
                     continue;
 

src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/DependencyAnalysis/NodeFactory.cs

@@ -301,6 +301,11 @@ private void CreateNodeCaches()
                 return new GenericMethodsHashtableEntryNode(method);
             });
 
+            _typesWithGvms = new NodeCache<TypeDesc, TypeWithGenericVirtualMethodsNode>(type =>
+            {
+                return new TypeWithGenericVirtualMethodsNode(type);
+            });
+
             _gvmTableEntries = new NodeCache<TypeDesc, TypeGVMEntriesNode>(type =>
             {
                 return new TypeGVMEntriesNode(type);
@@ -1007,6 +1012,12 @@ public GenericMethodsHashtableEntryNode GenericMethodsHashtableEntry(MethodDesc
             return _genericMethodEntries.GetOrAdd(method);
         }
 
+        private NodeCache<TypeDesc, TypeWithGenericVirtualMethodsNode> _typesWithGvms;
+        internal TypeWithGenericVirtualMethodsNode TypeWithGenericVirtualMethods(TypeDesc type)
+        {
+            return _typesWithGvms.GetOrAdd(type);
+        }
+
         private NodeCache<TypeDesc, TypeGVMEntriesNode> _gvmTableEntries;
         internal TypeGVMEntriesNode TypeGVMEntries(TypeDesc type)
         {

src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/DependencyAnalysis/TypeWithGenericVirtualMethodsNode.cs

@@ -0,0 +1,39 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections.Generic;
+
+using Internal.TypeSystem;
+
+using ILCompiler.DependencyAnalysisFramework;
+
+namespace ILCompiler.DependencyAnalysis
+{
+    internal sealed class TypeWithGenericVirtualMethodsNode : DependencyNodeCore<NodeFactory>
+    {
+        private readonly TypeDesc _type;
+
+        public TypeWithGenericVirtualMethodsNode(TypeDesc type)
+        {
+            _type = type;
+        }
+
+        public TypeDesc Type => _type;
+
+        public override IEnumerable<DependencyListEntry> GetStaticDependencies(NodeFactory factory)
+        {
+            TypeDesc canonType = _type.ConvertToCanonForm(CanonicalFormKind.Specific);
+            if (_type != canonType)
+                return [new DependencyListEntry(factory.TypeWithGenericVirtualMethods(canonType), "Canonical form")];
+            return null;
+        }
+
+        public override bool HasConditionalStaticDependencies => false;
+        public override bool HasDynamicDependencies => false;
+        public override bool InterestingForDynamicDependencyAnalysis => true;
+        public override bool StaticDependenciesAreComputed => true;
+        protected override string GetName(NodeFactory factory) => $"Generic virtual method analysis for {_type}";
+        public override IEnumerable<CombinedDependencyListEntry> GetConditionalStaticDependencies(NodeFactory context) => null;
+        public override IEnumerable<CombinedDependencyListEntry> SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, NodeFactory context) => null;
+    }
+}

src/coreclr/tools/aot/ILCompiler.Compiler/ILCompiler.Compiler.csproj

@@ -442,6 +442,7 @@
     <Compile Include="Compiler\DependencyAnalysis\TentativeInstanceMethodNode.cs" />
     <Compile Include="Compiler\DependencyAnalysis\TentativeMethodNode.cs" />
     <Compile Include="Compiler\DependencyAnalysis\TrimmingDescriptorNode.cs" />
+    <Compile Include="Compiler\DependencyAnalysis\TypeWithGenericVirtualMethodsNode.cs" />
     <Compile Include="Compiler\DependencyAnalysis\VariantInterfaceMethodUseNode.cs" />
     <Compile Include="Compiler\DependencyAnalysis\CustomAttributeBasedDependencyAlgorithm.cs" />
     <Compile Include="Compiler\DependencyAnalysis\FieldMetadataNode.cs" />