Add typechecking for enum fields

4 files changed, 81 insertions, 34 deletions

diff --git a/src/main.c b/src/main.c
index 4cbce58..f2c4d4f 100644
--- a/src/main.c
+++ b/src/main.c
@@ -6,15 +6,9 @@
 #include "lexer.c"
 #include "parser.c"
 #include "vm.c"
-// TODO: To typecheck IF we need to make sure it always returns a value if we
-// are using it as an expression. Not as straightforward as I initially
-// imagined! An alternative is implicit zero value in the previous case:
-//
-// let a = if (expr) 123
-//
-// If the expression evalueates to `true`, a will be 123, otherwise, 0.
-//
-// This pattern seems quite common in practice no?
+
+// TODO: typecheck structs
+// TODO: add field accessor for struct/enum symbols
 
 typedef enum ExecMode {
     RUN_NORMAL,
@@ -69,9 +63,21 @@ typedef struct Fun {
     Str return_type;
 } Fun;
 
+typedef struct Field {
+    Str name;
+    Node *val;
+} Field;
+
+typedef struct Enum {
+    Str name;
+    struct FieldMap *fields;
+} Enum;
+
 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(FieldMap, fieldmap, Str, Field, str_hash, str_eq)
 
 typedef struct Scope {
     sz id;
@@ -85,6 +91,7 @@ typedef struct TypeScope {
     Str name;
     TypeMap *types;
     FunMap *funcs;
+    EnumMap *enums;
     struct TypeScope *parent;
 } TypeScope;
 
@@ -471,6 +478,37 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
             node->type = cstr("nil");
             return node->type;
         } break;
+        case NODE_ENUM: {
+            node->type = cstr("nil");
+            Str symbol = node->value.str;
+            EnumMap *e = enummap_insert(&scope->enums, symbol,
+                                        (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;
+                if (fieldmap_lookup(&e->val.fields, field_name)) {
+                    eprintln(
+                        "%s:%d:%d: error: enum 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, cstr("int"))) {
+                        eprintln(
+                            "%s:%d:%d: error: non int enum 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, .val = field->field_val},
+                    a->storage);
+                field->type = cstr("int");
+            }
+            return node->type;
+        } break;
         case NODE_IF: {
             Type cond_type = type_inference(a, node->cond_if, scope);
             if (!str_eq(cond_type, cstr("bool"))) {
@@ -566,6 +604,10 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
             node->type = cstr("bool");
             return node->type;
         } break;
+        case NODE_NIL: {
+            node->type = cstr("nil");
+            return node->type;
+        } break;
         case NODE_NOT:
         case NODE_AND:
         case NODE_OR: {
diff --git a/tests/comparisons.bad b/tests/comparisons.bad
index 7bc5d33..512feac 100644
--- a/tests/comparisons.bad
+++ b/tests/comparisons.bad
@@ -7,7 +7,3 @@ true != false
 2 >= 1 && 2 > 1
 3 >= 3 || 4 <= 5
 4 < (5 + 6) == true
-
-nil != false
-nil != true
-nil != 1
diff --git a/tests/conditionals.bad b/tests/conditionals.bad
index b5ef61f..50d0cfc 100644
--- a/tests/conditionals.bad
+++ b/tests/conditionals.bad
@@ -5,7 +5,7 @@ if (true) "hello"
 let a = if (2 + 2 >= 4) 42
 
 ; We support a single if expression.
-let b = if (0xff == 255) "hello" else "world"
+let b = if (0xff == 0x32) "hello" else "world"
 
 ; ... but these can compound on each other
 if (1 < 2)      6
@@ -51,7 +51,7 @@ match (a) {
 ; Conditional `cond` statements are syntactic sugar for a chain of if-else
 ; statements.
 let msg:str = cond {
-    case a == b = "hello"
-    case a != f = "world"
-    else        = "what"
+    a == 1 = "hello"
+    a != 2 = "world"
+    else   = "what"
 }
diff --git a/tests/semantics.bad b/tests/semantics.bad
index 3479915..ee56c14 100644
--- a/tests/semantics.bad
+++ b/tests/semantics.bad
@@ -1,10 +1,19 @@
-fun add10(a: int, b: str): int {
-    a + 10
+enum weekdays {
+    mon = 1
+    tue
+    wed
+    thu
+    fri
+    sat
+    sun
 }
+; fun add10(a: int, b: str): int {
+;     a + 10
+; }
 
-fun foo(): int {
-    add10(1, "hello")
-}
+; fun foo(): int {
+;     add10(1, "hello")
+; }
 
 ; let a:f32 = (1.0 + 2.0 * 2.0) / 2.0
 
@@ -54,18 +63,18 @@ fun foo(): int {
 ; let a:my_struct
 ; set a.field_a = 1
 
-fun nested(): int {
-    fun adder(a: u32, b: u32): u32 {
-        a + b
-    }
-    if (1 + 1 == 2) {
-        let b = 15
-        5 + b
-    ;     {
-    ;         let b = 32
-    ;     }
-    }
-}
+; fun nested(): int {
+;     fun adder(a: u32, b: u32): u32 {
+;         a + b
+;     }
+;     if (1 + 1 == 2) {
+;         let b = 15
+;         {
+;             let c = 32
+;             5 + c
+;         }
+;     }
+; }
 
 ; enum field {
 ;     a