Add proper parsing of return statements and functions params

3 files changed, 41 insertions, 18 deletions

diff --git a/src/main.c b/src/main.c
index 4cde055..e93a538 100644
--- a/src/main.c
+++ b/src/main.c
@@ -491,16 +491,18 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
             return node->type;
         } break;
         case NODE_RETURN: {
-            Type type;
+            Type ret_type = cstr("(");
             for (sz i = 0; i < array_size(node->elements); i++) {
                 Node *expr = node->elements[i];
-                type = type_inference(a, expr, scope);
+                Type type = type_inference(a, expr, scope);
+                ret_type = str_concat(ret_type, type, a->storage);
+                if (i != array_size(node->elements) - 1) {
+                    ret_type = str_concat(ret_type, cstr(","), a->storage);
+                }
             }
-            // 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;
+            ret_type = str_concat(ret_type, cstr(")"), a->storage);
+            node->type = ret_type;
+            return node->type;
         } break;
         case NODE_FUN: {
             // TODO: we may want to do this and register a special table with
@@ -523,6 +525,7 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
 
             node->type = cstr("nil");
             scope = typescope_alloc(a, scope);
+            Type param_type = cstr("(");
             for (sz i = 0; i < array_size(node->func_params); i++) {
                 Node *param = node->func_params[i];
                 Str symbol = param->param_name->value.str;
@@ -531,12 +534,25 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
                     type_inference(a, param->param_type, scope);
                 param->type = param->param_name->type;
                 typemap_insert(&scope->types, symbol, type, a->storage);
+                param_type = str_concat(param_type, type, a->storage);
+                if (i != array_size(node->func_params) - 1) {
+                    param_type = str_concat(param_type, cstr(","), a->storage);
+                }
             }
+            param_type = str_concat(param_type, cstr(")"), a->storage);
+            node->fun_params = param_type;
 
+            Type ret_type = cstr("(");
             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 *expr = node->func_ret[i];
+                Type type = type_inference(a, expr, scope);
+                ret_type = str_concat(ret_type, type, a->storage);
+                if (i != array_size(node->func_ret) - 1) {
+                    ret_type = str_concat(ret_type, cstr(","), a->storage);
+                }
             }
+            ret_type = str_concat(ret_type, cstr(")"), a->storage);
+            node->fun_return = ret_type;
 
             node->type = cstr("nil");
             if (node->func_body->kind == NODE_BLOCK) {
diff --git a/src/parser.c b/src/parser.c
index b82579b..1283854 100644
--- a/src/parser.c
+++ b/src/parser.c
@@ -196,6 +196,8 @@ typedef struct Node {
     bool is_ptr;
     struct Scope *scope;
     Str type;
+    Str fun_params;
+    Str fun_return;
 } Node;
 
 //
@@ -1030,6 +1032,12 @@ graph_node(Node *node) {
     if (node->type.size > 0) {
         print("| Type: %s", node->type);
     }
+    if (node->fun_params.size > 0) {
+        print("| Params: %s", node->fun_params);
+    }
+    if (node->fun_return.size > 0) {
+        print("| Return: %s", node->fun_return);
+    }
     println("\"];");
 
     switch (node->kind) {
diff --git a/tests/semantics.bad b/tests/semantics.bad
index 47c4b88..5071d8b 100644
--- a/tests/semantics.bad
+++ b/tests/semantics.bad
@@ -90,16 +90,16 @@
 ;     1 + 1 + c
 ; }
 
-; fun testmatches(): nil {
-;     match (num) {
-;         case 1 = 23
-;         case 2 = num
-;         else = num
-;     }
+; fun testmatches(num: int): int {
+; ;     match (num) {
+; ;         case 1 = 23
+; ;         case 2 = num
+; ;         else = num
+; ;     }
 
 ;     cond {
-;         case 1 == 1 = 23
-;         case 2 != 1 = num
+;         1 == 1 = 23
+;         2 != 1 = num
 ;         else = num
 ;     }
 ; }
@@ -109,7 +109,6 @@
 ;     let c = 1
 ;     1 + 1 + c
 ; }
-
 fun foo(a: int b: str): (f32, f64) {
     return(1.0, 2.0)
 }