[DO NOT MERGE] POC: Add language-level tagged unions (enum union) and pattern matching (switch expressions)

compiler/include/dmd/aggregate.h

@@ -200,6 +200,15 @@ class UnionDeclaration final : public StructDeclaration
     void accept(Visitor *v) override { v->visit(this); }
 };
 
+class EnumUnionDeclaration final : public StructDeclaration
+{
+public:
+    EnumUnionDeclaration *syntaxCopy(Dsymbol *s) override;
+    const char *kind() const override;
+
+    void accept(Visitor *v) override { v->visit(this); }
+};
+
 struct BaseClass
 {
     Type *type;                         // (before semantic processing)

compiler/include/dmd/declaration.h

@@ -193,6 +193,15 @@ class TupleDeclaration final : public Declaration
     void accept(Visitor *v) override { v->visit(this); }
 };
 
+class EnumUnionCaseDeclaration final : public Declaration
+{
+public:
+    EnumUnionCaseDeclaration *syntaxCopy(Dsymbol *) override;
+    const char *kind() const override;
+
+    void accept(Visitor *v) override { v->visit(this); }
+};
+
 /**************************************************************/
 
 class AliasDeclaration final : public Declaration

compiler/include/dmd/dsymbol.h

@@ -31,9 +31,9 @@ class AggregateDeclaration;
 class EnumDeclaration;
 class ClassDeclaration;
 class StructDeclaration;
-class InterfaceDeclaration;
-class StructDeclaration;
 class UnionDeclaration;
+class EnumUnionDeclaration;
+class EnumUnionCaseDeclaration;
 class FuncDeclaration;
 class FuncAliasDeclaration;
 class OverDeclaration;
@@ -290,6 +290,7 @@ class Dsymbol : public ASTNode
     ClassDeclaration *isClassDeclaration();
     StructDeclaration *isStructDeclaration();
     UnionDeclaration *isUnionDeclaration();
+    EnumUnionDeclaration *isEnumUnionDeclaration();
     InterfaceDeclaration *isInterfaceDeclaration();
     ScopeDsymbol *isScopeDsymbol();
     ForwardingScopeDsymbol *isForwardingScopeDsymbol();
@@ -307,6 +308,7 @@ class Dsymbol : public ASTNode
     StaticAssert *isStaticAssert();
     StaticIfDeclaration *isStaticIfDeclaration();
     CAsmDeclaration *isCAsmDeclaration();
+    EnumUnionCaseDeclaration *isEnumUnionCaseDeclaration();
     void accept(Visitor *v) override { v->visit(this); }
 };
 

compiler/include/dmd/expression.h

@@ -40,6 +40,7 @@ class OverloadSet;
 class StringExp;
 class InterpExp;
 class LoweredAssignExp;
+class SwitchExp;
 class StaticForeach;
 #ifdef IN_GCC
 typedef union tree_node Symbol;
@@ -215,6 +216,7 @@ class Expression : public ASTNode
     EqualExp* isEqualExp();
     IdentityExp* isIdentityExp();
     CondExp* isCondExp();
+    SwitchExp* isSwitchExp();
     GenericExp* isGenericExp();
     DefaultInitExp* isDefaultInitExp();
     ClassReferenceExp* isClassReferenceExp();
@@ -1243,6 +1245,19 @@ class CondExp final : public BinExp
     void accept(Visitor *v) override { v->visit(this); }
 };
 
+struct CaseExpArm;
+
+class SwitchExp final : public Expression
+{
+public:
+    Expression *condition;
+    DArray<CaseExpArm> arms;
+    bool hasDefault;
+
+    SwitchExp *syntaxCopy() override;
+    void accept(Visitor *v) override { v->visit(this); }
+};
+
 class GenericExp final : Expression
 {
     Expression *cntlExp;

compiler/include/dmd/tokens.h

@@ -170,6 +170,7 @@ enum class TOK : unsigned char
     interface_,
     union_,
     enum_,
+    enumUnion,
     import_,
     alias_,
     override_,
@@ -384,6 +385,7 @@ enum class EXP : unsigned char
     dot,
     comma,
     question,
+    switchExpression,
     andAnd,
     orOr,
     prePlusPlus,

compiler/include/dmd/visitor.h

@@ -132,6 +132,7 @@ class CAsmDeclaration;
 class AggregateDeclaration;
 class StructDeclaration;
 class UnionDeclaration;
+class EnumUnionDeclaration;
 class ClassDeclaration;
 class InterfaceDeclaration;
 
@@ -140,6 +141,7 @@ class TupleDeclaration;
 class AliasDeclaration;
 class OverDeclaration;
 class VarDeclaration;
+class EnumUnionCaseDeclaration;
 class SymbolDeclaration;
 class ThisDeclaration;
 class BitFieldDeclaration;
@@ -298,6 +300,7 @@ class ClassReferenceExp;
 class VoidInitExp;
 class ThrownExceptionExp;
 class GenericExp;
+class SwitchExp;
 
 class TemplateParameter;
 class TemplateTypeParameter;
@@ -351,6 +354,7 @@ class ParseTimeVisitor
     virtual void visit(FuncDeclaration *s) { visit((Declaration *)s); }
     virtual void visit(AliasDeclaration *s) { visit((Declaration *)s); }
     virtual void visit(TupleDeclaration *s) { visit((Declaration *)s); }
+    virtual void visit(EnumUnionCaseDeclaration *s) { visit((Declaration *)s); }
 
     // FuncDeclarations
     virtual void visit(FuncLiteralDeclaration *s) { visit((FuncDeclaration *)s); }
@@ -387,6 +391,7 @@ class ParseTimeVisitor
     virtual void visit(Module *s) { visit((Package *)s); }
     virtual void visit(StructDeclaration *s) { visit((AggregateDeclaration *)s); }
     virtual void visit(UnionDeclaration *s) { visit((StructDeclaration *)s); }
+    virtual void visit(EnumUnionDeclaration *s) { visit((StructDeclaration *)s); }
     virtual void visit(ClassDeclaration *s) { visit((AggregateDeclaration *)s); }
     virtual void visit(InterfaceDeclaration *s) { visit((ClassDeclaration *)s); }
     virtual void visit(TemplateMixin *s) { visit((TemplateInstance *)s); }
@@ -499,6 +504,7 @@ class ParseTimeVisitor
     virtual void visit(TupleExp *e) { visit((Expression *)e); }
     virtual void visit(ThisExp *e) { visit((Expression *)e); }
     virtual void visit(GenericExp *e) { visit((Expression *)e); }
+    virtual void visit(SwitchExp *e) { visit((Expression *)e); }
 
     // Miscellaneous
     virtual void visit(VarExp *e) { visit((SymbolExp *)e); }

compiler/src/build.d

@@ -1392,7 +1392,7 @@ auto sourceFiles()
             access.d aggregate.d aliasthis.d argtypes_x86.d argtypes_sysv_x64.d argtypes_aarch64.d arrayop.d
             arraytypes.d astenums.d ast_node.d astcodegen.d asttypename.d attrib.d attribsem.d blockexit.d builtin.d canthrow.d chkformat.d
             cli.d clone.d compiler.d cond.d constfold.d  cpreprocess.d ctfeexpr.d
-            ctorflow.d dcast.d dclass.d declaration.d delegatize.d denum.d deps.d dimport.d
+            ctorflow.d dcast.d dclass.d declaration.d decisiontree.d delegatize.d denum.d deps.d dimport.d
             dinterpret.d dmacro.d dmodule.d doc.d dscope.d dstruct.d dsymbol.d dsymbolsem.d
             dtemplate.d dtoh.d dversion.d enumsem.d escape.d expression.d expressionsem.d func.d funcsem.d hdrgen.d
             impcnvtab.d imphint.d importc.d init.d initsem.d inline.d inlinecost.d intrange.d json.d lambdacomp.d

compiler/src/dmd/astbase.d

@@ -62,6 +62,7 @@ struct ASTBase
 
     alias Visitor = ParseTimeVisitor!ASTBase;
 
+
     extern (C++) abstract class ASTNode : RootObject
     {
         abstract void accept(Visitor v);
@@ -228,6 +229,16 @@ struct ASTBase
             return null;
         }
 
+        inout(EnumUnionDeclaration) isEnumUnionDeclaration() inout
+        {
+            return null;
+        }
+
+        inout(EnumUnionCaseDeclaration) isEnumUnionCaseDeclaration() inout
+        {
+            return null;
+        }
+
         inout(ClassDeclaration) isClassDeclaration() inout
         {
             return null;
@@ -893,6 +904,40 @@ struct ASTBase
         }
     }
 
+    struct EnumUnionVariant
+    {
+        Loc loc;
+        Identifier ident;
+        bool isTypeAlias;
+        Expressions* udas;
+        Type[] payload;
+        Identifier[] payloadNames;
+        Dsymbols* members;
+        TraitsExp variantSplice;
+    }
+
+    extern (C++) final class EnumUnionCaseDeclaration : Declaration
+    {
+        EnumUnionVariant variant;
+
+        extern (D) this(Loc loc, EnumUnionVariant variant)
+        {
+            super(null);
+            this.loc = loc;
+            this.variant = variant;
+        }
+
+        override void accept(Visitor v)
+        {
+            v.visit(this);
+        }
+
+        override inout(EnumUnionCaseDeclaration) isEnumUnionCaseDeclaration() inout
+        {
+            return this;
+        }
+    }
+
     extern (C++) abstract class AggregateDeclaration : ScopeDsymbol
     {
         Visibility visibility;
@@ -1491,6 +1536,28 @@ struct ASTBase
         }
     }
 
+    extern (C++) final class EnumUnionDeclaration : StructDeclaration
+    {
+        EnumUnionVariant[] variants;
+        VarDeclaration tagVar;
+        UnionDeclaration payloadUnion;
+
+        extern (D) this(Loc loc, Identifier id)
+        {
+            super(loc, id, false);
+        }
+
+        override void accept(Visitor v)
+        {
+            v.visit(this);
+        }
+
+        override inout(EnumUnionDeclaration) isEnumUnionDeclaration() inout
+        {
+            return this;
+        }
+    }
+
     extern (C++) class ClassDeclaration : AggregateDeclaration
     {
         extern (C++) __gshared
@@ -4604,6 +4671,7 @@ struct ASTBase
             inout(DotIdExp)     isDotIdExp() { return op == EXP.dotIdentifier ? cast(typeof(return))this : null; }
             inout(DotTemplateInstanceExp) isDotTemplateInstanceExp() { return op == EXP.dotTemplateInstance ? cast(typeof(return))this : null; }
             inout(CallExp)      isCallExp() { return op == EXP.call ? cast(typeof(return))this : null; }
+            inout(SwitchExp)    isSwitchExp() { return op == EXP.switchExpression ? cast(typeof(return))this : null; }
             inout(AddrExp)      isAddrExp() { return op == EXP.address ? cast(typeof(return))this : null; }
             inout(PtrExp)       isPtrExp() { return op == EXP.star ? cast(typeof(return))this : null; }
             inout(NegExp)       isNegExp() { return op == EXP.negate ? cast(typeof(return))this : null; }
@@ -5230,6 +5298,7 @@ struct ASTBase
     {
         Dsymbol s;
         bool hasOverloads;
+        bool preserveSymbol;
 
         extern (D) this(Loc loc, Dsymbol s, bool hasOverloads = true)
         {
@@ -6022,6 +6091,85 @@ struct ASTBase
         }
     }
 
+    struct CaseExpArm
+    {
+        Loc loc;
+        Expression pattern;
+        Type typePattern;
+        Identifier typeBinding;
+        Identifier[] recordBindings;
+        bool hasRestPattern;
+        Identifier[] recordPatternNames;
+        Expression[] recordPatterns;
+        Identifier restBinding;
+        Expression guard;
+        bool isDefault;
+        Expression action;
+
+        StaticForeach sfe;
+        CaseExpArm[] nestedArms;
+        Condition staticIfCond;
+        CaseExpArm[] elseArms;
+
+        CaseExpArm syntaxCopy()
+        {
+            CaseExpArm copy = this;
+            copy.pattern = pattern ? pattern.syntaxCopy() : null;
+            copy.typePattern = typePattern ? typePattern.syntaxCopy() : null;
+            copy.recordBindings = recordBindings.dup;
+            copy.recordPatternNames = recordPatternNames.dup;
+            if (recordPatterns)
+            {
+                copy.recordPatterns = new Expression[](recordPatterns.length);
+                foreach (j, pat; recordPatterns)
+                    copy.recordPatterns[j] = pat ? pat.syntaxCopy() : null;
+            }
+            copy.guard = guard ? guard.syntaxCopy() : null;
+            copy.action = action ? action.syntaxCopy() : null;
+            if (nestedArms)
+            {
+                copy.nestedArms = new CaseExpArm[](nestedArms.length);
+                foreach (j, ref na; nestedArms)
+                    copy.nestedArms[j] = na.syntaxCopy();
+            }
+            if (elseArms)
+            {
+                copy.elseArms = new CaseExpArm[](elseArms.length);
+                foreach (j, ref ea; elseArms)
+                    copy.elseArms[j] = ea.syntaxCopy();
+            }
+            return copy;
+        }
+    }
+
+    extern (C++) final class SwitchExp : Expression
+    {
+        Expression condition;
+        CaseExpArm[] arms;
+        bool hasDefault;
+
+        final extern (D) this(Loc loc, Expression condition, CaseExpArm[] arms, bool hasDefault)
+        {
+            super(loc, EXP.switchExpression, __traits(classInstanceSize, SwitchExp));
+            this.condition = condition;
+            this.arms = arms;
+            this.hasDefault = hasDefault;
+        }
+
+        override SwitchExp syntaxCopy()
+        {
+            auto copiedArms = new CaseExpArm[](arms.length);
+            foreach (i, arm; arms)
+                copiedArms[i] = arm.syntaxCopy();
+            return new SwitchExp(loc, condition.syntaxCopy(), copiedArms, hasDefault);
+        }
+
+        override void accept(Visitor v)
+        {
+            v.visit(this);
+        }
+    }
+
     extern (C++) final class AssignExp : BinExp
     {
         extern (D) this(Loc loc, Expression e1, Expression e2)

compiler/src/dmd/astcodegen.d

@@ -42,6 +42,7 @@ struct ASTCodegen
     alias Ensure                    = dmd.func.Ensure; // workaround for bug in older DMD frontends
     alias ErrorExp                  = dmd.expression.ErrorExp;
     alias ArgumentLabel             = dmd.expression.ArgumentLabel;
+    alias CaseExpArm                = dmd.expression.CaseExpArm;
 
     alias MODFlags                  = dmd.mtype.MODFlags;
     alias Type                      = dmd.mtype.Type;

compiler/src/dmd/backend/x86/cod2.d

@@ -2543,7 +2543,11 @@ void cdcond(ref CGstate cg, ref CodeBuilder cdb,elem* e,ref regm_t pretregs)
         fixresult(cg,cdb2,e22,retregs,pretregs);
     }
     else
+    {
+        if (pretregs == 0)
+            retregs = 0;
         codelem(cg,cdb2,e22,retregs,false);   // use same regs as E1
+    }
     pretregs = retregs | psw;
     andregcon(regconold);
     andregcon(regconsave);