Further consolidate symbol names

1 files changed, 122 insertions, 101 deletions

diff --git a/src/main.c b/src/main.c
index d997245..45c5213 100644
--- a/src/main.c
+++ b/src/main.c
@@ -28,7 +28,8 @@ init(void) {
 
 typedef enum {
     SYM_UNKNOWN,
-    SYM_BUILTIN,
+    SYM_BUILTIN_FUN,
+    SYM_BUILTIN_TYPE,
     SYM_FUN,
     SYM_VAR,
     SYM_PARAM,
@@ -40,7 +41,8 @@ typedef enum {
 
 Str sym_kind_str[] = {
     [SYM_UNKNOWN] = cstr("UNKNOWN      "),
-    [SYM_BUILTIN] = cstr("BUILTIN      "),
+    [SYM_BUILTIN_FUN] = cstr("BUILTIN FUN  "),
+    [SYM_BUILTIN_TYPE] = cstr("BUILTIN TYPE "),
     [SYM_FUN] = cstr("FUNCTION     "),
     [SYM_VAR] = cstr("VARIABLE     "),
     [SYM_PARAM] = cstr("PARAMETER    "),
@@ -50,7 +52,10 @@ Str sym_kind_str[] = {
     [SYM_STRUCT_FIELD] = cstr("STRUCT FIELD "),
 };
 
-typedef Str Symbol;
+typedef struct Symbol {
+    Str name;
+    SymbolKind kind;
+} Symbol;
 
 typedef struct Fun {
     Str name;
@@ -74,7 +79,7 @@ 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 TypeScope {
+typedef struct Scope {
     sz id;
     sz depth;
     Str name;
@@ -82,30 +87,30 @@ typedef struct TypeScope {
     FunMap *funcs;
     EnumMap *enums;
     StructMap *structs;
-    struct TypeScope *parent;
-} TypeScope;
+    struct Scope *parent;
+} Scope;
 
 typedef struct Analyzer {
     Arena *storage;
     Str file_name;
     sz typescope_gen;
-    TypeScope **types;
+    Scope **scopes;
     StrSet *numeric_types;
     StrSet *integer_types;
 } Analyzer;
 
-TypeScope *
-typescope_alloc(Analyzer *a, TypeScope *parent) {
-    TypeScope *scope = arena_calloc(sizeof(TypeScope), a->storage);
+Scope *
+typescope_alloc(Analyzer *a, Scope *parent) {
+    Scope *scope = arena_calloc(sizeof(Scope), 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);
+    array_push(a->scopes, scope, a->storage);
     return scope;
 }
 
 SymbolMap *
-find_type(TypeScope *scope, Str type) {
+find_type(Scope *scope, Str type) {
     while (scope != NULL) {
         SymbolMap *val = symmap_lookup(&scope->symbols, type);
         if (val != NULL) {
@@ -117,7 +122,7 @@ find_type(TypeScope *scope, Str type) {
 }
 
 FunMap *
-find_fun(TypeScope *scope, Str type) {
+find_fun(Scope *scope, Str type) {
     while (scope != NULL) {
         FunMap *val = funmap_lookup(&scope->funcs, type);
         if (val != NULL) {
@@ -130,11 +135,11 @@ find_fun(TypeScope *scope, Str type) {
 
 typedef struct FindEnumResult {
     EnumMap *map;
-    TypeScope *scope;
+    Scope *scope;
 } FindEnumResult;
 
 FindEnumResult
-find_enum(TypeScope *scope, Str type) {
+find_enum(Scope *scope, Str type) {
     while (scope != NULL) {
         EnumMap *val = enummap_lookup(&scope->enums, type);
         if (val != NULL) {
@@ -147,11 +152,11 @@ find_enum(TypeScope *scope, Str type) {
 
 typedef struct FindStructResult {
     StructMap *map;
-    TypeScope *scope;
+    Scope *scope;
 } FindStructResult;
 
 FindStructResult
-find_struct(TypeScope *scope, Str type) {
+find_struct(Scope *scope, Str type) {
     while (scope != NULL) {
         StructMap *val = structmap_lookup(&scope->structs, type);
         if (val != NULL) {
@@ -163,7 +168,7 @@ find_struct(TypeScope *scope, Str type) {
 }
 
 void
-graph_typescope(TypeScope *scope, Arena a) {
+graph_typescope(Scope *scope, Arena a) {
     if (!scope->symbols) {
         return;
     }
@@ -202,7 +207,7 @@ graph_typescope(TypeScope *scope, Arena a) {
 }
 
 void
-graph_functions(TypeScope *scope, Arena a) {
+graph_functions(Scope *scope, Arena a) {
     if (!scope->funcs) {
         return;
     }
@@ -244,7 +249,7 @@ graph_functions(TypeScope *scope, Arena a) {
 }
 
 void
-graph_types(TypeScope **scopes, Arena a) {
+graph_types(Scope **scopes, Arena a) {
     if (scopes == NULL) return;
     println("digraph types {");
     println("rankdir=LR;");
@@ -253,7 +258,7 @@ graph_types(TypeScope **scopes, Arena a) {
     println("overlap=scale;");
     println("bgcolor=\"transparent\";");
     for (sz i = 0; i < array_size(scopes); i++) {
-        TypeScope *scope = scopes[i];
+        Scope *scope = scopes[i];
         if (!scope) {
             continue;
         }
@@ -270,10 +275,10 @@ emit_semantic_error(Analyzer *a, Node *n, Str msg) {
     eprintln("%s:%d:%d: error: %s", a->file_name, n->line, n->col, msg);
 }
 
-Symbol type_inference(Analyzer *a, Node *node, TypeScope *scope);
+Str type_inference(Analyzer *a, Node *node, Scope *scope);
 
 void
-typecheck_field(Analyzer *a, Node *node, TypeScope *scope, Str symbol) {
+typecheck_field(Analyzer *a, Node *node, Scope *scope, Str symbol) {
     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);
@@ -303,7 +308,7 @@ typecheck_field(Analyzer *a, Node *node, TypeScope *scope, Str symbol) {
                      a->file_name, node->line, node->col, field_name);
         }
         if (node->field_val) {
-            Symbol type = type_inference(a, node->field_val, scope);
+            Str type = type_inference(a, node->field_val, scope);
             if (!str_eq(type, field_type)) {
                 eprintln(
                     "%s:%d:%d: error: mismatched types in struct "
@@ -325,7 +330,7 @@ typecheck_field(Analyzer *a, Node *node, TypeScope *scope, Str symbol) {
 }
 
 void
-typecheck_lit_field(Analyzer *a, Node *node, TypeScope *scope, Str symbol) {
+typecheck_lit_field(Analyzer *a, Node *node, Scope *scope, Str symbol) {
     if (node->field_val->kind == NODE_COMPOUND_TYPE) {
         Str type = cstr("\\{ ");
         for (sz i = 0; i < array_size(node->field_val->elements); i++) {
@@ -346,7 +351,7 @@ typecheck_lit_field(Analyzer *a, Node *node, TypeScope *scope, Str symbol) {
             return;
         }
         Str field_type = s->val.type;
-        Symbol type = type_inference(a, node->field_val, scope);
+        Str type = type_inference(a, node->field_val, scope);
         if (!str_eq(type, field_type)) {
             eprintln(
                 "%s:%d:%d: error: mismatched types in struct "
@@ -430,8 +435,8 @@ typecheck_returns(Analyzer *a, Node *node, Str expected) {
     }
 }
 
-Symbol
-type_inference(Analyzer *a, Node *node, TypeScope *scope) {
+Str
+type_inference(Analyzer *a, Node *node, Scope *scope) {
     assert(a);
     assert(scope);
     if (!node) {
@@ -460,7 +465,7 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
                     return cstr("");
                 }
                 if (node->var_val) {
-                    Symbol type = type_inference(a, node->var_val, scope);
+                    Str type = type_inference(a, node->var_val, scope);
                     if (!type.size) {
                         eprintln(
                             "%s:%d:%d: error: can't bind `nil` to variable "
@@ -490,16 +495,18 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
             }
 
             // We don't know the type for this symbol, perform inference.
-            Symbol type = type_inference(a, node->var_val, scope);
+            Str type = type_inference(a, node->var_val, scope);
             if (type.size) {
-                symmap_insert(&scope->symbols, symbol, type, a->storage);
+                symmap_insert(&scope->symbols, symbol,
+                              (Symbol){.name = type, .kind = SYM_VAR},
+                              a->storage);
                 node->var_name->type = type;
             }
             return node->type;
         } break;
         case NODE_SET: {
-            Symbol name = type_inference(a, node->var_name, scope);
-            Symbol val = type_inference(a, node->var_val, scope);
+            Str name = type_inference(a, node->var_name, scope);
+            Str val = type_inference(a, node->var_val, scope);
             if (!str_eq(name, val)) {
                 eprintln(
                     "%s:%d:%d: error: type mismatch, trying to assing "
@@ -527,7 +534,9 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
                 Node *field = node->struct_field[i];
                 typecheck_field(a, field, scope, symbol);
             }
-            symmap_insert(&scope->symbols, symbol, symbol, a->storage);
+            symmap_insert(&scope->symbols, symbol,
+                          (Symbol){.name = symbol, .kind = SYM_STRUCT},
+                          a->storage);
             return node->type;
         } break;
         case NODE_ENUM: {
@@ -556,7 +565,7 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
                              a->file_name, field->line, field->col, field_name);
                 }
                 if (field->field_val) {
-                    Symbol type = type_inference(a, field->field_val, scope);
+                    Str 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 +577,13 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
                                (Enum){.name = field_name}, a->storage);
                 field->type = cstr("int");
             }
-            symmap_insert(&scope->symbols, symbol, symbol, a->storage);
+            symmap_insert(&scope->symbols, symbol,
+                          (Symbol){.name = symbol, .kind = SYM_ENUM},
+                          a->storage);
             return node->type;
         } break;
         case NODE_IF: {
-            Symbol cond_type = type_inference(a, node->cond_if, scope);
+            Str cond_type = type_inference(a, node->cond_if, scope);
             if (!str_eq(cond_type, cstr("bool"))) {
                 emit_semantic_error(
                     a, node->cond_if,
@@ -582,15 +593,15 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
             if (node->cond_expr->kind == NODE_BLOCK) {
                 node->type = type_inference(a, node->cond_expr, scope);
             } else {
-                TypeScope *next = typescope_alloc(a, scope);
+                Scope *next = typescope_alloc(a, scope);
                 node->type = type_inference(a, node->cond_expr, next);
             }
             if (node->cond_else) {
-                Symbol else_type;
+                Str else_type;
                 if (node->cond_else->kind == NODE_BLOCK) {
                     else_type = type_inference(a, node->cond_else, scope);
                 } else {
-                    TypeScope *next = typescope_alloc(a, scope);
+                    Scope *next = typescope_alloc(a, scope);
                     else_type = type_inference(a, node->cond_else, next);
                 }
                 if (!str_eq(node->type, else_type)) {
@@ -602,7 +613,7 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
             return node->type;
         } break;
         case NODE_WHILE: {
-            Symbol cond_type = type_inference(a, node->while_cond, scope);
+            Str 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 +632,10 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
             if (node->match_expr) {
                 type_inference(a, node->match_expr, scope);
             }
-            Symbol previous = cstr("");
+            Str previous = cstr("");
             for (sz i = 0; i < array_size(node->match_cases); i++) {
                 Node *expr = node->match_cases[i];
-                Symbol next = type_inference(a, expr, scope);
+                Str next = type_inference(a, expr, scope);
                 if (i != 0 && !str_eq(next, previous)) {
                     emit_semantic_error(
                         a, node,
@@ -649,7 +660,7 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
         } break;
         case NODE_CASE_COND: {
             if (node->case_value) {
-                Symbol cond = type_inference(a, node->case_value, scope);
+                Str 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 +684,14 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
         case NODE_NOT:
         case NODE_AND:
         case NODE_OR: {
-            Symbol left = type_inference(a, node->left, scope);
+            Str 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) {
-                Symbol right = type_inference(a, node->right, scope);
+                Str 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 +707,8 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
         case NODE_GT:
         case NODE_LE:
         case NODE_GE: {
-            Symbol left = type_inference(a, node->left, scope);
-            Symbol right = type_inference(a, node->right, scope);
+            Str left = type_inference(a, node->left, scope);
+            Str 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 +718,7 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
             return node->type;
         } break;
         case NODE_BITNOT: {
-            Symbol left = type_inference(a, node->left, scope);
+            Str 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 +731,8 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
         case NODE_BITOR:
         case NODE_BITLSHIFT:
         case NODE_BITRSHIFT: {
-            Symbol left = type_inference(a, node->left, scope);
-            Symbol right = type_inference(a, node->right, scope);
+            Str left = type_inference(a, node->left, scope);
+            Str 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 +747,8 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
         case NODE_DIV:
         case NODE_MUL:
         case NODE_MOD: {
-            Symbol left = type_inference(a, node->left, scope);
-            Symbol right = type_inference(a, node->right, scope);
+            Str left = type_inference(a, node->left, scope);
+            Str right = type_inference(a, node->right, scope);
             if (!strset_lookup(&a->numeric_types, left) ||
                 !strset_lookup(&a->numeric_types, right)) {
                 emit_semantic_error(
@@ -774,7 +785,7 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
                 emit_semantic_error(a, node, cstr("unknown type"));
                 return cstr("");
             }
-            node->type = type->val;
+            node->type = type->val.name;
             return node->type;
         } break;
         case NODE_SYMBOL_IDX:
@@ -787,8 +798,8 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
                 return cstr("");
             }
 
-            FindEnumResult e = find_enum(scope, type->val);
-            if (e.map && str_eq(symbol, type->val)) {
+            FindEnumResult e = find_enum(scope, type->val.name);
+            if (e.map && str_eq(symbol, type->val.name)) {
                 if (!node->next) {
                     eprintln(
                         "%s:%d:%d: error: unspecified enum field for symbol "
@@ -797,7 +808,7 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
                     return cstr("");
                 }
                 // Check if there is a next and it matches the enum field.
-                Str field = str_concat(type->val, cstr("."), a->storage);
+                Str field = str_concat(type->val.name, cstr("."), a->storage);
                 field = str_concat(field, node->next->value.str, a->storage);
                 if (!enummap_lookup(&e.scope->enums, field)) {
                     eprintln(
@@ -808,13 +819,13 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
                     return cstr("");
                 }
                 node->next->type = cstr("int");
-                node->type = type->val;
+                node->type = type->val.name;
                 return node->next->type;
             }
 
-            FindStructResult s = find_struct(scope, type->val);
+            FindStructResult s = find_struct(scope, type->val.name);
             if (s.map) {
-                if (str_eq(symbol, type->val)) {
+                if (str_eq(symbol, type->val.name)) {
                     eprintln(
                         "%s:%d:%d: error: struct incomplete struct literal "
                         "'%s', did you mean to use %s:{}?",
@@ -823,7 +834,7 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
                     return cstr("");
                 } else {
                     if (node->next) {
-                        Str chain = type->val;
+                        Str chain = type->val.name;
                         Node *next = node;
                         while (next->next) {
                             next = next->next;
@@ -844,7 +855,7 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
                     }
                 }
             }
-            node->type = type->val;
+            node->type = type->val.name;
             return node->type;
         } break;
         case NODE_STRUCT_LIT: {
@@ -887,10 +898,10 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
                 return cstr("");
             }
             // Check that actual parameters typecheck
-            Symbol args = cstr("");
+            Str args = cstr("");
             for (sz i = 0; i < array_size(node->elements); i++) {
                 Node *expr = node->elements[i];
-                Symbol type = type_inference(a, expr, scope);
+                Str 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 +923,7 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
         } break;
         case NODE_BLOCK: {
             scope = typescope_alloc(a, scope);
-            Symbol type;
+            Str type;
             for (sz i = 0; i < array_size(node->elements); i++) {
                 Node *expr = node->elements[i];
                 type = type_inference(a, expr, scope);
@@ -921,10 +932,10 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
             return node->type;
         } break;
         case NODE_RETURN: {
-            Symbol ret_type = cstr("");
+            Str ret_type = cstr("");
             for (sz i = 0; i < array_size(node->elements); i++) {
                 Node *expr = node->elements[i];
-                Symbol type = type_inference(a, expr, scope);
+                Str 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);
@@ -938,17 +949,19 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
         } break;
         case NODE_FUN: {
             node->type = cstr("nil");
-            TypeScope *prev_scope = scope;
+            Scope *prev_scope = scope;
             scope = typescope_alloc(a, scope);
-            Symbol param_type = cstr("");
+            Str 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;
-                Symbol type = param->param_type->value.str;
+                Str type = param->param_type->value.str;
                 param->param_name->type =
                     type_inference(a, param->param_type, scope);
                 param->type = param->param_name->type;
-                symmap_insert(&scope->symbols, symbol, type, a->storage);
+                symmap_insert(&scope->symbols, symbol,
+                              (Symbol){.name = type, .kind = SYM_PARAM},
+                              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 +972,10 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
             }
             node->fun_params = param_type;
 
-            Symbol ret_type = cstr("");
+            Str ret_type = cstr("");
             for (sz i = 0; i < array_size(node->func_ret); i++) {
                 Node *expr = node->func_ret[i];
-                Symbol type = type_inference(a, expr, scope);
+                Str 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);
@@ -984,7 +997,9 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
                         symbol);
                     return cstr("");
                 }
-                symmap_insert(&prev_scope->symbols, symbol, symbol, a->storage);
+                symmap_insert(&scope->symbols, symbol,
+                              (Symbol){.name = symbol, .kind = SYM_FUN},
+                              a->storage);
             }
             scope->name = symbol;
             funmap_insert(&prev_scope->funcs, symbol,
@@ -994,7 +1009,7 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
                           a->storage);
 
             if (node->func_body->kind == NODE_BLOCK) {
-                Symbol type;
+                Str 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);
@@ -1032,7 +1047,7 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
 
 void
 symbolic_analysis(Analyzer *a, Parser *parser) {
-    TypeScope *types = typescope_alloc(a, NULL);
+    Scope *scope = typescope_alloc(a, NULL);
     assert(a);
     assert(parser);
 
@@ -1043,38 +1058,42 @@ symbolic_analysis(Analyzer *a, Parser *parser) {
     };
     for (sz i = 0; i < LEN(builtin_functions); i++) {
         Str symbol = builtin_functions[i];
-        symmap_insert(&types->symbols, symbol, symbol, a->storage);
-        funmap_insert(&types->funcs, symbol,
+        symmap_insert(&scope->symbols, symbol,
+                      (Symbol){.name = symbol, .kind = SYM_BUILTIN_FUN},
+                      a->storage);
+        funmap_insert(&scope->funcs, symbol,
                       (Fun){.name = symbol,
                             .param_type = cstr("..."),
                             .return_type = cstr("nil")},
                       a->storage);
     }
-    Symbol builtin_types[] = {
+    Str 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++) {
-        Symbol type = builtin_types[i];
-        symmap_insert(&types->symbols, type, type, a->storage);
+        Str type = builtin_types[i];
+        symmap_insert(&scope->symbols, type,
+                      (Symbol){.name = type, .kind = SYM_BUILTIN_TYPE},
+                      a->storage);
     }
-    Symbol numeric_types[] = {
+    Str 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++) {
-        Symbol type = numeric_types[i];
+        Str type = numeric_types[i];
         strset_insert(&a->numeric_types, type, a->storage);
     }
-    Symbol integer_types[] = {
+    Str 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++) {
-        Symbol type = integer_types[i];
+        Str type = integer_types[i];
         strset_insert(&a->integer_types, type, a->storage);
     }
     // Find top level function declarations.
@@ -1082,7 +1101,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 (symmap_lookup(&types->symbols, symbol)) {
+            if (symmap_lookup(&scope->symbols, symbol)) {
                 eprintln(
                     "%s:%d:%d: error: function '%s' already defined in "
                     "current "
@@ -1090,13 +1109,15 @@ symbolic_analysis(Analyzer *a, Parser *parser) {
                     a->file_name, root->var_name->line, root->var_name->col,
                     symbol);
             }
-            symmap_insert(&types->symbols, symbol, symbol, a->storage);
+            symmap_insert(&scope->symbols, symbol,
+                          (Symbol){.name = symbol, .kind = SYM_FUN},
+                          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);
+        type_inference(a, root, scope);
     }
 }
 
@@ -1174,7 +1195,7 @@ process_file(Str path) {
     // Printing symbol tables.
     if (mode == PRINT_SYMTABLES) {
         // graph_symbols(analyzer.scopes, lexer_arena);
-        graph_types(analyzer.types, lexer_arena);
+        graph_types(analyzer.scopes, lexer_arena);
     }
     if (mode == PRINT_SEMANTIC) {
         graph_ast(parser.nodes);
@@ -1183,9 +1204,9 @@ process_file(Str path) {
 
 #if DEBUG == 1
     println("========== enums ==========");
-    for (sz i = 0; i < array_size(analyzer.types); i++) {
+    for (sz i = 0; i < array_size(analyzer.scopes); i++) {
         Arena scratch = lexer_arena;
-        TypeScope *scope = analyzer.types[i];
+        Scope *scope = analyzer.scopes[i];
         EnumMapIter iter = enummap_iterator(scope->enums, &scratch);
         EnumMap *m = enummap_next(&iter, &scratch);
         while (m) {
@@ -1195,9 +1216,9 @@ process_file(Str path) {
         }
     }
     println("========= structs =========");
-    for (sz i = 0; i < array_size(analyzer.types); i++) {
+    for (sz i = 0; i < array_size(analyzer.scopes); i++) {
         Arena scratch = lexer_arena;
-        TypeScope *scope = analyzer.types[i];
+        Scope *scope = analyzer.scopes[i];
         StructMapIter iter = structmap_iterator(scope->structs, &scratch);
         StructMap *m = structmap_next(&iter, &scratch);
         while (m) {
@@ -1207,9 +1228,9 @@ process_file(Str path) {
         }
     }
     println("======== functions ========");
-    for (sz i = 0; i < array_size(analyzer.types); i++) {
+    for (sz i = 0; i < array_size(analyzer.scopes); i++) {
         Arena scratch = lexer_arena;
-        TypeScope *scope = analyzer.types[i];
+        Scope *scope = analyzer.scopes[i];
         FunMapIter iter = funmap_iterator(scope->funcs, &scratch);
         FunMap *m = funmap_next(&iter, &scratch);
         while (m) {
@@ -1218,15 +1239,15 @@ process_file(Str path) {
             m = funmap_next(&iter, &scratch);
         }
     }
-    println("========== types ==========");
-    for (sz i = 0; i < array_size(analyzer.types); i++) {
+    println("========= symbols =========");
+    for (sz i = 0; i < array_size(analyzer.scopes); i++) {
         Arena scratch = lexer_arena;
-        TypeScope *scope = analyzer.types[i];
-        SymbolMapIter iter = symmap_iterator(scope->types, &scratch);
+        Scope *scope = analyzer.scopes[i];
+        SymbolMapIter iter = symmap_iterator(scope->symbols, &scratch);
         SymbolMap *m = symmap_next(&iter, &scratch);
         while (m) {
-            println("scope: %x{2} -- %s: type: %s: %s", scope->id, path, m->key,
-                    m->val);
+            println("scope: %x{2} -- %s: %s %s: %s", scope->id, path,
+                    sym_kind_str[m->val.kind], m->key, m->val.name);
             m = symmap_next(&iter, &scratch);
         }
     }