Change typechecking to be independent of the symbolic checking

2 files changed, 122 insertions, 52 deletions

diff --git a/src/main.c b/src/main.c
index 077039a..a66a40c 100644
--- a/src/main.c
+++ b/src/main.c
@@ -70,15 +70,20 @@ typedef struct Scope {
     sz id;
     sz depth;
     SymbolMap *symbols;
-    TypeMap *types;
     struct Scope *parent;
 } Scope;
 
+typedef struct TypeScope {
+    TypeMap *types;
+    struct TypeScope *parent;
+} TypeScope;
+
 typedef struct Analyzer {
     Arena *storage;
     Str file_name;
     sz scope_gen;
     Scope **scopes;
+    TypeScope **types;
     StrSet *numeric_types;
     StrSet *integer_types;
 } Analyzer;
@@ -94,6 +99,14 @@ scope_alloc(Analyzer *a, Scope *parent) {
     return scope;
 }
 
+TypeScope *
+typescope_alloc(Analyzer *a, TypeScope *parent) {
+    TypeScope *scope = arena_calloc(sizeof(TypeScope), a->storage);
+    scope->parent = parent;
+    array_push(a->types, scope, a->storage);
+    return scope;
+}
+
 SymbolMap *
 find_symbol(Scope *scope, Str symbol) {
     while (scope != NULL) {
@@ -107,7 +120,7 @@ find_symbol(Scope *scope, Str symbol) {
 }
 
 TypeMap *
-find_type(Scope *scope, Str type) {
+find_type(TypeScope *scope, Str type) {
     while (scope != NULL) {
         TypeMap *val = typemap_lookup(&scope->types, type);
         if (val != NULL) {
@@ -135,10 +148,6 @@ graph_scope(Scope *scope, Arena a) {
         "</TD><TD ALIGN=\"left\" > TYPE </TD></TR>");
     while (sym) {
         Str type_name = cstr("nil");
-        TypeMap *type = find_type(scope, sym->val.name);
-        if (type) {
-            type_name = type->val;
-        }
         print(
             "<TR><TD ALIGN=\"left\"> %s </TD><TD ALIGN=\"left\"> %s </TD><TD "
             "ALIGN=\"left\"> %s </TD></TR>",
@@ -193,14 +202,62 @@ emit_semantic_error(Analyzer *a, Node *n, Str msg) {
 }
 
 Type
-type_inference(Analyzer *a, Node *node, Scope *scope) {
+type_inference(Analyzer *a, Node *node, TypeScope *scope) {
     assert(a);
     assert(scope);
     assert(node);
     // NOTE: For now we are not going to do implicit numeric conversions.
     switch (node->kind) {
+        case NODE_LET: {
+            node->type = cstr("nil");
+            Str symbol = node->var_name->value.str;
+            if (node->var_type) {
+                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 cstr("");
+                }
+                if (node->var_val) {
+                    Type type = type_inference(a, node->var_val, scope);
+                    if (!type.size) {
+                        eprintln(
+                            "%s:%d:%d: error: can't bind `nil` to variable "
+                            "'%s'",
+                            a->file_name, node->var_type->line,
+                            node->var_type->col, symbol);
+                        return cstr("");
+                    }
+                    // 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("");
+                    }
+                }
+                typemap_insert(&scope->types, symbol, type->val, a->storage);
+                return node->type;
+            }
+
+            // We don't know the type for this symbol, perform inference.
+            Type type = type_inference(a, node->var_val, scope);
+            if (type.size) {
+                typemap_insert(&scope->types, symbol, type, a->storage);
+                node->var_name->type = type;
+            }
+            return node->type;
+        } break;
         case NODE_TRUE:
-        case NODE_FALSE: return cstr("bool");
+        case NODE_FALSE: {
+            node->type = cstr("bool");
+            return node->type;
+        } break;
         case NODE_NOT:
         case NODE_AND:
         case NODE_OR: {
@@ -208,17 +265,18 @@ type_inference(Analyzer *a, Node *node, Scope *scope) {
             if (!str_eq(left, cstr("bool"))) {
                 emit_semantic_error(a, node,
                                     cstr("expected bool on logic expression"));
-                return (Type){0};
+                return cstr("");
             }
             if (node->right) {
                 Type right = type_inference(a, node->right, scope);
                 if (!str_eq(right, cstr("bool"))) {
                     emit_semantic_error(
                         a, node, cstr("expected bool on logic expression"));
-                    return (Type){0};
+                    return cstr("");
                 }
             }
-            return cstr("bool");
+            node->type = cstr("bool");
+            return node->type;
         } break;
         case NODE_EQ:
         case NODE_NEQ:
@@ -231,9 +289,10 @@ type_inference(Analyzer *a, Node *node, Scope *scope) {
             if (!str_eq(left, right)) {
                 emit_semantic_error(
                     a, node, cstr("mismatched types on binary expression"));
-                return (Type){0};
+                return cstr("");
             }
-            return cstr("bool");
+            node->type = cstr("bool");
+            return node->type;
         } break;
         case NODE_BITNOT:
         case NODE_BITAND:
@@ -246,13 +305,15 @@ type_inference(Analyzer *a, Node *node, Scope *scope) {
                 !strset_lookup(&a->integer_types, right)) {
                 emit_semantic_error(
                     a, node, cstr("non integer type on bit twiddling expr"));
-                return (Type){0};
+                return cstr("");
             }
             if (!str_eq(left, right)) {
                 emit_semantic_error(
                     a, node, cstr("mismatched types on binary expression"));
-                return (Type){0};
+                return cstr("");
             }
+            node->type = left;
+            return node->type;
         } break;
         case NODE_ADD:
         case NODE_SUB:
@@ -265,31 +326,56 @@ type_inference(Analyzer *a, Node *node, Scope *scope) {
                 !strset_lookup(&a->numeric_types, right)) {
                 emit_semantic_error(
                     a, node, cstr("non numeric type on arithmetic expr"));
-                return (Type){0};
+                return cstr("");
             }
             if (!str_eq(left, right)) {
                 emit_semantic_error(
                     a, node, cstr("mismatched types on binary expression"));
-                return (Type){0};
+                return cstr("");
             }
-            return left;
+            node->type = left;
+            return node->type;
+        } break;
+        case NODE_NUM_UINT: {
+            node->type = cstr("uint");
+            return node->type;
+        } break;
+        case NODE_NUM_INT: {
+            node->type = cstr("int");
+            return node->type;
+        } break;
+        case NODE_NUM_FLOAT: {
+            node->type = cstr("f64");
+            return node->type;
+        } break;
+        case NODE_STRING: {
+            node->type = cstr("str");
+            return node->type;
         } break;
-        case NODE_NUM_UINT: return cstr("uint"); break;
-        case NODE_NUM_INT: return cstr("int"); break;
-        case NODE_NUM_FLOAT: return cstr("f64"); break;
         case NODE_SYMBOL: {
             TypeMap *type = find_type(scope, node->value.str);
             if (type) {
-                return type->val;
+                node->type = type->val;
+                return node->type;
             }
         } break;
+        case NODE_BLOCK: {
+            scope = typescope_alloc(a, scope);
+            Type type;
+            for (sz i = 0; i < array_size(node->elements); i++) {
+                Node *expr = node->elements[i];
+                type = type_inference(a, expr, scope);
+            }
+            node->type = type;
+            return node->type;
+        } break;
         default: {
             emit_semantic_error(a, node,
                                 cstr("type inference not implemented for this "
                                      "kind of expression"));
         } break;
     }
-    return (Type){0};
+    return cstr("");
 }
 
 void
@@ -492,28 +578,6 @@ analyzer_symbols(Analyzer *a, Node *node, Scope *scope) {
             symmap_insert(&scope->symbols, symbol,
                           (Symbol){.kind = SYM_VAR, .name = symbol},
                           a->storage);
-
-            if (node->var_type) {
-                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);
-                // TODO: Typecheck the expression if we have it.
-                // if (node->var_val) ...
-                return;
-            }
-
-            // We don't know the type for this symbol, perform inference.
-            Type type = type_inference(a, node->var_val, scope);
-            if (type.size) {
-                typemap_insert(&scope->types, symbol, type, a->storage);
-                node->var_name->type = type;
-            }
         } break;
         // Binary ops
         case NODE_ADD:
@@ -545,6 +609,7 @@ analyzer_symbols(Analyzer *a, Node *node, Scope *scope) {
 void
 symbolic_analysis(Analyzer *a, Parser *parser) {
     Scope *scope = scope_alloc(a, NULL);
+    TypeScope *types = typescope_alloc(a, NULL);
     assert(a);
     assert(parser);
     assert(scope);
@@ -566,7 +631,7 @@ symbolic_analysis(Analyzer *a, Parser *parser) {
         cstr("uint"), cstr("str"), cstr("bool"), cstr("nil")};
     for (sz i = 0; i < LEN(builtin_types); i++) {
         Type type = builtin_types[i];
-        typemap_insert(&scope->types, type, type, a->storage);
+        typemap_insert(&types->types, type, type, a->storage);
     }
     Type numeric_types[] = {
         cstr("u8"),  cstr("s8"),  cstr("u16"),  cstr("s16"), cstr("u32"),
@@ -608,6 +673,7 @@ symbolic_analysis(Analyzer *a, Parser *parser) {
     // Recursively fill symbol tables.
     for (sz i = 0; i < array_size(parser->nodes); i++) {
         Node *root = parser->nodes[i];
+        type_inference(a, root, types);
         analyzer_symbols(a, root, scope);
     }
     // for (sz i = 0; i < array_size(parser->nodes); i++) {
diff --git a/tests/semantics.bad b/tests/semantics.bad
index d1effe4..158cec6 100644
--- a/tests/semantics.bad
+++ b/tests/semantics.bad
@@ -1,12 +1,16 @@
 ; let a:f32 = (1.0 + 2.0 * 2.0) / 2.0
 
-let a:int = (1 + 2 * 2) / 2
-let b = 1
-let c = b
-let d = 1 + 2 * 4
-let e = 1 <= 2
-let booleans = !true && false || (1 <= 2)
+let annotated:int = (1 + 2 * 2) / 2
+let numbers = 1
+let symbols = numbers
+let arith = 1 + 2 * 4
+let cmp = 1 <= 2
+let logic = !true && false || (1 <= 2)
 let bits = 0xff & 0b00001111
+let block = {
+    let a = 1 + 2
+    a + 3
+}
 
 ; enum test {
 ;     a = 1