nomen-lang 0.0.18 → 0.0.19

package/core/System/Array.nm

@@ -30,7 +30,7 @@ pub struct Array<T>: Viewable {
 		```
 	}
 
-	pub func at = (self, int index: index >= 0 && index < self.length, out T) {
+	pub inline func at = (self, int index: index >= 0 && index < self.length, out T) {
 		```
 		#arch: c
 		T* _data = (T*)((char*)self + sizeof(*self));

package/dist/index.mjs

@@ -2750,6 +2750,20 @@ function is_container_borrow_access(node) {
 	return !!node && node.node_type === "access" && node.access?.node_type === "access_func" && !node.access.owned_return && is_container_borrow_accessor_name(node.access.name);
 }
 /**
+* Whether `target` (the receiver of a `.to_string()` call) is a `view string`
+* VALUE — a named view local/param (the checker stamps variable references
+* with the declared type, and substitute_type preserves `is_view` across
+* monomorphization) or an inline `.slice(...)` chain (a slice call always
+* produces a view, even when its cached type lost the modifier). Such a call
+* MATERIALIZES a fresh owned heap copy (malloc + memcpy), unlike
+* `to_string` on an owned string (the `string_to_string` identity).
+*/
+function is_view_materialization_target(target) {
+	if (!target || typeof target !== "object") return false;
+	if (target.type?.is_view) return true;
+	return target.node_type === "access" && target.access?.node_type === "access_func" && !target.access.owned_return && target.access.name === "slice";
+}
+/**
 * Whether a function has any `return <expr>` statement in its body (used by
 * the C backend's gather, which registers every string-returning function
 * that actually returns — the backend strdup's borrows at the return site,
@@ -2858,6 +2872,7 @@ function value_is_owned_string(v, table, visiting, borrow_names, enclosing_fn) {
 			if (mangled.startsWith("_string_interpolate_")) return true;
 			if (mangled.endsWith("_to_string") && mangled !== "string_to_string") return true;
 			if (raw === "to_string" && v.target?.type?.name && v.target.type.name !== "string") return true;
+			if (raw === "to_string" && is_view_materialization_target(v.target)) return true;
 			if (!v.access.owned_return && is_container_borrow_accessor_name(raw)) return !is_call_site_borrow_accessor(enclosing_fn);
 			const resolved = method_call_returns_owned(v, table, visiting);
 			if (resolved !== void 0) return resolved;
@@ -9569,6 +9584,7 @@ function is_owned_heap_temp$1(node, status) {
 		if (mangled.startsWith("_string_interpolate_")) return true;
 		if (mangled.endsWith("_to_string") && mangled !== "string_to_string") return true;
 		if (raw_name === "to_string" && target_type_name && target_type_name !== "string") return true;
+		if (raw_name === "to_string" && status && node.node_type === "access" && is_view_value$1(node.target, status)) return true;
 		const heap_set = status?.heap_returning_functions;
 		if (heap_set?.has(mangled)) return true;
 		if (heap_set && target_value && heap_set.has(`${target_value}_${raw_name}`)) return true;
@@ -12237,10 +12253,17 @@ function build_naked_inline(struct_node, func, status) {
 	let asm = extract_aarch64_asm(func, status.platform);
 	const standalone_return_label = `.return_${struct_node.name}_${func.name.replace(/#/g, "")}`;
 	asm = asm.replaceAll(`b ${standalone_return_label}`, "");
-	if (count_x19_reads(asm) === 1) asm = asm.replace(/\bx19\b/g, "x0");
+	const x19_reads = count_x19_reads(asm);
+	let prologue = "";
+	let epilogue = "";
+	if (x19_reads === 1) asm = asm.replace(/\bx19\b/g, "x0");
+	else if (x19_reads > 1) {
+		prologue = `str x19, [sp, #-16]!\nmov x19, x0\n`;
+		epilogue = `ldr x19, [sp], #16\n`;
+	}
 	const site = inline_counter++;
-	asm = asm.replace(/(\.L[A-Za-z0-9_]+)/g, `$1_${site}`);
-	status.code += asm + "\n";
+	asm = asm.replace(/(\.L[A-Za-z0-9_]+)/g, `$1__ni${site}`);
+	status.code += prologue + asm + "\n" + epilogue;
 }
 function build_inline_method(struct_node, func, status) {
 	if (emit_owning_buffer_inline_aarch64(struct_node, func.name, status)) return;
@@ -12688,6 +12711,14 @@ function emit_string_length$1(target, status) {
 *                     struct element, with x0 = temp address)
 *   v.to_string()  →  malloc(len+1); memcpy; null-terminate; owned copy in x0
 *                     (string views only)
+* The receiver is either a NAMED view local/param (pair in its two stack
+* slots) or an INLINE view-producing expression such as
+* `text.slice(start, end).to_string()` — the expression leaves the pair in
+* x0/x1, which is spilled to scratch slots first. Without this, the inline
+* chain falls through to struct-method dispatch and resolves to
+* `string_to_string` (an identity `mov x0, x19`), handing consumers the raw
+* slice pointer — not NUL-terminated at len — and strlen-based readers run
+* past the slice.
 * Returns true if handled (caller skips struct-method dispatch).
 */
 function build_view_op(node, access_func, status) {
@@ -12696,11 +12727,19 @@ function build_view_op(node, access_func, status) {
 		const vt = status.variable_types?.get(node.target.value);
 		if (vt?.is_view) t = vt;
 	}
-	if (!t?.is_view) return false;
-	if (node.target.node_type !== "value") return false;
-	const base = status.stack_offsets?.get(node.target.value);
-	if (base === void 0) return false;
-	const elem_name = t.name === "string" ? "char" : t.name;
+	if (!t?.is_view && !is_view_value$1(node.target, status)) return false;
+	let base;
+	if (node.target.node_type === "value") base = status.stack_offsets?.get(node.target.value);
+	if (base === void 0) {
+		build_node$1(node.target, status);
+		if (!status.code.endsWith("\n")) status.code += "\n";
+		const temp_base = allocate_stack_space(status, 16, 16);
+		status.code += `str x0, [x29, #${temp_base}]\n`;
+		status.code += `str x1, [x29, #${temp_base + 8}]\n`;
+		base = temp_base;
+	}
+	const view_elem = t?.name || "string";
+	const elem_name = view_elem === "string" ? "char" : view_elem;
 	if (access_func.name === "at" && access_func.params.length === 1) {
 		build_node$1(access_func.params[0], status);
 		if (!status.code.endsWith("\n")) status.code += "\n";
@@ -12726,7 +12765,7 @@ function build_view_op(node, access_func, status) {
 		else status.code += `ldr x0, [x0, x1, lsl #3]\n`;
 		return true;
 	}
-	if (access_func.name === "to_string" && t.name === "string") {
+	if (access_func.name === "to_string" && view_elem === "string") {
 		status.code += `ldr x0, [x29, #${base}]\n`;
 		status.code += `ldr x1, [x29, #${base + 8}]\n`;
 		emit_view_materialize_owned(status);
@@ -25034,6 +25073,29 @@ function clone_type(t) {
 	c.type_args = t.type_args;
 	return c;
 }
+/**
+* Strip parallel-length equality clauses (`a.length == b.length`) from every
+* parameter's constraint of `func` at SIGNATURE-GATHER time — before any call
+* site can observe the signature, regardless of declaration order. A
+* forward-referenced callee must not hand its caller a clause no call site
+* could ever prove; the clause becomes an assumed equality for the callee's
+* own body instead (stashed on the param, seeded into scope when its params
+* are checked). Idempotent: a constraint already stripped has no clauses
+* left to extract. `check_function_node` re-runs the same extraction at
+* registration for function clones that never pass through a gather pass
+* (generic monomorphizations).
+*/
+function strip_param_length_equalities(func) {
+	const param_names = new Set(func.params.map((p) => p.name));
+	for (const param of func.params) {
+		if (!param.constraint) continue;
+		const { constraint, equalities } = extract_length_equalities_at_registration(param.constraint, param.name, param_names);
+		if (equalities.length) {
+			param.constraint = constraint;
+			param.stripped_length_equalities = equalities;
+		}
+	}
+}
 function gather_structs(block, status) {
 	const names_in_block = {
 		structs: /* @__PURE__ */ new Set(),
@@ -25050,6 +25112,7 @@ function gather_structs(block, status) {
 				names_in_block.structs.add(struct.name);
 				struct.scope = status.stack.at(-1) || block;
 				struct.is_generic = struct.type_params.length > 0;
+				for (const func of struct.functions) strip_param_length_equalities(func);
 				status.types.push(struct.name);
 				status.structs.push(struct);
 			}
@@ -25062,6 +25125,7 @@ function gather_structs(block, status) {
 				names_in_block.traits.add(trait.name);
 				status.types.push(trait.name);
 				status.traits.push(trait);
+				for (const func of trait.functions) strip_param_length_equalities(func);
 			}
 			break;
 		}
@@ -25073,15 +25137,7 @@ function gather_structs(block, status) {
 				func.scope = status.stack.at(-1) || block;
 				func.return_type = materialize_type(func.return_type, status);
 				instantiate_generic_type(func.return_type, status);
-				const param_names = new Set(func.params.map((p) => p.name));
-				for (const param of func.params) {
-					if (!param.constraint) continue;
-					const { constraint, equalities } = extract_length_equalities_at_registration(param.constraint, param.name, param_names);
-					if (equalities.length) {
-						param.constraint = constraint;
-						param.stripped_length_equalities = equalities;
-					}
-				}
+				strip_param_length_equalities(func);
 				status.functions.push(func);
 			}
 			break;
@@ -25147,7 +25203,10 @@ function apply_extensions(block, status) {
 			continue;
 		}
 		ext.scope = target;
-		for (const func of ext.functions) target.functions.push(func);
+		for (const func of ext.functions) {
+			strip_param_length_equalities(func);
+			target.functions.push(func);
+		}
 		for (let i = 0; i < ext.traits.length; i++) {
 			if (target.traits.includes(ext.traits[i])) {
 				add_error(status, `Type '${ext.name}' already conforms to trait '${ext.traits[i]}'`, ext.start);
@@ -27886,7 +27945,7 @@ function check_if_else_node(if_else, status) {
 	const else_returns = if_else.else_branch && block_always_returns(if_else.else_branch);
 	const if_falls_through = if_reachable && !if_returns;
 	const else_falls_through = else_reachable && (!has_else || !else_returns);
-	if (!has_else && else_reachable) apply_negated_bounds(if_else.condition, status);
+	if (!has_else && else_reachable && !if_returns) apply_negated_bounds(if_else.condition, status);
 	for (let [i, value] of status.values.entries()) {
 		const contributing_sets = [];
 		if (if_falls_through) contributing_sets.push(!!if_status.values[i].is_set);
@@ -27940,6 +27999,7 @@ function check_if_else_node(if_else, status) {
 			}
 		}
 	}
+	if (!has_else && if_returns && else_reachable) apply_negated_bounds(if_else.condition, status);
 	if (if_else.if_branch && !if_else.else_branch) {
 		const parent = status.stack.at(-1);
 		if (parent && (parent.node_type === "declare" || parent.node_type === "assign")) add_error(status, "If expression must have an else branch", if_else.start);

package/package.json

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