gofront 1.5.1 → 1.6.1

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,38 +83,56 @@ 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;
 }
 
 export function fnMutates(body, name, addrOnly = false, cache = null) {
 	if (!body) return true;
-	const key = `${addrOnly ? "&" : ""}${name}`;
 	if (cache) {
-		if (!cache.has(key)) {
-			cache.set(key, nodeMutatesVar(body, name, addrOnly));
+		const setKey = addrOnly ? "&*" : "*";
+		let set = cache.get(setKey);
+		if (!set) {
+			set = collectMutatedVars(body, new Set(), addrOnly);
+			cache.set(setKey, set);
 		}
-		return cache.get(key);
+		return set.has(name);
 	}
 	return nodeMutatesVar(body, name, addrOnly);
 }
 
+function collectClosureMutatedVars(node, mutated = new Set()) {
+	if (!node || typeof node !== "object") return mutated;
+	if (Array.isArray(node)) {
+		for (const item of node) collectClosureMutatedVars(item, mutated);
+		return mutated;
+	}
+	if (node.kind === "FuncLit") {
+		collectMutatedVars(node.body, mutated, false);
+		return mutated;
+	}
+	forEachChild(node, (child) => collectClosureMutatedVars(child, mutated));
+	return mutated;
+}
+
 export function closureMutates(body, name, cache = null) {
-	const key = `λ${name}`;
-	if (cache?.has(key)) return cache.get(key);
+	if (!body) return false;
+	if (cache) {
+		let set = cache.get("λ*");
+		if (!set) {
+			set = collectClosureMutatedVars(body, new Set());
+			cache.set("λ*", set);
+		}
+		return set.has(name);
+	}
 
 	const walk = (node) => {
 		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);
-	return res;
+	return walk(body);
 }
 
 export class OwnershipContext {

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/minifier.js

@@ -121,7 +121,7 @@ const REGEX_CONTEXT_VALUES = new Set([
 const DIVISION_AFTER_OPS = new Set([")", "]", "++", "--"]);
 
 function _isRegexContext(tokens) {
-	const prev = lastNonWhitespaceToken(tokens);
+	const prev = findPrevNonWs(tokens);
 	if (!prev) return true;
 	if (prev.type === "op") return !DIVISION_AFTER_OPS.has(prev.value);
 	return REGEX_CONTEXT_VALUES.has(prev.value);
@@ -323,14 +323,6 @@ function tokenize(code) {
 	return tokens;
 }
 
-function lastNonWhitespaceToken(tokens) {
-	for (let i = tokens.length - 1; i >= 0; i--) {
-		if (tokens[i].type !== "ws" && tokens[i].type !== "comment")
-			return tokens[i];
-	}
-	return null;
-}
-
 // ── Stage 1 & 2: Compress ────────────────────────────────────
 
 function isIdentLike(type) {
@@ -348,15 +340,6 @@ const SPACE_AFTER_KW_RIGHT_TYPES = new Set([
 ]);
 // Operator values that do NOT need a space after a keyword
 const NO_SPACE_AFTER_KW_OPS = new Set(["(", "[", "!", "-", "+"]);
-// Adjacent op pairs that would accidentally merge into a different operator
-const _INCREMENT_MERGE_PAIRS = new Set([
-	"+|+",
-	"-|-",
-	"+|++",
-	"-|--",
-	"++|+",
-	"--|−-",
-]);
 
 function _wouldMergeUnaryOps(left, right) {
 	return (
@@ -436,11 +419,7 @@ function compressTokens(tokens) {
 	return out;
 }
 
-function compress(code) {
-	return compressTokens(tokenize(code));
-}
-
-function findPrevNonWs(tokens, index) {
+function findPrevNonWs(tokens, index = tokens.length) {
 	for (let i = index - 1; i >= 0; i--) {
 		if (tokens[i].type !== "ws" && tokens[i].type !== "comment")
 			return tokens[i];
@@ -477,7 +456,7 @@ function _matchingParen(tokens, openIdx) {
 // A `(` opens a parameter list only when its `)` is followed by a body `{` or `=>`;
 // otherwise `name(...)` is a call and its arguments may be free globals.
 function _collectParamDecls(tokens, i, declaredLocals) {
-	const prev = findPrevNonWsToken(tokens, i);
+	const prev = findPrevNonWs(tokens, i);
 	if (
 		!prev ||
 		(prev.value !== "function" && prev.type !== "ident" && prev.value !== ")")
@@ -583,22 +562,7 @@ function _filterRenameCandidates(declaredLocals) {
 	}
 }
 
-function _applyRenaming(tokens, renameMap) {
-	let out = "";
-	for (let i = 0; i < tokens.length; i++) {
-		const tok = tokens[i];
-		if (tok.type === "ident" && renameMap.has(tok.value)) {
-			const prev = findPrevNonWsToken(tokens, i);
-			out += prev && prev.value === "." ? tok.value : renameMap.get(tok.value);
-		} else {
-			out += tok.value;
-		}
-	}
-	return out;
-}
-
-function mangle(code) {
-	const tokens = tokenize(code);
+function mangleTokens(tokens) {
 	const { declaredLocals } = _collectLocalDecls(tokens);
 	_filterRenameCandidates(declaredLocals);
 
@@ -612,7 +576,15 @@ function mangle(code) {
 	const nameGen = shortNameGeneratorFn(occupied);
 	const renameMap = new Map();
 	for (const name of declaredLocals) renameMap.set(name, nameGen());
-	return _applyRenaming(tokens, renameMap);
+	return tokens.map((tok, i) => {
+		if (tok.type === "ident" && renameMap.has(tok.value)) {
+			const prev = findPrevNonWs(tokens, i);
+			if (prev?.value !== ".") {
+				return { type: "ident", value: renameMap.get(tok.value) };
+			}
+		}
+		return tok;
+	});
 }
 
 function nextNonWs(tokens, index) {
@@ -624,14 +596,6 @@ function nextNonWs(tokens, index) {
 	return null;
 }
 
-function findPrevNonWsToken(tokens, index) {
-	for (let i = index - 1; i >= 0; i--) {
-		if (tokens[i].type !== "ws" && tokens[i].type !== "comment")
-			return tokens[i];
-	}
-	return null;
-}
-
 function collectDestructured(tokens, startIdx, locals) {
 	const open = tokens[startIdx].value;
 	const close = open === "[" ? "]" : "}";
@@ -647,7 +611,7 @@ function collectDestructured(tokens, startIdx, locals) {
 }
 
 function _isParamStart(tokens, i) {
-	const prev = findPrevNonWsToken(tokens, i);
+	const prev = findPrevNonWs(tokens, i);
 	return (
 		!prev ||
 		prev.value === "(" ||
@@ -839,28 +803,16 @@ function foldTokens(tokens) {
 	return current;
 }
 
-function foldLiterals(code) {
-	const tokens = tokenize(code);
-	return compressTokens(foldTokens(tokens));
-}
-
 // ── Public API ───────────────────────────────────────────────
 
 export function minify(code, options = {}) {
 	const { mangle: doMangle = false } = options;
-
-	// Stage 1 + 2: compress (strips comments, whitespace, compresses tokens)
-	let result = compress(code);
-
-	// Stage 4: literal folding
-	result = foldLiterals(result);
-
-	// Stage 3: mangling (optional)
+	let tokens = tokenize(code).filter(
+		(t) => t.type !== "ws" && t.type !== "comment",
+	);
+	tokens = foldTokens(tokens);
 	if (doMangle) {
-		result = mangle(result);
-		// Re-compress after mangling to clean up any leftover whitespace
-		result = compress(result);
+		tokens = mangleTokens(tokens);
 	}
-
-	return result;
+	return compressTokens(tokens);
 }