Start implementing the typechecker

3 files changed, 225 insertions, 59 deletions

diff --git a/src/main.c b/src/main.c
index 60203d5..2c2cc2d 100644
--- a/src/main.c
+++ b/src/main.c
@@ -6,6 +6,15 @@
 #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?
 
 typedef enum ExecMode {
     RUN_NORMAL,
@@ -156,6 +165,21 @@ graph_symbols(Scope **scopes, Arena a) {
 
 void
 analyzer_symbols(Analyzer *a, Node *node, Scope *scope) {
+    // TODO: Struct field initializers need to be checked... when we
+    // get to that. Note that for checking symbol chains, we need to
+    // first perform type analysis to know the variable is a certain
+    // type:
+    //
+    // struct T {
+    //     field_a: int
+    //     field_b: int
+    // }
+    // let a:my_struct
+    // set a.field_a = 1
+    //
+    // In this case we need to know that variable a is of type `T` which
+    // contains fields `field_a` and `field_b`.
+    //
     assert(a);
     assert(scope);
     if (!node) {
@@ -214,12 +238,8 @@ analyzer_symbols(Analyzer *a, Node *node, Scope *scope) {
                 analyzer_symbols(a, expr, scope);
             }
         } break;
-            // TODO: Struct field initializers need to be checked... when we
-            // get to that.
-            // case NODE_VAL_FIELD:
-            // case NODE_ENUM:
-            // case NODE_STRUCT:
-            // case NODE_STRUCT_LIT:
+        // TODO:
+        // case NODE_STRUCT_LIT:
         case NODE_BLOCK: {
             Scope *next = scope_alloc(a, scope);
             node->scope = scope;
@@ -367,6 +387,126 @@ analyzer_symbols(Analyzer *a, Node *node, Scope *scope) {
 }
 
 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);
+                }
+                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);
+        } 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) {
+                analyzer_typecheck(a, node->left, scope);
+            }
+            if (node->right) {
+                analyzer_typecheck(a, node->right, scope);
+            }
+        } break;
+        default: break;
+    }
+}
+
+void
 symbolic_analysis(Analyzer *a, Parser *parser) {
     Scope *scope = scope_alloc(a, NULL);
     assert(a);
@@ -407,6 +547,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);
+    }
 }
 
 void
@@ -484,6 +628,10 @@ process_file(Str path) {
     if (mode == PRINT_SYMTABLES) {
         graph_symbols(analyzer.scopes, lexer_arena);
     }
+    if (mode == PRINT_SEMANTIC) {
+        graph_ast(parser.nodes);
+        goto stop;
+    }
 
 #if DEBUG == 1
     for (sz i = 0; i < array_size(analyzer.scopes); i++) {
diff --git a/src/parser.c b/src/parser.c
index 67fc739..7864264 100644
--- a/src/parser.c
+++ b/src/parser.c
@@ -193,6 +193,7 @@ typedef struct Node {
     };
     bool is_ptr;
     struct Scope *scope;
+    Str type;
 } Node;
 
 //
@@ -1018,6 +1019,9 @@ graph_node(Node *node) {
         } break;
         default: break;
     }
+    if (node->type.size > 0) {
+        print("| Type: %s", node->type);
+    }
     println("\"];");
 
     switch (node->kind) {
diff --git a/tests/semantics.bad b/tests/semantics.bad
index d050426..c331ebc 100644
--- a/tests/semantics.bad
+++ b/tests/semantics.bad
@@ -1,66 +1,80 @@
-fun nested(): u32 {
-    fun adder(a: u32, b: u32): u32 a + b
-    if (1 + 1) {
-        {
-            let b = 32
-        }
-    }
-    adder(1,2)
-}
+let a:u16 = (1 + 2 * 2) / 2
+; enum test {
+;     a = 1
+;     b
+; }
+; ; Resolve struct accessors.
+; struct my_struct {
+;     field_a: int
+;     field_b: int
+; }
 
-enum field {
-    a
-    b
-}
+; let a:my_struct
+; set a.field_a = 1
 
-struct vec {
-    a: int
-    b: int
-}
+; fun nested(): u32 {
+;     fun adder(a: u32, b: u32): u32 a + b
+;     if (1 + 1) {
+;         {
+;             let b = 32
+;         }
+;     }
+;     adder(1,2)
+; }
 
-fun foo(): nil {
-    bar()
-}
+; enum field {
+;     a
+;     b
+; }
 
-fun bar(): nil {
-    foo()
-}
+; struct vec {
+;     a: int
+;     b: int
+; }
 
-; There are some builtint functions.
-println("hello world")
+; fun foo(): nil {
+;     bar()
+; }
 
-; Let/set.
-let num = 1
-set num = 2
-set num = 0 + num
+; fun bar(): nil {
+;     foo()
+; }
+
+; ; There are some builtint functions.
+; println("hello world")
+
+; ; Let/set.
+; let num = 1
+; set num = 2
+; set num = 0 + num
 
-; Loops and conditionals.
-if (num) 3 else 1
-let val = if (2 + num == 4) num else num
-if (true) {
-    let c = 1
-    1 + 1 + c
-}
+; ; Loops and conditionals.
+; if (num) 3 else 1
+; let val = if (2 + num == 4) num else num
+; if (true) {
+;     let c = 1
+;     1 + 1 + c
+; }
 
-fun testmatches(): nil {
-    match (num) {
-        case 1 = 23
-        case 2 = num
-        else = num
-    }
+; fun testmatches(): nil {
+;     match (num) {
+;         case 1 = 23
+;         case 2 = num
+;         else = num
+;     }
 
-    cond {
-        case 1 == 1 = 23
-        case 2 != 1 = num
-        else = num
-    }
-}
+;     cond {
+;         case 1 == 1 = 23
+;         case 2 != 1 = num
+;         else = num
+;     }
+; }
 
-while (num == 1) num
-while (true) {
-    let c = 1
-    1 + 1 + c
-}
+; while (num == 1) num
+; while (true) {
+;     let c = 1
+;     1 + 1 + c
+; }
 
 ; This should err.
 ; fun foo(): nil {