gofront 1.5.1 → 1.6.0

package/src/lower/escape.js

@@ -6,6 +6,7 @@
 
 import { collectDeclaredNames } from "./captures.js";
 import { rootIdentName } from "./ownership.js";
+import { forEachChild } from "./walk.js";
 
 /**
  * Checks whether an expression evaluates to one of the target pointer variables
@@ -15,7 +16,7 @@ import { rootIdentName } from "./ownership.js";
  * @param {Set<string>} targetNames Set of identifier names being tracked
  * @returns {boolean}
  */
-export function evaluatesToPointer(expr, targetNames) {
+function evaluatesToPointer(expr, targetNames) {
 	if (!expr || typeof expr !== "object") return false;
 	if (expr.kind === "Ident") {
 		return targetNames.has(expr.name);
@@ -144,10 +145,7 @@ export function paramEscapes(body, paramName) {
 					captured = true;
 					return;
 				}
-				for (const k of Object.keys(cNode)) {
-					if (k.startsWith("_")) continue;
-					checkClosure(cNode[k]);
-				}
+				forEachChild(cNode, checkClosure);
 			};
 			checkClosure(node.body);
 			if (captured) {
@@ -158,10 +156,7 @@ export function paramEscapes(body, paramName) {
 			return;
 		}
 
-		for (const key of Object.keys(node)) {
-			if (key.startsWith("_")) continue;
-			walk(node[key]);
-		}
+		forEachChild(node, walk);
 	};
 
 	walk(body);

package/src/lower/functions.js

@@ -1,6 +1,8 @@
 // src/lower/functions.js
 // Analyzes function signatures, named returns and defer structures.
 
+import { forEachChild, someChild } from "./walk.js";
+
 export function extractNamedReturns(decl) {
 	const named = decl?.returnType?._namedReturns;
 	if (!named || named.length === 0) return null;
@@ -19,12 +21,282 @@ export function hasDefer(body) {
 		if (Array.isArray(node)) return node.some(walk);
 		if (node.kind === "DeferStmt") return true;
 		if (node.kind === "FuncLit") return false; // separate function boundary
-		for (const key of Object.keys(node)) {
-			if (key.startsWith("_")) continue;
-			if (walk(node[key])) return true;
-		}
-		return false;
+		return someChild(node, walk);
 	};
 
 	return walk(body);
 }
+
+let defargCounter = 0;
+
+/**
+ * True when `body` contains a direct `recover()` call (not nested inside a
+ * FuncLit).  Used to decide which functions may legitimately observe an
+ * in-flight panic: Go only honours recover() when it is called directly by
+ * a deferred function.
+ */
+export function hasDirectRecover(body) {
+	if (!body) return false;
+	if (body._hasDirectRecover != null) return Boolean(body._hasDirectRecover);
+	const walk = (node) => {
+		if (!node || typeof node !== "object") return false;
+		if (Array.isArray(node)) return node.some(walk);
+		if (node.kind === "FuncLit") return false;
+		if (
+			node.kind === "CallExpr" &&
+			node.func?.kind === "Ident" &&
+			node.func.name === "recover"
+		)
+			return true;
+		return someChild(node, walk);
+	};
+	const result = walk(body);
+	body._hasDirectRecover = result;
+	return result;
+}
+
+const BUILTIN_FUNC_NAMES = new Set([
+	"println",
+	"print",
+	"panic",
+	"recover",
+	"make",
+	"new",
+	"len",
+	"cap",
+	"append",
+	"copy",
+	"delete",
+	"close",
+	"clear",
+	"min",
+	"max",
+]);
+
+export function normalizeDefers(programOrPrograms) {
+	defargCounter = 0;
+	const programs = Array.isArray(programOrPrograms)
+		? programOrPrograms
+		: [programOrPrograms];
+
+	const pkgFuncNames = new Set(BUILTIN_FUNC_NAMES);
+	// Package-level funcs/methods whose body calls recover() directly.  A
+	// `defer f()` whose callee is one of these must keep recover armed when the
+	// synthesized wrapper forwards the call.
+	const recoverFuncs = new Set();
+	for (const program of programs) {
+		for (const d of program?.decls ?? []) {
+			if (d.kind === "FuncDecl") pkgFuncNames.add(d.name);
+			if (
+				(d.kind === "FuncDecl" || d.kind === "MethodDecl") &&
+				hasDirectRecover(d.body)
+			)
+				recoverFuncs.add(d.name);
+		}
+	}
+	const ctx = { pkgFuncNames, recoverFuncs };
+
+	for (const program of programs) {
+		if (!program?.decls) continue;
+		for (const d of program.decls) {
+			if (d.body) normalizeBlockDefers(d.body, ctx);
+		}
+	}
+}
+
+function normalizeBlockDefers(node, ctx) {
+	if (!node || typeof node !== "object") return;
+	if (Array.isArray(node)) {
+		for (let i = 0; i < node.length; i++) {
+			const item = node[i];
+			if (item && item.kind === "DeferStmt") {
+				const inserted = normalizeDeferStmt(item, node, i, ctx);
+				i += inserted;
+			} else {
+				normalizeBlockDefers(item, ctx);
+			}
+		}
+		return;
+	}
+
+	if (node.kind === "FuncLit") {
+		normalizeBlockDefers(node.body, ctx);
+		return;
+	}
+
+	forEachChild(node, (child) => normalizeBlockDefers(child, ctx));
+}
+
+// Does the deferred callee possibly call recover() directly?  Known package
+// funcs/methods are looked up; unknown callees (closure variables, func
+// values) are assumed to, so recover stays armed through the wrapper.
+function deferCalleeMayRecover(funcExpr, ctx) {
+	if (!ctx) return false;
+	if (funcExpr.kind === "Ident") {
+		if (BUILTIN_FUNC_NAMES.has(funcExpr.name)) return false;
+		if (ctx.pkgFuncNames.has(funcExpr.name))
+			return ctx.recoverFuncs.has(funcExpr.name);
+		return true;
+	}
+	if (funcExpr.kind === "SelectorExpr") {
+		if (funcExpr.expr?._type?.kind === "namespace") return false;
+		return ctx.recoverFuncs.has(funcExpr.field);
+	}
+	if (funcExpr.kind === "FuncLit") return hasDirectRecover(funcExpr.body);
+	return true;
+}
+
+function normalizeDeferStmt(stmt, parentList = null, index = -1, ctx = null) {
+	if (stmt.call?.kind !== "CallExpr") return 0;
+	const call = stmt.call;
+	const isZeroArgFuncLit =
+		call.func?.kind === "FuncLit" && (!call.args || call.args.length === 0);
+	if (isZeroArgFuncLit) {
+		// The FuncLit itself is the deferred function: recover() inside it is
+		// honoured.
+		call.func._isDeferTarget = true;
+		normalizeBlockDefers(call.func.body, ctx);
+		return 0;
+	}
+	const pkgFuncNames = ctx?.pkgFuncNames ?? null;
+
+	const tempStmts = [];
+	let funcExpr = call.func;
+
+	// Hoist method receiver if call.func is a method call (e.g. defer r.Close()).
+	// Skipped for pointer-receiver methods on an addressable (non-pointer)
+	// operand: Go evaluates `&recv` at defer time, so the deferred call must
+	// observe later mutations of the original variable — copying the struct
+	// into a temp would break that.  The receiver expression itself is then
+	// re-evaluated at run time, which matches Go for the common `defer x.M()`
+	// / `defer s.f.M()` cases.
+	const recvIsAddressableValue =
+		call.func?._type?._ptrRecv === true &&
+		call.func.expr?._type?.kind !== "pointer";
+	if (
+		parentList &&
+		index >= 0 &&
+		call.func?.kind === "SelectorExpr" &&
+		call.func.expr?._type?.kind !== "namespace" &&
+		!recvIsAddressableValue
+	) {
+		const recv = call.func.expr;
+		defargCounter++;
+		const recvName = `__defrecv$${defargCounter}`;
+		const recvIdent = {
+			kind: "Ident",
+			name: recvName,
+			_type: recv._type,
+		};
+		tempStmts.push({
+			kind: "DefineStmt",
+			lhs: [{ kind: "Ident", name: recvName, _type: recv._type }],
+			rhs: [recv],
+		});
+		funcExpr = {
+			...call.func,
+			expr: recvIdent,
+		};
+	} else if (
+		parentList &&
+		index >= 0 &&
+		call.func?.kind === "Ident" &&
+		pkgFuncNames &&
+		!pkgFuncNames.has(call.func.name)
+	) {
+		// Hoist local function variable (e.g. fn := f1; defer fn(); fn = f2)
+		defargCounter++;
+		const fnName = `__deffn$${defargCounter}`;
+		const fnIdent = {
+			kind: "Ident",
+			name: fnName,
+			_type: call.func._type,
+		};
+		tempStmts.push({
+			kind: "DefineStmt",
+			lhs: [{ kind: "Ident", name: fnName, _type: call.func._type }],
+			rhs: [call.func],
+		});
+		funcExpr = fnIdent;
+	}
+
+	const args = call.args ?? [];
+	const tempIdents = [];
+
+	if (parentList && index >= 0 && args.length > 0) {
+		for (let a = 0; a < args.length; a++) {
+			const arg = args[a];
+			if (arg._type?.kind === "tuple" && Array.isArray(arg._type.types)) {
+				const tupleTypes = arg._type.types;
+				const tupleLhs = [];
+				for (let t = 0; t < tupleTypes.length; t++) {
+					defargCounter++;
+					const tempName = `__defarg$${defargCounter}`;
+					const ident = {
+						kind: "Ident",
+						name: tempName,
+						_type: tupleTypes[t],
+					};
+					tempIdents.push(ident);
+					tupleLhs.push(ident);
+				}
+				tempStmts.push({
+					kind: "DefineStmt",
+					lhs: tupleLhs,
+					rhs: [arg],
+				});
+			} else {
+				defargCounter++;
+				const tempName = `__defarg$${defargCounter}`;
+				tempIdents.push({
+					kind: "Ident",
+					name: tempName,
+					_type: arg._type,
+				});
+				tempStmts.push({
+					kind: "DefineStmt",
+					lhs: [{ kind: "Ident", name: tempName, _type: arg._type }],
+					rhs: [arg],
+				});
+			}
+		}
+	}
+
+	if (parentList && index >= 0 && tempStmts.length > 0) {
+		parentList.splice(index, 0, ...tempStmts);
+	}
+
+	const callArgs = tempIdents.length > 0 ? tempIdents : args;
+	const innerCall = {
+		...call,
+		func: funcExpr,
+		args: callArgs,
+		_multiForward: tempIdents.length > 0 ? false : call._multiForward,
+	};
+	const synthFuncLit = {
+		kind: "FuncLit",
+		params: [],
+		returnType: null,
+		body: {
+			kind: "Block",
+			stmts: [{ kind: "ExprStmt", expr: innerCall }],
+			list: [{ kind: "ExprStmt", expr: innerCall }],
+			_hasDefer: false,
+		},
+		_type: { kind: "FuncType", params: [], returnType: null },
+		_isDeferTarget: true,
+		// The wrapper only forwards to the real deferred callee; when that
+		// callee may call recover() directly, recover must stay armed across
+		// the wrapper frame.
+		_deferForward: deferCalleeMayRecover(call.func, ctx),
+	};
+	if (call.func?.kind === "FuncLit") normalizeBlockDefers(call.func.body, ctx);
+	stmt.call = {
+		kind: "CallExpr",
+		func: synthFuncLit,
+		args: [],
+		_type: { kind: "basic", name: "void" },
+	};
+
+	return tempStmts.length;
+}

package/src/lower/globals.js

@@ -3,6 +3,7 @@
 // and computes functions that participate in the package initialization call path.
 
 import { isReferenceType } from "./boxing.js";
+import { forEachChild, someChild } from "./walk.js";
 
 /**
  * Computes:
@@ -117,11 +118,9 @@ function scanReassignments(node, packageGlobals, reassigned, insideInit) {
 		}
 	}
 	checkAddressTaken(node, packageGlobals, reassigned);
-	for (const k of Object.keys(node)) {
-		if (!k.startsWith("_")) {
-			scanReassignments(node[k], packageGlobals, reassigned, insideInit);
-		}
-	}
+	forEachChild(node, (child) =>
+		scanReassignments(child, packageGlobals, reassigned, insideInit),
+	);
 }
 
 function addCallTarget(call, called) {
@@ -145,9 +144,7 @@ function findCalledFunctions(node, called = new Set()) {
 		return called;
 	}
 	if (node.kind === "CallExpr") addCallTarget(node, called);
-	for (const k of Object.keys(node)) {
-		if (!k.startsWith("_")) findCalledFunctions(node[k], called);
-	}
+	forEachChild(node, (child) => findCalledFunctions(child, called));
 	return called;
 }
 
@@ -244,9 +241,7 @@ function scanReadIdents(node, readSet) {
 		readSet.add(node.name);
 		return;
 	}
-	for (const k of Object.keys(node)) {
-		if (!k.startsWith("_")) scanReadIdents(node[k], readSet);
-	}
+	forEachChild(node, (child) => scanReadIdents(child, readSet));
 }
 
 function isLocallyDeclared(node, name) {
@@ -265,10 +260,7 @@ function isLocallyDeclared(node, name) {
 				return true;
 		}
 	}
-	for (const k of Object.keys(node)) {
-		if (!k.startsWith("_") && isLocallyDeclared(node[k], name)) return true;
-	}
-	return false;
+	return someChild(node, (child) => isLocallyDeclared(child, name));
 }
 
 function getGlobalsToCache(fn, neverAssignedGlobals, initPathFunctions) {

package/src/lower/index.js

@@ -9,16 +9,17 @@ export * from "./functions.js";
 export * from "./globals.js";
 export * from "./ownership.js";
 export * from "./range.js";
+export * from "./walk.js";
 
 import { scanAddressTaken } from "./boxing.js";
 import { analyzeCaptures } from "./captures.js";
 import { computeEmbeddedStubs } from "./embedding.js";
 import { paramEscapes } from "./escape.js";
-import { extractNamedReturns, hasDefer } from "./functions.js";
+import { extractNamedReturns, hasDefer, normalizeDefers } from "./functions.js";
 import { computeGlobalAnalysis } from "./globals.js";
 import { OwnershipContext } from "./ownership.js";
 
-export class LowerResult {
+class LowerResult {
 	constructor() {
 		// Map<ASTNode (FuncDecl, MethodDecl, FuncLit), Set<string>>
 		this.boxedVars = new Map();
@@ -53,6 +54,8 @@ export function lower(programOrPrograms, checker = null) {
 		? programOrPrograms
 		: [programOrPrograms];
 
+	normalizeDefers(programs);
+
 	// 1. Aggregate methods across all files in the package
 	const methodMap = new Map();
 	for (const program of programs) {

package/src/lower/ownership.js

@@ -1,6 +1,8 @@
 // src/lower/ownership.js
 // Tracks variable ownership, mutation and clone elision for Go value semantics.
 
+import { forEachChild, someChild } from "./walk.js";
+
 export function rootIdentName(e) {
 	while (e) {
 		if (e.kind === "Ident") return e.name;
@@ -42,11 +44,7 @@ export function nodeMutatesVar(node, name, addrOnly = false) {
 	)
 		return true;
 	if (!addrOnly && nodeWritesVar(node, name)) return true;
-	for (const key of Object.keys(node)) {
-		if (key.startsWith("_")) continue;
-		if (nodeMutatesVar(node[key], name, addrOnly)) return true;
-	}
-	return false;
+	return someChild(node, (child) => nodeMutatesVar(child, name, addrOnly));
 }
 
 // Single-pass collector of all mutated or address-taken variables in an AST node.
@@ -85,10 +83,7 @@ export function collectMutatedVars(
 		}
 	}
 
-	for (const key of Object.keys(node)) {
-		if (key.startsWith("_")) continue;
-		collectMutatedVars(node[key], mutated, addrOnly);
-	}
+	forEachChild(node, (child) => collectMutatedVars(child, mutated, addrOnly));
 	return mutated;
 }
 
@@ -112,7 +107,7 @@ export function closureMutates(body, name, cache = null) {
 		if (!node || typeof node !== "object") return false;
 		if (Array.isArray(node)) return node.some(walk);
 		if (node.kind === "FuncLit") return nodeMutatesVar(node.body, name);
-		return Object.keys(node).some((k) => !k.startsWith("_") && walk(node[k]));
+		return someChild(node, walk);
 	};
 	const res = walk(body);
 	if (cache) cache.set(key, res);

package/src/lower/range.js

@@ -2,6 +2,7 @@
 // Classifies for-range loop shapes and variable scoping/redelcarations.
 
 import { isNumeric } from "../typechecker/types.js";
+import { someChild } from "./walk.js";
 
 export function isRangeFor(stmt) {
 	if (!stmt?.init) return false;
@@ -40,11 +41,7 @@ export function nodeAssigns(node, name) {
 			node.expr.name === name)
 	)
 		return true;
-	for (const key of Object.keys(node)) {
-		if (key.startsWith("_")) continue;
-		if (nodeAssigns(node[key], name)) return true;
-	}
-	return false;
+	return someChild(node, (child) => nodeAssigns(child, name));
 }
 
 // True when the body re-declares one of `names` at its top level (legal Go shadowing).

package/src/lower/walk.js

@@ -0,0 +1,25 @@
+// src/lower/walk.js
+// Shared AST child traversal for the lowering passes.  Side-table fields
+// (`_type`, `_boxed`, …) start with "_" and are never AST children.
+
+/** True for a side-table key that traversal must skip. */
+function isSideTableKey(key) {
+	return key.charCodeAt(0) === 95; // "_"
+}
+
+/** Calls `fn(child)` for every non-side-table property of `node`. */
+export function forEachChild(node, fn) {
+	for (const key of Object.keys(node)) {
+		if (isSideTableKey(key)) continue;
+		fn(node[key]);
+	}
+}
+
+/** True when `pred(child)` holds for some non-side-table property of `node`. */
+export function someChild(node, pred) {
+	for (const key of Object.keys(node)) {
+		if (isSideTableKey(key)) continue;
+		if (pred(node[key])) return true;
+	}
+	return false;
+}

package/src/resolver.js

@@ -49,6 +49,7 @@ const BUILTIN_PACKAGES = new Set([
 	"path",
 	"path/filepath",
 	"testing",
+	"gofront/shared",
 ]);
 
 // Returns true for local relative paths (start with ./ or ../)
@@ -72,7 +73,7 @@ export function resolveGwDir(importPath, fromFile) {
 	return gwFiles.length > 0 ? dir : null;
 }
 
-export function resolveImport(importPath, fromFile) {
+function resolveImport(importPath, fromFile) {
 	const fromDir = dirname(resolve(fromFile));
 	const nodeModules = findNodeModules(fromDir);
 

package/src/test-runner.js

@@ -14,6 +14,19 @@ import {
 	gwFilesIn,
 } from "./compiler.js";
 
+// WasmGC + exception handling (what the wasm backend emits) ship enabled by
+// default from Node 22 (V8 11.9+). Older runtimes fail at instantiate time
+// with an opaque CompileError, so check up front and explain.
+export const MIN_WASM_NODE_MAJOR = 22;
+
+export function checkWasmRuntime(version = process.version) {
+	const major = Number.parseInt(version.replace(/^v/, ""), 10);
+	if (Number.isNaN(major) || major >= MIN_WASM_NODE_MAJOR) return;
+	throw new Error(
+		`running wasm packages requires Node ${MIN_WASM_NODE_MAJOR}+ (WasmGC); found ${version}\n  hint: upgrade Node, or compile with --js-only to run the JS backend instead`,
+	);
+}
+
 export function isTestFunc(decl) {
 	if (decl.kind !== "FuncDecl") return false;
 	if (!decl.name.startsWith("Test")) return false;
@@ -382,6 +395,13 @@ export async function runTests(targetDir, options = {}) {
 
 	// `wasm` packages run inside the linked app.wasm; `js` packages that import
 	// wasm packages need the linked module too (hybrid packages).
+	if (compiled.target === "both" || compiled.wasm) {
+		try {
+			checkWasmRuntime();
+		} catch (err) {
+			return reportBuildFailure(err, resolvedDir, options);
+		}
+	}
 	if (compiled.target === "both") {
 		return runDualTarget(compiled, resolvedDir, runHarness, options);
 	}

package/src/typechecker/assignability.js

@@ -1,6 +1,7 @@
 // Assignability, binary result types, and interface satisfaction.
 // Installed as a mixin on TypeChecker.prototype.
 
+import { sharedInfo } from "./stdlib/shared.js";
 import {
 	ANY,
 	BOOL,
@@ -159,6 +160,7 @@ export const assignabilityMethods = {
 		target = this.resolveType(target);
 		source = this.resolveType(source);
 		this._markIfaceBox(target, source, node);
+		this._checkWasmIfaceProvider(target, source, node);
 		if (this._assertAssignableEarlyReturn(target, source)) return;
 		if (isPointer(target) && isPointer(source)) {
 			this.assertAssignable(
@@ -200,6 +202,24 @@ export const assignabilityMethods = {
 			node._ifaceBox = "ptr";
 	},
 
+	// A js package cannot provide an implementation of a wasm interface: the
+	// value would cross into wasm, and JS-implemented proxies are not supported.
+	_checkWasmIfaceProvider(target, source, node) {
+		if (this.target !== "js" || target?.kind !== "named") return;
+		if (target._target !== "wasm" || !source) return;
+		const iface = this.resolveType(target.underlying);
+		if (iface?.kind !== "interface" || !(iface.methods?.size > 0)) return;
+		const ptr = source.kind === "pointer";
+		const src = ptr ? this.resolveType(source.base) : source;
+		if (src?.kind !== "named" || src._target === "wasm") return;
+		if (this.resolveType(src.underlying)?.kind === "interface") return;
+		if (!this.implements(source, iface, node)) return;
+		this.err(
+			`type '${ptr ? "*" : ""}${src.name}' (${src._target ?? "js"}) cannot implement wasm interface '${target.name}' across the boundary; implement it in a wasm package or pass a func callback`,
+			node,
+		);
+	},
+
 	_assertAssignableEarlyReturn(target, source) {
 		return (
 			target?.kind === "typeParam" ||
@@ -222,6 +242,23 @@ export const assignabilityMethods = {
 				);
 			return;
 		}
+		const sBase = this.resolveType(
+			source.kind === "named" ? source.underlying : source,
+		);
+		if (sharedInfo(source) && tBase?.kind === "slice") {
+			this.err(
+				`cannot use ${typeStr(source)} as ${typeStr(target)}: a linear-memory buffer cannot be passed as a GC slice without an explicit copy`,
+				node,
+			);
+			return;
+		}
+		if (tBase?.kind === "shared" && sBase?.kind === "slice") {
+			this.err(
+				`cannot use ${typeStr(source)} as ${typeStr(target)}: a GC slice cannot be used as a shared buffer; copy its elements into one allocated with shared.New${tBase.shared}`,
+				node,
+			);
+			return;
+		}
 		this.err(`Cannot assign ${typeStr(source)} to ${typeStr(target)}`, node);
 	},
 
@@ -346,6 +383,7 @@ export const assignabilityMethods = {
 	},
 
 	implements(srcType, iface, _node) {
+		const isPtr = srcType?.kind === "pointer";
 		// *T has the full method set of T (value + pointer receivers).
 		if (srcType?.kind === "pointer") srcType = this.resolveType(srcType.base);
 		let base = srcType.kind === "named" ? srcType.underlying : srcType;
@@ -366,7 +404,10 @@ export const assignabilityMethods = {
 					: null;
 		if (!methodMap) return false;
 		for (const [name, required] of iface.methods) {
-			if (!this._implementsMethod(required, methodMap.get(name))) return false;
+			const actual = methodMap.get(name);
+			if (!actual) return false;
+			if (!isPtr && actual._ptrRecv) return false;
+			if (!this._implementsMethod(required, actual)) return false;
 		}
 		return true;
 	},