Add semantic checking for enum constructs

4 files changed, 108 insertions, 54 deletions

diff --git a/src/main.c b/src/main.c
index 7cb0b87..8e177e1 100644
--- a/src/main.c
+++ b/src/main.c
@@ -28,16 +28,21 @@ typedef enum {
     SYM_FUN,
     SYM_VAR,
     SYM_PARAM,
+    SYM_ENUM,
+    SYM_ENUM_FIELD,
 } SymbolKind;
 
 Str sym_kind_str[] = {
-    [SYM_UNKNOWN] = cstr("UNKNOWN   "), [SYM_BUILTIN] = cstr("BUILTIN   "),
-    [SYM_FUN] = cstr("FUNCTION  "),     [SYM_VAR] = cstr("VARIABLE  "),
-    [SYM_PARAM] = cstr("PARAMETER "),
+    [SYM_UNKNOWN] = cstr("UNKNOWN   "),    [SYM_BUILTIN] = cstr("BUILTIN   "),
+    [SYM_FUN] = cstr("FUNCTION  "),        [SYM_VAR] = cstr("VARIABLE  "),
+    [SYM_PARAM] = cstr("PARAMETER "),      [SYM_ENUM] = cstr("ENUM      "),
+    [SYM_ENUM_FIELD] = cstr("ENUM FIELD"),
 };
 
 typedef struct Symbol {
     SymbolKind kind;
+    Str name;
+    struct Symbol *fields;
 } Symbol;
 
 MAPDEF(SymbolMap, symmap, Str, Symbol, str_hash, str_eq)
@@ -100,15 +105,18 @@ analyzer_symbols(Analyzer *a, Node *node, Scope *scope) {
                         node->func_name->col, symbol);
                 }
                 symmap_insert(&scope->symbols, symbol,
-                              (Symbol){.kind = SYM_FUN}, a->storage);
+                              (Symbol){.kind = SYM_FUN, .name = symbol},
+                              a->storage);
             }
 
             scope = scope_alloc(a, scope);
             node->scope = scope;
             for (sz i = 0; i < array_size(node->func_params); i++) {
                 Node *param = node->func_params[i];
-                symmap_insert(&scope->symbols, param->param_name->value.str,
-                              (Symbol){.kind = SYM_PARAM}, a->storage);
+                Str param_name = param->param_name->value.str;
+                symmap_insert(&scope->symbols, param_name,
+                              (Symbol){.kind = SYM_PARAM, .name = param_name},
+                              a->storage);
             }
             if (node->func_body->kind == NODE_BLOCK) {
                 node = node->func_body;
@@ -150,6 +158,27 @@ analyzer_symbols(Analyzer *a, Node *node, Scope *scope) {
                 analyzer_symbols(a, expr, next);
             }
         } break;
+        case NODE_ENUM: {
+            Str symbol = node->value.str;
+            if (symmap_lookup(&scope->symbols, symbol) != NULL) {
+                eprintln(
+                    "%s:%d:%d: error: symbol '%s' already exists in current "
+                    " scope ",
+                    a->file_name, node->line, node->col, symbol);
+            }
+            SymbolMap *map = symmap_insert(
+                &scope->symbols, symbol,
+                (Symbol){.kind = SYM_ENUM, .name = symbol}, a->storage);
+            // TODO: symcheck the value expression?
+            for (sz i = 0; i < array_size(node->struct_field); i++) {
+                Node *field = node->struct_field[i];
+                Str field_name = field->field_name->value.str;
+                field_name = str_concat(cstr("."), field_name, a->storage);
+                field_name = str_concat(symbol, field_name, a->storage);
+                Symbol s = (Symbol){.kind = SYM_ENUM_FIELD, .name = field_name};
+                array_push(map->val.fields, s, a->storage);
+            }
+        } break;
         case NODE_CASE: {
             analyzer_symbols(a, node->case_value, scope);
             if (node->case_expr) {
@@ -225,7 +254,8 @@ analyzer_symbols(Analyzer *a, Node *node, Scope *scope) {
                     a->file_name, node->var_name->line, node->var_name->col,
                     symbol);
             }
-            symmap_insert(&scope->symbols, symbol, (Symbol){.kind = SYM_VAR},
+            symmap_insert(&scope->symbols, symbol,
+                          (Symbol){.kind = SYM_VAR, .name = symbol},
                           a->storage);
         } break;
         // Binary ops
@@ -269,7 +299,7 @@ symbolic_analysis(Analyzer *a, Parser *parser) {
     };
     for (sz i = 0; i < LEN(builtin_functions); i++) {
         Str symbol = builtin_functions[i];
-        Symbol sym = (Symbol){.kind = SYM_BUILTIN};
+        Symbol sym = (Symbol){.kind = SYM_BUILTIN, .name = symbol};
         symmap_insert(&scope->symbols, symbol, sym, a->storage);
     }
 
@@ -285,7 +315,8 @@ symbolic_analysis(Analyzer *a, Parser *parser) {
                     a->file_name, root->func_name->line, root->func_name->col,
                     symbol);
             }
-            symmap_insert(&scope->symbols, symbol, (Symbol){.kind = SYM_FUN},
+            symmap_insert(&scope->symbols, symbol,
+                          (Symbol){.kind = SYM_FUN, .name = symbol},
                           a->storage);
         }
     }
@@ -376,7 +407,12 @@ process_file(Str path) {
         SymbolMap *sym = symmap_next(&iter, &scratch);
         while (sym) {
             println("%s: SCOPE: %d DEPTH: %d\t%s %s", path, scope->id,
-                    scope->depth, sym_kind_str[sym->val.kind], sym->key);
+                    scope->depth, sym_kind_str[sym->val.kind], sym->val.name);
+            for (sz i = 0; i < array_size(sym->val.fields); i++) {
+                Symbol field = sym->val.fields[i];
+                println("%s: SCOPE: %d DEPTH: %d\t%s %s", path, scope->id,
+                        scope->depth, sym_kind_str[field.kind], field.name);
+            }
             sym = symmap_next(&iter, &lexer_arena);
         }
     }
diff --git a/src/parser.c b/src/parser.c
index 04692b3..67fc739 100644
--- a/src/parser.c
+++ b/src/parser.c
@@ -192,7 +192,7 @@ typedef struct Node {
         };
     };
     bool is_ptr;
-    struct Scope* scope;
+    struct Scope *scope;
 } Node;
 
 //
@@ -651,6 +651,9 @@ parse_keyword(Parser *parser) {
                 }
                 array_push(node->struct_field, field, parser->storage);
             }
+            if (array_size(node->struct_field) == 0) {
+                parse_emit_err(parser, prev, cstr("empty enum declaration"));
+            }
         } break;
         case TOK_COND: {
             node = node_alloc(parser, NODE_COND, prev);
diff --git a/tests/conditionals.bad b/tests/conditionals.bad
index e1a456e..b5ef61f 100644
--- a/tests/conditionals.bad
+++ b/tests/conditionals.bad
@@ -34,12 +34,17 @@ enum flags {
     node_div = 1 << 2
     node_mul
 }
-let a:flags = flags.node_add
-
-; No need to qualify enum fields inside match-case.
+let f:flags = flags.node_add
+
+; TODO: No need to qualify enum fields inside match-case.
+; match (a) {
+;     case node_add = "adding something..."
+;     case node_add = "subbing something..."
+;     else          = "default case"
+; }
 match (a) {
-    case node_add = "adding something..."
-    case node_add = "subbing something..."
+    case flags.node_add = "adding something..."
+    case flags.node_add = "subbing something..."
     else          = "default case"
 }
 
@@ -47,6 +52,6 @@ match (a) {
 ; statements.
 let msg:str = cond {
     case a == b = "hello"
-    case a != c = "world"
+    case a != f = "world"
     else        = "what"
 }
diff --git a/tests/semantics.bad b/tests/semantics.bad
index 4ce40b9..29c91c4 100644
--- a/tests/semantics.bad
+++ b/tests/semantics.bad
@@ -1,49 +1,59 @@
-fun foo(): nil {
-    bar()
+enum field {
+    a
+    b
+    ; a
+    ; c = field.a
+    ; c = field.c
+    ; c = c
+    ; c = a
 }
 
-fun bar(): nil {
-    foo()
-}
+; fun foo(): nil {
+;     bar()
+; }
 
-; There are some builtint functions.
-println("hello world")
+; fun bar(): nil {
+;     foo()
+; }
 
-; Let/set.
-let num = 1
-set num = 2
-set num = 0 + num
+; ; There are some builtint functions.
+; println("hello world")
 
-; Loops and conditionals.
-if (num) 3 else 1
-let val = if (2 + num == 4) num else num
-if (true) {
-    let c = 1
-    1 + 1 + c
-}
+; ; Let/set.
+; let num = 1
+; set num = 2
+; set num = 0 + num
 
-match (num) {
-    case 1 = 23
-    case 2 = num
-    else = num
-}
+; ; Loops and conditionals.
+; if (num) 3 else 1
+; let val = if (2 + num == 4) num else num
+; if (true) {
+;     let c = 1
+;     1 + 1 + c
+; }
 
-cond {
-    case 1 == 1 = 23
-    case 2 != 1 = num
-    else = num
-}
+; match (num) {
+;     case 1 = 23
+;     case 2 = num
+;     else = num
+; }
 
-while (num == 1) num
-while (true) {
-    let c = 1
-    1 + 1 + c
-}
+; cond {
+;     case 1 == 1 = 23
+;     case 2 != 1 = num
+;     else = num
+; }
 
-fun nested(): u32 {
-    fun adder(a: u32, b: u32): u32 a + b
-    adder(1,2)
-}
+; while (num == 1) num
+; while (true) {
+;     let c = 1
+;     1 + 1 + c
+; }
+
+; fun nested(): u32 {
+;     fun adder(a: u32, b: u32): u32 a + b
+;     adder(1,2)
+; }
 
 ; This should err.
 ; fun foo(): nil {