nomen-lang 0.2.1 → 0.2.2

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)) {
@@ -40222,6 +40247,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 +40565,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 +40773,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 +40918,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 +41059,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 +43980,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 +45265,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) {
@@ -46031,7 +46107,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.2",
   "description": "The CLI for the Nomen programming language.",
   "keywords": [],
   "license": "ISC",