Limit expansion in TemplateConstructableTypes

The template type loader is a limited type loader that we use in native AOT to support scenarios such as `MakeGenericType`. We keep around extra MethodTables and metadata to be able to construct new type instantiations (e.g. `List<string>`) at runtime from template instantiations (e.g. `List<__Canon>`) we made at compile time.

The template instantiation is a `MethodTable` like any other that we make a copy of and patch up with the help of the metadata ("native layout metadata"). Patching up involves e.g. building interface list (`List<string>` should have `IList<string>` in the interface list). This patching up may involve loading more new types from templates (e.g. the mentioned `IList<string>` that needs to be loadable from a `IList<__Canon>` template MethodTable).

The job of the compiler is to figure out all the templates we might need (recursively) to build a type. This is done in places using a rather non-exact `TemplateConstructableTypes` call that just decomposes the type and makes templates for _everything_. Some of these might not be actually needed.

This is an attempt to somewhat limit it.

Author: MichalStrehovsky

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

@@ -650,27 +650,6 @@ protected override IMethodNode GetMethodEntrypointNode(NodeFactory factory)
             IMethodNode methodEntryPointNode = factory.AddressTakenMethodEntrypoint(_method, IsUnboxingStub);
             return methodEntryPointNode;
         }
-
-        public override IEnumerable<DependencyListEntry> GetStaticDependencies(NodeFactory context)
-        {
-            DependencyList dependencies = (DependencyList)base.GetStaticDependencies(context);
-
-            foreach (var arg in _method.Instantiation)
-            {
-                foreach (var dependency in context.NativeLayout.TemplateConstructableTypes(arg))
-                {
-                    dependencies.Add(new DependencyListEntry(dependency, "Dependencies to make a generic method template viable Method Instantiation"));
-                }
-            }
-
-
-            foreach (var dependency in context.NativeLayout.TemplateConstructableTypes(_method.OwningType))
-            {
-                dependencies.Add(new DependencyListEntry(dependency, "Dependencies to make a generic method template viable OwningType"));
-            }
-
-            return dependencies;
-        }
     }
 
     public sealed class NativeLayoutDictionarySignatureNode : NativeLayoutSavedVertexNode
@@ -788,19 +767,6 @@ public NativeLayoutTemplateMethodLayoutVertexNode(NodeFactory factory, MethodDes
 
         public override IEnumerable<DependencyListEntry> GetStaticDependencies(NodeFactory context)
         {
-            foreach (var dependency in context.NativeLayout.TemplateConstructableTypes(_method.OwningType))
-            {
-                yield return new DependencyListEntry(dependency, "method OwningType itself must be template loadable");
-            }
-
-            foreach (var type in _method.Instantiation)
-            {
-                foreach (var dependency in context.NativeLayout.TemplateConstructableTypes(type))
-                {
-                    yield return new DependencyListEntry(dependency, "method's instantiation arguments must be template loadable");
-                }
-            }
-
             foreach (GenericParameterDesc genericParam in _method.GetTypicalMethodDefinition().Instantiation)
             {
                 foreach (TypeDesc typeConstraint in genericParam.TypeConstraints)
@@ -1103,6 +1069,7 @@ public abstract class NativeLayoutTypeSignatureBasedGenericDictionarySlotNode :
 
         public NativeLayoutTypeSignatureBasedGenericDictionarySlotNode(NodeFactory factory, TypeDesc type)
         {
+            Debug.Assert(type.IsRuntimeDeterminedSubtype);
             _signature = factory.NativeLayout.TypeSignatureVertex(type);
             _type = type;
         }
@@ -1239,6 +1206,7 @@ public sealed class NativeLayoutInterfaceDispatchGenericDictionarySlotNode : Nat
 
         public NativeLayoutInterfaceDispatchGenericDictionarySlotNode(NodeFactory factory, MethodDesc method)
         {
+            Debug.Assert(method.IsRuntimeDeterminedExactMethod);
             _signature = factory.NativeLayout.TypeSignatureVertex(method.OwningType);
             _method = method;
         }
@@ -1250,16 +1218,14 @@ public sealed override IEnumerable<DependencyListEntry> GetStaticDependencies(No
         {
             yield return new DependencyListEntry(_signature, "TypeSignature");
 
-            MethodDesc method = _method;
-            if (method.IsRuntimeDeterminedExactMethod)
-                method = method.GetCanonMethodTarget(CanonicalFormKind.Specific);
+            MethodDesc canonMethod = _method.GetCanonMethodTarget(CanonicalFormKind.Specific);
 
-            if (!factory.VTable(method.OwningType).HasKnownVirtualMethodUse)
+            if (!factory.VTable(canonMethod.OwningType).HasKnownVirtualMethodUse)
             {
-                yield return new DependencyListEntry(factory.VirtualMethodUse(method), "Slot number");
+                yield return new DependencyListEntry(factory.VirtualMethodUse(canonMethod), "Slot number");
             }
 
-            foreach (var dependency in factory.NativeLayout.TemplateConstructableTypes(method.OwningType))
+            foreach (var dependency in factory.NativeLayout.TemplateConstructableTypes(_method.OwningType))
             {
                 yield return new DependencyListEntry(dependency, "template construction dependency");
             }

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

@@ -150,6 +150,12 @@ private void CreateNodeCaches()
             // of just necessary. (Which is what the actual templates signatures will ensure)
             public IEnumerable<IDependencyNode> TemplateConstructableTypes(TypeDesc type)
             {
+                if (!type.IsRuntimeDeterminedSubtype)
+                {
+                    yield return _factory.MaximallyConstructableType(type);
+                    yield break;
+                }
+
                 // Array types are the only parameterized types that have templates
                 if (type.IsSzArray && !type.IsArrayTypeWithoutGenericInterfaces())
                 {
@@ -160,8 +166,6 @@ public IEnumerable<IDependencyNode> TemplateConstructableTypes(TypeDesc type)
                     {
                         yield return _factory.NativeLayout.TemplateTypeLayout(arrayCanonicalType);
                     }
-
-                    yield return _factory.MaximallyConstructableType(arrayCanonicalType);
                 }
 
                 while (type.IsParameterizedType)
@@ -184,7 +188,6 @@ public IEnumerable<IDependencyNode> TemplateConstructableTypes(TypeDesc type)
                 }
 
                 TypeDesc canonicalType = type.ConvertToCanonForm(CanonicalFormKind.Specific);
-                yield return _factory.MaximallyConstructableType(canonicalType);
 
                 // Add a dependency on the template for this type, if the canonical type should be generated into this binary.
                 if (canonicalType.IsCanonicalSubtype(CanonicalFormKind.Any) && !_factory.NecessaryTypeSymbol(canonicalType).RepresentsIndirectionCell)