Add typechecking for structs and struct fields

2 files changed, 105 insertions, 8 deletions

diff --git a/src/main.c b/src/main.c
index d493d8e..9d8ace8 100644
--- a/src/main.c
+++ b/src/main.c
@@ -7,8 +7,10 @@
 #include "parser.c"
 #include "vm.c"
 
-// TODO: typecheck structs
-// TODO: add field accessor for struct symbols
+// TODO: in a let/set expression if the type is a struct check that we
+// are assigning a struct literal, not just a symbol.
+// TODO: nested structs
+// TODO: unions
 
 typedef enum ExecMode {
     RUN_NORMAL,
@@ -65,6 +67,7 @@ typedef struct Fun {
 
 typedef struct Field {
     Str name;
+    Str type;
     Node *val;
 } Field;
 
@@ -73,10 +76,16 @@ typedef struct Enum {
     struct FieldMap *fields;
 } Enum;
 
+typedef struct Struct {
+    Str name;
+    struct FieldMap *fields;
+} Struct;
+
 MAPDEF(SymbolMap, symmap, Str, Symbol, str_hash, str_eq)
 MAPDEF(TypeMap, typemap, Str, Type, str_hash, str_eq)
 MAPDEF(FunMap, funmap, Str, Fun, str_hash, str_eq)
 MAPDEF(EnumMap, enummap, Str, Enum, str_hash, str_eq)
+MAPDEF(StructMap, structmap, Str, Struct, str_hash, str_eq)
 MAPDEF(FieldMap, fieldmap, Str, Field, str_hash, str_eq)
 
 typedef struct Scope {
@@ -92,6 +101,7 @@ typedef struct TypeScope {
     TypeMap *types;
     FunMap *funcs;
     EnumMap *enums;
+    StructMap *structs;
     struct TypeScope *parent;
 } TypeScope;
 
@@ -174,6 +184,18 @@ find_enum(TypeScope *scope, Str type) {
     return NULL;
 }
 
+StructMap *
+find_struct(TypeScope *scope, Str type) {
+    while (scope != NULL) {
+        StructMap *val = structmap_lookup(&scope->structs, type);
+        if (val != NULL) {
+            return val;
+        }
+        scope = scope->parent;
+    }
+    return NULL;
+}
+
 void
 graph_scope(Scope *scope, Arena a) {
     if (!scope->symbols) {
@@ -490,9 +512,46 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
             node->type = cstr("nil");
             return node->type;
         } break;
+        case NODE_STRUCT: {
+            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);
+            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;
+            }
+            typemap_insert(&scope->types, symbol, symbol, a->storage);
+            return node->type;
+        } break;
         case NODE_ENUM: {
             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}, a->storage);
             for (sz i = 0; i < array_size(node->struct_field); i++) {
@@ -513,10 +572,11 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
                             field_name);
                     }
                 }
-                fieldmap_insert(
-                    &e->val.fields, field_name,
-                    (Field){.name = field_name, .val = field->field_val},
-                    a->storage);
+                fieldmap_insert(&e->val.fields, field_name,
+                                (Field){.name = field_name,
+                                        .type = cstr("int"),
+                                        .val = field->field_val},
+                                a->storage);
                 field->type = cstr("int");
             }
             typemap_insert(&scope->types, symbol, symbol, a->storage);
@@ -736,6 +796,7 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
                          a->file_name, node->line, node->col, symbol);
                 return cstr("");
             }
+
             EnumMap *e = find_enum(scope, type->val);
             if (e && str_eq(symbol, type->val)) {
                 if (!node->next) {
@@ -753,7 +814,27 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
                         a->file_name, node->line, node->col, symbol);
                     return cstr("");
                 }
-                node->next->type = symbol;
+                node->next->type = cstr("int");
+                node->type = type->val;
+                return node->type;
+            }
+
+            StructMap *s = find_struct(scope, type->val);
+            if (s && !str_eq(symbol, type->val)) {
+                if (node->next) {
+                    FieldMap *field =
+                        fieldmap_lookup(&s->val.fields, node->next->value.str);
+                    if (!field) {
+                        eprintln(
+                            "%s:%d:%d: error: unknown struct field for symbol "
+                            "'%s'",
+                            a->file_name, node->line, node->col, symbol);
+                        return cstr("");
+                    }
+                    node->next->type = field->val.type;
+                    node->type = type->val;
+                    return node->next->type;
+                }
             }
             node->type = type->val;
             return node->type;
diff --git a/tests/semantics.bad b/tests/semantics.bad
index 486f6c0..a6810a9 100644
--- a/tests/semantics.bad
+++ b/tests/semantics.bad
@@ -8,7 +8,23 @@ enum weekdays {
     sun
 }
 let a = weekdays.tue
-let b = a
+; let b = a
+
+struct item {
+    id: int
+    name: str
+}
+
+; let a: item = item {
+;     id = 1
+; }
+; let a: item = item ; this shouldn't work, or should it return the default val?
+let c: item
+set c.id = "hi"
+let d = c.id
+; set a.name = "hello"
+; let b = a.id
+; let c = a.name
 
 ; fun add10(a: int, b: str): int {
 ;     a + 10