From 58cd6d194ac0ba5bda390ef9d2dd2fce9f4c7214 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Michal=20Strehovsk=C3=BD?=
 <MichalStrehovsky@users.noreply.github.com>
Date: Thu, 16 Jan 2025 13:54:44 +0100
Subject: [PATCH 1/2] Don't report interfaces with optimized-away MT as "never
 instantiated"

---
 .../Compiler/DevirtualizationManager.cs       | 15 ++++++++++++
 .../Compiler/Compilation.cs                   | 10 ++++++++
 .../ILCompiler.Compiler/Compiler/ILScanner.cs | 23 +++++++++++++++++++
 .../JitInterface/CorInfoImpl.RyuJit.cs        | 13 +++++++++++
 4 files changed, 61 insertions(+)

diff --git a/src/coreclr/tools/Common/Compiler/DevirtualizationManager.cs b/src/coreclr/tools/Common/Compiler/DevirtualizationManager.cs
index 5574a9f8aa100f..7d1c3be1de42a9 100644
--- a/src/coreclr/tools/Common/Compiler/DevirtualizationManager.cs
+++ b/src/coreclr/tools/Common/Compiler/DevirtualizationManager.cs
@@ -208,6 +208,12 @@ protected virtual MethodDesc ResolveVirtualMethod(MethodDesc declMethod, DefType
         /// </summary>
         public virtual bool CanReferenceConstructedMethodTable(TypeDesc type) => true;
 
+        /// <summary>
+        /// Gets a value indicating whether it might be possible that the interface type is implemented by a constructed type data structure
+        /// in this compilation. Note that the MethodTable for the interface itself could still be optimized away.
+        /// </summary>
+        public virtual bool CanInterfaceBeImplementedByConstructedMethodTable(TypeDesc type) => true;
+
         /// <summary>
         /// Gets a value indicating whether a (potentially canonically-equlivalent) constructed MethodTable could
         /// exist. This is similar to <see cref="CanReferenceConstructedMethodTable"/>, but will return true
@@ -215,6 +221,15 @@ protected virtual MethodDesc ResolveVirtualMethod(MethodDesc declMethod, DefType
         /// </summary>
         public virtual bool CanReferenceConstructedTypeOrCanonicalFormOfType(TypeDesc type) => true;
 
+        /// <summary>
+        /// Gets a value indicating whether it might be possible that the interface type is implemented by a constructed type data structure
+        /// in this compilation. Note that the MethodTable for the interface itself could still be optimized away.
+        /// Similar to <see cref="CanInterfaceBeImplementedByConstructedMethodTable"/> but will return true for
+        /// IInterface&lt;__Canon&gt; if IInterface&lt;String&gt; could be implemented.
+        /// </summary>
+        public virtual bool CanInterfaceOrCanonicalFormOfItBeImplementedByConstructedMethodTable(TypeDesc type) => true;
+
+
         public virtual TypeDesc[] GetImplementingClasses(TypeDesc type) => null;
 #endif
     }
diff --git a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Compilation.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Compilation.cs
index 6a542d8d00a748..4673b0f7b18421 100644
--- a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Compilation.cs
+++ b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Compilation.cs
@@ -108,11 +108,21 @@ public bool CanReferenceConstructedMethodTable(TypeDesc type)
             return NodeFactory.DevirtualizationManager.CanReferenceConstructedMethodTable(type.NormalizeInstantiation());
         }
 
+        public bool CanInterfaceBeImplementedByConstructedMethodTable(TypeDesc type)
+        {
+            return NodeFactory.DevirtualizationManager.CanInterfaceBeImplementedByConstructedMethodTable(type.NormalizeInstantiation());
+        }
+
         public bool CanReferenceConstructedTypeOrCanonicalFormOfType(TypeDesc type)
         {
             return NodeFactory.DevirtualizationManager.CanReferenceConstructedTypeOrCanonicalFormOfType(type.NormalizeInstantiation());
         }
 
+        public bool CanInterfaceOrCanonicalFormOfItBeImplementedByConstructedMethodTable(TypeDesc type)
+        {
+            return NodeFactory.DevirtualizationManager.CanInterfaceOrCanonicalFormOfItBeImplementedByConstructedMethodTable(type.NormalizeInstantiation());
+        }
+
         public DelegateCreationInfo GetDelegateCtor(TypeDesc delegateType, MethodDesc target, TypeDesc constrainedType, bool followVirtualDispatch)
         {
             // If we're creating a delegate to a virtual method that cannot be overridden, devirtualize.
diff --git a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/ILScanner.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/ILScanner.cs
index 4d9328f1a34eef..954ae7b92b256e 100644
--- a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/ILScanner.cs
+++ b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/ILScanner.cs
@@ -438,6 +438,8 @@ private sealed class ScannedDevirtualizationManager : DevirtualizationManager
             private HashSet<TypeDesc> _constructedMethodTables = new HashSet<TypeDesc>();
             private HashSet<TypeDesc> _canonConstructedMethodTables = new HashSet<TypeDesc>();
             private HashSet<TypeDesc> _canonConstructedTypes = new HashSet<TypeDesc>();
+            private HashSet<TypeDesc> _implementedInterfaces = new HashSet<TypeDesc>();
+            private HashSet<TypeDesc> _canonImplementedInterfaces = new HashSet<TypeDesc>();
             private HashSet<TypeDesc> _unsealedTypes = new HashSet<TypeDesc>();
             private Dictionary<TypeDesc, HashSet<TypeDesc>> _implementators = new();
             private HashSet<TypeDesc> _disqualifiedTypes = new();
@@ -507,6 +509,13 @@ public ScannedDevirtualizationManager(NodeFactory factory, ImmutableArray<Depend
                                     {
                                         RecordImplementation(baseInterface, type);
                                     }
+
+                                    if (_implementedInterfaces.Add(baseInterface))
+                                    {
+                                        TypeDesc canonBaseInterface = baseInterface.ConvertToCanonForm(CanonicalFormKind.Specific);
+                                        if (baseInterface != canonBaseInterface)
+                                            _canonImplementedInterfaces.Add(canonBaseInterface);
+                                    }
                                 }
 
                                 // Record all base types of this class
@@ -729,6 +738,13 @@ public override bool CanReferenceConstructedMethodTable(TypeDesc type)
                 return _constructedMethodTables.Contains(type);
             }
 
+            public override bool CanInterfaceBeImplementedByConstructedMethodTable(TypeDesc type)
+            {
+                Debug.Assert(type.NormalizeInstantiation() == type);
+                Debug.Assert(type.IsInterface);
+                return _implementedInterfaces.Contains(type);
+            }
+
             public override bool CanReferenceConstructedTypeOrCanonicalFormOfType(TypeDesc type)
             {
                 Debug.Assert(type.NormalizeInstantiation() == type);
@@ -736,6 +752,13 @@ public override bool CanReferenceConstructedTypeOrCanonicalFormOfType(TypeDesc t
                 return _constructedMethodTables.Contains(type) || _canonConstructedMethodTables.Contains(type);
             }
 
+            public override bool CanInterfaceOrCanonicalFormOfItBeImplementedByConstructedMethodTable(TypeDesc type)
+            {
+                Debug.Assert(type.NormalizeInstantiation() == type);
+                Debug.Assert(type.IsInterface);
+                return _implementedInterfaces.Contains(type) || _canonImplementedInterfaces.Contains(type);
+            }
+
             public override TypeDesc[] GetImplementingClasses(TypeDesc type)
             {
                 if (_disqualifiedTypes.Contains(type))
diff --git a/src/coreclr/tools/aot/ILCompiler.RyuJit/JitInterface/CorInfoImpl.RyuJit.cs b/src/coreclr/tools/aot/ILCompiler.RyuJit/JitInterface/CorInfoImpl.RyuJit.cs
index 34c5a1a3b16cc0..96169cce8aa08a 100644
--- a/src/coreclr/tools/aot/ILCompiler.RyuJit/JitInterface/CorInfoImpl.RyuJit.cs
+++ b/src/coreclr/tools/aot/ILCompiler.RyuJit/JitInterface/CorInfoImpl.RyuJit.cs
@@ -2243,6 +2243,19 @@ private bool CanNeverHaveInstanceOfSubclassOf(TypeDesc type)
 
             TypeDesc canonType = type.ConvertToCanonForm(CanonicalFormKind.Specific);
 
+            // Interface optimization may be able to remove MethodTable of interfaces if they were never actually
+            // used to call/cast. Since getExactClasses can be called for things like "is a location of this
+            // type ever going to be non-null", we need to make sure the ability to optimize the interface MethodTable away
+            // doesn't lead to saying "this will always be null".
+            if (type.IsInterface)
+            {
+                if (_compilation.CanInterfaceOrCanonicalFormOfItBeImplementedByConstructedMethodTable(type)
+                    || (type != canonType && _compilation.CanInterfaceBeImplementedByConstructedMethodTable(canonType)))
+                {
+                    return false;
+                }
+            }
+
             // If we don't have a constructed MethodTable for the exact type or for its template,
             // this type or any of its subclasses can never be instantiated.
             return !_compilation.CanReferenceConstructedTypeOrCanonicalFormOfType(type)

From 9c25caa772ca080788bf621585c3c1a0763bcab6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Michal=20Strehovsk=C3=BD?=
 <MichalStrehovsky@users.noreply.github.com>
Date: Fri, 17 Jan 2025 06:40:33 +0100
Subject: [PATCH 2/2] Hmm

---
 .../aot/ILCompiler.RyuJit/JitInterface/CorInfoImpl.RyuJit.cs  | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/coreclr/tools/aot/ILCompiler.RyuJit/JitInterface/CorInfoImpl.RyuJit.cs b/src/coreclr/tools/aot/ILCompiler.RyuJit/JitInterface/CorInfoImpl.RyuJit.cs
index 96169cce8aa08a..36ddc60294a684 100644
--- a/src/coreclr/tools/aot/ILCompiler.RyuJit/JitInterface/CorInfoImpl.RyuJit.cs
+++ b/src/coreclr/tools/aot/ILCompiler.RyuJit/JitInterface/CorInfoImpl.RyuJit.cs
@@ -2241,6 +2241,10 @@ private bool CanNeverHaveInstanceOfSubclassOf(TypeDesc type)
             if (!ConstructedEETypeNode.CreationAllowed(type))
                 return false;
 
+            // TODO: rather conservative
+            if (type.HasVariance)
+                return false;
+
             TypeDesc canonType = type.ConvertToCanonForm(CanonicalFormKind.Specific);
 
             // Interface optimization may be able to remove MethodTable of interfaces if they were never actually