Add typechecking for enum fields

1 files changed, 51 insertions, 9 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: {