Add struct literals typechecking

2 files changed, 50 insertions, 10 deletions

diff --git a/src/main.c b/src/main.c
index 33d193b..6c3f3a5 100644
--- a/src/main.c
+++ b/src/main.c
@@ -12,6 +12,8 @@
 // TODO: nested structs
 // TODO: unions
 // TODO: match deconstruct structs
+// TODO: arrays and pointers
+// TODO: struct literals
 
 typedef enum ExecMode {
     RUN_NORMAL,
@@ -486,13 +488,18 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
                     }
                     // TODO: Consider compatible types.
                     if (!str_eq(type, type_name)) {
-                        eprintln(
-                            "%s:%d:%d: error: type mismatch, trying to assing "
-                            "%s"
-                            " to a variable of type %s",
-                            a->file_name, node->var_type->line,
-                            node->var_type->col, type, type_name);
-                        return cstr("");
+                        // Special case, enums can be treated as ints.
+                        EnumMap *e = find_enum(scope, type_name);
+                        if (!(e && str_eq(type, cstr("int")))) {
+                            eprintln(
+                                "%s:%d:%d: error: type mismatch, trying to "
+                                "assing "
+                                "%s"
+                                " to a variable of type %s",
+                                a->file_name, node->var_type->line,
+                                node->var_type->col, type, type_name);
+                            return cstr("");
+                        }
                     }
                 }
                 typemap_insert(&scope->types, symbol, type->val, a->storage);
@@ -515,8 +522,7 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
                     "%s:%d:%d: error: type mismatch, trying to assing "
                     "%s"
                     " to a variable of type %s",
-                    a->file_name, node->line, node->col,
-                    val, name);
+                    a->file_name, node->line, node->col, val, name);
                 return cstr("");
             }
             node->type = cstr("nil");
@@ -849,6 +855,40 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
             node->type = type->val;
             return node->type;
         } break;
+        case NODE_STRUCT_LIT: {
+            Str name = node->value.str;
+            StructMap *s = find_struct(scope, name);
+            if (!s) {
+                eprintln("%s:%d:%d: error: unknown struct type '%s'",
+                         a->file_name, node->line, node->col, name);
+                return cstr("");
+            }
+            for (sz i = 0; i < array_size(node->elements); i++) {
+                Node *next = node->elements[i];
+                Str field_name = next->field_name->value.str;
+                FieldMap *field = fieldmap_lookup(&s->val.fields, field_name);
+                if (!field) {
+                    eprintln(
+                        "%s:%d:%d: error: unknown struct field for symbol '%s'",
+                        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);
+                        }
+                    }
+                    next->type = field->val.type;
+                }
+            }
+            node->type = name;
+            return node->type;
+        } break;
         case NODE_FUNCALL: {
             Str symbol = node->value.str;
             FunMap *fun = find_fun(scope, symbol);
diff --git a/src/parser.c b/src/parser.c
index 7b49b55..b08c82a 100644
--- a/src/parser.c
+++ b/src/parser.c
@@ -959,7 +959,7 @@ parse_symbol(Parser *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);
+            field->field_val = array_pop(parser->nodes);
             array_push(node->elements, field, parser->storage);
         }
     } else if (parse_match(parser, TOK_LSQUARE)) {