Bugfixes for struct accessors

1 files changed, 45 insertions, 51 deletions

diff --git a/src/main.c b/src/main.c
index c8584e4..6d25b2d 100644
--- a/src/main.c
+++ b/src/main.c
@@ -13,6 +13,8 @@
 // TODO: match deconstruct structs
 // TODO: arrays and pointers
 // TODO: struct literals with compound types
+// FIXME: there may be an issue with shadowed structs sharing fields... we may
+// want to consider moving the fields to separate maps again...
 
 typedef enum ExecMode {
     RUN_NORMAL,
@@ -378,23 +380,19 @@ emit_semantic_error(Analyzer *a, Node *n, Str msg) {
 Type type_inference(Analyzer *a, Node *node, TypeScope *scope);
 
 void
-typecheck_field(Analyzer *a,
-                Node *node,
-                TypeScope *scope,
-                Str symbol,
-                StructMap *map) {
+typecheck_field(Analyzer *a, Node *node, TypeScope *scope, Str symbol) {
     // TODO: ensure the tables are filled properly.
     if (node->field_type->kind == NODE_COMPOUND_TYPE) {
         Str field_name = str_concat(symbol, cstr("."), a->storage);
         field_name = str_concat(field_name, node->value.str, a->storage);
-        if (structmap_lookup(&map, field_name)) {
+        if (structmap_lookup(&scope->structs, field_name)) {
             eprintln("%s:%d:%d: error: struct field '%s' already exists",
                      a->file_name, node->line, node->col, field_name);
         }
         Str type = cstr("\\{ ");
         for (sz i = 0; i < array_size(node->field_type->elements); i++) {
             Node *field = node->field_type->elements[i];
-            typecheck_field(a, field, scope, field_name, map);
+            typecheck_field(a, field, scope, field_name);
             type = str_concat(type, field->type, a->storage);
             type = str_concat(type, cstr(" "), a->storage);
         }
@@ -408,7 +406,7 @@ typecheck_field(Analyzer *a,
             eprintln("%s:%d:%d: error: unknown type '%s'", a->file_name,
                      node->field_type->line, node->field_type->col, field_type);
         }
-        if (structmap_lookup(&map, field_name)) {
+        if (structmap_lookup(&scope->structs, field_name)) {
             eprintln("%s:%d:%d: error: struct field '%s' already exists",
                      a->file_name, node->line, node->col, field_name);
         }
@@ -423,7 +421,7 @@ typecheck_field(Analyzer *a,
                     field_type);
             }
         }
-        structmap_insert(&map, field_name,
+        structmap_insert(&scope->structs, field_name,
                          (Struct){
                              .name = field_name,
                              .type = field_type,
@@ -584,11 +582,11 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
             node->type = cstr("nil");
             Str symbol = node->value.str;
             // TODO: make sure it didn't exist before.
-            StructMap *e = structmap_insert(
-                &scope->structs, symbol, (Struct){.name = symbol}, a->storage);
+            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];
-                typecheck_field(a, field, scope, symbol, e);
+                typecheck_field(a, field, scope, symbol);
             }
             typemap_insert(&scope->types, symbol, symbol, a->storage);
             return node->type;
@@ -597,18 +595,18 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
             node->type = cstr("nil");
             Str symbol = node->value.str;
             // TODO: make sure it didn't exist before.
-            EnumMap *e = enummap_insert(&scope->enums, symbol,
-                                        (Enum){
-                                            .name = symbol,
-                                            .val = node->field_val,
-                                        },
-                                        a->storage);
+            enummap_insert(&scope->enums, symbol,
+                           (Enum){
+                               .name = symbol,
+                               .val = node->field_val,
+                           },
+                           a->storage);
             for (sz i = 0; i < array_size(node->struct_field); i++) {
                 Node *field = node->struct_field[i];
                 Str field_name = str_concat(symbol, cstr("."), a->storage);
                 field_name =
                     str_concat(field_name, field->value.str, a->storage);
-                if (enummap_lookup(&e, field_name)) {
+                if (enummap_lookup(&scope->enums, field_name)) {
                     eprintln("%s:%d:%d: error: enum field '%s' already exists",
                              a->file_name, field->line, field->col, field_name);
                 }
@@ -621,8 +619,8 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
                             field_name);
                     }
                 }
-                enummap_insert(&e, field_name, (Enum){.name = field_name},
-                               a->storage);
+                enummap_insert(&scope->enums, field_name,
+                               (Enum){.name = field_name}, a->storage);
                 field->type = cstr("int");
             }
             typemap_insert(&scope->types, symbol, symbol, a->storage);
@@ -899,28 +897,39 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
                          a->file_name, node->line, node->col, name);
                 return cstr("");
             }
+
+            StrSet *set = NULL;
             for (sz i = 0; i < array_size(node->elements); i++) {
                 Node *next = node->elements[i];
-                Str field_name = next->value.str;
-                FieldMap *field = fieldmap_lookup(&s->val.fields, field_name);
-                if (!field) {
+                Str field_name = str_concat(name, cstr("."), a->storage);
+                field_name =
+                    str_concat(field_name, next->value.str, a->storage);
+
+                if (strset_lookup(&set, field_name)) {
                     eprintln(
-                        "%s:%d:%d: error: unknown struct field for symbol '%s'",
+                        "%s:%d:%d: error: field '%s' already present in struct "
+                        "literal",
                         a->file_name, next->line, next->col, field_name);
                 } else {
-                    if (next->field_val) {
-                        Type type = type_inference(a, next->field_val, scope);
-                        if (!str_eq(type, field->val.type)) {
-                            eprintln(
-                                "%s:%d:%d: error: mismatched types in struct "
-                                "value "
-                                "for '%s.%s': %s expected %s",
-                                a->file_name, next->line, next->col, name,
-                                field_name, type, field->val.type);
-                        }
+                    strset_insert(&set, field_name, a->storage);
+                }
+
+                StructMap *field = find_struct(scope, field_name);
+                if (!field) {
+                    eprintln("%s:%d:%d: error: unknown struct field '%s'",
+                             a->file_name, next->line, next->col, field_name);
+                } else {
+                    Type type = type_inference(a, next->field_val, scope);
+                    if (!str_eq(type, field->val.type)) {
+                        eprintln(
+                            "%s:%d:%d: error: mismatched types in struct "
+                            "literal for '%s': %s expected %s ",
+                            a->file_name, next->line, next->col, field_name,
+                            type, field->val.type);
                     }
-                    next->type = field->val.type;
+                    next->type = type;
                 }
+                // TODO: nested fields.
             }
             node->type = name;
             return node->type;
@@ -1088,21 +1097,6 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
 
 void
 analyzer_symbols(Analyzer *a, Node *node, Scope *scope) {
-    // TODO: Struct field initializers need to be checked... when we
-    // get to that. Note that for checking symbol chains, we need to
-    // first perform type analysis to know the variable is a certain
-    // type:
-    //
-    // struct T {
-    //     field_a: int
-    //     field_b: int
-    // }
-    // let a:my_struct
-    // set a.field_a = 1
-    //
-    // In this case we need to know that variable a is of type `T` which
-    // contains fields `field_a` and `field_b`.
-    //
     assert(a);
     assert(scope);
     if (!node) {