fixed multi depth dependencies

6 files changed, 155 insertions, 73 deletions

diff --git a/src/compiler/ast-tree.c b/src/compiler/ast-tree.c
index 22b1103..aee480d 100644
--- a/src/compiler/ast-tree.c
+++ b/src/compiler/ast-tree.c
@@ -1898,6 +1898,7 @@ bool isConst(AstTree *tree, AstTreeHelper *helper) {
   case AST_TREE_TOKEN_VALUE_FLOAT:
   case AST_TREE_TOKEN_VALUE_BOOL:
   case AST_TREE_TOKEN_KEYWORD_COMPTIME:
+  case AST_TREE_TOKEN_SCOPE:
     return true;
   case AST_TREE_TOKEN_KEYWORD_IF: {
     AstTreeIf *metadata = tree->metadata;
@@ -1935,7 +1936,6 @@ bool isConst(AstTree *tree, AstTreeHelper *helper) {
   case AST_TREE_TOKEN_OPERATOR_SMALLER:
   case AST_TREE_TOKEN_OPERATOR_GREATER_OR_EQUAL:
   case AST_TREE_TOKEN_OPERATOR_SMALLER_OR_EQUAL:
-  case AST_TREE_TOKEN_SCOPE:
     return false;
   case AST_TREE_TOKEN_VARIABLE: {
     AstTreeVariable *metadata = tree->metadata;
@@ -2157,7 +2157,8 @@ AstTree *getValue(AstTree *tree, AstTreeSetTypesHelper helper) {
   case AST_TREE_TOKEN_KEYWORD_WHILE:
   case AST_TREE_TOKEN_KEYWORD_COMPTIME:
   case AST_TREE_TOKEN_SCOPE: {
-    AstTree *value = runExpression(tree, helper.pages);
+    bool shouldRet = false;
+    AstTree *value = runExpression(tree, helper.pages, &shouldRet);
     if (value == NULL) {
       printError(tree->str_begin, tree->str_end, "Unknown error");
     }
@@ -2174,8 +2175,20 @@ AstTree *getValue(AstTree *tree, AstTreeSetTypesHelper helper) {
   UNREACHABLE;
 }
 
-bool isCircularDependencies(AstTreeHelper *helper, AstTreeVariable *variable,
-                            AstTree *tree) {
+bool isCircularDependencies(AstTreeHelper *helper, AstTreeVariable *variable) {
+  AstTreeVariables checkedVariables = {
+      .data = a404m_malloc(0),
+      .size = 0,
+  };
+  bool ret = isCircularDependenciesBack(helper, variable, variable->value,
+                                        &checkedVariables);
+  free(checkedVariables.data);
+  return ret;
+}
+
+bool isCircularDependenciesBack(AstTreeHelper *helper,
+                                AstTreeVariable *variable, AstTree *tree,
+                                AstTreeVariables *checkedVariables) {
   switch (tree->token) {
   case AST_TREE_TOKEN_SCOPE:
   case AST_TREE_TOKEN_TYPE_TYPE:
@@ -2203,7 +2216,8 @@ bool isCircularDependencies(AstTreeHelper *helper, AstTreeVariable *variable,
   case AST_TREE_TOKEN_OPERATOR_PLUS:
   case AST_TREE_TOKEN_OPERATOR_MINUS: {
     AstTreeSingleChild *metadata = tree->metadata;
-    return isCircularDependencies(helper, variable, metadata);
+    return isCircularDependenciesBack(helper, variable, metadata,
+                                      checkedVariables);
   }
   case AST_TREE_TOKEN_OPERATOR_ASSIGN:
   case AST_TREE_TOKEN_OPERATOR_SUM:
@@ -2218,24 +2232,31 @@ bool isCircularDependencies(AstTreeHelper *helper, AstTreeVariable *variable,
   case AST_TREE_TOKEN_OPERATOR_GREATER_OR_EQUAL:
   case AST_TREE_TOKEN_OPERATOR_SMALLER_OR_EQUAL: {
     AstTreeInfix *metadata = tree->metadata;
-    return isCircularDependencies(helper, variable, &metadata->left) ||
-           isCircularDependencies(helper, variable, &metadata->right);
+    return isCircularDependenciesBack(helper, variable, &metadata->left,
+                                      checkedVariables) ||
+           isCircularDependenciesBack(helper, variable, &metadata->right,
+                                      checkedVariables);
   }
   case AST_TREE_TOKEN_FUNCTION_CALL: {
     AstTreeFunctionCall *metadata = tree->metadata;
     for (size_t i = 0; i < metadata->parameters_size; ++i) {
-      if (isCircularDependencies(helper, variable, metadata->parameters[i])) {
+      if (isCircularDependenciesBack(helper, variable, metadata->parameters[i],
+                                     checkedVariables)) {
         return true;
       }
     }
-    return isCircularDependencies(helper, variable, metadata->function);
+    return isCircularDependenciesBack(helper, variable, metadata->function,
+                                      checkedVariables);
   }
   case AST_TREE_TOKEN_VARIABLE: {
     AstTreeVariable *metadata = tree->metadata;
     for (size_t index = 0; index < helper->variables[0]->size; ++index) {
       if (helper->variables[0]->data[index] == metadata) {
         for (size_t i = 0; i < helper->globalDeps[index].size; ++i) {
-          if (helper->globalDeps[index].data[i] == variable) {
+          AstTreeVariable *currentVariable = helper->globalDeps[index].data[i];
+          if (currentVariable == variable ||
+              isCircularDependenciesVariable(helper, variable, currentVariable,
+                                             checkedVariables)) {
             return true;
           }
         }
@@ -2257,10 +2278,46 @@ bool isCircularDependencies(AstTreeHelper *helper, AstTreeVariable *variable,
   UNREACHABLE;
 }
 
+bool isCircularDependenciesVariable(AstTreeHelper *helper,
+                                    AstTreeVariable *toBeFound,
+                                    AstTreeVariable *currentVariable,
+                                    AstTreeVariables *checkedVariables) {
+  for (size_t i = 0; i < checkedVariables->size; ++i) {
+    if (currentVariable == checkedVariables->data[i]) {
+      return false;
+    }
+  }
+
+  const size_t capacity = a404m_malloc_usable_size(checkedVariables->data) /
+                          sizeof(*checkedVariables->data);
+
+  if (capacity == checkedVariables->size) {
+    checkedVariables->data = a404m_realloc(checkedVariables->data,
+                                           (capacity + capacity / 2 + 1) *
+                                               sizeof(*checkedVariables->data));
+  }
+  checkedVariables->data[checkedVariables->size] = currentVariable;
+  checkedVariables->size += 1;
+
+  for (size_t index = 0; index < helper->variables[0]->size; ++index) {
+    if (helper->variables[0]->data[index] == currentVariable) {
+      for (size_t i = 0; i < helper->globalDeps[index].size; ++i) {
+        AstTreeVariable *var = helper->globalDeps[index].data[i];
+        if (var == toBeFound || isCircularDependenciesVariable(
+                                    helper, toBeFound, var, checkedVariables)) {
+          return true;
+        }
+      }
+      break;
+    }
+  }
+  return false;
+}
+
 bool setAllTypesRoot(AstTreeRoot *root, AstTreeHelper *helper) {
   for (size_t i = 0; i < root->variables.size; ++i) {
     AstTreeVariable *variable = root->variables.data[i];
-    if (isCircularDependencies(helper, variable, variable->value)) {
+    if (isCircularDependencies(helper, variable)) {
       printError(variable->name_begin, variable->name_end,
                  "Circular dependecies");
       return false;
diff --git a/src/compiler/ast-tree.h b/src/compiler/ast-tree.h
index cc66ede..19ff9e9 100644
--- a/src/compiler/ast-tree.h
+++ b/src/compiler/ast-tree.h
@@ -224,8 +224,11 @@ AstTree *makeTypeOf(AstTree *value);
 bool typeIsEqual(const AstTree *type0, const AstTree *type1);
 AstTree *getValue(AstTree *tree, AstTreeSetTypesHelper helper);
 
-bool isCircularDependencies(AstTreeHelper *helper, AstTreeVariable *variable,
-                            AstTree *tree);
+bool isCircularDependencies(AstTreeHelper *helper, AstTreeVariable *variable);
+bool isCircularDependenciesBack(AstTreeHelper *helper, AstTreeVariable *variable,
+                            AstTree *tree,AstTreeVariables *checkedVariables);
+bool isCircularDependenciesVariable(AstTreeHelper *helper, AstTreeVariable *toBeFound,
+                            AstTreeVariable *currentVariable,AstTreeVariables *checkedVariables);
 
 bool setAllTypesRoot(AstTreeRoot *root, AstTreeHelper *helper);
 bool setAllTypes(AstTree *tree, AstTreeSetTypesHelper helper,
diff --git a/src/compiler/parser.c b/src/compiler/parser.c
index 9d95c1d..d816ec9 100644
--- a/src/compiler/parser.c
+++ b/src/compiler/parser.c
@@ -136,7 +136,7 @@ static constexpr ParserOrder PARSER_ORDER[] = {
                     LEXER_TOKEN_SYMBOL_MODULO_ASSIGN, ),
     },
     {
-        .ltr = true,
+        .ltr = false,
         ORDER_ARRAY(LEXER_TOKEN_KEYWORD_RETURN, LEXER_TOKEN_KEYWORD_PRINT_U64,
                     LEXER_TOKEN_KEYWORD_COMPTIME, ),
     },
@@ -145,10 +145,9 @@ static constexpr ParserOrder PARSER_ORDER[] = {
         ORDER_ARRAY(LEXER_TOKEN_SYMBOL_EOL, LEXER_TOKEN_SYMBOL_COMMA, ),
     },
     {
-        .ltr = true,
-        ORDER_ARRAY(LEXER_TOKEN_KEYWORD_IF, LEXER_TOKEN_KEYWORD_WHILE, ),
+        .ltr = false,
+        ORDER_ARRAY(LEXER_TOKEN_KEYWORD_IF,LEXER_TOKEN_KEYWORD_WHILE, ),
     },
-
 };
 
 static constexpr size_t PARSER_ORDER_SIZE =
diff --git a/src/runner/runner.c b/src/runner/runner.c
index 47c825d..cf1c92e 100644
--- a/src/runner/runner.c
+++ b/src/runner/runner.c
@@ -191,13 +191,17 @@ AstTree *runAstTreeFunction(AstTree *tree, AstTree **arguments,
   pages.data[pages.size - 1]->data = a404m_malloc(0);
   pages.data[pages.size - 1]->size = 0;
 
+  bool shouldRet = false;
+
   for (size_t i = 0; i < arguments_size; ++i) {
     AstTreeVariable *variable = function->arguments.data[i];
-    AstTree *value = runExpression(arguments[i], &pages);
+    AstTree *value = runExpression(arguments[i], &pages, &shouldRet);
     runnerVariablePush(pages.data[pages.size - 1], variable);
     runnerVariableSetValue(&pages, variable, value);
   }
 
+  shouldRet = false;
+
   for (size_t i = arguments_size; i < function->arguments.size; ++i) {
     AstTreeVariable *variable = function->arguments.data[i];
     runnerVariablePush(pages.data[pages.size - 1], variable);
@@ -211,8 +215,8 @@ AstTree *runAstTreeFunction(AstTree *tree, AstTree **arguments,
   AstTree *ret = &AST_TREE_VOID_VALUE;
 
   for (size_t i = 0; i < function->scope.expressions_size; ++i) {
-    AstTree *r = runExpression(function->scope.expressions[i], &pages);
-    if (r) {
+    AstTree *r = runExpression(function->scope.expressions[i], &pages, &shouldRet);
+    if (shouldRet) {
       ret = r;
       break;
     }
@@ -224,15 +228,16 @@ AstTree *runAstTreeFunction(AstTree *tree, AstTree **arguments,
   return ret;
 }
 
-AstTree *runExpression(AstTree *expr, RunnerVariablePages *pages) {
+AstTree *runExpression(AstTree *expr, RunnerVariablePages *pages,
+                       bool *shouldRet) {
   switch (expr->token) {
   case AST_TREE_TOKEN_KEYWORD_PRINT_U64: {
     AstTreeSingleChild *metadata = expr->metadata;
-    AstTree *tree = runExpression(metadata, pages);
+    AstTree *tree = runExpression(metadata, pages, shouldRet);
     printf("%lu", (AstTreeInt)tree->metadata);
     astTreeDelete(tree);
+    return &AST_TREE_VOID_VALUE;
   }
-    return NULL;
   case AST_TREE_TOKEN_FUNCTION_CALL: {
     AstTreeFunctionCall *metadata = expr->metadata;
     if (metadata->function->token == AST_TREE_TOKEN_VARIABLE) {
@@ -249,16 +254,17 @@ AstTree *runExpression(AstTree *expr, RunnerVariablePages *pages) {
     if (metadata->left.token == AST_TREE_TOKEN_VARIABLE) {
       AstTreeVariable *left = metadata->left.metadata;
       runnerVariableSetValue(pages, left,
-                             runExpression(&metadata->right, pages));
+                             runExpression(&metadata->right, pages, shouldRet));
+      return copyAstTree(left->value);
     } else {
       UNREACHABLE;
     }
   }
-    return NULL;
   case AST_TREE_TOKEN_KEYWORD_RETURN: {
     AstTreeReturn *metadata = expr->metadata;
+    *shouldRet = true;
     if (metadata->value != NULL) {
-      return runExpression(metadata->value, pages);
+      return runExpression(metadata->value, pages, shouldRet);
     } else {
       return &AST_TREE_VOID_VALUE;
     }
@@ -266,18 +272,18 @@ AstTree *runExpression(AstTree *expr, RunnerVariablePages *pages) {
   case AST_TREE_TOKEN_VARIABLE_DEFINE: {
     AstTreeVariable *variable = expr->metadata;
     runnerVariableSetValue(pages, variable, copyAstTree(variable->value));
+    return &AST_TREE_VOID_VALUE;
   }
-    return NULL;
   case AST_TREE_TOKEN_KEYWORD_IF: {
     AstTreeIf *metadata = expr->metadata;
-    AstTree *condition = runExpression(metadata->condition, pages);
+    AstTree *condition = runExpression(metadata->condition, pages, shouldRet);
     AstTree *ret;
     if ((AstTreeBool)condition->metadata) {
-      ret = runExpression(metadata->ifBody, pages);
+      ret = runExpression(metadata->ifBody, pages, shouldRet);
     } else if (metadata->elseBody != NULL) {
-      ret = runExpression(metadata->elseBody, pages);
+      ret = runExpression(metadata->elseBody, pages, shouldRet);
     } else {
-      ret = NULL;
+      ret = &AST_TREE_VOID_VALUE;
     }
     astTreeDelete(condition);
     return ret;
@@ -285,20 +291,20 @@ AstTree *runExpression(AstTree *expr, RunnerVariablePages *pages) {
   case AST_TREE_TOKEN_KEYWORD_WHILE: {
     AstTreeWhile *metadata = expr->metadata;
     AstTree *ret = NULL;
-    while (true) {
-      AstTree *tree = runExpression(metadata->condition, pages);
+    while (!*shouldRet) {
+      AstTree *tree = runExpression(metadata->condition, pages, shouldRet);
       bool conti = (AstTreeBool)tree->metadata;
       astTreeDelete(tree);
       if (!conti) {
         break;
       }
-      ret = runExpression(metadata->body, pages);
+      ret = runExpression(metadata->body, pages, shouldRet);
     }
     return ret;
   }
   case AST_TREE_TOKEN_KEYWORD_COMPTIME: {
     AstTreeSingleChild *operand = expr->metadata;
-    return runExpression((AstTree *)operand, pages);
+    return runExpression((AstTree *)operand, pages, shouldRet);
   }
   case AST_TREE_TOKEN_SCOPE: {
     AstTreeScope *metadata = expr->metadata;
@@ -324,9 +330,9 @@ AstTree *runExpression(AstTree *expr, RunnerVariablePages *pages) {
       runnerVariablePush(newPages.data[newPages.size - 1], variable);
     }
 
-    AstTree *ret = NULL;
-    for (size_t i = 0; i < metadata->expressions_size; ++i) {
-      ret = runExpression(metadata->expressions[i], &newPages);
+    AstTree *ret = &AST_TREE_VOID_VALUE;
+    for (size_t i = 0; i < metadata->expressions_size && !*shouldRet; ++i) {
+      ret = runExpression(metadata->expressions[i], &newPages, shouldRet);
     }
     for (size_t i = 0; i < newPages.data[pages->size]->size; ++i) {
       if (newPages.data[pages->size]->data[i]->value) {
@@ -340,7 +346,8 @@ AstTree *runExpression(AstTree *expr, RunnerVariablePages *pages) {
     return ret;
   }
   case AST_TREE_TOKEN_OPERATOR_PLUS: {
-    AstTreeSingleChild *operand = runExpression(expr->metadata, pages);
+    AstTreeSingleChild *operand =
+        runExpression(expr->metadata, pages, shouldRet);
     if (operand->type == &AST_TREE_U64_TYPE) {
       doLeftOperation(operand, +, AstTreeInt, u64);
     } else if (operand->type == &AST_TREE_I64_TYPE) {
@@ -372,7 +379,8 @@ AstTree *runExpression(AstTree *expr, RunnerVariablePages *pages) {
     return operand;
   }
   case AST_TREE_TOKEN_OPERATOR_MINUS: {
-    AstTreeSingleChild *operand = runExpression(expr->metadata, pages);
+    AstTreeSingleChild *operand =
+        runExpression(expr->metadata, pages, shouldRet);
     if (operand->type == &AST_TREE_U64_TYPE) {
       doLeftOperation(operand, -, AstTreeInt, u64);
     } else if (operand->type == &AST_TREE_I64_TYPE) {
@@ -405,8 +413,8 @@ AstTree *runExpression(AstTree *expr, RunnerVariablePages *pages) {
   }
   case AST_TREE_TOKEN_OPERATOR_SUM: {
     AstTreeInfix *metadata = expr->metadata;
-    AstTree *left = runExpression(&metadata->left, pages);
-    AstTree *right = runExpression(&metadata->right, pages);
+    AstTree *left = runExpression(&metadata->left, pages, shouldRet);
+    AstTree *right = runExpression(&metadata->right, pages, shouldRet);
 
     if (left->type == &AST_TREE_U64_TYPE && right->type == &AST_TREE_U64_TYPE) {
       doOperation(left, right, +, AstTreeInt, u64);
@@ -452,8 +460,8 @@ AstTree *runExpression(AstTree *expr, RunnerVariablePages *pages) {
   }
   case AST_TREE_TOKEN_OPERATOR_SUB: {
     AstTreeInfix *metadata = expr->metadata;
-    AstTree *left = runExpression(&metadata->left, pages);
-    AstTree *right = runExpression(&metadata->right, pages);
+    AstTree *left = runExpression(&metadata->left, pages, shouldRet);
+    AstTree *right = runExpression(&metadata->right, pages, shouldRet);
 
     if (left->type == &AST_TREE_U64_TYPE && right->type == &AST_TREE_U64_TYPE) {
       doOperation(left, right, -, AstTreeInt, u64);
@@ -499,8 +507,8 @@ AstTree *runExpression(AstTree *expr, RunnerVariablePages *pages) {
   }
   case AST_TREE_TOKEN_OPERATOR_MULTIPLY: {
     AstTreeInfix *metadata = expr->metadata;
-    AstTree *left = runExpression(&metadata->left, pages);
-    AstTree *right = runExpression(&metadata->right, pages);
+    AstTree *left = runExpression(&metadata->left, pages, shouldRet);
+    AstTree *right = runExpression(&metadata->right, pages, shouldRet);
 
     if (left->type == &AST_TREE_U64_TYPE && right->type == &AST_TREE_U64_TYPE) {
       doOperation(left, right, *, AstTreeInt, u64);
@@ -546,8 +554,8 @@ AstTree *runExpression(AstTree *expr, RunnerVariablePages *pages) {
   }
   case AST_TREE_TOKEN_OPERATOR_DIVIDE: {
     AstTreeInfix *metadata = expr->metadata;
-    AstTree *left = runExpression(&metadata->left, pages);
-    AstTree *right = runExpression(&metadata->right, pages);
+    AstTree *left = runExpression(&metadata->left, pages, shouldRet);
+    AstTree *right = runExpression(&metadata->right, pages, shouldRet);
 
     if (left->type == &AST_TREE_U64_TYPE && right->type == &AST_TREE_U64_TYPE) {
       doOperation(left, right, /, AstTreeInt, u64);
@@ -593,8 +601,8 @@ AstTree *runExpression(AstTree *expr, RunnerVariablePages *pages) {
   }
   case AST_TREE_TOKEN_OPERATOR_MODULO: {
     AstTreeInfix *metadata = expr->metadata;
-    AstTree *left = runExpression(&metadata->left, pages);
-    AstTree *right = runExpression(&metadata->right, pages);
+    AstTree *left = runExpression(&metadata->left, pages, shouldRet);
+    AstTree *right = runExpression(&metadata->right, pages, shouldRet);
 
     if (left->type == &AST_TREE_U64_TYPE && right->type == &AST_TREE_U64_TYPE) {
       doOperation(left, right, %, AstTreeInt, u64);
@@ -628,8 +636,8 @@ AstTree *runExpression(AstTree *expr, RunnerVariablePages *pages) {
   }
   case AST_TREE_TOKEN_OPERATOR_EQUAL: {
     AstTreeInfix *metadata = expr->metadata;
-    AstTree *left = runExpression(&metadata->left, pages);
-    AstTree *right = runExpression(&metadata->right, pages);
+    AstTree *left = runExpression(&metadata->left, pages, shouldRet);
+    AstTree *right = runExpression(&metadata->right, pages, shouldRet);
 
     if (left->type == &AST_TREE_U64_TYPE && right->type == &AST_TREE_U64_TYPE) {
       doOperation(left, right, ==, AstTreeInt, u64);
@@ -681,8 +689,8 @@ AstTree *runExpression(AstTree *expr, RunnerVariablePages *pages) {
   }
   case AST_TREE_TOKEN_OPERATOR_NOT_EQUAL: {
     AstTreeInfix *metadata = expr->metadata;
-    AstTree *left = runExpression(&metadata->left, pages);
-    AstTree *right = runExpression(&metadata->right, pages);
+    AstTree *left = runExpression(&metadata->left, pages, shouldRet);
+    AstTree *right = runExpression(&metadata->right, pages, shouldRet);
 
     if (left->type == &AST_TREE_U64_TYPE && right->type == &AST_TREE_U64_TYPE) {
       doOperation(left, right, !=, AstTreeInt, u64);
@@ -734,8 +742,8 @@ AstTree *runExpression(AstTree *expr, RunnerVariablePages *pages) {
   }
   case AST_TREE_TOKEN_OPERATOR_GREATER: {
     AstTreeInfix *metadata = expr->metadata;
-    AstTree *left = runExpression(&metadata->left, pages);
-    AstTree *right = runExpression(&metadata->right, pages);
+    AstTree *left = runExpression(&metadata->left, pages, shouldRet);
+    AstTree *right = runExpression(&metadata->right, pages, shouldRet);
 
     if (left->type == &AST_TREE_U64_TYPE && right->type == &AST_TREE_U64_TYPE) {
       doOperation(left, right, >, AstTreeInt, u64);
@@ -781,8 +789,8 @@ AstTree *runExpression(AstTree *expr, RunnerVariablePages *pages) {
   }
   case AST_TREE_TOKEN_OPERATOR_SMALLER: {
     AstTreeInfix *metadata = expr->metadata;
-    AstTree *left = runExpression(&metadata->left, pages);
-    AstTree *right = runExpression(&metadata->right, pages);
+    AstTree *left = runExpression(&metadata->left, pages, shouldRet);
+    AstTree *right = runExpression(&metadata->right, pages, shouldRet);
 
     if (left->type == &AST_TREE_U64_TYPE && right->type == &AST_TREE_U64_TYPE) {
       doOperation(left, right, <, AstTreeInt, u64);
@@ -828,8 +836,8 @@ AstTree *runExpression(AstTree *expr, RunnerVariablePages *pages) {
   }
   case AST_TREE_TOKEN_OPERATOR_GREATER_OR_EQUAL: {
     AstTreeInfix *metadata = expr->metadata;
-    AstTree *left = runExpression(&metadata->left, pages);
-    AstTree *right = runExpression(&metadata->right, pages);
+    AstTree *left = runExpression(&metadata->left, pages, shouldRet);
+    AstTree *right = runExpression(&metadata->right, pages, shouldRet);
 
     if (left->type == &AST_TREE_U64_TYPE && right->type == &AST_TREE_U64_TYPE) {
       doOperation(left, right, >=, AstTreeInt, u64);
@@ -875,8 +883,8 @@ AstTree *runExpression(AstTree *expr, RunnerVariablePages *pages) {
   }
   case AST_TREE_TOKEN_OPERATOR_SMALLER_OR_EQUAL: {
     AstTreeInfix *metadata = expr->metadata;
-    AstTree *left = runExpression(&metadata->left, pages);
-    AstTree *right = runExpression(&metadata->right, pages);
+    AstTree *left = runExpression(&metadata->left, pages, shouldRet);
+    AstTree *right = runExpression(&metadata->right, pages, shouldRet);
 
     if (left->type == &AST_TREE_U64_TYPE && right->type == &AST_TREE_U64_TYPE) {
       doOperation(left, right, <=, AstTreeInt, u64);
@@ -944,7 +952,7 @@ AstTree *runExpression(AstTree *expr, RunnerVariablePages *pages) {
   case AST_TREE_TOKEN_VARIABLE: {
     AstTreeVariable *variable = expr->metadata;
     AstTree *value = runnerVariableGetValue(pages, variable);
-    return runExpression(value, pages);
+    return runExpression(value, pages, shouldRet);
   }
   case AST_TREE_TOKEN_FUNCTION:
   case AST_TREE_TOKEN_NONE:
diff --git a/src/runner/runner.h b/src/runner/runner.h
index 6fb0b36..060821c 100644
--- a/src/runner/runner.h
+++ b/src/runner/runner.h
@@ -20,9 +20,11 @@ typedef struct RunnerVariablePages {
 
 void runnerVariablesDelete(RunnerVariables *variables);
 
-void runnerVariablePush(RunnerVariables *variables,AstTreeVariable *variable);
-void runnerVariableSetValue(RunnerVariablePages *pages,AstTreeVariable *variable,AstTree *value);
-AstTree* runnerVariableGetValue(RunnerVariablePages *pages,AstTreeVariable *variable);
+void runnerVariablePush(RunnerVariables *variables, AstTreeVariable *variable);
+void runnerVariableSetValue(RunnerVariablePages *pages,
+                            AstTreeVariable *variable, AstTree *value);
+AstTree *runnerVariableGetValue(RunnerVariablePages *pages,
+                                AstTreeVariable *variable);
 
 RunnerVariablePages initRootPages();
 void destroyRootPages(RunnerVariablePages pages);
@@ -30,6 +32,7 @@ void destroyRootPages(RunnerVariablePages pages);
 bool runAstTree(AstTreeRoot *root);
 
 AstTree *runAstTreeFunction(AstTree *tree, AstTree **arguments,
-                            size_t arguments_size,RunnerVariablePages *pages);
+                            size_t arguments_size, RunnerVariablePages *pages);
 
-AstTree* runExpression(AstTree *expr,RunnerVariablePages *pages);
+AstTree *runExpression(AstTree *expr, RunnerVariablePages *pages,
+                       bool *shouldRet);
diff --git a/test/main.felan b/test/main.felan
index f852c7e..7715214 100644
--- a/test/main.felan
+++ b/test/main.felan
@@ -1,10 +1,22 @@
 main :: () -> void {
-  comptime test(u64,u64);
+  print_u64 a;
 };
 
-test :: (from:type, to:type) -> void {
-  if from == to
-    print_u64 1234;
+a :: f();
+
+f :: ()->u64{
+  b :u64= 2;
+  r := 2;
+  if r % 2 == 0
+    return b;
   else
-    print_u64 4321;
+    return d();
+};
+
+d :: ()->u64{
+  return c();
+};
+
+c :: ()->u64{
+  return d();
 };