Implement IAlternateEqualityComparer<ReadOnlySpan<char>, string> on EqualityComparer<string>.Default

stephentoub · stephentoub · commit b627e2c23eda · 2024-06-29T23:32:46.000-04:00
diff --git a/src/coreclr/System.Private.CoreLib/src/System/Collections/Generic/ComparerHelpers.cs b/src/coreclr/System.Private.CoreLib/src/System/Collections/Generic/ComparerHelpers.cs
@@ -68,7 +68,7 @@ internal static object CreateDefaultEqualityComparer(Type type)
 
             if (type == typeof(string))
             {
-                return new GenericEqualityComparer<string>();
+                return new StringEqualityComparer();
             }
             else if (type.IsAssignableTo(typeof(IEquatable<>).MakeGenericType(type)))
             {
diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/Internal/IntrinsicSupport/EqualityComparerHelpers.cs b/src/coreclr/nativeaot/System.Private.CoreLib/src/Internal/IntrinsicSupport/EqualityComparerHelpers.cs
@@ -51,6 +51,11 @@ internal static unsafe bool IsEnum(RuntimeTypeHandle t)
             return t.ToMethodTable()->IsEnum;
         }
 
+        internal static unsafe bool IsString(RuntimeTypeHandle t)
+        {
+            return t.ToMethodTable()->IsString;
+        }
+
         // this function utilizes the template type loader to generate new
         // EqualityComparer types on the fly
         internal static object GetComparer(RuntimeTypeHandle t)
@@ -59,6 +64,11 @@ internal static object GetComparer(RuntimeTypeHandle t)
             RuntimeTypeHandle openComparerType = default(RuntimeTypeHandle);
             RuntimeTypeHandle comparerTypeArgument = default(RuntimeTypeHandle);
 
+            if (IsString(t))
+            {
+                return new StringEqualityComparer();
+            }
+
             if (RuntimeAugments.IsNullable(t))
             {
                 RuntimeTypeHandle nullableType = RuntimeAugments.GetNullableType(t);
diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Collections/Generic/EqualityComparer.NativeAot.cs b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Collections/Generic/EqualityComparer.NativeAot.cs
@@ -23,6 +23,12 @@ private static EqualityComparer<T> Create()
             // This body serves as a fallback when instantiation-specific implementation is unavailable.
             // If that happens, the compiler ensures we generate data structures to make the fallback work
             // when this method is compiled.
+
+            if (typeof(T) == typeof(string))
+            {
+                return Unsafe.As<EqualityComparer<T>>(new StringEqualityComparer());
+            }
+
             if (SupportsGenericIEquatableInterfaces)
             {
                 return Unsafe.As<EqualityComparer<T>>(EqualityComparerHelpers.GetComparer(typeof(T).TypeHandle));
diff --git a/src/coreclr/vm/corelib.h b/src/coreclr/vm/corelib.h
@@ -1136,6 +1136,7 @@ DEFINE_METHOD(UTF8BUFFERMARSHALER, CONVERT_TO_MANAGED, ConvertToManaged, NoSig)
 
 // Classes referenced in EqualityComparer<T>.Default optimization
 
+DEFINE_CLASS(STRING_EQUALITYCOMPARER, CollectionsGeneric, StringEqualityComparer)
 DEFINE_CLASS(ENUM_EQUALITYCOMPARER, CollectionsGeneric, EnumEqualityComparer`1)
 DEFINE_CLASS(NULLABLE_EQUALITYCOMPARER, CollectionsGeneric, NullableEqualityComparer`1)
 DEFINE_CLASS(GENERIC_EQUALITYCOMPARER, CollectionsGeneric, GenericEqualityComparer`1)
diff --git a/src/coreclr/vm/jitinterface.cpp b/src/coreclr/vm/jitinterface.cpp
@@ -8848,8 +8848,7 @@ CORINFO_CLASS_HANDLE CEEInfo::getDefaultComparerClassHelper(CORINFO_CLASS_HANDLE
     TypeHandle elemTypeHnd(elemType);
 
     // Mirrors the logic in BCL's CompareHelpers.CreateDefaultComparer
-    // And in compile.cpp's SpecializeComparer
-    //
+
     // We need to find the appropriate instantiation
     Instantiation inst(&elemTypeHnd, 1);
 
@@ -8914,16 +8913,19 @@ CORINFO_CLASS_HANDLE CEEInfo::getDefaultEqualityComparerClassHelper(CORINFO_CLAS
         MODE_PREEMPTIVE;
     } CONTRACTL_END;
 
-    // Mirrors the logic in BCL's CompareHelpers.CreateDefaultEqualityComparer
-    // And in compile.cpp's SpecializeEqualityComparer
+    // Mirrors the logic in BCL's CompareHelpers.CreateDefaultEqualityComparer.
     TypeHandle elemTypeHnd(elemType);
 
-    // Mirrors the logic in BCL's CompareHelpers.CreateDefaultComparer
-    // And in compile.cpp's SpecializeComparer
-    //
-    // We need to find the appropriate instantiation
+    // We need to find the appropriate instantiation.
     Instantiation inst(&elemTypeHnd, 1);
 
+    // string
+    if (elemTypeHnd.IsString())
+    {
+        TypeHandle resultTh = ((TypeHandle)CoreLibBinder::GetClass(CLASS__STRING_EQUALITYCOMPARER)).Instantiate(inst);
+        return CORINFO_CLASS_HANDLE(resultTh.GetMethodTable());
+    }
+
     // Nullable<T>
     if (Nullable::IsNullableType(elemTypeHnd))
     {
diff --git a/src/coreclr/vm/typehandle.cpp b/src/coreclr/vm/typehandle.cpp
@@ -84,6 +84,13 @@ BOOL TypeHandle::IsArray() const {
     return !IsTypeDesc() && AsMethodTable()->IsArray();
 }
 
+BOOL TypeHandle::IsString() const
+{
+    LIMITED_METHOD_CONTRACT;
+
+    return !IsTypeDesc() && AsMethodTable()->IsString();
+}
+
 BOOL TypeHandle::IsGenericVariable() const {
     LIMITED_METHOD_DAC_CONTRACT;
 
diff --git a/src/coreclr/vm/typehandle.h b/src/coreclr/vm/typehandle.h
@@ -463,6 +463,9 @@ class TypeHandle
     // PTR
     BOOL IsPointer() const;
 
+    // String
+    BOOL IsString() const;
+
     // True if this type *is* a formal generic type parameter or any component of it is a formal generic type parameter
     BOOL ContainsGenericVariables(BOOL methodOnly=FALSE) const;
 
diff --git a/src/libraries/System.Collections.Concurrent/tests/ConcurrentDictionary/ConcurrentDictionaryTests.cs b/src/libraries/System.Collections.Concurrent/tests/ConcurrentDictionary/ConcurrentDictionaryTests.cs
@@ -1088,13 +1088,6 @@ public void ConcurrentWriteRead_NoTornValues()
                 }));
         }
 
-        // TODO: Revise this test when EqualityComparer<string>.Default implements IAlternateEqualityComparer<ReadOnlySpan<char>, string>
-        [Fact]
-        public void GetAlternateLookup_FailsForDefaultComparer()
-        {
-            Assert.False(new ConcurrentDictionary<string, string>().TryGetAlternateLookup<ReadOnlySpan<char>>(out _));
-        }
-
         [Fact]
         public void GetAlternateLookup_FailsWhenIncompatible()
         {
@@ -1119,17 +1112,19 @@ public void GetAlternateLookup_FailsWhenIncompatible()
         [InlineData(3)]
         [InlineData(4)]
         [InlineData(5)]
+        [InlineData(6)]
         public void GetAlternateLookup_OperationsMatchUnderlyingDictionary(int mode)
         {
             // Test with a variety of comparers to ensure that the alternate lookup is consistent with the underlying dictionary
             ConcurrentDictionary<string, int> dictionary = new(mode switch
             {
-                0 => StringComparer.Ordinal,
-                1 => StringComparer.OrdinalIgnoreCase,
-                2 => StringComparer.InvariantCulture,
-                3 => StringComparer.InvariantCultureIgnoreCase,
-                4 => StringComparer.CurrentCulture,
-                5 => StringComparer.CurrentCultureIgnoreCase,
+                0 => EqualityComparer<string>.Default,
+                1 => StringComparer.Ordinal,
+                2 => StringComparer.OrdinalIgnoreCase,
+                3 => StringComparer.InvariantCulture,
+                4 => StringComparer.InvariantCultureIgnoreCase,
+                5 => StringComparer.CurrentCulture,
+                6 => StringComparer.CurrentCultureIgnoreCase,
                 _ => throw new ArgumentOutOfRangeException(nameof(mode))
             });
             ConcurrentDictionary<string, int>.AlternateLookup<ReadOnlySpan<char>> lookup = dictionary.GetAlternateLookup<ReadOnlySpan<char>>();
@@ -1165,7 +1160,8 @@ public void GetAlternateLookup_OperationsMatchUnderlyingDictionary(int mode)
 
             // Ensure that case-sensitivity of the comparer is respected
             lookup["a".AsSpan()] = 42;
-            if (dictionary.Comparer.Equals(StringComparer.Ordinal) ||
+            if (dictionary.Comparer.Equals(EqualityComparer<string>.Default) ||
+                dictionary.Comparer.Equals(StringComparer.Ordinal) ||
                 dictionary.Comparer.Equals(StringComparer.InvariantCulture) ||
                 dictionary.Comparer.Equals(StringComparer.CurrentCulture))
             {
diff --git a/src/libraries/System.Collections.Immutable/tests/Frozen/FrozenDictionaryAlternateLookupTests.cs b/src/libraries/System.Collections.Immutable/tests/Frozen/FrozenDictionaryAlternateLookupTests.cs
@@ -12,20 +12,10 @@ public class FrozenDictionaryAlternateLookupTests
         [Fact]
         public void AlternateLookup_Empty()
         {
-            FrozenDictionary<string, string>[] unsupported =
+            FrozenDictionary<string, string>[] supported =
             [
-                FrozenDictionary<string, string>.Empty,
                 FrozenDictionary.ToFrozenDictionary<string, string>([]),
                 FrozenDictionary.ToFrozenDictionary<string, string>([], EqualityComparer<string>.Default),
-            ];
-            foreach (FrozenDictionary<string, string> frozen in unsupported)
-            {
-                Assert.Throws<InvalidOperationException>(() => frozen.GetAlternateLookup<ReadOnlySpan<char>>());
-                Assert.False(frozen.TryGetAlternateLookup<ReadOnlySpan<char>>(out _));
-            }
-
-            FrozenDictionary<string, string>[] supported =
-            [
                 FrozenDictionary.ToFrozenDictionary<string, string>([], StringComparer.Ordinal),
                 FrozenDictionary.ToFrozenDictionary<string, string>([], StringComparer.OrdinalIgnoreCase),
             ];
@@ -39,7 +29,7 @@ public void AlternateLookup_Empty()
         [Fact]
         public void UnsupportedComparer_ThrowsOrReturnsFalse()
         {
-            FrozenDictionary<string, int> frozen = new Dictionary<string, int> { ["a"] = 1, ["b"] = 2 }.ToFrozenDictionary();
+            FrozenDictionary<char, int> frozen = new Dictionary<char, int> { ['a'] = 1, ['b'] = 2 }.ToFrozenDictionary();
             Assert.Throws<InvalidOperationException>(() => frozen.GetAlternateLookup<ReadOnlySpan<char>>());
             Assert.False(frozen.TryGetAlternateLookup<ReadOnlySpan<char>>(out _));
         }
diff --git a/src/libraries/System.Collections.Immutable/tests/Frozen/FrozenSetAlternateLookupTests.cs b/src/libraries/System.Collections.Immutable/tests/Frozen/FrozenSetAlternateLookupTests.cs
@@ -12,9 +12,9 @@ public class FrozenSetAlternateLookupTests
         [Fact]
         public void AlternateLookup_Empty()
         {
-            Assert.False(FrozenSet<string>.Empty.TryGetAlternateLookup<ReadOnlySpan<char>>(out _));
+            Assert.True(FrozenSet<string>.Empty.TryGetAlternateLookup<ReadOnlySpan<char>>(out _));
 
-            foreach (StringComparer comparer in new[] { StringComparer.Ordinal, StringComparer.OrdinalIgnoreCase })
+            foreach (IEqualityComparer<string> comparer in new IEqualityComparer<string>[] { null, EqualityComparer<string>.Default, StringComparer.Ordinal, StringComparer.OrdinalIgnoreCase })
             {
                 FrozenSet<string>.AlternateLookup<ReadOnlySpan<char>> lookup = FrozenSet.ToFrozenSet([], comparer).GetAlternateLookup<ReadOnlySpan<char>>();
                 Assert.False(lookup.Contains("anything".AsSpan()));
@@ -24,7 +24,7 @@ public void AlternateLookup_Empty()
         [Fact]
         public void UnsupportedComparer()
         {
-            FrozenSet<string> frozen = FrozenSet.ToFrozenSet(["a", "b"]);
+            FrozenSet<char> frozen = FrozenSet.ToFrozenSet(['a', 'b']);
             Assert.Throws<InvalidOperationException>(() => frozen.GetAlternateLookup<ReadOnlySpan<char>>());
             Assert.False(frozen.TryGetAlternateLookup<ReadOnlySpan<char>>(out _));
         }
diff --git a/src/libraries/System.Collections/tests/Generic/CollectionExtensionsTests.cs b/src/libraries/System.Collections/tests/Generic/CollectionExtensionsTests.cs
@@ -151,15 +151,6 @@ public void GetAlternateLookup_ThrowsWhenNull()
             AssertExtensions.Throws<ArgumentNullException>("set", () => CollectionExtensions.TryGetAlternateLookup<int, long>((HashSet<int>)null, out _));
         }
 
-        // TODO https://github.com/dotnet/runtime/issues/102906:
-        // Revise this test when EqualityComparer<string>.Default implements IAlternateEqualityComparer<ReadOnlySpan<char>, string>
-        [Fact]
-        public void GetAlternateLookup_FailsForDefaultComparer()
-        {
-            Assert.False(new Dictionary<string, string>().TryGetAlternateLookup<string, string, ReadOnlySpan<char>>(out _));
-            Assert.False(new HashSet<string>().TryGetAlternateLookup<string, ReadOnlySpan<char>>(out _));
-        }
-
         [Fact]
         public void GetAlternateLookup_FailsWhenIncompatible()
         {
@@ -196,17 +187,19 @@ public void GetAlternateLookup_FailsWhenIncompatible()
         [InlineData(3)]
         [InlineData(4)]
         [InlineData(5)]
+        [InlineData(6)]
         public void Dictionary_GetAlternateLookup_OperationsMatchUnderlyingDictionary(int mode)
         {
             // Test with a variety of comparers to ensure that the alternate lookup is consistent with the underlying dictionary
             Dictionary<string, int> dictionary = new(mode switch
             {
-                0 => StringComparer.Ordinal,
-                1 => StringComparer.OrdinalIgnoreCase,
-                2 => StringComparer.InvariantCulture,
-                3 => StringComparer.InvariantCultureIgnoreCase,
-                4 => StringComparer.CurrentCulture,
-                5 => StringComparer.CurrentCultureIgnoreCase,
+                0 => EqualityComparer<string>.Default,
+                1 => StringComparer.Ordinal,
+                2 => StringComparer.OrdinalIgnoreCase,
+                3 => StringComparer.InvariantCulture,
+                4 => StringComparer.InvariantCultureIgnoreCase,
+                5 => StringComparer.CurrentCulture,
+                6 => StringComparer.CurrentCultureIgnoreCase,
                 _ => throw new ArgumentOutOfRangeException(nameof(mode))
             });
             Dictionary<string, int>.AlternateLookup<ReadOnlySpan<char>> lookup = dictionary.GetAlternateLookup<string, int, ReadOnlySpan<char>>();
@@ -241,7 +234,8 @@ public void Dictionary_GetAlternateLookup_OperationsMatchUnderlyingDictionary(in
 
             // Ensure that case-sensitivity of the comparer is respected
             lookup["a".AsSpan()] = 42;
-            if (dictionary.Comparer.Equals(StringComparer.Ordinal) ||
+            if (dictionary.Comparer.Equals(EqualityComparer<string>.Default) ||
+                dictionary.Comparer.Equals(StringComparer.Ordinal) ||
                 dictionary.Comparer.Equals(StringComparer.InvariantCulture) ||
                 dictionary.Comparer.Equals(StringComparer.CurrentCulture))
             {
diff --git a/src/libraries/System.Collections/tests/Generic/Dictionary/HashCollisionScenarios/OutOfBoundsRegression.cs b/src/libraries/System.Collections/tests/Generic/Dictionary/HashCollisionScenarios/OutOfBoundsRegression.cs
@@ -18,7 +18,7 @@ public class InternalHashCodeTests_Dictionary_NullComparer : InternalHashCodeTes
         protected override bool ContainsKey(Dictionary<string, string> collection, string key) => collection.ContainsKey(key);
         protected override IEqualityComparer<string> GetComparer(Dictionary<string, string> collection) => collection.Comparer;
 
-        protected override Type ExpectedInternalComparerTypeBeforeCollisionThreshold => nonRandomizedDefaultComparerType;
+        protected override Type ExpectedInternalComparerTypeBeforeCollisionThreshold => nonRandomizedOrdinalComparerType;
         protected override IEqualityComparer<string> ExpectedPublicComparerBeforeCollisionThreshold => EqualityComparer<string>.Default;
         protected override Type ExpectedInternalComparerTypeAfterCollisionThreshold => randomizedOrdinalComparerType;
 
@@ -60,7 +60,7 @@ public class InternalHashCodeTests_Dictionary_DefaultComparer : InternalHashCode
         protected override bool ContainsKey(Dictionary<string, string> collection, string key) => collection.ContainsKey(key);
         protected override IEqualityComparer<string> GetComparer(Dictionary<string, string> collection) => collection.Comparer;
 
-        protected override Type ExpectedInternalComparerTypeBeforeCollisionThreshold => nonRandomizedDefaultComparerType;
+        protected override Type ExpectedInternalComparerTypeBeforeCollisionThreshold => nonRandomizedOrdinalComparerType;
         protected override IEqualityComparer<string> ExpectedPublicComparerBeforeCollisionThreshold => EqualityComparer<string>.Default;
         protected override Type ExpectedInternalComparerTypeAfterCollisionThreshold => randomizedOrdinalComparerType;
     }
@@ -124,7 +124,7 @@ public class InternalHashCodeTests_HashSet_NullComparer : InternalHashCodeTests<
         protected override bool ContainsKey(HashSet<string> collection, string key) => collection.Contains(key);
         protected override IEqualityComparer<string> GetComparer(HashSet<string> collection) => collection.Comparer;
 
-        protected override Type ExpectedInternalComparerTypeBeforeCollisionThreshold => nonRandomizedDefaultComparerType;
+        protected override Type ExpectedInternalComparerTypeBeforeCollisionThreshold => nonRandomizedOrdinalComparerType;
         protected override IEqualityComparer<string> ExpectedPublicComparerBeforeCollisionThreshold => EqualityComparer<string>.Default;
         protected override Type ExpectedInternalComparerTypeAfterCollisionThreshold => randomizedOrdinalComparerType;
     }
@@ -136,7 +136,7 @@ public class InternalHashCodeTests_HashSet_DefaultComparer : InternalHashCodeTes
         protected override bool ContainsKey(HashSet<string> collection, string key) => collection.Contains(key);
         protected override IEqualityComparer<string> GetComparer(HashSet<string> collection) => collection.Comparer;
 
-        protected override Type ExpectedInternalComparerTypeBeforeCollisionThreshold => nonRandomizedDefaultComparerType;
+        protected override Type ExpectedInternalComparerTypeBeforeCollisionThreshold => nonRandomizedOrdinalComparerType;
         protected override IEqualityComparer<string> ExpectedPublicComparerBeforeCollisionThreshold => EqualityComparer<string>.Default;
         protected override Type ExpectedInternalComparerTypeAfterCollisionThreshold => randomizedOrdinalComparerType;
     }
@@ -186,7 +186,7 @@ public class InternalHashCodeTests_OrderedDictionary_NullComparer : InternalHash
         protected override bool ContainsKey(OrderedDictionary<string, string> collection, string key) => collection.ContainsKey(key);
         protected override IEqualityComparer<string> GetComparer(OrderedDictionary<string, string> collection) => collection.Comparer;
 
-        protected override Type ExpectedInternalComparerTypeBeforeCollisionThreshold => nonRandomizedDefaultComparerType;
+        protected override Type ExpectedInternalComparerTypeBeforeCollisionThreshold => nonRandomizedOrdinalComparerType;
         protected override IEqualityComparer<string> ExpectedPublicComparerBeforeCollisionThreshold => EqualityComparer<string>.Default;
         protected override Type ExpectedInternalComparerTypeAfterCollisionThreshold => EqualityComparer<string>.Default.GetType();
     }
@@ -198,7 +198,7 @@ public class InternalHashCodeTests_OrderedDictionary_DefaultComparer : InternalH
         protected override bool ContainsKey(OrderedDictionary<string, string> collection, string key) => collection.ContainsKey(key);
         protected override IEqualityComparer<string> GetComparer(OrderedDictionary<string, string> collection) => collection.Comparer;
 
-        protected override Type ExpectedInternalComparerTypeBeforeCollisionThreshold => nonRandomizedDefaultComparerType;
+        protected override Type ExpectedInternalComparerTypeBeforeCollisionThreshold => nonRandomizedOrdinalComparerType;
         protected override IEqualityComparer<string> ExpectedPublicComparerBeforeCollisionThreshold => EqualityComparer<string>.Default;
         protected override Type ExpectedInternalComparerTypeAfterCollisionThreshold => EqualityComparer<string>.Default.GetType();
     }
@@ -242,7 +242,6 @@ public class InternalHashCodeTests_OrderedDictionary_LinguisticComparer : Intern
 
     public abstract class InternalHashCodeTests<TCollection>
     {
-        protected static Type nonRandomizedDefaultComparerType = typeof(object).Assembly.GetType("System.Collections.Generic.NonRandomizedStringEqualityComparer+DefaultComparer", throwOnError: true);
         protected static Type nonRandomizedOrdinalComparerType = typeof(object).Assembly.GetType("System.Collections.Generic.NonRandomizedStringEqualityComparer+OrdinalComparer", throwOnError: true);
         protected static Type nonRandomizedOrdinalIgnoreCaseComparerType = typeof(object).Assembly.GetType("System.Collections.Generic.NonRandomizedStringEqualityComparer+OrdinalIgnoreCaseComparer", throwOnError: true);
         protected static Type randomizedOrdinalComparerType = typeof(object).Assembly.GetType("System.Collections.Generic.RandomizedStringEqualityComparer+OrdinalComparer", throwOnError: true);
diff --git a/src/libraries/System.Private.CoreLib/src/System/Collections/Generic/EqualityComparer.cs b/src/libraries/System.Private.CoreLib/src/System/Collections/Generic/EqualityComparer.cs
diff --git a/src/libraries/System.Private.CoreLib/src/System/Collections/Generic/NonRandomizedStringEqualityComparer.cs b/src/libraries/System.Private.CoreLib/src/System/Collections/Generic/NonRandomizedStringEqualityComparer.cs
diff --git a/src/libraries/System.Private.CoreLib/src/System/StringComparer.cs b/src/libraries/System.Private.CoreLib/src/System/StringComparer.cs
diff --git a/src/mono/System.Private.CoreLib/src/System/Collections/Generic/EqualityComparer.Mono.cs b/src/mono/System.Private.CoreLib/src/System/Collections/Generic/EqualityComparer.Mono.cs

Original file line number	Diff line number	Diff line change
`@@ -68,7 +68,7 @@ internal static object CreateDefaultEqualityComparer(Type type)`
`68`	`68`
`69`	`69`	`if (type == typeof(string))`
`70`	`70`	`{`
`71`		`- return new GenericEqualityComparer<string>();`
	`71`	`+ return new StringEqualityComparer();`
`72`	`72`	`}`
`73`	`73`	`else if (type.IsAssignableTo(typeof(IEquatable<>).MakeGenericType(type)))`
`74`	`74`	`{`
Original file line number	Diff line number	Diff line change
`@@ -12,9 +12,9 @@ public class FrozenSetAlternateLookupTests`
`12`	`12`	`[Fact]`
`13`	`13`	`public void AlternateLookup_Empty()`
`14`	`14`	`{`
`15`		`- Assert.False(FrozenSet<string>.Empty.TryGetAlternateLookup<ReadOnlySpan<char>>(out _));`
	`15`	`+ Assert.True(FrozenSet<string>.Empty.TryGetAlternateLookup<ReadOnlySpan<char>>(out _));`
`16`	`16`
`17`		`- foreach (StringComparer comparer in new[] { StringComparer.Ordinal, StringComparer.OrdinalIgnoreCase })`
	`17`	`+ foreach (IEqualityComparer<string> comparer in new IEqualityComparer<string>[] { null, EqualityComparer<string>.Default, StringComparer.Ordinal, StringComparer.OrdinalIgnoreCase })`
`18`	`18`	`{`
`19`	`19`	`FrozenSet<string>.AlternateLookup<ReadOnlySpan<char>> lookup = FrozenSet.ToFrozenSet([], comparer).GetAlternateLookup<ReadOnlySpan<char>>();`
`20`	`20`	`Assert.False(lookup.Contains("anything".AsSpan()));`
`@@ -24,7 +24,7 @@ public void AlternateLookup_Empty()`
`24`	`24`	`[Fact]`
`25`	`25`	`public void UnsupportedComparer()`
`26`	`26`	`{`
`27`		`- FrozenSet<string> frozen = FrozenSet.ToFrozenSet(["a", "b"]);`
	`27`	`+ FrozenSet<char> frozen = FrozenSet.ToFrozenSet(['a', 'b']);`
`28`	`28`	`Assert.Throws<InvalidOperationException>(() => frozen.GetAlternateLookup<ReadOnlySpan<char>>());`
`29`	`29`	`Assert.False(frozen.TryGetAlternateLookup<ReadOnlySpan<char>>(out _));`
`30`	`30`	`}`