nomen-lang 0.2.0 → 0.2.1

package/dist/index.mjs

@@ -24379,13 +24379,17 @@ function emit_struct_address(node, status) {
 /**
 * Whether an argument expression is a fat string VALUE: either its static
 * type names `string`, or it is a string literal (whose ValueNode.type may
-* be unset). Literals ride the pair ABI like any string.
+* be unset). Literals ride the pair ABI like any string. A `view string`
+* counts too — it IS the same (ptr, len) pair at runtime, so a view
+* argument to a non-view `string` param (e.g. a `.slice` receiver) must
+* occupy two slots just like an owned string. (`view` DECLARED params are
+* unaffected: the view_arg_set check runs first.)
 */
 function arg_is_string$1(node) {
 	const v = node;
 	if (node.node_type === "value" && typeof v.value === "string" && v.value.startsWith("\"")) return true;
 	const t = type_from_value_node$1(node);
-	return t?.name === "string" && !t.is_view && !t.is_array;
+	return t?.name === "string" && !t.is_array;
 }
 function build_function_call_node$1(node, status) {
 	if (node.is_enum_shorthand && node.params.length > 0) {
@@ -29176,13 +29180,14 @@ function build_access_field(node, status) {
 /**
 * Whether an argument expression is a fat string VALUE: either its static
 * type names `string`, or it is a string literal (whose ValueNode.type may
-* be unset). Literals ride the pair ABI like any string.
+* be unset). Literals ride the pair ABI like any string. A `view string`
+* counts too — same pair ABI (see build_function_call_node).
 */
 function arg_is_string(node) {
 	const v = node;
 	if (node.node_type === "value" && typeof v.value === "string" && v.value.startsWith("\"")) return true;
 	const t = type_from_value_node$1(node);
-	return t?.name === "string" && !t.is_view && !t.is_array;
+	return t?.name === "string" && !t.is_array;
 }
 function build_access_method(node, access_func, status) {
 	let target_type = type_from_value_node$1(node.target);
@@ -29742,7 +29747,7 @@ function build_access_method(node, access_func, status) {
 		status.stack_offsets.set(temp_addr, temp_offset);
 		status.code += `add x8, x29, #${temp_offset}\n`;
 	}
-	const receiver_is_string = !access_func.is_static && target_type?.name === "string" && !target_type.is_view && !target_type.is_array && !method_self_is_ref;
+	const receiver_is_string = !access_func.is_static && target_type?.name === "string" && !target_type.is_array && !method_self_is_ref;
 	let frees_string_receiver = false;
 	if (receiver_is_string) {
 		status.last_result_is_heap = false;
@@ -32535,8 +32540,9 @@ function build_struct_functions(node, status, skip_init = false) {
 		} else if (return_type.startsWith("Array_")) status.code += `void* ${emit_label}(`;
 		else if (func.return_type.is_view) status.code += `nomen_view ${emit_label}(`;
 		else {
-			const return_struct = status.structs.find((s) => s.name === return_type && !s.is_simple_type);
-			const return_trait = status.traits.find((t) => t.name === return_type);
+			const mono_return_type = mono_type_name(func.return_type);
+			const return_struct = status.structs.find((s) => s.name === mono_return_type && !s.is_simple_type);
+			const return_trait = status.traits.find((t) => t.name === mono_return_type);
 			if (return_struct && !return_struct.is_class) {
 				const swap = status.code;
 				status.code = status.headers;
@@ -32544,7 +32550,7 @@ function build_struct_functions(node, status, skip_init = false) {
 				status.headers = status.code;
 				status.code = swap;
 			}
-			if (return_struct || return_trait) status.code += `struct ${return_type}`;
+			if (return_struct || return_trait) status.code += `struct ${mono_return_type}`;
 			else status.code += `${c_type(return_type)}`;
 			if (return_struct?.is_class || return_trait) status.code += `*`;
 			status.code += ` ${emit_label}(`;
@@ -35329,6 +35335,17 @@ function build_access_node(node, status) {
 					status.code += `]`;
 					return;
 				}
+				if (access_func.name === "slice" && target_type.name === "string" && access_func.params.length === 2) {
+					const tmp = `_vsl_${status.label_counter = (status.label_counter ?? 0) + 1}`;
+					status.code += `({ nomen_view ${tmp} = `;
+					build_node(node.target, status);
+					status.code += `; long _s = `;
+					build_node(access_func.params[0], status);
+					status.code += `; nomen_view _r; _r.ptr = (void*)((char*)${tmp}.ptr + _s); _r.len = (long)(`;
+					build_node(access_func.params[1], status);
+					status.code += ` - _s); _r; })`;
+					return;
+				}
 				if (access_func.name === "to_string" && target_type.name === "string") {
 					const tmp = `_vts_${status.label_counter = (status.label_counter ?? 0) + 1}`;
 					status.code += `({ nomen_view ${tmp} = `;
@@ -40363,7 +40380,7 @@ function evaluate_operation(op, status) {
 				const right_base_name = right_str.split(".")[0];
 				const rdecl = status.values.findLast((v) => v.name === right_base_name);
 				const ra = rdecl?.alias_of ? parse_offset_expr(rdecl.alias_of) : void 0;
-				const right_base = ra ? ra.base : right_str;
+				const right_base = ra && !(right_str === ra.base || ra.offset === 0 && right_str.startsWith(ra.base + ".")) ? ra.base : right_str;
 				const right_off = ra ? ra.offset : 0;
 				if (left_base === right_base) {
 					const d = left_off - right_off;
@@ -43981,12 +43998,24 @@ function check_function_call(node, status, func, target_type, self_value, self_p
 			});
 			if (self_value && self_value !== "?") {
 				const self_type = target_type || func.params[0]?.type;
+				const self_path_or_value = self_path ?? self_value;
+				const self_base = status.values.findLast((v) => v.name === self_path_or_value.split(".")[0]);
 				status.values.push({
 					declaration: "const",
 					name: "self",
 					type: self_type,
 					is_set: true,
-					alias_of: self_path ?? self_value
+					alias_of: self_path_or_value,
+					range_lower: self_base?.range_lower,
+					range_upper: self_base?.range_upper,
+					upper_bound_exprs: self_base?.upper_bound_exprs?.slice(),
+					lower_bound_exprs: self_base?.lower_bound_exprs?.slice(),
+					upper_bound_inclusive_exprs: self_base?.upper_bound_inclusive_exprs?.slice(),
+					lower_bound_inclusive_exprs: self_base?.lower_bound_inclusive_exprs?.slice(),
+					upper_bound_expr: self_base?.upper_bound_expr,
+					lower_bound_expr: self_base?.lower_bound_expr,
+					known_length: self_base?.known_length,
+					path_bounds: self_base?.path_bounds
 				});
 			}
 			const satisfied = evaluate_const_condition(func_param.constraint, status);
@@ -49276,6 +49305,14 @@ function project_root_for(input_path) {
 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");
 }
+/**
+* The linked binary path for `input_path`: an explicit `--out` wins,
+* otherwise `<build dir>/<entry basename>`.
+*/
+function outfile_for(input_path, is_test, out) {
+	if (out) return path.resolve(out);
+	return path.join(build_dir_for(input_path, is_test), path.basename(input_path, ".nm"));
+}
 //#endregion
 //#region src/test.ts
 const RECORD_PREFIX = "\\nomen|";
@@ -49746,6 +49783,7 @@ try {
 		if (args.audit_runtime) config.audit_runtime = args.audit_runtime;
 		if (args.release) config.release = args.release;
 		if (args.fast_math) config.fast_math = args.fast_math;
+		if (args.out) config.out = args.out;
 		if (fs.lstatSync(args.in).isDirectory()) {
 			if (args.watch) watchPath(args.in, config, mode, args.program_args);
 			else processFolder(args.in, config, mode, args.program_args);
@@ -49872,7 +49910,8 @@ function processFile(filename, config, mode, program_args) {
 	const ext = arch === "aarch64" ? ".s" : platform === "macos" || platform === "ios" ? ".m" : ".c";
 	const headerfile = path.join(buildDir, "main.h");
 	const codefile = path.join(buildDir, basename + ext);
-	const outfile = path.join(buildDir, basename);
+	const outfile = outfile_for(resolved_path, filename.endsWith(".test.nm"), config.out);
+	if (!fs.existsSync(path.dirname(outfile))) fs.mkdirSync(path.dirname(outfile), { recursive: true });
 	fs.writeFileSync(headerfile, result.headers);
 	fs.writeFileSync(codefile, result.code);
 	let companionfile;

package/package.json

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

package/src/index.ts

@@ -14,7 +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 { build_dir_for, outfile_for } from "./paths.ts";
 import { runTests } from "./test.ts";
 import type Config from "./types/Config.ts";
 
@@ -170,6 +170,7 @@ try {
 		if (args.audit_runtime) config.audit_runtime = args.audit_runtime;
 		if (args.release) config.release = args.release;
 		if (args.fast_math) config.fast_math = args.fast_math;
+		if (args.out) config.out = args.out;
 
 		// Is the --in path a folder
 		if (fs.lstatSync(args.in).isDirectory()) {
@@ -370,7 +371,8 @@ function processFile(filename: string, config: Config, mode: Mode, program_args:
 	}
 
 	const basename = path.basename(filename, ".nm");
-	// Output lives in the project's `build/` — `build/test` for *.test.nm.
+	// Output lives in the project's `build/` — `build/test` for *.test.nm —
+	// unless an explicit --out names the linked binary.
 	const buildDir = build_dir_for(resolved_path, filename.endsWith(".test.nm"));
 	if (!fs.existsSync(buildDir)) {
 		fs.mkdirSync(buildDir, { recursive: true });
@@ -378,7 +380,10 @@ function processFile(filename: string, config: Config, mode: Mode, program_args:
 	const ext = arch === "aarch64" ? ".s" : platform === "macos" || platform === "ios" ? ".m" : ".c";
 	const headerfile = path.join(buildDir, "main.h");
 	const codefile = path.join(buildDir, basename + ext);
-	const outfile = path.join(buildDir, basename);
+	const outfile = outfile_for(resolved_path, filename.endsWith(".test.nm"), config.out);
+	if (!fs.existsSync(path.dirname(outfile))) {
+		fs.mkdirSync(path.dirname(outfile), { recursive: true });
+	}
 	fs.writeFileSync(headerfile, result.headers);
 	fs.writeFileSync(codefile, result.code);
 

package/src/paths.ts

@@ -26,3 +26,12 @@ export function build_dir_for(input_path: string, is_test: boolean): string {
 		? path.join(project_root_for(input_path), "build", "test")
 		: path.join(project_root_for(input_path), "build");
 }
+
+/**
+ * The linked binary path for `input_path`: an explicit `--out` wins,
+ * otherwise `<build dir>/<entry basename>`.
+ */
+export function outfile_for(input_path: string, is_test: boolean, out?: string): string {
+	if (out) return path.resolve(out);
+	return path.join(build_dir_for(input_path, is_test), path.basename(input_path, ".nm"));
+}

package/src/types/Config.ts

@@ -6,4 +6,5 @@ export default interface Config {
 	audit_runtime?: string;
 	release?: boolean;
 	fast_math?: boolean;
+	out?: string;
 }