Add let, set and struct definitions

2 files changed, 221 insertions, 191 deletions

diff --git a/src/badlib.h b/src/badlib.h
index 6432562..25bb92b 100644
--- a/src/badlib.h
+++ b/src/badlib.h
@@ -930,7 +930,8 @@ typedef struct ArrayHeader {
      (ARR)[array_head(ARR)->size++] = (T))
 
 // Return the last element of the array. Can be used to build stacks.
-#define array_pop(ARR) (ARR)[--array_head(ARR)->size]
+#define array_pop(ARR) \
+    ((ARR) && array_size(ARR) ? (ARR)[--array_head(ARR)->size] : NULL)
 
 // Return the value stored at the OFFSET position from the tail of the array.
 #define array_peek(ARR, OFFSET) (ARR)[array_head(ARR)->size - 1 - (OFFSET)]
diff --git a/src/main.c b/src/main.c
index d456381..3466f44 100644
--- a/src/main.c
+++ b/src/main.c
@@ -70,13 +70,15 @@ typedef enum NodeKind {
     NODE_TRUE,
     NODE_FALSE,
     NODE_NIL,
+    NODE_STRUCT_LIT,
     // Keywords.
     NODE_LET,
     NODE_SET,
     NODE_STRUCT,
     // Helpers.
-    NODE_NODE_LIST,
-    NODE_NODE_TYPE,
+    NODE_TYPE,
+    NODE_COMPOUND_TYPE,
+    NODE_STRUCT_FIELD,
 } NodeKind;
 
 Str node_str[] = {
@@ -111,12 +113,15 @@ Str node_str[] = {
     [NODE_TRUE] = cstr("TRUE"),
     [NODE_FALSE] = cstr("FALSE"),
     [NODE_NIL] = cstr("NIL"),
+    [NODE_STRUCT_LIT] = cstr("STRUCT LITERAL"),
+    // Keywords.
     [NODE_LET] = cstr("LET"),
     [NODE_SET] = cstr("SET"),
     [NODE_STRUCT] = cstr("STRUCT"),
     // Helpers.
-    [NODE_NODE_LIST] = cstr("..."),
-    [NODE_NODE_TYPE] = cstr("TYPE"),
+    [NODE_TYPE] = cstr("TYPE"),
+    [NODE_COMPOUND_TYPE] = cstr("COMPOUND TYPE"),
+    [NODE_STRUCT_FIELD] = cstr("FIELD"),
 };
 
 typedef struct Node {
@@ -133,13 +138,27 @@ typedef struct Node {
         Str sym;
     } value;
     union {
-        struct Node *left;
-        struct Node *varname;
-    };
-    union {
-        struct Node *right;
-        struct Node *vartype;
-        struct Node *varvalue;
+        struct {
+            struct Node *left;
+            struct Node *right;
+        };
+        struct Node *next;
+        struct Node *initializer;
+        struct {
+            struct Node *var_name;
+            struct Node *var_type;
+            struct Node *var_val;
+        };
+        struct {
+            struct Node *field_name;
+            struct Node *field_type;
+            struct Node *field_val;
+        };
+        struct {
+            struct Node *struct_name;
+            struct Node **struct_field;
+        };
+        struct Node **elements;
     };
 } Node;
 
@@ -197,14 +216,13 @@ void parse_number(Parser *parser);
 void parse_literal(Parser *parser);
 void parse_string(Parser *parser);
 void parse_symbol(Parser *parser);
-void parse_symbol_chain(Parser *parser);
 void parse_keyword(Parser *parser);
-void parse_struct(Parser *parser);
-Node *parse_struct_field(Parser *parser);
-Node *parse_type(Parser *parser);
+void parse_type(Parser *parser);
 
 ParseRule parse_rules[] = {
     [TOK_LPAREN] = {parse_grouping, NULL, PREC_NONE},
+    [TOK_LCURLY] = {NULL, NULL, PREC_NONE},
+
     // Arithmetic.
     [TOK_SUB] = {parse_unary, parse_binary, PREC_TERM},
     [TOK_ADD] = {NULL, parse_binary, PREC_TERM},
@@ -232,7 +250,7 @@ ParseRule parse_rules[] = {
 
     // Literals.
     [TOK_STRING] = {parse_string, NULL, PREC_NONE},
-    [TOK_SYMBOL] = {parse_symbol_chain, NULL, PREC_NONE},
+    [TOK_SYMBOL] = {parse_symbol, NULL, PREC_NONE},
     [TOK_NUM_INT] = {parse_number, NULL, PREC_NONE},
     [TOK_NUM_FLOAT] = {parse_number, NULL, PREC_NONE},
     [TOK_TRUE] = {parse_literal, NULL, PREC_NONE},
@@ -256,12 +274,10 @@ ParseRule parse_rules[] = {
 };
 
 Node *
-node_alloc(NodeKind kind, Token tok, Parser *p) {
-    if (p->panic) {
-        return NULL;
-    }
+node_alloc(Parser *parser, NodeKind kind, Token tok) {
+    if (parser->panic) return NULL;
     static sz id = 0;
-    Node *node = arena_calloc((sz)sizeof(Node), p->storage);
+    Node *node = arena_calloc((sz)sizeof(Node), parser->storage);
     node->id = id++;
     node->kind = kind;
     node->line = tok.line;
@@ -271,17 +287,15 @@ node_alloc(NodeKind kind, Token tok, Parser *p) {
 
 void
 parse_emit_err(Parser *parser, Token token, Str msg) {
-    if (parser->panic) {
-        return;
-    }
+    if (parser->panic) return;
     parser->panic = true;
     parser->err = true;
     eprint("%d:%d: error: %s", token.line, token.col, msg);
 
     if (token.kind == TOK_EOF) {
-        eprintln(" -> at end of the file");
+        eprintln(" at end of the file");
     } else if (token.kind != TOK_UNKNOWN) {
-        eprintln(" -> at %s", token.val);
+        eprintln(" at %s", token.val);
     }
 }
 
@@ -318,9 +332,7 @@ void
 parse_expr(Parser *parser, ParsePrecedence precedence) {
     parse_advance(parser);
     // TODO: synchronize panic mode on keywords.
-    if (parser->panic) {
-        return;
-    }
+    if (parser->panic) return;
     ParseFn prefix = parse_rules[parser->previous.kind].prefix;
     if (prefix == NULL) {
         parse_emit_err(parser, parser->previous, cstr("expected expression"));
@@ -342,6 +354,7 @@ parse_expr(Parser *parser, ParsePrecedence precedence) {
 
 void
 parse_unary(Parser *parser) {
+    if (parser->panic) return;
     Token prev = parser->previous;
 #if DEBUG == 1
     print("parsing unary ");
@@ -350,19 +363,18 @@ parse_unary(Parser *parser) {
     parse_expr(parser, PREC_UNARY);
     Node *node = NULL;
     switch (prev.kind) {
-        case TOK_NOT: node = node_alloc(NODE_NOT, prev, parser); break;
-        case TOK_BITNOT: node = node_alloc(NODE_BITNOT, prev, parser); break;
+        case TOK_NOT: node = node_alloc(parser, NODE_NOT, prev); break;
+        case TOK_BITNOT: node = node_alloc(parser, NODE_BITNOT, prev); break;
         default: break;  // Unreachable.
     }
-    if (!node) {
-        return;
-    }
+    if (!node) return;
     node->left = array_pop(parser->nodes);
     array_push(parser->nodes, node, parser->storage);
 }
 
 void
 parse_literal(Parser *parser) {
+    if (parser->panic) return;
     Token prev = parser->previous;
 #if DEBUG == 1
     print("parsing literal ");
@@ -370,74 +382,68 @@ parse_literal(Parser *parser) {
 #endif
     Node *node = NULL;
     switch (prev.kind) {
-        case TOK_TRUE: {
-            node = node_alloc(NODE_TRUE, prev, parser);
-        } break;
-        case TOK_FALSE: {
-            node = node_alloc(NODE_FALSE, prev, parser);
-        } break;
-        case TOK_NIL: {
-            node = node_alloc(NODE_NIL, prev, parser);
-        } break;
+        case TOK_TRUE: node = node_alloc(parser, NODE_TRUE, prev); break;
+        case TOK_FALSE: node = node_alloc(parser, NODE_FALSE, prev); break;
+        case TOK_NIL: node = node_alloc(parser, NODE_NIL, prev); break;
         default: return;  // Unreachable.
     }
+    if (!node) return;
     array_push(parser->nodes, node, parser->storage);
 }
 
-Node *
+// Node *
+// parse_struct_field(Parser *parser) {
+// #if DEBUG == 1
+//     println("parsing struct field ");
+//     print_token(parser->previous);
+// #endif
+//     parse_consume(parser, TOK_SYMBOL, cstr("expected struct field name"));
+//     parse_symbol(parser);
+//     Node *field = array_pop(parser->nodes);
+//     parse_consume(parser, TOK_COLON,
+//                   cstr("invalid type name given for struct field"));
+//     field->right = parse_type(parser);
+//     if (parse_match(parser, TOK_ASSIGN)) {
+//         parse_expr(parser, PREC_LOW);
+//         field->left = array_pop(parser->nodes);
+//     }
+
+//     Node *list = node_alloc(NODE_NODE_LIST, parser->previous, parser);
+//     list->left = field;
+//     return list;
+// }
+
+void
 parse_type(Parser *parser) {
     Token prev = parser->previous;
 #if DEBUG == 1
     print("parsing type ");
     print_token(prev);
 #endif
-    Node *node = node_alloc(NODE_NODE_TYPE, prev, parser);
+    Node *node = node_alloc(parser, NODE_TYPE, prev);
+    if (!node) return;
     if (parse_match(parser, TOK_LCURLY)) {
-        node->value.sym = cstr("...");
-        Node *l = parse_struct_field(parser);
-        if (!l) {
-            return NULL;
-        }
-        node->vartype = l;
+        node->kind = NODE_COMPOUND_TYPE;
         while (!parse_match(parser, TOK_RCURLY) && !parser->panic) {
-            Node *tmp = parse_struct_field(parser);
-            if (!tmp) {
-                return NULL;
-            }
-            l->vartype = tmp;
-            l = tmp;
+            parse_consume(parser, TOK_SYMBOL, cstr("expected name"));
+            parse_symbol(parser);
+            Node *next = array_pop(parser->nodes);
+            parse_consume(parser, TOK_COLON, cstr("incomplete type"));
+            parse_type(parser);
+            next->next = array_pop(parser->nodes);
+            array_push(node->elements, next, parser->storage);
         }
-        return node;
-    }
-    parse_consume(parser, TOK_SYMBOL, cstr("no type given for struct field"));
-    node->value.sym = parser->previous.val;
-    return node;
-}
-
-Node *
-parse_struct_field(Parser *parser) {
-#if DEBUG == 1
-    println("parsing struct field ");
-    print_token(parser->previous);
-#endif
-    parse_consume(parser, TOK_SYMBOL, cstr("expected struct field name"));
-    parse_symbol(parser);
-    Node *field = array_pop(parser->nodes);
-    parse_consume(parser, TOK_COLON,
-                  cstr("invalid type name given for struct field"));
-    field->vartype = parse_type(parser);
-    if (parse_match(parser, TOK_ASSIGN)) {
-        parse_expr(parser, PREC_LOW);
-        field->varname = array_pop(parser->nodes);
+    } else {
+        parse_consume(parser, TOK_SYMBOL,
+                      cstr("no type given for struct field"));
+        node->value.sym = parser->previous.val;
     }
-
-    Node *list = node_alloc(NODE_NODE_LIST, parser->previous, parser);
-    list->varname = field;
-    return list;
+    array_push(parser->nodes, node, parser->storage);
 }
 
 void
 parse_keyword(Parser *parser) {
+    if (parser->panic) return;
     Token prev = parser->previous;
 #if DEBUG == 1
     print("parsing keyword ");
@@ -446,66 +452,70 @@ parse_keyword(Parser *parser) {
     Node *node = NULL;
     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);
 
             // Optional type declaration.
-            Node *type = NULL;
             if (parse_match(parser, TOK_COLON)) {
-                type = parse_type(parser);
-            }
-
-            node = node_alloc(NODE_LET, prev, parser);
-            if (!node) {
-                return;
+                parse_type(parser);
+                node->var_type = array_pop(parser->nodes);
             }
 
             // Optional assignment.
             if (parse_match(parser, TOK_ASSIGN)) {
                 parse_expr(parser, PREC_LOW);
-                node->varvalue = array_pop(parser->nodes);
+                node->var_val = array_pop(parser->nodes);
             }
-            node->varname = array_pop(parser->nodes);
-            node->varname->vartype = type;
         } break;
         case TOK_SET: {
+            node = node_alloc(parser, NODE_SET, prev);
+            if (!node) return;
             parse_consume(parser, TOK_SYMBOL,
-                          cstr("expected symbol name on set expression"));
-            parse_symbol_chain(parser);
+                          cstr("expected symbol name on let 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 = node_alloc(NODE_SET, prev, parser);
-            if (!node) {
-                return;
-            }
-            node->varvalue = array_pop(parser->nodes);
-            node->varname = array_pop(parser->nodes);
+            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"));
             parse_symbol(parser);
+            node->struct_name = array_pop(parser->nodes);
+
             parse_consume(parser, TOK_LCURLY,
                           cstr("expected '{' on struct definition"));
-            node = node_alloc(NODE_STRUCT, prev, parser);
-            if (!node) {
-                return;
-            }
-            node->varname = array_pop(parser->nodes);
-            Node *l = parse_struct_field(parser);
-            if (!l) {
-                return;
-            }
-            node->vartype = l;
+
             while (!parse_match(parser, TOK_RCURLY) && !parser->panic) {
-                Node *tmp = parse_struct_field(parser);
-                if (!tmp) {
-                    return;
+                Node *field =
+                    node_alloc(parser, NODE_STRUCT_FIELD, parser->current);
+                if (!field) return;
+                parse_consume(
+                    parser, TOK_SYMBOL,
+                    cstr("expected symbol name on struct definition"));
+                parse_symbol(parser);
+                field->field_name = array_pop(parser->nodes);
+                parse_consume(
+                    parser, TOK_COLON,
+                    cstr("expected symbol name on struct definition"));
+                parse_type(parser);
+                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);
                 }
-                l->vartype = tmp;
-                l = tmp;
+
+                array_push(node->struct_field, field, parser->storage);
             }
         } break;
         default: return;  // Unreachable.
@@ -515,6 +525,7 @@ parse_keyword(Parser *parser) {
 
 void
 parse_binary(Parser *parser) {
+    if (parser->panic) return;
     Token prev = parser->previous;
 #if DEBUG == 1
     print("parsing binary ");
@@ -525,39 +536,37 @@ parse_binary(Parser *parser) {
 
     Node *node;
     switch (prev.kind) {
-        case TOK_ADD: node = node_alloc(NODE_ADD, prev, parser); break;
-        case TOK_SUB: node = node_alloc(NODE_SUB, prev, parser); break;
-        case TOK_MUL: node = node_alloc(NODE_MUL, prev, parser); break;
-        case TOK_DIV: node = node_alloc(NODE_DIV, prev, parser); break;
-        case TOK_MOD: node = node_alloc(NODE_MOD, prev, parser); break;
-        case TOK_AND: node = node_alloc(NODE_AND, prev, parser); break;
-        case TOK_OR: node = node_alloc(NODE_OR, prev, parser); break;
-        case TOK_EQ: node = node_alloc(NODE_EQ, prev, parser); break;
-        case TOK_NEQ: node = node_alloc(NODE_NEQ, prev, parser); break;
-        case TOK_LT: node = node_alloc(NODE_LT, prev, parser); break;
-        case TOK_GT: node = node_alloc(NODE_GT, prev, parser); break;
-        case TOK_LE: node = node_alloc(NODE_LE, prev, parser); break;
-        case TOK_GE: node = node_alloc(NODE_GE, prev, parser); break;
+        case TOK_ADD: node = node_alloc(parser, NODE_ADD, prev); break;
+        case TOK_SUB: node = node_alloc(parser, NODE_SUB, prev); break;
+        case TOK_MUL: node = node_alloc(parser, NODE_MUL, prev); break;
+        case TOK_DIV: node = node_alloc(parser, NODE_DIV, prev); break;
+        case TOK_MOD: node = node_alloc(parser, NODE_MOD, prev); break;
+        case TOK_AND: node = node_alloc(parser, NODE_AND, prev); break;
+        case TOK_OR: node = node_alloc(parser, NODE_OR, prev); break;
+        case TOK_EQ: node = node_alloc(parser, NODE_EQ, prev); break;
+        case TOK_NEQ: node = node_alloc(parser, NODE_NEQ, prev); break;
+        case TOK_LT: node = node_alloc(parser, NODE_LT, prev); break;
+        case TOK_GT: node = node_alloc(parser, NODE_GT, prev); break;
+        case TOK_LE: node = node_alloc(parser, NODE_LE, prev); break;
+        case TOK_GE: node = node_alloc(parser, NODE_GE, prev); break;
         case TOK_BITAND: {
-            node = node_alloc(NODE_BITAND, prev, parser);
+            node = node_alloc(parser, NODE_BITAND, prev);
         } break;
         case TOK_BITOR: {
-            node = node_alloc(NODE_BITOR, prev, parser);
+            node = node_alloc(parser, NODE_BITOR, prev);
         } break;
         case TOK_BITLSHIFT: {
-            node = node_alloc(NODE_BITLSHIFT, prev, parser);
+            node = node_alloc(parser, NODE_BITLSHIFT, prev);
         } break;
         case TOK_BITRSHIFT: {
-            node = node_alloc(NODE_BITRSHIFT, prev, parser);
+            node = node_alloc(parser, NODE_BITRSHIFT, prev);
         } break;
         default: {
             parse_emit_err(parser, prev, cstr("unreachable"));
             return;
         }
     }
-    if (!node) {
-        return;
-    }
+    if (!node) return;
     node->right = array_pop(parser->nodes);
     node->left = array_pop(parser->nodes);
     array_push(parser->nodes, node, parser->storage);
@@ -565,6 +574,7 @@ parse_binary(Parser *parser) {
 
 void
 parse_number(Parser *parser) {
+    if (parser->panic) return;
     Token prev = parser->previous;
 #if DEBUG == 1
     print("parsing number ");
@@ -575,24 +585,18 @@ parse_number(Parser *parser) {
         case TOK_NUM_INT: {
             if (str_has_prefix(prev.val, cstr("0x")) ||
                 str_has_prefix(prev.val, cstr("0b"))) {
-                node = node_alloc(NODE_NUM_UINT, prev, parser);
-                if (!node) {
-                    return;
-                }
+                node = node_alloc(parser, NODE_NUM_UINT, prev);
+                if (!node) return;
                 node->value.u = str_to_uint(prev.val);
             } else {
-                node = node_alloc(NODE_NUM_INT, prev, parser);
-                if (!node) {
-                    return;
-                }
+                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(NODE_NUM_FLOAT, prev, parser);
-            if (!node) {
-                return;
-            }
+            node = node_alloc(parser, NODE_NUM_FLOAT, prev);
+            if (!node) return;
             node->value.d = str_to_float(prev.val);
         } break;
         default: break;
@@ -602,15 +606,14 @@ parse_number(Parser *parser) {
 
 void
 parse_string(Parser *parser) {
+    if (parser->panic) return;
     Token prev = parser->previous;
 #if DEBUG == 1
     print("parsing string ");
     print_token(prev);
 #endif
-    Node *node = node_alloc(NODE_STRING, prev, parser);
-    if (!node) {
-        return;
-    }
+    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);
@@ -618,42 +621,32 @@ parse_string(Parser *parser) {
 
 void
 parse_symbol(Parser *parser) {
+    if (parser->panic) return;
     Token prev = parser->previous;
 #if DEBUG == 1
     print("parsing symbol ");
     print_token(prev);
 #endif
-    Node *node = node_alloc(NODE_SYMBOL, prev, parser);
-    if (!node) {
-        return;
-    }
-    node->value.sym = prev.val;
-    array_push(parser->nodes, node, parser->storage);
-}
-
-void
-parse_symbol_chain(Parser *parser) {
-    Token prev = parser->previous;
-#if DEBUG == 1
-    print("parsing symbol ");
-    print_token(prev);
-#endif
-    Node *node = node_alloc(NODE_SYMBOL, prev, parser);
-    if (!node) {
-        return;
-    }
-    node->value.sym = prev.val;
+    Node *node;
     if (parse_match(parser, TOK_DOT)) {
+        // Symbol chain.
         parse_consume(parser, TOK_SYMBOL,
                       cstr("expected symbol after '.' operator"));
-        parse_symbol_chain(parser);
-        node->varname = array_pop(parser->nodes);
+        node = node_alloc(parser, NODE_SYMBOL, prev);
+        if (!node) return;
+        parse_symbol(parser);
+        node->next = array_pop(parser->nodes);
+    } else {
+        node = node_alloc(parser, NODE_SYMBOL, prev);
+        if (!node) return;
     }
+    node->value.sym = prev.val;
     array_push(parser->nodes, node, parser->storage);
 }
 
 void
 parse_grouping(Parser *parser) {
+    if (parser->panic) return;
 #if DEBUG == 1
     print("parsing group  ");
     print_token(parser->previous);
@@ -664,37 +657,73 @@ parse_grouping(Parser *parser) {
 
 void
 graph_node(Node *node) {
-    if (node == NULL) {
-        return;
-    }
+    if (node == NULL) return;
     print("%d [width=2.5,shape=Mrecord,label=\"", node->id);
-    print("{ %s | { L: %d | C: %d } } ", node_str[node->kind], node->line,
-          node->col);
+    print("{ <type> %s | { L: %d | C: %d } } ", node_str[node->kind],
+          node->line, node->col);
     switch (node->kind) {
         case NODE_NUM_INT: print("| Value: %d", node->value.i); break;
         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: print("| Value: %s", node->value.sym); break;
-        case NODE_NODE_TYPE: print("| Value: %s", node->value.sym); break;
+        case NODE_STRUCT_LIT: print("| Value: %s", node->value.sym); break;
+        case NODE_TYPE: print("| Value: %s", node->value.sym); break;
         default: break;
     }
     println("\"];");
-    if (node->left) {
-        println("%d:e->%d:w;", node->id, node->left->id);
-        graph_node(node->left);
-    }
-    if (node->right) {
-        println("%d:e->%d:w;", node->id, node->right->id);
-        graph_node(node->right);
+
+    switch (node->kind) {
+        case NODE_COMPOUND_TYPE: {
+            for (sz i = 0; i < array_size(node->elements); i++) {
+                Node *next = node->elements[i];
+                println("%d:e->%d:w;", node->id, next->id);
+                graph_node(next);
+            }
+        } break;
+        case NODE_STRUCT: {
+            if (node->struct_name) {
+                println("%d:e->%d:w;", node->id, node->struct_name->id);
+                graph_node(node->struct_name);
+            }
+            for (sz i = 0; i < array_size(node->struct_field); i++) {
+                Node *next = node->struct_field[i];
+                println("%d:e->%d:w;", node->id, next->id);
+                graph_node(next);
+            }
+        } break;
+        case NODE_STRUCT_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_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);
+            }
+        } break;
+        default: {
+            if (node->left) {
+                println("%d:e->%d:w;", node->id, node->left->id);
+                graph_node(node->left);
+            }
+            if (node->right) {
+                println("%d:e->%d:w;", node->id, node->right->id);
+                graph_node(node->right);
+            }
+        } break;
     }
 }
 
 void
 graph_ast(Node **roots) {
-    if (roots == NULL) {
-        return;
-    }
+    if (roots == NULL) return;
     println("digraph ast {");
     println("rankdir=LR;");
     println("ranksep=\"0.95 equally\";");