Change grammar for struct literals

1 files changed, 41 insertions, 39 deletions

diff --git a/src/parser.c b/src/parser.c
index 1283854..7b49b55 100644
--- a/src/parser.c
+++ b/src/parser.c
@@ -63,7 +63,6 @@ typedef enum NodeKind {
     NODE_SYMBOL_IDX,
     NODE_TYPE,
     NODE_ARR_TYPE,
-    NODE_COMPOUND_TYPE,
     NODE_VAL_FIELD,
     NODE_BLOCK,
 } NodeKind;
@@ -123,7 +122,6 @@ Str node_str[] = {
     [NODE_TYPE] = cstr("TYPE"),
     [NODE_ARR_TYPE] = cstr("TYPE (ARR)"),
     [NODE_SYMBOL_IDX] = cstr("SYMBOL[IDX]"),
-    [NODE_COMPOUND_TYPE] = cstr("TYPE (COMPOUND)"),
     [NODE_VAL_FIELD] = cstr("FIELD"),
     [NODE_BLOCK] = cstr("BLOCK"),
 };
@@ -353,6 +351,15 @@ parse_advance(Parser *parser) {
     parser->current = parser->tokens[parser->idx++];
 }
 
+TokenKind
+parse_peek(Parser *parser) {
+    assert(parser);
+    if (parser->current.kind == TOK_EOF) {
+        return TOK_EOF;
+    }
+    return parser->tokens[parser->idx].kind;
+}
+
 bool
 parse_match(Parser *parser, TokenKind kind) {
     assert(parser);
@@ -463,30 +470,16 @@ parse_type(Parser *parser) {
     if (parse_match(parser, TOK_AT)) {
         node->is_ptr = true;
     }
-    if (parse_match(parser, TOK_LCURLY)) {
-        node->kind = NODE_COMPOUND_TYPE;
-        while (!parse_match(parser, TOK_RCURLY) && !parser->panic) {
-            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);
-        }
-    } else {
-        parse_consume(parser, TOK_SYMBOL,
-                      cstr("no type given for struct field"));
-        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"));
-        }
+    parse_consume(parser, TOK_SYMBOL, cstr("no type given for struct field"));
+    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);
 }
@@ -570,11 +563,17 @@ parse_keyword(Parser *parser) {
                                    cstr("invalid symbol name in struct field"));
                     return;
                 }
-                parse_consume(
-                    parser, TOK_COLON,
-                    cstr("expected symbol name on struct definition"));
-                parse_type(parser);
-                field->field_type = array_pop(parser->nodes);
+                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)) {
@@ -629,8 +628,8 @@ parse_keyword(Parser *parser) {
                 tmp->case_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...
+            // 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;
@@ -769,9 +768,9 @@ parse_keyword(Parser *parser) {
                                           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"));
+                            parse_consume(parser, TOK_RSQUARE,
+                                          cstr("unmatched brackets ']' in "
+                                               "array type"));
                         }
                         array_push(node->func_ret, ret, parser->storage);
                     }
@@ -946,7 +945,11 @@ parse_symbol(Parser *parser) {
                       cstr("expected symbol after '.' operator"));
         parse_symbol(parser);
         node->next = array_pop(parser->nodes);
-    } else if (parse_match(parser, TOK_LCURLY)) {
+    } else if (parser->current.kind == TOK_COLON &&
+               parse_peek(parser) == TOK_LCURLY) {
+        parse_advance(parser);
+        parse_advance(parser);
+
         // Struct literal.
         node->kind = NODE_STRUCT_LIT;
         while (!parse_match(parser, TOK_RCURLY) && !parser->panic) {
@@ -1076,8 +1079,7 @@ graph_node(Node *node) {
         case NODE_FUNCALL:
         case NODE_RETURN:
         case NODE_BLOCK:
-        case NODE_STRUCT_LIT:
-        case NODE_COMPOUND_TYPE: {
+        case NODE_STRUCT_LIT: {
             for (sz i = 0; i < array_size(node->elements); i++) {
                 Node *next = node->elements[i];
                 println("%d:e->%d:w;", node->id, next->id);