Add wip function typechecking

2 files changed, 82 insertions, 9 deletions

diff --git a/src/main.c b/src/main.c
index d442b98..4cde055 100644
--- a/src/main.c
+++ b/src/main.c
@@ -448,6 +448,15 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
             node->type = cstr("str");
             return node->type;
         } break;
+        case NODE_TYPE: {
+            TypeMap *type = find_type(scope, node->value.str);
+            if (!type) {
+                emit_semantic_error(a, node, cstr("unknown type"));
+                return cstr("");
+            }
+            node->type = type->val;
+            return node->type;
+        } break;
         case NODE_SYMBOL: {
             TypeMap *type = find_type(scope, node->value.str);
             if (type) {
@@ -481,6 +490,70 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
             node->type = type;
             return node->type;
         } break;
+        case NODE_RETURN: {
+            Type type;
+            for (sz i = 0; i < array_size(node->elements); i++) {
+                Node *expr = node->elements[i];
+                type = type_inference(a, expr, scope);
+            }
+            // TODO: this is incorrect, must return the inferred type, but what
+            // to do if we have multiple? This only considers single return
+            // values for now...
+            node->type = type;
+            return type;
+        } break;
+        case NODE_FUN: {
+            // TODO: we may want to do this and register a special table with
+            // function and formals...
+            // if (scope->parent != NULL) {
+            // //     Str symbol = node->func_name->value.str;
+            // //     if (symmap_lookup(&scope->symbols, symbol) != NULL) {
+            // //         eprintln(
+            // //             "%s:%d:%d: error: symbol '%s' already exists in "
+            // //             "current "
+            // //             "scope",
+            // //             a->file_name, node->func_name->line,
+            // //             node->func_name->col, symbol);
+            // //         return;
+            // //     }
+            // //     symmap_insert(&scope->symbols, symbol,
+            // //                   (Symbol){.kind = SYM_FUN, .name = symbol},
+            // //                   a->storage);
+            // }
+
+            node->type = cstr("nil");
+            scope = typescope_alloc(a, scope);
+            for (sz i = 0; i < array_size(node->func_params); i++) {
+                Node *param = node->func_params[i];
+                Str symbol = param->param_name->value.str;
+                Type type = param->param_type->value.str;
+                param->param_name->type =
+                    type_inference(a, param->param_type, scope);
+                param->type = param->param_name->type;
+                typemap_insert(&scope->types, symbol, type, a->storage);
+            }
+
+            for (sz i = 0; i < array_size(node->func_ret); i++) {
+                Node *ret = node->func_ret[i];
+                ret->type = type_inference(a, ret, scope);
+            }
+
+            node->type = cstr("nil");
+            if (node->func_body->kind == NODE_BLOCK) {
+                node = node->func_body;
+                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;
+                // TODO: ensure ALL return statements match the function
+                // prototype.
+            } else {
+                type_inference(a, node->func_body, scope);
+            }
+            return cstr("nil");
+        } break;
         default: {
             emit_semantic_error(a, node,
                                 cstr("type inference not implemented for this "
diff --git a/tests/semantics.bad b/tests/semantics.bad
index 5b5c971..47c4b88 100644
--- a/tests/semantics.bad
+++ b/tests/semantics.bad
@@ -28,10 +28,10 @@
 
 ; set single = 32
 
-cond {
-    1 == 2 = "hello"
-    else = "dong"
-}
+; cond {
+;     1 == 2 = "hello"
+;     else = "dong"
+; }
 
 ; enum test {
 ;     a = 1
@@ -48,7 +48,7 @@ cond {
 
 ; fun nested(): u32 {
 ;     fun adder(a: u32, b: u32): u32 a + b
-;     if (1 + 1) {
+;     if (1 + 1 == 2) {
 ;         {
 ;             let b = 32
 ;         }
@@ -110,10 +110,10 @@ cond {
 ;     1 + 1 + c
 ; }
 
-; This should err.
-; fun foo(): nil {
-;     1
-; }
+fun foo(a: int b: str): (f32, f64) {
+    return(1.0, 2.0)
+}
+
 ; let b = a
 ; let a = a
 ; set a = 10