gofront 1.7.0 → 1.8.0

package/src/lower/captures.js

@@ -3,6 +3,7 @@
 // are mutated and thus require heap-allocated environment cells for WASM closures.
 
 import { collectMutatedVars } from "./ownership.js";
+import { getOrCreateIteratorFuncLit, isIteratorRangeFor } from "./range.js";
 import { forEachChild } from "./walk.js";
 
 /**
@@ -40,7 +41,7 @@ export function collectDeclaredNames(node, names = new Set()) {
 	}
 
 	// Do not descend into nested functions when collecting local declarations
-	if (node.kind === "FuncLit") return names;
+	if (node.kind === "FuncLit" || isIteratorRangeFor(node)) return names;
 
 	forEachChild(node, (child) => collectDeclaredNames(child, names));
 	return names;
@@ -92,6 +93,53 @@ function collectReferencedNames(node, localDecls, refs = new Set()) {
 	return refs;
 }
 
+function hasReturnInNode(n) {
+	let found = false;
+	const check = (x) => {
+		if (!x || typeof x !== "object" || found) return;
+		if (Array.isArray(x)) {
+			for (const elem of x) check(elem);
+			return;
+		}
+		if (x.kind === "ReturnStmt") {
+			found = true;
+			return;
+		}
+		if (x.kind === "FuncLit" && !x._isYieldClosure) return;
+		for (const k of Object.keys(x)) {
+			if (k.startsWith("_")) continue;
+			check(x[k]);
+		}
+	};
+	check(n);
+	return found;
+}
+
+function hasIteratorWithReturn(body) {
+	let found = false;
+	const check = (x) => {
+		if (!x || typeof x !== "object" || found) return;
+		if (Array.isArray(x)) {
+			for (const elem of x) check(elem);
+			return;
+		}
+		if (x.kind === "FuncLit") return;
+		if (isIteratorRangeFor(x)) {
+			const lit = getOrCreateIteratorFuncLit(x);
+			if (hasReturnInNode(lit?.body)) {
+				found = true;
+				return;
+			}
+		}
+		for (const k of Object.keys(x)) {
+			if (k.startsWith("_")) continue;
+			check(x[k]);
+		}
+	};
+	check(body);
+	return found;
+}
+
 /**
  * Analyzes a function or method declaration for closures and their captured variables.
  * @param {Object} fnDecl AST FuncDecl or FuncLit node
@@ -101,6 +149,26 @@ export function analyzeCaptures(fnDecl) {
 	const result = new CaptureAnalysis();
 	if (!fnDecl?.body) return result;
 
+	// Synthesize named returns if not already present, so iterator returns can share boxed slots
+	if (
+		fnDecl.returnType &&
+		!fnDecl.returnType._namedReturns &&
+		hasIteratorWithReturn(fnDecl.body)
+	) {
+		const ret = fnDecl.returnType;
+		if (ret.name !== "void") {
+			const types =
+				ret.kind === "TupleType" || ret.kind === "tuple" ? ret.types : [ret];
+			if (types && types.length > 0) {
+				fnDecl.returnType._namedReturns = types.map((t, i) => ({
+					name: `__retVal$${i}`,
+					type: { ...t, _namedReturns: undefined },
+					_synthesized: true,
+				}));
+			}
+		}
+	}
+
 	// Collect parameters, receiver and named returns of the root function
 	const rootScope = new Set();
 	if (fnDecl.recvName && fnDecl.recvName !== "_") {
@@ -117,46 +185,87 @@ export function analyzeCaptures(fnDecl) {
 	// 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;
+	const handleIteratorRange = (node, scopeStack) => {
+		const funcLit = getOrCreateIteratorFuncLit(node);
+		if (node._iterStateName) {
+			rootScope.add(node._iterStateName);
+			result.mutatedCaptures.add(node._iterStateName);
 		}
-
-		if (node.kind === "FuncLit") {
-			const closureLocals = new Set();
-			for (const p of node.params ?? []) {
-				if (p.name && p.name !== "_") closureLocals.add(p.name);
+		const rootNamed = fnDecl.returnType?._namedReturns ?? [];
+		const hasRet = hasReturnInNode(funcLit.body);
+		if (hasRet && rootNamed.length > 0) {
+			for (const r of rootNamed) {
+				if (r.name && r.name !== "_") {
+					rootScope.add(r.name);
+					result.mutatedCaptures.add(r.name);
+				}
 			}
-			for (const r of node.returnType?._namedReturns ?? []) {
-				if (r.name && r.name !== "_") closureLocals.add(r.name);
+		}
+		walkClosures(funcLit, scopeStack);
+		// A func literal ranged over directly is a closure of its own.
+		walkClosures(node.cond?.expr ?? node.init?.rhs?.[0]?.expr, scopeStack);
+		const captured = result.capturesByClosure.get(funcLit) ?? new Set();
+		if (node._iterStateName) {
+			captured.add(node._iterStateName);
+		}
+		if (hasRet && rootNamed.length > 0) {
+			for (const r of rootNamed) {
+				if (r.name && r.name !== "_") {
+					captured.add(r.name);
+				}
 			}
-			collectDeclaredNames(node.body, closureLocals);
+		}
+		result.capturesByClosure.set(funcLit, captured);
+	};
 
-			// 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 handleFuncLit = (node, scopeStack) => {
+		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);
 
-			const allRefs = collectReferencedNames(node.body, closureLocals);
-			const captured = new Set();
-			for (const ref of allRefs) {
-				if (allOuterScope.has(ref)) {
-					captured.add(ref);
-				}
+		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);
+		}
+		result.capturesByClosure.set(node, captured);
 
-			for (const varName of captured) {
-				if (mutatedVars.has(varName)) {
-					result.mutatedCaptures.add(varName);
-				}
+		for (const varName of captured) {
+			if (mutatedVars.has(varName)) {
+				result.mutatedCaptures.add(varName);
 			}
+		}
 
-			walkClosures(node.body, [...scopeStack, closureLocals]);
+		walkClosures(node.body, [...scopeStack, closureLocals]);
+	};
+
+	// 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 (isIteratorRangeFor(node)) {
+			handleIteratorRange(node, scopeStack);
+			return;
+		}
+
+		if (node.kind === "FuncLit") {
+			handleFuncLit(node, scopeStack);
 			return;
 		}
 
@@ -166,3 +275,38 @@ export function analyzeCaptures(fnDecl) {
 	walkClosures(fnDecl.body, [rootScope]);
 	return result;
 }
+
+/**
+ * Go 1.22 per-iteration loop variables: the names declared by a three-clause
+ * `for` init (`for i := …`) that a closure inside the loop (body, cond or
+ * post) refers to, or whose address is taken there (`&i`, `&p.X`): a pointer
+ * from one iteration must keep pointing at that iteration's variable.
+ * Conservative by name.  Only these need a fresh copy per iteration; the
+ * others stay plain locals.
+ */
+export function loopVarsCapturedInLoop(stmt) {
+	const out = new Set();
+	if (stmt?.init?.kind !== "DefineStmt") return out;
+	const names = new Set(
+		(stmt.init.lhs ?? [])
+			.filter((l) => l.kind === "Ident" && l.name !== "_")
+			.map((l) => l.name),
+	);
+	if (names.size === 0) return out;
+	const walk = (node, inClosure) => {
+		if (!node || typeof node !== "object") return;
+		if (Array.isArray(node)) {
+			for (const n of node) walk(n, inClosure);
+			return;
+		}
+		if (inClosure && node.kind === "Ident" && names.has(node.name))
+			out.add(node.name);
+		const nowIn = inClosure || node.kind === "FuncLit";
+		forEachChild(node, (child) => walk(child, nowIn));
+	};
+	const loop = [stmt.cond, stmt.post, stmt.body];
+	walk(loop, false);
+	for (const name of collectMutatedVars(loop, new Set(), true))
+		if (names.has(name)) out.add(name);
+	return out;
+}

package/src/lower/index.js

@@ -1,6 +1,7 @@
 // src/lower/index.js
 // Lowering step: analyzes AST and types to populate side-tables for backends (JS and WASM).
 
+export * from "./bounds.js";
 export * from "./boxing.js";
 export * from "./captures.js";
 export * from "./embedding.js";
@@ -42,6 +43,30 @@ class LowerResult {
 	}
 }
 
+/**
+ * Runs the per-function analyses for `d` and records them in `res`.  Also
+ * used for synthesized functions (the package-level initializer).
+ */
+export function lowerFunction(res, d) {
+	if (!d.body) return;
+	const boxed = scanAddressTaken(d.body, new Set());
+	res.boxedVars.set(d, boxed);
+	res.ownership.set(d, new OwnershipContext(d.body));
+	res.functions.set(d, {
+		hasDefer: hasDefer(d.body),
+		namedReturns: extractNamedReturns(d),
+	});
+	res.captures.set(d, analyzeCaptures(d));
+
+	const escapingParams = new Set();
+	for (const p of d.params ?? []) {
+		if (p.name && p.name !== "_" && paramEscapes(d.body, p.name)) {
+			escapingParams.add(p.name);
+		}
+	}
+	res.escapes.set(d, escapingParams);
+}
+
 /**
  * Runs lowering analyses across an AST or collection of programs, returning side-tables.
  * @param {Object} programOrPrograms
@@ -74,24 +99,7 @@ export function lower(programOrPrograms, checker = null) {
 
 		for (const d of program.decls) {
 			if (d.kind === "FuncDecl" || d.kind === "MethodDecl") {
-				if (d.body) {
-					const boxed = scanAddressTaken(d.body, new Set());
-					res.boxedVars.set(d, boxed);
-					res.ownership.set(d, new OwnershipContext(d.body));
-					res.functions.set(d, {
-						hasDefer: hasDefer(d.body),
-						namedReturns: extractNamedReturns(d),
-					});
-					res.captures.set(d, analyzeCaptures(d));
-
-					const escapingParams = new Set();
-					for (const p of d.params ?? []) {
-						if (p.name && p.name !== "_" && paramEscapes(d.body, p.name)) {
-							escapingParams.add(p.name);
-						}
-					}
-					res.escapes.set(d, escapingParams);
-				}
+				lowerFunction(res, d);
 			}
 		}