nomen-lang 0.0.9 → 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
@@ -16308,14 +16374,22 @@ function describe(token) {
 }
 //#endregion
 //#region ../src/join.ts
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const DEFAULT_LIB_PATH = path.resolve(__dirname, "../../core/src");
+const DEFAULT_LIB_REL = "../../core/src";
+let default_lib_path;
+function fallback_lib_path() {
+	if (default_lib_path === void 0) try {
+		default_lib_path = path.resolve(path.dirname(fileURLToPath(import.meta.url)), DEFAULT_LIB_REL);
+	} catch {
+		default_lib_path = "";
+	}
+	return default_lib_path;
+}
 let test_src_dir;
 function join$1(entry_file_path, lib_path, options) {
 	const folder_path = path.dirname(entry_file_path);
 	const file_path = path.basename(entry_file_path);
 	const inputs = /* @__PURE__ */ new Map();
-	const resolved_lib_path = lib_path ? path.resolve(lib_path, "src") : DEFAULT_LIB_PATH;
+	const resolved_lib_path = lib_path ? path.resolve(lib_path, "src") : fallback_lib_path();
 	const for_test = options?.for_test ?? file_path.endsWith(".test.nm");
 	const prev_test_src_dir = test_src_dir;
 	test_src_dir = for_test ? resolve_src_module(folder_path) : void 0;
@@ -16759,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
@@ -17685,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;
@@ -17981,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
 /**
@@ -18352,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++}`;
@@ -18444,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) {
@@ -19024,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);
@@ -19062,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,
@@ -19095,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"));
@@ -19119,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,
@@ -19249,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);
@@ -21715,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;
 		}
@@ -21725,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;
@@ -21746,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,
@@ -21761,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);
@@ -22688,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. */
@@ -23040,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);
@@ -24270,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);
@@ -24374,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);
@@ -24465,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":
@@ -25223,7 +25419,7 @@ const MAIN_NM = `import System
 pub func add = (int a, int b) => a + b
 
 pub func main = (Init init) {
-	Console.write("Hello world, 2 + 2 is \\{add(a + b)}!\\n")
+	Console.write("Hello world, 2 + 2 is \\{add(2, 2)}!\\n")
 }
 `;
 const TEST_NM = `import System
@@ -25307,6 +25503,30 @@ function run_init(name) {
 	console.log(`\nNext: cd ${name} && nomen run`);
 }
 //#endregion
+//#region src/paths.ts
+/**
+* The project root for `input_path`: the nearest ancestor folder (or the input
+* folder itself) containing a `package.jsonc`. Falls back to the input's own
+* folder for standalone files, so builds stay next to their source.
+*/
+function project_root_for(input_path) {
+	let dir = fs.lstatSync(input_path).isDirectory() ? input_path : path.dirname(input_path);
+	for (let i = 0; i < 20; i++) {
+		if (fs.existsSync(path.join(dir, "package.jsonc"))) return dir;
+		const parent = path.dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	return path.dirname(input_path);
+}
+/**
+* The folder that receives compiler output for `input_path`: the project's
+* `build/`, or `build/test` for `*.test.nm` files.
+*/
+function build_dir_for(input_path, is_test) {
+	return is_test ? path.join(project_root_for(input_path), "build", "test") : path.join(project_root_for(input_path), "build");
+}
+//#endregion
 //#region src/test.ts
 const RECORD_PREFIX = "\\nomen|";
 /** Recursively collect `*.test.nm` files under `root`, skipping build output. */
@@ -25487,7 +25707,7 @@ function run_test_file(entry_path, lib_path, arch) {
 		result.ms = performance.now() - start;
 		return result;
 	}
-	const buildDir = path.join(path.dirname(resolved), "build");
+	const buildDir = build_dir_for(resolved, true);
 	if (!fs.existsSync(buildDir)) fs.mkdirSync(buildDir, { recursive: true });
 	const ext = arch === "aarch64" ? ".s" : ".c";
 	const codefile = path.join(buildDir, path.basename(entry_path, ".nm") + ext);
@@ -25573,8 +25793,8 @@ function report_file(result) {
 	const mark = result.ok ? C.green("✓") : C.red("✗");
 	console.log(` ${mark} ${rel} ${C.dim(`(${totalTests} tests)`)} ${C.dim(format_duration(result.ms))}`);
 	if (result.crashed) console.log(C.red(`   ${result.crashed}`));
-	for (const f of result.fails) console.log(`   ${C.red("✗")} ${C.bold(f.test)} ${C.dim(">")} ${f.message}`);
-	for (const b of result.benches) console.log(`   ${C.cyan("⏱")} ${C.bold(b.label)} ${C.dim(`(n=${b.n})`)} ${C.dim("min")} ${fmt_ns(b.min)} ${C.dim("median")} ${fmt_ns(b.median)} ${C.dim("mean")} ${fmt_ns(Math.round(b.mean))} ${C.dim("max")} ${fmt_ns(b.max)} ${C.dim("±")} ${fmt_ns(Math.round(b.stddev))}`);
+	for (const f of result.fails) console.log(`   ${C.red("✗")} ${f.test} ${C.dim(">")} ${f.message}`);
+	for (const b of result.benches) console.log(`   ${C.cyan("⏱")} ${b.label} ${C.dim(`(n=${b.n})`)} ${C.dim("min")} ${fmt_ns(b.min)} ${C.dim("median")} ${fmt_ns(b.median)} ${C.dim("mean")} ${fmt_ns(Math.round(b.mean))} ${C.dim("max")} ${fmt_ns(b.max)} ${C.dim("±")} ${fmt_ns(Math.round(b.stddev))}`);
 	if (result.other.length) {
 		console.log(C.dim("   --- test stdout ---"));
 		for (const line of result.other) console.log(C.dim(`   ${line}`));
@@ -25595,7 +25815,7 @@ function runTests(root, options = {}) {
 	}
 	const elapsed = performance.now() - startTime;
 	const totalFiles = results.length;
-	const totalFilesFailed = results.reduce((a, r) => a + (r.fails ? 1 : 0), 0);
+	const totalFilesFailed = results.reduce((a, r) => a + (r.ok ? 0 : 1), 0);
 	const totalFilesPassed = totalFiles - totalFilesFailed;
 	const totalTests = results.reduce((a, r) => a + r.tests.length, 0);
 	const totalFailed = results.reduce((a, r) => a + r.tests.reduce((x, t) => x + t.failed, 0), 0);
@@ -25667,7 +25887,6 @@ function collect_nm_files(folder) {
 	}
 	return out;
 }
-let build_root;
 console.error("\n~ NOMEN ~\n");
 const args = parse_args();
 const command = args.command;
@@ -25728,7 +25947,6 @@ try {
 	}
 	args.in = args.in ?? resolve_input();
 	if (!args.in) process.exit(0);
-	if (!build_root) build_root = fs.lstatSync(args.in).isDirectory() ? args.in : path.dirname(args.in);
 	if (fs.existsSync(args.in)) {
 		let config = {
 			arch: "aarch64",
@@ -25758,19 +25976,13 @@ function resolve_input() {
 	if (fs.existsSync(config_path)) try {
 		const json = fs.readFileSync(config_path, "utf8").replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
 		const parsed = JSON.parse(json);
-		if (parsed.entry) {
-			build_root = cwd;
-			return path.resolve(cwd, parsed.entry);
-		}
+		if (parsed.entry) return path.resolve(cwd, parsed.entry);
 	} catch {}
 	let nm_files = [];
 	try {
 		nm_files = fs.readdirSync(cwd).filter((f) => f.endsWith(".nm"));
 	} catch {}
-	if (nm_files.length === 1) {
-		build_root = cwd;
-		return path.resolve(cwd, nm_files[0]);
-	}
+	if (nm_files.length === 1) return path.resolve(cwd, nm_files[0]);
 	if (nm_files.length > 1) {
 		console.log(`Found ${nm_files.length} .nm files in ${cwd}. Specify which to run with --in:\n  ` + nm_files.join("\n  "));
 		return;
@@ -25863,7 +26075,7 @@ function processFile(filename, config, mode) {
 		return;
 	}
 	const basename = path.basename(filename, ".nm");
-	const buildDir = path.join(build_root ?? path.dirname(filename), "build");
+	const buildDir = build_dir_for(resolved_path, filename.endsWith(".test.nm"));
 	if (!fs.existsSync(buildDir)) fs.mkdirSync(buildDir, { recursive: true });
 	const ext = arch === "aarch64" ? ".s" : platform === "macos" || platform === "ios" ? ".m" : ".c";
 	const headerfile = path.join(buildDir, "main.h");

package/package.json

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

package/src/index.ts

@@ -14,6 +14,7 @@ import { parse_args, print_help, type Args } from "./args.ts";
 import { run_docs } from "./docs.ts";
 import render_errors, { render_warnings } from "./format_errors.ts";
 import { find_bundled, run_init } from "./init.ts";
+import { build_dir_for } from "./paths.ts";
 import { runTests } from "./test.ts";
 import type Config from "./types/Config.ts";
 
@@ -66,11 +67,6 @@ function collect_nm_files(folder: string): string[] {
 	return out;
 }
 
-// The folder whose `build/` subdirectory receives compiler output. Set during
-// input resolution: the --in folder, the .nm file's folder, or — for
-// package.jsonc discovery — the package folder (cwd), not the entry's folder.
-let build_root: string | undefined;
-
 console.error("\n~ NOMEN ~\n");
 
 const args: Args = parse_args();
@@ -154,11 +150,6 @@ try {
 	if (!args.in) {
 		process.exit(0);
 	}
-	// For an explicit --in, build next to whatever was passed (the folder
-	// itself, or the file's folder). Discovery cases set build_root themselves.
-	if (!build_root) {
-		build_root = fs.lstatSync(args.in).isDirectory() ? args.in : path.dirname(args.in);
-	}
 
 	if (fs.existsSync(args.in)) {
 		let config: Config = { arch: "aarch64", platform: default_platform() };
@@ -213,7 +204,6 @@ function resolve_input(): string | undefined {
 			const json = raw.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
 			const parsed = JSON.parse(json);
 			if (parsed.entry) {
-				build_root = cwd;
 				return path.resolve(cwd, parsed.entry);
 			}
 		} catch {
@@ -229,7 +219,6 @@ function resolve_input(): string | undefined {
 		// unreadable working folder
 	}
 	if (nm_files.length === 1) {
-		build_root = cwd;
 		return path.resolve(cwd, nm_files[0]);
 	}
 	if (nm_files.length > 1) {
@@ -368,7 +357,8 @@ function processFile(filename: string, config: Config, mode: Mode) {
 	}
 
 	const basename = path.basename(filename, ".nm");
-	const buildDir = path.join(build_root ?? path.dirname(filename), "build");
+	// Output lives in the project's `build/` — `build/test` for *.test.nm.
+	const buildDir = build_dir_for(resolved_path, filename.endsWith(".test.nm"));
 	if (!fs.existsSync(buildDir)) {
 		fs.mkdirSync(buildDir, { recursive: true });
 	}

package/src/init.ts

@@ -26,7 +26,7 @@ const MAIN_NM = `import System
 pub func add = (int a, int b) => a + b
 
 pub func main = (Init init) {
-	Console.write("Hello world, 2 + 2 is \\{add(a + b)}!\\n")
+	Console.write("Hello world, 2 + 2 is \\{add(2, 2)}!\\n")
 }
 `;
 

package/src/paths.ts

@@ -0,0 +1,28 @@
+import fs from "node:fs";
+import path from "node:path";
+
+/**
+ * The project root for `input_path`: the nearest ancestor folder (or the input
+ * folder itself) containing a `package.jsonc`. Falls back to the input's own
+ * folder for standalone files, so builds stay next to their source.
+ */
+export function project_root_for(input_path: string): string {
+	let dir = fs.lstatSync(input_path).isDirectory() ? input_path : path.dirname(input_path);
+	for (let i = 0; i < 20; i++) {
+		if (fs.existsSync(path.join(dir, "package.jsonc"))) return dir;
+		const parent = path.dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	return path.dirname(input_path);
+}
+
+/**
+ * The folder that receives compiler output for `input_path`: the project's
+ * `build/`, or `build/test` for `*.test.nm` files.
+ */
+export function build_dir_for(input_path: string, is_test: boolean): string {
+	return is_test
+		? path.join(project_root_for(input_path), "build", "test")
+		: path.join(project_root_for(input_path), "build");
+}

package/src/test.ts

@@ -8,6 +8,7 @@ import join from "../../src/join.ts";
 import { get_library } from "../../src/lib.ts";
 import parse from "../../src/parse.ts";
 import { find_bundled } from "./init.ts";
+import { build_dir_for } from "./paths.ts";
 
 const RECORD_PREFIX = "\\nomen|";
 
@@ -303,7 +304,7 @@ export function run_test_file(
 		return result;
 	}
 
-	const buildDir = path.join(path.dirname(resolved), "build");
+	const buildDir = build_dir_for(resolved, true);
 	if (!fs.existsSync(buildDir)) fs.mkdirSync(buildDir, { recursive: true });
 	const ext = arch === "aarch64" ? ".s" : ".c";
 	const codefile = path.join(buildDir, path.basename(entry_path, ".nm") + ext);
@@ -407,11 +408,11 @@ export function report_file(result: TestFileResult): void {
 	// short-circuiting a test has at most one failure, so the fail lines are
 	// the per-test detail and a separate count line would just repeat names.
 	for (const f of result.fails) {
-		console.log(`   ${C.red("✗")} ${C.bold(f.test)} ${C.dim(">")} ${f.message}`);
+		console.log(`   ${C.red("✗")} ${f.test} ${C.dim(">")} ${f.message}`);
 	}
 	for (const b of result.benches) {
 		console.log(
-			`   ${C.cyan("⏱")} ${C.bold(b.label)} ${C.dim(`(n=${b.n})`)} ` +
+			`   ${C.cyan("⏱")} ${b.label} ${C.dim(`(n=${b.n})`)} ` +
 				`${C.dim("min")} ${fmt_ns(b.min)} ${C.dim("median")} ${fmt_ns(b.median)} ` +
 				`${C.dim("mean")} ${fmt_ns(Math.round(b.mean))} ${C.dim("max")} ${fmt_ns(b.max)} ` +
 				`${C.dim("±")} ${fmt_ns(Math.round(b.stddev))}`,
@@ -447,7 +448,7 @@ export function runTests(root: string, options: RunTestsOptions = {}): boolean {
 
 	const elapsed = performance.now() - startTime;
 	const totalFiles = results.length;
-	const totalFilesFailed = results.reduce((a, r) => a + (r.fails ? 1 : 0), 0);
+	const totalFilesFailed = results.reduce((a, r) => a + (r.ok ? 0 : 1), 0);
 	const totalFilesPassed = totalFiles - totalFilesFailed;
 	// `tests[].failed` (from each test's `done` record) is the authoritative
 	// failure count; `result.fails` holds the same failures' messages for