Add funcall typechecking

2 files changed, 79 insertions, 42 deletions

diff --git a/src/main.c b/src/main.c
index 72ea88b..88d49ed 100644
--- a/src/main.c
+++ b/src/main.c
@@ -143,6 +143,18 @@ find_type(TypeScope *scope, Str type) {
     return NULL;
 }
 
+FunMap *
+find_fun(TypeScope *scope, Str type) {
+    while (scope != NULL) {
+        FunMap *val = funmap_lookup(&scope->funcs, type);
+        if (val != NULL) {
+            return val;
+        }
+        scope = scope->parent;
+    }
+    return NULL;
+}
+
 void
 graph_scope(Scope *scope, Arena a) {
     if (!scope->symbols) {
@@ -302,7 +314,7 @@ graph_symbols(Scope **scopes, Arena a) {
 void
 graph_types(TypeScope **scopes, Arena a) {
     if (scopes == NULL) return;
-    println("digraph symbols {");
+    println("digraph types {");
     println("rankdir=LR;");
     println("ranksep=\"0.95 equally\";");
     println("nodesep=\"0.5 equally\";");
@@ -664,19 +676,38 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
             return node->type;
         } break;
         case NODE_FUNCALL: {
-            // TODO: ...
-            // Str symbol = node->value.str;
-            // if (find_symbol(scope, symbol) == NULL) {
-            //     eprintln(
-            //         "%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];
-            //     analyzer_symbols(a, expr, scope);
-            // }
+            Str symbol = node->value.str;
+            FunMap *fun = find_fun(scope, symbol);
+            if (!fun) {
+                eprintln(
+                    "%s:%d:%d: error: function '%s' doesn't exist in current "
+                    " scope ",
+                    a->file_name, node->line, node->col, symbol);
+                return cstr("");
+            }
+            // Check that actual parameters typecheck
+            Type args = cstr("");
+            for (sz i = 0; i < array_size(node->elements); i++) {
+                Node *expr = node->elements[i];
+                Type type = type_inference(a, expr, scope);
+                args = str_concat(args, type, a->storage);
+                if (i != array_size(node->elements) - 1) {
+                    args = str_concat(args, cstr(","), a->storage);
+                }
+            }
+            if (!args.size) {
+                args = cstr("nil");
+            }
+            Str expected = fun->val.param_type;
+            bool err = !str_eq(args, expected);
+            if (err) {
+                eprintln(
+                    "%s:%d:%d: error: mismatched parameter types: %s expected "
+                    "%s",
+                    a->file_name, node->line, node->col, args, expected);
+            }
+            node->type = fun->val.return_type;
+            return node->type;
         } break;
         case NODE_BLOCK: {
             scope = typescope_alloc(a, scope);
@@ -794,8 +825,6 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
             typecheck_returns(a, node->func_body, ret_type);
 
             // TODO: should return statements be allowed on let blocks?
-            // TODO: insert this into a functions map in the current scope? need
-            // the arity and return parameters for funcalls.
             return node->type;
         } break;
         default: {
diff --git a/tests/semantics.bad b/tests/semantics.bad
index 3305222..3479915 100644
--- a/tests/semantics.bad
+++ b/tests/semantics.bad
@@ -1,23 +1,31 @@
-; let a:f32 = (1.0 + 2.0 * 2.0) / 2.0
-
-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
+fun add10(a: int, b: str): int {
+    a + 10
 }
 
-let maybe = if (1 == 2) {
-    32
-} else {
-    44
+fun foo(): int {
+    add10(1, "hello")
 }
 
+; let a:f32 = (1.0 + 2.0 * 2.0) / 2.0
+
+; 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
+; }
+
+; let maybe = if (1 == 2) {
+;     32
+; } else {
+;     44
+; }
+
 ; let single = if (true) {
 ;     123
 ; }
@@ -112,16 +120,16 @@ fun nested(): int {
 ;     let c = 1
 ;     1 + 1 + c
 ; }
-fun foo(a: int b: str): (f64, f64) {
-    fun bar(): nil {
-        println("ding")
-    }
-    if (a == 1) {
-        ; return("test", b)
-        return(3.0, 4.0)
-    }
-    return(1.0, 2.0)
-}
+; fun foo(a: int b: str): (f64, f64) {
+;     fun bar(): nil {
+;         println("ding")
+;     }
+;     if (a == 1) {
+;         ; return("test", b)
+;         return (3.0, 4.0)
+;     }
+;     return (1.0, 2.0)
+; }
 
 ; let b = a
 ; let a = a