Start basic type checking/inference

2 files changed, 91 insertions, 123 deletions

diff --git a/src/main.c b/src/main.c
index 2d2e04d..d244d37 100644
--- a/src/main.c
+++ b/src/main.c
@@ -55,6 +55,11 @@ Str sym_kind_str[] = {
     [SYM_STRUCT_FIELD] = cstr("STRUCT FIELD "),
 };
 
+typedef struct Type {
+    Str name;
+    sz size;
+} Type;
+
 typedef struct Symbol {
     SymbolKind kind;
     Str name;
@@ -62,11 +67,13 @@ typedef struct Symbol {
 } Symbol;
 
 MAPDEF(SymbolMap, symmap, Str, Symbol, str_hash, str_eq)
+MAPDEF(TypeMap, typemap, Str, Type, str_hash, str_eq)
 
 typedef struct Scope {
     sz id;
     sz depth;
     SymbolMap *symbols;
+    TypeMap *types;
     struct Scope *parent;
 } Scope;
 
@@ -100,6 +107,18 @@ find_symbol(Scope *scope, Str symbol) {
     return NULL;
 }
 
+TypeMap *
+find_type(Scope *scope, Str type) {
+    while (scope != NULL) {
+        TypeMap *val = typemap_lookup(&scope->types, type);
+        if (val != NULL) {
+            return val;
+        }
+        scope = scope->parent;
+    }
+    return NULL;
+}
+
 void
 graph_scope(Scope *scope, Arena a) {
     if (!scope->symbols) {
@@ -163,6 +182,11 @@ graph_symbols(Scope **scopes, Arena a) {
     println("}");
 }
 
+Type
+type_inference(Analyzer *a, Node *node, Scope *scope) {
+    return (Type){0};
+}
+
 void
 analyzer_symbols(Analyzer *a, Node *node, Scope *scope) {
     // TODO: Struct field initializers need to be checked... when we
@@ -197,6 +221,7 @@ analyzer_symbols(Analyzer *a, Node *node, Scope *scope) {
                         "scope",
                         a->file_name, node->func_name->line,
                         node->func_name->col, symbol);
+                    return;
                 }
                 symmap_insert(&scope->symbols, symbol,
                               (Symbol){.kind = SYM_FUN, .name = symbol},
@@ -272,6 +297,7 @@ analyzer_symbols(Analyzer *a, Node *node, Scope *scope) {
                         "%s:%d:%d: error: enum field '%s.%s' already exists",
                         a->file_name, field->line, field->col, symbol,
                         field_name);
+                    return;
                 }
                 Symbol s =
                     (Symbol){.kind = node->kind == NODE_ENUM ? SYM_ENUM_FIELD
@@ -322,6 +348,7 @@ analyzer_symbols(Analyzer *a, Node *node, Scope *scope) {
                     "%s:%d:%d: error: symbol '%s' doesn't exists in current "
                     " scope ",
                     a->file_name, node->line, node->col, symbol);
+                return;
             }
             for (sz i = 0; i < array_size(node->elements); i++) {
                 Node *expr = node->elements[i];
@@ -336,6 +363,7 @@ analyzer_symbols(Analyzer *a, Node *node, Scope *scope) {
                     "%s:%d:%d: error: symbol '%s' doesn't exists in current "
                     " scope ",
                     a->file_name, node->line, node->col, symbol);
+                return;
             }
             // TODO: Resolve symbol chains.
         } break;
@@ -354,128 +382,29 @@ analyzer_symbols(Analyzer *a, Node *node, Scope *scope) {
                     " scope ",
                     a->file_name, node->var_name->line, node->var_name->col,
                     symbol);
+                return;
             }
             symmap_insert(&scope->symbols, symbol,
                           (Symbol){.kind = SYM_VAR, .name = symbol},
                           a->storage);
-        } break;
-        // Binary ops
-        case NODE_ADD:
-        case NODE_SUB:
-        case NODE_DIV:
-        case NODE_MUL:
-        case NODE_MOD:
-        case NODE_NOT:
-        case NODE_AND:
-        case NODE_OR:
-        case NODE_EQ:
-        case NODE_NEQ:
-        case NODE_LT:
-        case NODE_GT:
-        case NODE_LE:
-        case NODE_GE:
-        case NODE_BITNOT:
-        case NODE_BITAND:
-        case NODE_BITOR:
-        case NODE_BITLSHIFT:
-        case NODE_BITRSHIFT: {
-            analyzer_symbols(a, node->left, scope);
-            analyzer_symbols(a, node->right, scope);
-        } break;
-        default: break;
-    }
-}
-
-void
-propagate_type(Analyzer *a, Node *node, Scope *scope) {
-    if (!node) {
-        return;
-    }
-    switch (node->kind) {
-        // case NODE_LET: {
-        // } break;
-        // Binary ops
-        case NODE_NUM_INT:
-        case NODE_NUM_UINT: {
-            // Check if the terminal correspond to an integer numeric type.
-        } break;
-        case NODE_ADD:
-        case NODE_SUB:
-        case NODE_DIV:
-        case NODE_MUL:
-        case NODE_MOD:
-        case NODE_NOT:
-        case NODE_AND:
-        case NODE_OR:
-        case NODE_EQ:
-        case NODE_NEQ:
-        case NODE_LT:
-        case NODE_GT:
-        case NODE_LE:
-        case NODE_GE:
-        case NODE_BITNOT:
-        case NODE_BITAND:
-        case NODE_BITOR:
-        case NODE_BITLSHIFT:
-        case NODE_BITRSHIFT: {
-            if (node->left) {
-                node->left->type = node->type;
-                propagate_type(a, node->left, scope);
-            }
-            if (node->right) {
-                node->right->type = node->type;
-                propagate_type(a, node->right, scope);
-            }
-        } break;
-        default: break;
-    }
-}
-
-void
-analyzer_typecheck(Analyzer *a, Node *node, Scope *scope) {
-    assert(a);
-    assert(scope);
-    if (!node) {
-        return;
-    }
-    switch (node->kind) {
-        case NODE_NUM_INT:
-        case NODE_NUM_UINT: {
-            // TODO: Check if the terminal correspond to an integer numeric type.
-            // printf("DING\n");
-        } break;
-        case NODE_LET: {
-            // Check the value first to avoid recursive symbol usage.
-            // analyzer_symbols(a, node->var_val, scope);
 
             if (node->var_type) {
-                Str type = node->var_type->value.str;
-                // TODO: register type on symbol table?
-                // println("found let type: %s", type);
-                // Propagate down.
-                if (node->var_val) {
-                    node->var_val->type = type;
-                    propagate_type(a, node->var_val, scope);
-                    analyzer_typecheck(a, node->var_val, scope);
+                Str type_name = node->var_type->value.str;
+                TypeMap *type = find_type(scope, type_name);
+                if (type == NULL) {
+                    eprintln("%s:%d:%d: error: unknown type '%s'", a->file_name,
+                             node->var_type->line, node->var_type->col,
+                             type_name);
+                    return;
                 }
+                typemap_insert(&scope->types, symbol, type->val, a->storage);
                 return;
             }
-            // TODO: perform inference
-            if (node->var_val) {
-            //     analyzer_typecheck(a, node->var_val, scope);
-            }
-            // TODO: Type check
-            // if (symmap_lookup(&scope->symbols, symbol) != NULL) {
-            //     eprintln(
-            //         "%s:%d:%d: error: symbol '%s' already exists in current "
-            //         " scope ",
-            //         a->file_name, node->var_name->line, node->var_name->col,
-            //         symbol);
-            // }
-            // symmap_insert(&scope->symbols, symbol,
-            //               (Symbol){.kind = SYM_VAR, .name = symbol},
-            //               a->storage);
+            // We don't know the type for this symbol, perform inference.
+            type_inference(a, node->var_val, scope);
+
         } break;
+        // Binary ops
         case NODE_ADD:
         case NODE_SUB:
         case NODE_DIV:
@@ -495,12 +424,8 @@ analyzer_typecheck(Analyzer *a, Node *node, Scope *scope) {
         case NODE_BITOR:
         case NODE_BITLSHIFT:
         case NODE_BITRSHIFT: {
-            if (node->left) {
-                analyzer_typecheck(a, node->left, scope);
-            }
-            if (node->right) {
-                analyzer_typecheck(a, node->right, scope);
-            }
+            analyzer_symbols(a, node->left, scope);
+            analyzer_symbols(a, node->right, scope);
         } break;
         default: break;
     }
@@ -524,6 +449,48 @@ symbolic_analysis(Analyzer *a, Parser *parser) {
         symmap_insert(&scope->symbols, symbol, sym, a->storage);
     }
 
+    // Fill builtin types.
+    Type builtin_types[] = {
+        {cstr("u8"), 1},
+        {cstr("s8"), 1},
+        {cstr("u16"), 2},
+        {cstr("s16"), 2},
+        {cstr("u32"), 4},
+        {cstr("s32"), 4},
+        {cstr("u64"), 8},
+        {cstr("s64"), 8},
+        {cstr("f32"), 4},
+        {cstr("f64"), 8},
+        // TODO: down here is machine dependant, we could insert 0 for now and
+        // fill it up later maybe? Dunno.
+        {cstr("ptr"), 8},
+        {cstr("int"), 8},
+        {cstr("uint"), 8},
+        {cstr("str"), 8 + 8},  // (u8*, sz)
+    };
+    for (sz i = 0; i < LEN(builtin_types); i++) {
+        Type type = builtin_types[i];
+        typemap_insert(&scope->types, type.name, type, a->storage);
+    }
+
+    // Str valid_int_types[] = {
+    //     cstr("u8"),  cstr("u16"), cstr("u32"), cstr("u64"), cstr("s8"),
+    //     cstr("s16"), cstr("s32"), cstr("s64"), cstr("int"), cstr("uint"),
+    // };
+    // for (sz i = 0; i < LEN(valid_int_types); i++) {
+    //     Str type = valid_int_types[i];
+    //     strset_insert(&a->valid_int_types, type, a->storage);
+    // }
+
+    // Str valid_float_types[] = {
+    //     cstr("f32"),
+    //     cstr("f64"),
+    // };
+    // for (sz i = 0; i < LEN(valid_float_types); i++) {
+    //     Str type = valid_float_types[i];
+    //     strset_insert(&a->valid_float_types, type, a->storage);
+    // }
+
     // Find top level function declarations.
     for (sz i = 0; i < array_size(parser->nodes); i++) {
         Node *root = parser->nodes[i];
@@ -547,10 +514,10 @@ symbolic_analysis(Analyzer *a, Parser *parser) {
         Node *root = parser->nodes[i];
         analyzer_symbols(a, root, scope);
     }
-    for (sz i = 0; i < array_size(parser->nodes); i++) {
-        Node *root = parser->nodes[i];
-        analyzer_typecheck(a, root, scope);
-    }
+    // for (sz i = 0; i < array_size(parser->nodes); i++) {
+    //     Node *root = parser->nodes[i];
+    //     analyzer_typecheck(a, root, scope);
+    // }
 }
 
 void
diff --git a/tests/semantics.bad b/tests/semantics.bad
index c331ebc..ff024f7 100644
--- a/tests/semantics.bad
+++ b/tests/semantics.bad
@@ -1,4 +1,5 @@
-let a:u16 = (1 + 2 * 2) / 2
+; let a:int = (1 + 2 * 2) / 2
+let a:f32 = (1.0 + 2.0 * 2.0) / 2.0
 ; enum test {
 ;     a = 1
 ;     b