Use generics only for value type comparers

Author: 2A5F

src/libraries/System.Private.CoreLib/src/System/Collections/Generic/ArraySortHelper.cs

@@ -70,6 +70,26 @@ internal static void Sort(Span<T> keys, Comparison<T> comparer)
             }
         }
 
+        internal static void Sort<TComparer>(Span<T> keys, TComparer comparer)
+            where TComparer : IComparer<T>
+        {
+            Debug.Assert(comparer != null, "Check the arguments in the caller!");
+
+            // Add a try block here to detect bogus comparisons
+            try
+            {
+                IntrospectiveSort(keys, comparer);
+            }
+            catch (IndexOutOfRangeException)
+            {
+                ThrowHelper.ThrowArgumentException_BadComparer(comparer);
+            }
+            catch (Exception e)
+            {
+                ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_IComparerFailed, e);
+            }
+        }
+
         internal static int InternalBinarySearch(T[] array, int index, int length, T value, IComparer<T> comparer)
         {
             Debug.Assert(array != null, "Check the arguments in the caller!");
@@ -108,6 +128,19 @@ private static void SwapIfGreater(Span<T> keys, Comparison<T> comparer, int i, i
             }
         }
 
+        private static void SwapIfGreater<TComparer>(Span<T> keys, TComparer comparer, int i, int j)
+            where TComparer : IComparer<T>, allows ref struct
+        {
+            Debug.Assert(i != j);
+
+            if (comparer.Compare(keys[i], keys[j]) > 0)
+            {
+                T key = keys[i];
+                keys[i] = keys[j];
+                keys[j] = key;
+            }
+        }
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private static void Swap(Span<T> a, int i, int j)
         {
@@ -128,6 +161,17 @@ internal static void IntrospectiveSort(Span<T> keys, Comparison<T> comparer)
             }
         }
 
+        internal static void IntrospectiveSort<TComparer>(Span<T> keys, TComparer comparer)
+            where TComparer : IComparer<T>, allows ref struct
+        {
+            Debug.Assert(comparer != null);
+
+            if (keys.Length > 1)
+            {
+                IntroSort(keys, 2 * (BitOperations.Log2((uint)keys.Length) + 1), comparer);
+            }
+        }
+
         // IntroSort is recursive; block it from being inlined into itself as
         // this is currenly not profitable.
         [MethodImpl(MethodImplOptions.NoInlining)]
@@ -176,6 +220,53 @@ private static void IntroSort(Span<T> keys, int depthLimit, Comparison<T> compar
             }
         }
 
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        private static void IntroSort<TComparer>(Span<T> keys, int depthLimit, TComparer comparer)
+            where TComparer : IComparer<T>, allows ref struct
+        {
+            Debug.Assert(!keys.IsEmpty);
+            Debug.Assert(depthLimit >= 0);
+            Debug.Assert(comparer != null);
+
+            int partitionSize = keys.Length;
+            while (partitionSize > 1)
+            {
+                if (partitionSize <= Array.IntrosortSizeThreshold)
+                {
+
+                    if (partitionSize == 2)
+                    {
+                        SwapIfGreater(keys, comparer, 0, 1);
+                        return;
+                    }
+
+                    if (partitionSize == 3)
+                    {
+                        SwapIfGreater(keys, comparer, 0, 1);
+                        SwapIfGreater(keys, comparer, 0, 2);
+                        SwapIfGreater(keys, comparer, 1, 2);
+                        return;
+                    }
+
+                    InsertionSort(keys.Slice(0, partitionSize), comparer);
+                    return;
+                }
+
+                if (depthLimit == 0)
+                {
+                    HeapSort(keys.Slice(0, partitionSize), comparer);
+                    return;
+                }
+                depthLimit--;
+
+                int p = PickPivotAndPartition(keys.Slice(0, partitionSize), comparer);
+
+                // Note we've already partitioned around the pivot and do not have to move the pivot again.
+                IntroSort(keys[(p + 1)..partitionSize], depthLimit, comparer);
+                partitionSize = p;
+            }
+        }
+
         private static int PickPivotAndPartition(Span<T> keys, Comparison<T> comparer)
         {
             Debug.Assert(keys.Length >= Array.IntrosortSizeThreshold);
@@ -214,6 +305,45 @@ private static int PickPivotAndPartition(Span<T> keys, Comparison<T> comparer)
             return left;
         }
 
+        private static int PickPivotAndPartition<TComparer>(Span<T> keys, TComparer comparer)
+            where TComparer : IComparer<T>, allows ref struct
+        {
+            Debug.Assert(keys.Length >= Array.IntrosortSizeThreshold);
+            Debug.Assert(comparer != null);
+
+            int hi = keys.Length - 1;
+
+            // Compute median-of-three.  But also partition them, since we've done the comparison.
+            int middle = hi >> 1;
+
+            // Sort lo, mid and hi appropriately, then pick mid as the pivot.
+            SwapIfGreater(keys, comparer, 0, middle);  // swap the low with the mid point
+            SwapIfGreater(keys, comparer, 0, hi);   // swap the low with the high
+            SwapIfGreater(keys, comparer, middle, hi); // swap the middle with the high
+
+            T pivot = keys[middle];
+            Swap(keys, middle, hi - 1);
+            int left = 0, right = hi - 1;  // We already partitioned lo and hi and put the pivot in hi - 1.  And we pre-increment & decrement below.
+
+            while (left < right)
+            {
+                while (comparer.Compare(keys[++left], pivot) < 0) ;
+                while (comparer.Compare(pivot, keys[--right]) < 0) ;
+
+                if (left >= right)
+                    break;
+
+                Swap(keys, left, right);
+            }
+
+            // Put pivot in the right location.
+            if (left != hi - 1)
+            {
+                Swap(keys, left, hi - 1);
+            }
+            return left;
+        }
+
         private static void HeapSort(Span<T> keys, Comparison<T> comparer)
         {
             Debug.Assert(comparer != null);
@@ -232,6 +362,25 @@ private static void HeapSort(Span<T> keys, Comparison<T> comparer)
             }
         }
 
+        private static void HeapSort<TComparer>(Span<T> keys, TComparer comparer)
+            where TComparer : IComparer<T>, allows ref struct
+        {
+            Debug.Assert(comparer != null);
+            Debug.Assert(!keys.IsEmpty);
+
+            int n = keys.Length;
+            for (int i = n >> 1; i >= 1; i--)
+            {
+                DownHeap(keys, i, n, comparer);
+            }
+
+            for (int i = n; i > 1; i--)
+            {
+                Swap(keys, 0, i - 1);
+                DownHeap(keys, 1, i - 1, comparer);
+            }
+        }
+
         private static void DownHeap(Span<T> keys, int i, int n, Comparison<T> comparer)
         {
             Debug.Assert(comparer != null);
@@ -255,6 +404,30 @@ private static void DownHeap(Span<T> keys, int i, int n, Comparison<T> comparer)
             keys[i - 1] = d;
         }
 
+        private static void DownHeap<TComparer>(Span<T> keys, int i, int n, TComparer comparer)
+            where TComparer : IComparer<T>, allows ref struct
+        {
+            Debug.Assert(comparer != null);
+
+            T d = keys[i - 1];
+            while (i <= n >> 1)
+            {
+                int child = 2 * i;
+                if (child < n && comparer.Compare(keys[child - 1], keys[child]) < 0)
+                {
+                    child++;
+                }
+
+                if (!(comparer.Compare(d, keys[child - 1]) < 0))
+                    break;
+
+                keys[i - 1] = keys[child - 1];
+                i = child;
+            }
+
+            keys[i - 1] = d;
+        }
+
         private static void InsertionSort(Span<T> keys, Comparison<T> comparer)
         {
             for (int i = 0; i < keys.Length - 1; i++)
@@ -271,6 +444,24 @@ private static void InsertionSort(Span<T> keys, Comparison<T> comparer)
                 keys[j + 1] = t;
             }
         }
+
+        private static void InsertionSort<TComparer>(Span<T> keys, TComparer comparer)
+            where TComparer : IComparer<T>, allows ref struct
+        {
+            for (int i = 0; i < keys.Length - 1; i++)
+            {
+                T t = keys[i + 1];
+
+                int j = i;
+                while (j >= 0 && comparer.Compare(t, keys[j]) < 0)
+                {
+                    keys[j + 1] = keys[j];
+                    j--;
+                }
+
+                keys[j + 1] = t;
+            }
+        }
     }
 
     internal sealed partial class GenericArraySortHelper<T>
@@ -478,7 +669,7 @@ private static unsafe int PickPivotAndPartition(Span<T> keys)
             {
                 if (pivot == null)
                 {
-                    while (Unsafe.IsAddressLessThan(ref leftRef, ref nextToLastRef) && (leftRef = ref Unsafe.Add(ref leftRef, 1)) == null) ;
+                    while (Unsafe.IsAddressLessThan(ref leftRef, ref nextToLastRef) && (leftRef = ref Unsafe.Add(ref leftRef!, 1)) == null) ;
                     while (Unsafe.IsAddressGreaterThan(ref rightRef, ref zeroRef) && (rightRef = ref Unsafe.Add(ref rightRef, -1)) != null) ;
                 }
                 else
@@ -492,13 +683,13 @@ private static unsafe int PickPivotAndPartition(Span<T> keys)
                     break;
                 }
 
-                Swap(ref leftRef, ref rightRef);
+                Swap(ref leftRef!, ref rightRef!);
             }
 
             // Put the pivot in the correct location.
             if (!Unsafe.AreSame(ref leftRef, ref nextToLastRef))
             {
-                Swap(ref leftRef, ref nextToLastRef);
+                Swap(ref leftRef!, ref nextToLastRef);
             }
 
             return (int)((nint)Unsafe.ByteOffset(ref zeroRef, ref leftRef) / sizeof(T));
@@ -630,7 +821,27 @@ public void Sort(Span<TKey> keys, Span<TValue> values, IComparer<TKey>? comparer
             }
         }
 
-        private static void SwapIfGreaterWithValues(Span<TKey> keys, Span<TValue> values, IComparer<TKey> comparer, int i, int j)
+        public static void Sort<TComparer>(Span<TKey> keys, Span<TValue> values, TComparer comparer)
+            where TComparer : IComparer<TKey>
+        {
+            // Add a try block here to detect IComparers (or their
+            // underlying IComparables, etc) that are bogus.
+            try
+            {
+                IntrospectiveSort(keys, values, comparer);
+            }
+            catch (IndexOutOfRangeException)
+            {
+                ThrowHelper.ThrowArgumentException_BadComparer(comparer);
+            }
+            catch (Exception e)
+            {
+                ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_IComparerFailed, e);
+            }
+        }
+
+        private static void SwapIfGreaterWithValues<TComparer>(Span<TKey> keys, Span<TValue> values, TComparer comparer, int i, int j)
+            where TComparer : IComparer<TKey>, allows ref struct
         {
             Debug.Assert(comparer != null);
             Debug.Assert(0 <= i && i < keys.Length && i < values.Length);
@@ -663,7 +874,8 @@ private static void Swap(Span<TKey> keys, Span<TValue> values, int i, int j)
             values[j] = v;
         }
 
-        internal static void IntrospectiveSort(Span<TKey> keys, Span<TValue> values, IComparer<TKey> comparer)
+        internal static void IntrospectiveSort<TComparer>(Span<TKey> keys, Span<TValue> values, TComparer comparer)
+            where TComparer : IComparer<TKey>, allows ref struct
         {
             Debug.Assert(comparer != null);
             Debug.Assert(keys.Length == values.Length);
@@ -674,7 +886,8 @@ internal static void IntrospectiveSort(Span<TKey> keys, Span<TValue> values, ICo
             }
         }
 
-        private static void IntroSort(Span<TKey> keys, Span<TValue> values, int depthLimit, IComparer<TKey> comparer)
+        private static void IntroSort<TComparer>(Span<TKey> keys, Span<TValue> values, int depthLimit, TComparer comparer)
+            where TComparer : IComparer<TKey>, allows ref struct
         {
             Debug.Assert(!keys.IsEmpty);
             Debug.Assert(values.Length == keys.Length);
@@ -720,7 +933,8 @@ private static void IntroSort(Span<TKey> keys, Span<TValue> values, int depthLim
             }
         }
 
-        private static int PickPivotAndPartition(Span<TKey> keys, Span<TValue> values, IComparer<TKey> comparer)
+        private static int PickPivotAndPartition<TComparer>(Span<TKey> keys, Span<TValue> values, TComparer comparer)
+            where TComparer : IComparer<TKey>, allows ref struct
         {
             Debug.Assert(keys.Length >= Array.IntrosortSizeThreshold);
             Debug.Assert(comparer != null);
@@ -758,7 +972,8 @@ private static int PickPivotAndPartition(Span<TKey> keys, Span<TValue> values, I
             return left;
         }
 
-        private static void HeapSort(Span<TKey> keys, Span<TValue> values, IComparer<TKey> comparer)
+        private static void HeapSort<TComparer>(Span<TKey> keys, Span<TValue> values, TComparer comparer)
+            where TComparer : IComparer<TKey>, allows ref struct
         {
             Debug.Assert(comparer != null);
             Debug.Assert(!keys.IsEmpty);
@@ -776,7 +991,8 @@ private static void HeapSort(Span<TKey> keys, Span<TValue> values, IComparer<TKe
             }
         }
 
-        private static void DownHeap(Span<TKey> keys, Span<TValue> values, int i, int n, IComparer<TKey> comparer)
+        private static void DownHeap<TComparer>(Span<TKey> keys, Span<TValue> values, int i, int n, TComparer comparer)
+            where TComparer : IComparer<TKey>, allows ref struct
         {
             Debug.Assert(comparer != null);
 
@@ -803,7 +1019,8 @@ private static void DownHeap(Span<TKey> keys, Span<TValue> values, int i, int n,
             values[i - 1] = dValue;
         }
 
-        private static void InsertionSort(Span<TKey> keys, Span<TValue> values, IComparer<TKey> comparer)
+        private static void InsertionSort<TComparer>(Span<TKey> keys, Span<TValue> values, TComparer comparer)
+            where TComparer : IComparer<TKey>, allows ref struct
         {
             Debug.Assert(comparer != null);
 

src/libraries/System.Private.CoreLib/src/System/MemoryExtensions.cs

@@ -4313,7 +4313,16 @@ public static void Sort<T, TComparer>(this Span<T> span, TComparer comparer) whe
         {
             if (span.Length > 1)
             {
-                ArraySortHelper<T>.Default.Sort(span, comparer); // value-type comparer will be boxed
+                if (typeof(TComparer).IsValueType)
+                {
+                    #pragma warning disable CS8631
+                    ArraySortHelper<T>.Sort<TComparer>(span, comparer);
+                    #pragma warning restore CS8631
+                }
+                else
+                {
+                    ArraySortHelper<T>.Default.Sort(span, comparer);
+                }
             }
         }
 
@@ -4380,7 +4389,16 @@ public static void Sort<TKey, TValue, TComparer>(this Span<TKey> keys, Span<TVal
 
             if (keys.Length > 1)
             {
-                ArraySortHelper<TKey, TValue>.Default.Sort(keys, items, comparer); // value-type comparer will be boxed
+                if (typeof(TComparer).IsValueType)
+                {
+                    #pragma warning disable CS8631
+                    ArraySortHelper<TKey, TValue>.Sort<TComparer>(keys, items, comparer);
+                    #pragma warning restore CS8631
+                }
+                else
+                {
+                    ArraySortHelper<TKey, TValue>.Default.Sort(keys, items, comparer);
+                }
             }
         }