Change typecheck returns to emit err on site

1 files changed, 16 insertions, 29 deletions

diff --git a/src/main.c b/src/main.c
index acc2b46..33ab4ed 100644
--- a/src/main.c
+++ b/src/main.c
@@ -201,10 +201,10 @@ emit_semantic_error(Analyzer *a, Node *n, Str msg) {
     eprintln("%s:%d:%d: error: %s", a->file_name, n->line, n->col, msg);
 }
 
-bool
-typecheck_returns(Node *node, Str expected) {
+void
+typecheck_returns(Analyzer *a, Node *node, Str expected) {
     if (!node) {
-        return true;
+        return;
     }
 
     // Traverse the tree again.
@@ -213,56 +213,44 @@ typecheck_returns(Node *node, Str expected) {
         case NODE_MATCH: {
             for (sz i = 0; i < array_size(node->match_cases); i++) {
                 Node *next = node->match_cases[i];
-                if (!typecheck_returns(next, expected)) {
-                    return false;
-                }
+                typecheck_returns(a, next, expected);
             }
         } break;
         case NODE_RETURN: {
-            return str_eq(node->type, expected);
+            bool err = !str_eq(node->type, expected);
+            if (err) {
+                emit_semantic_error(a, node, cstr("mismatched return types"));
+            }
         } break;
         case NODE_BLOCK: {
             for (sz i = 0; i < array_size(node->elements); i++) {
                 Node *next = node->elements[i];
-                if (!typecheck_returns(next, expected)) {
-                    return false;
-                }
+                typecheck_returns(a, next, expected);
             }
         } break;
         case NODE_IF: {
             if (node->cond_expr) {
-                if (!typecheck_returns(node->cond_expr, expected)) {
-                    return false;
-                }
+                typecheck_returns(a, node->cond_expr, expected);
             }
             if (node->cond_else) {
-                if (!typecheck_returns(node->cond_else, expected)) {
-                    return false;
-                }
+                typecheck_returns(a, node->cond_else, expected);
             }
         } break;
         case NODE_SET:
         case NODE_LET: {
             if (node->var_val) {
-                if (!typecheck_returns(node->var_val, expected)) {
-                    return false;
-                }
+                typecheck_returns(a, node->var_val, expected);
             }
         } break;
         default: {
             if (node->left) {
-                if (!typecheck_returns(node->left, expected)) {
-                    return false;
-                }
+                typecheck_returns(a, node->left, expected);
             }
             if (node->right) {
-                if (!typecheck_returns(node->right, expected)) {
-                    return false;
-                }
+                typecheck_returns(a, node->right, expected);
             }
         } break;
     }
-    return true;
 }
 
 Type
@@ -635,10 +623,9 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
             }
 
             // Ensure ALL return statements match the function prototype.
-            if (!typecheck_returns(node->func_body, ret_type)) {
-                emit_semantic_error(a, node, cstr("mismatched return types"));
-            }
+            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;