Clean up HasDuplicates extension method

src/Compilers/CSharp/Portable/Symbols/ConstraintsHelper.cs

@@ -804,7 +804,7 @@ private static bool HasDuplicateInterfaces(NamedTypeSymbol type, ConsList<TypeSy
 // some implemented interfaces are related
 // will have to instantiate interfaces and check
 hasRelatedInterfaces:
-            return type.InterfacesNoUseSiteDiagnostics(basesBeingResolved).HasDuplicates(Symbols.SymbolEqualityComparer.IgnoringDynamicTupleNamesAndNullability);
+            return type.InterfacesNoUseSiteDiagnostics(basesBeingResolved).HasDuplicates<NamedTypeSymbol>(SymbolEqualityComparer.IgnoringDynamicTupleNamesAndNullability);
         }
 
         public static bool CheckConstraints(

src/Compilers/Core/CodeAnalysisTest/InternalUtilities/EnumerableExtensionsTests.cs → src/Compilers/Core/CodeAnalysisTest/Collections/Extensions/EnumerableExtensionsTests.cs

@@ -17,7 +17,12 @@ namespace Microsoft.CodeAnalysis.UnitTests;
 public class EnumerableExtensionsTests
 {
     private static IEnumerable<T> MakeEnumerable<T>(params T[] values)
-        => values;
+    {
+        foreach (var value in values)
+        {
+            yield return value;
+        }
+    }
 
     [Fact]
     public void SequenceEqual()
@@ -154,5 +159,46 @@ public void TestSequenceEqualWithFunction()
         Assert.False(seq.SequenceEqual(new int[] { 1, 2, 6 }, equality));
     }
 
+    public sealed class Comparer<T>(Func<T, T, bool> equals, Func<T, int> hashCode) : IEqualityComparer<T>
+    {
+        private readonly Func<T, T, bool> _equals = equals;
+        private readonly Func<T, int> _hashCode = hashCode;
+
+        public bool Equals(T x, T y) => _equals(x, y);
+        public int GetHashCode(T obj) => _hashCode(obj);
+    }
+
+    [Fact]
+    public void HasDuplicates()
+    {
+        var comparer = new Comparer<int>((x, y) => x % 10 == y % 10, x => (x % 10).GetHashCode());
+
+        Assert.False(MakeEnumerable<int>().HasDuplicates());
+        Assert.False(MakeEnumerable<int>().HasDuplicates(comparer));
+        Assert.False(MakeEnumerable<int>().HasDuplicates(i => i + 1));
+
+        Assert.False(MakeEnumerable(1).HasDuplicates());
+        Assert.False(MakeEnumerable(1).HasDuplicates(comparer));
+        Assert.False(MakeEnumerable(1).HasDuplicates(i => i + 1));
+
+        Assert.False(MakeEnumerable(1, 2).HasDuplicates());
+        Assert.False(MakeEnumerable(1, 2).HasDuplicates(comparer));
+        Assert.False(MakeEnumerable(1, 2).HasDuplicates(i => i + 1));
+
+        Assert.True(MakeEnumerable(1, 1).HasDuplicates());
+        Assert.True(MakeEnumerable(11, 1).HasDuplicates(comparer));
+        Assert.True(MakeEnumerable(1, 3).HasDuplicates(i => i % 2));
+        Assert.True(MakeEnumerable(11.0, 1.2).HasDuplicates(i => (int)i, comparer));
+
+        Assert.False(MakeEnumerable(2, 0, 1, 3).HasDuplicates());
+        Assert.False(MakeEnumerable(2, 0, 1, 13).HasDuplicates(comparer));
+        Assert.False(MakeEnumerable(2, 0, 1, 53).HasDuplicates(i => i % 10));
+        Assert.False(MakeEnumerable(2.3, 0.1, 1.3, 53.4).HasDuplicates(i => (int)i, comparer));
+
+        Assert.True(MakeEnumerable(2, 0, 1, 2).HasDuplicates());
+        Assert.True(MakeEnumerable(2, 0, 1, 12).HasDuplicates(comparer));
+        Assert.True(MakeEnumerable(2, 0, 1, 52).HasDuplicates(i => i % 10));
+        Assert.True(MakeEnumerable(2.3, 0.1, 1.3, 52.4).HasDuplicates(i => (int)i, comparer));
+    }
 }
 

src/Compilers/Core/CodeAnalysisTest/Collections/ImmutableArrayExtensionsTests.cs → src/Compilers/Core/CodeAnalysisTest/Collections/Extensions/ImmutableArrayExtensionsTests.cs

@@ -7,13 +7,12 @@
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
-using System.Collections.ObjectModel;
 using System.Linq;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Roslyn.Test.Utilities;
 using Xunit;
 
-namespace Microsoft.CodeAnalysis.UnitTests.Collections
+namespace Microsoft.CodeAnalysis.UnitTests
 {
     public class ImmutableArrayExtensionsTests
     {
@@ -544,5 +543,47 @@ public void IsSubsetOf_Equal(int[] array, int[] other)
             Assert.True(array.ToImmutableArray().IsSubsetOf(other.ToImmutableArray()));
             Assert.True(other.ToImmutableArray().IsSubsetOf(array.ToImmutableArray()));
         }
+
+        public sealed class Comparer<T>(Func<T, T, bool> equals, Func<T, int> hashCode) : IEqualityComparer<T>
+        {
+            private readonly Func<T, T, bool> _equals = equals;
+            private readonly Func<T, int> _hashCode = hashCode;
+
+            public bool Equals(T x, T y) => _equals(x, y);
+            public int GetHashCode(T obj) => _hashCode(obj);
+        }
+
+        [Fact]
+        public void HasDuplicates()
+        {
+            var comparer = new Comparer<int>((x, y) => x % 10 == y % 10, x => (x % 10).GetHashCode());
+
+            Assert.False(ImmutableArray<int>.Empty.HasDuplicates());
+            Assert.False(ImmutableArray<int>.Empty.HasDuplicates(comparer));
+            Assert.False(ImmutableArray<int>.Empty.HasDuplicates(i => i + 1));
+
+            Assert.False(ImmutableArray.Create(1).HasDuplicates());
+            Assert.False(ImmutableArray.Create(1).HasDuplicates(comparer));
+            Assert.False(ImmutableArray.Create(1).HasDuplicates(i => i + 1));
+
+            Assert.False(ImmutableArray.Create(1, 2).HasDuplicates());
+            Assert.False(ImmutableArray.Create(1, 2).HasDuplicates(comparer));
+            Assert.False(ImmutableArray.Create(1, 2).HasDuplicates(i => i + 1));
+
+            Assert.True(ImmutableArray.Create(1, 1).HasDuplicates());
+            Assert.True(ImmutableArray.Create(11, 1).HasDuplicates(comparer));
+            Assert.True(ImmutableArray.Create(1, 3).HasDuplicates(i => i % 2));
+            Assert.True(ImmutableArray.Create(11.0, 1.2).HasDuplicates(i => (int)i, comparer));
+
+            Assert.False(ImmutableArray.Create(2, 0, 1, 3).HasDuplicates());
+            Assert.False(ImmutableArray.Create(2, 0, 1, 13).HasDuplicates(comparer));
+            Assert.False(ImmutableArray.Create(2, 0, 1, 53).HasDuplicates(i => i % 10));
+            Assert.False(ImmutableArray.Create(2.3, 0.1, 1.3, 53.4).HasDuplicates(i => (int)i, comparer));
+
+            Assert.True(ImmutableArray.Create(2, 0, 1, 2).HasDuplicates());
+            Assert.True(ImmutableArray.Create(2, 0, 1, 12).HasDuplicates(comparer));
+            Assert.True(ImmutableArray.Create(2, 0, 1, 52).HasDuplicates(i => i % 10));
+            Assert.True(ImmutableArray.Create(2.3, 0.1, 1.3, 52.4).HasDuplicates(i => (int)i, comparer));
+        }
     }
 }

src/Compilers/Core/CodeAnalysisTest/Collections/Extensions/ListExtensionsTests.cs

@@ -0,0 +1,58 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#nullable disable
+
+using System;
+using System.Collections.Generic;
+using Roslyn.Utilities;
+using Xunit;
+
+namespace Microsoft.CodeAnalysis.UnitTests;
+
+public class ListExtensionsTests
+{
+    public sealed class Comparer<T>(Func<T, T, bool> equals, Func<T, int> hashCode) : IEqualityComparer<T>
+    {
+        private readonly Func<T, T, bool> _equals = equals;
+        private readonly Func<T, int> _hashCode = hashCode;
+
+        public bool Equals(T x, T y) => _equals(x, y);
+        public int GetHashCode(T obj) => _hashCode(obj);
+    }
+
+    [Fact]
+    public void HasDuplicates()
+    {
+        var comparer = new Comparer<int>((x, y) => x % 10 == y % 10, x => (x % 10).GetHashCode());
+
+        Assert.False(new int[0].HasDuplicates());
+        Assert.False(new int[0].HasDuplicates(comparer));
+        Assert.False(new int[0].HasDuplicates(i => i + 1));
+
+        Assert.False(new[] { 1 }.HasDuplicates());
+        Assert.False(new[] { 1 }.HasDuplicates(comparer));
+        Assert.False(new[] { 1 }.HasDuplicates(i => i + 1));
+
+        Assert.False(new[] { 1, 2 }.HasDuplicates());
+        Assert.False(new[] { 1, 2 }.HasDuplicates(comparer));
+        Assert.False(new[] { 1, 2 }.HasDuplicates(i => i + 1));
+
+        Assert.True(new[] { 1, 1 }.HasDuplicates());
+        Assert.True(new[] { 11, 1 }.HasDuplicates(comparer));
+        Assert.True(new[] { 1, 3 }.HasDuplicates(i => i % 2));
+        Assert.True(new[] { 11.0, 1.2 }.HasDuplicates(i => (int)i, comparer));
+
+        Assert.False(new[] { 2, 0, 1, 3 }.HasDuplicates());
+        Assert.False(new[] { 2, 0, 1, 13 }.HasDuplicates(comparer));
+        Assert.False(new[] { 2, 0, 1, 53 }.HasDuplicates(i => i % 10));
+        Assert.False(new[] { 2.3, 0.1, 1.3, 53.4 }.HasDuplicates(i => (int)i, comparer));
+
+        Assert.True(new[] { 2, 0, 1, 2 }.HasDuplicates());
+        Assert.True(new[] { 2, 0, 1, 12 }.HasDuplicates(comparer));
+        Assert.True(new[] { 2, 0, 1, 52 }.HasDuplicates(i => i % 10));
+        Assert.True(new[] { 2.3, 0.1, 1.3, 52.4 }.HasDuplicates(i => (int)i, comparer));
+    }
+}
+

src/Dependencies/Collections/Extensions/IEnumerableExtensions.cs

@@ -252,6 +252,72 @@ public static bool IsEmpty<T>(this List<T> source)
             return source.Count == 0;
         }
 
+        public static bool HasDuplicates<T>(this IEnumerable<T> source)
+            => source.HasDuplicates(EqualityComparer<T>.Default);
+
+        public static bool HasDuplicates<T>(this IEnumerable<T> source, IEqualityComparer<T> comparer)
+            => source.HasDuplicates(static x => x, comparer);
+
+        public static bool HasDuplicates<TItem, TValue>(this IEnumerable<TItem> source, Func<TItem, TValue> selector)
+            => source.HasDuplicates(selector, EqualityComparer<TValue>.Default);
+
+        /// <summary>
+        /// Determines whether duplicates exist using given equality comparer.
+        /// </summary>
+        /// <param name="source">Array to search for duplicates</param>
+        /// <returns>Whether duplicates were found</returns>
+        /// <remarks>
+        /// API proposal: https://github.com/dotnet/runtime/issues/30582.
+        /// <seealso cref="Microsoft.CodeAnalysis.ImmutableArrayExtensions.HasDuplicates{TItem, TValue}(ImmutableArray{TItem}, Func{TItem, TValue}, IEqualityComparer{TValue})"/>
+        /// </remarks>
+        public static bool HasDuplicates<TItem, TValue>(this IEnumerable<TItem> source, Func<TItem, TValue> selector, IEqualityComparer<TValue> comparer)
+        {
+            if (source is IReadOnlyList<TItem> list)
+            {
+                return list.HasDuplicates(selector, comparer);
+            }
+
+            TItem firstItem = default!;
+            HashSet<TValue>? set = null;
+            var isFirstItem = true;
+            var result = false;
+
+            foreach (var item in source)
+            {
+                if (isFirstItem)
+                {
+                    firstItem = item;
+                    isFirstItem = false;
+                    continue;
+                }
+
+                var value = selector(item);
+
+                if (set == null)
+                {
+                    var firstValue = selector(firstItem);
+
+                    if (comparer.Equals(value, firstValue))
+                    {
+                        result = true;
+                        break;
+                    }
+
+                    set = comparer == EqualityComparer<TValue>.Default ? PooledHashSet<TValue>.GetInstance() : new HashSet<TValue>(comparer);
+                    set.Add(firstValue);
+                    set.Add(value);
+                }
+                else if (!set.Add(value))
+                {
+                    result = true;
+                    break;
+                }
+            }
+
+            (set as PooledHashSet<TValue>)?.Free();
+            return result;
+        }
+
         private static readonly Func<object, bool> s_notNullTest = x => x != null;
 
         public static IEnumerable<T> WhereNotNull<T>(this IEnumerable<T?> source)

src/Dependencies/Collections/Extensions/IListExtensions.cs

@@ -0,0 +1,61 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using Microsoft.CodeAnalysis.PooledObjects;
+
+namespace Microsoft.CodeAnalysis;
+
+internal static class IListExtensions
+{
+    public static bool HasDuplicates<T>(this IReadOnlyList<T> list)
+        => list.HasDuplicates(EqualityComparer<T>.Default);
+
+    public static bool HasDuplicates<T>(this IReadOnlyList<T> list, IEqualityComparer<T> comparer)
+        => list.HasDuplicates(static x => x, comparer);
+
+    public static bool HasDuplicates<TItem, TValue>(this IReadOnlyList<TItem> list, Func<TItem, TValue> selector)
+        => list.HasDuplicates(selector, EqualityComparer<TValue>.Default);
+
+    /// <summary>
+    /// Determines whether duplicates exist using given equality comparer.
+    /// </summary>
+    /// <param name="list">Array to search for duplicates</param>
+    /// <returns>Whether duplicates were found</returns>
+    /// <remarks>
+    /// API proposal: https://github.com/dotnet/runtime/issues/30582.
+    /// <seealso cref="ImmutableArrayExtensions.HasDuplicates{TItem, TValue}(System.Collections.Immutable.ImmutableArray{TItem}, Func{TItem, TValue}, IEqualityComparer{TValue})"/>
+    /// <seealso cref="Roslyn.Utilities.EnumerableExtensions.HasDuplicates{TItem, TValue}(IEnumerable{TItem}, Func{TItem, TValue}, IEqualityComparer{TValue})"/>
+    /// </remarks>
+    internal static bool HasDuplicates<TItem, TValue>(this IReadOnlyList<TItem> list, Func<TItem, TValue> selector, IEqualityComparer<TValue> comparer)
+    {
+        switch (list.Count)
+        {
+            case 0:
+            case 1:
+                return false;
+
+            case 2:
+                return comparer.Equals(selector(list[0]), selector(list[1]));
+
+            default:
+                var set = comparer == EqualityComparer<TValue>.Default ? PooledHashSet<TValue>.GetInstance() : new HashSet<TValue>(comparer);
+                var result = false;
+
+                // index to avoid allocating enumerator
+                for (int i = 0, n = list.Count; i < n; i++)
+                {
+                    if (!set.Add(selector(list[i])))
+                    {
+                        result = true;
+                        break;
+                    }
+                }
+
+                (set as PooledHashSet<TValue>)?.Free();
+                return result;
+        }
+    }
+}