Continue consolidation with proper naming

1 files changed, 71 insertions, 71 deletions

diff --git a/src/main.c b/src/main.c
index 898ac15..d997245 100644
--- a/src/main.c
+++ b/src/main.c
@@ -50,7 +50,7 @@ Str sym_kind_str[] = {
     [SYM_STRUCT_FIELD] = cstr("STRUCT FIELD "),
 };
 
-typedef Str Type;
+typedef Str Symbol;
 
 typedef struct Fun {
     Str name;
@@ -69,7 +69,7 @@ typedef struct Struct {
     Node *val;
 } Struct;
 
-MAPDEF(TypeMap, typemap, Str, Type, str_hash, str_eq)
+MAPDEF(SymbolMap, symmap, Str, Symbol, 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)
@@ -78,7 +78,7 @@ typedef struct TypeScope {
     sz id;
     sz depth;
     Str name;
-    TypeMap *types;
+    SymbolMap *symbols;
     FunMap *funcs;
     EnumMap *enums;
     StructMap *structs;
@@ -104,10 +104,10 @@ typescope_alloc(Analyzer *a, TypeScope *parent) {
     return scope;
 }
 
-TypeMap *
+SymbolMap *
 find_type(TypeScope *scope, Str type) {
     while (scope != NULL) {
-        TypeMap *val = typemap_lookup(&scope->types, type);
+        SymbolMap *val = symmap_lookup(&scope->symbols, type);
         if (val != NULL) {
             return val;
         }
@@ -164,11 +164,11 @@ find_struct(TypeScope *scope, Str type) {
 
 void
 graph_typescope(TypeScope *scope, Arena a) {
-    if (!scope->types) {
+    if (!scope->symbols) {
         return;
     }
-    TypeMapIter iter = typemap_iterator(scope->types, &a);
-    TypeMap *type = typemap_next(&iter, &a);
+    SymbolMapIter iter = symmap_iterator(scope->symbols, &a);
+    SymbolMap *type = symmap_next(&iter, &a);
     print(
         "%d[shape=\"none\" label=<<TABLE ALIGN=\"left\" STYLE=\"rounded\" "
         "BORDER=\"1\" CELLBORDER=\"0\" CELLSPACING=\"0\" CELLPADDING=\"6\" "
@@ -186,13 +186,13 @@ graph_typescope(TypeScope *scope, Arena a) {
             "<TD ALIGN=\"left\"> %s</TD>"
             "</TR>",
             type->key, type->val);
-        type = typemap_next(&iter, &a);
+        type = symmap_next(&iter, &a);
     }
     println("</TABLE>>];");
 
     sz this_id = scope->id;
     while (scope->parent) {
-        if (scope->parent->types) {
+        if (scope->parent->symbols) {
             println("%d:e->%d:w;", this_id, scope->parent->id);
             break;
         } else {
@@ -233,7 +233,7 @@ graph_functions(TypeScope *scope, Arena a) {
     println("</TABLE>>];");
     sz this_id = scope->id;
     while (scope->parent) {
-        if (scope->parent->types) {
+        if (scope->parent->symbols) {
             println("fun_%d:e->fun_%d:%s:w;", this_id, scope->parent->id,
                     scope->name);
             break;
@@ -270,7 +270,7 @@ emit_semantic_error(Analyzer *a, Node *n, Str msg) {
     eprintln("%s:%d:%d: error: %s", a->file_name, n->line, n->col, msg);
 }
 
-Type type_inference(Analyzer *a, Node *node, TypeScope *scope);
+Symbol type_inference(Analyzer *a, Node *node, TypeScope *scope);
 
 void
 typecheck_field(Analyzer *a, Node *node, TypeScope *scope, Str symbol) {
@@ -303,7 +303,7 @@ typecheck_field(Analyzer *a, Node *node, TypeScope *scope, Str symbol) {
                      a->file_name, node->line, node->col, field_name);
         }
         if (node->field_val) {
-            Type type = type_inference(a, node->field_val, scope);
+            Symbol type = type_inference(a, node->field_val, scope);
             if (!str_eq(type, field_type)) {
                 eprintln(
                     "%s:%d:%d: error: mismatched types in struct "
@@ -346,7 +346,7 @@ typecheck_lit_field(Analyzer *a, Node *node, TypeScope *scope, Str symbol) {
             return;
         }
         Str field_type = s->val.type;
-        Type type = type_inference(a, node->field_val, scope);
+        Symbol type = type_inference(a, node->field_val, scope);
         if (!str_eq(type, field_type)) {
             eprintln(
                 "%s:%d:%d: error: mismatched types in struct "
@@ -430,7 +430,7 @@ typecheck_returns(Analyzer *a, Node *node, Str expected) {
     }
 }
 
-Type
+Symbol
 type_inference(Analyzer *a, Node *node, TypeScope *scope) {
     assert(a);
     assert(scope);
@@ -442,7 +442,7 @@ 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)) {
+            if (symmap_lookup(&scope->symbols, symbol)) {
                 eprintln(
                     "%s:%d:%d: error: symbol '%s' already exists in current "
                     "scope ",
@@ -452,7 +452,7 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
             }
             if (node->var_type) {
                 Str type_name = node->var_type->value.str;
-                TypeMap *type = find_type(scope, type_name);
+                SymbolMap *type = find_type(scope, type_name);
                 if (type == NULL) {
                     eprintln("%s:%d:%d: error: unknown type '%s'", a->file_name,
                              node->var_type->line, node->var_type->col,
@@ -460,7 +460,7 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
                     return cstr("");
                 }
                 if (node->var_val) {
-                    Type type = type_inference(a, node->var_val, scope);
+                    Symbol type = type_inference(a, node->var_val, scope);
                     if (!type.size) {
                         eprintln(
                             "%s:%d:%d: error: can't bind `nil` to variable "
@@ -485,21 +485,21 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
                         }
                     }
                 }
-                typemap_insert(&scope->types, symbol, type->val, a->storage);
+                symmap_insert(&scope->symbols, symbol, type->val, a->storage);
                 return node->type;
             }
 
             // We don't know the type for this symbol, perform inference.
-            Type type = type_inference(a, node->var_val, scope);
+            Symbol type = type_inference(a, node->var_val, scope);
             if (type.size) {
-                typemap_insert(&scope->types, symbol, type, a->storage);
+                symmap_insert(&scope->symbols, symbol, type, a->storage);
                 node->var_name->type = type;
             }
             return node->type;
         } break;
         case NODE_SET: {
-            Type name = type_inference(a, node->var_name, scope);
-            Type val = type_inference(a, node->var_val, scope);
+            Symbol name = type_inference(a, node->var_name, scope);
+            Symbol val = type_inference(a, node->var_val, scope);
             if (!str_eq(name, val)) {
                 eprintln(
                     "%s:%d:%d: error: type mismatch, trying to assing "
@@ -514,7 +514,7 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
         case NODE_STRUCT: {
             node->type = cstr("nil");
             Str symbol = node->value.str;
-            if (typemap_lookup(&scope->types, symbol) != NULL) {
+            if (symmap_lookup(&scope->symbols, symbol) != NULL) {
                 eprintln(
                     "%s:%d:%d: error: struct '%s' already exists in current "
                     "scope",
@@ -527,13 +527,13 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
                 Node *field = node->struct_field[i];
                 typecheck_field(a, field, scope, symbol);
             }
-            typemap_insert(&scope->types, symbol, symbol, a->storage);
+            symmap_insert(&scope->symbols, symbol, symbol, a->storage);
             return node->type;
         } break;
         case NODE_ENUM: {
             node->type = cstr("nil");
             Str symbol = node->value.str;
-            if (typemap_lookup(&scope->types, symbol) != NULL) {
+            if (symmap_lookup(&scope->symbols, symbol) != NULL) {
                 eprintln(
                     "%s:%d:%d: error: enum '%s' already exists in current "
                     "scope",
@@ -556,7 +556,7 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
                              a->file_name, field->line, field->col, field_name);
                 }
                 if (field->field_val) {
-                    Type type = type_inference(a, field->field_val, scope);
+                    Symbol type = type_inference(a, field->field_val, scope);
                     if (!str_eq(type, cstr("int"))) {
                         eprintln(
                             "%s:%d:%d: error: non int enum value for '%s.%s'",
@@ -568,11 +568,11 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
                                (Enum){.name = field_name}, a->storage);
                 field->type = cstr("int");
             }
-            typemap_insert(&scope->types, symbol, symbol, a->storage);
+            symmap_insert(&scope->symbols, symbol, symbol, a->storage);
             return node->type;
         } break;
         case NODE_IF: {
-            Type cond_type = type_inference(a, node->cond_if, scope);
+            Symbol cond_type = type_inference(a, node->cond_if, scope);
             if (!str_eq(cond_type, cstr("bool"))) {
                 emit_semantic_error(
                     a, node->cond_if,
@@ -586,7 +586,7 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
                 node->type = type_inference(a, node->cond_expr, next);
             }
             if (node->cond_else) {
-                Type else_type;
+                Symbol else_type;
                 if (node->cond_else->kind == NODE_BLOCK) {
                     else_type = type_inference(a, node->cond_else, scope);
                 } else {
@@ -602,7 +602,7 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
             return node->type;
         } break;
         case NODE_WHILE: {
-            Type cond_type = type_inference(a, node->while_cond, scope);
+            Symbol cond_type = type_inference(a, node->while_cond, scope);
             if (!str_eq(cond_type, cstr("bool"))) {
                 emit_semantic_error(
                     a, node->cond_if,
@@ -621,10 +621,10 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
             if (node->match_expr) {
                 type_inference(a, node->match_expr, scope);
             }
-            Type previous = cstr("");
+            Symbol 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);
+                Symbol next = type_inference(a, expr, scope);
                 if (i != 0 && !str_eq(next, previous)) {
                     emit_semantic_error(
                         a, node,
@@ -649,7 +649,7 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
         } break;
         case NODE_CASE_COND: {
             if (node->case_value) {
-                Type cond = type_inference(a, node->case_value, scope);
+                Symbol cond = type_inference(a, node->case_value, scope);
                 if (!str_eq(cond, cstr("bool"))) {
                     emit_semantic_error(a, node,
                                         cstr("non-boolean case condition"));
@@ -673,14 +673,14 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
         case NODE_NOT:
         case NODE_AND:
         case NODE_OR: {
-            Type left = type_inference(a, node->left, scope);
+            Symbol left = type_inference(a, node->left, scope);
             if (!str_eq(left, cstr("bool"))) {
                 emit_semantic_error(a, node,
                                     cstr("expected bool on logic expression"));
                 return cstr("");
             }
             if (node->right) {
-                Type right = type_inference(a, node->right, scope);
+                Symbol right = type_inference(a, node->right, scope);
                 if (!str_eq(right, cstr("bool"))) {
                     emit_semantic_error(
                         a, node, cstr("expected bool on logic expression"));
@@ -696,8 +696,8 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
         case NODE_GT:
         case NODE_LE:
         case NODE_GE: {
-            Type left = type_inference(a, node->left, scope);
-            Type right = type_inference(a, node->right, scope);
+            Symbol left = type_inference(a, node->left, scope);
+            Symbol right = type_inference(a, node->right, scope);
             if (!str_eq(left, right)) {
                 emit_semantic_error(
                     a, node, cstr("mismatched types on binary expression"));
@@ -707,7 +707,7 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
             return node->type;
         } break;
         case NODE_BITNOT: {
-            Type left = type_inference(a, node->left, scope);
+            Symbol left = type_inference(a, node->left, scope);
             if (!strset_lookup(&a->integer_types, left)) {
                 emit_semantic_error(
                     a, node, cstr("non integer type on bit twiddling expr"));
@@ -720,8 +720,8 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
         case NODE_BITOR:
         case NODE_BITLSHIFT:
         case NODE_BITRSHIFT: {
-            Type left = type_inference(a, node->left, scope);
-            Type right = type_inference(a, node->right, scope);
+            Symbol left = type_inference(a, node->left, scope);
+            Symbol right = type_inference(a, node->right, scope);
             if (!strset_lookup(&a->integer_types, left) ||
                 !strset_lookup(&a->integer_types, right)) {
                 emit_semantic_error(
@@ -736,8 +736,8 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
         case NODE_DIV:
         case NODE_MUL:
         case NODE_MOD: {
-            Type left = type_inference(a, node->left, scope);
-            Type right = type_inference(a, node->right, scope);
+            Symbol left = type_inference(a, node->left, scope);
+            Symbol right = type_inference(a, node->right, scope);
             if (!strset_lookup(&a->numeric_types, left) ||
                 !strset_lookup(&a->numeric_types, right)) {
                 emit_semantic_error(
@@ -769,7 +769,7 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
             return node->type;
         } break;
         case NODE_TYPE: {
-            TypeMap *type = find_type(scope, node->value.str);
+            SymbolMap *type = find_type(scope, node->value.str);
             if (!type) {
                 emit_semantic_error(a, node, cstr("unknown type"));
                 return cstr("");
@@ -780,7 +780,7 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
         case NODE_SYMBOL_IDX:
         case NODE_SYMBOL: {
             Str symbol = node->value.str;
-            TypeMap *type = find_type(scope, symbol);
+            SymbolMap *type = find_type(scope, symbol);
             if (!type) {
                 eprintln("%s:%d:%d: error: couldn't resolve symbol '%s'",
                          a->file_name, node->line, node->col, symbol);
@@ -887,10 +887,10 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
                 return cstr("");
             }
             // Check that actual parameters typecheck
-            Type args = cstr("");
+            Symbol args = cstr("");
             for (sz i = 0; i < array_size(node->elements); i++) {
                 Node *expr = node->elements[i];
-                Type type = type_inference(a, expr, scope);
+                Symbol type = type_inference(a, expr, scope);
                 args = str_concat(args, type, a->storage);
                 if (i != array_size(node->elements) - 1) {
                     args = str_concat(args, cstr(","), a->storage);
@@ -912,7 +912,7 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
         } break;
         case NODE_BLOCK: {
             scope = typescope_alloc(a, scope);
-            Type type;
+            Symbol type;
             for (sz i = 0; i < array_size(node->elements); i++) {
                 Node *expr = node->elements[i];
                 type = type_inference(a, expr, scope);
@@ -921,10 +921,10 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
             return node->type;
         } break;
         case NODE_RETURN: {
-            Type ret_type = cstr("");
+            Symbol ret_type = cstr("");
             for (sz i = 0; i < array_size(node->elements); i++) {
                 Node *expr = node->elements[i];
-                Type type = type_inference(a, expr, scope);
+                Symbol type = type_inference(a, expr, scope);
                 ret_type = str_concat(ret_type, type, a->storage);
                 if (i != array_size(node->elements) - 1) {
                     ret_type = str_concat(ret_type, cstr(","), a->storage);
@@ -940,15 +940,15 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
             node->type = cstr("nil");
             TypeScope *prev_scope = scope;
             scope = typescope_alloc(a, scope);
-            Type param_type = cstr("");
+            Symbol param_type = cstr("");
             for (sz i = 0; i < array_size(node->func_params); i++) {
                 Node *param = node->func_params[i];
                 Str symbol = param->param_name->value.str;
-                Type type = param->param_type->value.str;
+                Symbol type = param->param_type->value.str;
                 param->param_name->type =
                     type_inference(a, param->param_type, scope);
                 param->type = param->param_name->type;
-                typemap_insert(&scope->types, symbol, type, a->storage);
+                symmap_insert(&scope->symbols, symbol, type, a->storage);
                 param_type = str_concat(param_type, type, a->storage);
                 if (i != array_size(node->func_params) - 1) {
                     param_type = str_concat(param_type, cstr(","), a->storage);
@@ -959,10 +959,10 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
             }
             node->fun_params = param_type;
 
-            Type ret_type = cstr("");
+            Symbol ret_type = cstr("");
             for (sz i = 0; i < array_size(node->func_ret); i++) {
                 Node *expr = node->func_ret[i];
-                Type type = type_inference(a, expr, scope);
+                Symbol type = type_inference(a, expr, scope);
                 ret_type = str_concat(ret_type, type, a->storage);
                 if (i != array_size(node->func_ret) - 1) {
                     ret_type = str_concat(ret_type, cstr(","), a->storage);
@@ -975,7 +975,7 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
 
             Str symbol = node->func_name->value.str;
             if (prev_scope->parent != NULL) {
-                if (typemap_lookup(&prev_scope->types, symbol)) {
+                if (symmap_lookup(&prev_scope->symbols, symbol)) {
                     eprintln(
                         "%s:%d:%d: error: function '%s' already defined in "
                         "current "
@@ -984,7 +984,7 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
                         symbol);
                     return cstr("");
                 }
-                typemap_insert(&prev_scope->types, symbol, symbol, a->storage);
+                symmap_insert(&prev_scope->symbols, symbol, symbol, a->storage);
             }
             scope->name = symbol;
             funmap_insert(&prev_scope->funcs, symbol,
@@ -994,7 +994,7 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
                           a->storage);
 
             if (node->func_body->kind == NODE_BLOCK) {
-                Type type;
+                Symbol type;
                 for (sz i = 0; i < array_size(node->func_body->elements); i++) {
                     Node *expr = node->func_body->elements[i];
                     type = type_inference(a, expr, scope);
@@ -1043,38 +1043,38 @@ symbolic_analysis(Analyzer *a, Parser *parser) {
     };
     for (sz i = 0; i < LEN(builtin_functions); i++) {
         Str symbol = builtin_functions[i];
-        typemap_insert(&types->types, symbol, symbol, a->storage);
+        symmap_insert(&types->symbols, symbol, symbol, a->storage);
         funmap_insert(&types->funcs, symbol,
                       (Fun){.name = symbol,
                             .param_type = cstr("..."),
                             .return_type = cstr("nil")},
                       a->storage);
     }
-    Type builtin_types[] = {
+    Symbol builtin_types[] = {
         cstr("u8"),   cstr("s8"),  cstr("u16"),  cstr("s16"),
         cstr("u32"),  cstr("s32"), cstr("u64"),  cstr("s64"),
         cstr("f32"),  cstr("f64"), cstr("ptr"),  cstr("int"),
         cstr("uint"), cstr("str"), cstr("bool"), cstr("nil")};
     for (sz i = 0; i < LEN(builtin_types); i++) {
-        Type type = builtin_types[i];
-        typemap_insert(&types->types, type, type, a->storage);
+        Symbol type = builtin_types[i];
+        symmap_insert(&types->symbols, type, type, a->storage);
     }
-    Type numeric_types[] = {
+    Symbol numeric_types[] = {
         cstr("u8"),  cstr("s8"),  cstr("u16"),  cstr("s16"), cstr("u32"),
         cstr("s32"), cstr("u64"), cstr("s64"),  cstr("f32"), cstr("f64"),
         cstr("ptr"), cstr("int"), cstr("uint"),
     };
     for (sz i = 0; i < LEN(numeric_types); i++) {
-        Type type = numeric_types[i];
+        Symbol type = numeric_types[i];
         strset_insert(&a->numeric_types, type, a->storage);
     }
-    Type integer_types[] = {
+    Symbol integer_types[] = {
         cstr("u8"),  cstr("s8"),  cstr("u16"),  cstr("s16"),
         cstr("u32"), cstr("s32"), cstr("u64"),  cstr("s64"),
         cstr("ptr"), cstr("int"), cstr("uint"),
     };
     for (sz i = 0; i < LEN(integer_types); i++) {
-        Type type = integer_types[i];
+        Symbol type = integer_types[i];
         strset_insert(&a->integer_types, type, a->storage);
     }
     // Find top level function declarations.
@@ -1082,7 +1082,7 @@ symbolic_analysis(Analyzer *a, Parser *parser) {
         Node *root = parser->nodes[i];
         if (root->kind == NODE_FUN) {
             Str symbol = root->func_name->value.str;
-            if (typemap_lookup(&types->types, symbol)) {
+            if (symmap_lookup(&types->symbols, symbol)) {
                 eprintln(
                     "%s:%d:%d: error: function '%s' already defined in "
                     "current "
@@ -1090,7 +1090,7 @@ symbolic_analysis(Analyzer *a, Parser *parser) {
                     a->file_name, root->var_name->line, root->var_name->col,
                     symbol);
             }
-            typemap_insert(&types->types, symbol, symbol, a->storage);
+            symmap_insert(&types->symbols, symbol, symbol, a->storage);
         }
     }
     // Recursively fill symbol tables.
@@ -1222,12 +1222,12 @@ process_file(Str path) {
     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);
+        SymbolMapIter iter = symmap_iterator(scope->types, &scratch);
+        SymbolMap *m = symmap_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);
+            m = symmap_next(&iter, &scratch);
         }
     }
 #endif