nomen-lang 0.0.10 → 0.0.11

package/dist/index.mjs

@@ -3742,6 +3742,9 @@ var ForLoopNode = class extends BaseNode {
 	index;
 	update;
 	statements;
+	/** `for ref x of arr` — the user wants mutable element access. For arrays
+	*  this desugars to copy-out / mutate / copy-back via .at()/.set(). */
+	item_is_ref;
 	constructor(start, item, list, statements, update) {
 		super("for", start);
 		this.item = item;
@@ -5094,6 +5097,7 @@ function build_break_node$1(status) {
 	const loop = status.loop_labels?.[status.loop_labels.length - 1];
 	if (loop) {
 		emit_cleanup_to_loop_depth(status);
+		status.loop_writebacks?.[status.loop_writebacks.length - 1]?.();
 		status.code += `b ${loop.end}\n`;
 	}
 }
@@ -5172,6 +5176,7 @@ function build_continue_node$1(status) {
 	const loop = status.loop_labels?.[status.loop_labels.length - 1];
 	if (loop) {
 		emit_cleanup_to_loop_depth(status);
+		status.loop_writebacks?.[status.loop_writebacks.length - 1]?.();
 		status.code += `b ${loop.start}\n`;
 	}
 }
@@ -6604,6 +6609,8 @@ function build_for_loop_node$1(node, status) {
 		end: end_label,
 		cleanup_depth
 	});
+	if (!status.loop_writebacks) status.loop_writebacks = [];
+	status.loop_writebacks.push(void 0);
 	if (status.function_return_label) {
 		const item_offset = allocate_stack_space(status, 8);
 		status.stack_offsets.set(item_name, item_offset);
@@ -6817,7 +6824,49 @@ function build_for_loop_node$1(node, status) {
 			else status.code += `ldr x0, [x0]\n`;
 			emit_var_store(status, "x0", item_name, element_size);
 		}
+		if (node.item_is_ref) {
+			const wb_struct_type = struct_type;
+			const wb_element_size = element_size;
+			const wb_item_name = item_name;
+			const wb_idx_name = idx_name;
+			const wb_list_name = list_name;
+			const wb_list_is_pointer = list_is_pointer;
+			const wb_shift = shift;
+			status.loop_writebacks[status.loop_writebacks.length - 1] = () => {
+				if (wb_list_is_pointer) {
+					emit_var_load(status, "x9", wb_list_name, 8);
+					if (status.heap_array_vars?.has(wb_list_name)) status.code += `add x9, x9, #8\n`;
+				} else emit_var_address(status, "x9", wb_list_name);
+				emit_var_load(status, "x10", wb_idx_name, 8);
+				if (Number.isInteger(wb_shift) && wb_shift > 0) status.code += `add x9, x9, x10, lsl #${wb_shift}\n`;
+				else {
+					status.code += `mov x11, #${wb_element_size}\n`;
+					status.code += `mul x10, x10, x11\n`;
+					status.code += `add x9, x9, x10\n`;
+				}
+				if (wb_struct_type) {
+					const item_offset = status.stack_offsets.get(wb_item_name);
+					if (item_offset !== void 0) {
+						const words = Math.ceil(wb_element_size / 8);
+						for (let w = 0; w < words; w++) {
+							status.code += `ldr x10, [x29, #${item_offset + w * 8}]\n`;
+							status.code += `str x10, [x9, #${w * 8}]\n`;
+						}
+					}
+				} else if (wb_element_size === 1) {
+					emit_var_load(status, "x10", wb_item_name, wb_element_size);
+					status.code += `strb w10, [x9]\n`;
+				} else if (wb_element_size === 4) {
+					emit_var_load(status, "x10", wb_item_name, wb_element_size);
+					status.code += `str w10, [x9]\n`;
+				} else {
+					emit_var_load(status, "x10", wb_item_name, wb_element_size);
+					status.code += `str x10, [x9]\n`;
+				}
+			};
+		}
 		build_block_node$1(node, status);
+		status.loop_writebacks[status.loop_writebacks.length - 1]?.();
 		if (node.update) {
 			status.code += `${continue_label}:\n`;
 			build_node$1(node.update, status);
@@ -6835,6 +6884,7 @@ function build_for_loop_node$1(node, status) {
 	else status.register_allocations = void 0;
 	status.buffer_data_cache = saved_buffer_cache;
 	status.loop_labels.pop();
+	status.loop_writebacks?.pop();
 	status.scoped_declarations = old_scoped_declarations;
 }
 function is_enumerable_type$1(node, status) {
@@ -14064,6 +14114,7 @@ function build_async_block_node(node, status) {
 //#region ../src/build_c/build_break_node.ts
 function build_break_node(node, status) {
 	reclaim_to_loop_body(status);
+	status.loop_writebacks?.[status.loop_writebacks.length - 1]?.();
 	status.code += `break;\n`;
 }
 //#endregion
@@ -14088,6 +14139,7 @@ function build_cast_node(node, status) {
 //#region ../src/build_c/build_continue_node.ts
 function build_continue_node(node, status) {
 	reclaim_to_loop_body(status);
+	status.loop_writebacks?.[status.loop_writebacks.length - 1]?.();
 	status.code += `continue;\n`;
 }
 //#endregion
@@ -14373,6 +14425,7 @@ function build_for_loop_node(node, status) {
 	const old_deferred_frees = status.deferred_frees;
 	status.deferred_frees = [];
 	push_c_loop_frame(status);
+	let ref_writeback;
 	if (node.item && node.list) if (node.list.node_type == "range") {
 		status.code += "{\n";
 		status.code += `${c_type("int")} `;
@@ -14439,14 +14492,27 @@ function build_for_loop_node(node, status) {
 			build_node(node.list, status);
 			status.code += `[${idx_var}];\n`;
 		}
+		if (node.item_is_ref) {
+			let wb_target;
+			if (is_heap) wb_target = `((${elem_is_class ? `struct ${element_type} **` : `${elem_struct ? `struct ${element_type}` : c_type(element_type)} *`})((char *)${list_name} + sizeof(struct Array_${element_type})))[${idx_var}]`;
+			else wb_target = `${list_name}[${idx_var}]`;
+			const wb_code = `${wb_target} = ${node.item.value};\n`;
+			ref_writeback = () => {
+				status.code += wb_code;
+			};
+		}
 	}
+	if (!status.loop_writebacks) status.loop_writebacks = [];
+	status.loop_writebacks.push(ref_writeback);
 	build_block_node(node, status);
 	if (node.update) {
 		build_node(node.update, status);
 		status.code += ";\n";
 	}
+	if (ref_writeback) ref_writeback();
 	build_auto_free(status);
 	status.code += `}\n`;
+	status.loop_writebacks.pop();
 	if (node.list && (node.list.node_type == "range" || is_enumerable_type(node.list, status))) status.code += `}\n`;
 	pop_c_loop_frame(status);
 	leave_c_scope(status);
@@ -15410,8 +15476,7 @@ const CALL_KEYWORDS = /* @__PURE__ */ new Set([
 	"trait",
 	"enum",
 	"bitset",
-	"cast",
-	"view"
+	"cast"
 ]);
 const NO_SPACE_BEFORE = /* @__PURE__ */ new Set([
 	",",
@@ -16021,9 +16086,10 @@ const PAIRS = {
 * formatted source doesn't tokenize to exactly the same stream, the original is
 * returned untouched. Nomen's tokenizer folds a sign into the number that
 * follows it (`a -1` is not `a - 1`), so a spacing slip really can change the
-* meaning of a program — never let one through.
+* meaning of a program — never let one through. Pass `force` to apply the
+* layout anyway (e.g. for an explicit "force format" command).
 */
-function format_source(source, options) {
+function format_source(source, options, force = false) {
 	const config = {
 		...default_format_options,
 		...options
@@ -16034,7 +16100,7 @@ function format_source(source, options) {
 		strip_redundant_types: false
 	});
 	const difference = token_difference(source, layout);
-	if (difference) return {
+	if (difference && !force) return {
 		code: source,
 		changed: false,
 		unsafe: difference
@@ -16767,14 +16833,20 @@ function struct_owns_heap(s, status, visited) {
 //#endregion
 //#region ../src/check/utils/type_name.ts
 function type_name(type) {
-	if (type.tuple_types?.length && (type.name === "tuple" || type.name.startsWith("_Tuple_"))) return `[${type.tuple_types.map((t) => type_name(t)).join(", ")}]${type.is_nullable ? "?" : ""}`;
+	const prefix = type_modifier(type);
+	if (type.tuple_types?.length && (type.name === "tuple" || type.name.startsWith("_Tuple_"))) return `${prefix}[${type.tuple_types.map((t) => type_name(t)).join(", ")}]${type.is_nullable ? "?" : ""}`;
 	if (type.is_array) return `Array<${type_name_without_array(type)}>${type.is_nullable ? "?" : ""}`;
 	const args = type.type_args?.length ? `<${type.type_args.map((t) => type_name(t)).join(", ")}>` : "";
-	return `${type.is_ref ? "ref " : ""}${type.name}${args}${type.is_nullable ? "?" : ""}`;
+	return `${prefix}${type.name}${args}${type.is_nullable ? "?" : ""}`;
+}
+function type_modifier(type) {
+	if (type.is_view) return "view ";
+	if (type.is_ref) return "ref ";
+	return "";
 }
 function type_name_without_array(type) {
 	const args = type.type_args?.length ? `<${type.type_args.map((t) => type_name(t)).join(", ")}>` : "";
-	return `${type.is_ref ? "ref " : ""}${type.name}${args}`;
+	return `${type_modifier(type)}${type.name}${args}`;
 }
 //#endregion
 //#region ../src/check/utils/check_type_and_value_match.ts
@@ -17693,6 +17765,7 @@ function evaluate_operation(op, status) {
 	if (op.op === "<" || op.op === "<=" || op.op === ">" || op.op === ">=") {
 		const num = evaluate_numeric_comparison(op, status);
 		if (num !== void 0) return num;
+		if (op.op === "<=" && is_zero(op.left_value, status) && is_nonnegative_access(op.right_value) || op.op === ">=" && is_zero(op.right_value, status) && is_nonnegative_access(op.left_value)) return true;
 		let left_var;
 		let left_offset = 0;
 		if (op.left_value.node_type === "value") left_var = op.left_value.value;
@@ -17989,6 +18062,25 @@ function evaluate_numeric_or_bool(node, status) {
 		return evaluate_const_condition(op_node, status);
 	}
 }
+const NON_NEGATIVE_FIELDS = /* @__PURE__ */ new Set([
+	"length",
+	"cap",
+	"count",
+	"size"
+]);
+/** Does `node` read a container's length/capacity, which is always >= 0? */
+function is_nonnegative_access(node) {
+	if (node.node_type !== "access") return false;
+	const access = node;
+	if (access.access.node_type === "access_field") return NON_NEGATIVE_FIELDS.has(access.access.name);
+	if (access.access.node_type === "access_func") return NON_NEGATIVE_FIELDS.has(access.access.name);
+	return false;
+}
+/** Does `node` evaluate to the compile-time integer 0 (literal or const)? */
+function is_zero(node, status) {
+	const value = evaluate_numeric_or_bool(node, status);
+	return typeof value === "number" && value === 0;
+}
 //#endregion
 //#region ../src/check/utils/is_visible.ts
 /**
@@ -18360,10 +18452,12 @@ function check_function_call(node, status, func, target_type, self_value, self_p
 			}
 			const satisfied = evaluate_const_condition(func_param.constraint, status);
 			status.values.length = saved_values_length;
-			if (satisfied === false) add_error(status, `Parameter constraint not satisfied: ${func_param.name}`, param.start);
+			const constraint_source = expression_to_source(func_param.constraint);
+			const suffix = constraint_source ? `\n  ${constraint_source}` : "";
+			if (satisfied === false) add_error(status, `Parameter constraint not satisfied: ${func_param.name}${suffix}`, param.start);
 			else if (satisfied === void 0) {
-				if (!is_inside_core_method(status)) add_error(status, `Parameter constraint cannot be verified: ${func_param.name}`, param.start);
-			} else if (satisfied === "unsafe") add_error(status, `Parameter constraint not satisfied: ${func_param.name}`, param.start);
+				if (!is_inside_core_method(status)) add_error(status, `Parameter constraint cannot be verified: ${func_param.name}${suffix}`, param.start);
+			} else if (satisfied === "unsafe") add_error(status, `Parameter constraint not satisfied: ${func_param.name}${suffix}`, param.start);
 		}
 		if (param.node_type !== "value" && !has_ref_keyword && !node.swap_params?.has(i) && !(i === node.variadic_param_index && param.node_type === "array")) {
 			const declaration_name = `_param_${status.var_name_counter.value++}`;
@@ -18452,6 +18546,29 @@ function find_lhs_var_name(status) {
 		if (node.node_type === "func") return void 0;
 	}
 }
+/** Render a constraint expression AST back to a source-like string. */
+function expression_to_source(node) {
+	if (!node) return "";
+	if (node.node_type === "value") return node.value;
+	if (node.node_type === "access") {
+		const access = node;
+		const target = expression_to_source(access.target);
+		if (access.access.node_type === "access_field") {
+			const name = access.access.name;
+			return target ? `${target}.${name}` : name;
+		}
+		if (access.access.node_type === "access_func") {
+			const name = access.access.name;
+			return target ? `${target}.${name}()` : `${name}()`;
+		}
+		return target;
+	}
+	if (node.node_type === "op") {
+		const op = node;
+		return `${expression_to_source(op.left_value)} ${op.op} ${expression_to_source(op.right_value)}`;
+	}
+	return "";
+}
 //#endregion
 //#region ../src/nodes/clone_node.ts
 function clone_type$2(type) {
@@ -19032,7 +19149,12 @@ function materialize_tuple_type(type, status) {
 //#endregion
 //#region ../src/check/check_declaration_node.ts
 function check_declaration_node(decl, status) {
+	const is_view_keyword = decl.declaration === "view";
+	const declaration = decl.declaration === "view" ? "const" : decl.declaration;
+	decl.declaration = declaration;
+	const declared_type_is_view = !!decl.type.is_view;
 	if (decl.func_params) {
+		if (is_view_keyword) add_error(status, `'view' cannot declare a function-typed binding`, decl.start);
 		if (decl.func_return_type) {
 			check_type_exists(decl.func_return_type, status, -1);
 			if (decl.func_return_type.name === "tuple" && decl.func_return_type.tuple_types?.length) decl.func_return_type = materialize_tuple_type(decl.func_return_type, status);
@@ -19070,13 +19192,13 @@ function check_declaration_node(decl, status) {
 			status.stack.pop();
 		}
 		status.values.push({
-			declaration: decl.declaration,
+			declaration,
 			name: decl.name,
 			type: decl.func_return_type || decl.type,
 			is_set: !!decl.value,
 			start: decl.start,
 			is_null: decl.value?.node_type === "value" && decl.value.value === "null",
-			const_value: decl.declaration === "const" ? extract_const_value(decl.value) : void 0,
+			const_value: declaration === "const" ? extract_const_value(decl.value) : void 0,
 			constraint: decl.constraint,
 			func_params: decl.func_params?.map((p) => ({
 				name: p.name,
@@ -19103,6 +19225,8 @@ function check_declaration_node(decl, status) {
 			}
 			status.stack.pop();
 		}
+		if (is_view_keyword && decl.value && !decl.type.is_view) add_error(status, `'view' binding requires a view value (e.g. a .slice() result), got ${decl.type.name}`, decl.value.start);
+		if (!is_view_keyword && !declared_type_is_view && decl.type.is_view && decl.value) add_error(status, `binding a view requires the 'view' keyword (e.g. 'view name = ...' or 'var view name = ...')`, decl.value.start);
 		if (decl.type.name === "string" && decl.value && decl.value.node_type === "value" && decl.value.value.startsWith("\"") && decl.value.value.endsWith("\"")) {
 			const len = decl.value.value.length - 2;
 			decl.type.length = new ValueNode(decl.value.start, len.toString(), new Type("int"));
@@ -19127,13 +19251,13 @@ function check_declaration_node(decl, status) {
 		check_constraint(decl, status);
 		const class_alias_src = decl.value?.node_type === "value" && !decl.value.is_moved && decl.value.value !== "null" && decl.type.name && is_class_type$1(decl.type.name, status) ? decl.value.value : void 0;
 		status.values.push({
-			declaration: decl.declaration,
+			declaration,
 			name: decl.name,
 			type: decl.type,
 			is_set: !!decl.value,
 			start: decl.start,
 			is_null: decl.value?.node_type === "value" && decl.value.value === "null",
-			const_value: decl.declaration === "const" ? extract_const_value(decl.value) : void 0,
+			const_value: declaration === "const" ? extract_const_value(decl.value) : void 0,
 			constraint: decl.constraint,
 			decl_depth: status.scope_depth,
 			borrow_depth: decl.value ? borrow_depth_of(decl.value, status) : void 0,
@@ -19257,8 +19381,8 @@ function check_struct_node(struct, status) {
 	const values_length_before_fields = status.values.length;
 	for (let decl of struct.fields) {
 		decl.scope = struct;
-		if (decl.type.is_ref || decl.type.is_view) {
-			add_error(status, `${struct.is_class ? "class" : "struct"} fields cannot be '${decl.type.is_view ? "view" : "ref"}'`, decl.start);
+		if (decl.type.is_ref || decl.type.is_view || decl.declaration === "view") {
+			add_error(status, `${struct.is_class ? "class" : "struct"} fields cannot be '${decl.type.is_view || decl.declaration === "view" ? "view" : "ref"}'`, decl.start);
 			continue;
 		}
 		if (!struct.is_class && is_class_type$1(decl.type.name, status)) add_error(status, `struct fields cannot be class types, use a class instead`, decl.start);
@@ -21723,6 +21847,7 @@ function check_for_loop_node(for_loop, status) {
 		const has_at = list_type.name !== void 0 && !!status.structs.find((s) => s.name === "Array_" + list_type.name && s.functions.some((f) => f.name === "at"));
 		if (list_type.is_array && !enumerable && has_at) {
 			desugar_array_for_loop(for_loop, list_type);
+			for_loop.item_is_ref = false;
 			check_for_loop_node(for_loop, status);
 			return;
 		}
@@ -21733,7 +21858,13 @@ function check_for_loop_node(for_loop, status) {
 		const list_type = type_from_value_node(for_loop.list, for_status);
 		const is_enumerable = list_type.name ? has_trait(list_type.name, "Enumerable", for_status) : false;
 		if (!list_type.is_array && !is_enumerable && list_type.name) add_error(for_status, `For loop list must be an array or Enumerable, not ${list_type.name}`, for_loop.list.start);
+		if (for_loop.item_is_ref && list_type.is_array && for_loop.list.node_type === "value") {
+			const list_name = for_loop.list.value;
+			const list_value = for_status.values.find((v) => v.name === list_name);
+			if (list_value && list_value.declaration !== "var") add_error(for_status, `'ref' iteration requires a 'var' array, but '${list_name}' is const`, for_loop.list.start);
+		}
 		if (for_loop.item) {
+			if (for_loop.item_is_ref && (for_loop.list instanceof RangeNode || is_enumerable)) add_error(for_status, `'ref' is only valid for array element iteration (for ref x of arr), not ranges or Enumerable types`, for_loop.item.start);
 			if (is_enumerable) for_loop.item.type = new Type("int", true);
 			else for_loop.item.type = new Type(list_type.name);
 			let range_lower;
@@ -21754,7 +21885,7 @@ function check_for_loop_node(for_loop, status) {
 				if (upper_bound_expr) upper_bound_expr = upper_bound_expr + ".length";
 			}
 			for_status.values.push({
-				declaration: "var",
+				declaration: for_loop.item_is_ref ? "var" : "const",
 				name: for_loop.item.value,
 				type: for_loop.item.type,
 				is_set: true,
@@ -21769,19 +21900,56 @@ function check_for_loop_node(for_loop, status) {
 	if (for_loop.update) check_node(for_loop.update, for_status);
 	persist_invalidated(status, for_status);
 }
-/** Rewrite `for x of arr` in place into `for __idx of 0..arr.length { var x = arr.at(__idx) }`. */
+/**
+* Rewrite `for x of arr` in place into `for __idx of 0..arr.length { x = arr.at(__idx) }`.
+*
+* By default `x` is const (read-only). For `for ref x of arr` the desugaring is
+* copy-out / mutate / copy-back: `var x = arr.at(__idx)` is prepended and
+* `arr.set(__idx, x)` is appended, with the write-back duplicated before every
+* break/continue so mutations persist on all exit paths. (The write-back is
+* skipped on `return`, matching Rust's copy semantics.)
+*/
 function desugar_array_for_loop(for_loop, array_type) {
 	const list = for_loop.list;
 	const start = list.start;
 	const original_item = for_loop.item;
 	const idx_name = `__for_idx_${original_item.value}`;
+	const is_ref = !!for_loop.item_is_ref;
 	for_loop.item = new ValueNode(original_item.start, idx_name);
 	for_loop.list = new RangeNode(start, new ValueNode(start, "0"), array_type.length ? clone_node(array_type.length) : new AccessNode(start, clone_node(list), new AccessFieldNode(start, "length")));
 	const at_call = new AccessFunctionCallNode(start, "at", new Type(""), [new ValueNode(start, idx_name)]);
 	const at_access = new AccessNode(start, clone_node(list), at_call);
-	const decl = new DeclarationNode(original_item.start, "private", "var", original_item.value, new Type(array_type.name), at_access);
+	const decl = new DeclarationNode(original_item.start, "private", is_ref ? "var" : "const", original_item.value, new Type(array_type.name), at_access);
 	decl.is_loop_iterator = true;
 	for_loop.statements.unshift(decl);
+	if (is_ref) {
+		const make_writeback = () => {
+			const set_call = new AccessFunctionCallNode(start, "set", new Type(""), [new ValueNode(start, idx_name), new ValueNode(start, original_item.value)]);
+			return new AccessNode(start, clone_node(list), set_call);
+		};
+		insert_writebacks(for_loop.statements, make_writeback);
+		for_loop.statements.push(make_writeback());
+	}
+}
+/**
+* Walk a statement array and insert a write-back node before every break /
+* continue that belongs to the current loop. Nested for/while loops and nested
+* function bodies are not descended into (their exits belong to them).
+*/
+function insert_writebacks(statements, make_writeback) {
+	for (let i = statements.length - 1; i >= 0; i--) {
+		const stmt = statements[i];
+		if (stmt.node_type === "break" || stmt.node_type === "continue") {
+			statements.splice(i, 0, make_writeback());
+			continue;
+		}
+		if (stmt.node_type === "for" || stmt.node_type === "while" || stmt.node_type === "func") continue;
+		for (const key of Object.keys(stmt)) {
+			if (key === "parent" || key === "scope") continue;
+			const val = stmt[key];
+			if (Array.isArray(val)) insert_writebacks(val, make_writeback);
+		}
+	}
 }
 function evaluate_range_bound_value(node, status) {
 	const val = evaluate_numeric_or_bool(node, status);
@@ -22696,6 +22864,10 @@ function warn_var_not_changed(decl, locals, status) {
 	if (is_discard(decl.name)) return;
 	if (locals.assigned.has(decl.name)) return;
 	if (status.mutated_local_names?.has(decl.name)) return;
+	if (decl.type?.is_view) {
+		add_warning(status, `View '${decl.name}' is never re-pointed, consider dropping 'var' (use 'view ${decl.name} = ...')`, decl.name_start ?? decl.start);
+		return;
+	}
 	add_warning(status, `Variable '${decl.name}' is never changed, consider using const`, decl.name_start ?? decl.start);
 }
 /** Names that count as a "use": call targets, method names, and value reads. */
@@ -23048,12 +23220,23 @@ function parse_declaration(visibility, declaration, status) {
 		decl.type_start = get_index(status);
 		decl.type = parse_type(status);
 		if (peek_current(status) === "=" || status.i >= status.tokens.length) {
-			status.i = saved_i;
-			status.errors.length = saved_errors_length;
-			decl.type = new Type("");
-			decl.type_start = void 0;
-			decl.name_start = get_index(status);
-			decl.name = consume(status);
+			const modifier = status.tokens[saved_i]?.value;
+			if ((modifier === "view" || modifier === "ref") && decl.type.name) {
+				decl.name = decl.type.name;
+				decl.name_start = saved_i + 1;
+				const inferred = new Type("");
+				if (modifier === "view") inferred.is_view = true;
+				else inferred.is_ref = true;
+				decl.type = inferred;
+				decl.type_start = void 0;
+			} else {
+				status.i = saved_i;
+				status.errors.length = saved_errors_length;
+				decl.type = new Type("");
+				decl.type_start = void 0;
+				decl.name_start = get_index(status);
+				decl.name = consume(status);
+			}
 		} else {
 			decl.name_start = get_index(status);
 			decl.name = consume(status);
@@ -24278,13 +24461,16 @@ function parse_extend(visibility, status) {
 function parse_for_loop(status) {
 	const for_start = get_index(status);
 	accept("for", status);
-	const item = new ValueNode(get_index(status), consume(status));
+	const start = get_index(status);
+	const item_is_ref = accept("ref", status);
+	const item = new ValueNode(start, consume(status));
 	if (expect("of", status)) {
 		const list = parse_expression(status);
 		let update;
 		if (accept(";", status)) update = parse_expression(status);
 		if (expect("{", status)) {
 			const for_loop = new ForLoopNode(for_start, item, list, void 0, update);
+			for_loop.item_is_ref = item_is_ref;
 			status.stack.push(for_loop);
 			parse_statement(status);
 			expect("}", status);
@@ -24382,6 +24568,7 @@ function parse_visibility(visibility, status) {
 		case "const":
 		case "var":
 		case "mov":
+		case "view":
 			if (visibility === "private" && status.stack.at(-1)?.node_type === "trait") {
 				add_error(status, `Trait fields cannot be private`, get_index(status));
 				consume(status);
@@ -24473,6 +24660,7 @@ function parse_statement(status) {
 			case "const":
 			case "var":
 			case "mov":
+			case "view":
 				parse_declaration(default_visibility(status), value, status);
 				break;
 			case "struct":

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nomen-lang",
-  "version": "0.0.10",
+  "version": "0.0.11",
   "description": "The CLI for the Nomen programming language.",
   "keywords": [],
   "license": "ISC",