Add tuple unpacking syntax

changelog/dmd.tuple-unpacking.dd

@@ -0,0 +1,30 @@
+Tuple unpacking is now supported!
+
+D now supports tuple unpacking for variable declarations, `foreach` loops, and function literal
+template parameters.
+This feature is available as a preview and can be enabled with the `-preview=tuples` compiler switch.
+It allows extracting multiple values from a tuple or compile-time sequence directly into distinct variables.
+
+-------
+// Requires -preview=tuples
+import std.typecons : tuple;
+
+void main()
+{
+    auto (x, y, z) = tuple(1, 2.5, "three");
+    assert(x == 1);
+    assert(y == 2.5);
+    assert(z == "three");
+
+    // Types can be specified explicitly
+    (int a, string b) = tuple(4, "five");
+
+    // Unpacking works in foreach loops
+    foreach ((i, s); [tuple(1, "one"), tuple(2, "two")])
+    {
+        // ...
+    }
+}
+-------
+
+For more information, see the D blog article: $(LINK2 https://blog.dlang.org/2026/04/12/dip-1053-a-tale-of-tuples/, DIP 1053 - A Tale of Tuples).

compiler/include/dmd/attrib.h

@@ -198,3 +198,23 @@ class UserAttributeDeclaration final : public AttribDeclaration
     const char *kind() const override;
     void accept(Visitor *v) override { v->visit(this); }
 };
+
+/***********************************************************
+ * Unpack declarations look like, e.g.:
+ * auto (a, b) = init;
+ * (int a, string b) = init;
+ */
+class UnpackDeclaration final : public AttribDeclaration
+{
+public:
+    Expression *_init;
+    ScopeDsymbol *scopesym;
+    StorageClass declared_storage_class;
+    StorageClass storage_class;
+    bool onStack;
+    bool lowered;
+
+    UnpackDeclaration *syntaxCopy(Dsymbol *) override;
+    const char *kind() const override;
+    void accept(Visitor *v) override { v->visit(this); }
+};

compiler/include/dmd/dsymbol.h

@@ -25,6 +25,7 @@ class ThisDeclaration;
 class BitFieldDeclaration;
 class TypeInfoDeclaration;
 class TupleDeclaration;
+class UnpackDeclaration;
 class AliasDeclaration;
 class AggregateDeclaration;
 class EnumDeclaration;
@@ -266,6 +267,7 @@ class Dsymbol : public ASTNode
     BitFieldDeclaration *isBitFieldDeclaration();
     TypeInfoDeclaration *isTypeInfoDeclaration();
     TupleDeclaration *isTupleDeclaration();
+    UnpackDeclaration *isUnpackDeclaration();
     AliasDeclaration *isAliasDeclaration();
     AggregateDeclaration *isAggregateDeclaration();
     FuncDeclaration *isFuncDeclaration();

compiler/include/dmd/globals.h

@@ -225,6 +225,7 @@ struct Param
                                  // Implementation: https://github.com/dlang/dmd/pull/9817
     FeatureState safer;          // safer by default (more @safe checks in unattributed code)
                                  // https://github.com/WalterBright/documents/blob/38f0a846726b571f8108f6e63e5e217b91421c86/safer.md
+    FeatureState tuples;         // Tuple unpacking
 
     FeatureState noSharedAccess; // read/write access to shared memory objects
     d_bool previewIn;              // `in` means `[ref] scope const`, accepts rvalues

compiler/include/dmd/mtype.h

@@ -33,6 +33,8 @@ class TemplateDeclaration;
 class TypeBasic;
 class Parameter;
 
+class UnpackDeclaration;
+
 // Back end
 #ifdef IN_GCC
 typedef union tree_node type;
@@ -428,9 +430,11 @@ class Parameter final : public ASTNode
     Identifier *ident;
     Expression *defaultArg;
     UserAttributeDeclaration *userAttribDecl;   // user defined attributes
+    UnpackDeclaration *unpack;
 
     static Parameter *create(Loc loc, StorageClass storageClass, Type *type, Identifier *ident,
-                             Expression *defaultArg, UserAttributeDeclaration *userAttribDecl);
+                             Expression *defaultArg, UserAttributeDeclaration *userAttribDecl,
+                             UnpackDeclaration *unpack);
     Parameter *syntaxCopy();
     bool isLazy() const;
     bool isReference() const;

compiler/include/dmd/visitor.h

@@ -113,6 +113,7 @@ class StaticIfDeclaration;
 class MixinDeclaration;
 class StaticForeachDeclaration;
 class UserAttributeDeclaration;
+class UnpackDeclaration;
 class ForwardingAttribDeclaration;
 
 class ScopeDsymbol;
@@ -377,6 +378,7 @@ class ParseTimeVisitor
     virtual void visit(StorageClassDeclaration *s) { visit((AttribDeclaration *)s); }
     virtual void visit(ConditionalDeclaration *s) { visit((AttribDeclaration *)s); }
     virtual void visit(StaticForeachDeclaration *s) { visit((AttribDeclaration *)s); }
+    virtual void visit(UnpackDeclaration *s) { visit((AttribDeclaration *)s); }
 
     // Miscellaneous
     virtual void visit(DeprecatedDeclaration *s) { visit((StorageClassDeclaration *)s); }

compiler/src/dmd/astbase.d

@@ -262,6 +262,20 @@ struct ASTBase
         {
             v.visit(this);
         }
+
+        extern (D) static Dsymbols* arraySyntaxCopy(Dsymbols* a)
+        {
+            Dsymbols* b = null;
+            if (a)
+            {
+                b = a.copy();
+                for (size_t i = 0; i < b.length; i++)
+                {
+                    (*b)[i] = (*b)[i].syntaxCopy(null);
+                }
+            }
+            return b;
+        }
     }
 
     extern (C++) class AliasThis : Dsymbol
@@ -1346,6 +1360,33 @@ struct ASTBase
         }
     }
 
+    extern (C++) final class UnpackDeclaration : AttribDeclaration
+    {
+        Dsymbols* vars;
+        Expression _init;
+        StorageClass storage_class;
+
+        extern (D) this(Loc loc, Dsymbols* vars, Expression _init, StorageClass storage_class)
+        {
+            super(null);
+            this.loc = loc;
+            this.vars = vars;
+            this._init = _init;
+            this.storage_class = storage_class;
+        }
+
+        override UnpackDeclaration syntaxCopy(Dsymbol s)
+        {
+            return new UnpackDeclaration(loc, Dsymbol.arraySyntaxCopy(vars), _init ? _init.syntaxCopy() : null, storage_class);
+        }
+
+        override void accept(Visitor v)
+        {
+            v.visit(this);
+        }
+    }
+
+
     extern (C++) final class EnumMember : VarDeclaration
     {
         Expression origValue;
@@ -1703,16 +1744,18 @@ struct ASTBase
         Identifier ident;
         Expression defaultArg;
         UserAttributeDeclaration userAttribDecl; // user defined attributes
+        UnpackDeclaration unpack;
 
         extern (D) alias ForeachDg = int delegate(size_t idx, Parameter param);
 
-        final extern (D) this(Loc loc, StorageClass storageClass, Type type, Identifier ident, Expression defaultArg, UserAttributeDeclaration userAttribDecl)
+        final extern (D) this(Loc loc, StorageClass storageClass, Type type, Identifier ident, Expression defaultArg, UserAttributeDeclaration userAttribDecl, UnpackDeclaration unpack)
         {
             this.storageClass = storageClass;
             this.type = type;
             this.ident = ident;
             this.defaultArg = defaultArg;
             this.userAttribDecl = userAttribDecl;
+            this.unpack = unpack;
         }
 
         static size_t dim(Parameters* parameters)
@@ -1779,7 +1822,7 @@ struct ASTBase
 
         Parameter syntaxCopy()
         {
-            return new Parameter(loc, storageClass, type ? type.syntaxCopy() : null, ident, defaultArg ? defaultArg.syntaxCopy() : null, userAttribDecl ? userAttribDecl.syntaxCopy(null) : null);
+            return new Parameter(loc, storageClass, type ? type.syntaxCopy() : null, ident, defaultArg ? defaultArg.syntaxCopy() : null, userAttribDecl ? userAttribDecl.syntaxCopy(null) : null, unpack ? unpack.syntaxCopy(null) : null);
         }
 
         override void accept(Visitor v)
@@ -3638,7 +3681,7 @@ struct ASTBase
                     Expression e = (*exps)[i];
                     if (e.type.ty == Ttuple)
                         error(e.loc, "cannot form sequence of sequences");
-                    auto arg = new Parameter(e.loc, STC.none, e.type, null, null, null);
+                    auto arg = new Parameter(e.loc, STC.none, e.type, null, null, null, null);
                     (*arguments)[i] = arg;
                 }
             }