Add wip function typechecking

1 files changed, 73 insertions, 0 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 "