Add compound types for anonymous struct fields

1 files changed, 32 insertions, 30 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",