Fix Issue 21030 - Reduce template function instantiations related to array equality

Author: n8sh

src/core/internal/array/equality.d

@@ -23,20 +23,50 @@ bool __ArrayEq(T1, T2)(T1[] a, T2[] b)
     return true;
 }
 
+ // `lhs == rhs` lowers to `__equals(lhs, rhs)` for dynamic arrays
+ // The scalar-only overload takes advantage of known properties of scalars to
+ // consolidate IFTI instances and remove the need for helper functions.
+bool __equals(T1, T2)(scope const T1[] lhs, scope const T2[] rhs)
+@nogc nothrow pure @trusted
+if (__traits(isScalar, T1) && __traits(isScalar, T2))
+{
+    if (lhs.length != rhs.length)
+        return false;
+    static if (T1.sizeof == T2.sizeof
+        && __traits(isUnsigned, T1) == __traits(isUnsigned, T2)
+        && !__traits(isFloating, T1) && !__traits(isFloating, T2))
+    {
+        if (!__ctfe)
+        {
+            // This would improperly allow equality of integers and pointers
+            // but the CTFE branch will stop this function from compiling then.
+            import core.stdc.string : memcmp;
+            return lhs.length == 0 || 0 == memcmp(lhs.ptr, rhs.ptr, lhs.length * T1.sizeof);
+        }
+    }
+    foreach (const i; 0 .. lhs.length)
+        if (lhs.ptr[i] != rhs.ptr[i])
+            return false;
+    return true;
+}
+
+pragma(inline, true)
+private @trusted ref at(R)(return scope inout(R)[] r, size_t i) { return r.ptr[i]; }
+pragma(inline, true)
+private @trusted R trustedCast(R, S)(return scope S[] r) { return cast(R) r; }
+
  // `lhs == rhs` lowers to `__equals(lhs, rhs)` for dynamic arrays
 bool __equals(T1, T2)(T1[] lhs, T2[] rhs)
+if (!__traits(isScalar, T1) || !__traits(isScalar, T2))
 {
     import core.internal.traits : Unqual;
     alias U1 = Unqual!T1;
     alias U2 = Unqual!T2;
 
-    static @trusted ref R at(R)(R[] r, size_t i) { return r.ptr[i]; }
-    static @trusted R trustedCast(R, S)(S[] r) { return cast(R) r; }
-
     if (lhs.length != rhs.length)
         return false;
 
-    if (lhs.length == 0 && rhs.length == 0)
+    if (lhs.length == 0)
         return true;
 
     static if (is(U1 == void) && is(U2 == void))
@@ -64,24 +94,6 @@ bool __equals(T1, T2)(T1[] lhs, T2[] rhs)
         }
         return true;
     }
-    else static if (__traits(isIntegral, U1))
-    {
-
-        if (!__ctfe)
-        {
-            import core.stdc.string : memcmp;
-            return () @trusted { return memcmp(cast(void*)lhs.ptr, cast(void*)rhs.ptr, lhs.length * U1.sizeof) == 0; }();
-        }
-        else
-        {
-            foreach (const u; 0 .. lhs.length)
-            {
-                if (at(lhs, u) != at(rhs, u))
-                    return false;
-            }
-            return true;
-        }
-    }
     else
     {
         foreach (const u; 0 .. lhs.length)
@@ -91,11 +103,6 @@ bool __equals(T1, T2)(T1[] lhs, T2[] rhs)
                 if (!__equals(at(lhs, u), at(rhs, u)))
                     return false;
             }
-            else static if (__traits(isFloating, U1))
-            {
-                if (at(lhs, u) != at(rhs, u))
-                    return false;
-            }
             else static if (is(U1 : Object) && is(U2 : Object))
             {
                 if (!(cast(Object)at(lhs, u) is cast(Object)at(rhs, u)