Add non-exhaustive typechecking for cond/match expr

3 files changed, 64 insertions, 11 deletions

diff --git a/src/main.c b/src/main.c
index bfaca4e..d442b98 100644
--- a/src/main.c
+++ b/src/main.c
@@ -304,6 +304,51 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
             node->type = cstr("nil");
             return node->type;
         } break;
+        case NODE_COND:
+        case NODE_MATCH: {
+            if (node->match_expr) {
+                type_inference(a, node->match_expr, scope);
+            }
+            Type previous = cstr("");
+            for (sz i = 0; i < array_size(node->match_cases); i++) {
+                Node *expr = node->match_cases[i];
+                Type next = type_inference(a, expr, scope);
+                if (i != 0 && !str_eq(next, previous)) {
+                    emit_semantic_error(
+                        a, node,
+                        cstr("non-matching types for case expressions"));
+                    return cstr("");
+                }
+                previous = next;
+            }
+            // TODO: proper typecheck matchcase expressions here...
+            node->type = previous;
+            return node->type;
+        } break;
+        case NODE_CASE_MATCH: {
+            if (node->case_value) {
+                type_inference(a, node->case_value, scope);
+            }
+            if (node->case_expr->kind != NODE_BLOCK) {
+                scope = typescope_alloc(a, scope);
+            }
+            node->type = type_inference(a, node->case_expr, scope);
+            return node->type;
+        } break;
+        case NODE_CASE_COND: {
+            if (node->case_value) {
+                Type cond = type_inference(a, node->case_value, scope);
+                if (!str_eq(cond, cstr("bool"))) {
+                    emit_semantic_error(a, node,
+                                        cstr("non-boolean case condition"));
+                }
+            }
+            if (node->case_expr->kind != NODE_BLOCK) {
+                scope = typescope_alloc(a, scope);
+            }
+            node->type = type_inference(a, node->case_expr, scope);
+            return node->type;
+        } break;
         case NODE_TRUE:
         case NODE_FALSE: {
             node->type = cstr("bool");
@@ -564,7 +609,8 @@ analyzer_symbols(Analyzer *a, Node *node, Scope *scope) {
                 symmap_insert(&map->val.fields, field_name, s, a->storage);
             }
         } break;
-        case NODE_CASE: {
+        case NODE_CASE_MATCH:
+        case NODE_CASE_COND: {
             analyzer_symbols(a, node->case_value, scope);
             if (node->case_expr) {
                 if (node->case_expr->kind != NODE_BLOCK) {
diff --git a/src/parser.c b/src/parser.c
index 9079df9..b82579b 100644
--- a/src/parser.c
+++ b/src/parser.c
@@ -47,8 +47,9 @@ typedef enum NodeKind {
     NODE_STRUCT,
     NODE_IF,
     NODE_MATCH,
-    NODE_CASE,
     NODE_COND,
+    NODE_CASE_MATCH,
+    NODE_CASE_COND,
     NODE_ENUM,
     NODE_BREAK,
     NODE_CONTINUE,
@@ -111,8 +112,9 @@ Str node_str[] = {
     [NODE_STRUCT] = cstr("STRUCT DEF"),
     [NODE_IF] = cstr("IF"),
     [NODE_MATCH] = cstr("MATCH"),
-    [NODE_CASE] = cstr("CASE"),
     [NODE_COND] = cstr("COND"),
+    [NODE_CASE_MATCH] = cstr("CASE"),
+    [NODE_CASE_COND] = cstr("CASE"),
     [NODE_ENUM] = cstr("ENUM"),
     [NODE_BREAK] = cstr("BREAK"),
     [NODE_CONTINUE] = cstr("CONTINUE"),
@@ -609,7 +611,8 @@ parse_keyword(Parser *parser) {
             parse_consume(parser, TOK_LCURLY,
                           cstr("expected block of match cases"));
             while (!parse_match(parser, TOK_RCURLY) && !parser->panic) {
-                Node *tmp = node_alloc(parser, NODE_CASE, parser->previous);
+                Node *tmp =
+                    node_alloc(parser, NODE_CASE_MATCH, parser->previous);
                 if (!tmp) return;
                 // Are we on the default case.
                 if (!parse_match(parser, TOK_ELSE)) {
@@ -668,12 +671,11 @@ parse_keyword(Parser *parser) {
             parse_consume(parser, TOK_LCURLY,
                           cstr("expected '{' on cond expression"));
             while (!parse_match(parser, TOK_RCURLY) && !parser->panic) {
-                Node *tmp = node_alloc(parser, NODE_CASE, parser->previous);
+                Node *tmp =
+                    node_alloc(parser, NODE_CASE_COND, parser->previous);
                 if (!tmp) return;
                 // Are we on the default case.
                 if (!parse_match(parser, TOK_ELSE)) {
-                    parse_consume(parser, TOK_CASE,
-                                  cstr("expected case statement"));
                     parse_expr(parser, PREC_LOW);
                     tmp->case_value = array_pop(parser->nodes);
                 }
diff --git a/tests/semantics.bad b/tests/semantics.bad
index a938979..5b5c971 100644
--- a/tests/semantics.bad
+++ b/tests/semantics.bad
@@ -18,15 +18,20 @@
 ;     44
 ; }
 
-let single = if (true) {
-    123
-}
+; let single = if (true) {
+;     123
+; }
 
 ; while (!true) {
 ;     "asjdflasdjf"
 ; }
 
-set single = 32
+; set single = 32
+
+cond {
+    1 == 2 = "hello"
+    else = "dong"
+}
 
 ; enum test {
 ;     a = 1