gofront 1.4.0 → 1.6.0

package/src/lower/captures.js

@@ -0,0 +1,172 @@
+// src/lower/captures.js
+// Identifies free variables captured by closures and determines which ones
+// are mutated and thus require heap-allocated environment cells for WASM closures.
+
+import { collectMutatedVars, nodeMutatesVar } from "./ownership.js";
+import { forEachChild } from "./walk.js";
+
+/**
+ * Result of capture analysis on a function or closure.
+ */
+export class CaptureAnalysis {
+	constructor() {
+		// Map<FuncLit, Set<string>>: free variables captured by each closure
+		this.capturesByClosure = new Map();
+		// Set<string>: variables in the enclosing scope that are captured AND mutated
+		this.mutatedCaptures = new Set();
+	}
+}
+
+/**
+ * Finds all variable declarations in a block or list of statements.
+ */
+export function collectDeclaredNames(node, names = new Set()) {
+	if (!node || typeof node !== "object") return names;
+	if (Array.isArray(node)) {
+		for (const item of node) collectDeclaredNames(item, names);
+		return names;
+	}
+
+	if (node.kind === "VarDecl" || node.kind === "ConstDecl") {
+		for (const spec of node.decls ?? []) {
+			for (const name of spec.names ?? []) names.add(name);
+		}
+	} else if (node.kind === "DefineStmt") {
+		for (const lhs of node.lhs ?? []) {
+			if (lhs.kind === "Ident") names.add(lhs.name);
+		}
+	} else if (node.kind === "TypeSwitchStmt" && node.assign) {
+		names.add(node.assign);
+	}
+
+	// Do not descend into nested functions when collecting local declarations
+	if (node.kind === "FuncLit") return names;
+
+	forEachChild(node, (child) => collectDeclaredNames(child, names));
+	return names;
+}
+
+/**
+ * Finds all identifier references in a node that are not shadowed by inner declarations.
+ */
+function collectReferencedNames(node, localDecls, refs = new Set()) {
+	if (!node || typeof node !== "object") return refs;
+	if (Array.isArray(node)) {
+		for (const item of node) collectReferencedNames(item, localDecls, refs);
+		return refs;
+	}
+
+	// In struct literals, field names in KeyValueExpr are not variable references
+	if (node.kind === "KeyValueExpr") {
+		collectReferencedNames(node.value, localDecls, refs);
+		return refs;
+	}
+
+	if (node.kind === "FuncLit") {
+		const innerLocals = new Set(localDecls);
+		for (const p of node.params ?? []) {
+			if (p.name && p.name !== "_") innerLocals.add(p.name);
+		}
+		for (const r of node.returnType?._namedReturns ?? []) {
+			if (r.name && r.name !== "_") innerLocals.add(r.name);
+		}
+		collectDeclaredNames(node.body, innerLocals);
+		forEachChild(node, (child) =>
+			collectReferencedNames(child, innerLocals, refs),
+		);
+		return refs;
+	}
+
+	if (
+		node.kind === "Ident" &&
+		!localDecls.has(node.name) &&
+		node.name !== "_"
+	) {
+		refs.add(node.name);
+	}
+
+	// For nested closures, free variables are also referenced
+	forEachChild(node, (child) =>
+		collectReferencedNames(child, localDecls, refs),
+	);
+	return refs;
+}
+
+/**
+ * Analyzes a function or method declaration for closures and their captured variables.
+ * @param {Object} fnDecl AST FuncDecl or FuncLit node
+ * @returns {CaptureAnalysis}
+ */
+export function analyzeCaptures(fnDecl) {
+	const result = new CaptureAnalysis();
+	if (!fnDecl?.body) return result;
+
+	// Collect parameters, receiver and named returns of the root function
+	const rootScope = new Set();
+	if (fnDecl.recvName && fnDecl.recvName !== "_") {
+		rootScope.add(fnDecl.recvName);
+	}
+	for (const p of fnDecl.params ?? []) {
+		if (p.name && p.name !== "_") rootScope.add(p.name);
+	}
+	for (const r of fnDecl.returnType?._namedReturns ?? []) {
+		if (r.name && r.name !== "_") rootScope.add(r.name);
+	}
+	collectDeclaredNames(fnDecl.body, rootScope);
+
+	// Fast pre-collected set of all mutated variables in the entire function
+	const mutatedVars = collectMutatedVars(fnDecl.body);
+
+	// Traverse closures with lexical scope stack to properly handle arbitrary nesting
+	const walkClosures = (node, scopeStack) => {
+		if (!node || typeof node !== "object") return;
+		if (Array.isArray(node)) {
+			for (const item of node) walkClosures(item, scopeStack);
+			return;
+		}
+
+		if (node.kind === "FuncLit") {
+			const closureLocals = new Set();
+			for (const p of node.params ?? []) {
+				if (p.name && p.name !== "_") closureLocals.add(p.name);
+			}
+			for (const r of node.returnType?._namedReturns ?? []) {
+				if (r.name && r.name !== "_") closureLocals.add(r.name);
+			}
+			collectDeclaredNames(node.body, closureLocals);
+
+			// Visible outer variables from all enclosing ancestor scopes
+			const allOuterScope = new Set();
+			for (const scope of scopeStack) {
+				for (const name of scope) allOuterScope.add(name);
+			}
+
+			const allRefs = collectReferencedNames(node.body, closureLocals);
+			const captured = new Set();
+			for (const ref of allRefs) {
+				if (allOuterScope.has(ref)) {
+					captured.add(ref);
+				}
+			}
+			result.capturesByClosure.set(node, captured);
+
+			for (const varName of captured) {
+				if (
+					mutatedVars.has(varName) ||
+					nodeMutatesVar(fnDecl.body, varName) ||
+					nodeMutatesVar(node.body, varName)
+				) {
+					result.mutatedCaptures.add(varName);
+				}
+			}
+
+			walkClosures(node.body, [...scopeStack, closureLocals]);
+			return;
+		}
+
+		forEachChild(node, (child) => walkClosures(child, scopeStack));
+	};
+
+	walkClosures(fnDecl.body, [rootScope]);
+	return result;
+}

package/src/lower/embedding.js

@@ -0,0 +1,30 @@
+// src/lower/embedding.js
+// Computes promoted methods and delegation stubs for embedded structs.
+
+export function computeEmbeddedStubs(name, methodDecls, checker) {
+	if (!checker) return [];
+	const resolvedType = checker.types.get(name)?.underlying;
+	if (resolvedType?.kind !== "struct" || !resolvedType._embeds) return [];
+
+	const declared = new Set(methodDecls.map((m) => m.name));
+	const stubs = [];
+
+	for (const embed of resolvedType._embeds) {
+		const embedName = embed.kind === "named" ? embed.name : null;
+		if (!embedName) continue;
+		const embedBase = embed.kind === "named" ? embed.underlying : embed;
+		if (embedBase?.kind !== "struct" || !embedBase.methods) continue;
+
+		for (const [mName] of embedBase.methods.entries()) {
+			if (!declared.has(mName)) {
+				stubs.push({
+					methodName: mName,
+					embedName,
+				});
+				declared.add(mName); // Prevent duplicate stubs for diamond embeds
+			}
+		}
+	}
+
+	return stubs;
+}

package/src/lower/escape.js

@@ -0,0 +1,164 @@
+// src/lower/escape.js
+// Analyzes pointer retention / escaping for arguments across the WASM boundary.
+// In GoFront's hybrid model, `*T` where T is a `both` type (e.g. `*mathx.Vec3`) uses
+// copy-in/copy-out per call. If the WASM side retains the pointer beyond the call,
+// it is flagged as an escape error.
+
+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
+ * (or an interior pointer into them).
+ *
+ * @param {Object} expr AST expression node
+ * @param {Set<string>} targetNames Set of identifier names being tracked
+ * @returns {boolean}
+ */
+function evaluatesToPointer(expr, targetNames) {
+	if (!expr || typeof expr !== "object") return false;
+	if (expr.kind === "Ident") {
+		return targetNames.has(expr.name);
+	}
+	if (expr.kind === "ParenExpr" || expr.kind === "TypeAssertExpr") {
+		return evaluatesToPointer(expr.expr, targetNames);
+	}
+	// Type conversions: (*Vec3)(p)
+	if (expr.kind === "CallExpr" && expr.args?.length === 1) {
+		return evaluatesToPointer(expr.args[0], targetNames);
+	}
+	// Interior pointer: &p.Field or &p[i] retains a pointer into p, or &CompositeLit holding p
+	if (expr.kind === "UnaryExpr" && expr.op === "&") {
+		const root = rootIdentName(expr.operand);
+		if (root != null && targetNames.has(root)) return true;
+		return evaluatesToPointer(expr.operand, targetNames);
+	}
+	// Composite literal holding pointer: Holder{ P: p } or []*Vec{ p }
+	if (expr.kind === "CompositeLit") {
+		for (const elem of expr.elems ?? []) {
+			const val = elem.kind === "KeyValueExpr" ? elem.value : elem;
+			if (evaluatesToPointer(val, targetNames)) return true;
+		}
+	}
+	return false;
+}
+
+/**
+ * Checks if a parameter identifier escapes or is retained in `body`.
+ * A parameter `name` is considered retained if it:
+ * - is returned from the function
+ * - is assigned to a package global or external object field
+ * - is stored into a struct field or slice/map element (e.g., `obj.field = p`, `arr[i] = p`)
+ * - is captured by a closure that outlives or is returned from the function
+ *
+ * @param {Object} body AST block of the function
+ * @param {string} paramName Name of the parameter to check
+ * @returns {boolean} True if param escapes/is retained, false if only used locally in-place
+ */
+export function paramEscapes(body, paramName) {
+	if (!body || !paramName || paramName === "_") return false;
+
+	const aliases = new Set([paramName]);
+	const localNames = new Set([paramName]);
+	collectDeclaredNames(body, localNames);
+
+	let escapes = false;
+
+	const walk = (node) => {
+		if (escapes || !node || typeof node !== "object") return;
+		if (Array.isArray(node)) {
+			for (const item of node) walk(item);
+			return;
+		}
+
+		// 1. Returning the pointer
+		if (node.kind === "ReturnStmt") {
+			for (const res of node.values ?? node.results ?? []) {
+				if (evaluatesToPointer(res, aliases)) {
+					escapes = true;
+					return;
+				}
+			}
+		}
+
+		// 2. Assigning the pointer:
+		// Storing into a field, index, or package-level global escapes.
+		// Storing into a local variable aliases the pointer.
+		if (node.kind === "AssignStmt") {
+			for (let i = 0; i < node.lhs.length; i++) {
+				const lhs = node.lhs[i];
+				const rhs = node.rhs?.[i];
+				if (!rhs) continue;
+				if (evaluatesToPointer(rhs, aliases)) {
+					// Storing into a field or index: `target.field = p` or `arr[i] = p`
+					if (lhs.kind === "SelectorExpr" || lhs.kind === "IndexExpr") {
+						escapes = true;
+						return;
+					}
+					// If LHS is not a local variable declared in body, it's package-level / global
+					if (lhs.kind === "Ident") {
+						if (!localNames.has(lhs.name)) {
+							escapes = true;
+							return;
+						}
+						aliases.add(lhs.name);
+					}
+				}
+			}
+		}
+
+		// 3. Short variable definition: local alias `tmp := p`
+		if (node.kind === "DefineStmt") {
+			for (let i = 0; i < node.lhs.length; i++) {
+				const lhs = node.lhs[i];
+				const rhs = node.rhs?.[i];
+				if (rhs && evaluatesToPointer(rhs, aliases)) {
+					if (lhs.kind === "Ident") {
+						aliases.add(lhs.name);
+					}
+				}
+			}
+		}
+
+		// 4. Storing into append call: `slice = append(slice, p)`
+		const fnName = node.func?.name ?? node.fun?.name;
+		if (node.kind === "CallExpr" && fnName === "append") {
+			for (const arg of node.args?.slice(1) ?? []) {
+				if (evaluatesToPointer(arg, aliases)) {
+					escapes = true;
+					return;
+				}
+			}
+		}
+
+		// 5. Storing into a closure (FuncLit)
+		if (node.kind === "FuncLit") {
+			let captured = false;
+			const checkClosure = (cNode) => {
+				if (captured || !cNode || typeof cNode !== "object") return;
+				if (Array.isArray(cNode)) {
+					for (const item of cNode) checkClosure(item);
+					return;
+				}
+				if (cNode.kind === "Ident" && aliases.has(cNode.name)) {
+					captured = true;
+					return;
+				}
+				forEachChild(cNode, checkClosure);
+			};
+			checkClosure(node.body);
+			if (captured) {
+				escapes = true;
+				return;
+			}
+			// Do not descend redundantly into closure body
+			return;
+		}
+
+		forEachChild(node, walk);
+	};
+
+	walk(body);
+	return escapes;
+}

package/src/lower/functions.js

@@ -0,0 +1,302 @@
+// 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;
+	return {
+		entries: named, // [{ name, type }]
+		names: named.map((r) => r.name).filter(Boolean),
+	};
+}
+
+export function hasDefer(body) {
+	if (!body) return false;
+	if (body._hasDefer != null) return Boolean(body._hasDefer);
+
+	const walk = (node) => {
+		if (!node || typeof node !== "object") return false;
+		if (Array.isArray(node)) return node.some(walk);
+		if (node.kind === "DeferStmt") return true;
+		if (node.kind === "FuncLit") return false; // separate function boundary
+		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;
+}