fixing some problems with array access

5 files changed, 102 insertions, 107 deletions

diff --git a/code/lib/operator.felan b/code/lib/operator.felan
index 2112c57..3da070a 100644
--- a/code/lib/operator.felan
+++ b/code/lib/operator.felan
@@ -801,4 +801,15 @@ __sub__ :: (left:*anytype,right:i64) -> (@type_of(left)) {
   return @sub(left,right);
 };
 
+__get_item__ :: (left:*anytype,index:i64) -> (@type_of(left.*)) {
+  return (left + index).*;
+};
+
+__set_item__ :: (left:*anytype,index:i64,item:@type_of(left.*)) -> (@type_of(left.*)) {
+  return (left + index).* = item;
+};
+
+__get_item_address__ :: (left:*anytype,index:i64) -> (@type_of(left)) {
+  return (left + index);
+};
 
diff --git a/code/main.felan b/code/main.felan
index 3e98896..5b0c634 100644
--- a/code/main.felan
+++ b/code/main.felan
@@ -10,21 +10,12 @@ print :: (value:**anytype)->void{
   }
 };
 
-__get_item__ :: (left:*anytype,index:i64) -> (@type_of(left.*)) {
-  return (left + index).*;
-};
-
-__set_item__ :: (left:*anytype,index:i64,item:@type_of(left.*)) -> (@type_of(left.*)) {
-  return (left + index).* = item;
-};
-
-__get_item_address__ :: (left:*anytype,index:i64,item:@type_of(left.*)) -> (@type_of(left)) {
-  return (left + index);
-};
-
 main :: () -> void {
   a := @stack_alloc(10,u8);
   a[0] = '1';
+  b := &a[2];
+  b.* = '9';
   @putc(a[0]);
+  @putc(b.*);
 };
 
diff --git a/src/compiler/ast-tree.c b/src/compiler/ast-tree.c
index 1206b12..08c8091 100644
--- a/src/compiler/ast-tree.c
+++ b/src/compiler/ast-tree.c
@@ -262,7 +262,6 @@ const char *AST_TREE_TOKEN_STRINGS[] = {
     "AST_TREE_TOKEN_VALUE_BOOL",
     "AST_TREE_TOKEN_VALUE_OBJECT",
     "AST_TREE_TOKEN_RAW_VALUE",
-    "AST_TREE_TOKEN_RAW_VALUE_NOT_OWNED",
 
     "AST_TREE_TOKEN_SHAPE_SHIFTER_ELEMENT",
 
@@ -404,7 +403,6 @@ void astTreePrint(const AstTree *tree, int indent) {
   case AST_TREE_TOKEN_VALUE_NULL:
   case AST_TREE_TOKEN_VALUE_UNDEFINED:
   case AST_TREE_TOKEN_VARIABLE_DEFINE:
-  case AST_TREE_TOKEN_RAW_VALUE_NOT_OWNED:
     goto RETURN_SUCCESS;
   case AST_TREE_TOKEN_TYPE_C_FUNCTION:
     NOT_IMPLEMENTED;
@@ -863,7 +861,6 @@ void astTreeDestroy(AstTree tree) {
   case AST_TREE_TOKEN_VALUE_UNDEFINED:
   case AST_TREE_TOKEN_VALUE_VOID:
   case AST_TREE_TOKEN_VARIABLE_DEFINE:
-  case AST_TREE_TOKEN_RAW_VALUE_NOT_OWNED:
     return;
   case AST_TREE_TOKEN_KEYWORD_BREAK:
   case AST_TREE_TOKEN_KEYWORD_CONTINUE: {
@@ -1315,14 +1312,6 @@ AstTree *copyAstTreeBack(AstTree *tree, AstTreeVariables oldVariables[],
                                       variables_size, safetyCheck),
                       tree->str_begin, tree->str_end);
   }
-  case AST_TREE_TOKEN_RAW_VALUE_NOT_OWNED: {
-    AstTreeRawValue *metadata = tree->metadata;
-    AstTreeRawValue *newMetadata = metadata;
-    return newAstTree(tree->token, newMetadata,
-                      copyAstTreeBack(tree->type, oldVariables, newVariables,
-                                      variables_size, safetyCheck),
-                      tree->str_begin, tree->str_end);
-  }
   case AST_TREE_TOKEN_RAW_VALUE: {
     AstTreeRawValue *metadata = tree->metadata;
     const size_t size = a404m_malloc_usable_size(metadata);
@@ -2569,8 +2558,7 @@ AstTree *astTreeParse(const ParserNode *parserNode) {
     return astTreeParseUnaryOperatorSingleChild(
         parserNode, AST_TREE_TOKEN_OPERATOR_POINTER);
   case PARSER_TOKEN_OPERATOR_ADDRESS:
-    return astTreeParseUnaryOperatorSingleChild(
-        parserNode, AST_TREE_TOKEN_OPERATOR_ADDRESS);
+    return astTreeParseAddressOperator(parserNode);
   case PARSER_TOKEN_OPERATOR_DEREFERENCE:
     return astTreeParseUnaryOperatorSingleChild(
         parserNode, AST_TREE_TOKEN_OPERATOR_DEREFERENCE);
@@ -3195,6 +3183,23 @@ AstTree *astTreeParseUnaryOperatorSingleChild(const ParserNode *parserNode,
                     parserNode->str_end);
 }
 
+AstTree *astTreeParseAddressOperator(const ParserNode *parserNode) {
+  ParserNodeSingleChildMetadata *node_metadata = parserNode->metadata;
+
+  AstTreeSingleChild *metadata = astTreeParse(node_metadata);
+  if (metadata == NULL) {
+    return NULL;
+  }
+
+  if (metadata->token == AST_TREE_TOKEN_OPERATOR_ARRAY_ACCESS) {
+    metadata->token = AST_TREE_TOKEN_OPERATOR_ARRAY_ACCESS_ADDRESS;
+    return metadata;
+  }
+
+  return newAstTree(AST_TREE_TOKEN_OPERATOR_ADDRESS, metadata, NULL,
+                    parserNode->str_begin, parserNode->str_end);
+}
+
 AstTree *astTreeParseOperateAssignOperator(const ParserNode *parserNode,
                                            AstTreeToken token) {
   ParserNodeInfixMetadata *node_metadata = parserNode->metadata;
@@ -3853,7 +3858,6 @@ bool hasAnyTypeInside(AstTree *type) {
   case AST_TREE_TOKEN_VALUE_SHAPE_SHIFTER:
   case AST_TREE_TOKEN_VALUE_C_LIBRARY:
   case AST_TREE_TOKEN_VALUE_C_FUNCTION:
-  case AST_TREE_TOKEN_RAW_VALUE_NOT_OWNED:
   case AST_TREE_TOKEN_SHAPE_SHIFTER_ELEMENT:
   case AST_TREE_TOKEN_OPERATOR_ASSIGN:
   case AST_TREE_TOKEN_OPERATOR_PLUS:
@@ -3957,7 +3961,6 @@ bool isConst(AstTree *tree) {
   case AST_TREE_TOKEN_VALUE_BOOL:
   case AST_TREE_TOKEN_VALUE_OBJECT:
   case AST_TREE_TOKEN_RAW_VALUE:
-  case AST_TREE_TOKEN_RAW_VALUE_NOT_OWNED:
   case AST_TREE_TOKEN_KEYWORD_COMPTIME:
   case AST_TREE_TOKEN_SCOPE:
     return true;
@@ -4254,7 +4257,6 @@ AstTree *makeTypeOf(AstTree *value) {
   case AST_TREE_TOKEN_VALUE_C_LIBRARY:
   case AST_TREE_TOKEN_VALUE_C_FUNCTION:
   case AST_TREE_TOKEN_RAW_VALUE:
-  case AST_TREE_TOKEN_RAW_VALUE_NOT_OWNED:
   case AST_TREE_TOKEN_NONE:
   }
   UNREACHABLE;
@@ -4351,7 +4353,6 @@ bool typeIsEqualBack(const AstTree *type0, const AstTree *type1) {
   case AST_TREE_TOKEN_VALUE_BOOL:
   case AST_TREE_TOKEN_VALUE_OBJECT:
   case AST_TREE_TOKEN_RAW_VALUE:
-  case AST_TREE_TOKEN_RAW_VALUE_NOT_OWNED:
   case AST_TREE_TOKEN_VARIABLE_DEFINE:
   case AST_TREE_TOKEN_OPERATOR_ASSIGN:
   case AST_TREE_TOKEN_OPERATOR_SUM:
@@ -4565,7 +4566,6 @@ AstTree *getValue(AstTree *tree, bool copy) {
   case AST_TREE_TOKEN_VALUE_BOOL:
   case AST_TREE_TOKEN_VALUE_OBJECT:
   case AST_TREE_TOKEN_RAW_VALUE:
-  case AST_TREE_TOKEN_RAW_VALUE_NOT_OWNED:
   case AST_TREE_TOKEN_VARIABLE:
   case AST_TREE_TOKEN_FUNCTION_CALL:
   case AST_TREE_TOKEN_OPERATOR_ASSIGN:
@@ -4736,7 +4736,6 @@ bool isIntType(AstTree *type) {
   case AST_TREE_TOKEN_VALUE_BOOL:
   case AST_TREE_TOKEN_VALUE_OBJECT:
   case AST_TREE_TOKEN_RAW_VALUE:
-  case AST_TREE_TOKEN_RAW_VALUE_NOT_OWNED:
   case AST_TREE_TOKEN_OPERATOR_ASSIGN:
   case AST_TREE_TOKEN_OPERATOR_PLUS:
   case AST_TREE_TOKEN_OPERATOR_MINUS:
@@ -4854,7 +4853,6 @@ bool isFloatType(AstTree *type) {
   case AST_TREE_TOKEN_VALUE_BOOL:
   case AST_TREE_TOKEN_VALUE_OBJECT:
   case AST_TREE_TOKEN_RAW_VALUE:
-  case AST_TREE_TOKEN_RAW_VALUE_NOT_OWNED:
   case AST_TREE_TOKEN_OPERATOR_ASSIGN:
   case AST_TREE_TOKEN_OPERATOR_PLUS:
   case AST_TREE_TOKEN_OPERATOR_MINUS:
@@ -4944,7 +4942,6 @@ bool isEqual(AstTree *left, AstTree *right) {
     AstTreeVariable *right_metadata = right->metadata;
     return isEqualVariable(left_metadata, right_metadata);
   }
-  case AST_TREE_TOKEN_RAW_VALUE_NOT_OWNED:
   case AST_TREE_TOKEN_RAW_VALUE: {
     AstTreeRawValue *left_metadata = left->metadata;
     AstTreeRawValue *right_metadata = right->metadata;
@@ -5418,7 +5415,6 @@ bool setAllTypes(AstTree *tree, AstTreeSetTypesHelper helper,
   case AST_TREE_TOKEN_VALUE_C_FUNCTION:
   case AST_TREE_TOKEN_SHAPE_SHIFTER_ELEMENT:
   case AST_TREE_TOKEN_RAW_VALUE:
-  case AST_TREE_TOKEN_RAW_VALUE_NOT_OWNED:
   case AST_TREE_TOKEN_NONE:
   }
   printError(tree->str_begin, tree->str_end, "Unknown token %d", tree->token);
@@ -6959,7 +6955,6 @@ bool setTypesBuiltinUnary(AstTree *tree, AstTreeSetTypesHelper helper,
   case AST_TREE_TOKEN_VALUE_BOOL:
   case AST_TREE_TOKEN_VALUE_OBJECT:
   case AST_TREE_TOKEN_RAW_VALUE:
-  case AST_TREE_TOKEN_RAW_VALUE_NOT_OWNED:
   case AST_TREE_TOKEN_OPERATOR_ASSIGN:
   case AST_TREE_TOKEN_OPERATOR_PLUS:
   case AST_TREE_TOKEN_OPERATOR_MINUS:
@@ -8148,8 +8143,7 @@ AstTree *getShapeShifterElement(AstTreeFunctionCall *metadata,
 }
 
 char *u8ArrayToCString(AstTree *tree) {
-  if (tree->token == AST_TREE_TOKEN_RAW_VALUE ||
-      tree->token == AST_TREE_TOKEN_RAW_VALUE_NOT_OWNED) {
+  if (tree->token == AST_TREE_TOKEN_RAW_VALUE) {
     AstTreeRawValue *value = tree->metadata;
     const size_t size = getSizeOfType(tree->type);
 
@@ -8286,7 +8280,6 @@ size_t getSizeOfType(AstTree *type) {
   case AST_TREE_TOKEN_VALUE_BOOL:
   case AST_TREE_TOKEN_VALUE_OBJECT:
   case AST_TREE_TOKEN_RAW_VALUE:
-  case AST_TREE_TOKEN_RAW_VALUE_NOT_OWNED:
   case AST_TREE_TOKEN_SHAPE_SHIFTER_ELEMENT:
   case AST_TREE_TOKEN_OPERATOR_ASSIGN:
   case AST_TREE_TOKEN_OPERATOR_PLUS:
diff --git a/src/compiler/ast-tree.h b/src/compiler/ast-tree.h
index ac511b4..364263e 100644
--- a/src/compiler/ast-tree.h
+++ b/src/compiler/ast-tree.h
@@ -88,7 +88,6 @@ typedef enum AstTreeToken {
   AST_TREE_TOKEN_VALUE_BOOL,
   AST_TREE_TOKEN_VALUE_OBJECT,
   AST_TREE_TOKEN_RAW_VALUE,
-  AST_TREE_TOKEN_RAW_VALUE_NOT_OWNED,
 
   AST_TREE_TOKEN_SHAPE_SHIFTER_ELEMENT,
 
@@ -422,6 +421,7 @@ AstTree *astTreeParseUnaryOperator(const ParserNode *parserNode,
                                    AstTreeToken token);
 AstTree *astTreeParseUnaryOperatorSingleChild(const ParserNode *parserNode,
                                               AstTreeToken token);
+AstTree *astTreeParseAddressOperator(const ParserNode *parserNode);
 AstTree *astTreeParseOperateAssignOperator(const ParserNode *parserNode,
                                            AstTreeToken token);
 bool astTreeParseConstant(const ParserNode *parserNode,
diff --git a/src/runner/runner.c b/src/runner/runner.c
index c261730..432a750 100644
--- a/src/runner/runner.c
+++ b/src/runner/runner.c
@@ -1283,8 +1283,7 @@ AstTree *runAstTreeCFunction(AstTree *tree, AstTree **arguments,
       printLog("%s %s", AST_TREE_TOKEN_STRINGS[arg.type->token],
                AST_TREE_TOKEN_STRINGS[arguments[i]->type->token]);
       UNREACHABLE;
-    } else if (arguments[i]->token != AST_TREE_TOKEN_RAW_VALUE &&
-               arguments[i]->token != AST_TREE_TOKEN_RAW_VALUE_NOT_OWNED) {
+    } else if (arguments[i]->token != AST_TREE_TOKEN_RAW_VALUE) {
       UNREACHABLE;
     }
     values[i] = arguments[i]->metadata;
@@ -1430,39 +1429,61 @@ AstTree *runExpression(AstTree *expr, AstTreeScope *scope, bool *shouldRet,
   }
   case AST_TREE_TOKEN_OPERATOR_ASSIGN: {
     AstTreePureInfix *metadata = expr->metadata;
-    AstTree *l = runExpression(metadata->left, scope, shouldRet, true,
-                               isComptime, breakCount, shouldContinue, false);
-    if (discontinue(*shouldRet, *breakCount)) {
-      return l;
-    }
-    if (l->token == AST_TREE_TOKEN_VARIABLE) {
-      AstTreeVariable *left = l->metadata;
+    if (metadata->left->token == AST_TREE_TOKEN_OPERATOR_DEREFERENCE) {
       AstTree *right =
           runExpression(metadata->right, scope, shouldRet, false, isComptime,
                         breakCount, shouldContinue, false);
       if (discontinue(*shouldRet, *breakCount)) {
-        astTreeDelete(l);
         return right;
       }
-      runnerVariableSetValue(left, right);
+
+      AstTree *l = (AstTreeSingleChild *)metadata->left->metadata;
+      l = runExpression(l, scope, shouldRet, false, isComptime, breakCount,
+                        shouldContinue, false);
+      if (right->token != AST_TREE_TOKEN_RAW_VALUE) {
+        UNREACHABLE;
+      }
+      if (l->token != AST_TREE_TOKEN_RAW_VALUE ||
+          l->type->token != AST_TREE_TOKEN_OPERATOR_POINTER) {
+        UNREACHABLE;
+      }
+      void **value = l->metadata;
+      memcpy(*value, right->metadata, getSizeOfType(right->type));
       astTreeDelete(l);
-      return copyAstTree(left->value);
-    } else if (l->token == AST_TREE_TOKEN_RAW_VALUE_NOT_OWNED ||
-               l->token == AST_TREE_TOKEN_RAW_VALUE) {
-      AstTree *right =
-          runExpression(metadata->right, scope, shouldRet, false, isComptime,
-                        breakCount, shouldContinue, false);
+      return right;
+    } else {
+      AstTree *l = runExpression(metadata->left, scope, shouldRet, true,
+                                 isComptime, breakCount, shouldContinue, false);
       if (discontinue(*shouldRet, *breakCount)) {
-        astTreeDelete(l);
-        return right;
+        return l;
       }
-      if (right->token != AST_TREE_TOKEN_RAW_VALUE &&
-          right->token != AST_TREE_TOKEN_RAW_VALUE_NOT_OWNED) {
-        NOT_IMPLEMENTED;
+      if (l->token == AST_TREE_TOKEN_VARIABLE) {
+        AstTreeVariable *left = l->metadata;
+        AstTree *right =
+            runExpression(metadata->right, scope, shouldRet, false, isComptime,
+                          breakCount, shouldContinue, false);
+        if (discontinue(*shouldRet, *breakCount)) {
+          astTreeDelete(l);
+          return right;
+        }
+        runnerVariableSetValue(left, right);
+        astTreeDelete(l);
+        return copyAstTree(left->value);
+      } else if (l->token == AST_TREE_TOKEN_RAW_VALUE) {
+        AstTree *right =
+            runExpression(metadata->right, scope, shouldRet, false, isComptime,
+                          breakCount, shouldContinue, false);
+        if (discontinue(*shouldRet, *breakCount)) {
+          astTreeDelete(l);
+          return right;
+        }
+        if (right->token != AST_TREE_TOKEN_RAW_VALUE) {
+          NOT_IMPLEMENTED;
+        }
+        memcpy(l->metadata, right->metadata, getSizeOfType(l->type));
+        astTreeDelete(right);
+        return l;
       }
-      memcpy(l->metadata, right->metadata, getSizeOfType(l->type));
-      astTreeDelete(right);
-      return l;
     }
     UNREACHABLE;
   }
@@ -1600,7 +1621,6 @@ AstTree *runExpression(AstTree *expr, AstTreeScope *scope, bool *shouldRet,
   case AST_TREE_TOKEN_VALUE_FLOAT:
   case AST_TREE_TOKEN_VALUE_OBJECT:
   case AST_TREE_TOKEN_RAW_VALUE:
-  case AST_TREE_TOKEN_RAW_VALUE_NOT_OWNED:
   case AST_TREE_TOKEN_FUNCTION:
   case AST_TREE_TOKEN_TYPE_ARRAY:
   case AST_TREE_TOKEN_BUILTIN_CAST:
@@ -1634,30 +1654,22 @@ AstTree *runExpression(AstTree *expr, AstTreeScope *scope, bool *shouldRet,
   case AST_TREE_TOKEN_BUILTIN_IS_COMPTIME: {
     AstTreeBool *metadata = a404m_malloc(sizeof(*metadata));
     *metadata = isComptime;
-    return newAstTree(AST_TREE_TOKEN_RAW_VALUE_NOT_OWNED, metadata,
+    return newAstTree(AST_TREE_TOKEN_RAW_VALUE, metadata,
                       copyAstTree(&AST_TREE_BOOL_TYPE), expr->str_begin,
                       expr->str_end);
   }
   case AST_TREE_TOKEN_OPERATOR_ADDRESS: {
     AstTreeSingleChild *metadata = expr->metadata;
-    AstTree *operand =
-        runExpression(metadata, scope, shouldRet, true, isComptime, breakCount,
-                      shouldContinue, false);
-    if (discontinue(*shouldRet, *breakCount)) {
-      return operand;
-    }
-
-    if (operand->token != AST_TREE_TOKEN_RAW_VALUE_NOT_OWNED) {
-      printLog("%s", AST_TREE_TOKEN_STRINGS[operand->token]);
+    if (metadata->token == AST_TREE_TOKEN_VARIABLE) {
+      AstTreeVariable *variable = metadata->metadata;
+      AstTreeRawValue *address = a404m_malloc(sizeof(void *));
+      *(void **)address = variable->value;
+      return newAstTree(AST_TREE_TOKEN_RAW_VALUE, address,
+                        copyAstTree(expr->type), NULL, NULL);
+    } else {
+      printLog("%s", AST_TREE_TOKEN_STRINGS[metadata->token]);
       UNREACHABLE;
     }
-
-    AstTreeRawValue *address = a404m_malloc(sizeof(void *));
-    *(void **)address = operand->metadata;
-    AstTree *type = copyAstTree(expr->type);
-    astTreeDelete(operand);
-
-    return newAstTree(AST_TREE_TOKEN_RAW_VALUE, address, type, NULL, NULL);
   }
   case AST_TREE_TOKEN_OPERATOR_DEREFERENCE: {
     AstTreeSingleChild *metadata = expr->metadata;
@@ -1667,17 +1679,19 @@ AstTree *runExpression(AstTree *expr, AstTreeScope *scope, bool *shouldRet,
     if (discontinue(*shouldRet, *breakCount)) {
       return operand;
     }
-    if (operand->token == AST_TREE_TOKEN_RAW_VALUE_NOT_OWNED ||
-        operand->token == AST_TREE_TOKEN_RAW_VALUE) {
+    if (operand->token == AST_TREE_TOKEN_RAW_VALUE) {
       if (operand->type->token != AST_TREE_TOKEN_OPERATOR_POINTER) {
+        printLog("%s %p", AST_TREE_TOKEN_STRINGS[operand->type->token],
+                 operand);
         UNREACHABLE;
       }
       AstTree *type =
           copyAstTree((AstTreeSingleChild *)operand->type->metadata);
-      AstTreeRawValue *value = *(void **)operand->metadata;
+      size_t size = getSizeOfType(type);
+      AstTreeRawValue *value = a404m_malloc(size);
+      memcpy(value, *(void **)operand->metadata, size);
       astTreeDelete(operand);
-      return newAstTree(AST_TREE_TOKEN_RAW_VALUE_NOT_OWNED, value, type, NULL,
-                        NULL);
+      return newAstTree(AST_TREE_TOKEN_RAW_VALUE, value, type, NULL, NULL);
     } else if (operand->token == AST_TREE_TOKEN_VARIABLE) {
       AstTree *ret;
       if (isLeft) {
@@ -1695,18 +1709,6 @@ AstTree *runExpression(AstTree *expr, AstTreeScope *scope, bool *shouldRet,
   }
   case AST_TREE_TOKEN_VARIABLE: {
     AstTreeVariable *variable = expr->metadata;
-    if (variable->value->token == AST_TREE_TOKEN_RAW_VALUE ||
-        variable->value->token == AST_TREE_TOKEN_RAW_VALUE_NOT_OWNED) {
-      if (needOwnership && variable->value->token == AST_TREE_TOKEN_RAW_VALUE) {
-        variable->value->token = AST_TREE_TOKEN_RAW_VALUE_NOT_OWNED;
-        return newAstTree(AST_TREE_TOKEN_RAW_VALUE, variable->value->metadata,
-                          copyAstTree(expr->type), variable->value->str_begin,
-                          variable->value->str_end);
-      }
-      return newAstTree(AST_TREE_TOKEN_RAW_VALUE_NOT_OWNED,
-                        variable->value->metadata, copyAstTree(expr->type),
-                        variable->value->str_begin, variable->value->str_end);
-    }
     if (isLeft) {
       return copyAstTree(expr);
     } else {
@@ -1714,6 +1716,7 @@ AstTree *runExpression(AstTree *expr, AstTreeScope *scope, bool *shouldRet,
         UNREACHABLE;
       }
       if (variable->isLazy) {
+        UNREACHABLE;
         AstTree *value =
             runExpression(variable->value, scope, shouldRet, false, isComptime,
                           breakCount, shouldContinue, false);
@@ -1797,7 +1800,7 @@ AstTree *runExpression(AstTree *expr, AstTreeScope *scope, bool *shouldRet,
         }
       }
       UNREACHABLE;
-    } else if (tree->token == AST_TREE_TOKEN_RAW_VALUE_NOT_OWNED) {
+    } else if (tree->token == AST_TREE_TOKEN_RAW_VALUE) {
       if (tree->type->token == AST_TREE_TOKEN_TYPE_ARRAY) {
         AstTreeBracket *array_metadata = tree->type->metadata;
         if (metadata->member.index != 0) {
@@ -1823,13 +1826,13 @@ AstTree *runExpression(AstTree *expr, AstTreeScope *scope, bool *shouldRet,
       for (size_t i = 0; i < metadata->member.index; ++i) {
         index += getSizeOfType(type->variables.data[i]->type);
       }
-      AstTreeRawValue *value =
-          (AstTreeRawValue *)((u8 *)tree->metadata + index);
       AstTree *t =
           copyAstTree(type->variables.data[metadata->member.index]->type);
+      size_t size = getSizeOfType(t);
+      AstTreeRawValue *value = a404m_malloc(size);
+      memcpy(value, (u8 *)tree->metadata + index, size);
       astTreeDelete(tree);
-      return newAstTree(AST_TREE_TOKEN_RAW_VALUE_NOT_OWNED, value, t, NULL,
-                        NULL);
+      return newAstTree(AST_TREE_TOKEN_RAW_VALUE, value, t, NULL, NULL);
     } else {
       UNREACHABLE;
     }
@@ -2052,7 +2055,6 @@ AstTree *toRawValue(AstTree *value) {
   case AST_TREE_TOKEN_VARIABLE:
   case AST_TREE_TOKEN_VARIABLE_DEFINE:
   case AST_TREE_TOKEN_RAW_VALUE:
-  case AST_TREE_TOKEN_RAW_VALUE_NOT_OWNED:
   case AST_TREE_TOKEN_SHAPE_SHIFTER_ELEMENT:
   case AST_TREE_TOKEN_OPERATOR_ASSIGN:
   case AST_TREE_TOKEN_OPERATOR_PLUS:
@@ -2261,7 +2263,6 @@ AstTree *castTo(AstTree *tree, AstTree *to) {
   case AST_TREE_TOKEN_VALUE_BOOL:
   case AST_TREE_TOKEN_VALUE_OBJECT:
   case AST_TREE_TOKEN_RAW_VALUE:
-  case AST_TREE_TOKEN_RAW_VALUE_NOT_OWNED:
   case AST_TREE_TOKEN_SHAPE_SHIFTER_ELEMENT:
   case AST_TREE_TOKEN_OPERATOR_ASSIGN:
   case AST_TREE_TOKEN_OPERATOR_PLUS:
@@ -2413,7 +2414,6 @@ ffi_type *toFFIType(AstTree *type) {
   case AST_TREE_TOKEN_VALUE_BOOL:
   case AST_TREE_TOKEN_VALUE_OBJECT:
   case AST_TREE_TOKEN_RAW_VALUE:
-  case AST_TREE_TOKEN_RAW_VALUE_NOT_OWNED:
   case AST_TREE_TOKEN_SHAPE_SHIFTER_ELEMENT:
   case AST_TREE_TOKEN_OPERATOR_ASSIGN:
   case AST_TREE_TOKEN_OPERATOR_PLUS: