Add struct literals typechecking

4 files changed, 106 insertions, 59 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)) {
diff --git a/tests/semantics.bad b/tests/semantics.bad
index 95e827b..60e47d1 100644
--- a/tests/semantics.bad
+++ b/tests/semantics.bad
@@ -1,27 +1,33 @@
-enum weekdays {
-    mon = 1
-    tue
-    wed
-    thu
-    fri
-    sat
-    sun
+struct vec {
+    x: f64
+    y: f64
+    z: f64
 }
-let a = weekdays.tue
-; 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 = 1
-let d = c.id
+let v = vec : { x = 1.0 }
+; enum weekdays {
+;     mon = 1
+;     tue
+;     wed
+;     thu
+;     fri
+;     sat
+;     sun
+; }
+; let a = weekdays.tue
+; ; 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 = 1
+; let d = c.id
 ; set a.name = "hello"
 ; let b = a.id
 ; let c = a.name
diff --git a/tests/variables.bad b/tests/variables.bad
index 88e04d1..34293dc 100644
--- a/tests/variables.bad
+++ b/tests/variables.bad
@@ -11,10 +11,11 @@ set c = (1 + 2 - 3)
 
 ; Struct definitions.
 struct vec {
-    x: f32
-    y: f32
-    z: f32
+    x: f64
+    y: f64
+    z: f64
 }
+let v = vec : { x = 2.0 y = 3.0 }
 
 ; Default values are allowed, including const expressions.
 struct person {
@@ -28,41 +29,41 @@ set player_a.name = "alex"
 set player_a.age = 32
 let player_b = player_a
 
-; Anonymous structs can also be declared inline.
-let user: { id: u64 name: str }
-set user.id = 10
-set user.name = "haxor"
-
 ; We can have anonymous struct fields.
 struct entity {
     pos: vec
     vel: vec
-    attr: {
-        id: u64
-        name: str
-    }
+    ; TODO: ...
+    ; attr: {
+    ;     id: u64
+    ;     name: str
+    ; }
 }
 
 ; Symbols followed by curly braces output struct literals.
 let particle = entity : {
     ; Two ways of initializing inner fields.
-    pos = vec : { x = 1 y = 2 }
-    attr.id = 1
-    attr.name = "particle"
+    pos = vec : { x = 1.0 y = 2.0 }
+    ; TODO: Get rid of this, unnecessary complexity on the implementation, let's
+    ; just do the top option.
+    ; attr.id = 1
+    ; attr.name = "particle"
 
     ; Missing initialization fields default to zero.
-    vel = vec : { y = -3 }
+    vel = vec : { y = -3.0 }
 }
+; let particle = entity : {}
+; TODO: Now we can get rid of parenthesis on if/while statements
 
-; We can have static arrays and have indexed access.
-let numbers: u32[0xff]
-set numbers[0] = 32
-set numbers[1] = 42
+; ; We can have static arrays and have indexed access.
+; let numbers: u32[0xff]
+; set numbers[0] = 32
+; set numbers[1] = 42
 
-; Arrays are syntactic sugar for pointers (@).
-let ptr:@u32 = numbers
-set ptr[10] = 33
+; ; Arrays are syntactic sugar for pointers (@).
+; let ptr:@u32 = numbers
+; set ptr[10] = 33
 
-; Strings hold a .mem and .size fields with the number of bytes it holds.
-let hello: str = "hello world"
-set c[1] = 'a' ; "hallo world"
+; ; Strings hold a .mem and .size fields with the number of bytes it holds.
+; let hello: str = "hello world"
+; set c[1] = 'a' ; "hallo world"