Implement tuple-compatible _d_assert_fail2

The goal of this new hook is to superseed the current hook,
but since there is an inter-dependence between DMD and druntime,
we just introduce a new symbol and will remove the old one
in a future PR after DMD has been adapted.

Author: Geod24

src/core/internal/dassert.d

@@ -47,27 +47,50 @@ string _d_assert_fail(string comp, A, B)(auto ref const scope A a, auto ref cons
  * Returns:
  *   A string such as "$a != true" or "$a == true".
  */
+string _d_assert_fail2(A)(string op, auto ref const scope A a)
+{
+    string[2] vals = [ miniFormatFakeAttributes(a), "true" ];
+    immutable token = op == "!" ? "==" : "!=";
+    return combine(vals[0 .. 1], token, vals[1 .. $]);
+}
+
+/// Ditto
 string _d_assert_fail(A)(const scope string op, auto ref const scope A a)
 {
-    string val = miniFormatFakeAttributes(a);
+    string[2] vals = [ miniFormatFakeAttributes(a), "true" ];
     immutable token = op == "!" ? "==" : "!=";
-    return combine(val, token, "true");
+    return combine(vals[0 .. 1], token, vals[1 .. $]);
 }
 
 /**
  * Generates rich assert error messages for binary expressions
  *
  * The binary expression `assert(x == y)` will be turned into
- * `assert(x == y, _d_assert_fail("==", x, y))`.
+ * `assert(x == y, _d_assert_fail!(typeof(x))("==", x, y))`.
  *
  * Params:
  *   comp = Comparison operator that was used in the expression.
- *   a  = Left hand side operand.
- *   b  = Right hand side operand.
+ *   a  = Left hand side operand (can be a tuple).
+ *   b  = Right hand side operand (can be a tuple).
  *
  * Returns:
  *   A string such as "$a $comp $b".
  */
+template _d_assert_fail2(A...) {
+    string _d_assert_fail2(B...)(
+        string comp, auto ref const scope A a, auto ref const scope B b)
+    {
+        string[A.length + B.length] vals;
+        static foreach (idx; 0 .. A.length)
+            vals[idx] = miniFormatFakeAttributes(a[idx]);
+        static foreach (idx; 0 .. B.length)
+            vals[A.length + idx] = miniFormatFakeAttributes(b[idx]);
+        immutable token = invertCompToken(comp);
+        return combine(vals[0 .. A.length], token, vals[A.length .. $]);
+    }
+}
+
+/// Ditto
 string _d_assert_fail(A, B)(const scope string comp, auto ref const scope A a, auto ref const scope B b)
 {
     /*
@@ -77,26 +100,44 @@ string _d_assert_fail(A, B)(const scope string comp, auto ref const scope A a, a
     Hence, we can fake purity and @nogc-ness here.
     */
 
-    string valA = miniFormatFakeAttributes(a);
-    string valB = miniFormatFakeAttributes(b);
+    string[1] valA = miniFormatFakeAttributes(a);
+    string[1] valB = miniFormatFakeAttributes(b);
     immutable token = invertCompToken(comp);
-    return combine(valA, token, valB);
+    return combine(valA[], token, valB[]);
 }
 
 /// Combines the supplied arguments into one string "valA token valB"
-private string combine(const scope string valA, const scope string token,
-const scope string valB) pure nothrow @nogc @safe
+private string combine(const scope string[] valA, const scope string token,
+    const scope string[] valB) pure nothrow @nogc @safe
 {
-    const totalLen = valA.length + token.length + valB.length + 2;
+    // Each separator is 2 chars (", "), plus the two spaces around the token.
+    size_t totalLen = (valA.length - 1) * 2 +
+        (valB.length - 1) * 2 + 2 + token.length;
+    foreach (v; valA) totalLen += v.length;
+    foreach (v; valB) totalLen += v.length;
     char[] buffer = cast(char[]) pureAlloc(totalLen)[0 .. totalLen];
     // @nogc-concat of "<valA> <comp> <valB>"
-    auto n = valA.length;
-    buffer[0 .. n] = valA;
+    static void formatTuple (scope char[] buffer, ref size_t n, in string[] vals)
+    {
+        foreach (idx, v; vals)
+        {
+            if (idx)
+            {
+                buffer[n++] = ',';
+                buffer[n++] = ' ';
+            }
+            buffer[n .. n + v.length] = v;
+            n += v.length;
+        }
+    }
+
+    size_t n;
+    formatTuple(buffer, n, valA);
     buffer[n++] = ' ';
     buffer[n .. n + token.length] = token;
     n += token.length;
     buffer[n++] = ' ';
-    buffer[n .. n + valB.length] = valB;
+    formatTuple(buffer, n, valB);
     return (() @trusted => cast(string) buffer)();
 }
 
@@ -371,7 +412,7 @@ private string invertCompToken(string comp) pure nothrow @nogc @safe
         case "!in":
             return "in";
         default:
-            assert(0, combine("Invalid comparison operator", "-", comp));
+            assert(0, combine(["Invalid comparison operator"], "-", [comp]));
     }
 }