Language: add when statement modelled after Odin and Nim

analyser/module_analyser.c2

@@ -499,6 +499,10 @@ fn bool Analyser.analyseGlobalDecl(Analyser* ma, Decl* d) {
     case Variable:
         ma.analyseGlobalVarDecl((VarDecl*)d);
         break;
+    case When:
+        // TODO: support this: dispatch to other lists
+        ma.error(d.getLoc(), "'when' blocks not supported at global scope");
+        break;
     }
 
     d.setChecked();

analyser/module_analyser_expr.c2

@@ -256,6 +256,8 @@ fn IdentifierKind Analyser.setExprFlags(Analyser* ma, Expr** e_ptr, Decl* d) {
             break;
         }
         break;
+    case When:
+        break;
     }
     return kind;
 }
@@ -650,6 +652,7 @@ fn void get_best_match(const char* name1, usize len1, StructTypeDecl* s, usize*
     u32 num_members = s.getNumMembers();
     for (u32 i = 0; i < num_members; i++) {
         Decl* m = members[i];
+        if (m.isDisabled()) continue;
         const char* name2 = m.getName();
         if (name2 == nil) {
             get_best_match(name1, len1, (StructTypeDecl*)m, best_dist, result);

analyser/module_analyser_init.c2

@@ -410,6 +410,7 @@ fn void fillFieldInfo(StructTypeDecl* std, FillInfo* fi, u32 base_offset) {
 
     for (u32 i=0; i<num_members; i++) {
         Decl* d = members[i];
+        if (d.isDisabled()) continue;
         FieldInitField* f = &fi.fii.fields[fi.idx];
         f.member_idx = fi.member_idx;
         const StructMemberLayout* ml = &layout.members[i];
@@ -559,6 +560,7 @@ fn bool Analyser.analyseInitListStruct(Analyser* ma, InitListExpr* ile, QualType
     const StructLayout* layout = std.getLayout();
     u32 member_idx = 0;
     for (u32 i=0; i<numValues; i++) {
+        if (members[i].isDisabled()) continue;
         Expr* value = values[i];
 
         const StructMemberLayout* ml = &layout.members[member_idx];

analyser/module_analyser_member.c2

@@ -357,6 +357,7 @@ fn ValType decl2valtype(const Decl* d) {
     case EnumConstant:
     case FunctionType:
     case AliasType:
+    case When:
         break;
     case Variable:
         return LValue;

analyser/module_analyser_stmt.c2

@@ -127,6 +127,9 @@ fn FlowBits Analyser.analyseStmt(Analyser* ma, Stmt** s_ptr, bool checkEffect) {
     case Assert:
         ma.analyseAssertStmt(s);
         return FlowNext;
+    case When:
+        flow = ma.analyseWhenStmt(s);
+        break;
     }
     if (!(flow & FlowNext)) ma.scope.setUnreachable();
     return flow;
@@ -228,6 +231,14 @@ fn QualType Analyser.analyseCondition(Analyser* ma, Stmt** s_ptr, bool check_ass
     return qt;
 }
 
+fn bool Analyser.checkWhen(Analyser* ma, Stmt* s) {
+    if (s.isWhen()) {
+        ma.error(s.getLoc(), "'when' statement must be braced in this context");
+        return false;
+    }
+    return true;
+}
+
 fn FlowBits Analyser.analyseIfStmt(Analyser* ma, Stmt* s) {
     FlowBits flow = FlowNext;
     IfStmt* i = (IfStmt*)s;
@@ -237,15 +248,17 @@ fn FlowBits Analyser.analyseIfStmt(Analyser* ma, Stmt* s) {
     if (ma.has_error) goto done;
     // TODO: handle constant conditions
 
+    ma.checkWhen(i.getThen());
     ma.scope.enter(scope.Decl);
     flow = ma.analyseStmt(i.getThen2(), true);
     ma.scope.exit(ma.has_error);
 
     FlowBits flow2 = FlowNext;
-    Stmt** else_ = i.getElse2();
-    if (else_) {
+    Stmt** elsep = i.getElse2();
+    if (elsep) {
+        ma.checkWhen(*elsep);
         ma.scope.enter(scope.Decl);
-        flow2 = ma.analyseStmt(else_, true);
+        flow2 = ma.analyseStmt(elsep, true);
         ma.scope.exit(ma.has_error);
     }
     flow |= flow2;
@@ -288,6 +301,7 @@ fn FlowBits Analyser.analyseForStmt(Analyser* ma, Stmt* s) {
         if (qt.isInvalid()) goto done;
     }
 
+    ma.checkWhen(f.getBody());
     FlowBits flow2 = ma.analyseStmt(f.getBody2(), true);
     flow |= flow2 & (FlowReturn | FlowGoto | FlowNoReturn | FlowError);
     if (flow2 & FlowBreak) flow |= FlowNext;
@@ -315,6 +329,7 @@ fn FlowBits Analyser.analyseWhileStmt(Analyser* ma, Stmt* s) {
     }
 
     ma.scope.enter(scope.Break | scope.Continue | scope.Decl | scope.Control);
+    ma.checkWhen(w.getBody());
     FlowBits flow2 = ma.analyseStmt(w.getBody2(), true);
     ma.scope.exit(ma.has_error);
     flow |= flow2 & (FlowReturn | FlowGoto | FlowNoReturn | FlowError);
@@ -555,3 +570,38 @@ fn void Analyser.checkReturnAddrOfLocal(Analyser* ma, Expr* arg) {
     }
 }
 
+// when statement modelled after Odin and Nim
+fn FlowBits Analyser.analyseWhenStmt(Analyser* ma, Stmt* s) {
+    WhenStmt* w = (WhenStmt*)s;
+
+    QualType qt = ma.analyseConstExpr(w.getCond2(), true);
+    if (qt.isInvalid()) return FlowError;
+
+    Expr* cond = w.getCond();
+    if (!cond.isCtv()) {
+        ma.errorRange(cond.getLoc(), cond.getRange(), "'when' condition is not a compile-time value");
+        return FlowError;
+    }
+
+    Value v = ast.evalExpr(cond);
+    if (v.kind == Error) {
+        ma.errorRange(cond.getLoc(), cond.getRange(), "%s", v.error_msg);
+        return FlowError;
+    }
+    if (!v.isZero()) {
+        w.setTrue();
+        Stmt* thenStmt = w.getThen();
+        if (thenStmt.isCompound())
+            return ma.analyseCompoundStmt((CompoundStmt*)thenStmt);
+        else
+            return ma.analyseStmt(w.getThen2(), true);
+    } else
+    if (w.hasElse()) {
+        Stmt* elseStmt = w.getElse();
+        if (elseStmt.isCompound())
+            return ma.analyseCompoundStmt((CompoundStmt*)elseStmt);
+        else
+            return ma.analyseStmt(w.getElse2(), true);
+    }
+    return FlowNext;
+}

analyser/module_analyser_struct.c2

@@ -25,10 +25,12 @@ fn void Analyser.analyseStructType(Analyser* ma, StructTypeDecl* d) {
         ma.checkStack[ma.checkIndex-1].usedPublic = false;
         ma.usedPublic = false;
     }
-    NameMap names.init(d.getNumMembers());
 
-    ma.analyseStructNames(d, &names);
+    // Handle 'when' blocks: disable unselected members
+    if (d.hasWhen() && !ma.analyseStructTypeWhenBlocks(d)) return;
 
+    NameMap names.init(d.getNumMembers());
+    ma.analyseStructNames(d, &names);
     names.free();
 
     ma.analyseStructMembers(d);
@@ -47,6 +49,7 @@ fn void Analyser.analyseStructMembers(Analyser* ma, StructTypeDecl* d) {
 
     for (u32 i=0; i<count; i++) {
         Decl* member = members[i];
+        if (member.isDisabled()) continue;
         if (member.isVariable()) {
             VarDecl* vd = (VarDecl*)member;
             // Note: dont push to stack, because can self-ref to StructType
@@ -173,21 +176,19 @@ fn void Analyser.analyseStructMember(Analyser* ma, VarDecl* v) {
 }
 
 fn void Analyser.analyseStructNames(Analyser* ma, StructTypeDecl* d, NameMap* names) {
-    // note: already checked that struct doesn't have 0 members
     u32 count = d.getNumMembers();
     Decl** members = d.getMembers();
 
     for (u32 i=0; i<count; i++) {
         // there can more members in anonymous sub-structs
         Decl* member = members[i];
+        if (member.isDisabled()) continue;
         u32 name_idx = member.getNameIdx();
 
-        StructTypeDecl* sub = nil;
-        if (member.isStructType()) sub = (StructTypeDecl*)member;
-
         if (name_idx == 0) {
             // can be anonymous sub-struct/union or anonymous bit-field
             if (member.isStructType()) {
+                StructTypeDecl* sub = (StructTypeDecl*)member;
                 ma.analyseStructNames(sub, names);
             }
         } else {
@@ -200,6 +201,7 @@ fn void Analyser.analyseStructNames(Analyser* ma, StructTypeDecl* d, NameMap* na
             names.add(name_idx, member.getLoc());
 
             if (member.isStructType()) {
+                StructTypeDecl* sub = (StructTypeDecl*)member;
                 NameMap sub_names.init(sub.getNumMembers());
                 ma.analyseStructNames(sub, &sub_names);
                 sub_names.free();
@@ -208,3 +210,51 @@ fn void Analyser.analyseStructNames(Analyser* ma, StructTypeDecl* d, NameMap* na
     }
 }
 
+fn bool Analyser.resolveWhenDecl(Analyser* ma, WhenDecl* wd) {
+    QualType qt = ma.analyseConstExpr(wd.getCond2(), true);
+    if (qt.isInvalid()) return false;
+    Expr* cond = wd.getCond();
+    if (!cond.isCtv()) {
+        ma.errorRange(cond.getLoc(), cond.getRange(), "'when' condition is not a compile-time value");
+        return false;
+    }
+    Value v = ast.evalExpr(cond);
+    if (v.kind == Error) {
+        ma.errorRange(cond.getLoc(), cond.getRange(), "%s", v.error_msg);
+        return false;
+    }
+    if (!v.isZero()) wd.setTrue();
+    return true;
+}
+
+fn bool Analyser.analyseStructTypeWhenBlocks(Analyser* ma, StructTypeDecl* d) {
+    bool ok = true;
+    u32 count = d.getNumMembers();
+    Decl** members = d.getMembers();
+
+    for (u32 i = 0; i < count; i++) {
+        Decl* member = members[i];
+        if (member.isDisabled()) continue;
+        if (member.isStructType()) {
+            StructTypeDecl* sub = (StructTypeDecl*)member;
+            if (!ma.analyseStructTypeWhenBlocks(sub)) return false;
+        }
+        if (member.isWhenDecl()) {
+            WhenDecl* wd = (WhenDecl*)member;
+            if (!ma.resolveWhenDecl(wd)) return false;
+            member.setDisabled();
+            u32 then_count = wd.getThenCount();
+            u32 else_count = wd.getElseCount();
+            u32 from = i + 1;
+            u32 end1 = from + then_count;
+            if (wd.isTrue()) {
+                from += then_count;
+                end1 += else_count;
+            }
+            for (u32 j = from; j < end1; j++) {
+                members[j].setDisabled();
+            }
+        }
+    }
+    return ok;
+}

analyser/size_analyser.c2

@@ -37,6 +37,7 @@ fn void sizeOfUnion(StructTypeDecl* s) {
     Decl** members = s.getMembers();
     for (u32 i = 0; i < num_members; i++) {
         Decl* d = members[i];
+        if (d.isDisabled()) continue;
         TypeSize member = sizeOfType(d.getType());
         // TODO handle un-packed sub-structs
         u32 size = member.size;     // byte size of the current member
@@ -83,6 +84,7 @@ public fn void sizeOfStruct(StructTypeDecl* s) {
 
     for (u32 i = 0; i < num_members; i++) {
         Decl* d = members[i];
+        if (d.isDisabled()) continue;
         // Note: doesn't analyze the bit-field
         TypeSize member = sizeOfType(d.getType());
         StructMemberLayout* ml = &layout.members[i];

analyser/unused_checker.c2

@@ -91,6 +91,8 @@ fn void Checker.check(void* arg, Decl* d) {
     case Variable:
         if (c.warnings.no_unused_variable) return;
         break;
+    case When:
+        return;
     }
     if (!used && !d.hasAttrUnused() && !d.isExported()) {
         c.diags.warn(d.getLoc(), "unused %s '%s'", d.getKindName(), d.getFullName());
@@ -139,6 +141,7 @@ fn void Checker.checkStructMembers(Checker* c, Decl* d) {
     Decl** members = std.getMembers();
     for (u32 i=0; i<num_members; i++) {
         Decl* member = members[i];
+        if (member.isDisabled()) continue;
         if (member.isStructType()) {
             c.checkStructMembers(member);
         } else {

ast/ast_evaluator.c2

@@ -550,6 +550,7 @@ fn Cont Stmt.eval(Stmt* s, Evaluator* sf) {
     case Decl:        return ((DeclStmt*)s).eval(sf);
     case Asm:         return ((AsmStmt*)s).eval(sf);
     case Assert:      return ((AssertStmt*)s).eval(sf);
+    case When:        return ((WhenStmt*)s).eval(sf);
     }
     return Abort;
 }
@@ -751,3 +752,9 @@ fn Cont AssertStmt.eval(AssertStmt* s, Evaluator* sf) {
     }
     return Normal;
 }
+
+fn Cont WhenStmt.eval(WhenStmt* s, Evaluator* sf) {
+    if (s.isTrue()) return s.getThen().eval(sf);
+    if (s.hasElse()) return s.getElse().eval(sf);
+    return Normal;
+}

ast/decl.c2

@@ -31,6 +31,7 @@ public type DeclKind enum u8 {
     FunctionType,
     AliasType,
     Variable,
+    When,
 }
 
 const char*[DeclKind] declKind_names = {
@@ -42,6 +43,7 @@ const char*[DeclKind] declKind_names = {
     "FunctionType",
     "AliasTypeDecl",
     "VarDecl",
+    "WhenDecl",
 }
 
 public type DeclCheckState enum u8 {
@@ -68,9 +70,9 @@ type DeclBits struct {
     u32 is_external : 1;    // in external lib
     u32 is_generated : 1;   // for globals, can be used by generators
     u32 has_gen_idx : 1;
+    u32 is_disabled : 1;    // potentially merge with check_state
 }
-
-const u32 NumDeclBits = 15;  // should match bitfields above
+const u32 NumDeclBits = 16;  // should match bitfields above
 
 public type Decl struct @(opaque) {
     union {
@@ -81,6 +83,7 @@ public type Decl struct @(opaque) {
         EnumTypeDeclBits enumTypeDeclBits;
         EnumConstantDeclBits enumConstantDeclBits;
         VarDeclBits varDeclBits;
+        WhenDeclBits whenDeclBits;
         u32 bits;
     }
     union {
@@ -141,6 +144,9 @@ public fn bool Decl.isCheckInProgress(const Decl* d) {
 public fn void Decl.setChecked(Decl* d) { d.declBits.check_state = Checked; }
 public fn void Decl.setCheckInProgress(Decl* d) { d.declBits.check_state = InProgress; }
 
+public fn void Decl.setDisabled(Decl* d) { d.declBits.is_disabled = true; }
+public fn bool Decl.isDisabled(const Decl* d) { return d.declBits.is_disabled; }
+
 public fn void Decl.setHasAttr(Decl* d) { d.declBits.has_attr = 1; }
 public fn bool Decl.hasAttr(const Decl* d) { return d.declBits.has_attr; }
 
@@ -199,6 +205,10 @@ public fn bool Decl.isVariable(const Decl* d) {
     return  d.getKind() == Variable;
 }
 
+public fn bool Decl.isWhenDecl(const Decl* d) {
+    return d.getKind() == When;
+}
+
 public fn const char* Decl.getName(const Decl* d) {
     return idx2name(d.name_idx);
 }
@@ -279,6 +289,7 @@ public fn bool Decl.isTypeDecl(const Decl* d) {
     case FunctionType: return true;
     case AliasType:    return true;
     case Variable:     break;
+    case When:         break;
     }
     return false;
 }
@@ -297,6 +308,7 @@ public fn const char* Decl.getKindName(const Decl* d) {
     case FunctionType: return "type";
     case AliasType:    return "type";
     case Variable:     return "variable";
+    case When:         return "when";
     }
     return "";
 }
@@ -384,6 +396,9 @@ fn void Decl.print(const Decl* d, string_buffer.Buf* out, u32 indent) {
     case Variable:
         VarDecl.print((VarDecl*)d, out, indent);
         break;
+    case When:
+        WhenDecl.print((WhenDecl*)d, out, indent);
+        break;
     }
 }