fixing some bugs in new way of operators and printing

8 files changed, 368 insertions, 97 deletions

diff --git a/code/basic.felan b/code/basic.felan
index 6a01d8a..e69a219 100644
--- a/code/basic.felan
+++ b/code/basic.felan
@@ -46,8 +46,29 @@ __minus__ :: (a:i64) -> i64 {
   return @neg(a);
 };
 
-__logical_not__ :: (a:bool) -> bool {
-  return a;
+__logical_not__ :: (value:bool) -> bool {
+  return value == true;
 };
 
+__logical_and__ :: (left:bool,right:bool) -> bool {
+  if left == true {
+    if right == true {
+      return true;
+    }
+  }
+  return false;
+};
 
+__logical_or__ :: (left:bool,right:bool) -> bool {
+  if left == true {
+    return true;
+  } else if right == true {
+    return true;
+  } else {
+    return false;
+  }
+};
+
+__equal__ :: (left:bool,right:bool) -> bool {
+  return @equal(left,right);
+};
diff --git a/code/main.felan b/code/main.felan
index 6107731..4e3a4b4 100644
--- a/code/main.felan
+++ b/code/main.felan
@@ -1,9 +1,10 @@
 @import("basic.felan");
 
 main :: () -> void {
-  a : i8 = 65;
-  b : i8 = 70;
-  a+b;
+  a := false;
+  b :: true;
+  if a == b {
+  }
 };
 
 __sum__ :: (left:i8,right:i8)->i8{
diff --git a/src/compiler/ast-tree.c b/src/compiler/ast-tree.c
index 6fb62f7..d85f99d 100644
--- a/src/compiler/ast-tree.c
+++ b/src/compiler/ast-tree.c
@@ -123,6 +123,18 @@ const char *AST_TREE_TOKEN_STRINGS[] = {
     "AST_TREE_TOKEN_BUILTIN_IS_COMPTIME",
     "AST_TREE_TOKEN_BUILTIN_STACK_ALLOC",
     "AST_TREE_TOKEN_BUILTIN_HEAP_ALLOC",
+    "AST_TREE_TOKEN_BUILTIN_NEG",
+    "AST_TREE_TOKEN_BUILTIN_ADD",
+    "AST_TREE_TOKEN_BUILTIN_SUB",
+    "AST_TREE_TOKEN_BUILTIN_MUL",
+    "AST_TREE_TOKEN_BUILTIN_DIV",
+    "AST_TREE_TOKEN_BUILTIN_MOD",
+    "AST_TREE_TOKEN_BUILTIN_EQUAL",
+    "AST_TREE_TOKEN_BUILTIN_NOT_EQUAL",
+    "AST_TREE_TOKEN_BUILTIN_GREATER",
+    "AST_TREE_TOKEN_BUILTIN_SMALLER",
+    "AST_TREE_TOKEN_BUILTIN_GREATER_OR_EQUAL",
+    "AST_TREE_TOKEN_BUILTIN_SMALLER_OR_EQUAL",
 
     "AST_TREE_TOKEN_KEYWORD_PUTC",
     "AST_TREE_TOKEN_KEYWORD_RETURN",
@@ -181,6 +193,9 @@ const char *AST_TREE_TOKEN_STRINGS[] = {
     "AST_TREE_TOKEN_OPERATOR_ADDRESS",
     "AST_TREE_TOKEN_OPERATOR_DEREFERENCE",
     "AST_TREE_TOKEN_OPERATOR_ACCESS",
+    "AST_TREE_TOKEN_OPERATOR_LOGICAL_NOT",
+    "AST_TREE_TOKEN_OPERATOR_LOGICAL_AND",
+    "AST_TREE_TOKEN_OPERATOR_LOGICAL_OR",
     "AST_TREE_TOKEN_OPERATOR_ARRAY_ACCESS",
 
     "AST_TREE_TOKEN_SCOPE",
@@ -4117,13 +4132,15 @@ bool setAllTypes(AstTree *tree, AstTreeSetTypesHelper helper,
   case AST_TREE_TOKEN_BUILTIN_MUL:
   case AST_TREE_TOKEN_BUILTIN_DIV:
   case AST_TREE_TOKEN_BUILTIN_MOD:
+    return setTypesBuiltinBinary(tree, helper, functionCall);
   case AST_TREE_TOKEN_BUILTIN_EQUAL:
   case AST_TREE_TOKEN_BUILTIN_NOT_EQUAL:
   case AST_TREE_TOKEN_BUILTIN_GREATER:
   case AST_TREE_TOKEN_BUILTIN_SMALLER:
   case AST_TREE_TOKEN_BUILTIN_GREATER_OR_EQUAL:
   case AST_TREE_TOKEN_BUILTIN_SMALLER_OR_EQUAL:
-    return setTypesBuiltinBinary(tree, helper, functionCall);
+    return setTypesBuiltinBinaryWithRet(tree, helper, functionCall,
+                                        &AST_TREE_BOOL_TYPE);
   case AST_TREE_TOKEN_TYPE_ARRAY:
     return setTypesTypeArray(tree, helper);
   case AST_TREE_TOKEN_OPERATOR_ARRAY_ACCESS:
@@ -4642,6 +4659,7 @@ bool setTypesOperatorInfix(AstTree *tree, AstTreeSetTypesHelper _helper,
   AstTreeVariable *variable =
       setTypesFindVariable(str, str + str_size, helper, &functionCall);
   if (variable == NULL) {
+    printError(tree->str_begin, tree->str_end, "Can't find operator");
     return false;
   }
 
@@ -5457,6 +5475,84 @@ bool setTypesBuiltinBinary(AstTree *tree, AstTreeSetTypesHelper helper,
   return true;
 }
 
+bool setTypesBuiltinBinaryWithRet(AstTree *tree, AstTreeSetTypesHelper helper,
+                                  AstTreeFunctionCall *functionCall,
+                                  AstTree *retType) {
+  (void)helper;
+  if (functionCall->parameters_size != 2) {
+    printError(tree->str_begin, tree->str_end, "Too many or too few arguments");
+    return false;
+  }
+  AstTree *left = NULL;
+  AstTree *right = NULL;
+
+  static char LEFT_STR[] = "left";
+  static const size_t LEFT_STR_SIZE =
+      sizeof(LEFT_STR) / sizeof(*LEFT_STR) - sizeof(*LEFT_STR);
+  static char RIGHT_STR[] = "right";
+  static const size_t RIGHT_STR_SIZE =
+      sizeof(RIGHT_STR) / sizeof(*RIGHT_STR) - sizeof(*RIGHT_STR);
+
+  for (size_t i = 0; i < functionCall->parameters_size; ++i) {
+    AstTreeFunctionCallParam param = functionCall->parameters[i];
+    const size_t param_name_size = param.nameEnd - param.nameBegin;
+
+    if (param_name_size == 0) {
+      if (left == NULL) {
+        left = param.value;
+      } else if (right == NULL) {
+        right = param.value;
+      } else {
+        printError(param.value->str_begin, param.value->str_end,
+                   "Bad paramter");
+        return false;
+      }
+    } else if (param_name_size == LEFT_STR_SIZE &&
+               strnEquals(param.nameBegin, LEFT_STR, LEFT_STR_SIZE) &&
+               left == NULL) {
+      left = param.value;
+    } else if (param_name_size == RIGHT_STR_SIZE &&
+               strnEquals(param.nameBegin, RIGHT_STR, RIGHT_STR_SIZE) &&
+               right == NULL) {
+      right = param.value;
+    } else {
+      printError(param.value->str_begin, param.value->str_end, "Bad paramter");
+      return false;
+    }
+  }
+
+  if (left == NULL || right == NULL) {
+    return false;
+  }
+
+  AstTreeTypeFunction *type_metadata = a404m_malloc(sizeof(*type_metadata));
+  type_metadata->arguments_size = 2;
+  type_metadata->arguments = a404m_malloc(type_metadata->arguments_size *
+                                          sizeof(*type_metadata->arguments));
+
+  type_metadata->returnType = copyAstTree(retType);
+
+  type_metadata->arguments[0] = (AstTreeTypeFunctionArgument){
+      .type = copyAstTree(left->type),
+      .name_begin = LEFT_STR,
+      .name_end = LEFT_STR + LEFT_STR_SIZE,
+      .str_begin = NULL,
+      .str_end = NULL,
+  };
+
+  type_metadata->arguments[1] = (AstTreeTypeFunctionArgument){
+      .type = copyAstTree(left->type),
+      .name_begin = RIGHT_STR,
+      .name_end = RIGHT_STR + RIGHT_STR_SIZE,
+      .str_begin = NULL,
+      .str_end = NULL,
+  };
+
+  tree->type = newAstTree(AST_TREE_TOKEN_TYPE_FUNCTION, type_metadata,
+                          &AST_TREE_TYPE_TYPE, NULL, NULL);
+  return true;
+}
+
 bool setTypesTypeArray(AstTree *tree, AstTreeSetTypesHelper helper) {
   AstTreeBracket *metadata = tree->metadata;
 
diff --git a/src/compiler/ast-tree.h b/src/compiler/ast-tree.h
index e410bc7..74aa027 100644
--- a/src/compiler/ast-tree.h
+++ b/src/compiler/ast-tree.h
@@ -426,7 +426,10 @@ bool setTypesBuiltinHeapAlloc(AstTree *tree, AstTreeSetTypesHelper helper,
 bool setTypesBuiltinUnary(AstTree *tree, AstTreeSetTypesHelper helper,
                           AstTreeFunctionCall *functionCall);
 bool setTypesBuiltinBinary(AstTree *tree, AstTreeSetTypesHelper helper,
-                          AstTreeFunctionCall *functionCall);
+                           AstTreeFunctionCall *functionCall);
+bool setTypesBuiltinBinaryWithRet(AstTree *tree, AstTreeSetTypesHelper helper,
+                                  AstTreeFunctionCall *functionCall,
+                                  AstTree *retType);
 bool setTypesTypeArray(AstTree *tree, AstTreeSetTypesHelper helper);
 bool setTypesArrayAccess(AstTree *tree, AstTreeSetTypesHelper helper);
 
diff --git a/src/compiler/lexer.c b/src/compiler/lexer.c
index 66fb81b..b28bd48 100644
--- a/src/compiler/lexer.c
+++ b/src/compiler/lexer.c
@@ -10,6 +10,7 @@ const char *LEXER_TOKEN_STRINGS[] = {
     "LEXER_TOKEN_SYMBOL_CLOSE_PARENTHESIS",
     "LEXER_TOKEN_SYMBOL_CLOSE_BRACKET",
     "LEXER_TOKEN_IDENTIFIER",
+    "LEXER_TOKEN_BUILTIN",
     "LEXER_TOKEN_BUILTIN_CAST",
     "LEXER_TOKEN_BUILTIN_TYPE_OF",
     "LEXER_TOKEN_BUILTIN_IMPORT",
@@ -363,6 +364,10 @@ LexerNodeArray lexer(char *str) {
 RETURN_SUCCESS:
   result.data = a404m_realloc(result.data, result.size * sizeof(*result.data));
 
+#ifdef PRINT_COMPILE_TREE
+  lexerNodeArrayPrint(result);
+#endif
+
   return result;
 }
 
diff --git a/src/compiler/lexer.h b/src/compiler/lexer.h
index e89c8bd..7f52eaf 100644
--- a/src/compiler/lexer.h
+++ b/src/compiler/lexer.h
@@ -2,6 +2,7 @@
 
 #include "utils/type.h"
 #include <stddef.h>
+#include <stdio.h>
 
 typedef enum LexerToken {
   LEXER_TOKEN_SYMBOL_CLOSE_CURLY_BRACKET,
diff --git a/src/compiler/parser.c b/src/compiler/parser.c
index b7a6226..6e8283a 100644
--- a/src/compiler/parser.c
+++ b/src/compiler/parser.c
@@ -244,6 +244,18 @@ void parserNodePrint(const ParserNode *node, int indent) {
   case PARSER_TOKEN_BUILTIN_IS_COMPTIME:
   case PARSER_TOKEN_BUILTIN_STACK_ALLOC:
   case PARSER_TOKEN_BUILTIN_HEAP_ALLOC:
+  case PARSER_TOKEN_BUILTIN_NEG:
+  case PARSER_TOKEN_BUILTIN_ADD:
+  case PARSER_TOKEN_BUILTIN_SUB:
+  case PARSER_TOKEN_BUILTIN_MUL:
+  case PARSER_TOKEN_BUILTIN_DIV:
+  case PARSER_TOKEN_BUILTIN_MOD:
+  case PARSER_TOKEN_BUILTIN_EQUAL:
+  case PARSER_TOKEN_BUILTIN_NOT_EQUAL:
+  case PARSER_TOKEN_BUILTIN_GREATER:
+  case PARSER_TOKEN_BUILTIN_SMALLER:
+  case PARSER_TOKEN_BUILTIN_GREATER_OR_EQUAL:
+  case PARSER_TOKEN_BUILTIN_SMALLER_OR_EQUAL:
   case PARSER_TOKEN_TYPE_TYPE:
   case PARSER_TOKEN_TYPE_VOID:
   case PARSER_TOKEN_TYPE_BOOL:
@@ -741,6 +753,9 @@ ParserNode *parserFromPath(const char *filePath
 ParserNode *parser(LexerNodeArray lexed) {
   ParserNode *root = newParserNode(PARSER_TOKEN_ROOT, NULL, NULL, NULL, NULL);
   if (parserNodeArray(lexed.data, lexed.data + lexed.size, root)) {
+#ifdef PRINT_COMPILE_TREE
+    parserNodePrint(root, 0);
+#endif
     return root;
   } else {
     free(root);
diff --git a/src/runner/runner.c b/src/runner/runner.c
index 81e4f83..e334cf1 100644
--- a/src/runner/runner.c
+++ b/src/runner/runner.c
@@ -479,6 +479,7 @@ AstTree *runAstTreeBuiltin(AstTree *tree, AstTreeScope *scope,
     default:
       UNREACHABLE;
     }
+    astTreeDelete(right);
   }
     goto RETURN;
   case AST_TREE_TOKEN_BUILTIN_SUB: {
@@ -530,6 +531,7 @@ AstTree *runAstTreeBuiltin(AstTree *tree, AstTreeScope *scope,
     default:
       UNREACHABLE;
     }
+    astTreeDelete(right);
   }
     goto RETURN;
   case AST_TREE_TOKEN_BUILTIN_MUL: {
@@ -581,6 +583,7 @@ AstTree *runAstTreeBuiltin(AstTree *tree, AstTreeScope *scope,
     default:
       UNREACHABLE;
     }
+    astTreeDelete(right);
   }
     goto RETURN;
   case AST_TREE_TOKEN_BUILTIN_DIV: {
@@ -632,6 +635,7 @@ AstTree *runAstTreeBuiltin(AstTree *tree, AstTreeScope *scope,
     default:
       UNREACHABLE;
     }
+    astTreeDelete(right);
   }
     goto RETURN;
   case AST_TREE_TOKEN_BUILTIN_MOD: {
@@ -686,312 +690,437 @@ AstTree *runAstTreeBuiltin(AstTree *tree, AstTreeScope *scope,
     default:
       UNREACHABLE;
     }
+    astTreeDelete(right);
   }
     goto RETURN;
   case AST_TREE_TOKEN_BUILTIN_EQUAL: {
     bool shouldRet = false;
-    ret = runExpression(args.data[0], scope, &shouldRet, false, isComptime);
+    AstTree *left =
+        runExpression(args.data[0], scope, &shouldRet, false, isComptime);
     AstTree *right =
         runExpression(args.data[1], scope, &shouldRet, false, isComptime);
 
-    switch (ret->type->token) {
+    ret =
+        newAstTree(AST_TREE_TOKEN_VALUE_BOOL, a404m_malloc(sizeof(AstTreeBool)),
+                   &AST_TREE_BOOL_TYPE, NULL, NULL);
+
+    switch (left->type->token) {
     case AST_TREE_TOKEN_TYPE_I8:
-      *(i8 *)ret->metadata = *(i8 *)ret->metadata == *(i8 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(i8 *)left->metadata == *(i8 *)right->metadata;
       break;
     case AST_TREE_TOKEN_TYPE_U8:
-      *(u8 *)ret->metadata = *(u8 *)ret->metadata == *(u8 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(u8 *)left->metadata == *(u8 *)right->metadata;
       break;
     case AST_TREE_TOKEN_TYPE_I16:
-      *(i16 *)ret->metadata = *(i16 *)ret->metadata == *(i16 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(i16 *)left->metadata == *(i16 *)right->metadata;
       break;
     case AST_TREE_TOKEN_TYPE_U16:
-      *(u16 *)ret->metadata = *(u16 *)ret->metadata == *(u16 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(u16 *)left->metadata == *(u16 *)right->metadata;
       break;
     case AST_TREE_TOKEN_TYPE_I32:
-      *(i32 *)ret->metadata = *(i32 *)ret->metadata == *(i32 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(i32 *)left->metadata == *(i32 *)right->metadata;
       break;
     case AST_TREE_TOKEN_TYPE_U32:
-      *(u32 *)ret->metadata = *(u32 *)ret->metadata == *(u32 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(u32 *)left->metadata == *(u32 *)right->metadata;
       break;
     case AST_TREE_TOKEN_TYPE_I64:
-      *(i64 *)ret->metadata = *(i64 *)ret->metadata == *(i64 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(i64 *)left->metadata == *(i64 *)right->metadata;
       break;
     case AST_TREE_TOKEN_TYPE_U64:
-      *(u64 *)ret->metadata = *(u64 *)ret->metadata == *(u64 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(u64 *)left->metadata == *(u64 *)right->metadata;
       break;
 #ifdef FLOAT_16_SUPPORT
     case AST_TREE_TOKEN_TYPE_F16:
-      *(f16 *)ret->metadata = *(f16 *)ret->metadata == *(f16 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(f16 *)left->metadata == *(f16 *)right->metadata;
       break;
 #endif
     case AST_TREE_TOKEN_TYPE_F32:
-      *(f32 *)ret->metadata = *(f32 *)ret->metadata == *(f32 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(f32 *)left->metadata == *(f32 *)right->metadata;
       break;
     case AST_TREE_TOKEN_TYPE_F64:
-      *(f64 *)ret->metadata = *(f64 *)ret->metadata == *(f64 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(f64 *)left->metadata == *(f64 *)right->metadata;
       break;
     case AST_TREE_TOKEN_TYPE_F128:
-      *(f128 *)ret->metadata =
-          *(f128 *)ret->metadata == *(f128 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(f128 *)left->metadata == *(f128 *)right->metadata;
+      break;
+    case AST_TREE_TOKEN_TYPE_BOOL:
+      *(AstTreeBool *)ret->metadata =
+          *(AstTreeBool *)left->metadata == *(AstTreeBool *)right->metadata;
       break;
     default:
       UNREACHABLE;
     }
+    astTreeDelete(left);
+    astTreeDelete(right);
   }
     goto RETURN;
   case AST_TREE_TOKEN_BUILTIN_NOT_EQUAL: {
     bool shouldRet = false;
-    ret = runExpression(args.data[0], scope, &shouldRet, false, isComptime);
+    AstTree *left =
+        runExpression(args.data[0], scope, &shouldRet, false, isComptime);
     AstTree *right =
         runExpression(args.data[1], scope, &shouldRet, false, isComptime);
 
-    switch (ret->type->token) {
+    ret =
+        newAstTree(AST_TREE_TOKEN_VALUE_BOOL, a404m_malloc(sizeof(AstTreeBool)),
+                   &AST_TREE_BOOL_TYPE, NULL, NULL);
+
+    switch (left->type->token) {
     case AST_TREE_TOKEN_TYPE_I8:
-      *(i8 *)ret->metadata = *(i8 *)ret->metadata != *(i8 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(i8 *)left->metadata != *(i8 *)right->metadata;
       break;
     case AST_TREE_TOKEN_TYPE_U8:
-      *(u8 *)ret->metadata = *(u8 *)ret->metadata != *(u8 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(u8 *)left->metadata != *(u8 *)right->metadata;
       break;
     case AST_TREE_TOKEN_TYPE_I16:
-      *(i16 *)ret->metadata = *(i16 *)ret->metadata != *(i16 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(i16 *)left->metadata != *(i16 *)right->metadata;
       break;
     case AST_TREE_TOKEN_TYPE_U16:
-      *(u16 *)ret->metadata = *(u16 *)ret->metadata != *(u16 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(u16 *)left->metadata != *(u16 *)right->metadata;
       break;
     case AST_TREE_TOKEN_TYPE_I32:
-      *(i32 *)ret->metadata = *(i32 *)ret->metadata != *(i32 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(i32 *)left->metadata != *(i32 *)right->metadata;
       break;
     case AST_TREE_TOKEN_TYPE_U32:
-      *(u32 *)ret->metadata = *(u32 *)ret->metadata != *(u32 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(u32 *)left->metadata != *(u32 *)right->metadata;
       break;
     case AST_TREE_TOKEN_TYPE_I64:
-      *(i64 *)ret->metadata = *(i64 *)ret->metadata != *(i64 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(i64 *)left->metadata != *(i64 *)right->metadata;
       break;
     case AST_TREE_TOKEN_TYPE_U64:
-      *(u64 *)ret->metadata = *(u64 *)ret->metadata != *(u64 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(u64 *)left->metadata != *(u64 *)right->metadata;
       break;
 #ifdef FLOAT_16_SUPPORT
     case AST_TREE_TOKEN_TYPE_F16:
-      *(f16 *)ret->metadata = *(f16 *)ret->metadata != *(f16 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(f16 *)left->metadata != *(f16 *)right->metadata;
       break;
 #endif
     case AST_TREE_TOKEN_TYPE_F32:
-      *(f32 *)ret->metadata = *(f32 *)ret->metadata != *(f32 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(f32 *)left->metadata != *(f32 *)right->metadata;
       break;
     case AST_TREE_TOKEN_TYPE_F64:
-      *(f64 *)ret->metadata = *(f64 *)ret->metadata != *(f64 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(f64 *)left->metadata != *(f64 *)right->metadata;
       break;
     case AST_TREE_TOKEN_TYPE_F128:
-      *(f128 *)ret->metadata =
-          *(f128 *)ret->metadata != *(f128 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(f128 *)left->metadata != *(f128 *)right->metadata;
+      break;
+    case AST_TREE_TOKEN_TYPE_BOOL:
+      *(AstTreeBool *)ret->metadata =
+          *(AstTreeBool *)left->metadata == *(AstTreeBool *)right->metadata;
       break;
     default:
       UNREACHABLE;
     }
+    astTreeDelete(left);
+    astTreeDelete(right);
   }
     goto RETURN;
   case AST_TREE_TOKEN_BUILTIN_GREATER: {
     bool shouldRet = false;
-    ret = runExpression(args.data[0], scope, &shouldRet, false, isComptime);
+    AstTree *left =
+        runExpression(args.data[0], scope, &shouldRet, false, isComptime);
     AstTree *right =
         runExpression(args.data[1], scope, &shouldRet, false, isComptime);
 
-    switch (ret->type->token) {
+    ret =
+        newAstTree(AST_TREE_TOKEN_VALUE_BOOL, a404m_malloc(sizeof(AstTreeBool)),
+                   &AST_TREE_BOOL_TYPE, NULL, NULL);
+
+    switch (left->type->token) {
     case AST_TREE_TOKEN_TYPE_I8:
-      *(i8 *)ret->metadata = *(i8 *)ret->metadata > *(i8 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(i8 *)left->metadata > *(i8 *)right->metadata;
       break;
     case AST_TREE_TOKEN_TYPE_U8:
-      *(u8 *)ret->metadata = *(u8 *)ret->metadata > *(u8 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(u8 *)left->metadata > *(u8 *)right->metadata;
       break;
     case AST_TREE_TOKEN_TYPE_I16:
-      *(i16 *)ret->metadata = *(i16 *)ret->metadata > *(i16 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(i16 *)left->metadata > *(i16 *)right->metadata;
       break;
     case AST_TREE_TOKEN_TYPE_U16:
-      *(u16 *)ret->metadata = *(u16 *)ret->metadata > *(u16 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(u16 *)left->metadata > *(u16 *)right->metadata;
       break;
     case AST_TREE_TOKEN_TYPE_I32:
-      *(i32 *)ret->metadata = *(i32 *)ret->metadata > *(i32 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(i32 *)left->metadata > *(i32 *)right->metadata;
       break;
     case AST_TREE_TOKEN_TYPE_U32:
-      *(u32 *)ret->metadata = *(u32 *)ret->metadata > *(u32 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(u32 *)left->metadata > *(u32 *)right->metadata;
       break;
     case AST_TREE_TOKEN_TYPE_I64:
-      *(i64 *)ret->metadata = *(i64 *)ret->metadata > *(i64 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(i64 *)left->metadata > *(i64 *)right->metadata;
       break;
     case AST_TREE_TOKEN_TYPE_U64:
-      *(u64 *)ret->metadata = *(u64 *)ret->metadata > *(u64 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(u64 *)left->metadata > *(u64 *)right->metadata;
       break;
 #ifdef FLOAT_16_SUPPORT
     case AST_TREE_TOKEN_TYPE_F16:
-      *(f16 *)ret->metadata = *(f16 *)ret->metadata > *(f16 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(f16 *)left->metadata > *(f16 *)right->metadata;
       break;
 #endif
     case AST_TREE_TOKEN_TYPE_F32:
-      *(f32 *)ret->metadata = *(f32 *)ret->metadata > *(f32 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(f32 *)left->metadata > *(f32 *)right->metadata;
       break;
     case AST_TREE_TOKEN_TYPE_F64:
-      *(f64 *)ret->metadata = *(f64 *)ret->metadata > *(f64 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(f64 *)left->metadata > *(f64 *)right->metadata;
       break;
     case AST_TREE_TOKEN_TYPE_F128:
-      *(f128 *)ret->metadata =
-          *(f128 *)ret->metadata > *(f128 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(f128 *)left->metadata > *(f128 *)right->metadata;
       break;
     default:
       UNREACHABLE;
     }
+    astTreeDelete(left);
+    astTreeDelete(right);
   }
     goto RETURN;
   case AST_TREE_TOKEN_BUILTIN_SMALLER: {
     bool shouldRet = false;
-    ret = runExpression(args.data[0], scope, &shouldRet, false, isComptime);
+    AstTree *left =
+        runExpression(args.data[0], scope, &shouldRet, false, isComptime);
     AstTree *right =
         runExpression(args.data[1], scope, &shouldRet, false, isComptime);
 
-    switch (ret->type->token) {
+    ret =
+        newAstTree(AST_TREE_TOKEN_VALUE_BOOL, a404m_malloc(sizeof(AstTreeBool)),
+                   &AST_TREE_BOOL_TYPE, NULL, NULL);
+
+    switch (left->type->token) {
     case AST_TREE_TOKEN_TYPE_I8:
-      *(i8 *)ret->metadata = *(i8 *)ret->metadata < *(i8 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(i8 *)left->metadata < *(i8 *)right->metadata;
       break;
     case AST_TREE_TOKEN_TYPE_U8:
-      *(u8 *)ret->metadata = *(u8 *)ret->metadata < *(u8 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(u8 *)left->metadata < *(u8 *)right->metadata;
       break;
     case AST_TREE_TOKEN_TYPE_I16:
-      *(i16 *)ret->metadata = *(i16 *)ret->metadata < *(i16 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(i16 *)left->metadata < *(i16 *)right->metadata;
       break;
     case AST_TREE_TOKEN_TYPE_U16:
-      *(u16 *)ret->metadata = *(u16 *)ret->metadata < *(u16 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(u16 *)left->metadata < *(u16 *)right->metadata;
       break;
     case AST_TREE_TOKEN_TYPE_I32:
-      *(i32 *)ret->metadata = *(i32 *)ret->metadata < *(i32 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(i32 *)left->metadata < *(i32 *)right->metadata;
       break;
     case AST_TREE_TOKEN_TYPE_U32:
-      *(u32 *)ret->metadata = *(u32 *)ret->metadata < *(u32 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(u32 *)left->metadata < *(u32 *)right->metadata;
       break;
     case AST_TREE_TOKEN_TYPE_I64:
-      *(i64 *)ret->metadata = *(i64 *)ret->metadata < *(i64 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(i64 *)left->metadata < *(i64 *)right->metadata;
       break;
     case AST_TREE_TOKEN_TYPE_U64:
-      *(u64 *)ret->metadata = *(u64 *)ret->metadata < *(u64 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(u64 *)left->metadata < *(u64 *)right->metadata;
       break;
 #ifdef FLOAT_16_SUPPORT
     case AST_TREE_TOKEN_TYPE_F16:
-      *(f16 *)ret->metadata = *(f16 *)ret->metadata < *(f16 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(f16 *)left->metadata < *(f16 *)right->metadata;
       break;
 #endif
     case AST_TREE_TOKEN_TYPE_F32:
-      *(f32 *)ret->metadata = *(f32 *)ret->metadata < *(f32 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(f32 *)left->metadata < *(f32 *)right->metadata;
       break;
     case AST_TREE_TOKEN_TYPE_F64:
-      *(f64 *)ret->metadata = *(f64 *)ret->metadata < *(f64 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(f64 *)left->metadata < *(f64 *)right->metadata;
       break;
     case AST_TREE_TOKEN_TYPE_F128:
-      *(f128 *)ret->metadata =
-          *(f128 *)ret->metadata < *(f128 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(f128 *)left->metadata < *(f128 *)right->metadata;
       break;
     default:
       UNREACHABLE;
     }
+    astTreeDelete(left);
+    astTreeDelete(right);
   }
     goto RETURN;
   case AST_TREE_TOKEN_BUILTIN_GREATER_OR_EQUAL: {
     bool shouldRet = false;
-    ret = runExpression(args.data[0], scope, &shouldRet, false, isComptime);
+    AstTree *left =
+        runExpression(args.data[0], scope, &shouldRet, false, isComptime);
     AstTree *right =
         runExpression(args.data[1], scope, &shouldRet, false, isComptime);
 
-    switch (ret->type->token) {
+    ret =
+        newAstTree(AST_TREE_TOKEN_VALUE_BOOL, a404m_malloc(sizeof(AstTreeBool)),
+                   &AST_TREE_BOOL_TYPE, NULL, NULL);
+
+    switch (left->type->token) {
     case AST_TREE_TOKEN_TYPE_I8:
-      *(i8 *)ret->metadata = *(i8 *)ret->metadata >= *(i8 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(i8 *)left->metadata >= *(i8 *)right->metadata;
       break;
     case AST_TREE_TOKEN_TYPE_U8:
-      *(u8 *)ret->metadata = *(u8 *)ret->metadata >= *(u8 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(u8 *)left->metadata >= *(u8 *)right->metadata;
       break;
     case AST_TREE_TOKEN_TYPE_I16:
-      *(i16 *)ret->metadata = *(i16 *)ret->metadata >= *(i16 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(i16 *)left->metadata >= *(i16 *)right->metadata;
       break;
     case AST_TREE_TOKEN_TYPE_U16:
-      *(u16 *)ret->metadata = *(u16 *)ret->metadata >= *(u16 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(u16 *)left->metadata >= *(u16 *)right->metadata;
       break;
     case AST_TREE_TOKEN_TYPE_I32:
-      *(i32 *)ret->metadata = *(i32 *)ret->metadata >= *(i32 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(i32 *)left->metadata >= *(i32 *)right->metadata;
       break;
     case AST_TREE_TOKEN_TYPE_U32:
-      *(u32 *)ret->metadata = *(u32 *)ret->metadata >= *(u32 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(u32 *)left->metadata >= *(u32 *)right->metadata;
       break;
     case AST_TREE_TOKEN_TYPE_I64:
-      *(i64 *)ret->metadata = *(i64 *)ret->metadata >= *(i64 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(i64 *)left->metadata >= *(i64 *)right->metadata;
       break;
     case AST_TREE_TOKEN_TYPE_U64:
-      *(u64 *)ret->metadata = *(u64 *)ret->metadata >= *(u64 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(u64 *)left->metadata >= *(u64 *)right->metadata;
       break;
 #ifdef FLOAT_16_SUPPORT
     case AST_TREE_TOKEN_TYPE_F16:
-      *(f16 *)ret->metadata = *(f16 *)ret->metadata >= *(f16 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(f16 *)left->metadata >= *(f16 *)right->metadata;
       break;
 #endif
     case AST_TREE_TOKEN_TYPE_F32:
-      *(f32 *)ret->metadata = *(f32 *)ret->metadata >= *(f32 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(f32 *)left->metadata >= *(f32 *)right->metadata;
       break;
     case AST_TREE_TOKEN_TYPE_F64:
-      *(f64 *)ret->metadata = *(f64 *)ret->metadata >= *(f64 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(f64 *)left->metadata >= *(f64 *)right->metadata;
       break;
     case AST_TREE_TOKEN_TYPE_F128:
-      *(f128 *)ret->metadata =
-          *(f128 *)ret->metadata >= *(f128 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(f128 *)left->metadata >= *(f128 *)right->metadata;
+      break;
+    case AST_TREE_TOKEN_TYPE_BOOL:
+      *(AstTreeBool *)ret->metadata =
+          *(AstTreeBool *)left->metadata == *(AstTreeBool *)right->metadata;
       break;
     default:
       UNREACHABLE;
     }
+    astTreeDelete(left);
+    astTreeDelete(right);
   }
     goto RETURN;
   case AST_TREE_TOKEN_BUILTIN_SMALLER_OR_EQUAL: {
     bool shouldRet = false;
-    ret = runExpression(args.data[0], scope, &shouldRet, false, isComptime);
+    AstTree *left =
+        runExpression(args.data[0], scope, &shouldRet, false, isComptime);
     AstTree *right =
         runExpression(args.data[1], scope, &shouldRet, false, isComptime);
 
-    switch (ret->type->token) {
+    ret =
+        newAstTree(AST_TREE_TOKEN_VALUE_BOOL, a404m_malloc(sizeof(AstTreeBool)),
+                   &AST_TREE_BOOL_TYPE, NULL, NULL);
+
+    switch (left->type->token) {
     case AST_TREE_TOKEN_TYPE_I8:
-      *(i8 *)ret->metadata = *(i8 *)ret->metadata <= *(i8 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(i8 *)left->metadata <= *(i8 *)right->metadata;
       break;
     case AST_TREE_TOKEN_TYPE_U8:
-      *(u8 *)ret->metadata = *(u8 *)ret->metadata <= *(u8 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(u8 *)left->metadata <= *(u8 *)right->metadata;
       break;
     case AST_TREE_TOKEN_TYPE_I16:
-      *(i16 *)ret->metadata = *(i16 *)ret->metadata <= *(i16 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(i16 *)left->metadata <= *(i16 *)right->metadata;
       break;
     case AST_TREE_TOKEN_TYPE_U16:
-      *(u16 *)ret->metadata = *(u16 *)ret->metadata <= *(u16 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(u16 *)left->metadata <= *(u16 *)right->metadata;
       break;
     case AST_TREE_TOKEN_TYPE_I32:
-      *(i32 *)ret->metadata = *(i32 *)ret->metadata <= *(i32 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(i32 *)left->metadata <= *(i32 *)right->metadata;
       break;
     case AST_TREE_TOKEN_TYPE_U32:
-      *(u32 *)ret->metadata = *(u32 *)ret->metadata <= *(u32 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(u32 *)left->metadata <= *(u32 *)right->metadata;
       break;
     case AST_TREE_TOKEN_TYPE_I64:
-      *(i64 *)ret->metadata = *(i64 *)ret->metadata <= *(i64 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(i64 *)left->metadata <= *(i64 *)right->metadata;
       break;
     case AST_TREE_TOKEN_TYPE_U64:
-      *(u64 *)ret->metadata = *(u64 *)ret->metadata <= *(u64 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(u64 *)left->metadata <= *(u64 *)right->metadata;
       break;
 #ifdef FLOAT_16_SUPPORT
     case AST_TREE_TOKEN_TYPE_F16:
-      *(f16 *)ret->metadata = *(f16 *)ret->metadata <= *(f16 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(f16 *)left->metadata <= *(f16 *)right->metadata;
       break;
 #endif
     case AST_TREE_TOKEN_TYPE_F32:
-      *(f32 *)ret->metadata = *(f32 *)ret->metadata <= *(f32 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(f32 *)left->metadata <= *(f32 *)right->metadata;
       break;
     case AST_TREE_TOKEN_TYPE_F64:
-      *(f64 *)ret->metadata = *(f64 *)ret->metadata <= *(f64 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(f64 *)left->metadata <= *(f64 *)right->metadata;
       break;
     case AST_TREE_TOKEN_TYPE_F128:
-      *(f128 *)ret->metadata =
-          *(f128 *)ret->metadata <= *(f128 *)right->metadata;
+      *(AstTreeBool *)ret->metadata =
+          *(f128 *)left->metadata <= *(f128 *)right->metadata;
+      break;
+    case AST_TREE_TOKEN_TYPE_BOOL:
+      *(AstTreeBool *)ret->metadata =
+          *(AstTreeBool *)left->metadata == *(AstTreeBool *)right->metadata;
       break;
     default:
       UNREACHABLE;
     }
+    astTreeDelete(left);
+    astTreeDelete(right);
   }
     goto RETURN;
   case AST_TREE_TOKEN_BUILTIN_IMPORT: