nomen-lang 0.2.2 → 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

@@ -37940,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 "";
 	});
@@ -45418,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);
@@ -45429,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);
@@ -45487,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) {

package/package.json

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