Add asserts to catch unintentional use of generic overloads

src/coreclr/src/System.Private.CoreLib/src/System/RuntimeType.CoreCLR.cs

@@ -4288,7 +4288,7 @@ internal bool Equals(MdUtf8String s)
             }
             else
             {
-                return SpanHelpers.SequenceEqual<byte>(ref *s.m_pStringHeap, ref *m_pStringHeap, m_StringHeapByteLength);
+                return SpanHelpers.SequenceEqual(ref *s.m_pStringHeap, ref *m_pStringHeap, (uint)m_StringHeapByteLength);
             }
         }
 

src/libraries/System.Private.CoreLib/src/System/Runtime/CompilerServices/ConfiguredValueTaskAwaitable.cs

@@ -8,9 +8,7 @@
 using System.Threading.Tasks;
 using System.Threading.Tasks.Sources;
 
-#if !NETSTANDARD2_0
 using Internal.Runtime.CompilerServices;
-#endif
 
 namespace System.Runtime.CompilerServices
 {

src/libraries/System.Private.CoreLib/src/System/Runtime/CompilerServices/ValueTaskAwaiter.cs

@@ -7,9 +7,7 @@
 using System.Threading.Tasks;
 using System.Threading.Tasks.Sources;
 
-#if !NETSTANDARD2_0
 using Internal.Runtime.CompilerServices;
-#endif
 
 namespace System.Runtime.CompilerServices
 {

src/libraries/System.Private.CoreLib/src/System/SpanHelpers.T.cs

@@ -3,16 +3,19 @@
 // See the LICENSE file in the project root for more information.
 
 using System.Diagnostics;
-#if !NETSTANDARD2_0
+using System.Runtime.CompilerServices;
+
 using Internal.Runtime.CompilerServices;
-#endif
 
 namespace System
 {
     internal static partial class SpanHelpers // .T
     {
         public static int IndexOf<T>(ref T searchSpace, int searchSpaceLength, ref T value, int valueLength) where T : IEquatable<T>
         {
+            // The optimized implementation should be used for these types
+            Debug.Assert(!RuntimeHelpers.IsBitwiseEquatable<T>() || !(Unsafe.SizeOf<T>() == sizeof(byte) || Unsafe.SizeOf<T>() == sizeof(char)));
+
             Debug.Assert(searchSpaceLength >= 0);
             Debug.Assert(valueLength >= 0);
 
@@ -49,6 +52,9 @@ public static int IndexOf<T>(ref T searchSpace, int searchSpaceLength, ref T val
         // Adapted from IndexOf(...)
         public static unsafe bool Contains<T>(ref T searchSpace, T value, int length) where T : IEquatable<T>
         {
+            // The optimized implementation should be used for these types
+            Debug.Assert(!RuntimeHelpers.IsBitwiseEquatable<T>() || !(Unsafe.SizeOf<T>() == sizeof(byte) || Unsafe.SizeOf<T>() == sizeof(char)));
+
             Debug.Assert(length >= 0);
 
             IntPtr index = (IntPtr)0; // Use IntPtr for arithmetic to avoid unnecessary 64->32->64 truncations
@@ -119,6 +125,9 @@ public static unsafe bool Contains<T>(ref T searchSpace, T value, int length) wh
 
         public static unsafe int IndexOf<T>(ref T searchSpace, T value, int length) where T : IEquatable<T>
         {
+            // The optimized implementation should be used for these types
+            Debug.Assert(!RuntimeHelpers.IsBitwiseEquatable<T>() || !(Unsafe.SizeOf<T>() == sizeof(byte) || Unsafe.SizeOf<T>() == sizeof(char)));
+
             Debug.Assert(length >= 0);
 
             IntPtr index = (IntPtr)0; // Use IntPtr for arithmetic to avoid unnecessary 64->32->64 truncations
@@ -206,6 +215,9 @@ public static unsafe int IndexOf<T>(ref T searchSpace, T value, int length) wher
 
         public static int IndexOfAny<T>(ref T searchSpace, T value0, T value1, int length) where T : IEquatable<T>
         {
+            // The optimized implementation should be used for these types
+            Debug.Assert(!RuntimeHelpers.IsBitwiseEquatable<T>() || !(Unsafe.SizeOf<T>() == sizeof(byte) || Unsafe.SizeOf<T>() == sizeof(char)));
+
             Debug.Assert(length >= 0);
 
             T lookUp;
@@ -310,6 +322,9 @@ public static int IndexOfAny<T>(ref T searchSpace, T value0, T value1, int lengt
 
         public static int IndexOfAny<T>(ref T searchSpace, T value0, T value1, T value2, int length) where T : IEquatable<T>
         {
+            // The optimized implementation should be used for these types
+            Debug.Assert(!RuntimeHelpers.IsBitwiseEquatable<T>() || !(Unsafe.SizeOf<T>() == sizeof(byte) || Unsafe.SizeOf<T>() == sizeof(char)));
+
             Debug.Assert(length >= 0);
 
             T lookUp;
@@ -413,6 +428,9 @@ public static int IndexOfAny<T>(ref T searchSpace, T value0, T value1, T value2,
 
         public static int IndexOfAny<T>(ref T searchSpace, int searchSpaceLength, ref T value, int valueLength) where T : IEquatable<T>
         {
+            // The optimized implementation should be used for these types
+            Debug.Assert(!RuntimeHelpers.IsBitwiseEquatable<T>() || !(Unsafe.SizeOf<T>() == sizeof(byte) || Unsafe.SizeOf<T>() == sizeof(char)));
+
             Debug.Assert(searchSpaceLength >= 0);
             Debug.Assert(valueLength >= 0);
 
@@ -472,6 +490,9 @@ public static int LastIndexOf<T>(ref T searchSpace, int searchSpaceLength, ref T
 
         public static int LastIndexOf<T>(ref T searchSpace, T value, int length) where T : IEquatable<T>
         {
+            // The optimized implementation should be used for these types
+            Debug.Assert(!RuntimeHelpers.IsBitwiseEquatable<T>() || !(Unsafe.SizeOf<T>() == sizeof(byte) || Unsafe.SizeOf<T>() == sizeof(char)));
+
             Debug.Assert(length >= 0);
 
             if (default(T)! != null || (object)value != null) // TODO-NULLABLE: default(T) == null warning (https://github.com/dotnet/roslyn/issues/34757)
@@ -553,6 +574,9 @@ public static int LastIndexOf<T>(ref T searchSpace, T value, int length) where T
 
         public static int LastIndexOfAny<T>(ref T searchSpace, T value0, T value1, int length) where T : IEquatable<T>
         {
+            // The optimized implementation should be used for these types
+            Debug.Assert(!RuntimeHelpers.IsBitwiseEquatable<T>() || !(Unsafe.SizeOf<T>() == sizeof(byte) || Unsafe.SizeOf<T>() == sizeof(char)));
+
             Debug.Assert(length >= 0);
 
             T lookUp;
@@ -656,6 +680,9 @@ public static int LastIndexOfAny<T>(ref T searchSpace, T value0, T value1, int l
 
         public static int LastIndexOfAny<T>(ref T searchSpace, T value0, T value1, T value2, int length) where T : IEquatable<T>
         {
+            // The optimized implementation should be used for these types
+            Debug.Assert(!RuntimeHelpers.IsBitwiseEquatable<T>() || !(Unsafe.SizeOf<T>() == sizeof(byte) || Unsafe.SizeOf<T>() == sizeof(char)));
+
             Debug.Assert(length >= 0);
 
             T lookUp;
@@ -759,6 +786,9 @@ public static int LastIndexOfAny<T>(ref T searchSpace, T value0, T value1, T val
 
         public static int LastIndexOfAny<T>(ref T searchSpace, int searchSpaceLength, ref T value, int valueLength) where T : IEquatable<T>
         {
+            // The optimized implementation should be used for these types
+            Debug.Assert(!RuntimeHelpers.IsBitwiseEquatable<T>() || !(Unsafe.SizeOf<T>() == sizeof(byte) || Unsafe.SizeOf<T>() == sizeof(char)));
+
             Debug.Assert(searchSpaceLength >= 0);
             Debug.Assert(valueLength >= 0);
 
@@ -777,6 +807,9 @@ public static int LastIndexOfAny<T>(ref T searchSpace, int searchSpaceLength, re
 
         public static bool SequenceEqual<T>(ref T first, ref T second, int length) where T : IEquatable<T>
         {
+            // The optimized implementation should be used for these types
+            Debug.Assert(!RuntimeHelpers.IsBitwiseEquatable<T>() || !(Unsafe.SizeOf<T>() == sizeof(byte) || Unsafe.SizeOf<T>() == sizeof(char)));
+
             Debug.Assert(length >= 0);
 
             if (Unsafe.AreSame(ref first, ref second))
@@ -869,6 +902,9 @@ public static bool SequenceEqual<T>(ref T first, ref T second, int length) where
         public static int SequenceCompareTo<T>(ref T first, int firstLength, ref T second, int secondLength)
             where T : IComparable<T>
         {
+            // The optimized implementation should be used for these types
+            Debug.Assert(typeof(T) != typeof(byte) && typeof(T) != typeof(char));
+
             Debug.Assert(firstLength >= 0);
             Debug.Assert(secondLength >= 0);