Add semantic checking for enum constructs

2 files changed, 50 insertions, 11 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);