Add compound types for anonymous struct fields

2 files changed, 81 insertions, 78 deletions

diff --git a/src/main.c b/src/main.c
index 6c3f3a5..f792b10 100644
--- a/src/main.c
+++ b/src/main.c
@@ -534,33 +534,35 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
             // TODO: make sure it didn't exist before.
             StructMap *e = structmap_insert(
                 &scope->structs, symbol, (Struct){.name = symbol}, a->storage);
-            for (sz i = 0; i < array_size(node->struct_field); i++) {
-                Node *field = node->struct_field[i];
-                Str field_name = field->field_name->value.str;
-                Str field_type = field->field_type->value.str;
-                if (fieldmap_lookup(&e->val.fields, field_name)) {
-                    eprintln(
-                        "%s:%d:%d: error: struct field '%s.%s' already exists",
-                        a->file_name, field->line, field->col, symbol,
-                        field_name);
-                }
-                if (field->field_val) {
-                    Type type = type_inference(a, field->field_val, scope);
-                    if (!str_eq(type, field_type)) {
-                        eprintln(
-                            "%s:%d:%d: error: mismatched types in struct value "
-                            "for '%s.%s' ",
-                            a->file_name, field->line, field->col, symbol,
-                            field_name);
-                    }
-                }
-                fieldmap_insert(&e->val.fields, field_name,
-                                (Field){.name = field_name,
-                                        .type = field_type,
-                                        .val = field->field_val},
-                                a->storage);
-                field->type = field_type;
-            }
+            // for (sz i = 0; i < array_size(node->struct_field); i++) {
+            //     Node *field = node->struct_field[i];
+            //     // TODO: handle compound types
+            //     Str field_name = field->value.str;
+            //     Str field_type = field->field_type->value.str;
+            //     if (fieldmap_lookup(&e->val.fields, field_name)) {
+            //         eprintln(
+            //             "%s:%d:%d: error: struct field '%s.%s' already exists",
+            //             a->file_name, field->line, field->col, symbol,
+            //             field_name);
+            //     }
+            //     if (field->field_val) {
+            //         Type type = type_inference(a, field->field_val, scope);
+            //         if (!str_eq(type, field_type)) {
+            //             eprintln(
+            //                 "%s:%d:%d: error: mismatched types in struct "
+            //                 "value "
+            //                 "for '%s.%s': %s expected %s",
+            //                 a->file_name, field->line, field->col, symbol,
+            //                 field_name, type, field_type);
+            //         }
+            //     }
+            //     fieldmap_insert(&e->val.fields, field_name,
+            //                     (Field){.name = field_name,
+            //                             .type = field_type,
+            //                             .val = field->field_val},
+            //                     a->storage);
+            //     field->type = field_type;
+            // }
             typemap_insert(&scope->types, symbol, symbol, a->storage);
             return node->type;
         } break;
@@ -572,7 +574,7 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
                                         (Enum){.name = symbol}, a->storage);
             for (sz i = 0; i < array_size(node->struct_field); i++) {
                 Node *field = node->struct_field[i];
-                Str field_name = field->field_name->value.str;
+                Str field_name = field->value.str;
                 if (fieldmap_lookup(&e->val.fields, field_name)) {
                     eprintln(
                         "%s:%d:%d: error: enum field '%s.%s' already exists",
@@ -865,7 +867,7 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
             }
             for (sz i = 0; i < array_size(node->elements); i++) {
                 Node *next = node->elements[i];
-                Str field_name = next->field_name->value.str;
+                Str field_name = next->value.str;
                 FieldMap *field = fieldmap_lookup(&s->val.fields, field_name);
                 if (!field) {
                     eprintln(
@@ -1154,7 +1156,7 @@ analyzer_symbols(Analyzer *a, Node *node, Scope *scope) {
             // TODO: symcheck the value expression?
             for (sz i = 0; i < array_size(node->struct_field); i++) {
                 Node *field = node->struct_field[i];
-                Str field_name = field->field_name->value.str;
+                Str field_name = field->value.str;
                 if (symmap_lookup(&map->val.fields, field_name) != NULL) {
                     eprintln(
                         "%s:%d:%d: error: enum field '%s.%s' already exists",
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) {