Add struct literals

1 files changed, 33 insertions, 34 deletions

diff --git a/src/main.c b/src/main.c
index 3466f44..558e0fc 100644
--- a/src/main.c
+++ b/src/main.c
@@ -113,11 +113,11 @@ Str node_str[] = {
     [NODE_TRUE] = cstr("TRUE"),
     [NODE_FALSE] = cstr("FALSE"),
     [NODE_NIL] = cstr("NIL"),
-    [NODE_STRUCT_LIT] = cstr("STRUCT LITERAL"),
+    [NODE_STRUCT_LIT] = cstr("STRUCT LIT"),
     // Keywords.
     [NODE_LET] = cstr("LET"),
     [NODE_SET] = cstr("SET"),
-    [NODE_STRUCT] = cstr("STRUCT"),
+    [NODE_STRUCT] = cstr("STRUCT DEF"),
     // Helpers.
     [NODE_TYPE] = cstr("TYPE"),
     [NODE_COMPOUND_TYPE] = cstr("COMPOUND TYPE"),
@@ -154,10 +154,7 @@ typedef struct Node {
             struct Node *field_type;
             struct Node *field_val;
         };
-        struct {
-            struct Node *struct_name;
-            struct Node **struct_field;
-        };
+        struct Node **struct_field;
         struct Node **elements;
     };
 } Node;
@@ -391,28 +388,6 @@ parse_literal(Parser *parser) {
     array_push(parser->nodes, node, parser->storage);
 }
 
-// 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;
@@ -458,6 +433,11 @@ parse_keyword(Parser *parser) {
                           cstr("expected symbol name on let expression"));
             parse_symbol(parser);
             node->var_name = array_pop(parser->nodes);
+            if (node->var_name->next) {
+                parse_emit_err(parser, prev,
+                               cstr("invalid symbol name in let expression"));
+                return;
+            }
 
             // Optional type declaration.
             if (parse_match(parser, TOK_COLON)) {
@@ -488,8 +468,8 @@ parse_keyword(Parser *parser) {
             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);
+            // Just consume this to avoid conflicts with struct literals.
+            node->value.sym = parser->previous.val;
 
             parse_consume(parser, TOK_LCURLY,
                           cstr("expected '{' on struct definition"));
@@ -503,6 +483,11 @@ parse_keyword(Parser *parser) {
                     cstr("expected symbol name on struct definition"));
                 parse_symbol(parser);
                 field->field_name = array_pop(parser->nodes);
+                if (field->field_name->next) {
+                    parse_emit_err(parser, prev,
+                                   cstr("invalid symbol name in struct field"));
+                    return;
+                }
                 parse_consume(
                     parser, TOK_COLON,
                     cstr("expected symbol name on struct definition"));
@@ -636,6 +621,22 @@ parse_symbol(Parser *parser) {
         if (!node) return;
         parse_symbol(parser);
         node->next = array_pop(parser->nodes);
+    } else if (parse_match(parser, TOK_LCURLY)) {
+        // Struct literal.
+        node = node_alloc(parser, NODE_STRUCT_LIT, prev);
+        if (!node) return;
+
+        while (!parse_match(parser, TOK_RCURLY) && !parser->panic) {
+            Node *field =
+                node_alloc(parser, NODE_STRUCT_FIELD, parser->current);
+            parse_consume(parser, TOK_SYMBOL, cstr("expected symbol name"));
+            parse_symbol(parser);
+            field->field_name = array_pop(parser->nodes);
+            parse_consume(parser, TOK_ASSIGN, cstr("expected assignment"));
+            parse_expr(parser, PREC_LOW);
+            field->field_type = array_pop(parser->nodes);
+            array_push(node->elements, field, parser->storage);
+        }
     } else {
         node = node_alloc(parser, NODE_SYMBOL, prev);
         if (!node) return;
@@ -667,6 +668,7 @@ graph_node(Node *node) {
         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_STRUCT: 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;
@@ -674,6 +676,7 @@ graph_node(Node *node) {
     println("\"];");
 
     switch (node->kind) {
+        case NODE_STRUCT_LIT:
         case NODE_COMPOUND_TYPE: {
             for (sz i = 0; i < array_size(node->elements); i++) {
                 Node *next = node->elements[i];
@@ -682,10 +685,6 @@ graph_node(Node *node) {
             }
         } 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);