Implement basic type inference for numbers and symbols

1 files changed, 48 insertions, 28 deletions

diff --git a/src/main.c b/src/main.c
index d244d37..3614e56 100644
--- a/src/main.c
+++ b/src/main.c
@@ -55,10 +55,7 @@ Str sym_kind_str[] = {
     [SYM_STRUCT_FIELD] = cstr("STRUCT FIELD "),
 };
 
-typedef struct Type {
-    Str name;
-    sz size;
-} Type;
+typedef Str Type;
 
 typedef struct Symbol {
     SymbolKind kind;
@@ -129,15 +126,21 @@ graph_scope(Scope *scope, Arena a) {
     print(
         "%d[shape=\"none\" label=<\
 <TABLE ALIGN=\"left\" STYLE=\"rounded\"  BORDER=\"1\" CELLBORDER=\"0\" CELLSPACING=\"0\" CELLPADDING=\"6\" COLUMNS=\"*\">\
-  <TR style=\"rounded\" ><TD COLSPAN=\"2\">ID: %d</TD></TR>",
+  <TR style=\"rounded\" ><TD COLSPAN=\"3\">ID: %d</TD></TR>",
         scope->id, scope->id);
     print(
-        "<TR ><TD ALIGN=\"left\" > NAME</TD><TD ALIGN=\"left\" > "
-        "KIND</TD></TR>");
+        "<TR ><TD ALIGN=\"left\" > NAME </TD><TD ALIGN=\"left\" > KIND "
+        "</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></TR>",
-            sym->val.name, sym_kind_str[sym->val.kind]);
+            "<TR><TD ALIGN=\"left\"> %s </TD><TD ALIGN=\"left\"> %s </TD><TD "
+            "ALIGN=\"left\"> %s </TD></TR>",
+            sym->val.name, sym_kind_str[sym->val.kind], type_name);
         SymbolMapIter field_iter = symmap_iterator(sym->val.fields, &a);
         SymbolMap *field = symmap_next(&field_iter, &a);
         while (field) {
@@ -182,8 +185,32 @@ graph_symbols(Scope **scopes, Arena a) {
     println("}");
 }
 
+void
+emit_semantic_error(Analyzer *a, Node *n, Str msg) {
+    eprintln("%s:%d:%d: error: %s", a->file_name, n->line, n->col, msg);
+}
+
 Type
 type_inference(Analyzer *a, Node *node, Scope *scope) {
+    assert(a);
+    assert(scope);
+    assert(node);
+    switch (node->kind) {
+        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;
+            }
+        } break;
+        default: {
+            emit_semantic_error(a, node,
+                                cstr("type inference not implemented for this "
+                                     "kind of expression"));
+        } break;
+    }
     return (Type){0};
 }
 
@@ -398,11 +425,17 @@ analyzer_symbols(Analyzer *a, Node *node, Scope *scope) {
                     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_inference(a, node->var_val, scope);
 
+            // 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:
@@ -451,26 +484,13 @@ symbolic_analysis(Analyzer *a, Parser *parser) {
 
     // 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)
+        cstr("u8"),  cstr("s8"),  cstr("u16"),  cstr("s16"), cstr("u32"),
+        cstr("s32"), cstr("u64"), cstr("s64"),  cstr("f32"), cstr("f64"),
+        cstr("ptr"), cstr("int"), cstr("uint"), cstr("str"),
     };
     for (sz i = 0; i < LEN(builtin_types); i++) {
         Type type = builtin_types[i];
-        typemap_insert(&scope->types, type.name, type, a->storage);
+        typemap_insert(&scope->types, type, type, a->storage);
     }
 
     // Str valid_int_types[] = {