Fix optimizations for comparers corner cases in native AOT (#89829)

jkotas · web-flow · commit 41b8bc43b675 · 2023-08-02T15:16:44.000-07:00
Fixes #89767
diff --git a/src/coreclr/tools/Common/TypeSystem/IL/NativeAotILProvider.cs b/src/coreclr/tools/Common/TypeSystem/IL/NativeAotILProvider.cs
@@ -245,26 +245,9 @@ private static MethodIL TryGetPerInstantiationIntrinsicMethodIL(MethodDesc metho
                             {
                                 Debug.Assert(elementType.IsValueType);
 
-                                TypeSystemContext context = elementType.Context;
-                                MetadataType helperType = context.SystemModule.GetKnownType("Internal.IntrinsicSupport", "EqualityComparerHelpers");
-
-                                MethodDesc methodToCall;
-                                if (elementType.IsEnum)
-                                {
-                                    methodToCall = helperType.GetKnownMethod("EnumOnlyEquals", null).MakeInstantiatedMethod(elementType);
-                                }
-                                else if (elementType.IsNullable && ComparerIntrinsics.ImplementsIEquatable(elementType.Instantiation[0]))
-                                {
-                                    methodToCall = helperType.GetKnownMethod("StructOnlyEqualsNullable", null).MakeInstantiatedMethod(elementType.Instantiation[0]);
-                                }
-                                else if (ComparerIntrinsics.ImplementsIEquatable(elementType))
-                                {
-                                    methodToCall = helperType.GetKnownMethod("StructOnlyEqualsIEquatable", null).MakeInstantiatedMethod(elementType);
-                                }
-                                else
-                                {
-                                    methodToCall = helperType.GetKnownMethod("StructOnlyNormalEquals", null).MakeInstantiatedMethod(elementType);
-                                }
+                                MethodDesc methodToCall = GetMethodToCall(elementType);
+                                if (methodToCall == null)
+                                    return null;
 
                                 return new ILStubMethodIL(method, new byte[]
                                 {
@@ -274,6 +257,31 @@ private static MethodIL TryGetPerInstantiationIntrinsicMethodIL(MethodDesc metho
                                     (byte)ILOpcode.ret
                                 },
                                 Array.Empty<LocalVariableDefinition>(), new object[] { methodToCall });
+
+                                static MethodDesc GetMethodToCall(TypeDesc elementType)
+                                {
+                                    TypeSystemContext context = elementType.Context;
+                                    MetadataType helperType = context.SystemModule.GetKnownType("Internal.IntrinsicSupport", "EqualityComparerHelpers");
+
+                                    if (elementType.IsEnum)
+                                        return helperType.GetKnownMethod("EnumOnlyEquals", null)
+                                            .MakeInstantiatedMethod(elementType);
+
+                                    if (elementType.IsNullable)
+                                    {
+                                        bool? nullableOfEquatable = ComparerIntrinsics.ImplementsIEquatable(elementType.Instantiation[0]);
+                                        if (nullableOfEquatable.HasValue && nullableOfEquatable.Value)
+                                            return helperType.GetKnownMethod("StructOnlyEqualsNullable", null)
+                                                .MakeInstantiatedMethod(elementType.Instantiation[0]);
+                                        return null; // Fallback to default implementation based on EqualityComparer
+                                    }
+
+                                    bool? equatable = ComparerIntrinsics.ImplementsIEquatable(elementType);
+                                    if (!equatable.HasValue)
+                                        return null;
+                                    return helperType.GetKnownMethod(equatable.Value ? "StructOnlyEqualsIEquatable" : "StructOnlyNormalEquals", null)
+                                        .MakeInstantiatedMethod(elementType);
+                                }
                             }
                         }
                     }
diff --git a/src/coreclr/tools/Common/TypeSystem/IL/Stubs/ComparerIntrinsics.cs b/src/coreclr/tools/Common/TypeSystem/IL/Stubs/ComparerIntrinsics.cs
@@ -85,33 +85,28 @@ private static InstantiatedType GetComparerForType(TypeDesc type, string flavor,
                 // The comparer will be determined at runtime. We can't tell the exact type at compile time.
                 return null;
             }
-            else if (type.IsNullable)
-            {
-                TypeDesc nullableType = type.Instantiation[0];
-
-                if (context.IsCanonicalDefinitionType(nullableType, CanonicalFormKind.Universal))
-                {
-                    // We can't tell at compile time either.
-                    return null;
-                }
 
+            if (type.IsNullable)
+            {
                 return context.SystemModule.GetKnownType("System.Collections.Generic", $"Nullable{flavor}`1")
-                    .MakeInstantiatedType(nullableType);
+                    .MakeInstantiatedType(type.Instantiation[0]);
             }
-            else if (type.IsEnum)
+
+            if (type.IsEnum)
             {
                 // Enums have a specialized comparer that avoids boxing
                 return context.SystemModule.GetKnownType("System.Collections.Generic", $"Enum{flavor}`1")
                     .MakeInstantiatedType(type);
             }
-            else if (ImplementsInterfaceOfSelf(type, interfaceName))
+
+            bool? implementsInterfaceOfSelf = ImplementsInterfaceOfSelf(type, interfaceName);
+            if (!implementsInterfaceOfSelf.HasValue)
             {
-                return context.SystemModule.GetKnownType("System.Collections.Generic", $"Generic{flavor}`1")
-                    .MakeInstantiatedType(type);
+                return null;
             }
 
-            return context.SystemModule.GetKnownType("System.Collections.Generic", $"Object{flavor}`1")
-                    .MakeInstantiatedType(type);
+            return context.SystemModule.GetKnownType("System.Collections.Generic", implementsInterfaceOfSelf.Value ? $"Generic{flavor}`1" : $"Object{flavor}`1")
+                .MakeInstantiatedType(type);
         }
 
         public static TypeDesc[] GetPotentialComparersForType(TypeDesc type)
@@ -194,27 +189,49 @@ private static TypeDesc[] GetPotentialComparersForTypeCommon(TypeDesc type, stri
             };
         }
 
-        public static bool ImplementsIEquatable(TypeDesc type)
+        public static bool? ImplementsIEquatable(TypeDesc type)
             => ImplementsInterfaceOfSelf(type, "IEquatable`1");
 
-        private static bool ImplementsInterfaceOfSelf(TypeDesc type, string interfaceName)
+        private static bool? ImplementsInterfaceOfSelf(TypeDesc type, string interfaceName)
         {
             MetadataType interfaceType = null;
+            bool canonicalSubtype = false;
 
+            if (type.IsCanonicalSubtype(CanonicalFormKind.Any))
+            {
+                type = type.GetTypeDefinition();
+                canonicalSubtype = true;
+            }
+
+            bool candidateFound = false;
             foreach (TypeDesc implementedInterface in type.RuntimeInterfaces)
             {
                 Instantiation interfaceInstantiation = implementedInterface.Instantiation;
-                if (interfaceInstantiation.Length == 1 &&
-                    interfaceInstantiation[0] == type)
+                if (interfaceInstantiation.Length == 1)
                 {
                     interfaceType ??= interfaceType = type.Context.SystemModule.GetKnownType("System", interfaceName);
 
                     if (implementedInterface.GetTypeDefinition() == interfaceType)
-                        return true;
+                    {
+                        // Exact match
+                        if (interfaceInstantiation[0] == type)
+                            return true;
+
+                        candidateFound = true;
+                        break;
+                    }
                 }
             }
 
-            return false;
+            if (!candidateFound)
+                return false;
+
+            // Try inexact match
+            if (type.CanCastTo(interfaceType.MakeInstantiatedType(type)))
+                return true;
+
+            // Specific instantiation of the canonical subtype may implement the interface.
+            return canonicalSubtype ? null : false;
         }
 
         public static bool CanCompareValueTypeBits(MetadataType type, MethodDesc objectEqualsMethod)
diff --git a/src/coreclr/tools/Common/TypeSystem/IL/Stubs/RuntimeHelpersIntrinsics.cs b/src/coreclr/tools/Common/TypeSystem/IL/Stubs/RuntimeHelpersIntrinsics.cs
@@ -84,13 +84,18 @@ public static MethodIL EmitIL(MethodDesc method)
                             {
                                 result = true;
                             }
-                            else if (mdType.IsValueType && !ComparerIntrinsics.ImplementsIEquatable(mdType.GetTypeDefinition()))
+                            else if (mdType.IsValueType)
                             {
-                                // Value type that can use memcmp and that doesn't override object.Equals or implement IEquatable<T>.Equals.
-                                MethodDesc objectEquals = mdType.Context.GetWellKnownType(WellKnownType.Object).GetMethod("Equals", null);
-                                result =
-                                    mdType.FindVirtualFunctionTargetMethodOnObjectType(objectEquals).OwningType != mdType &&
-                                    ComparerIntrinsics.CanCompareValueTypeBits(mdType, objectEquals);
+                                bool? equatable = ComparerIntrinsics.ImplementsIEquatable(mdType.GetTypeDefinition());
+
+                                if (equatable.HasValue && !equatable.Value)
+                                {
+                                    // Value type that can use memcmp and that doesn't override object.Equals or implement IEquatable<T>.Equals.
+                                    MethodDesc objectEquals = mdType.Context.GetWellKnownType(WellKnownType.Object).GetMethod("Equals", null);
+                                    result =
+                                        mdType.FindVirtualFunctionTargetMethodOnObjectType(objectEquals).OwningType != mdType &&
+                                        ComparerIntrinsics.CanCompareValueTypeBits(mdType, objectEquals);
+                                }
                             }
                         }
                         break;
