1 files changed, 251 insertions, 144 deletions

diff --git a/src/parser.c b/src/parser.c
index 90adaf3..5253841 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.
@@ -69,6 +71,7 @@ typedef enum NodeKind {
 } NodeKind;
 
 Str node_str[] = {
+    [NODE_ERR] = cstr("ERR"),
     // Arithmetic.
     [NODE_ADD] = cstr("ADD"),
     [NODE_SUB] = cstr("SUB"),
@@ -89,6 +92,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.
@@ -128,75 +132,102 @@ Str node_str[] = {
     [NODE_BLOCK] = cstr("BLOCK"),
 };
 
+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;
+    struct Node *arr_size;
+} NodeSymbol;
+
 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;
         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 +317,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 +340,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},
@@ -437,7 +470,7 @@ parse_unary(Parser *parser) {
         default: break;  // Unreachable.
     }
     if (!node) return;
-    node->left = array_pop(parser->nodes);
+    node->unary.left = array_pop(parser->nodes);
     array_push(parser->nodes, node, parser->storage);
 }
 
@@ -482,7 +515,7 @@ parse_type(Parser *parser) {
         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);
+        node->sym.arr_size = array_pop(parser->nodes);
         parse_consume(parser, TOK_RSQUARE,
                       cstr("unmatched brackets ']' in array type"));
     }
@@ -510,16 +543,16 @@ parse_struct_field(Parser *parser) {
             Node *subfield = array_pop(parser->nodes);
             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);
     }
 
     // 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);
     }
     array_push(parser->nodes, field, parser->storage);
 }
@@ -546,10 +579,10 @@ parse_struct_lit_field(Parser *parser) {
             Node *subfield = array_pop(parser->nodes);
             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);
     }
     array_push(parser->nodes, field, parser->storage);
 }
@@ -570,8 +603,8 @@ parse_keyword(Parser *parser) {
             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);
+            if (node->var.name->sym.next) {
                 parse_emit_err(parser, prev,
                                cstr("invalid symbol name in let expression"));
                 return;
@@ -580,16 +613,16 @@ 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);
             }
 
             // 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);
             }
 
-            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"));
@@ -599,13 +632,50 @@ parse_keyword(Parser *parser) {
             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);
+
+            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;
+                node->var.val = op;
+                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);
@@ -629,19 +699,19 @@ parse_keyword(Parser *parser) {
             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);
             parse_expr(parser, PREC_LOW);
-            node->cond_expr = array_pop(parser->nodes);
+            node->ifelse.expr_true = array_pop(parser->nodes);
             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);
             }
         } 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);
             parse_consume(parser, TOK_LCURLY,
                           cstr("expected block of match cases"));
             while (!parse_match(parser, TOK_RCURLY) && !parser->panic) {
@@ -653,13 +723,13 @@ parse_keyword(Parser *parser) {
                     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);
                 }
                 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);
+                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...
@@ -683,7 +753,7 @@ parse_keyword(Parser *parser) {
                 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);
                 }
                 array_push(node->struct_field, field, parser->storage);
             }
@@ -703,13 +773,13 @@ parse_keyword(Parser *parser) {
                 // 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);
                 }
                 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);
+                array_push(node->match.cases, tmp, parser->storage);
             }
         } break;
         case TOK_BREAK: {
@@ -720,13 +790,47 @@ parse_keyword(Parser *parser) {
             node = node_alloc(parser, NODE_CONTINUE, prev);
             if (!node) return;
         } break;
+        case TOK_FOR: {
+            node = node_alloc(parser, NODE_BLOCK, prev);
+            if (!node) return;
+
+            Node *node_while = node_alloc(parser, NODE_WHILE, prev);
+            if (!node_while) return;
+            Node *block = node_alloc(parser, NODE_BLOCK, prev);
+            if (!block) return;
+
+            parse_expr(parser, PREC_LOW);
+            Node *pre = array_pop(parser->nodes);
+
+            parse_expr(parser, PREC_LOW);
+            Node *cond = array_pop(parser->nodes);
+
+            parse_expr(parser, PREC_LOW);
+            Node *post = array_pop(parser->nodes);
+
+            // 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);
+                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);
             parse_expr(parser, PREC_LOW);
-            node->while_expr = array_pop(parser->nodes);
+            node->loop.expr = array_pop(parser->nodes);
         } break;
         case TOK_FUN: {
             node = node_alloc(parser, NODE_FUN, prev);
@@ -735,7 +839,7 @@ parse_keyword(Parser *parser) {
             Node *name = node_alloc(parser, NODE_SYMBOL, prev);
             if (!name) return;
             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.
@@ -747,7 +851,7 @@ parse_keyword(Parser *parser) {
                 if (!name) return;
                 parse_consume(parser, TOK_SYMBOL, cstr("expected symbol name"));
                 name->value.sym = parser->previous.val;
-                param->param_name = name;
+                param->param.name = name;
 
                 Node *type = node_alloc(parser, NODE_TYPE, prev);
                 if (!type) return;
@@ -757,17 +861,17 @@ parse_keyword(Parser *parser) {
                 }
                 parse_consume(parser, TOK_SYMBOL, cstr("expected param type"));
                 type->value.sym = parser->previous.val;
-                param->param_type = type;
+                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);
+                    type->sym.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);
+                array_push(node->func.params, param, parser->storage);
             }
             parse_consume(parser, TOK_COLON, cstr("expected param type"));
 
@@ -788,12 +892,12 @@ parse_keyword(Parser *parser) {
                             parse_consume(parser, TOK_NUM_INT,
                                           cstr("no array size given"));
                             parse_number(parser);
-                            ret->arr_size = array_pop(parser->nodes);
+                            ret->sym.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);
+                        array_push(node->func.ret, ret, parser->storage);
                     }
                 } else {
                     Node *ret = node_alloc(parser, NODE_TYPE, prev);
@@ -809,18 +913,18 @@ parse_keyword(Parser *parser) {
                         parse_consume(parser, TOK_NUM_INT,
                                       cstr("no array size given"));
                         parse_number(parser);
-                        ret->arr_size = array_pop(parser->nodes);
+                        ret->sym.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);
+                    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);
@@ -870,6 +974,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;
@@ -882,8 +989,8 @@ parse_binary(Parser *parser) {
         }
     }
     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);
     array_push(parser->nodes, node, parser->storage);
 }
 
@@ -965,7 +1072,7 @@ parse_symbol(Parser *parser) {
         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);
     } else if (parser->current.kind == TOK_COLON &&
                parse_peek(parser) == TOK_LCURLY) {
         parse_advance(parser);
@@ -981,7 +1088,7 @@ parse_symbol(Parser *parser) {
     } else if (parse_match(parser, TOK_LSQUARE)) {
         node->kind = NODE_SYMBOL_IDX;
         parse_expr(parser, PREC_LOW);
-        node->arr_size = array_pop(parser->nodes);
+        node->sym.arr_size = array_pop(parser->nodes);
         parse_consume(parser, TOK_RSQUARE,
                       cstr("unmatched brackets ']' in array type"));
         if (parse_match(parser, TOK_DOT)) {
@@ -989,7 +1096,7 @@ parse_symbol(Parser *parser) {
             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);
         }
     } else if (parse_match(parser, TOK_LPAREN)) {
         node->kind = NODE_FUNCALL;
@@ -1003,7 +1110,7 @@ parse_symbol(Parser *parser) {
             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->value.sym = prev.val;
@@ -1051,43 +1158,43 @@ graph_node(Node *node) {
     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("\"];");
 
     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 +1219,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;
     }