Add @nogc variants for array utils functions

Also use enforceRawArraysConformableNogc in _d_arrayctor

Signed-off-by: Teodor Dutu <[email protected]>

Author: teodutu

src/core/internal/array/construction.d

@@ -28,20 +28,25 @@ Tarr _d_arrayctor(Tarr : T[], T)(return scope Tarr to, scope Tarr from) @trusted
     import core.lifetime : copyEmplace;
     import core.stdc.string : memcpy;
     import core.stdc.stdint : uintptr_t;
-    debug(PRINTF) import core.stdc.stdio;
+    debug(PRINTF) import core.stdc.stdio : printf;
 
     debug(PRINTF) printf("_d_arrayctor(to = %p,%d, from = %p,%d) size = %d\n", from.ptr, from.length, to.ptr, to.length, T.tsize);
 
-    // Rewrite `enforceRawArraysConformable` manually to allow @nogc.
-    // Use more austere errors because @nogc doesn't allow string concatenation.
     void[] vFrom = (cast(void*)from.ptr)[0..from.length];
     void[] vTo = (cast(void*)to.ptr)[0..to.length];
-    assert(vFrom.length == vTo.length, "Array lengths don't match");
 
-    const ptrTo = cast(uintptr_t)vTo.ptr;
-    const ptrFrom = cast(uintptr_t)vFrom.ptr;
-    const d = ptrTo > ptrFrom ? ptrTo - ptrFrom : ptrFrom - ptrTo;
-    assert(d >= vFrom.length * T.sizeof, "Overlapping arrays");
+    // Force `enforceRawArraysConformable` to be `pure`
+    void enforceRawArraysConformable(const char[] action, const size_t elementSize,
+        const void[] a1, const void[] a2) @trusted
+    {
+        import core.internal.util.array : enforceRawArraysConformableNogc;
+
+        alias Type = void function(const char[] action, const size_t elementSize,
+            const void[] a1, const void[] a2, in bool allowOverlap = false) @nogc pure nothrow;
+        (cast(Type)&enforceRawArraysConformableNogc)(action, elementSize, a1, a2, false);
+    }
+
+    enforceRawArraysConformable("initialization", T.sizeof, vFrom, vTo);
 
     static if (hasElaborateCopyConstructor!T)
     {

src/core/internal/util/array.d

@@ -13,6 +13,17 @@ import core.internal.string;
 import core.stdc.stdint;
 
 
+// TLS storage shared for all error messages.
+private align(2 * size_t.sizeof) char[256] _store;
+
+private char[] errorMessage(Args...)(scope const(char*) format,
+    const char[] action, Args args) @trusted
+{
+    import core.stdc.stdio : snprintf;
+    snprintf(&_store[0], _store.sizeof, format, &action[0], args);
+    return _store;
+}
+
 @safe /* pure dmd @@@BUG11461@@@ */ nothrow:
 
 void enforceTypedArraysConformable(T)(const char[] action,
@@ -65,6 +76,44 @@ private void _enforceNoOverlap(const char[] action,
     assert(0, msg);
 }
 
+void enforceTypedArraysConformableNogc(T)(const char[] action,
+    const T[] a1, const T[] a2, const bool allowOverlap = false)
+{
+    _enforceSameLengthNogc(action, a1.length, a2.length);
+    if (!allowOverlap)
+        _enforceNoOverlapNogc(action, arrayToPtr(a1), arrayToPtr(a2), T.sizeof * a1.length);
+}
+
+void enforceRawArraysConformableNogc(const char[] action, const size_t elementSize,
+    const void[] a1, const void[] a2, const bool allowOverlap = false)
+{
+    _enforceSameLengthNogc(action, a1.length, a2.length);
+    if (!allowOverlap)
+        _enforceNoOverlapNogc(action, arrayToPtr(a1), arrayToPtr(a2), elementSize * a1.length);
+}
+
+private void _enforceNoOverlapNogc(const ref char[] action,
+    uintptr_t ptr1, uintptr_t ptr2, const size_t bytes)
+{
+    const d = ptr1 > ptr2 ? ptr1 - ptr2 : ptr2 - ptr1;
+    if (d >= bytes)
+        return;
+    const overlappedBytes = bytes - d;
+
+    assert(0, errorMessage("Overlapping arrays in %s: %zu byte(s) overlap of %zu",
+        action, overlappedBytes, bytes));
+}
+
+private void _enforceSameLengthNogc(const ref char[] action,
+    const size_t length1, const size_t length2)
+{
+    if (length1 == length2)
+        return;
+
+    assert(0, errorMessage("Array lengths don't match for %s: %zu != %zu",
+        action, length1, length2));
+}
+
 private uintptr_t arrayToPtr(const void[] array) @trusted
 {
     // Ok because the user will never dereference the pointer