Consolidate semantic analyzer functions

1 files changed, 65 insertions, 392 deletions

diff --git a/src/main.c b/src/main.c
index f0c4469..898ac15 100644
--- a/src/main.c
+++ b/src/main.c
@@ -8,7 +8,7 @@
 #include "vm.c"
 
 // TODO: unions
-// TODO: match deconstruct structs
+// TODO: match deconstruct enums
 // TODO: arrays and pointers
 
 typedef enum ExecMode {
@@ -52,12 +52,6 @@ Str sym_kind_str[] = {
 
 typedef Str Type;
 
-typedef struct Symbol {
-    SymbolKind kind;
-    Str name;
-    struct SymbolMap *fields;
-} Symbol;
-
 typedef struct Fun {
     Str name;
     Str param_type;
@@ -75,21 +69,14 @@ typedef struct Struct {
     Node *val;
 } Struct;
 
-MAPDEF(SymbolMap, symmap, Str, Symbol, str_hash, str_eq)
 MAPDEF(TypeMap, typemap, Str, Type, str_hash, str_eq)
 MAPDEF(FunMap, funmap, Str, Fun, str_hash, str_eq)
 MAPDEF(EnumMap, enummap, Str, Enum, str_hash, str_eq)
 MAPDEF(StructMap, structmap, Str, Struct, str_hash, str_eq)
 
-typedef struct Scope {
-    sz id;
-    sz depth;
-    SymbolMap *symbols;
-    struct Scope *parent;
-} Scope;
-
 typedef struct TypeScope {
     sz id;
+    sz depth;
     Str name;
     TypeMap *types;
     FunMap *funcs;
@@ -102,45 +89,21 @@ typedef struct Analyzer {
     Arena *storage;
     Str file_name;
     sz typescope_gen;
-    sz scope_gen;
-    Scope **scopes;
     TypeScope **types;
     StrSet *numeric_types;
     StrSet *integer_types;
 } Analyzer;
 
-Scope *
-scope_alloc(Analyzer *a, Scope *parent) {
-    bool is_root = parent == NULL;
-    Scope *scope = arena_calloc(sizeof(Scope), a->storage);
-    scope->id = a->scope_gen++;
-    scope->parent = parent;
-    scope->depth = is_root ? 0 : parent->depth + 1;
-    array_push(a->scopes, scope, a->storage);
-    return scope;
-}
-
 TypeScope *
 typescope_alloc(Analyzer *a, TypeScope *parent) {
     TypeScope *scope = arena_calloc(sizeof(TypeScope), a->storage);
     scope->parent = parent;
     scope->id = a->typescope_gen++;
+    scope->depth = parent == NULL ? 0 : parent->depth + 1;
     array_push(a->types, scope, a->storage);
     return scope;
 }
 
-SymbolMap *
-find_symbol(Scope *scope, Str symbol) {
-    while (scope != NULL) {
-        SymbolMap *val = symmap_lookup(&scope->symbols, symbol);
-        if (val != NULL) {
-            return val;
-        }
-        scope = scope->parent;
-    }
-    return NULL;
-}
-
 TypeMap *
 find_type(TypeScope *scope, Str type) {
     while (scope != NULL) {
@@ -200,60 +163,6 @@ find_struct(TypeScope *scope, Str type) {
 }
 
 void
-graph_scope(Scope *scope, Arena a) {
-    if (!scope->symbols) {
-        return;
-    }
-    SymbolMapIter iter = symmap_iterator(scope->symbols, &a);
-    SymbolMap *sym = symmap_next(&iter, &a);
-    print(
-        "%d[shape=\"none\" label=<<TABLE ALIGN=\"left\" STYLE=\"rounded\" "
-        "BORDER=\"1\" CELLBORDER=\"0\" CELLSPACING=\"0\" CELLPADDING=\"6\" "
-        "COLUMNS=\"*\">"
-        "<TR style=\"rounded\"><TD COLSPAN=\"3\">ID: %d</TD></TR>",
-        scope->id, scope->id);
-    print(
-        "<TR >"
-        "<TD ALIGN=\"left\" > NAME </TD>"
-        "<TD ALIGN=\"left\" > KIND </TD>"
-        "<TD ALIGN=\"left\" > TYPE </TD>"
-        "</TR>");
-    while (sym) {
-        Str type_name = cstr("nil");
-        print(
-            "<TR>"
-            "<TD ALIGN=\"left\"> %s </TD>"
-            "<TD ALIGN=\"left\"> %s </TD>"
-            "<TD ALIGN=\"left\"> %s </TD>"
-            "</TR>",
-            sym->val.name, sym_kind_str[sym->val.kind], type_name);
-        SymbolMapIter field_iter = symmap_iterator(sym->val.fields, &a);
-        SymbolMap *field = symmap_next(&field_iter, &a);
-        while (field) {
-            print(
-                "<TR>"
-                "<TD ALIGN=\"left\"> %s.%s </TD>"
-                "<TD ALIGN=\"left\"> %s "
-                "</TD>"
-                "</TR>",
-                sym->val.name, field->val.name, sym_kind_str[field->val.kind]);
-            field = symmap_next(&field_iter, &a);
-        }
-        sym = symmap_next(&iter, &a);
-    }
-    println("</TABLE>>];");
-    sz this_id = scope->id;
-    while (scope->parent) {
-        if (scope->parent->symbols) {
-            println("%d:n->%d:s;", this_id, scope->parent->id);
-            break;
-        } else {
-            scope = scope->parent;
-        }
-    }
-}
-
-void
 graph_typescope(TypeScope *scope, Arena a) {
     if (!scope->types) {
         return;
@@ -335,27 +244,6 @@ graph_functions(TypeScope *scope, Arena a) {
 }
 
 void
-graph_symbols(Scope **scopes, Arena a) {
-    if (scopes == NULL) return;
-    println("digraph symbols {");
-    println("rankdir=BT;");
-    println("ranksep=\"0.95 equally\";");
-    println("nodesep=\"0.5 equally\";");
-    println("overlap=scale;");
-    println("bgcolor=\"transparent\";");
-    for (sz i = 0; i < array_size(scopes); i++) {
-        Scope *scope = scopes[i];
-        if (!scope) {
-            continue;
-        }
-        println("subgraph %d {", i);
-        graph_scope(scope, a);
-        println("}");
-    }
-    println("}");
-}
-
-void
 graph_types(TypeScope **scopes, Arena a) {
     if (scopes == NULL) return;
     println("digraph types {");
@@ -386,7 +274,6 @@ Type type_inference(Analyzer *a, Node *node, TypeScope *scope);
 
 void
 typecheck_field(Analyzer *a, Node *node, TypeScope *scope, Str symbol) {
-    // TODO: ensure the tables are filled properly.
     if (node->field_type->kind == NODE_COMPOUND_TYPE) {
         Str field_name = str_concat(symbol, cstr("."), a->storage);
         field_name = str_concat(field_name, node->value.str, a->storage);
@@ -476,7 +363,6 @@ typecheck_returns(Analyzer *a, Node *node, Str expected) {
     if (!node) {
         return;
     }
-
     // Traverse the tree again.
     switch (node->kind) {
         case NODE_COND:
@@ -556,6 +442,14 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
         case NODE_LET: {
             node->type = cstr("nil");
             Str symbol = node->var_name->value.str;
+            if (typemap_lookup(&scope->types, symbol)) {
+                eprintln(
+                    "%s:%d:%d: error: symbol '%s' already exists in current "
+                    "scope ",
+                    a->file_name, node->var_name->line, node->var_name->col,
+                    symbol);
+                return cstr("");
+            }
             if (node->var_type) {
                 Str type_name = node->var_type->value.str;
                 TypeMap *type = find_type(scope, type_name);
@@ -620,7 +514,13 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
         case NODE_STRUCT: {
             node->type = cstr("nil");
             Str symbol = node->value.str;
-            // TODO: make sure it didn't exist before.
+            if (typemap_lookup(&scope->types, symbol) != NULL) {
+                eprintln(
+                    "%s:%d:%d: error: struct '%s' already exists in current "
+                    "scope",
+                    a->file_name, node->line, node->col, symbol);
+                return cstr("");
+            }
             structmap_insert(&scope->structs, symbol, (Struct){.name = symbol},
                              a->storage);
             for (sz i = 0; i < array_size(node->struct_field); i++) {
@@ -633,7 +533,13 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
         case NODE_ENUM: {
             node->type = cstr("nil");
             Str symbol = node->value.str;
-            // TODO: make sure it didn't exist before.
+            if (typemap_lookup(&scope->types, symbol) != NULL) {
+                eprintln(
+                    "%s:%d:%d: error: enum '%s' already exists in current "
+                    "scope",
+                    a->file_name, node->line, node->col, symbol);
+                return cstr("");
+            }
             enummap_insert(&scope->enums, symbol,
                            (Enum){
                                .name = symbol,
@@ -871,6 +777,7 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
             node->type = type->val;
             return node->type;
         } break;
+        case NODE_SYMBOL_IDX:
         case NODE_SYMBOL: {
             Str symbol = node->value.str;
             TypeMap *type = find_type(scope, symbol);
@@ -975,7 +882,7 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
             if (!fun) {
                 eprintln(
                     "%s:%d:%d: error: function '%s' doesn't exist in current "
-                    " scope ",
+                    "scope ",
                     a->file_name, node->line, node->col, symbol);
                 return cstr("");
             }
@@ -1030,24 +937,6 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
             return node->type;
         } break;
         case NODE_FUN: {
-            // TODO: we may want to do this and register a special table with
-            // function and formals...
-            // if (scope->parent != NULL) {
-            // //     Str symbol = node->func_name->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->func_name->line,
-            // //             node->func_name->col, symbol);
-            // //         return;
-            // //     }
-            // //     symmap_insert(&scope->symbols, symbol,
-            // //                   (Symbol){.kind = SYM_FUN, .name = symbol},
-            // //                   a->storage);
-            // }
-
             node->type = cstr("nil");
             TypeScope *prev_scope = scope;
             scope = typescope_alloc(a, scope);
@@ -1085,7 +974,18 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
             node->fun_return = ret_type;
 
             Str symbol = node->func_name->value.str;
-            // TODO: check it was not defined before.
+            if (prev_scope->parent != NULL) {
+                if (typemap_lookup(&prev_scope->types, symbol)) {
+                    eprintln(
+                        "%s:%d:%d: error: function '%s' already defined in "
+                        "current "
+                        "scope ",
+                        a->file_name, node->var_name->line, node->var_name->col,
+                        symbol);
+                    return cstr("");
+                }
+                typemap_insert(&prev_scope->types, symbol, symbol, a->storage);
+            }
             scope->name = symbol;
             funmap_insert(&prev_scope->funcs, symbol,
                           (Fun){.name = symbol,
@@ -1131,226 +1031,10 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
 }
 
 void
-analyzer_symbols(Analyzer *a, Node *node, Scope *scope) {
-    assert(a);
-    assert(scope);
-    if (!node) {
-        return;
-    }
-    node->scope = scope;
-    switch (node->kind) {
-        case NODE_FUN: {
-            if (scope->depth != 0) {
-                Str symbol = node->func_name->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->func_name->line,
-                        node->func_name->col, symbol);
-                    return;
-                }
-                symmap_insert(&scope->symbols, symbol,
-                              (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];
-                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;
-                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: {
-            if (node->match_expr) {
-                analyzer_symbols(a, node->match_expr, scope);
-            }
-            for (sz i = 0; i < array_size(node->match_cases); i++) {
-                Node *expr = node->match_cases[i];
-                analyzer_symbols(a, expr, scope);
-            }
-        } break;
-        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:
-        // case NODE_STRUCT_LIT:
-        case NODE_BLOCK: {
-            Scope *next = scope_alloc(a, scope);
-            node->scope = scope;
-            for (sz i = 0; i < array_size(node->elements); i++) {
-                Node *expr = node->elements[i];
-                analyzer_symbols(a, expr, next);
-            }
-        } break;
-        case NODE_STRUCT:
-        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 = node->kind == NODE_ENUM ? SYM_ENUM : SYM_STRUCT,
-                    .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->value.str;
-                if (symmap_lookup(&map->val.fields, field_name) != NULL) {
-                    eprintln(
-                        "%s:%d:%d: error: struct field '%s.%s' already exists",
-                        a->file_name, field->line, field->col, symbol,
-                        field_name);
-                    return;
-                }
-                Symbol s =
-                    (Symbol){.kind = node->kind == NODE_ENUM ? SYM_ENUM_FIELD
-                                                             : SYM_STRUCT_FIELD,
-                             .name = field_name};
-                symmap_insert(&map->val.fields, field_name, s, a->storage);
-            }
-        } break;
-        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) {
-                    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) {
-                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) {
-                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);
-            if (node->while_expr->kind != NODE_BLOCK) {
-                scope = scope_alloc(a, scope);
-            }
-            analyzer_symbols(a, node->while_expr, scope);
-        } break;
-        case NODE_FUNCALL: {
-            Str symbol = node->value.str;
-            if (find_symbol(scope, symbol) == NULL) {
-                eprintln(
-                    "%s:%d:%d: error: symbol '%s' doesn't exists in current "
-                    " scope ",
-                    a->file_name, node->line, node->col, symbol);
-                return;
-            }
-            for (sz i = 0; i < array_size(node->elements); i++) {
-                Node *expr = node->elements[i];
-                analyzer_symbols(a, expr, scope);
-            }
-        } break;
-        case NODE_SYMBOL_IDX:
-        case NODE_SYMBOL: {
-            Str symbol = node->value.str;
-            if (find_symbol(scope, symbol) == NULL) {
-                eprintln(
-                    "%s:%d:%d: error: symbol '%s' doesn't exists in current "
-                    " scope ",
-                    a->file_name, node->line, node->col, symbol);
-                return;
-            }
-            // TODO: Resolve symbol chains.
-        } break;
-        case NODE_SET: {
-            analyzer_symbols(a, node->var_name, scope);
-            analyzer_symbols(a, node->var_val, scope);
-        } break;
-        case NODE_LET: {
-            // Check the value first to avoid recursive symbol usage.
-            analyzer_symbols(a, node->var_val, scope);
-
-            Str symbol = node->var_name->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->var_name->line, node->var_name->col,
-                    symbol);
-                return;
-            }
-            symmap_insert(&scope->symbols, symbol,
-                          (Symbol){.kind = SYM_VAR, .name = symbol},
-                          a->storage);
-        } break;
-        // Binary ops
-        case NODE_ADD:
-        case NODE_SUB:
-        case NODE_DIV:
-        case NODE_MUL:
-        case NODE_MOD:
-        case NODE_NOT:
-        case NODE_AND:
-        case NODE_OR:
-        case NODE_EQ:
-        case NODE_NEQ:
-        case NODE_LT:
-        case NODE_GT:
-        case NODE_LE:
-        case NODE_GE:
-        case NODE_BITNOT:
-        case NODE_BITAND:
-        case NODE_BITOR:
-        case NODE_BITLSHIFT:
-        case NODE_BITRSHIFT: {
-            analyzer_symbols(a, node->left, scope);
-            analyzer_symbols(a, node->right, scope);
-        } break;
-        default: break;
-    }
-}
-
-void
 symbolic_analysis(Analyzer *a, Parser *parser) {
-    Scope *scope = scope_alloc(a, NULL);
     TypeScope *types = typescope_alloc(a, NULL);
     assert(a);
     assert(parser);
-    assert(scope);
 
     // Fill builtin tables.
     Str builtin_functions[] = {
@@ -1359,8 +1043,12 @@ 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, .name = symbol};
-        symmap_insert(&scope->symbols, symbol, sym, a->storage);
+        typemap_insert(&types->types, symbol, symbol, a->storage);
+        funmap_insert(&types->funcs, symbol,
+                      (Fun){.name = symbol,
+                            .param_type = cstr("..."),
+                            .return_type = cstr("nil")},
+                      a->storage);
     }
     Type builtin_types[] = {
         cstr("u8"),   cstr("s8"),  cstr("u16"),  cstr("s16"),
@@ -1389,35 +1077,27 @@ symbolic_analysis(Analyzer *a, Parser *parser) {
         Type type = integer_types[i];
         strset_insert(&a->integer_types, type, a->storage);
     }
-
     // Find top level function declarations.
     for (sz i = 0; i < array_size(parser->nodes); i++) {
         Node *root = parser->nodes[i];
         if (root->kind == NODE_FUN) {
             Str symbol = root->func_name->value.str;
-            if (symmap_lookup(&scope->symbols, symbol) != NULL) {
+            if (typemap_lookup(&types->types, symbol)) {
                 eprintln(
-                    "%s:%d:%d: error: symbol '%s' already exists in current "
-                    "scope",
-                    a->file_name, root->func_name->line, root->func_name->col,
+                    "%s:%d:%d: error: function '%s' already defined in "
+                    "current "
+                    "scope ",
+                    a->file_name, root->var_name->line, root->var_name->col,
                     symbol);
             }
-            symmap_insert(&scope->symbols, symbol,
-                          (Symbol){.kind = SYM_FUN, .name = symbol},
-                          a->storage);
+            typemap_insert(&types->types, symbol, symbol, a->storage);
         }
     }
-
     // Recursively fill symbol tables.
     for (sz i = 0; i < array_size(parser->nodes); i++) {
         Node *root = parser->nodes[i];
         type_inference(a, root, types);
-        analyzer_symbols(a, root, scope);
     }
-    // for (sz i = 0; i < array_size(parser->nodes); i++) {
-    //     Node *root = parser->nodes[i];
-    //     analyzer_typecheck(a, root, scope);
-    // }
 }
 
 void
@@ -1502,7 +1182,7 @@ process_file(Str path) {
     }
 
 #if DEBUG == 1
-    println("========   enums   ========");
+    println("========== enums ==========");
     for (sz i = 0; i < array_size(analyzer.types); i++) {
         Arena scratch = lexer_arena;
         TypeScope *scope = analyzer.types[i];
@@ -1514,7 +1194,7 @@ process_file(Str path) {
             m = enummap_next(&iter, &scratch);
         }
     }
-    println("========  structs  ========");
+    println("========= structs =========");
     for (sz i = 0; i < array_size(analyzer.types); i++) {
         Arena scratch = lexer_arena;
         TypeScope *scope = analyzer.types[i];
@@ -1538,25 +1218,18 @@ process_file(Str path) {
             m = funmap_next(&iter, &scratch);
         }
     }
-    // println("========  symbols  ========");
-    // 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->val.name);
-    //     SymbolMapIter field_iter =
-    //         symmap_iterator(sym->val.fields, &scratch);
-    //     SymbolMap *field = symmap_next(&field_iter, &scratch);
-    //     while (field) {
-    //         println("%s: SCOPE: %d DEPTH: %d\t%s %s.%s", path, scope->id,
-    //                 scope->depth, sym_kind_str[field->val.kind],
-    //                 sym->val.name, field->val.name);
-    //         field = symmap_next(&field_iter, &scratch);
-    //     }
-    //     sym = symmap_next(&iter, &lexer_arena);
-    // }
-    // }
+    println("========== types ==========");
+    for (sz i = 0; i < array_size(analyzer.types); i++) {
+        Arena scratch = lexer_arena;
+        TypeScope *scope = analyzer.types[i];
+        TypeMapIter iter = typemap_iterator(scope->types, &scratch);
+        TypeMap *m = typemap_next(&iter, &scratch);
+        while (m) {
+            println("scope: %x{2} -- %s: type: %s: %s", scope->id, path, m->key,
+                    m->val);
+            m = typemap_next(&iter, &scratch);
+        }
+    }
 #endif
 
     // TODO: Type checking.