removing lazy because macro can do the job

8 files changed, 188 insertions, 88 deletions

diff --git a/src/compiler/ast-tree.c b/src/compiler/ast-tree.c
index 8cea6f7..3dd2308 100644
--- a/src/compiler/ast-tree.c
+++ b/src/compiler/ast-tree.c
@@ -1784,7 +1784,6 @@ AstTreeVariables copyAstTreeVariables(AstTreeVariables variables,
     result.data[i]->name_begin = variables.data[i]->name_begin;
     result.data[i]->name_end = variables.data[i]->name_end;
     result.data[i]->isConst = variables.data[i]->isConst;
-    result.data[i]->isLazy = variables.data[i]->isLazy;
     result.data[i]->type =
         copyAstTreeBack(variables.data[i]->type, new_oldVariables,
                         new_newVariables, new_variables_size, safetyCheck);
@@ -2115,7 +2114,6 @@ AstTreeRoot *makeAstRoot(const ParserNode *parsedRoot, char *filePath) {
       variable->name_begin = node_metadata->name->str_begin;
       variable->name_end = node_metadata->name->str_end;
       variable->isConst = node->token == PARSER_TOKEN_CONSTANT;
-      variable->isLazy = node_metadata->isLazy;
 
       if (node_metadata->isComptime && !variable->isConst) {
         printError(node->str_begin, node->str_end, "Bad comptime %s",
@@ -2678,7 +2676,6 @@ AstTree *astTreeParseFunction(const ParserNode *parserNode) {
     argument->name_begin = arg_metadata->name->str_begin;
     argument->name_end = arg_metadata->name->str_end;
     argument->isConst = arg_metadata->isComptime;
-    argument->isLazy = arg_metadata->isLazy;
 
     if (!pushVariable(&function->arguments, argument)) {
       astTreeVariableDelete(argument);
@@ -3329,7 +3326,6 @@ bool astTreeParseConstant(const ParserNode *parserNode,
   variable->name_begin = node_metadata->name->str_begin;
   variable->name_end = node_metadata->name->str_end;
   variable->isConst = true;
-  variable->isLazy = node_metadata->isLazy;
 
   if (!pushVariable(variables, variable)) {
     astTreeVariableDelete(variable);
@@ -3381,7 +3377,6 @@ AstTree *astTreeParseVariable(const ParserNode *parserNode,
   variable->name_begin = node_metadata->name->str_begin;
   variable->name_end = node_metadata->name->str_end;
   variable->isConst = false;
-  variable->isLazy = node_metadata->isLazy;
 
   if (!pushVariable(variables, variable)) {
     astTreeVariableDelete(variable);
@@ -3703,7 +3698,6 @@ AstTree *astTreeParseStruct(const ParserNode *parserNode) {
       variable->initValue = NULL;
       variable->isConst = false;
     }
-    variable->isLazy = node_variable->isLazy;
 
     variables.data[i] = variable;
   }
diff --git a/src/compiler/ast-tree.h b/src/compiler/ast-tree.h
index 7ee62ff..7d4eb84 100644
--- a/src/compiler/ast-tree.h
+++ b/src/compiler/ast-tree.h
@@ -173,7 +173,6 @@ typedef struct AstTreeVariable {
   AstTree *value;
   AstTree *initValue;
   bool isConst;
-  bool isLazy;
 } AstTreeVariable;
 
 typedef struct AstTreeVariables {
diff --git a/src/compiler/lexer.c b/src/compiler/lexer.c
index 869f62f..d6d4c55 100644
--- a/src/compiler/lexer.c
+++ b/src/compiler/lexer.c
@@ -137,7 +137,6 @@ const char *LEXER_TOKEN_STRINGS[] = {
     "LEXER_TOKEN_SYMBOL_OPEN_PARENTHESIS",
     "LEXER_TOKEN_SYMBOL_OPEN_BRACKET",
     "LEXER_TOKEN_SYMBOL_OPEN_CURLY_BRACKET",
-    "LEXER_TOKEN_KEYWORD_LAZY",
     "LEXER_TOKEN_KEYWORD_MACRO",
 
     "LEXER_TOKEN_NONE",
@@ -192,40 +191,54 @@ static const size_t LEXER_SYMBOL_SIZE =
     sizeof(LEXER_SYMBOL_TOKENS) / sizeof(*LEXER_SYMBOL_TOKENS);
 
 static const char *LEXER_KEYWORD_STRINGS[] = {
-    "type",      "anytype",       "void",     "i8",
-    "u8",        "i16",           "u16",      "i32",
-    "u32",       "i64",           "u64",
+    "type",       "anytype",       "void",   "i8",        "u8",
+    "i16",        "u16",           "i32",    "u32",       "i64",
+    "u64",
 #ifdef FLOAT_16_SUPPORT
     "f16",
 #endif
-    "f32",       "f64",           "f128",     "bool",
-    "return",    "true",          "false",    "if",
-    "else",      "while",         "comptime", "null",
-    "struct",    "undefined",     "code",     "lazy",
-    "namespace", "shape_shifter", "break",    "continue",
-    "c_library", "c_function",    "macro",
+    "f32",        "f64",           "f128",   "bool",      "return",
+    "true",       "false",         "if",     "else",      "while",
+    "comptime",   "null",          "struct", "undefined", "code",
+    "namespace",  "shape_shifter", "break",  "continue",  "c_library",
+    "c_function", "macro",
 };
 static const LexerToken LEXER_KEYWORD_TOKENS[] = {
-    LEXER_TOKEN_KEYWORD_TYPE,      LEXER_TOKEN_KEYWORD_ANY_TYPE,
-    LEXER_TOKEN_KEYWORD_VOID,      LEXER_TOKEN_KEYWORD_I8,
-    LEXER_TOKEN_KEYWORD_U8,        LEXER_TOKEN_KEYWORD_I16,
-    LEXER_TOKEN_KEYWORD_U16,       LEXER_TOKEN_KEYWORD_I32,
-    LEXER_TOKEN_KEYWORD_U32,       LEXER_TOKEN_KEYWORD_I64,
+    LEXER_TOKEN_KEYWORD_TYPE,
+    LEXER_TOKEN_KEYWORD_ANY_TYPE,
+    LEXER_TOKEN_KEYWORD_VOID,
+    LEXER_TOKEN_KEYWORD_I8,
+    LEXER_TOKEN_KEYWORD_U8,
+    LEXER_TOKEN_KEYWORD_I16,
+    LEXER_TOKEN_KEYWORD_U16,
+    LEXER_TOKEN_KEYWORD_I32,
+    LEXER_TOKEN_KEYWORD_U32,
+    LEXER_TOKEN_KEYWORD_I64,
     LEXER_TOKEN_KEYWORD_U64,
 #ifdef FLOAT_16_SUPPORT
     LEXER_TOKEN_KEYWORD_F16,
 #endif
-    LEXER_TOKEN_KEYWORD_F32,       LEXER_TOKEN_KEYWORD_F64,
-    LEXER_TOKEN_KEYWORD_F128,      LEXER_TOKEN_KEYWORD_BOOL,
-    LEXER_TOKEN_KEYWORD_RETURN,    LEXER_TOKEN_KEYWORD_TRUE,
-    LEXER_TOKEN_KEYWORD_FALSE,     LEXER_TOKEN_KEYWORD_IF,
-    LEXER_TOKEN_KEYWORD_ELSE,      LEXER_TOKEN_KEYWORD_WHILE,
-    LEXER_TOKEN_KEYWORD_COMPTIME,  LEXER_TOKEN_KEYWORD_NULL,
-    LEXER_TOKEN_KEYWORD_STRUCT,    LEXER_TOKEN_KEYWORD_UNDEFINED,
-    LEXER_TOKEN_KEYWORD_CODE,      LEXER_TOKEN_KEYWORD_LAZY,
-    LEXER_TOKEN_KEYWORD_NAMESPACE, LEXER_TOKEN_KEYWORD_SHAPE_SHIFTER,
-    LEXER_TOKEN_KEYWORD_BREAK,     LEXER_TOKEN_KEYWORD_CONTINUE,
-    LEXER_TOKEN_KEYWORD_C_LIBRARY, LEXER_TOKEN_KEYWORD_C_FUNCTION,
+    LEXER_TOKEN_KEYWORD_F32,
+    LEXER_TOKEN_KEYWORD_F64,
+    LEXER_TOKEN_KEYWORD_F128,
+    LEXER_TOKEN_KEYWORD_BOOL,
+    LEXER_TOKEN_KEYWORD_RETURN,
+    LEXER_TOKEN_KEYWORD_TRUE,
+    LEXER_TOKEN_KEYWORD_FALSE,
+    LEXER_TOKEN_KEYWORD_IF,
+    LEXER_TOKEN_KEYWORD_ELSE,
+    LEXER_TOKEN_KEYWORD_WHILE,
+    LEXER_TOKEN_KEYWORD_COMPTIME,
+    LEXER_TOKEN_KEYWORD_NULL,
+    LEXER_TOKEN_KEYWORD_STRUCT,
+    LEXER_TOKEN_KEYWORD_UNDEFINED,
+    LEXER_TOKEN_KEYWORD_CODE,
+    LEXER_TOKEN_KEYWORD_NAMESPACE,
+    LEXER_TOKEN_KEYWORD_SHAPE_SHIFTER,
+    LEXER_TOKEN_KEYWORD_BREAK,
+    LEXER_TOKEN_KEYWORD_CONTINUE,
+    LEXER_TOKEN_KEYWORD_C_LIBRARY,
+    LEXER_TOKEN_KEYWORD_C_FUNCTION,
     LEXER_TOKEN_KEYWORD_MACRO,
 };
 static const size_t LEXER_KEYWORD_SIZE =
@@ -502,7 +515,6 @@ lexerPushClear(LexerNodeArray *array, size_t *array_size, char const *iter,
   case LEXER_TOKEN_KEYWORD_UNDEFINED:
   case LEXER_TOKEN_KEYWORD_CODE:
   case LEXER_TOKEN_KEYWORD_NAMESPACE:
-  case LEXER_TOKEN_KEYWORD_LAZY:
   case LEXER_TOKEN_KEYWORD_MACRO:
   case LEXER_TOKEN_NUMBER:
   case LEXER_TOKEN_CHAR:
diff --git a/src/compiler/lexer.h b/src/compiler/lexer.h
index 568fabc..bf53b75 100644
--- a/src/compiler/lexer.h
+++ b/src/compiler/lexer.h
@@ -149,7 +149,6 @@ typedef enum LexerToken {
   LEXER_TOKEN_SYMBOL_OPEN_PARENTHESIS,
   LEXER_TOKEN_SYMBOL_OPEN_BRACKET,
   LEXER_TOKEN_SYMBOL_OPEN_CURLY_BRACKET,
-  LEXER_TOKEN_KEYWORD_LAZY,
   LEXER_TOKEN_KEYWORD_MACRO,
 
   LEXER_TOKEN_NONE,
diff --git a/src/compiler/parser.c b/src/compiler/parser.c
index ea54e52..a58b19c 100644
--- a/src/compiler/parser.c
+++ b/src/compiler/parser.c
@@ -353,7 +353,6 @@ void parserNodePrint(const ParserNode *node, int indent) {
   case PARSER_TOKEN_CONSTANT:
   case PARSER_TOKEN_VARIABLE: {
     const ParserNodeVariableMetadata *metadata = node->metadata;
-    printf("isLazy=%b,\n", metadata->isLazy);
     for (int i = 0; i < indent; ++i)
       printf(" ");
     printf("name=\n");
@@ -1177,7 +1176,6 @@ ParserNode *parseNode(LexerNode *node, LexerNode *begin, LexerNode *end,
     return parserComptime(node, end, parent);
   case LEXER_TOKEN_KEYWORD_STRUCT:
     return parserStruct(node, end, parent);
-  case LEXER_TOKEN_KEYWORD_LAZY:
   case LEXER_TOKEN_KEYWORD_ELSE:
   case LEXER_TOKEN_KEYWORD_MACRO:
   case LEXER_TOKEN_BUILTIN:
@@ -2071,14 +2069,10 @@ ParserNode *parserVariable(LexerNode *node, LexerNode *begin, LexerNode *end,
   metadata->name = name;
   metadata->type = type;
   metadata->isComptime = false;
-  metadata->isLazy = false;
 
   LexerNode *flagNode = nameNode - 1;
   while (flagNode >= begin && flagNode->parserNode == NULL) {
     switch (flagNode->token) {
-    case LEXER_TOKEN_KEYWORD_LAZY:
-      metadata->isLazy = true;
-      break;
     case LEXER_TOKEN_KEYWORD_COMPTIME:
       metadata->isComptime = true;
       break;
diff --git a/src/compiler/parser.h b/src/compiler/parser.h
index 3db1d3d..9a7ac74 100644
--- a/src/compiler/parser.h
+++ b/src/compiler/parser.h
@@ -156,7 +156,6 @@ typedef struct ParserNodeVariableMetadata {
   ParserNode *name;
   ParserNode *type;
   ParserNode *value;
-  bool isLazy;
   bool isComptime;
 } ParserNodeVariableMetadata;
 
diff --git a/src/runner/runner.c b/src/runner/runner.c
index dcfda79..949d9fb 100644
--- a/src/runner/runner.c
+++ b/src/runner/runner.c
@@ -1364,17 +1364,19 @@ AstTree *runExpression(AstTree *expr, AstTreeScope *scope, bool *shouldRet,
       AstTreeFunction *fun = function->metadata;
 
       for (size_t i = 0; i < args_size; ++i) {
-        AstTreeVariable *function_arg = fun->arguments.data[i];
         AstTreeFunctionCallParam param = metadata->parameters.data[i];
-        args[i] =
-            getForVariable(param.value, scope, shouldRet, false, isComptime,
-                           breakCount, shouldContinue, function_arg->isLazy);
-        if (discontinue(*shouldRet, *breakCount)) {
-          astTreeDelete(function);
-          for (size_t j = 0; j < i; ++j) {
-            astTreeDelete(args[i]);
+        if (fun->isMacro) {
+          args[i] = copyAstTree(param.value);
+        } else {
+          args[i] = runExpression(param.value, scope, shouldRet, false,
+                                  isComptime, breakCount, shouldContinue);
+          if (discontinue(*shouldRet, *breakCount)) {
+            astTreeDelete(function);
+            for (size_t j = 0; j < i; ++j) {
+              astTreeDelete(args[i]);
+            }
+            return args[i];
           }
-          return args[i];
         }
       }
       result = runAstTreeFunction(function, args, args_size, scope, isComptime);
@@ -1383,9 +1385,8 @@ AstTree *runExpression(AstTree *expr, AstTreeScope *scope, bool *shouldRet,
       for (size_t i = 0; i < args_size; ++i) {
         AstTreeFunctionCallParam param = metadata->parameters.data[i];
         if (function->token != AST_TREE_TOKEN_BUILTIN_TYPE_OF) {
-          args[i] =
-              getForVariable(param.value, scope, shouldRet, false, isComptime,
-                             breakCount, shouldContinue, false);
+          args[i] = runExpression(param.value, scope, shouldRet, false,
+                                  isComptime, breakCount, shouldContinue);
           if (discontinue(*shouldRet, *breakCount)) {
             astTreeDelete(function);
             for (size_t j = 0; j < i; ++j) {
@@ -1406,8 +1407,8 @@ AstTree *runExpression(AstTree *expr, AstTreeScope *scope, bool *shouldRet,
     } else if (function->token == AST_TREE_TOKEN_VALUE_C_FUNCTION) {
       for (size_t i = 0; i < args_size; ++i) {
         AstTreeFunctionCallParam param = metadata->parameters.data[i];
-        args[i] = getForVariable(param.value, scope, shouldRet, false,
-                                 isComptime, breakCount, shouldContinue, false);
+        args[i] = runExpression(param.value, scope, shouldRet, false,
+                                isComptime, breakCount, shouldContinue);
         if (discontinue(*shouldRet, *breakCount)) {
           astTreeDelete(function);
           for (size_t j = 0; j < i; ++j) {
@@ -1503,15 +1504,10 @@ AstTree *runExpression(AstTree *expr, AstTreeScope *scope, bool *shouldRet,
   }
   case AST_TREE_TOKEN_VARIABLE_DEFINE: {
     AstTreeVariable *variable = expr->metadata;
-    AstTree *value;
-    if (variable->isLazy) {
-      value = copyAstTree(variable->initValue);
-    } else {
-      value = runExpression(variable->initValue, scope, shouldRet, false,
-                            isComptime, breakCount, shouldContinue);
-      if (discontinue(*shouldRet, *breakCount)) {
-        return value;
-      }
+    AstTree *value = runExpression(variable->initValue, scope, shouldRet, false,
+                                   isComptime, breakCount, shouldContinue);
+    if (discontinue(*shouldRet, *breakCount)) {
+      return value;
     }
     runnerVariableSetValue(variable, value, scope);
     return &AST_TREE_VOID_VALUE;
@@ -1729,12 +1725,6 @@ AstTree *runExpression(AstTree *expr, AstTreeScope *scope, bool *shouldRet,
   case AST_TREE_TOKEN_VARIABLE: {
     AstTreeVariable *variable = expr->metadata;
 
-    if (variable->isLazy) {
-      AstTree *value = runExpression(variable->value, scope, shouldRet, false,
-                                     isComptime, breakCount, shouldContinue);
-      runnerVariableSetValue(variable, value, scope);
-    }
-
     if (variable->value->token == AST_TREE_TOKEN_RAW_VALUE) {
       if (isLeft) {
         return newAstTree(AST_TREE_TOKEN_RAW_VALUE_NOT_OWNED,
@@ -1756,7 +1746,12 @@ AstTree *runExpression(AstTree *expr, AstTreeScope *scope, bool *shouldRet,
       if (variable->value == NULL) {
         UNREACHABLE;
       }
-      return copyAstTree(variable->value);
+      if (canBeRaw(variable->type)) {
+        return runExpression(variable->value, scope, shouldRet, isLeft,
+                             isComptime, breakCount, shouldContinue);
+      } else {
+        return copyAstTree(variable->value);
+      }
     }
   }
   case AST_TREE_TOKEN_OPERATOR_ACCESS: {
@@ -1887,17 +1882,6 @@ AstTree *runExpression(AstTree *expr, AstTreeScope *scope, bool *shouldRet,
   UNREACHABLE;
 }
 
-AstTree *getForVariable(AstTree *expr, AstTreeScope *scope, bool *shouldRet,
-                        bool isLeft, bool isComptime, u32 *breakCount,
-                        bool *shouldContinue, bool isLazy) {
-  if (isLazy) {
-    return copyAstTree(expr);
-  } else {
-    return runExpression(expr, scope, shouldRet, isLeft, isComptime, breakCount,
-                         shouldContinue);
-  }
-}
-
 bool discontinue(bool shouldRet, u32 breakCount) {
   return shouldRet || breakCount > 0;
 }
@@ -2128,7 +2112,127 @@ AstTree *toRawValue(AstTree *value, AstTreeScope *scope) {
   case AST_TREE_TOKEN_OPERATOR_ARRAY_ACCESS_ASSIGN:
   case AST_TREE_TOKEN_OPERATOR_ARRAY_ACCESS_ADDRESS:
   case AST_TREE_TOKEN_SCOPE:
+  case AST_TREE_TOKEN_TYPE_ANY_TYPE:
+  case AST_TREE_TOKEN_BUILTIN_SIZE_OF:
+  case AST_TREE_TOKEN_BUILTIN_C_LIBRARY:
+  case AST_TREE_TOKEN_BUILTIN_C_FUNCTION:
+  case AST_TREE_TOKEN_TYPE_C_LIBRARY:
+  case AST_TREE_TOKEN_TYPE_C_FUNCTION:
+  case AST_TREE_TOKEN_TYPE_MACRO:
+    return NULL;
   case AST_TREE_TOKEN_NONE:
+  }
+  UNREACHABLE;
+}
+
+bool canBeRaw(AstTree *type) {
+  switch (type->token) {
+  case AST_TREE_TOKEN_TYPE_ARRAY:
+  case AST_TREE_TOKEN_TYPE_TYPE:
+  case AST_TREE_TOKEN_TYPE_VOID:
+  case AST_TREE_TOKEN_TYPE_I8:
+  case AST_TREE_TOKEN_TYPE_U8:
+  case AST_TREE_TOKEN_TYPE_I16:
+  case AST_TREE_TOKEN_TYPE_U16:
+  case AST_TREE_TOKEN_TYPE_I32:
+  case AST_TREE_TOKEN_TYPE_U32:
+  case AST_TREE_TOKEN_TYPE_I64:
+  case AST_TREE_TOKEN_TYPE_U64:
+#ifdef FLOAT_16_SUPPORT
+  case AST_TREE_TOKEN_TYPE_F16:
+#endif
+  case AST_TREE_TOKEN_TYPE_F32:
+  case AST_TREE_TOKEN_TYPE_F64:
+  case AST_TREE_TOKEN_TYPE_F128:
+  case AST_TREE_TOKEN_TYPE_BOOL:
+    return true;
+  case AST_TREE_TOKEN_VALUE_VOID:
+  case AST_TREE_TOKEN_VALUE_NULL:
+  case AST_TREE_TOKEN_VALUE_UNDEFINED:
+  case AST_TREE_TOKEN_VALUE_BOOL:
+  case AST_TREE_TOKEN_VALUE_INT:
+  case AST_TREE_TOKEN_VALUE_FLOAT:
+  case AST_TREE_TOKEN_VALUE_OBJECT:
+  case AST_TREE_TOKEN_RAW_VALUE_NOT_OWNED:
+  case AST_TREE_TOKEN_VALUE_C_LIBRARY:
+  case AST_TREE_TOKEN_VALUE_C_FUNCTION:
+  case AST_TREE_TOKEN_VALUE_SHAPE_SHIFTER:
+  case AST_TREE_TOKEN_VALUE_MACRO:
+  case AST_TREE_TOKEN_VALUE_NAMESPACE:
+  case AST_TREE_TOKEN_TYPE_FUNCTION:
+  case AST_TREE_TOKEN_TYPE_CODE:
+  case AST_TREE_TOKEN_TYPE_NAMESPACE:
+  case AST_TREE_TOKEN_TYPE_SHAPE_SHIFTER:
+  case AST_TREE_TOKEN_FUNCTION:
+  case AST_TREE_TOKEN_BUILTIN_CAST:
+  case AST_TREE_TOKEN_BUILTIN_TYPE_OF:
+  case AST_TREE_TOKEN_BUILTIN_IMPORT:
+  case AST_TREE_TOKEN_BUILTIN_IS_COMPTIME:
+  case AST_TREE_TOKEN_BUILTIN_STACK_ALLOC:
+  case AST_TREE_TOKEN_BUILTIN_HEAP_ALLOC:
+  case AST_TREE_TOKEN_BUILTIN_NEG:
+  case AST_TREE_TOKEN_BUILTIN_ADD:
+  case AST_TREE_TOKEN_BUILTIN_SUB:
+  case AST_TREE_TOKEN_BUILTIN_MUL:
+  case AST_TREE_TOKEN_BUILTIN_DIV:
+  case AST_TREE_TOKEN_BUILTIN_MOD:
+  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:
+  case AST_TREE_TOKEN_BUILTIN_PUTC:
+  case AST_TREE_TOKEN_BUILTIN_BITWISE_NOT:
+  case AST_TREE_TOKEN_BUILTIN_BITWISE_AND:
+  case AST_TREE_TOKEN_BUILTIN_BITWISE_XOR:
+  case AST_TREE_TOKEN_BUILTIN_BITWISE_OR:
+  case AST_TREE_TOKEN_BUILTIN_SHIFT_LEFT:
+  case AST_TREE_TOKEN_BUILTIN_SHIFT_RIGHT:
+  case AST_TREE_TOKEN_BUILTIN_INSERT:
+  case AST_TREE_TOKEN_KEYWORD_RETURN:
+  case AST_TREE_TOKEN_KEYWORD_BREAK:
+  case AST_TREE_TOKEN_KEYWORD_CONTINUE:
+  case AST_TREE_TOKEN_KEYWORD_IF:
+  case AST_TREE_TOKEN_KEYWORD_WHILE:
+  case AST_TREE_TOKEN_KEYWORD_COMPTIME:
+  case AST_TREE_TOKEN_KEYWORD_STRUCT:
+  case AST_TREE_TOKEN_FUNCTION_CALL:
+  case AST_TREE_TOKEN_VARIABLE:
+  case AST_TREE_TOKEN_VARIABLE_DEFINE:
+  case AST_TREE_TOKEN_RAW_VALUE:
+  case AST_TREE_TOKEN_SHAPE_SHIFTER_ELEMENT:
+  case AST_TREE_TOKEN_OPERATOR_ASSIGN:
+  case AST_TREE_TOKEN_OPERATOR_PLUS:
+  case AST_TREE_TOKEN_OPERATOR_MINUS:
+  case AST_TREE_TOKEN_OPERATOR_SUM:
+  case AST_TREE_TOKEN_OPERATOR_SUB:
+  case AST_TREE_TOKEN_OPERATOR_MULTIPLY:
+  case AST_TREE_TOKEN_OPERATOR_DIVIDE:
+  case AST_TREE_TOKEN_OPERATOR_MODULO:
+  case AST_TREE_TOKEN_OPERATOR_EQUAL:
+  case AST_TREE_TOKEN_OPERATOR_NOT_EQUAL:
+  case AST_TREE_TOKEN_OPERATOR_GREATER:
+  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_OPERATOR_POINTER:
+  case AST_TREE_TOKEN_OPERATOR_ADDRESS:
+  case AST_TREE_TOKEN_OPERATOR_DEREFERENCE:
+  case AST_TREE_TOKEN_OPERATOR_ACCESS:
+  case AST_TREE_TOKEN_OPERATOR_LOGICAL_NOT:
+  case AST_TREE_TOKEN_OPERATOR_LOGICAL_AND:
+  case AST_TREE_TOKEN_OPERATOR_LOGICAL_OR:
+  case AST_TREE_TOKEN_OPERATOR_BITWISE_NOT:
+  case AST_TREE_TOKEN_OPERATOR_BITWISE_AND:
+  case AST_TREE_TOKEN_OPERATOR_BITWISE_XOR:
+  case AST_TREE_TOKEN_OPERATOR_BITWISE_OR:
+  case AST_TREE_TOKEN_OPERATOR_SHIFT_LEFT:
+  case AST_TREE_TOKEN_OPERATOR_SHIFT_RIGHT:
+  case AST_TREE_TOKEN_OPERATOR_ARRAY_ACCESS:
+  case AST_TREE_TOKEN_OPERATOR_ARRAY_ACCESS_ASSIGN:
+  case AST_TREE_TOKEN_OPERATOR_ARRAY_ACCESS_ADDRESS:
+  case AST_TREE_TOKEN_SCOPE:
   case AST_TREE_TOKEN_TYPE_ANY_TYPE:
   case AST_TREE_TOKEN_BUILTIN_SIZE_OF:
   case AST_TREE_TOKEN_BUILTIN_C_LIBRARY:
@@ -2136,8 +2240,10 @@ AstTree *toRawValue(AstTree *value, AstTreeScope *scope) {
   case AST_TREE_TOKEN_TYPE_C_LIBRARY:
   case AST_TREE_TOKEN_TYPE_C_FUNCTION:
   case AST_TREE_TOKEN_TYPE_MACRO:
+    return false;
+  case AST_TREE_TOKEN_NONE:
   }
-  return NULL;
+  UNREACHABLE;
 }
 
 AstTree *fromRawValue(AstTree *value) {
diff --git a/src/runner/runner.h b/src/runner/runner.h
index 3175ece..815cb0a 100644
--- a/src/runner/runner.h
+++ b/src/runner/runner.h
@@ -31,13 +31,10 @@ AstTree *runExpression(AstTree *expr, AstTreeScope *scope, bool *shouldRet,
                        bool isLeft, bool isComptime, u32 *breakCount,
                        bool *shouldContinue);
 
-AstTree *getForVariable(AstTree *expr, AstTreeScope *scope, bool *shouldRet,
-                        bool isLeft, bool isComptime, u32 *breakCount,
-                        bool *shouldContinue, bool isLazy);
-
 bool discontinue(bool shouldRet, u32 breakCount);
 
 AstTree *toRawValue(AstTree *value, AstTreeScope *scope);
+bool canBeRaw(AstTree *type);
 AstTree *fromRawValue(AstTree *value);
 
 AstTree *castTo(AstTree *value, AstTree *to);