Implement sumtypes and matching

Author: rikkimax

compiler/include/dmd/aggregate.h

@@ -13,6 +13,8 @@
 #include "dsymbol.h"
 #include "objc.h"
 
+class TypeSumType;
+
 class AliasThis;
 class Identifier;
 class Type;
@@ -162,6 +164,7 @@ class StructDeclaration : public AggregateDeclaration
     // ABI-specific type(s) if the struct can be passed in registers
     TypeTuple *argTypes;
 
+    TypeSumType *sumtype;      // if non-null, this struct is the lowered form of a __sumtype
     structalign_t alignment;    // alignment applied outside of the struct
     ThreeState ispod;           // if struct is POD
 private:

compiler/include/dmd/expression.h

@@ -706,6 +706,7 @@ class DotVarExp final : public UnaExp
 public:
     Declaration *var;
     d_bool hasOverloads;
+    d_bool compilerOverlappedAccess;
 
     void accept(Visitor *v) override { v->visit(this); }
 };
@@ -1256,6 +1257,30 @@ class GenericExp final : Expression
 
 /****************************************************************/
 
+struct SumTypeMatchArmInfo
+{
+    VarDeclaration *vd;
+    Expression *guard;
+    int variantIndex;
+    int originalIndex;
+};
+
+class MatchExp final : Expression
+{
+public:
+    Expression *arg;
+    Array<SumTypeMatchArmInfo> *armInfos;
+    Type *resultType;
+    StructDeclaration *loweredStruct;
+    TypeSumType *sumtypeType;
+
+    MatchExp *syntaxCopy() override;
+
+    void accept(Visitor *v) override { v->visit(this); }
+};
+
+/****************************************************************/
+
 class DefaultInitExp : public Expression
 {
 public:

compiler/include/dmd/module.h

@@ -113,6 +113,8 @@ class Module final : public Package
     size_t nameoffset;          // offset of module name from start of ModuleInfo
     size_t namelen;             // length of module name in characters
 
+    void* sumtypeCollations;    // AA: collation table for sumtype declarations (SumTypeKey -> StructDeclaration)
+
     static Module* create(const char *arg, Identifier *ident, int doDocComment, int doHdrGen);
     static Module *load(Loc loc, Identifiers *packages, Identifier *ident);
 

compiler/include/dmd/mtype.h

@@ -106,6 +106,8 @@ enum class TY : uint8_t
     Ttraits,
     Tmixin,
     Tnoreturn,
+    Ttag,
+    Tsumtype,
     TMAX
 };
 
@@ -284,6 +286,7 @@ class Type : public ASTNode
     TypeTraits *isTypeTraits();
     TypeNoreturn *isTypeNoreturn();
     TypeTag *isTypeTag();
+    TypeSumType *isTypeSumType();
 
     void accept(Visitor *v) override { v->visit(this); }
 };
@@ -713,6 +716,30 @@ class TypeTag final : public Type
 
 /**************************************************************/
 
+struct SumTypeVariantInfo
+{
+    Type *type;
+    Identifier *name;
+    Expressions *udas;
+    const char *comment;
+};
+
+typedef Array<SumTypeVariantInfo> SumTypeVariantInfos;
+
+class TypeSumType final : public Type
+{
+public:
+    SumTypeVariantInfos *variantInfos;
+    StructDeclaration *loweredStruct;
+    size_t defaultVariantIdx;
+
+    TypeSumType *syntaxCopy() override;
+
+    void accept(Visitor *v) override { v->visit(this); }
+};
+
+/**************************************************************/
+
 namespace dmd
 {
     // If the type is a class or struct, returns the symbol for it, else null.

compiler/include/dmd/tokens.h

@@ -259,6 +259,8 @@ enum class TOK : unsigned char
     whitespace,
     rvalue,
 
+    sumtype_,
+
     // C only keywords
     inline_,
     register_,
@@ -430,6 +432,10 @@ enum class EXP : unsigned char
     _Generic_,
     interval,
 
+    loweredAssignExp,
+    rvalue,
+    matchExp,
+
     MAX
 };
 

compiler/include/dmd/visitor.h

@@ -86,6 +86,7 @@ class TypeNoreturn;
 class TypeTraits;
 class TypeMixin;
 class TypeTag;
+class TypeSumType;
 
 class Dsymbol;
 
@@ -298,6 +299,7 @@ class ClassReferenceExp;
 class VoidInitExp;
 class ThrownExceptionExp;
 class GenericExp;
+class MatchExp;
 
 class TemplateParameter;
 class TemplateTypeParameter;
@@ -450,6 +452,7 @@ class ParseTimeVisitor
     virtual void visit(TypeTraits *t) { visit((Type *)t); }
     virtual void visit(TypeMixin *t) { visit((Type *)t); }
     virtual void visit(TypeTag *t) { visit((Type *)t); }
+    virtual void visit(TypeSumType *t) { visit((Type *)t); }
 
     // TypeNext
     virtual void visit(TypeReference *t) { visit((TypeNext *)t); }
@@ -499,6 +502,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(MatchExp *e) { visit((Expression *)e); }
 
     // Miscellaneous
     virtual void visit(VarExp *e) { visit((SymbolExp *)e); }

compiler/src/dmd/arraytypes.d

@@ -55,3 +55,5 @@ alias TemplateInstances = Array!(TemplateInstance);
 alias Ensures = Array!(Ensure);
 alias Designators = Array!(Designator);
 alias DesigInits = Array!(DesigInit);
+alias SumTypeVariantInfos = Array!(SumTypeVariantInfo);
+alias SumTypeMatchArmInfos = Array!(SumTypeMatchArmInfo);

compiler/src/dmd/astbase.d

@@ -2702,6 +2702,7 @@ struct ASTBase
                 sizeTy[Tmixin] = __traits(classInstanceSize, TypeMixin);
                 sizeTy[Tnoreturn] = __traits(classInstanceSize, TypeNoreturn);
                 sizeTy[Ttag] = __traits(classInstanceSize, TypeTag);
+                sizeTy[Tsumtype] = __traits(classInstanceSize, TypeSumType);
                 return sizeTy;
             }();
 
@@ -3784,6 +3785,39 @@ struct ASTBase
         }
     }
 
+    struct SumTypeVariantInfo
+    {
+        Type type;
+        Identifier name;
+        Expressions* udas;
+        const(char)* comment;
+    }
+
+    alias SumTypeVariantInfos   = Array!(SumTypeVariantInfo);
+
+    extern (C++) final class TypeSumType : Type
+    {
+        SumTypeVariantInfos* variantInfos;
+        StructDeclaration loweredStruct;
+        size_t defaultVariantIdx;
+
+        extern (D) this(SumTypeVariantInfos* variantInfos = null)
+        {
+            super(Tsumtype);
+            this.variantInfos = variantInfos;
+        }
+
+        override TypeSumType syntaxCopy()
+        {
+            return this;
+        }
+
+        override void accept(Visitor v)
+        {
+            v.visit(this);
+        }
+    }
+
     extern (C++) final class TypeReference : TypeNext
     {
         extern (D) this(Type t)
@@ -6270,6 +6304,35 @@ struct ASTBase
         }
     }
 
+    struct SumTypeMatchArmInfo
+    {
+        VarDeclaration vd;
+        Expression guard;
+        int variantIndex;
+        int originalIndex;
+    }
+
+    alias SumTypeMatchArmInfos  = Array!(SumTypeMatchArmInfo);
+
+    extern (C++) final class MatchExp : Expression
+    {
+        Expression arg;
+        SumTypeMatchArmInfos* armInfos;
+        Type resultType;
+
+        extern (D) this(Loc loc, Expression arg, SumTypeMatchArmInfos* armInfos)
+        {
+            super(loc, EXP.matchExp, __traits(classInstanceSize, MatchExp));
+            this.arg = arg;
+            this.armInfos = armInfos;
+        }
+
+        override void accept(Visitor v)
+        {
+            v.visit(this);
+        }
+    }
+
     extern (C++) final class ErrorExp : Expression
     {
         extern (D) this()

compiler/src/dmd/astcodegen.d

@@ -74,6 +74,7 @@ struct ASTCodegen
     alias Tvoid                     = dmd.mtype.Tvoid;
     alias Twchar                    = dmd.mtype.Twchar;
     alias Tnoreturn                 = dmd.mtype.Tnoreturn;
+    alias Tsumtype                 = dmd.mtype.Tsumtype;
 
     alias Timaginary32              = dmd.mtype.Timaginary32;
     alias Timaginary64              = dmd.mtype.Timaginary64;

compiler/src/dmd/astenums.d

@@ -228,6 +228,7 @@ enum TY : ubyte
     Tmixin,
     Tnoreturn,
     Ttag,
+    Tsumtype,
 }
 enum TMAX = TY.max + 1;
 
@@ -279,6 +280,7 @@ alias Ttraits = TY.Ttraits;
 alias Tmixin = TY.Tmixin;
 alias Tnoreturn = TY.Tnoreturn;
 alias Ttag = TY.Ttag;
+alias Tsumtype = TY.Tsumtype;
 
 enum TFlags
 {