Start implementing the typechecker

2 files changed, 158 insertions, 6 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) {