nomen-lang 0.0.14 → 0.0.15

package/dist/index.mjs

@@ -12110,13 +12110,7 @@ function build_spawn_node(node, status) {
 	if (!status.headers.includes("__nomen_pool_submit")) status.headers += POOL_HEADER;
 	const struct_name = `__nomen_spawn_${id}_args`;
 	const tramp_name = `__nomen_spawn_${id}_trampoline`;
-	const arg_c_types = [];
-	for (let i = 0; i < call.params.length; i++) {
-		const mono_name = mono_type_name(type_from_value_node$1(call.params[i]));
-		const is_class = !!status.structs.find((s) => s.name === mono_name && s.is_class);
-		const is_trait = !!status.traits.find((t) => t.name === mono_name);
-		arg_c_types.push(is_class || is_trait ? `struct ${mono_name} *` : c_type(mono_name));
-	}
+	const arg_c_types = spawn_arg_c_types(call, status);
 	const return_type_name = node.function_return_type?.name;
 	const returns_value = !!(return_type_name && return_type_name !== "void" && return_type_name !== "?");
 	const is_class_ret = returns_value && !!status.structs.find((s) => s.name === return_type_name && s.is_class);
@@ -12189,6 +12183,98 @@ function build_spawn_node(node, status) {
 	}
 	status.code += `})\n`;
 }
+const C_BUILTIN_TYPES = /* @__PURE__ */ new Set([
+	"bool",
+	"int",
+	"uint",
+	"int8",
+	"uint8",
+	"int16",
+	"uint16",
+	"int32",
+	"uint32",
+	"int64",
+	"uint64",
+	"float",
+	"ufloat",
+	"float32",
+	"ufloat32",
+	"float64",
+	"ufloat64",
+	"char",
+	"string",
+	"func",
+	"void",
+	"null"
+]);
+/**
+* Resolve each spawn argument's C type. Classes/traits are pointers;
+* primitives and by-value structs use c_type's output directly. Generic
+* instantiations (e.g. Channel<uint64>) use the monomorphized C name
+* (`Channel_uint64`). The type comes from the CALLEE's declared parameter
+* whenever it can be resolved — an argument's own node type can differ
+* (e.g. an int literal `41` passed for a `uint64` param lowers to `long`,
+* conflicting with the emitted `unsigned long long` prototype). Falls back
+* to the argument's type when the callee (or its param type) can't be
+* resolved at build time.
+*/
+function spawn_arg_c_types(call, status) {
+	const arg_c_types = [];
+	const callee_params = find_spawn_callee(call.name, status)?.params?.filter((p) => !p.is_self_param) ?? [];
+	for (let i = 0; i < call.params.length; i++) {
+		const mono_name = mono_type_name(callee_params[i]?.type && is_resolvable_c_type(callee_params[i].type, status) ? callee_params[i].type : type_from_value_node$1(call.params[i]));
+		const is_class = !!status.structs.find((s) => s.name === mono_name && s.is_class);
+		const is_trait = !!status.traits.find((t) => t.name === mono_name);
+		arg_c_types.push(is_class || is_trait ? `struct ${mono_name} *` : c_type(mono_name));
+	}
+	return arg_c_types;
+}
+/** Whether a Nomen type name lowers to a real C type in this build: a
+*  builtin primitive or a struct/enum the backend knows (post-monomorphization).
+*  Unresolved generic type params (`T`) fail this check. */
+function is_resolvable_c_type(type, status) {
+	if (C_BUILTIN_TYPES.has(type.name)) return true;
+	return !!status.structs.find((s) => s.name === type.name);
+}
+/**
+* Find the spawned function's definition — a top-level function, a function
+* nested in a block (parse wrappers hoist user code into `main`), or a
+* struct/trait method (matched by its mangled `Struct_method` name) — so the
+* trampoline's forward declaration can copy the callee's DECLARED parameter
+* types. Monomorphized clones are also reachable this way (they are appended
+* to the AST). A same-named pair would already collide at C level, so the
+* first match is as good as any.
+*/
+function find_spawn_callee(name, status) {
+	let found;
+	const visit = (node) => {
+		if (found || !node || typeof node !== "object") return;
+		if (node.node_type === "func") {
+			if (node.name === name) {
+				found = node;
+				return;
+			}
+		} else if (node.node_type === "struct" || node.node_type === "trait") {
+			const functions = node.functions ?? [];
+			for (const func of functions) {
+				const owner = node.name;
+				if (func.name === name || `${owner}_${func.name}` === name) {
+					found = func;
+					return;
+				}
+			}
+		}
+		for (const key of Object.keys(node)) {
+			if (key === "parent" || key === "scope") continue;
+			const v = node[key];
+			if (Array.isArray(v)) for (const item of v) visit(item);
+			else if (v && typeof v === "object" && "node_type" in v) visit(v);
+			if (found) return;
+		}
+	};
+	visit(status.root);
+	return found;
+}
 //#endregion
 //#region ../src/build_c/build_nursery_spawn.ts
 /**
@@ -12214,13 +12300,7 @@ function build_nursery_spawn(node, nursery_ptr, status) {
 	if (!status.headers.includes("__nomen_pool_submit")) status.headers += POOL_HEADER;
 	const struct_name = `__nomen_spawn_${id}_args`;
 	const tramp_name = `__nomen_spawn_${id}_trampoline`;
-	const arg_c_types = [];
-	for (let i = 0; i < args.length; i++) {
-		const mono_name = mono_type_name(type_from_value_node$1(args[i]));
-		const is_class = !!status.structs.find((s) => s.name === mono_name && s.is_class);
-		const is_trait = !!status.traits.find((t) => t.name === mono_name);
-		arg_c_types.push(is_class || is_trait ? `struct ${mono_name} *` : c_type(mono_name));
-	}
+	const arg_c_types = spawn_arg_c_types(call, status);
 	const return_type_name = node.function_return_type?.name;
 	const returns_value = !!(return_type_name && return_type_name !== "void" && return_type_name !== "?");
 	const is_class_ret = returns_value && !!status.structs.find((s) => s.name === return_type_name && s.is_class);
@@ -13517,12 +13597,14 @@ function build_assignment_node(node, status) {
 	if (!node.operator && node.left_value.node_type === "access" && node.left_value.access.node_type === "access_field" && node.left_value.access.type?.name === "string" && !node.left_value.access.type?.is_ref && !node.left_value.access.type?.is_array) {
 		const access_lhs = node.left_value;
 		const field_access_node = access_lhs.access;
-		const target_type = type_from_value_node$1(access_lhs.target);
+		let target_type = type_from_value_node$1(access_lhs.target);
+		if (!target_type?.name && access_lhs.target.node_type === "value" && access_lhs.target.value === "self" && status.current_struct) target_type = new Type(status.current_struct.name);
 		const target_struct = target_type?.name ? status.structs.find((s) => s.name === target_type.name && !s.is_simple_type) : null;
 		const target_var = access_lhs.target.node_type === "value" ? access_lhs.target.value : "";
+		const self_target = target_var === "self";
 		const tracked_key = `${target_var}.${field_access_node.name}`;
 		const old_was_heap = !!target_struct?.is_class || !!status.heap_string_fields?.has(tracked_key);
-		if (target_struct && target_var && target_var !== "self") {
+		if (target_struct && target_var && (!self_target || target_struct.is_class)) {
 			const fresh_heap = is_owned_heap_temp(node.right_value, status);
 			const before_len = status.code.length;
 			build_node(node.left_value, status);
@@ -15808,6 +15890,52 @@ function emit_nullable_arg_flag(arg, status) {
 	status.code += `1`;
 }
 //#endregion
+//#region ../src/build_c/utils/build_condition.ts
+/**
+* Build a controlling expression (an if/while/for condition or a switch-case
+* comparison) and emit it without redundant fully-wrapping outer parentheses.
+* The codegen wraps every binary operation in parens (build_default_binary),
+* so emitting the condition verbatim would read `if ((a == b))`, which clang
+* flags as -Wparentheses-equality ("equality comparison with extraneous
+* parentheses").
+*/
+function build_condition(node, status) {
+	const before = status.code.length;
+	build_node(node, status);
+	status.code = status.code.substring(0, before) + strip_outer_parens(status.code.substring(before));
+}
+/**
+* Strip outer paren layers that wrap the ENTIRE expression (the opening paren
+* matches only the final character). A layer is removed only when the inner
+* text does not start with `{` — a GCC/clang statement-expression
+* `({ ... })` must keep its wrapper to stay a valid expression. Parens
+* inside string/char literals can only make the scan conservative (they
+* unbalance the depth count, so nothing is stripped), never incorrect.
+*/
+function strip_outer_parens(expr) {
+	let code = expr.trim();
+	while (code.length > 1 && code.startsWith("(") && code.endsWith(")")) {
+		let depth = 0;
+		let wraps_whole = true;
+		for (let i = 0; i < code.length; i++) {
+			const ch = code[i];
+			if (ch === "(") depth++;
+			else if (ch === ")") {
+				depth--;
+				if (depth === 0 && i < code.length - 1) {
+					wraps_whole = false;
+					break;
+				}
+			}
+		}
+		if (!wraps_whole || depth !== 0) break;
+		const inner = code.slice(1, -1).trim();
+		if (inner.startsWith("{")) break;
+		code = inner;
+	}
+	return code;
+}
+//#endregion
 //#region ../src/build_c/build_if_else_node.ts
 function build_if_else_node(node, status) {
 	const old_scoped_declarations = status.scoped_declarations;
@@ -15816,7 +15944,7 @@ function build_if_else_node(node, status) {
 	status.deferred_frees = [];
 	emit_allocations(node.condition, status);
 	status.code += `if (`;
-	build_node(node.condition, status);
+	build_condition(node.condition, status);
 	status.code += `) {\n`;
 	if (node.if_branch) {
 		build_block_node(node.if_branch, status);
@@ -16229,6 +16357,7 @@ function build_switch_node(node, status) {
 		}
 		cond_code = cond_code.trim();
 		while (cond_code.startsWith("(") && !cond_code.endsWith(")")) cond_code = cond_code.substring(1).trim();
+		cond_code = strip_outer_parens(cond_code);
 		if (decls.length > 0) status.code += decls.join("\n") + "\n";
 		const prefix = status.code.endsWith("} else ") ? "" : "";
 		status.code += `${prefix}if (${cond_code}) {\n`;
@@ -16305,13 +16434,13 @@ function build_while_loop_node(node, status) {
 	emit_allocations(node.condition, status);
 	if (node.update) {
 		status.code += `for (; `;
-		build_node(node.condition, status);
+		build_condition(node.condition, status);
 		status.code += `; `;
 		build_node(node.update, status);
 		status.code += `) {\n`;
 	} else {
 		status.code += `while (`;
-		build_node(node.condition, status);
+		build_condition(node.condition, status);
 		status.code += `) {\n`;
 	}
 	build_block_node(node, status);

package/package.json

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