1 files changed, 383 insertions, 155 deletions

diff --git a/src/semantic.c b/src/semantic.c
index 1b40723..7c44671 100644
--- a/src/semantic.c
+++ b/src/semantic.c
@@ -82,6 +82,9 @@ Scope *
 typescope_alloc(Analyzer *a, Scope *parent) {
     Scope *scope = arena_calloc(sizeof(Scope), a->storage);
     scope->parent = parent;
+    if (parent != NULL) {
+        scope->name = parent->name;
+    }
     scope->id = a->typescope_gen++;
     scope->depth = parent == NULL ? 0 : parent->depth + 1;
     array_push(a->scopes, scope, a->storage);
@@ -146,6 +149,23 @@ find_struct(Scope *scope, Str type) {
     return (FindStructResult){0};
 }
 
+typedef struct FindSymbolResult {
+    SymbolMap *map;
+    Scope *scope;
+} FindSymbolResult;
+
+FindSymbolResult
+find_symbol(Scope *scope, Str type) {
+    while (scope != NULL) {
+        SymbolMap *val = symmap_lookup(&scope->symbols, type);
+        if (val != NULL) {
+            return (FindSymbolResult){.map = val, .scope = scope};
+        }
+        scope = scope->parent;
+    }
+    return (FindSymbolResult){0};
+}
+
 void
 graph_typescope(Scope *scope, Arena a) {
     if (!scope->symbols) {
@@ -259,7 +279,7 @@ Str type_inference(Analyzer *a, Node *node, Scope *scope);
 
 void
 typecheck_field(Analyzer *a, Node *node, Scope *scope, Str symbol) {
-    if (node->field_type->kind == NODE_COMPOUND_TYPE) {
+    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);
         if (structmap_lookup(&scope->structs, field_name)) {
@@ -268,8 +288,8 @@ typecheck_field(Analyzer *a, Node *node, Scope *scope, Str symbol) {
             a->err = true;
         }
         Str type = cstr("\\{ ");
-        for (sz i = 0; i < array_size(node->field_type->elements); i++) {
-            Node *field = node->field_type->elements[i];
+        for (sz i = 0; i < array_size(node->field.type->elements); i++) {
+            Node *field = node->field.type->elements[i];
             typecheck_field(a, field, scope, field_name);
             type = str_concat(type, field->type, a->storage);
             type = str_concat(type, cstr(" "), a->storage);
@@ -279,16 +299,16 @@ typecheck_field(Analyzer *a, Node *node, Scope *scope, Str symbol) {
     } else {
         Str field_name = str_concat(symbol, cstr("."), a->storage);
         field_name = str_concat(field_name, node->value.str, a->storage);
-        Str field_type = node->field_type->value.str;
+        Str field_type = node->field.type->value.str;
         if (!find_type(scope, field_type)) {
             eprintln("%s:%d:%d: error: unknown type '%s'", a->file_name,
-                     node->field_type->line, node->field_type->col, field_type);
+                     node->field.type->line, node->field.type->col, field_type);
             a->err = true;
         }
-        if (node->field_type->is_ptr) {
+        if (node->field.type->is_ptr) {
             field_type = str_concat(cstr("@"), field_type, a->storage);
         }
-        if (node->field_type->kind == NODE_ARR_TYPE) {
+        if (node->field.type->kind == NODE_ARR_TYPE) {
             field_type = str_concat(cstr("@"), field_type, a->storage);
         }
         if (structmap_lookup(&scope->structs, field_name)) {
@@ -296,8 +316,8 @@ typecheck_field(Analyzer *a, Node *node, Scope *scope, Str symbol) {
                      a->file_name, node->line, node->col, field_name);
             a->err = true;
         }
-        if (node->field_val) {
-            Str type = type_inference(a, node->field_val, scope);
+        if (node->field.val) {
+            Str type = type_inference(a, node->field.val, scope);
             if (!str_eq(type, field_type)) {
                 eprintln(
                     "%s:%d:%d: error: mismatched types in struct "
@@ -312,7 +332,7 @@ typecheck_field(Analyzer *a, Node *node, Scope *scope, Str symbol) {
                          (Struct){
                              .name = field_name,
                              .type = field_type,
-                             .val = node->field_val,
+                             .val = node->field.val,
                          },
                          a->storage);
         symmap_insert(&scope->symbols, field_name,
@@ -324,10 +344,10 @@ typecheck_field(Analyzer *a, Node *node, Scope *scope, Str symbol) {
 
 void
 typecheck_lit_field(Analyzer *a, Node *node, Scope *scope, Str symbol) {
-    if (node->field_val->kind == NODE_COMPOUND_TYPE) {
+    if (node->field.val->kind == NODE_COMPOUND_TYPE) {
         Str type = cstr("\\{ ");
-        for (sz i = 0; i < array_size(node->field_val->elements); i++) {
-            Node *field = node->field_val->elements[i];
+        for (sz i = 0; i < array_size(node->field.val->elements); i++) {
+            Node *field = node->field.val->elements[i];
             Str field_name = str_concat(symbol, cstr("."), a->storage);
             field_name = str_concat(field_name, field->value.str, a->storage);
             typecheck_lit_field(a, field, scope, field_name);
@@ -345,7 +365,7 @@ typecheck_lit_field(Analyzer *a, Node *node, Scope *scope, Str symbol) {
             return;
         }
         Str field_type = s->val.type;
-        Str 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 "
@@ -367,17 +387,18 @@ typecheck_returns(Analyzer *a, Node *node, Str expected) {
     switch (node->kind) {
         case NODE_COND:
         case NODE_MATCH: {
-            for (sz i = 0; i < array_size(node->match_cases); i++) {
-                Node *next = node->match_cases[i];
+            for (sz i = 0; i < array_size(node->match.cases); i++) {
+                Node *next = node->match.cases[i];
                 typecheck_returns(a, next, expected);
             }
         } break;
         case NODE_RETURN: {
-            bool err = !str_eq(node->type, expected);
+            Str type = str_remove_prefix(node->type, cstr("ret:"));
+            bool err = !str_eq(type, expected);
             if (err) {
                 eprintln(
                     "%s:%d:%d: error: mismatched return type %s, expected %s",
-                    a->file_name, node->line, node->col, node->type, expected);
+                    a->file_name, node->line, node->col, type, expected);
                 a->err = true;
             }
         } break;
@@ -388,17 +409,17 @@ typecheck_returns(Analyzer *a, Node *node, Str expected) {
             }
         } break;
         case NODE_IF: {
-            if (node->cond_expr) {
-                typecheck_returns(a, node->cond_expr, expected);
+            if (node->ifelse.expr_true) {
+                typecheck_returns(a, node->ifelse.expr_true, expected);
             }
-            if (node->cond_else) {
-                typecheck_returns(a, node->cond_else, expected);
+            if (node->ifelse.expr_else) {
+                typecheck_returns(a, node->ifelse.expr_else, expected);
             }
         } break;
         case NODE_SET:
         case NODE_LET: {
-            if (node->var_val) {
-                typecheck_returns(a, node->var_val, expected);
+            if (node->var.val) {
+                typecheck_returns(a, node->var.val, expected);
             }
         } break;
         case NODE_ADD:
@@ -418,13 +439,14 @@ typecheck_returns(Analyzer *a, Node *node, Str expected) {
         case NODE_BITNOT:
         case NODE_BITAND:
         case NODE_BITOR:
+        case NODE_BITXOR:
         case NODE_BITLSHIFT:
         case NODE_BITRSHIFT: {
-            if (node->left) {
-                typecheck_returns(a, node->left, expected);
+            if (node->binary.left) {
+                typecheck_returns(a, node->binary.left, expected);
             }
-            if (node->right) {
-                typecheck_returns(a, node->right, expected);
+            if (node->binary.right) {
+                typecheck_returns(a, node->binary.right, expected);
             }
         } break;
         default: break;
@@ -435,66 +457,79 @@ Str
 type_inference(Analyzer *a, Node *node, Scope *scope) {
     assert(a);
     assert(scope);
-    if (!node) {
+    if (!node || a->err) {
         return cstr("");
     }
     // NOTE: For now we are not going to do implicit numeric conversions.
     switch (node->kind) {
         case NODE_LET: {
             node->type = cstr("nil");
-            Str symbol = node->var_name->value.str;
+            node->var.name->parent = node;
+            Str symbol = node->var.name->value.str;
             if (symmap_lookup(&scope->symbols, symbol)) {
                 eprintln(
                     "%s:%d:%d: error: symbol '%s' already exists in current "
                     "scope ",
-                    a->file_name, node->var_name->line, node->var_name->col,
+                    a->file_name, node->var.name->line, node->var.name->col,
                     symbol);
                 a->err = true;
                 return cstr("");
             }
-            if (node->var_type) {
-                Str type_name = node->var_type->value.str;
+            if (node->var.type) {
+                node->var.type->parent = node;
+                Str type_name = node->var.type->value.str;
                 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,
+                             node->var.type->line, node->var.type->col,
                              type_name);
                     a->err = true;
                     return cstr("");
                 }
-                if (node->var_type->is_ptr) {
+                if (node->var.type->is_ptr) {
                     type_name = str_concat(cstr("@"), type_name, a->storage);
                 }
-                if (node->var_type->kind == NODE_ARR_TYPE) {
+                if (node->var.type->kind == NODE_ARR_TYPE) {
                     type_name = str_concat(cstr("@"), type_name, a->storage);
-                    // TODO: typecheck size
+                    if (node->var.type->sym.arr_size->value.i == 0) {
+                        eprintln("%s:%d:%d: error: zero sized array '%s'",
+                                 a->file_name, node->var.type->line,
+                                 node->var.type->col, symbol);
+                        a->err = true;
+                        return cstr("");
+                    }
                     // TODO: register array in scope
                 }
-                if (node->var_val) {
-                    Str type = type_inference(a, node->var_val, scope);
+                if (node->var.val) {
+                    node->var.val->parent = node;
+                    Str type = type_inference(a, node->var.val, scope);
                     if (!type.size) {
                         eprintln(
                             "%s:%d:%d: error: can't bind `nil` to variable "
                             "'%s'",
-                            a->file_name, node->var_type->line,
-                            node->var_type->col, symbol);
+                            a->file_name, node->var.type->line,
+                            node->var.type->col, symbol);
                         a->err = true;
                         return cstr("");
                     }
-                    // TODO: Consider compatible types.
                     if (!str_eq(type, type_name)) {
-                        // Special case, enums can be treated as ints.
-                        FindEnumResult res = find_enum(scope, type_name);
-                        if (!(res.map && str_eq(type, cstr("int")))) {
-                            eprintln(
-                                "%s:%d:%d: error: type mismatch, trying to "
-                                "assing "
-                                "%s"
-                                " to a variable of type %s",
-                                a->file_name, node->var_type->line,
-                                node->var_type->col, type, type_name);
-                            a->err = true;
-                            return cstr("");
+                        if (!(strset_lookup(&a->integer_types, type) &&
+                              strset_lookup(&a->integer_types, type_name)) &&
+                            !(strset_lookup(&a->numeric_types, type) &&
+                              strset_lookup(&a->numeric_types, type_name))) {
+                            // Special case, enums can be treated as ints.
+                            FindEnumResult res = find_enum(scope, type_name);
+                            if (!(res.map && str_eq(type, cstr("int")))) {
+                                eprintln(
+                                    "%s:%d:%d: error: type mismatch, trying to "
+                                    "assing "
+                                    "%s"
+                                    " to a variable of type %s",
+                                    a->file_name, node->var.type->line,
+                                    node->var.type->col, type, type_name);
+                                a->err = true;
+                                return cstr("");
+                            }
                         }
                     }
                 }
@@ -504,17 +539,29 @@ type_inference(Analyzer *a, Node *node, Scope *scope) {
                                   .kind = SYM_VAR,
                               },
                               a->storage);
+                node->var.name->type = type_name;
+                symbol = str_concat(cstr("."), symbol, a->storage);
+                symbol = str_concat(symbol, str_from_int(scope->id, a->storage),
+                                    a->storage);
+                node->unique_name = symbol;
                 return node->type;
             }
 
             // We don't know the type for this symbol, perform inference.
-            Str type = type_inference(a, node->var_val, scope);
-            if (type.size) {
-                symmap_insert(&scope->symbols, symbol,
-                              (Symbol){.name = type, .kind = SYM_VAR},
-                              a->storage);
-                node->var_name->type = type;
+            node->var.val->parent = node;
+            Str type = type_inference(a, node->var.val, scope);
+            if (!type.size || str_eq(type, cstr("nil")) ||
+                str_has_prefix(type, cstr("ret:"))) {
+                eprintln(
+                    "%s:%d:%d: error: can't bind `nil` to variable "
+                    "'%s'",
+                    a->file_name, node->line, node->col, symbol);
+                a->err = true;
+                return cstr("");
             }
+            symmap_insert(&scope->symbols, symbol,
+                          (Symbol){.name = type, .kind = SYM_VAR}, a->storage);
+            node->var.name->type = type;
             symbol = str_concat(cstr("."), symbol, a->storage);
             symbol = str_concat(symbol, str_from_int(scope->id, a->storage),
                                 a->storage);
@@ -522,8 +569,10 @@ type_inference(Analyzer *a, Node *node, Scope *scope) {
             return node->type;
         } break;
         case NODE_SET: {
-            Str name = type_inference(a, node->var_name, scope);
-            Str val = type_inference(a, node->var_val, scope);
+            node->var.name->parent = node;
+            node->var.val->parent = node;
+            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 "
@@ -533,6 +582,12 @@ type_inference(Analyzer *a, Node *node, Scope *scope) {
                 a->err = true;
                 return cstr("");
             }
+            Str symbol = node->var.name->value.str;
+            FindSymbolResult sym = find_symbol(scope, symbol);
+            node->unique_name = str_concat(cstr("."), symbol, a->storage);
+            node->unique_name =
+                str_concat(node->unique_name,
+                           str_from_int(sym.scope->id, a->storage), a->storage);
             node->type = cstr("nil");
             return node->type;
         } break;
@@ -551,6 +606,7 @@ type_inference(Analyzer *a, Node *node, Scope *scope) {
                              a->storage);
             for (sz i = 0; i < array_size(node->struct_field); i++) {
                 Node *field = node->struct_field[i];
+                field->parent = node;
                 typecheck_field(a, field, scope, symbol);
             }
             symmap_insert(&scope->symbols, symbol,
@@ -572,11 +628,12 @@ type_inference(Analyzer *a, Node *node, Scope *scope) {
             enummap_insert(&scope->enums, symbol,
                            (Enum){
                                .name = symbol,
-                               .val = node->field_val,
+                               .val = node->field.val,
                            },
                            a->storage);
             for (sz i = 0; i < array_size(node->struct_field); i++) {
                 Node *field = node->struct_field[i];
+                field->parent = node;
                 Str field_name = str_concat(symbol, cstr("."), a->storage);
                 field_name =
                     str_concat(field_name, field->value.str, a->storage);
@@ -585,8 +642,8 @@ type_inference(Analyzer *a, Node *node, Scope *scope) {
                              a->file_name, field->line, field->col, field_name);
                     a->err = true;
                 }
-                if (field->field_val) {
-                    Str type = type_inference(a, field->field_val, scope);
+                if (field->field.val) {
+                    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'",
@@ -609,26 +666,34 @@ type_inference(Analyzer *a, Node *node, Scope *scope) {
             return node->type;
         } break;
         case NODE_IF: {
-            Str cond_type = type_inference(a, node->cond_if, scope);
+            node->ifelse.cond->parent = node;
+            node->ifelse.expr_true->parent = node;
+            Str cond_type = type_inference(a, node->ifelse.cond, scope);
             if (!str_eq(cond_type, cstr("bool"))) {
                 emit_semantic_error(
-                    a, node->cond_if,
+                    a, node->ifelse.cond,
                     cstr("non boolean expression on if condition"));
                 return cstr("");
             }
-            if (node->cond_expr->kind == NODE_BLOCK) {
-                node->type = type_inference(a, node->cond_expr, scope);
+            if (node->ifelse.expr_true->kind == NODE_BLOCK) {
+                node->type = type_inference(a, node->ifelse.expr_true, scope);
             } else {
                 Scope *next = typescope_alloc(a, scope);
-                node->type = type_inference(a, node->cond_expr, next);
+                node->type = type_inference(a, node->ifelse.expr_true, next);
             }
-            if (node->cond_else) {
+            if (str_has_prefix(node->type, cstr("ret:")) ||
+                str_has_prefix(node->type, cstr("flow:"))) {
+                node->type = cstr("nil");
+            }
+            if (node->ifelse.expr_else) {
+                node->ifelse.expr_else->parent = node;
                 Str else_type;
-                if (node->cond_else->kind == NODE_BLOCK) {
-                    else_type = type_inference(a, node->cond_else, scope);
+                if (node->ifelse.expr_else->kind == NODE_BLOCK) {
+                    else_type =
+                        type_inference(a, node->ifelse.expr_else, scope);
                 } else {
                     Scope *next = typescope_alloc(a, scope);
-                    else_type = type_inference(a, node->cond_else, next);
+                    else_type = type_inference(a, node->ifelse.expr_else, next);
                 }
                 if (!str_eq(node->type, else_type)) {
                     emit_semantic_error(
@@ -636,27 +701,41 @@ type_inference(Analyzer *a, Node *node, Scope *scope) {
                     return cstr("");
                 }
             }
+
+            // If it returns a value, verify it contains an `else` statement.
+            if (!str_eq(node->type, cstr("nil"))) {
+                if (!node->ifelse.expr_else) {
+                    emit_semantic_error(
+                        a, node,
+                        cstr("missing else statement in if expression"));
+                    return cstr("");
+                }
+            }
             return node->type;
         } break;
         case NODE_WHILE: {
-            Str cond_type = type_inference(a, node->while_cond, scope);
+            node->loop.cond->parent = node;
+            node->loop.expr->parent = node;
+            Str cond_type = type_inference(a, node->loop.cond, scope);
             if (!str_eq(cond_type, cstr("bool"))) {
                 emit_semantic_error(
-                    a, node->cond_if,
+                    a, node->loop.cond,
                     cstr("non boolean expression on while condition"));
                 return cstr("");
             }
-            if (node->while_expr->kind != NODE_BLOCK) {
+            if (node->loop.expr->kind != NODE_BLOCK) {
                 scope = typescope_alloc(a, scope);
             }
-            type_inference(a, node->while_expr, scope);
+            type_inference(a, node->loop.expr, scope);
             node->type = cstr("nil");
             return node->type;
         } break;
         case NODE_COND: {
             Str previous = cstr("");
-            for (sz i = 0; i < array_size(node->match_cases); i++) {
-                Node *expr = node->match_cases[i];
+            bool has_else = false;
+            for (sz i = 0; i < array_size(node->match.cases); i++) {
+                Node *expr = node->match.cases[i];
+                expr->parent = node;
                 Str next = type_inference(a, expr, scope);
                 if (i != 0 && !str_eq(next, previous)) {
                     emit_semantic_error(
@@ -664,22 +743,38 @@ type_inference(Analyzer *a, Node *node, Scope *scope) {
                         cstr("non-matching types for cond expressions"));
                     return cstr("");
                 }
+                if (!expr->case_entry.cond) {
+                    has_else = true;
+                }
                 previous = next;
             }
+            // If it returns a value, verify it contains an `else` statement.
+            if (!str_eq(node->type, cstr("nil")) &&
+                !str_has_prefix(node->type, cstr("ret:")) &&
+                !str_has_prefix(node->type, cstr("flow:"))) {
+                if (!has_else) {
+                    emit_semantic_error(
+                        a, node,
+                        cstr("missing else statement in cond expression"));
+                    return cstr("");
+                }
+            }
             node->type = previous;
             return node->type;
         } break;
         case NODE_MATCH: {
-            Str e = type_inference(a, node->match_expr, scope);
+            node->match.expr->parent = node;
+            Str e = type_inference(a, node->match.expr, scope);
             if (str_eq(e, cstr("int"))) {
                 // Integer matching.
-                for (sz i = 0; i < array_size(node->match_cases); i++) {
-                    Node *field = node->match_cases[i];
-                    if (field->case_value) {
-                        if (field->case_value->kind != NODE_NUM_INT &&
-                            field->case_value->kind != NODE_NUM_UINT) {
+                for (sz i = 0; i < array_size(node->match.cases); i++) {
+                    Node *field = node->match.cases[i];
+                    field->parent = node;
+                    if (field->case_entry.cond) {
+                        if (field->case_entry.cond->kind != NODE_NUM_INT &&
+                            field->case_entry.cond->kind != NODE_NUM_UINT) {
                             emit_semantic_error(
-                                a, field->case_value,
+                                a, field->case_entry.cond,
                                 cstr(
                                     "non-integer or enum types on match case"));
                         }
@@ -690,24 +785,26 @@ type_inference(Analyzer *a, Node *node, Scope *scope) {
                 FindEnumResult res = find_enum(scope, e);
                 Str enum_prefix =
                     str_concat(res.map->val.name, cstr("."), a->storage);
-                for (sz i = 0; i < array_size(node->match_cases); i++) {
-                    Node *field = node->match_cases[i];
-                    if (field->case_value) {
+                for (sz i = 0; i < array_size(node->match.cases); i++) {
+                    Node *field = node->match.cases[i];
+                    field->parent = node;
+                    if (field->case_entry.cond) {
                         Str field_name = str_concat(
-                            enum_prefix, field->case_value->value.str,
+                            enum_prefix, field->case_entry.cond->value.str,
                             a->storage);
                         if (!enummap_lookup(&res.scope->enums, field_name)) {
                             eprintln("%s:%d:%d: error: unknown enum field '%s'",
-                                     a->file_name, field->case_value->line,
-                                     field->case_value->col, field_name);
+                                     a->file_name, field->case_entry.cond->line,
+                                     field->case_entry.cond->col, field_name);
                             a->err = true;
                         }
                     }
                 }
             }
             Str previous = cstr("");
-            for (sz i = 0; i < array_size(node->match_cases); i++) {
-                Node *expr = node->match_cases[i];
+            for (sz i = 0; i < array_size(node->match.cases); i++) {
+                Node *expr = node->match.cases[i];
+                expr->parent = node;
                 Str next = type_inference(a, expr, scope);
                 if (i != 0 && !str_eq(next, previous)) {
                     emit_semantic_error(
@@ -721,24 +818,27 @@ type_inference(Analyzer *a, Node *node, Scope *scope) {
             return node->type;
         } break;
         case NODE_CASE_MATCH: {
-            if (node->case_expr->kind != NODE_BLOCK) {
+            if (node->case_entry.expr->kind != NODE_BLOCK) {
                 scope = typescope_alloc(a, scope);
             }
-            node->type = type_inference(a, node->case_expr, scope);
+            node->case_entry.expr->parent = node;
+            node->type = type_inference(a, node->case_entry.expr, scope);
             return node->type;
         } break;
         case NODE_CASE_COND: {
-            if (node->case_value) {
-                Str cond = type_inference(a, node->case_value, scope);
+            node->case_entry.expr->parent = node;
+            if (node->case_entry.cond) {
+                node->case_entry.cond->parent = node;
+                Str cond = type_inference(a, node->case_entry.cond, scope);
                 if (!str_eq(cond, cstr("bool"))) {
                     emit_semantic_error(a, node,
                                         cstr("non-boolean case condition"));
                 }
             }
-            if (node->case_expr->kind != NODE_BLOCK) {
+            if (node->case_entry.expr->kind != NODE_BLOCK) {
                 scope = typescope_alloc(a, scope);
             }
-            node->type = type_inference(a, node->case_expr, scope);
+            node->type = type_inference(a, node->case_entry.expr, scope);
             return node->type;
         } break;
         case NODE_TRUE:
@@ -753,14 +853,16 @@ type_inference(Analyzer *a, Node *node, Scope *scope) {
         case NODE_NOT:
         case NODE_AND:
         case NODE_OR: {
-            Str left = type_inference(a, node->left, scope);
+            node->binary.left->parent = node;
+            Str left = type_inference(a, node->binary.left, scope);
             if (!str_eq(left, cstr("bool"))) {
                 emit_semantic_error(a, node,
                                     cstr("expected bool on logic expression"));
                 return cstr("");
             }
-            if (node->right) {
-                Str right = type_inference(a, node->right, scope);
+            if (node->binary.right) {
+                node->binary.right->parent = node;
+                Str right = type_inference(a, node->binary.right, scope);
                 if (!str_eq(right, cstr("bool"))) {
                     emit_semantic_error(
                         a, node, cstr("expected bool on logic expression"));
@@ -776,8 +878,10 @@ type_inference(Analyzer *a, Node *node, Scope *scope) {
         case NODE_GT:
         case NODE_LE:
         case NODE_GE: {
-            Str left = type_inference(a, node->left, scope);
-            Str right = type_inference(a, node->right, scope);
+            node->binary.left->parent = node;
+            node->binary.right->parent = node;
+            Str left = type_inference(a, node->binary.left, scope);
+            Str right = type_inference(a, node->binary.right, scope);
             if (!str_eq(left, right)) {
                 emit_semantic_error(
                     a, node, cstr("mismatched types on binary expression"));
@@ -787,7 +891,8 @@ type_inference(Analyzer *a, Node *node, Scope *scope) {
             return node->type;
         } break;
         case NODE_BITNOT: {
-            Str left = type_inference(a, node->left, scope);
+            node->binary.left->parent = node;
+            Str left = type_inference(a, node->binary.left, scope);
             if (!strset_lookup(&a->integer_types, left)) {
                 emit_semantic_error(
                     a, node, cstr("non integer type on bit twiddling expr"));
@@ -798,10 +903,13 @@ type_inference(Analyzer *a, Node *node, Scope *scope) {
         } break;
         case NODE_BITAND:
         case NODE_BITOR:
+        case NODE_BITXOR:
         case NODE_BITLSHIFT:
         case NODE_BITRSHIFT: {
-            Str left = type_inference(a, node->left, scope);
-            Str right = type_inference(a, node->right, scope);
+            node->binary.left->parent = node;
+            node->binary.right->parent = node;
+            Str left = type_inference(a, node->binary.left, scope);
+            Str right = type_inference(a, node->binary.right, scope);
             if (!strset_lookup(&a->integer_types, left) ||
                 !strset_lookup(&a->integer_types, right)) {
                 emit_semantic_error(
@@ -816,8 +924,10 @@ type_inference(Analyzer *a, Node *node, Scope *scope) {
         case NODE_DIV:
         case NODE_MUL:
         case NODE_MOD: {
-            Str left = type_inference(a, node->left, scope);
-            Str right = type_inference(a, node->right, scope);
+            node->binary.left->parent = node;
+            node->binary.right->parent = node;
+            Str left = type_inference(a, node->binary.left, scope);
+            Str right = type_inference(a, node->binary.right, scope);
             if (!strset_lookup(&a->numeric_types, left) ||
                 !strset_lookup(&a->numeric_types, right)) {
                 emit_semantic_error(
@@ -833,7 +943,7 @@ type_inference(Analyzer *a, Node *node, Scope *scope) {
             return node->type;
         } break;
         case NODE_NUM_UINT: {
-            node->type = cstr("uint");
+            node->type = cstr("int");
             return node->type;
         } break;
         case NODE_NUM_INT: {
@@ -868,9 +978,24 @@ type_inference(Analyzer *a, Node *node, Scope *scope) {
                 a->err = true;
                 return cstr("");
             }
+
+            FindSymbolResult sym = find_symbol(scope, symbol);
+            if (!str_eq(sym.scope->name, scope->name) && sym.scope->name.size) {
+                eprintln(
+                    "%s:%d:%d: error: can't capture external local symbol '%s'",
+                    a->file_name, node->line, node->col, symbol);
+                a->err = true;
+                return cstr("");
+            }
+            node->unique_name = str_concat(cstr("."), symbol, a->storage);
+            node->unique_name =
+                str_concat(node->unique_name,
+                           str_from_int(sym.scope->id, a->storage), a->storage);
+
             Str type_name = type->val.name;
             if (node->kind == NODE_SYMBOL_IDX) {
-                Str idx_type = type_inference(a, node->arr_size, scope);
+                node->sym.arr_size->parent = node;
+                Str idx_type = type_inference(a, node->sym.arr_size, scope);
                 if (!strset_lookup(&a->integer_types, idx_type)) {
                     emit_semantic_error(
                         a, node, cstr("can't resolve non integer index"));
@@ -884,7 +1009,7 @@ type_inference(Analyzer *a, Node *node, Scope *scope) {
 
             FindEnumResult e = find_enum(scope, type_name);
             if (e.map && str_eq(symbol, type_name)) {
-                if (!node->next) {
+                if (!node->sym.next) {
                     eprintln(
                         "%s:%d:%d: error: unspecified enum field for symbol "
                         "'%s'",
@@ -894,19 +1019,21 @@ type_inference(Analyzer *a, Node *node, Scope *scope) {
                 }
                 // Check if there is a next and it matches the enum field.
                 Str field = str_concat(type_name, cstr("."), a->storage);
-                field = str_concat(field, node->next->value.str, a->storage);
+                field =
+                    str_concat(field, node->sym.next->value.str, a->storage);
                 if (!enummap_lookup(&e.scope->enums, field)) {
                     eprintln(
                         "%s:%d:%d: error: unknown enum field for "
                         "'%s': %s",
                         a->file_name, node->line, node->col, symbol,
-                        node->next->value.str);
+                        node->sym.next->value.str);
                     a->err = true;
                     return cstr("");
                 }
-                node->next->type = type_name;
+
+                node->sym.next->type = type_name;
                 node->type = type_name;
-                return node->next->type;
+                return node->sym.next->type;
             }
 
             FindStructResult s = find_struct(scope, type_name);
@@ -919,11 +1046,11 @@ type_inference(Analyzer *a, Node *node, Scope *scope) {
                     a->err = true;
                     return cstr("");
                 } else {
-                    if (node->next) {
+                    if (node->sym.next) {
                         Str chain = type_name;
                         Node *next = node;
-                        while (next->next) {
-                            next = next->next;
+                        while (next->sym.next) {
+                            next = next->sym.next;
                             chain = str_concat(chain, cstr("."), a->storage);
                             chain =
                                 str_concat(chain, next->value.str, a->storage);
@@ -939,8 +1066,9 @@ type_inference(Analyzer *a, Node *node, Scope *scope) {
                         }
                         Str field_type = field->val.type;
                         if (next->kind == NODE_SYMBOL_IDX) {
+                            node->sym.arr_size->parent = node;
                             Str idx_type =
-                                type_inference(a, next->arr_size, scope);
+                                type_inference(a, next->sym.arr_size, scope);
                             if (!strset_lookup(&a->integer_types, idx_type)) {
                                 emit_semantic_error(
                                     a, next,
@@ -971,6 +1099,7 @@ type_inference(Analyzer *a, Node *node, Scope *scope) {
             StrSet *set = NULL;
             for (sz i = 0; i < array_size(node->elements); i++) {
                 Node *next = node->elements[i];
+                next->parent = node;
                 Str field_name = str_concat(name, cstr("."), a->storage);
                 field_name =
                     str_concat(field_name, next->value.str, a->storage);
@@ -1000,10 +1129,17 @@ type_inference(Analyzer *a, Node *node, Scope *scope) {
                 a->err = true;
                 return cstr("");
             }
+            FindSymbolResult sym = find_symbol(scope, symbol);
+            node->unique_name = str_concat(cstr("."), symbol, a->storage);
+            node->unique_name =
+                str_concat(node->unique_name,
+                           str_from_int(sym.scope->id, a->storage), a->storage);
+
             // Check that actual parameters typecheck
             Str args = cstr("");
             for (sz i = 0; i < array_size(node->elements); i++) {
                 Node *expr = node->elements[i];
+                expr->parent = node;
                 Str type = type_inference(a, expr, scope);
                 args = str_concat(args, type, a->storage);
                 if (i != array_size(node->elements) - 1) {
@@ -1029,15 +1165,27 @@ type_inference(Analyzer *a, Node *node, Scope *scope) {
             Str type;
             for (sz i = 0; i < array_size(node->elements); i++) {
                 Node *expr = node->elements[i];
+                expr->parent = node;
                 type = type_inference(a, expr, scope);
+                if (str_has_prefix(type, cstr("ret:")) ||
+                    str_has_prefix(type, cstr("flow:"))) {
+                    break;
+                }
             }
             node->type = type;
             return node->type;
         } break;
         case NODE_RETURN: {
-            Str ret_type = cstr("");
+            if (!scope->name.size) {
+                emit_semantic_error(
+                    a, node, cstr("return statement outside a function"));
+                a->err = true;
+                return cstr("");
+            }
+            Str ret_type = cstr("ret:");
             for (sz i = 0; i < array_size(node->elements); i++) {
                 Node *expr = node->elements[i];
+                expr->parent = node;
                 Str type = type_inference(a, expr, scope);
                 ret_type = str_concat(ret_type, type, a->storage);
                 if (i != array_size(node->elements) - 1) {
@@ -1050,40 +1198,68 @@ type_inference(Analyzer *a, Node *node, Scope *scope) {
             node->type = ret_type;
             return node->type;
         } break;
+        case NODE_CONTINUE:
+        case NODE_BREAK: {
+            // Check if we are inside a loop.
+            Node *parent = node->parent;
+            bool inside_loop = false;
+            while (parent != NULL) {
+                if (parent->kind == NODE_WHILE) {
+                    inside_loop = true;
+                    break;
+                }
+                parent = parent->parent;
+            }
+            if (!inside_loop) {
+                eprintln(
+                    "%s:%d:%d: error: control flow statement outside a loop",
+                    a->file_name, node->line, node->col);
+                a->err = true;
+                return cstr("");
+            }
+            node->type = cstr("flow:");
+            return node->type;
+        } break;
         case NODE_FUN: {
             node->type = cstr("nil");
             Scope *prev_scope = scope;
             scope = typescope_alloc(a, scope);
             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;
-                Str type = param->param_type->value.str;
-                if (param->param_type->is_ptr) {
+            for (sz i = 0; i < array_size(node->func.params); i++) {
+                Node *param = node->func.params[i];
+                param->parent = node;
+                Str symbol = param->param.name->value.str;
+                Str type = param->param.type->value.str;
+                if (param->param.type->is_ptr) {
                     type = str_concat(cstr("@"), type, a->storage);
                 }
-                if (param->param_type->kind == NODE_ARR_TYPE) {
+                if (param->param.type->kind == NODE_ARR_TYPE) {
                     type = str_concat(cstr("@"), type, a->storage);
                 }
-                param->param_name->type =
-                    type_inference(a, param->param_type, scope);
+                param->param.name->type =
+                    type_inference(a, param->param.type, scope);
                 param->type = type;
                 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) {
+                if (i != array_size(node->func.params) - 1) {
                     param_type = str_concat(param_type, cstr(","), a->storage);
                 }
+                symbol = str_concat(cstr("."), symbol, a->storage);
+                symbol = str_concat(symbol, str_from_int(scope->id, a->storage),
+                                    a->storage);
+                param->unique_name = symbol;
             }
             if (!param_type.size) {
                 param_type = cstr("nil");
             }
-            node->fun_params = param_type;
+            node->type_params = param_type;
 
             Str ret_type = cstr("");
-            for (sz i = 0; i < array_size(node->func_ret); i++) {
-                Node *expr = node->func_ret[i];
+            for (sz i = 0; i < array_size(node->func.ret); i++) {
+                Node *expr = node->func.ret[i];
+                expr->parent = node;
                 Str type = type_inference(a, expr, scope);
                 if (expr->is_ptr) {
                     type = str_concat(cstr("@"), type, a->storage);
@@ -1092,28 +1268,28 @@ type_inference(Analyzer *a, Node *node, Scope *scope) {
                     type = str_concat(cstr("@"), type, a->storage);
                 }
                 ret_type = str_concat(ret_type, type, a->storage);
-                if (i != array_size(node->func_ret) - 1) {
+                if (i != array_size(node->func.ret) - 1) {
                     ret_type = str_concat(ret_type, cstr(","), a->storage);
                 }
             }
             if (!ret_type.size) {
                 ret_type = cstr("nil");
             }
-            node->fun_return = ret_type;
+            node->type_returns = ret_type;
 
-            Str symbol = node->func_name->value.str;
+            Str symbol = node->func.name->value.str;
             if (prev_scope->parent != NULL) {
                 if (symmap_lookup(&prev_scope->symbols, symbol)) {
                     eprintln(
                         "%s:%d:%d: error: function '%s' already defined in "
                         "current "
                         "scope ",
-                        a->file_name, node->var_name->line, node->var_name->col,
+                        a->file_name, node->var.name->line, node->var.name->col,
                         symbol);
                     a->err = true;
                     return cstr("");
                 }
-                symmap_insert(&scope->symbols, symbol,
+                symmap_insert(&prev_scope->symbols, symbol,
                               (Symbol){.name = symbol, .kind = SYM_FUN},
                               a->storage);
             }
@@ -1123,41 +1299,50 @@ type_inference(Analyzer *a, Node *node, Scope *scope) {
                                 .param_type = param_type,
                                 .return_type = ret_type},
                           a->storage);
+            symbol = str_concat(cstr("."), symbol, a->storage);
+            symbol = str_concat(
+                symbol, str_from_int(prev_scope->id, a->storage), a->storage);
+            node->unique_name = symbol;
 
-            if (node->func_body->kind == NODE_BLOCK) {
+            if (node->func.body->kind == NODE_BLOCK) {
                 Str type;
-                for (sz i = 0; i < array_size(node->func_body->elements); i++) {
-                    Node *expr = node->func_body->elements[i];
+                for (sz i = 0; i < array_size(node->func.body->elements); i++) {
+                    Node *expr = node->func.body->elements[i];
+                    expr->parent = node;
+                    // TODO: block early return.
                     type = type_inference(a, expr, scope);
                 }
                 if (!type.size) {
                     type = cstr("nil");
                 }
-                node->func_body->type = type;
+                node->func.body->type = type;
             } else {
-                type_inference(a, node->func_body, scope);
+                node->func.body->parent = node;
+                type_inference(a, node->func.body, scope);
             }
 
             // Ensure main body return matches the prototype.
-            if (!str_eq(node->func_body->type, ret_type)) {
+            Str type = str_remove_prefix(node->func.body->type, cstr("ret:"));
+            node->func.body->type = type;
+            if (!str_eq(type, ret_type)) {
                 eprintln(
                     "%s:%d:%d: error: mismatched return type %s, expected %s",
-                    a->file_name, node->line, node->col, node->func_body->type,
-                    ret_type);
+                    a->file_name, node->line, node->col, type, ret_type);
                 a->err = true;
             }
 
             // Ensure ALL return statements match the function prototype.
-            typecheck_returns(a, node->func_body, ret_type);
+            typecheck_returns(a, node->func.body, ret_type);
 
             // TODO: should return statements be allowed on let blocks?
             return node->type;
         } break;
         default: {
-            emit_semantic_error(a, node,
-                                cstr("type inference not implemented for this "
-                                     "kind of expression"));
-            println("KIND: %s", node_str[node->kind]);
+            eprintln(
+                "%s:%d:%d: error: type inference not implemented for node "
+                "type: %s",
+                a->file_name, node->line, node->col, node_str[node->kind]);
+            a->err = true;
         } break;
     }
     return cstr("");
@@ -1218,16 +1403,59 @@ symbolic_analysis(Analyzer *a, Parser *parser) {
     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;
+            Str symbol = root->func.name->value.str;
             if (symmap_lookup(&scope->symbols, symbol)) {
                 eprintln(
                     "%s:%d:%d: error: function '%s' already defined in "
                     "current "
                     "scope ",
-                    a->file_name, root->var_name->line, root->var_name->col,
+                    a->file_name, root->var.name->line, root->var.name->col,
                     symbol);
                 a->err = true;
             }
+            Str param_type = cstr("");
+            for (sz i = 0; i < array_size(root->func.params); i++) {
+                Node *param = root->func.params[i];
+                Str type = param->param.type->value.str;
+                if (param->param.type->is_ptr) {
+                    type = str_concat(cstr("@"), type, a->storage);
+                }
+                if (param->param.type->kind == NODE_ARR_TYPE) {
+                    type = str_concat(cstr("@"), type, a->storage);
+                }
+                param_type = str_concat(param_type, type, a->storage);
+                if (i != array_size(root->func.params) - 1) {
+                    param_type = str_concat(param_type, cstr(","), a->storage);
+                }
+            }
+            if (!param_type.size) {
+                param_type = cstr("nil");
+            }
+            root->type_params = param_type;
+
+            Str ret_type = cstr("");
+            for (sz i = 0; i < array_size(root->func.ret); i++) {
+                Node *expr = root->func.ret[i];
+                Str type = expr->value.str;
+                if (expr->is_ptr) {
+                    type = str_concat(cstr("@"), type, a->storage);
+                }
+                if (expr->kind == NODE_ARR_TYPE) {
+                    type = str_concat(cstr("@"), type, a->storage);
+                }
+                ret_type = str_concat(ret_type, type, a->storage);
+                if (i != array_size(root->func.ret) - 1) {
+                    ret_type = str_concat(ret_type, cstr(","), a->storage);
+                }
+            }
+            if (!ret_type.size) {
+                ret_type = cstr("nil");
+            }
+            funmap_insert(&scope->funcs, symbol,
+                          (Fun){.name = symbol,
+                                .param_type = param_type,
+                                .return_type = ret_type},
+                          a->storage);
             symmap_insert(&scope->symbols, symbol,
                           (Symbol){.name = symbol, .kind = SYM_FUN},
                           a->storage);