Fix ImmutableHashSet.SetEquals correctness for mismatched comparers

src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableHashSet_1.cs

@@ -743,39 +743,40 @@ private static bool SetEquals(IEnumerable<T> other, MutationInput origin)
             switch (other)
             {
                 case ImmutableHashSet<T> otherAsImmutableHashSet:
-                    if (otherAsImmutableHashSet.Count != origin.Count)
-                    {
-                        return false;
-                    }
-
                     if (EqualityComparer<IEqualityComparer<T>>.Default.Equals(origin.EqualityComparer, otherAsImmutableHashSet.KeyComparer))
                     {
+                        if (otherAsImmutableHashSet.Count != origin.Count)
+                        {
+                            return false;
+                        }
                         return SetEqualsWithImmutableHashset(otherAsImmutableHashSet, origin);
                     }
-                    break;
 
-                case HashSet<T> otherAsHashset:
-                    if (otherAsHashset.Count != origin.Count)
+                    if (otherAsImmutableHashSet.Count < origin.Count)
                     {
                         return false;
                     }
+                    break;
 
+                case HashSet<T> otherAsHashset:
                     if (EqualityComparer<IEqualityComparer<T>>.Default.Equals(origin.EqualityComparer, otherAsHashset.Comparer))
                     {
+                        if (otherAsHashset.Count != origin.Count)
+                        {
+                            return false;
+                        }
                         return SetEqualsWithHashset(otherAsHashset, origin);
                     }
-                    break;
 
-                case ICollection<T> otherAsICollectionGeneric:
-                    // We check for < instead of != because other is not guaranteed to be a set, it could be a collection with duplicates.
-                    if (otherAsICollectionGeneric.Count < origin.Count)
+                    if (otherAsHashset.Count < origin.Count)
                     {
                         return false;
                     }
                     break;
 
-                case ICollection otherAsICollection:
-                    if (otherAsICollection.Count < origin.Count)
+                case ICollection<T> otherAsICollectionGeneric:
+                    // We check for < instead of != because other is not guaranteed to be a set, it could be a collection with duplicates.
+                    if (otherAsICollectionGeneric.Count < origin.Count)
                     {
                         return false;
                     }

src/libraries/System.Collections.Immutable/tests/ImmutableHashSetTest.cs

@@ -31,6 +31,96 @@ public void CustomSort()
                 new[] { "apple" });
         }
 
+        [Fact]
+        public void SetEqualsMismatchedComparersOriginInsensitiveOtherSensitive()
+        {
+            var ignoreCaseSet = ImmutableHashSet.Create(StringComparer.OrdinalIgnoreCase, "a");
+            var sensitiveSet = ImmutableHashSet.Create(StringComparer.Ordinal, "a", "A");
+
+            Assert.True(ignoreCaseSet.SetEquals(sensitiveSet));
+        }
+
+        [Fact]
+        public void SetEqualsMismatchedComparersOriginSensitiveOtherInsensitive()
+        {
+            var sensitiveSetMain = ImmutableHashSet.Create(StringComparer.Ordinal, "a");
+            var insensitiveMutable = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "a", "A" };
+
+            Assert.True(sensitiveSetMain.SetEquals(insensitiveMutable));
+        }
+
+        [Fact]
+        public void SetEqualsICollectionWithDuplicatesValidatesCorrectness()
+        {
+            var ignoreCaseSet = ImmutableHashSet.Create(StringComparer.OrdinalIgnoreCase, "a");
+            var listWithDupes = new List<string> { "a", "a", "a", "a" };
+
+            Assert.True(ignoreCaseSet.SetEquals(listWithDupes));
+        }
+
+        [Fact]
+        public void SetEqualsDifferentContent()
+        {
+            var ignoreCaseSet = ImmutableHashSet.Create(StringComparer.OrdinalIgnoreCase, "a");
+            var setB = ImmutableHashSet.Create(StringComparer.Ordinal, "b");
+
+            Assert.False(ignoreCaseSet.SetEquals(setB));
+        }
+
+        [Fact]
+        public void SetEqualsMismatchedComparersOtherCountSmaller()
+        {
+            var originTwoElements = ImmutableHashSet.Create(StringComparer.OrdinalIgnoreCase, "a", "b");
+            var otherOneElement = ImmutableHashSet.Create(StringComparer.Ordinal, "a");
+
+            Assert.False(originTwoElements.SetEquals(otherOneElement));
+        }
+
+        [Fact]
+        public void SetEqualsMatchedComparersDifferentCounts()
+        {
+            var matchedSet1 = ImmutableHashSet.Create(StringComparer.Ordinal, "a", "b");
+            var matchedSet2 = ImmutableHashSet.Create(StringComparer.Ordinal, "a");
+
+            Assert.False(matchedSet1.SetEquals(matchedSet2));
+        }
+
+        [Fact]
+        public void SetEqualsMatchedComparersSameContent()
+        {
+            var matchedSet1 = ImmutableHashSet.Create(StringComparer.Ordinal, "a", "b");
+            var matchedSet2 = ImmutableHashSet.Create(StringComparer.Ordinal, "a", "b");
+
+            Assert.True(matchedSet1.SetEquals(matchedSet2));
+        }
+
+        [Fact]
+        public void SetEqualsEmptySetsDifferentComparers()
+        {
+            var empty1 = ImmutableHashSet<string>.Empty.WithComparer(StringComparer.Ordinal);
+            var empty2 = ImmutableHashSet<string>.Empty.WithComparer(StringComparer.OrdinalIgnoreCase);
+
+            Assert.True(empty1.SetEquals(empty2));
+        }
+
+        [Fact]
+        public void SetEqualsMismatchedComparersOriginSensitiveOtherInsensitiveSameCount()
+        {
+            var sensitiveSet = ImmutableHashSet.Create(StringComparer.Ordinal, "a", "A");
+            var insensitiveSet = ImmutableHashSet.Create(StringComparer.OrdinalIgnoreCase, "a", "b");
+
+            Assert.False(sensitiveSet.SetEquals(insensitiveSet));
+        }
+
+        [Fact]
+        public void SetEqualsMismatchedComparersOtherIsLarger()
+        {
+            var origin = ImmutableHashSet.Create(StringComparer.OrdinalIgnoreCase, "a");
+            var other = ImmutableHashSet.Create(StringComparer.Ordinal, "a", "b");
+
+            Assert.False(origin.SetEquals(other));
+        }
+
         [Fact]
         public void ChangeUnorderedEqualityComparer()
         {