Fix #10538 - Cannot swap a std.typecons.Tuple (#8864)

* Fix #10538 - Cannot swap a std.typecons.Tuple

Co-authored-by: Elias Batek <0xEAB@users.noreply.github.com>

* De-optimize `opAssign` of `std.typecons.Tuple`

---------

Co-authored-by: Elias Batek <0xEAB@users.noreply.github.com>
Co-authored-by: Elias Batek <desisma@heidel.beer>

Author: ntrel

std/algorithm/mutation.d

@@ -2885,6 +2885,17 @@ if (isBlitAssignable!T && !is(typeof(lhs.proxySwap(rhs))))
     {
         if (&lhs != &rhs)
         {
+            static if (__traits(compiles, lhs.tupleof = rhs.tupleof))
+            {
+                if (__ctfe)
+                {
+                    // can't reinterpret cast
+                    foreach (i, ref e; lhs.tupleof)
+                        swap(e, rhs.tupleof[i]);
+                    return;
+                }
+            }
+
             // For structs with non-trivial assignment, move memory directly
             ubyte[T.sizeof] t = void;
             auto a = (cast(ubyte*) &lhs)[0 .. T.sizeof];
@@ -3128,6 +3139,18 @@ if (isBlitAssignable!T && !is(typeof(lhs.proxySwap(rhs))))
     swap(a3, a4);
 }
 
+// https://issues.dlang.org/show_bug.cgi?id=21429
+@safe unittest
+{
+    enum e = (){
+        Tuple!int a = 5, b = 6;
+        swap(a, b);
+        assert(a[0] == 6);
+        assert(b[0] == 5);
+        return 0;
+    }();
+}
+
 /**
 Swaps two elements in-place of a range `r`,
 specified by their indices `i1` and `i2`.

std/typecons.d

@@ -980,24 +980,35 @@ if (distinctFieldNames!(Specs))
         {
             import std.algorithm.mutation : swap;
 
-            static if (is(R == Tuple!Types) && !__traits(isRef, rhs) && isTuple!R)
+            /*
+                This optimization caused compilation failures with no error message available:
+
+                > Error: unknown, please file report on issues.dlang.org
+                > std/sumtype.d(1262): Error: template instance `std.sumtype.SumType!(Flag, Tuple!(This*))` error instantiating
+            */
+            version (none)
             {
-                if (__ctfe)
+                static if (is(R == Tuple!Types) && !__traits(isRef, rhs) && isTuple!R)
                 {
-                    // Cannot use swap at compile time
-                    field[] = rhs.field[];
+                    if (__ctfe)
+                    {
+                        // Cannot use swap at compile time
+                        field[] = rhs.field[];
+                    }
+                    else
+                    {
+                        // Use swap-and-destroy to optimize rvalue assignment
+                        swap!(Tuple!Types)(this, rhs);
+                    }
                 }
                 else
                 {
-                    // Use swap-and-destroy to optimize rvalue assignment
-                    swap!(Tuple!Types)(this, rhs);
+                    // Do not swap; opAssign should be called on the fields.
+                    field[] = rhs.field[];
                 }
             }
-            else
-            {
-                // Do not swap; opAssign should be called on the fields.
-                field[] = rhs.field[];
-            }
+
+            field[] = rhs.field[];
             return this;
         }