nomen-lang 0.2.1 → 0.2.3

package/core/System/Enumerable.nm

@@ -1,5 +1,7 @@
 // Trait for collection types that can be iterated with `for x of collection`.
 // The loop variable receives int indices 0..length-1; use .at(i) to access values.
+// (`List<T>` is deliberately NOT Enumerable: `for x of some_list` desugars to
+// element iteration like arrays, which is what loop bodies almost always want.)
 /**
  * A trait for collections that can be iterated with `for x of collection`
  **/

package/dist/index.mjs

@@ -21164,7 +21164,8 @@ function build_return_node$1(node, status, nir_value) {
 		else if ((node.value.node_type === "match" || node.value.node_type === "switch") && !return_join_owned_string) needs_borrow_strdup = true;
 	}
 	if (needs_borrow_strdup) {
-		emit_strdup_string(status);
+		if (is_view_value(node.value, status) && (node.value.node_type === "value" || node.value.node_type === "access")) emit_view_materialize_owned(status);
+		else emit_strdup_string(status);
 		if (!status.code.endsWith("\n")) status.code += "\n";
 		status.last_result_is_heap = true;
 	}
@@ -25996,6 +25997,12 @@ function build_assignment_node$1(node, status, nir_rhs, nir_swap) {
 			status.last_result_is_heap = false;
 			emit_rhs_value$1(node.right_value, nir_rhs, status);
 			if (!status.code.endsWith("\n")) status.code += "\n";
+			const assign_lhs_type = status.scoped_declarations.find((d) => d.name === name)?.type ?? status.variable_types?.get(name);
+			const rhs_is_view_into_owned = !node.swap && !node.operator && size === 16 && assign_lhs_type?.name === "string" && !assign_lhs_type.is_view && is_view_value(node.right_value, status);
+			if (rhs_is_view_into_owned) {
+				emit_view_materialize_owned(status);
+				if (!status.code.endsWith("\n")) status.code += "\n";
+			}
 			const saves_fat_pair = size === 16;
 			if (saves_fat_pair) status.code += `stp x0, x1, [sp, #-16]!\n`;
 			else status.code += `str x0, [sp, #-16]!\n`;
@@ -26011,7 +26018,10 @@ function build_assignment_node$1(node, status, nir_rhs, nir_swap) {
 			const move_source = rhs_is_string_var && node.last_use_move && move_on_last_use_enabled() ? rhs_value.value : void 0;
 			const explicit_move_source = !node.swap && !!rhs_value && rhs_value.is_moved && size === 16 && rhs_value.type?.name === "string" && !rhs_value.type?.is_view ? rhs_value.value : void 0;
 			const borrow_needs_dup = !node.swap && size === 16 && is_string_borrow(node.right_value) && !!status.force_heap_strings?.has(name);
-			if (rhs_is_string_var && move_source === void 0 || borrow_needs_dup) emit_strdup_string(status);
+			if (rhs_is_view_into_owned) {
+				if (!status.heap_strings) status.heap_strings = /* @__PURE__ */ new Set();
+				status.heap_strings.add(name);
+			} else if (rhs_is_string_var && move_source === void 0 || borrow_needs_dup) emit_strdup_string(status);
 			if (rhs_is_string_var || borrow_needs_dup) {
 				if (move_source !== void 0) status.heap_strings?.delete(move_source);
 				if (!status.heap_strings) status.heap_strings = /* @__PURE__ */ new Set();
@@ -34108,6 +34118,7 @@ function build_return_node(node, status, nir_value) {
 			if (!returned_value_decl) returns_borrow_var = true;
 			else if (is_string_borrow(returned_value_decl.value) || !!status.string_borrow_vars?.has(var_name)) returns_borrow_var = true;
 		}
+		const returns_view_value = ret_type.name === "string" && !ret_type.is_view && !ret_type.is_array && is_view_value(node.value, status) && (node.value.node_type === "value" || node.value.node_type === "access");
 		if (returns_borrowed_string) {
 			const access = node.value.access;
 			if (access.node_type === "access_func") {
@@ -34134,16 +34145,17 @@ function build_return_node(node, status, nir_value) {
 			}
 		}
 		const returns_string_zero = ret_type.name === "string" && !ret_type.is_view && !ret_type.is_array && node.value.node_type === "value" && (node.value.value === "0" || node.value.value === "null");
-		if (!returns_string_zero && (returns_borrowed_string || returns_string_literal || returns_borrow_var)) status.code += `nomen_str_dup(`;
+		if (!returns_string_zero && !returns_view_value && (returns_borrowed_string || returns_string_literal || returns_borrow_var)) status.code += `nomen_str_dup(`;
 		const wrap_view_string_return = !!ret_type.is_view && ret_type.name === "string" && !is_view_value(node.value, status);
 		const expr_type_name = node.type?.name || "";
 		const expr_is_simple = !status.structs.find((s) => s.name === expr_type_name && !s.is_simple_type);
 		if (is_struct && expr_is_simple && !returns_borrowed_string && !ret_type.is_view) status.code += return_is_class ? `(struct ${mono_ret_name}*)` : `(struct ${mono_ret_name})`;
 		if (wrap_view_string_return) status.code += `({ nomen_string _p = `;
 		if (returns_string_zero) status.code += `(nomen_string){0,0}`;
+		else if (returns_view_value) c_materialize_view_string(node.value, status);
 		else emit_return_value(node.value, nir_value, status);
 		if (wrap_view_string_return) status.code += `; nomen_view _v = { (void*)_p.ptr, _p.len }; _v; })`;
-		if (!returns_string_zero && (returns_borrowed_string || returns_string_literal || returns_borrow_var)) status.code += `)`;
+		if (!returns_string_zero && !returns_view_value && (returns_borrowed_string || returns_string_literal || returns_borrow_var)) status.code += `)`;
 		status.code += `;\n`;
 		if (node.value.node_type === "func_call" && node.value.field_overrides?.length) emit_field_overrides("_return_val", node.value, build_node, status, "", ";\n");
 		reclaim_all_c_scopes(status);
@@ -35884,9 +35896,15 @@ function build_assignment_node(node, status, nir_rhs, nir_swap) {
 			} else {
 				if (lhs_is_string && !rhs_is_bare_value) {
 					const temp = `_reassign_${status.label_counter = (status.label_counter ?? 0) + 1}`;
+					const rhs_is_view = is_view_value(node.right_value, status);
 					status.code += `nomen_string ${temp} = `;
-					emit_rhs_value(node.right_value, nir_rhs, status);
+					if (rhs_is_view) c_materialize_view_string(node.right_value, status);
+					else emit_rhs_value(node.right_value, nir_rhs, status);
 					status.code += `;\nfree(${lhs_name}.ptr);\n${lhs_name} = ${temp};\n`;
+					if (rhs_is_view) {
+						if (!status.heap_strings) status.heap_strings = /* @__PURE__ */ new Set();
+						status.heap_strings.add(lhs_name);
+					}
 					return;
 				}
 				status.code += `free(${lhs_name}.ptr);\n`;
@@ -35900,6 +35918,13 @@ function build_assignment_node(node, status, nir_rhs, nir_swap) {
 			if (rhs_is_bare_value) {
 				if (lhs_is_class) {
 					if (!node.swap) splice_decl_from_c_scopes(status, rhs.value);
+				} else if (lhs_is_string && !node.swap && rhs.node_type === "value" && is_view_value(rhs, status)) {
+					status.code += `${lhs_name} = `;
+					c_materialize_view_string(rhs, status);
+					status.code += `;\n`;
+					if (!status.heap_strings) status.heap_strings = /* @__PURE__ */ new Set();
+					status.heap_strings.add(lhs_name);
+					return;
 				} else if (!node.swap && rhs.is_moved) {
 					const src_name = rhs.value;
 					if (string_var_owns_heap(status, src_name)) {
@@ -37915,7 +37940,28 @@ function add_source(folder_path, file_path, inputs, lib_path) {
 	source = source.replaceAll(/^import(.*)$/gm, (match, name) => {
 		const trimmed = name.trim();
 		if (trimmed === "System" || trimmed.startsWith("System::")) return match;
-		const import_file_path = `./${trimmed.split("::").join("/")}.nm`;
+		const segments = trimmed.split("::").map((s) => s.trim()).filter((s) => s.length > 0);
+		if (!segments.length) return "";
+		const rel = segments.join("/");
+		let is_dir = false;
+		try {
+			is_dir = fs.statSync(path.resolve(folder_path, rel)).isDirectory();
+		} catch {}
+		if (is_dir) {
+			let names;
+			try {
+				names = fs.readdirSync(path.resolve(folder_path, rel));
+			} catch {
+				return "";
+			}
+			for (const name of names.sort()) {
+				if (!name.endsWith(".nm")) continue;
+				const import_file_path = `./${rel}/${name}`;
+				if (!inputs.has(import_file_path)) add_source(folder_path, import_file_path, inputs, lib_path);
+			}
+			return "";
+		}
+		const import_file_path = `./${rel}.nm`;
 		if (!inputs.has(import_file_path)) add_source(folder_path, import_file_path, inputs, lib_path);
 		return "";
 	});
@@ -40222,6 +40268,15 @@ function evaluate_operation(op, status) {
 				}
 				if (op.op === "<=" && left_decl?.upper_bound_inclusive_exprs?.length && target_str) {
 					if (left_decl.upper_bound_inclusive_exprs.includes(target_str)) return true;
+					if (left_decl.upper_bound_inclusive_exprs.some((u) => upper_implies(u, target_str))) return true;
+					for (const u of left_decl.upper_bound_inclusive_exprs) {
+						const v = parse_offset_expr(u);
+						if (v && v.offset === 0 && u !== target_str) {
+							const vdecl = status.values.findLast((vv) => vv.name === v.base);
+							if (vdecl?.upper_bound_exprs?.includes(target_str)) return true;
+							if (vdecl?.upper_bound_inclusive_exprs?.includes(target_str)) return true;
+						}
+					}
 				}
 				if (op.op === "<" && left_decl?.upper_bound_inclusive_exprs?.length && target_str && left_decl.upper_bound_inclusive_exprs.includes(target_str)) return "unsafe";
 				if (left_decl?.upper_bound_expr && target_str) {
@@ -40531,6 +40586,7 @@ function is_nonnegative_access(node, status) {
 			if (m) {
 				const field_path = m[1];
 				const offset_str = m[2];
+				if (!field_path.includes(".")) return false;
 				const last = field_path.split(".").at(-1);
 				if (last && NON_NEGATIVE_FIELDS.has(last)) {
 					if (!offset_str) return true;
@@ -40738,6 +40794,30 @@ function materialize_type(type, status) {
 //#endregion
 //#region ../src/check/utils/view_fields.ts
 /**
+* Whether the named struct (or any value struct embedded in its fields,
+* recursively) declares a `view T` field. A struct with view fields carries
+* non-owning borrows inside its bytes, which drives the borrow rules:
+* copies are sound (a pair copy aliases nothing owned), but escapes
+* (returning, outer-scope assignment) are checked against where those
+* borrows were taken.
+*/
+function struct_has_view_fields(type_name, status) {
+	if (!type_name) return false;
+	const struct = status.structs.find((s) => s.name === type_name && !s.is_simple_type);
+	return !!struct && has_view_fields(struct, status, /* @__PURE__ */ new Set());
+}
+function has_view_fields(struct, status, visited) {
+	if (visited.has(struct.name)) return false;
+	visited.add(struct.name);
+	for (const field of struct.fields) {
+		if (field.type.is_view) return true;
+		if (field.type.is_ref || field.type.is_array) continue;
+		const field_struct = status.structs.find((s) => s.name === field.type.name && !s.is_simple_type && !s.is_class);
+		if (field_struct && has_view_fields(field_struct, status, visited)) return true;
+	}
+	return false;
+}
+/**
 * The root variable an access chain bottoms out at (`line.text` → "line",
 * `a.b.c` → "a", bare `x` → "x"). Returns undefined when the chain does not
 * bottom out in a plain name (e.g. a call receiver).
@@ -40859,6 +40939,23 @@ function view_borrows_root_at_self(sv) {
 	return !!owners?.size && [...owners].every((o) => o === "self");
 }
 /**
+* Whether a value of this type can carry a non-owning view borrow: the type
+* itself is a `view`, a `ref` (a borrow by definition — keep the existing
+* taint), a struct declaring (transitively) `view T` fields, or a generic
+* instantiation with such an argument. Anything else (primitives, owned
+* strings, containers of owned values) owns its storage outright, so a call
+* producing it does not propagate its view arguments' borrows — tainting it
+* is a false positive (e.g. returning `slice_string(view)` from a function
+* returning owned `string`). Callers pass an unset/unknown type through as
+* carrying, preserving today's behavior where nothing is known.
+*/
+function type_can_carry_view_borrow(type, status) {
+	if (!type || !type.name) return true;
+	if (type.is_view || type.is_ref) return true;
+	if (struct_has_view_fields(type.name, status)) return true;
+	return (type.type_args ?? []).some((t) => type_can_carry_view_borrow(t, status));
+}
+/**
 * Whether reading view fields of `root` is currently rejected because their
 * source was mutated (reassigned / ref-mutated).
 */
@@ -40983,7 +41080,7 @@ function check_declaration_node(decl, status) {
 			if (type_from_value_node(decl.value, status)?.is_const_ref) decl.type.is_const_ref = true;
 		}
 		let view_borrows;
-		if (decl.value?.node_type === "func_call") {
+		if (decl.value?.node_type === "func_call" && type_can_carry_view_borrow(decl.type, status)) {
 			view_borrows = ctor_call_view_borrow(decl.value, status);
 			if (view_borrows?.size) for (const [, info] of view_borrows) {
 				const depth = info.depth ?? status.scope_depth;
@@ -43904,7 +44001,7 @@ function check_function_call(node, status, func, target_type, self_value, self_p
 				lower_bound_inclusive_exprs = decl.lower_bound_inclusive_exprs;
 				upper_bound_expr = decl.upper_bound_expr;
 				lower_bound_expr = decl.lower_bound_expr;
-				alias_of = decl.alias_of;
+				alias_of = decl.alias_of ?? expr_to_string(param, status);
 			}
 		} else if (param.node_type === "op") {
 			const pop = param;
@@ -45189,7 +45286,7 @@ function check_assignment_node(assign, status) {
 			const src_name = value_from_value_node(assign.right_value);
 			const src_sv = assign.right_value.node_type === "value" ? status.values.findLast((v) => v.name === src_name) : void 0;
 			if (src_sv?.has_view_borrows) propagate_view_borrows(left_value, src_sv);
-		} else if (assign.right_value.node_type === "func_call" && type_from_value_node(assign.right_value, status)?.name) {
+		} else if (assign.right_value.node_type === "func_call" && type_from_value_node(assign.right_value, status)?.name && type_can_carry_view_borrow(type_from_value_node(assign.right_value, status), status)) {
 			const infos = ctor_call_view_borrow(assign.right_value, status);
 			if (infos?.size) {
 				for (const [, info] of infos) {
@@ -45342,6 +45439,25 @@ function has_trait(type_name, trait_name, status) {
 	if (!struct) return false;
 	return struct.traits.includes(trait_name);
 }
+/**
+* The element type of a `List<T>` value, from either the generic annotation
+* (`List` + type args) or the monomorphized struct (`List_Diff` via its
+* recorded source args) — mirroring the lookup in check_access_node.
+* Returns undefined when the List struct isn't in scope at all (e.g. bare
+* parse without the System library) or the element can't be recovered, in
+* which case the loop falls through to the array-or-Enumerable error.
+*/
+function list_element_type(t, status) {
+	if (t.name === "List") {
+		const generic = status.structs.find((s) => s.name === "List");
+		if (!generic || !generic.functions.some((f) => f.name === "at")) return void 0;
+		return t.type_args?.[0];
+	}
+	const struct = t.name ? status.structs.find((s) => s.name === t.name) : void 0;
+	if (!struct?.name.startsWith("List_")) return void 0;
+	if (!struct.functions.some((f) => f.name === "at")) return void 0;
+	return struct.source_type_args?.[0];
+}
 function check_for_loop_node(for_loop, status) {
 	if (for_loop.list && !(for_loop.list instanceof RangeNode) && for_loop.list.node_type === "value") {
 		const list_type = type_from_value_node(for_loop.list, status);
@@ -45353,13 +45469,23 @@ function check_for_loop_node(for_loop, status) {
 			check_for_loop_node(for_loop, status);
 			return;
 		}
+		const list_elem = list_element_type(list_type, status);
+		if (list_elem && !enumerable) {
+			if (for_loop.item_is_ref) {
+				add_error(status, `'ref' iteration is not supported for List<T> — index explicitly (for i of 0..xs.length) and use .set to write back`, for_loop.item.start);
+				return;
+			}
+			desugar_array_for_loop(for_loop, list_type, list_elem);
+			check_for_loop_node(for_loop, status);
+			return;
+		}
 	}
 	let for_status = clone_status(status);
 	if (for_loop.list) {
 		check_node(for_loop.list, for_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 (!list_type.is_array && !is_enumerable && list_type.name) add_error(for_status, `For loop list must be an array, List, 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.findLast((v) => v.name === list_name);
@@ -45411,17 +45537,17 @@ function check_for_loop_node(for_loop, status) {
 * 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) {
+function desugar_array_for_loop(for_loop, array_type, elem_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.storage_kind === "heap_array" || !array_type.length ? new AccessNode(start, clone_node(list), new AccessFieldNode(start, "length")) : clone_node(array_type.length));
+	for_loop.list = new RangeNode(start, new ValueNode(start, "0"), elem_type !== void 0 || array_type.storage_kind === "heap_array" || !array_type.length ? new AccessNode(start, clone_node(list), new AccessFieldNode(start, "length")) : clone_node(array_type.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", is_ref ? "var" : "const", 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, elem_type ?? new Type(array_type.name), at_access);
 	decl.is_loop_iterator = true;
 	for_loop.statements.unshift(decl);
 	if (is_ref) {
@@ -46031,7 +46157,7 @@ function check_return_node(ret, status) {
 			if (!safe_view_from_self && !explicit_mov) add_error(status, `cannot return a borrowed reference — use 'move' (with swap) to transfer ownership`, ret.value.start);
 		}
 	} else if (func && ret.value.node_type === "func_call") {
-		const infos = ctor_call_view_borrow(ret.value, status);
+		const infos = type_can_carry_view_borrow(ret.type, status) ? ctor_call_view_borrow(ret.value, status) : void 0;
 		if (infos?.size && ![...infos.keys()].every((o) => o === "self")) add_error(status, `cannot return '${ret.type.name}' — its 'view' field(s) borrow from this scope`, ret.value.start);
 	}
 	if (func) {

package/package.json

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