Remove unnecessary scope creation.

1 files changed, 59 insertions, 32 deletions

diff --git a/src/main.c b/src/main.c
index e5f0f29..182a597 100644
--- a/src/main.c
+++ b/src/main.c
@@ -23,12 +23,19 @@ init(void) {
 }
 
 typedef enum {
-    SYM_VAR,
+    SYM_UNKNOWN,
+    SYM_BUILTIN,
     SYM_FUN,
+    SYM_VAR,
     SYM_PARAM,
-    SYM_BUILTIN,
 } 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 "),
+};
+
 typedef struct Symbol {
     SymbolKind kind;
 } Symbol;
@@ -102,7 +109,15 @@ analyzer_symbols(Analyzer *a, Node *node, Scope *scope) {
                 symmap_insert(&scope->symbols, param->param_name->value.str,
                               (Symbol){.kind = SYM_PARAM}, a->storage);
             }
-            analyzer_symbols(a, node->func_body, scope);
+            if (node->func_body->kind == NODE_BLOCK) {
+                node = node->func_body;
+                for (sz i = 0; i < array_size(node->elements); i++) {
+                    Node *expr = node->elements[i];
+                    analyzer_symbols(a, expr, scope);
+                }
+            } else {
+                analyzer_symbols(a, node->func_body, scope);
+            }
         } break;
         case NODE_COND:
         case NODE_MATCH: {
@@ -114,7 +129,12 @@ analyzer_symbols(Analyzer *a, Node *node, Scope *scope) {
                 analyzer_symbols(a, expr, scope);
             }
         } break;
-        case NODE_RETURN:
+        case NODE_RETURN: {
+            for (sz i = 0; i < array_size(node->elements); i++) {
+                Node *expr = node->elements[i];
+                analyzer_symbols(a, expr, scope);
+            }
+        } break;
             // TODO: Struct field initializers need to be checked... when we
             // get to that.
             // case NODE_VAL_FIELD:
@@ -131,24 +151,36 @@ analyzer_symbols(Analyzer *a, Node *node, Scope *scope) {
         case NODE_CASE: {
             analyzer_symbols(a, node->case_value, scope);
             if (node->case_expr) {
-                Scope *next = scope_alloc(a, scope);
-                analyzer_symbols(a, node->case_expr, next);
+                if (node->case_expr->kind != NODE_BLOCK) {
+                    scope = scope_alloc(a, scope);
+                }
+                analyzer_symbols(a, node->case_expr, scope);
             }
         } break;
         case NODE_IF: {
             analyzer_symbols(a, node->cond_if, scope);
             if (node->cond_expr) {
-                Scope *next = scope_alloc(a, scope);
-                analyzer_symbols(a, node->cond_expr, next);
+                if (node->cond_expr->kind == NODE_BLOCK) {
+                    analyzer_symbols(a, node->cond_expr, scope);
+                } else {
+                    Scope *next = scope_alloc(a, scope);
+                    analyzer_symbols(a, node->cond_expr, next);
+                }
             }
             if (node->cond_else) {
-                Scope *next = scope_alloc(a, scope);
-                analyzer_symbols(a, node->cond_else, next);
+                if (node->cond_else->kind == NODE_BLOCK) {
+                    analyzer_symbols(a, node->cond_else, scope);
+                } else {
+                    Scope *next = scope_alloc(a, scope);
+                    analyzer_symbols(a, node->cond_else, next);
+                }
             }
         } break;
         case NODE_WHILE: {
             analyzer_symbols(a, node->while_cond, scope);
-            scope = scope_alloc(a, scope);
+            if (node->while_expr->kind != NODE_BLOCK) {
+                scope = scope_alloc(a, scope);
+            }
             analyzer_symbols(a, node->while_expr, scope);
         } break;
         case NODE_FUNCALL: {
@@ -159,10 +191,9 @@ analyzer_symbols(Analyzer *a, Node *node, Scope *scope) {
                     " scope ",
                     a->file_name, node->line, node->col, symbol);
             }
-            Scope *next = scope_alloc(a, scope);
             for (sz i = 0; i < array_size(node->elements); i++) {
                 Node *expr = node->elements[i];
-                analyzer_symbols(a, expr, next);
+                analyzer_symbols(a, expr, scope);
             }
         } break;
         case NODE_SYMBOL_IDX:
@@ -263,6 +294,9 @@ symbolic_analysis(Analyzer *a, Parser *parser) {
 
 void
 process_file(Str path) {
+#if DEBUG == 1
+    println("%s", path);
+#endif
     Arena lexer_arena = arena_create(LEXER_MEM, os_allocator);
 
     FileContents file = platform_read_file(path, &lexer_arena);
@@ -329,25 +363,18 @@ process_file(Str path) {
     };
     symbolic_analysis(&analyzer, &parser);
 
-    // DEBUG: Printing all symbols on the HT.
-    // StrSetIter iter = strset_iterator(root_scope.symbols, &lexer_arena);
-    // StrSet *val = strset_next(&iter, &lexer_arena);
-    // while (val) {
-    //     println("SYMBOL: %s", val->key);
-    //     val = strset_next(&iter, &lexer_arena);
-    // }
-
-    // StrIntMap *map = NULL;
-    // strintmap_insert(&map, cstr("test"), 1, &lexer_arena);
-    // strintmap_insert(&map, cstr("toast"), 9, &lexer_arena);
-    // strintmap_insert(&map, cstr("waaaa"), 420, &lexer_arena);
-    // strintmap_insert(&map, cstr("test"), 69, &lexer_arena);
-    // StrIntMapIter iter = strintmap_iterator(map, &lexer_arena);
-    // StrIntMap *val = strintmap_next(&iter, &lexer_arena);
-    // while (val) {
-    //     println("KEY: %s value: %d", val->key, val->val);
-    //     val = strintmap_next(&iter, &lexer_arena);
-    // }
+    // Printing symbol tables.
+    for (sz i = 0; i < array_size(analyzer.scopes); i++) {
+        Arena scratch = lexer_arena;
+        Scope *scope = analyzer.scopes[i];
+        SymbolMapIter iter = symmap_iterator(scope->symbols, &scratch);
+        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);
+            sym = symmap_next(&iter, &lexer_arena);
+        }
+    }
 
     // TODO: Type checking.