Add compound types for anonymous struct fields

1 files changed, 49 insertions, 48 deletions

diff --git a/src/parser.c b/src/parser.c
index a6d9f83..1e54776 100644
--- a/src/parser.c
+++ b/src/parser.c
@@ -62,8 +62,9 @@ typedef enum NodeKind {
     // Helpers.
     NODE_SYMBOL_IDX,
     NODE_TYPE,
+    NODE_COMPOUND_TYPE,
     NODE_ARR_TYPE,
-    NODE_VAL_FIELD,
+    NODE_FIELD,
     NODE_BLOCK,
 } NodeKind;
 
@@ -120,9 +121,10 @@ Str node_str[] = {
     [NODE_WHILE] = cstr("WHILE"),
     // Helpers.
     [NODE_TYPE] = cstr("TYPE"),
+    [NODE_COMPOUND_TYPE] = cstr("COMPOUND TYPE"),
     [NODE_ARR_TYPE] = cstr("TYPE (ARR)"),
     [NODE_SYMBOL_IDX] = cstr("SYMBOL[IDX]"),
-    [NODE_VAL_FIELD] = cstr("FIELD"),
+    [NODE_FIELD] = cstr("FIELD"),
     [NODE_BLOCK] = cstr("BLOCK"),
 };
 
@@ -163,7 +165,6 @@ typedef struct Node {
             struct Node *cond_else;
         };
         struct {
-            struct Node *field_name;
             struct Node *field_type;
             struct Node *field_val;
         };
@@ -485,6 +486,42 @@ parse_type(Parser *parser) {
 }
 
 void
+parse_struct_field(Parser *parser) {
+    if (parser->panic) return;
+    Token prev = parser->previous;
+#if DEBUG == 1
+    print("parsing struct field ");
+    print_token(prev);
+#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;
+        while (!parse_match(parser, TOK_RCURLY) && !parser->panic) {
+            parse_struct_field(parser);
+            Node *subfield = array_pop(parser->nodes);
+            array_push(type->elements, subfield, parser->storage);
+        }
+        field->field_type = type;
+    } else {
+        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);
+    }
+    array_push(parser->nodes, field, parser->storage);
+}
+
+void
 parse_keyword(Parser *parser) {
     if (parser->panic) return;
     Token prev = parser->previous;
@@ -549,37 +586,8 @@ parse_keyword(Parser *parser) {
                           cstr("expected '{' on struct definition"));
 
             while (!parse_match(parser, TOK_RCURLY) && !parser->panic) {
-                Node *field =
-                    node_alloc(parser, NODE_VAL_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);
-                if (field->field_name->next ||
-                    field->field_name->kind == NODE_SYMBOL_IDX) {
-                    parse_emit_err(parser, prev,
-                                   cstr("invalid symbol name in struct field"));
-                    return;
-                }
-                parse_consume(parser, TOK_COLON,
-                              cstr("expected type in struct field"));
-                // TODO: if consume curly
-                if (parse_match(parser, TOK_LCURLY)) {
-                    // TODO: nested struct
-                } else {
-                    parse_type(parser);
-                    field->field_type = array_pop(parser->nodes);
-                }
-                //     while (!parse_match(parser, TOK_RCURLY) &&
-                //     !parser->panic) {
-
-                // Optional assignment.
-                if (parse_match(parser, TOK_ASSIGN)) {
-                    parse_expr(parser, PREC_LOW);
-                    field->field_val = array_pop(parser->nodes);
-                }
+                parse_struct_field(parser);
+                Node *field = array_pop(parser->nodes);
 
                 array_push(node->struct_field, field, parser->storage);
             }
@@ -635,19 +643,11 @@ parse_keyword(Parser *parser) {
             parse_consume(parser, TOK_LCURLY,
                           cstr("expected '{' on enum definition"));
             while (!parse_match(parser, TOK_RCURLY) && !parser->panic) {
-                Node *field =
-                    node_alloc(parser, NODE_VAL_FIELD, parser->current);
+                Node *field = node_alloc(parser, NODE_FIELD, parser->current);
                 if (!field) return;
                 parse_consume(parser, TOK_SYMBOL,
                               cstr("expected symbol name on enum definition"));
-                parse_symbol(parser);
-                field->field_name = array_pop(parser->nodes);
-                if (field->field_name->next ||
-                    field->field_name->kind == NODE_SYMBOL_IDX) {
-                    parse_emit_err(parser, prev,
-                                   cstr("invalid symbol name in enum field"));
-                    return;
-                }
+                field->value.sym = parser->previous.val;
                 if (parse_match(parser, TOK_ASSIGN)) {
                     parse_expr(parser, PREC_LOW);
                     field->field_val = array_pop(parser->nodes);
@@ -941,10 +941,9 @@ parse_symbol(Parser *parser) {
         // Struct literal.
         node->kind = NODE_STRUCT_LIT;
         while (!parse_match(parser, TOK_RCURLY) && !parser->panic) {
-            Node *field = node_alloc(parser, NODE_VAL_FIELD, parser->current);
+            Node *field = node_alloc(parser, NODE_FIELD, parser->current);
             parse_consume(parser, TOK_SYMBOL, cstr("expected symbol name"));
-            parse_symbol(parser);
-            field->field_name = array_pop(parser->nodes);
+            field->value.sym = parser->previous.val;
             parse_consume(parser, TOK_ASSIGN, cstr("expected assignment"));
             parse_expr(parser, PREC_LOW);
             field->field_val = array_pop(parser->nodes);
@@ -1011,6 +1010,7 @@ graph_node(Node *node) {
         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);
@@ -1067,6 +1067,7 @@ graph_node(Node *node) {
         case NODE_FUNCALL:
         case NODE_RETURN:
         case NODE_BLOCK:
+        case NODE_COMPOUND_TYPE:
         case NODE_STRUCT_LIT: {
             for (sz i = 0; i < array_size(node->elements); i++) {
                 Node *next = node->elements[i];
@@ -1096,7 +1097,7 @@ graph_node(Node *node) {
                 graph_node(node->cond_else);
             }
         } break;
-        case NODE_VAL_FIELD:
+        case NODE_FIELD:
         case NODE_SET:
         case NODE_LET: {
             if (node->var_name) {