1 files changed, 463 insertions, 280 deletions

diff --git a/src/parser.c b/src/parser.c
index 90adaf3..05a00e7 100644
--- a/src/parser.c
+++ b/src/parser.c
@@ -9,6 +9,7 @@
 //
 
 typedef enum NodeKind {
+    NODE_ERR,
     // Arithmetic.
     NODE_ADD,
     NODE_SUB,
@@ -29,6 +30,7 @@ typedef enum NodeKind {
     NODE_BITNOT,
     NODE_BITAND,
     NODE_BITOR,
+    NODE_BITXOR,
     NODE_BITLSHIFT,
     NODE_BITRSHIFT,
     // Literals.
@@ -60,15 +62,18 @@ typedef enum NodeKind {
     NODE_FUNCALL,
     NODE_RETURN,
     // Helpers.
-    NODE_SYMBOL_IDX,
     NODE_TYPE,
     NODE_COMPOUND_TYPE,
-    NODE_ARR_TYPE,
     NODE_FIELD,
     NODE_BLOCK,
+    NODE_PTR,
+    NODE_DEREF,
+    NODE_ARR,
+    NODE_INDEX,
 } NodeKind;
 
 Str node_str[] = {
+    [NODE_ERR] = cstr("ERR"),
     // Arithmetic.
     [NODE_ADD] = cstr("ADD"),
     [NODE_SUB] = cstr("SUB"),
@@ -89,6 +94,7 @@ Str node_str[] = {
     [NODE_BITNOT] = cstr("BITNOT"),
     [NODE_BITAND] = cstr("BITAND"),
     [NODE_BITOR] = cstr("BITOR"),
+    [NODE_BITXOR] = cstr("BITXOR"),
     [NODE_BITLSHIFT] = cstr("BITLSHIFT"),
     [NODE_BITRSHIFT] = cstr("BITRSHIFT"),
     // Literals.
@@ -122,81 +128,137 @@ Str node_str[] = {
     // Helpers.
     [NODE_TYPE] = cstr("TYPE"),
     [NODE_COMPOUND_TYPE] = cstr("COMPOUND TYPE"),
-    [NODE_ARR_TYPE] = cstr("TYPE (ARR)"),
-    [NODE_SYMBOL_IDX] = cstr("SYMBOL[IDX]"),
     [NODE_FIELD] = cstr("FIELD"),
     [NODE_BLOCK] = cstr("BLOCK"),
+    [NODE_PTR] = cstr("@"),
+    [NODE_DEREF] = cstr("DEREF"),
+    [NODE_ARR] = cstr("ARR"),
+    [NODE_INDEX] = cstr("INDEX"),
 };
 
+typedef union NodeLit {
+    f64 d;
+    sz i;
+    u64 u;
+    Str str;
+    Str sym;
+} NodeLit;
+
+typedef struct NodeBinary {
+    struct Node *left;
+    struct Node *right;
+} NodeBinary;
+
+typedef struct NodeUnary {
+    struct Node *left;
+} NodeUnary;
+
+typedef struct NodeVariable {
+    struct Node *name;
+    struct Node *type;
+    struct Node *val;
+} NodeVariable;
+
+typedef struct NodeLoop {
+    struct Node *cond;
+    struct Node *expr;
+} NodeLoop;
+
+typedef struct NodeIf {
+    struct Node *cond;
+    struct Node *expr_true;
+    struct Node *expr_else;
+} NodeIf;
+
+typedef struct NodeField {
+    struct Node *type;
+    struct Node *val;
+} NodeField;
+
+typedef struct NodeParam {
+    struct Node *name;
+    struct Node *type;
+} NodeParam;
+
+typedef struct NodeMatch {
+    struct Node *expr;
+    struct Node **cases;
+} NodeMatch;
+
+typedef struct NodeCase {
+    struct Node *cond;
+    struct Node *expr;
+} NodeCase;
+
+typedef struct NodeFunction {
+    struct Node *name;
+    struct Node **params;
+    struct Node **ret;
+    struct Node *body;
+} NodeFunction;
+
+typedef struct NodeSymbol {
+    struct Node *next;
+} NodeSymbol;
+
+typedef struct NodeIndex {
+    struct Node *next;
+    struct Node *value;
+} NodeIndex;
+
+typedef struct NodeType {
+    struct Node *next;
+} NodeType;
+
+typedef struct NodeDeref {
+    struct Node *next;
+} NodeDeref;
+
+typedef enum {
+    NODE_ARR_STATIC,
+    NODE_ARR_DYNAMIC,
+    NODE_ARR_SLICE,
+} NodeArrKind;
+
+typedef struct NodeArr {
+    struct Node *next;
+    struct Node *size;
+    NodeArrKind kind;
+} NodeArr;
+
 typedef struct Node {
     sz id;
     sz line;
     sz col;
+    struct Node *parent;
 
     NodeKind kind;
+    NodeLit value;
     union {
-        f64 d;
-        sz i;
-        u64 u;
-        Str str;
-        Str sym;
-    } value;
-    union {
-        struct {
-            struct Node *left;
-            struct Node *right;
-        };
-        struct {
-            struct Node *next;
-            struct Node *arr_size;
-        };
-        struct {
-            struct Node *var_name;
-            struct Node *var_type;
-            struct Node *var_val;
-        };
-        struct {
-            struct Node *while_cond;
-            struct Node *while_expr;
-        };
-        struct {
-            struct Node *cond_if;
-            struct Node *cond_expr;
-            struct Node *cond_else;
-        };
-        struct {
-            struct Node *field_type;
-            struct Node *field_val;
-        };
-        struct {
-            struct Node *param_name;
-            struct Node *param_type;
-        };
-        struct {
-            struct Node *match_expr;
-            struct Node **match_cases;
-        };
-        struct {
-            struct Node *case_value;
-            struct Node *case_expr;
-        };
+        NodeBinary binary;
+        NodeUnary unary;
+        NodeVariable var;
+        NodeSymbol sym;
+        NodeLoop loop;
+        NodeIf ifelse;
+        NodeField field;
+        NodeParam param;
+        NodeMatch match;
+        NodeCase case_entry;
+        NodeFunction func;
+        NodeType t;
+        NodeIndex idx;
+        NodeDeref deref;
+        NodeArr array;
         struct Node **struct_field;
         struct Node **elements;
         struct Node **statements;
         struct Node **expressions;
         struct Node **arguments;
-        struct {
-            struct Node *func_name;
-            struct Node **func_params;
-            struct Node **func_ret;
-            struct Node *func_body;
-        };
     };
-    bool is_ptr;
-    struct Scope *scope;
     Str type;
-    Str fun_params;
-    Str fun_return;
+    Str type_params;
+    Str type_returns;
     Str unique_name;
 } Node;
 
@@ -286,6 +348,7 @@ ParseRule parse_rules[] = {
     [TOK_BITNOT] = {parse_unary, NULL, PREC_NONE},
     [TOK_BITAND] = {NULL, parse_binary, PREC_BITLOGIC},
     [TOK_BITOR] = {NULL, parse_binary, PREC_BITLOGIC},
+    [TOK_BITXOR] = {NULL, parse_binary, PREC_BITLOGIC},
     [TOK_BITLSHIFT] = {NULL, parse_binary, PREC_BITSHIFT},
     [TOK_BITRSHIFT] = {NULL, parse_binary, PREC_BITSHIFT},
 
@@ -308,6 +371,7 @@ ParseRule parse_rules[] = {
     [TOK_MATCH] = {parse_keyword, NULL, PREC_NONE},
     [TOK_COND] = {parse_keyword, NULL, PREC_NONE},
     [TOK_WHILE] = {parse_keyword, NULL, PREC_NONE},
+    [TOK_FOR] = {parse_keyword, NULL, PREC_NONE},
     [TOK_CONTINUE] = {parse_keyword, NULL, PREC_NONE},
     [TOK_BREAK] = {parse_keyword, NULL, PREC_NONE},
     [TOK_FUN] = {parse_keyword, NULL, PREC_NONE},
@@ -318,7 +382,6 @@ ParseRule parse_rules[] = {
 
 Node *
 node_alloc(Parser *parser, NodeKind kind, Token tok) {
-    if (parser->panic) return NULL;
     static sz id = 0;
     Node *node = arena_calloc((sz)sizeof(Node), parser->storage);
     node->id = id++;
@@ -388,20 +451,44 @@ parse_block(Parser *parser) {
     print_token(parser->previous);
 #endif
     Node *block = node_alloc(parser, NODE_BLOCK, parser->previous);
-    if (!block) return;
     while (!parse_match(parser, TOK_RCURLY) && !parser->panic) {
         parse_expr(parser, PREC_LOW);
         Node *next = array_pop(parser->nodes);
+        next->parent = block;
         array_push(block->statements, next, parser->storage);
     }
     array_push(parser->nodes, block, parser->storage);
 }
 
 void
+parser_sync(Parser *parser) {
+    parser->panic = false;
+    while (parser->current.kind != TOK_EOF) {
+        switch (parser->current.kind) {
+            case TOK_FUN:
+            case TOK_LET:
+            case TOK_SET:
+            case TOK_STRUCT:
+            case TOK_ENUM:
+            case TOK_FOR:
+            case TOK_IF:
+            case TOK_WHILE:
+            case TOK_BREAK:
+            case TOK_CONTINUE:
+            case TOK_COND:
+            case TOK_MATCH:
+            case TOK_CASE:
+            case TOK_RETURN: return;
+            default: break;
+        }
+        parse_advance(parser);
+    }
+}
+
+void
 parse_expr(Parser *parser, ParsePrecedence precedence) {
     parse_advance(parser);
-    // TODO: synchronize panic mode on keywords.
-    if (parser->panic) return;
+    if (parser->panic) parser_sync(parser);
     ParseFn prefix = parse_rules[parser->previous.kind].prefix;
     if (prefix == NULL) {
         parse_emit_err(parser, parser->previous, cstr("expected expression"));
@@ -436,8 +523,8 @@ parse_unary(Parser *parser) {
         case TOK_BITNOT: node = node_alloc(parser, NODE_BITNOT, prev); break;
         default: break;  // Unreachable.
     }
-    if (!node) return;
-    node->left = array_pop(parser->nodes);
+    node->unary.left = array_pop(parser->nodes);
+    node->unary.left->parent = node;
     array_push(parser->nodes, node, parser->storage);
 }
 
@@ -459,7 +546,6 @@ parse_literal(Parser *parser) {
         case TOK_NIL: node = node_alloc(parser, NODE_NIL, prev); break;
         default: return;  // Unreachable.
     }
-    if (!node) return;
     array_push(parser->nodes, node, parser->storage);
 }
 
@@ -471,21 +557,50 @@ parse_type(Parser *parser) {
     print_token(prev);
 #endif
     Node *node = node_alloc(parser, NODE_TYPE, prev);
-    if (!node) return;
-    if (parse_match(parser, TOK_AT)) {
-        node->is_ptr = true;
+    Node *child = node;
+    while (parse_match(parser, TOK_AT) || parse_match(parser, TOK_LSQUARE)) {
+        switch (parser->previous.kind) {
+            case TOK_AT: {
+                Node *ptr_node = node_alloc(parser, NODE_PTR, parser->previous);
+                ptr_node->parent = child;
+                child->t.next = ptr_node;
+                child = ptr_node;
+            } break;
+            case TOK_LSQUARE: {
+                Node *ptr_node = node_alloc(parser, NODE_ARR, parser->previous);
+                if (parse_match(parser, TOK_NUM_INT)) {
+                    // Static array.
+                    parse_number(parser);
+                    ptr_node->array.size = array_pop(parser->nodes);
+                    ptr_node->array.kind = NODE_ARR_STATIC;
+                    ptr_node->array.size->parent = ptr_node;
+                    parse_consume(parser, TOK_RSQUARE,
+                                  cstr("unmatched brackets ']' in array type"));
+                } else if (parse_match(parser, TOK_RSQUARE)) {
+                    // Slice.
+                    ptr_node->array.kind = NODE_ARR_SLICE;
+                } else {
+                    // Dynamic array.
+                    parse_consume(parser, TOK_DOT, cstr("invalid array type"));
+                    parse_consume(parser, TOK_DOT, cstr("invalid array type"));
+                    parse_consume(parser, TOK_DOT, cstr("invalid array type"));
+                    parse_consume(parser, TOK_RSQUARE,
+                                  cstr("unmatched brackets ']' in array type"));
+                    ptr_node->array.kind = NODE_ARR_DYNAMIC;
+                }
+                ptr_node->parent = child;
+                child->t.next = ptr_node;
+                child = ptr_node;
+            } break;
+            default: {
+                parse_emit_err(parser, prev, cstr("unimplemented"));
+            } break;
+        }
     }
-    parse_consume(parser, TOK_SYMBOL, cstr("no type given for struct field"));
+    // TODO: maps
+    // TODO: function pointer syntax: : (T T : R)
+    parse_consume(parser, TOK_SYMBOL, cstr("expected type name"));
     node->value.sym = parser->previous.val;
-    // Optional array value?
-    if (parse_match(parser, TOK_LSQUARE)) {
-        node->kind = NODE_ARR_TYPE,
-        parse_consume(parser, TOK_NUM_INT, cstr("no array size given"));
-        parse_number(parser);
-        node->arr_size = array_pop(parser->nodes);
-        parse_consume(parser, TOK_RSQUARE,
-                      cstr("unmatched brackets ']' in array type"));
-    }
     array_push(parser->nodes, node, parser->storage);
 }
 
@@ -497,29 +612,31 @@ parse_struct_field(Parser *parser) {
     print_token(parser->previous);
 #endif
     Node *field = node_alloc(parser, NODE_FIELD, parser->current);
-    if (!field) return;
     parse_consume(parser, TOK_SYMBOL,
                   cstr("expected symbol name on struct field"));
     field->value.sym = parser->previous.val;
     parse_consume(parser, TOK_COLON, cstr("expected type in struct field"));
     if (parse_match(parser, TOK_LCURLY)) {
         Node *type = node_alloc(parser, NODE_COMPOUND_TYPE, parser->current);
-        if (!type) return;
+        type->parent = field;
         while (!parse_match(parser, TOK_RCURLY) && !parser->panic) {
             parse_struct_field(parser);
             Node *subfield = array_pop(parser->nodes);
+            subfield->parent = type;
             array_push(type->elements, subfield, parser->storage);
         }
-        field->field_type = type;
+        field->field.type = type;
     } else {
         parse_type(parser);
-        field->field_type = array_pop(parser->nodes);
+        field->field.type = array_pop(parser->nodes);
+        field->field.type->parent = field;
     }
 
     // Optional assignment.
     if (parse_match(parser, TOK_ASSIGN)) {
         parse_expr(parser, PREC_LOW);
-        field->field_val = array_pop(parser->nodes);
+        field->field.val = array_pop(parser->nodes);
+        field->field.val->parent = field;
     }
     array_push(parser->nodes, field, parser->storage);
 }
@@ -532,7 +649,6 @@ parse_struct_lit_field(Parser *parser) {
     print_token(parser->previous);
 #endif
     Node *field = node_alloc(parser, NODE_FIELD, parser->current);
-    if (!field) return;
     parse_consume(parser, TOK_SYMBOL,
                   cstr("expected symbol name on struct field"));
     field->value.sym = parser->previous.val;
@@ -540,16 +656,18 @@ parse_struct_lit_field(Parser *parser) {
                   cstr("expected field value on struct literal"));
     if (parse_match(parser, TOK_LCURLY)) {
         Node *type = node_alloc(parser, NODE_COMPOUND_TYPE, parser->current);
-        if (!type) return;
+        type->parent = field;
         while (!parse_match(parser, TOK_RCURLY) && !parser->panic) {
             parse_struct_lit_field(parser);
             Node *subfield = array_pop(parser->nodes);
+            subfield->parent = type;
             array_push(type->elements, subfield, parser->storage);
         }
-        field->field_val = type;
+        field->field.val = type;
     } else {
         parse_expr(parser, PREC_LOW);
-        field->field_val = array_pop(parser->nodes);
+        field->field.val = array_pop(parser->nodes);
+        field->field.val->parent = field;
     }
     array_push(parser->nodes, field, parser->storage);
 }
@@ -566,12 +684,12 @@ parse_keyword(Parser *parser) {
     switch (prev.kind) {
         case TOK_LET: {
             node = node_alloc(parser, NODE_LET, prev);
-            if (!node) return;
             parse_consume(parser, TOK_SYMBOL,
                           cstr("expected symbol name on let expression"));
             parse_symbol(parser);
-            node->var_name = array_pop(parser->nodes);
-            if (node->var_name->next) {
+            node->var.name = array_pop(parser->nodes);
+            node->var.name->parent = node;
+            if (node->var.name->sym.next) {
                 parse_emit_err(parser, prev,
                                cstr("invalid symbol name in let expression"));
                 return;
@@ -580,16 +698,18 @@ parse_keyword(Parser *parser) {
             // Optional type declaration.
             if (parse_match(parser, TOK_COLON)) {
                 parse_type(parser);
-                node->var_type = array_pop(parser->nodes);
+                node->var.type = array_pop(parser->nodes);
+                node->var.type->parent = node;
             }
 
             // Optional assignment.
             if (parse_match(parser, TOK_ASSIGN)) {
                 parse_expr(parser, PREC_LOW);
-                node->var_val = array_pop(parser->nodes);
+                node->var.val = array_pop(parser->nodes);
+                node->var.val->parent = node;
             }
 
-            if (node->var_type == NULL && node->var_val == NULL) {
+            if (node->var.type == NULL && node->var.val == NULL) {
                 parse_emit_err(parser, prev,
                                cstr("variable declaration must include type or "
                                     "value information"));
@@ -597,19 +717,58 @@ parse_keyword(Parser *parser) {
         } break;
         case TOK_SET: {
             node = node_alloc(parser, NODE_SET, prev);
-            if (!node) return;
             parse_consume(parser, TOK_SYMBOL,
-                          cstr("expected symbol name on let expression"));
+                          cstr("expected symbol name on set expression"));
             parse_symbol(parser);
-            node->var_name = array_pop(parser->nodes);
-            parse_consume(parser, TOK_ASSIGN,
-                          cstr("expected assignment on set expression"));
-            parse_expr(parser, PREC_LOW);
-            node->var_val = array_pop(parser->nodes);
+            node->var.name = array_pop(parser->nodes);
+            node->var.name->parent = node;
+
+            if (parse_match(parser, TOK_ADD_ASSIGN) ||
+                parse_match(parser, TOK_ADD_ASSIGN) ||
+                parse_match(parser, TOK_SUB_ASSIGN) ||
+                parse_match(parser, TOK_MUL_ASSIGN) ||
+                parse_match(parser, TOK_DIV_ASSIGN) ||
+                parse_match(parser, TOK_MOD_ASSIGN) ||
+                parse_match(parser, TOK_BITAND_ASSIGN) ||
+                parse_match(parser, TOK_BITOR_ASSIGN) ||
+                parse_match(parser, TOK_BITXOR_ASSIGN) ||
+                parse_match(parser, TOK_BITLSHIFT_ASSIGN) ||
+                parse_match(parser, TOK_BITRSHIFT_ASSIGN)) {
+                NodeKind kind = NODE_ERR;
+                switch (parser->previous.kind) {
+                    case TOK_ADD_ASSIGN: kind = NODE_ADD; break;
+                    case TOK_SUB_ASSIGN: kind = NODE_SUB; break;
+                    case TOK_MUL_ASSIGN: kind = NODE_MUL; break;
+                    case TOK_DIV_ASSIGN: kind = NODE_DIV; break;
+                    case TOK_MOD_ASSIGN: kind = NODE_MOD; break;
+                    case TOK_BITAND_ASSIGN: kind = NODE_BITAND; break;
+                    case TOK_BITOR_ASSIGN: kind = NODE_BITOR; break;
+                    case TOK_BITXOR_ASSIGN: kind = NODE_BITXOR; break;
+                    case TOK_BITLSHIFT_ASSIGN: kind = NODE_BITLSHIFT; break;
+                    case TOK_BITRSHIFT_ASSIGN: kind = NODE_BITRSHIFT; break;
+                    default: break;
+                }
+                parse_expr(parser, PREC_LOW);
+                Node *value = array_pop(parser->nodes);
+                Node *sym = node_alloc(parser, NODE_SYMBOL, prev);
+                Node *op = node_alloc(parser, kind, prev);
+                op->binary.left = sym;
+                op->binary.right = value;
+                sym->parent = op;
+                value->parent = op;
+                node->var.val = op;
+                node->var.val->parent = node;
+                sym->value = node->var.name->value;
+                sym->kind = node->var.name->kind;
+            } else {
+                parse_consume(parser, TOK_ASSIGN,
+                              cstr("expected assignment on set expression"));
+                parse_expr(parser, PREC_LOW);
+                node->var.val = array_pop(parser->nodes);
+            }
         } break;
         case TOK_STRUCT: {
             node = node_alloc(parser, NODE_STRUCT, prev);
-            if (!node) return;
             parse_consume(parser, TOK_SYMBOL,
                           cstr("expected symbol name on struct definition"));
             // Just consume this to avoid conflicts with struct literals.
@@ -621,54 +780,53 @@ parse_keyword(Parser *parser) {
             while (!parse_match(parser, TOK_RCURLY) && !parser->panic) {
                 parse_struct_field(parser);
                 Node *field = array_pop(parser->nodes);
-
+                field->parent = node;
                 array_push(node->struct_field, field, parser->storage);
             }
         } break;
         case TOK_IF: {
             node = node_alloc(parser, NODE_IF, prev);
-            if (!node) return;
             parse_expr(parser, PREC_LOW);
-            node->cond_if = array_pop(parser->nodes);
+            node->ifelse.cond = array_pop(parser->nodes);
+            node->ifelse.cond->parent = node;
             parse_expr(parser, PREC_LOW);
-            node->cond_expr = array_pop(parser->nodes);
+            node->ifelse.expr_true = array_pop(parser->nodes);
+            node->ifelse.expr_true->parent = node;
             if (parse_match(parser, TOK_ELSE)) {
                 parse_expr(parser, PREC_LOW);
-                node->cond_else = array_pop(parser->nodes);
+                node->ifelse.expr_else = array_pop(parser->nodes);
+                node->ifelse.expr_else->parent = node;
             }
         } break;
         case TOK_MATCH: {
             node = node_alloc(parser, NODE_MATCH, prev);
-            if (!node) return;
             parse_expr(parser, PREC_LOW);
-            node->match_expr = array_pop(parser->nodes);
+            node->match.expr = array_pop(parser->nodes);
+            node->match.expr->parent = node;
             parse_consume(parser, TOK_LCURLY,
                           cstr("expected block of match cases"));
             while (!parse_match(parser, TOK_RCURLY) && !parser->panic) {
                 Node *tmp =
                     node_alloc(parser, NODE_CASE_MATCH, parser->previous);
-                if (!tmp) return;
+                tmp->parent = node;
                 // Are we on the default case.
                 if (!parse_match(parser, TOK_ELSE)) {
                     parse_consume(parser, TOK_CASE,
                                   cstr("expected case statement"));
                     parse_expr(parser, PREC_LOW);
-                    tmp->case_value = array_pop(parser->nodes);
+                    tmp->case_entry.cond = array_pop(parser->nodes);
+                    tmp->case_entry.cond->parent = tmp;
                 }
                 parse_consume(parser, TOK_ASSIGN,
                               cstr("malformed case statement"));
                 parse_expr(parser, PREC_LOW);
-                tmp->case_expr = array_pop(parser->nodes);
-                array_push(node->match_cases, tmp, parser->storage);
+                tmp->case_entry.expr = array_pop(parser->nodes);
+                tmp->case_entry.expr->parent = tmp;
+                array_push(node->match.cases, tmp, parser->storage);
             }
-            // TODO: Check that we only have literals on the match case,
-            // this could be done on the analysis step, but also here...
-            // TODO: Check that there are no multiple default or duplicated
-            // cases.
         } break;
         case TOK_ENUM: {
             node = node_alloc(parser, NODE_ENUM, prev);
-            if (!node) return;
             parse_consume(parser, TOK_SYMBOL,
                           cstr("expected symbol name on enum definition"));
             // Just consume this to avoid conflicts with struct literals.
@@ -677,13 +835,14 @@ parse_keyword(Parser *parser) {
                           cstr("expected '{' on enum definition"));
             while (!parse_match(parser, TOK_RCURLY) && !parser->panic) {
                 Node *field = node_alloc(parser, NODE_FIELD, parser->current);
-                if (!field) return;
+                field->parent = node;
                 parse_consume(parser, TOK_SYMBOL,
                               cstr("expected symbol name on enum definition"));
                 field->value.sym = parser->previous.val;
                 if (parse_match(parser, TOK_ASSIGN)) {
                     parse_expr(parser, PREC_LOW);
-                    field->field_val = array_pop(parser->nodes);
+                    field->field.val = array_pop(parser->nodes);
+                    field->field.val->parent = field;
                 }
                 array_push(node->struct_field, field, parser->storage);
             }
@@ -693,144 +852,133 @@ parse_keyword(Parser *parser) {
         } break;
         case TOK_COND: {
             node = node_alloc(parser, NODE_COND, prev);
-            if (!node) return;
             parse_consume(parser, TOK_LCURLY,
                           cstr("expected '{' on cond expression"));
             while (!parse_match(parser, TOK_RCURLY) && !parser->panic) {
                 Node *tmp =
                     node_alloc(parser, NODE_CASE_COND, parser->previous);
-                if (!tmp) return;
+                tmp->parent = node;
                 // Are we on the default case.
                 if (!parse_match(parser, TOK_ELSE)) {
                     parse_expr(parser, PREC_LOW);
-                    tmp->case_value = array_pop(parser->nodes);
+                    tmp->case_entry.cond = array_pop(parser->nodes);
+                    tmp->case_entry.cond->parent = tmp;
                 }
                 parse_consume(parser, TOK_ASSIGN,
                               cstr("malformed case statement"));
                 parse_expr(parser, PREC_LOW);
-                tmp->case_expr = array_pop(parser->nodes);
-                array_push(node->match_cases, tmp, parser->storage);
+                tmp->case_entry.expr = array_pop(parser->nodes);
+                tmp->case_entry.expr->parent = tmp;
+                array_push(node->match.cases, tmp, parser->storage);
             }
         } break;
         case TOK_BREAK: {
             node = node_alloc(parser, NODE_BREAK, prev);
-            if (!node) return;
         } break;
         case TOK_CONTINUE: {
             node = node_alloc(parser, NODE_CONTINUE, prev);
-            if (!node) return;
+        } break;
+        case TOK_FOR: {
+            node = node_alloc(parser, NODE_BLOCK, prev);
+
+            Node *node_while = node_alloc(parser, NODE_WHILE, prev);
+            node_while->parent = node;
+            Node *block = node_alloc(parser, NODE_BLOCK, prev);
+            block->parent = node_while;
+
+            parse_expr(parser, PREC_LOW);
+            Node *pre = array_pop(parser->nodes);
+            pre->parent = node;
+
+            parse_expr(parser, PREC_LOW);
+            Node *cond = array_pop(parser->nodes);
+            cond->parent = node_while;
+
+            parse_expr(parser, PREC_LOW);
+            Node *post = array_pop(parser->nodes);
+            post->parent = block;
+
+            // Body.
+            parse_consume(parser, TOK_LCURLY,
+                          cstr("expected '{' on for loop statement"));
+            while (!parse_match(parser, TOK_RCURLY) && !parser->panic) {
+                parse_expr(parser, PREC_LOW);
+                Node *next = array_pop(parser->nodes);
+                next->parent = block;
+                array_push(block->statements, next, parser->storage);
+            }
+            array_push(block->statements, post, parser->storage);
+
+            // Put everything together
+            node_while->loop.cond = cond;
+            node_while->loop.expr = block;
+            array_push(node->statements, pre, parser->storage);
+            array_push(node->statements, node_while, parser->storage);
         } break;
         case TOK_WHILE: {
             node = node_alloc(parser, NODE_WHILE, prev);
-            if (!node) return;
             parse_expr(parser, PREC_LOW);
-            node->while_cond = array_pop(parser->nodes);
+            node->loop.cond = array_pop(parser->nodes);
+            node->loop.cond->parent = node;
             parse_expr(parser, PREC_LOW);
-            node->while_expr = array_pop(parser->nodes);
+            node->loop.expr = array_pop(parser->nodes);
+            node->loop.expr->parent = node;
         } break;
         case TOK_FUN: {
             node = node_alloc(parser, NODE_FUN, prev);
-            if (!node) return;
             parse_consume(parser, TOK_SYMBOL, cstr("expected function name"));
             Node *name = node_alloc(parser, NODE_SYMBOL, prev);
-            if (!name) return;
+            name->parent = node;
             name->value.sym = parser->previous.val;
-            node->func_name = name;
+            node->func.name = name;
             parse_consume(parser, TOK_LPAREN,
                           cstr("expected '(' on function definition"));
             // Parameters.
             while (!parse_match(parser, TOK_RPAREN) && !parser->panic) {
                 Node *param =
                     node_alloc(parser, NODE_FUN_PARAM, parser->current);
-                if (!param) return;
+                param->parent = node;
+
+                // Name.
                 Node *name = node_alloc(parser, NODE_SYMBOL, prev);
-                if (!name) return;
                 parse_consume(parser, TOK_SYMBOL, cstr("expected symbol name"));
                 name->value.sym = parser->previous.val;
-                param->param_name = name;
 
-                Node *type = node_alloc(parser, NODE_TYPE, prev);
-                if (!type) return;
+                // Type.
                 parse_consume(parser, TOK_COLON, cstr("expected param type"));
-                if (parse_match(parser, TOK_AT)) {
-                    type->is_ptr = true;
-                }
-                parse_consume(parser, TOK_SYMBOL, cstr("expected param type"));
-                type->value.sym = parser->previous.val;
-                param->param_type = type;
-                if (parse_match(parser, TOK_LSQUARE)) {
-                    type->kind = NODE_ARR_TYPE,
-                    parse_consume(parser, TOK_NUM_INT,
-                                  cstr("no array size given"));
-                    parse_number(parser);
-                    type->arr_size = array_pop(parser->nodes);
-                    parse_consume(parser, TOK_RSQUARE,
-                                  cstr("unmatched brackets ']' in array type"));
-                }
-                array_push(node->func_params, param, parser->storage);
+                parse_type(parser);
+
+                // Put everything together.
+                param->param.name = name;
+                param->param.type = array_pop(parser->nodes);
+                param->param.name->parent = param;
+                param->param.type->parent = param;
+                array_push(node->func.params, param, parser->storage);
             }
-            parse_consume(parser, TOK_COLON, cstr("expected param type"));
 
             // Return type(s).
-            if (!parse_match(parser, TOK_NIL)) {
-                if (parse_match(parser, TOK_LPAREN)) {
-                    while (!parse_match(parser, TOK_RPAREN) && !parser->panic) {
-                        Node *ret = node_alloc(parser, NODE_TYPE, prev);
-                        if (!ret) return;
-                        if (parse_match(parser, TOK_AT)) {
-                            ret->is_ptr = true;
-                        }
-                        parse_consume(parser, TOK_SYMBOL,
-                                      cstr("expected type name"));
-                        ret->value.sym = parser->previous.val;
-                        if (parse_match(parser, TOK_LSQUARE)) {
-                            ret->kind = NODE_ARR_TYPE,
-                            parse_consume(parser, TOK_NUM_INT,
-                                          cstr("no array size given"));
-                            parse_number(parser);
-                            ret->arr_size = array_pop(parser->nodes);
-                            parse_consume(parser, TOK_RSQUARE,
-                                          cstr("unmatched brackets ']' in "
-                                               "array type"));
-                        }
-                        array_push(node->func_ret, ret, parser->storage);
-                    }
-                } else {
-                    Node *ret = node_alloc(parser, NODE_TYPE, prev);
-                    if (!ret) return;
-                    if (parse_match(parser, TOK_AT)) {
-                        ret->is_ptr = true;
-                    }
-                    parse_consume(parser, TOK_SYMBOL,
-                                  cstr("expected type name"));
-                    ret->value.sym = parser->previous.val;
-                    if (parse_match(parser, TOK_LSQUARE)) {
-                        ret->kind = NODE_ARR_TYPE,
-                        parse_consume(parser, TOK_NUM_INT,
-                                      cstr("no array size given"));
-                        parse_number(parser);
-                        ret->arr_size = array_pop(parser->nodes);
-                        parse_consume(
-                            parser, TOK_RSQUARE,
-                            cstr("unmatched brackets ']' in array type"));
-                    }
-                    array_push(node->func_ret, ret, parser->storage);
-                }
+            // NOTE: We are setup here for multiple return values, but we are
+            // currently only considering a single one for simplicity.
+            if (parse_match(parser, TOK_COLON)) {
+                parse_type(parser);
+                Node *ret = array_pop(parser->nodes);
+                ret->parent = node;
+                array_push(node->func.ret, ret, parser->storage);
             }
 
             // Body.
             parse_expr(parser, PREC_LOW);
-            node->func_body = array_pop(parser->nodes);
+            node->func.body = array_pop(parser->nodes);
         } break;
         case TOK_RETURN: {
             node = node_alloc(parser, NODE_RETURN, prev);
-            if (!node) return;
             parse_consume(parser, TOK_LPAREN,
                           cstr("expected '(' after return"));
             while (!parse_match(parser, TOK_RPAREN) && !parser->panic) {
                 parse_expr(parser, PREC_LOW);
-                array_push(node->expressions, array_pop(parser->nodes),
-                           parser->storage);
+                Node *val = array_pop(parser->nodes);
+                val->parent = node;
+                array_push(node->expressions, val, parser->storage);
             }
         } break;
         default: return;  // Unreachable.
@@ -870,6 +1018,9 @@ parse_binary(Parser *parser) {
         case TOK_BITOR: {
             node = node_alloc(parser, NODE_BITOR, prev);
         } break;
+        case TOK_BITXOR: {
+            node = node_alloc(parser, NODE_BITXOR, prev);
+        } break;
         case TOK_BITLSHIFT: {
             node = node_alloc(parser, NODE_BITLSHIFT, prev);
         } break;
@@ -881,9 +1032,10 @@ parse_binary(Parser *parser) {
             return;
         }
     }
-    if (!node) return;
-    node->right = array_pop(parser->nodes);
-    node->left = array_pop(parser->nodes);
+    node->binary.right = array_pop(parser->nodes);
+    node->binary.left = array_pop(parser->nodes);
+    node->binary.right->parent = node;
+    node->binary.left->parent = node;
     array_push(parser->nodes, node, parser->storage);
 }
 
@@ -901,22 +1053,18 @@ parse_number(Parser *parser) {
             if (str_has_prefix(prev.val, cstr("0x")) ||
                 str_has_prefix(prev.val, cstr("0b"))) {
                 node = node_alloc(parser, NODE_NUM_UINT, prev);
-                if (!node) return;
                 node->value.u = str_to_uint(prev.val);
             } else {
                 node = node_alloc(parser, NODE_NUM_INT, prev);
-                if (!node) return;
                 node->value.i = str_to_int(prev.val);
             }
         } break;
         case TOK_NUM_FLOAT: {
             node = node_alloc(parser, NODE_NUM_FLOAT, prev);
-            if (!node) return;
             node->value.d = str_to_float(prev.val);
         } break;
         case TOK_CHAR: {
             node = node_alloc(parser, NODE_NUM_INT, prev);
-            if (!node) return;
             node->value.i = prev.val.mem[1];
         } break;
         default: break;
@@ -933,7 +1081,6 @@ parse_string(Parser *parser) {
     print_token(prev);
 #endif
     Node *node = node_alloc(parser, NODE_STRING, prev);
-    if (!node) return;
     node->value.str = str_remove_prefix(prev.val, cstr("\""));
     node->value.str = str_remove_suffix(node->value.str, cstr("\""));
     array_push(parser->nodes, node, parser->storage);
@@ -947,25 +1094,27 @@ parse_symbol(Parser *parser) {
     print("parsing symbol ");
     print_token(prev);
 #endif
+    // Dereference operators.
     if (prev.kind == TOK_AT) {
+        Node *node = node_alloc(parser, NODE_PTR, parser->previous);
         parse_consume(parser, TOK_SYMBOL,
-                      cstr("expected symbol after '.' operator"));
+                      cstr("expected symbol after '@' operator"));
         parse_symbol(parser);
-        Node *node = array_pop(parser->nodes);
-        if (node) {
-            node->is_ptr = true;
-            array_push(parser->nodes, node, parser->storage);
-        }
+        node->t.next = array_pop(parser->nodes);
+        node->t.next->parent = node;
+        array_push(parser->nodes, node, parser->storage);
         return;
     }
+
     Node *node = node_alloc(parser, NODE_SYMBOL, prev);
-    if (!node) return;
+    node->value.sym = prev.val;
     if (parse_match(parser, TOK_DOT)) {
         // Symbol chain.
         parse_consume(parser, TOK_SYMBOL,
                       cstr("expected symbol after '.' operator"));
         parse_symbol(parser);
-        node->next = array_pop(parser->nodes);
+        node->sym.next = array_pop(parser->nodes);
+        node->sym.next->parent = node;
     } else if (parser->current.kind == TOK_COLON &&
                parse_peek(parser) == TOK_LCURLY) {
         parse_advance(parser);
@@ -976,37 +1125,62 @@ parse_symbol(Parser *parser) {
         while (!parse_match(parser, TOK_RCURLY) && !parser->panic) {
             parse_struct_lit_field(parser);
             Node *field = array_pop(parser->nodes);
+            field->parent = node;
             array_push(node->elements, field, parser->storage);
         }
     } else if (parse_match(parser, TOK_LSQUARE)) {
-        node->kind = NODE_SYMBOL_IDX;
+        Node *index = node_alloc(parser, NODE_INDEX, prev);
+        Node *start = index;
         parse_expr(parser, PREC_LOW);
-        node->arr_size = array_pop(parser->nodes);
         parse_consume(parser, TOK_RSQUARE,
                       cstr("unmatched brackets ']' in array type"));
-        if (parse_match(parser, TOK_DOT)) {
-            // Symbol chain.
-            parse_consume(parser, TOK_SYMBOL,
-                          cstr("expected symbol after '.' operator"));
-            parse_symbol(parser);
-            node->next = array_pop(parser->nodes);
+        index->idx.value = array_pop(parser->nodes);
+        index->idx.value->parent = start;
+        while (parse_match(parser, TOK_LSQUARE)) {
+            Node *next = node_alloc(parser, NODE_INDEX, prev);
+            parse_expr(parser, PREC_LOW);
+            parse_consume(parser, TOK_RSQUARE,
+                          cstr("unmatched brackets ']' in array type"));
+            next->idx.value = array_pop(parser->nodes);
+            next->parent = index;
+            index->idx.next = next;
+            index = next;
         }
+
+        index->idx.next = node;
+        index->idx.next->parent = index;
+        array_push(parser->nodes, start, parser->storage);
+        return;
     } else if (parse_match(parser, TOK_LPAREN)) {
         node->kind = NODE_FUNCALL;
         while (!parse_match(parser, TOK_RPAREN) && !parser->panic) {
             parse_expr(parser, PREC_LOW);
-            array_push(node->arguments, array_pop(parser->nodes),
-                       parser->storage);
+            Node *arg = array_pop(parser->nodes);
+            arg->parent = node;
+            array_push(node->arguments, arg, parser->storage);
         }
         if (parse_match(parser, TOK_DOT)) {
             // Symbol chain.
             parse_consume(parser, TOK_SYMBOL,
                           cstr("expected symbol after '.' operator"));
             parse_symbol(parser);
-            node->next = array_pop(parser->nodes);
+            node->sym.next = array_pop(parser->nodes);
+            node->sym.next->parent = node;
+        }
+    } else if (parse_match(parser, TOK_AT)) {
+        Node *deref = node_alloc(parser, NODE_DEREF, prev);
+        Node *start = deref;
+        while (parse_match(parser, TOK_AT)) {
+            Node *next = node_alloc(parser, NODE_DEREF, prev);
+            next->parent = deref;
+            deref->deref.next = next;
+            deref = next;
         }
+        deref->deref.next = node;
+        deref->deref.next->parent = deref;
+        array_push(parser->nodes, start, parser->storage);
+        return;
     }
-    node->value.sym = prev.val;
     array_push(parser->nodes, node, parser->storage);
 }
 
@@ -1032,62 +1206,71 @@ graph_node(Node *node) {
         case NODE_NUM_UINT: print("| Value: %x", node->value.u); break;
         case NODE_NUM_FLOAT: print("| Value: %f{2}", node->value.d); break;
         case NODE_STRING: print("| Value: %s", node->value.str); break;
-        case NODE_SYMBOL_IDX:
         case NODE_STRUCT:
         case NODE_STRUCT_LIT: print("| Name: %s", node->value.sym); break;
         case NODE_SYMBOL:
         case NODE_FUNCALL:
-        case NODE_ARR_TYPE:
         case NODE_FIELD:
         case NODE_TYPE: {
-            if (node->is_ptr) {
-                print("| Name: @%s", node->value.sym);
-            } else {
-                print("| Name: %s", node->value.sym);
+            print("| Name: %s", node->value.sym);
+        } break;
+        case NODE_ARR: {
+            if (node->array.kind == NODE_ARR_STATIC) {
+                print("| Static [%d]", node->array.size->value.i);
+            } else if (node->array.kind == NODE_ARR_SLICE) {
+                print("| Slice []");
+            } else if (node->array.kind == NODE_ARR_DYNAMIC) {
+                print("| Dynamic [...]");
             }
         } break;
         default: break;
     }
+    if (node->unique_name.size > 0) {
+        print("| Unique Name: %s", node->unique_name);
+    }
     if (node->type.size > 0) {
         print("| Type: %s", node->type);
     }
-    if (node->fun_params.size > 0) {
-        print("| Params: %s", node->fun_params);
+    if (node->type_params.size > 0) {
+        print("| Params: %s", node->type_params);
     }
-    if (node->fun_return.size > 0) {
-        print("| Return: %s", node->fun_return);
+    if (node->type_returns.size > 0) {
+        print("| Return: %s", node->type_returns);
     }
     println("\"];");
 
+    if (node->parent) {
+        println("%d:w->%d:e;", node->id, node->parent->id);
+    }
     switch (node->kind) {
         case NODE_FUN: {
-            for (sz i = 0; i < array_size(node->func_params); i++) {
-                Node *next = node->func_params[i];
+            for (sz i = 0; i < array_size(node->func.params); i++) {
+                Node *next = node->func.params[i];
                 println("%d:e->%d:w;", node->id, next->id);
                 graph_node(next);
             }
-            for (sz i = 0; i < array_size(node->func_ret); i++) {
-                Node *next = node->func_ret[i];
+            for (sz i = 0; i < array_size(node->func.ret); i++) {
+                Node *next = node->func.ret[i];
                 println("%d:e->%d:w;", node->id, next->id);
                 graph_node(next);
             }
-            if (node->func_name) {
-                println("%d:e->%d:w;", node->id, node->func_name->id);
-                graph_node(node->func_name);
+            if (node->func.name) {
+                println("%d:e->%d:w;", node->id, node->func.name->id);
+                graph_node(node->func.name);
             }
-            if (node->func_body) {
-                println("%d:e->%d:w;", node->id, node->func_body->id);
-                graph_node(node->func_body);
+            if (node->func.body) {
+                println("%d:e->%d:w;", node->id, node->func.body->id);
+                graph_node(node->func.body);
             }
         } break;
         case NODE_COND:
         case NODE_MATCH: {
-            if (node->match_expr) {
-                println("%d:e->%d:w;", node->id, node->match_expr->id);
-                graph_node(node->match_expr);
+            if (node->match.expr) {
+                println("%d:e->%d:w;", node->id, node->match.expr->id);
+                graph_node(node->match.expr);
             }
-            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];
                 println("%d:e->%d:w;", node->id, next->id);
                 graph_node(next);
             }
@@ -1112,43 +1295,43 @@ graph_node(Node *node) {
             }
         } break;
         case NODE_IF: {
-            if (node->cond_if) {
-                println("%d:e->%d:w;", node->id, node->cond_if->id);
-                graph_node(node->cond_if);
+            if (node->ifelse.cond) {
+                println("%d:e->%d:w;", node->id, node->ifelse.cond->id);
+                graph_node(node->ifelse.cond);
             }
-            if (node->cond_expr) {
-                println("%d:e->%d:w;", node->id, node->cond_expr->id);
-                graph_node(node->cond_expr);
+            if (node->ifelse.expr_true) {
+                println("%d:e->%d:w;", node->id, node->ifelse.expr_true->id);
+                graph_node(node->ifelse.expr_true);
             }
-            if (node->cond_else) {
-                println("%d:e->%d:w;", node->id, node->cond_else->id);
-                graph_node(node->cond_else);
+            if (node->ifelse.expr_else) {
+                println("%d:e->%d:w;", node->id, node->ifelse.expr_else->id);
+                graph_node(node->ifelse.expr_else);
             }
         } break;
         case NODE_FIELD:
         case NODE_SET:
         case NODE_LET: {
-            if (node->var_name) {
-                println("%d:e->%d:w;", node->id, node->var_name->id);
-                graph_node(node->var_name);
+            if (node->var.name) {
+                println("%d:e->%d:w;", node->id, node->var.name->id);
+                graph_node(node->var.name);
             }
-            if (node->var_type) {
-                println("%d:e->%d:w;", node->id, node->var_type->id);
-                graph_node(node->var_type);
+            if (node->var.type) {
+                println("%d:e->%d:w;", node->id, node->var.type->id);
+                graph_node(node->var.type);
             }
-            if (node->var_val) {
-                println("%d:e->%d:w;", node->id, node->var_val->id);
-                graph_node(node->var_val);
+            if (node->var.val) {
+                println("%d:e->%d:w;", node->id, node->var.val->id);
+                graph_node(node->var.val);
             }
         } break;
         default: {
-            if (node->left) {
-                println("%d:e->%d:w;", node->id, node->left->id);
-                graph_node(node->left);
+            if (node->binary.left) {
+                println("%d:e->%d:w;", node->id, node->binary.left->id);
+                graph_node(node->binary.left);
             }
-            if (node->right) {
-                println("%d:e->%d:w;", node->id, node->right->id);
-                graph_node(node->right);
+            if (node->binary.right) {
+                println("%d:e->%d:w;", node->id, node->binary.right->id);
+                graph_node(node->binary.right);
             }
         } break;
     }