gofront 1.7.0 → 1.9.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";
 
 /**
@@ -12,6 +13,9 @@ export class CaptureAnalysis {
 	constructor() {
 		// Map<FuncLit, Set<string>>: free variables captured by each closure
 		this.capturesByClosure = new Map();
+		// Map<FuncLit, Map<string, Type>>: the type of each captured variable,
+		// read off the closure's first reference to it.
+		this.captureTypes = new Map();
 		// Set<string>: variables in the enclosing scope that are captured AND mutated
 		this.mutatedCaptures = new Set();
 	}
@@ -40,58 +44,151 @@ 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;
 }
 
 /**
- * Finds all identifier references in a node that are not shadowed by inner declarations.
+ * Finds the identifiers a function literal body reads from outside itself.  A
+ * name is local only from its declaration onwards and only inside its block,
+ * so `m := f(m)` reads the enclosing `m`, and `{ m := 1 }; use(m)` reads it
+ * too.  `scopes` is the stack of name sets visible inside the literal;
+ * `types` receives the type of the first reference to each free name.
  */
-function collectReferencedNames(node, localDecls, refs = new Set()) {
+function collectReferencedNames(node, scopes, refs = new Set(), types) {
 	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);
+		for (const item of node) collectReferencedNames(item, scopes, refs, types);
 		return refs;
 	}
+	const walk = (child) => collectReferencedNames(child, scopes, refs, types);
+	const scoped = (fn) => {
+		scopes.push(new Set());
+		fn();
+		scopes.pop();
+	};
+	const declare = (name) => {
+		if (name && name !== "_") scopes[scopes.length - 1].add(name);
+	};
 
-	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);
+	switch (node.kind) {
+		// In struct literals, field names in KeyValueExpr are not variable references
+		case "KeyValueExpr":
+			walk(node.value);
+			return refs;
+		// Map keys are expressions that may read captured variables; struct
+		// field names are not references.
+		case "CompositeLit": {
+			const t = node._type?.underlying ?? node._type;
+			if (t && t.kind !== "struct") {
+				for (const el of node.elems ?? []) {
+					if (el?.kind === "KeyValueExpr") walk(el.key);
+				}
+			}
+			break;
 		}
-		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);
+		case "FuncLit":
+			scoped(() => {
+				for (const p of node.params ?? []) declare(p.name);
+				for (const r of node.returnType?._namedReturns ?? []) declare(r.name);
+				forEachChild(node, walk);
+			});
+			return refs;
+		case "DefineStmt":
+			walk(node.rhs);
+			for (const l of node.lhs ?? []) {
+				if (l.kind === "Ident") declare(l.name);
+				else walk(l);
+			}
+			return refs;
+		case "VarDecl":
+		case "ConstDecl":
+			for (const spec of node.decls ?? []) {
+				walk(spec.value ?? spec.init);
+				for (const name of spec.names ?? []) declare(name);
+			}
+			return refs;
+		case "TypeSwitchStmt":
+			scoped(() => {
+				walk(node.expr);
+				for (const c of node.cases ?? []) {
+					scoped(() => {
+						declare(node.assign);
+						walk(c.stmts);
+					});
+				}
+			});
+			return refs;
+		case "Block":
+		case "CaseClause":
+		case "IfStmt":
+		case "ForStmt":
+		case "SwitchStmt":
+			scoped(() => forEachChild(node, walk));
+			return refs;
+		case "Ident":
+			if (node.name !== "_" && !scopes.some((sc) => sc.has(node.name))) {
+				refs.add(node.name);
+				if (node._type && types && !types.has(node.name))
+					types.set(node.name, node._type);
+			}
+			return refs;
 	}
 
 	// For nested closures, free variables are also referenced
-	forEachChild(node, (child) =>
-		collectReferencedNames(child, localDecls, refs),
-	);
+	forEachChild(node, walk);
 	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 +198,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 +234,97 @@ 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);
+		}
+		const paramScope = new Set(closureLocals);
+		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 refTypes = new Map();
+		const allRefs = collectReferencedNames(
+			node.body,
+			[paramScope],
+			new Set(),
+			refTypes,
+		);
+		const captured = new Set();
+		const capturedTypes = new Map();
+		for (const ref of allRefs) {
+			if (allOuterScope.has(ref)) {
+				captured.add(ref);
+				if (refTypes.has(ref)) capturedTypes.set(ref, refTypes.get(ref));
 			}
-			result.capturesByClosure.set(node, captured);
+		}
+		result.capturesByClosure.set(node, captured);
+		result.captureTypes.set(node, capturedTypes);
 
-			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]);
+	};
+
+	// 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;
+		}
 
-			walkClosures(node.body, [...scopeStack, closureLocals]);
+		if (isIteratorRangeFor(node)) {
+			handleIteratorRange(node, scopeStack);
+			return;
+		}
+
+		if (node.kind === "FuncLit") {
+			handleFuncLit(node, scopeStack);
 			return;
 		}
 
@@ -166,3 +334,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/embedding.js

@@ -1,6 +1,15 @@
 // src/lower/embedding.js
 // Computes promoted methods and delegation stubs for embedded structs.
 
+import { embeddedFieldName } from "../typechecker/types.js";
+
+// A method promoted from an embedded struct value but declared on its
+// pointer receiver is outside the method set of the outer struct's value.
+function isPtrOnlyPromotion(rawEmbed, embed, mName, mType) {
+	if (rawEmbed.kind === "pointer") return false;
+	return Boolean((mType ?? embed.methods?.get(mName))?._ptrRecv);
+}
+
 export function computeEmbeddedStubs(name, methodDecls, checker) {
 	if (!checker) return [];
 	const resolvedType = checker.types.get(name)?.underlying;
@@ -9,18 +18,38 @@ export function computeEmbeddedStubs(name, methodDecls, checker) {
 	const declared = new Set(methodDecls.map((m) => m.name));
 	const stubs = [];
 
-	for (const rawEmbed of resolvedType._embeds) {
+	const embedded = (resolvedType._structFields ?? []).filter((f) => f.embedded);
+	for (const [i, rawEmbed] of resolvedType._embeds.entries()) {
+		const fieldName = embedded[i] ? embeddedFieldName(embedded[i]) : null;
 		const embed = rawEmbed.kind === "pointer" ? rawEmbed.base : rawEmbed;
 		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;
+		if (embedBase?.kind !== "struct" || !embedBase.methods) {
+			// A named non-struct type (`time.Duration`) promotes its value
+			// methods; the stub passes the embedded value as the receiver.
+			if (rawEmbed.kind === "pointer" || embedBase?.kind === "interface")
+				continue;
+			for (const [mName, mType] of embed.methods?.entries() ?? []) {
+				if (declared.has(mName) || mType?._ptrRecv) continue;
+				stubs.push({
+					methodName: mName,
+					embedName,
+					fieldName,
+					valueEmbed: true,
+				});
+				declared.add(mName);
+			}
+			continue;
+		}
 
-		for (const [mName] of embedBase.methods.entries()) {
+		for (const [mName, mType] of embedBase.methods.entries()) {
 			if (!declared.has(mName)) {
 				stubs.push({
 					methodName: mName,
 					embedName,
+					fieldName,
+					ptrOnly: isPtrOnlyPromotion(rawEmbed, embed, mName, mType),
 				});
 				declared.add(mName); // Prevent duplicate stubs for diamond embeds
 			}

package/src/lower/errors-as.js

@@ -0,0 +1,196 @@
+// src/lower/errors-as.js
+// errors.As as generated Go source.
+//
+// `errors.As(err, &x)` stores through a pointer whose type only the checker
+// knows.  Each call site gets a function generated for its static target
+// type; it walks the error tree like the real package and honours custom
+// `As(any) bool` methods.  The functions are ordinary Go, parsed and checked
+// as part of the package's generated file (src/link/stdlib.js), so both
+// backends compile the same code.
+
+import {
+	importsFor,
+	mentionsTypeParam,
+	TypeSpeller,
+	walkNodes,
+} from "./gen-types.js";
+
+const ERRORS_PATH = "errors";
+const NOT_POINTER =
+	"errors.As: second argument must be a non-nil pointer to a type that implements error or to any interface type";
+
+// The names the file imports `errors` as.
+function errorsAliases(program) {
+	const aliases = new Set();
+	for (const imp of program.imports ?? [])
+		for (const spec of imp.imports)
+			if (spec.path === ERRORS_PATH && spec.alias !== "_")
+				aliases.add(spec.alias ?? "errors");
+	return aliases;
+}
+
+const isAsRef = (node, aliases) =>
+	node.kind === "SelectorExpr" &&
+	node.expr?.kind === "Ident" &&
+	node.expr._type?.kind === "namespace" &&
+	aliases.has(node.expr.name) &&
+	node.field === "As";
+
+const isAsCall = (node, aliases) =>
+	node.kind === "CallExpr" && isAsRef(node.func, aliases);
+
+// Marks `call` to call the generated function `name`.  The function takes the
+// typed pointer: the target is not boxed into an interface the way
+// errors.As's `any` parameter asked.
+function markCall(call, name) {
+	call.func._genEntry = name;
+	const arg = call.args[1];
+	arg._ifaceBox = undefined;
+	arg._ifaceSrc = undefined;
+	arg._ifaceNamedType = undefined;
+	arg._ifacePtrFields = undefined;
+}
+
+// One function per distinct target type; `tparams` ("[T any]") makes it the
+// shared function for targets that are a type parameter.
+function asFunction(name, target, tparams = "") {
+	return `func ${name}${tparams}(err error, target *${target}) bool {
+	if target == nil {
+		panic("errors: target must be a non-nil pointer")
+	}
+	for err != nil {
+		if v, ok := err.(${target}); ok {
+			*target = v
+			return true
+		}
+		if a, ok := err.(interface{ As(any) bool }); ok && a.As(target) {
+			return true
+		}
+		switch u := err.(type) {
+		case interface{ Unwrap() error }:
+			err = u.Unwrap()
+		case interface{ Unwrap() []error }:
+			for _, e := range u.Unwrap() {
+				if e != nil && ${name}${tparams ? "[T]" : ""}(e, target) {
+					return true
+				}
+			}
+			return false
+		default:
+			return false
+		}
+	}
+	return false
+}`;
+}
+
+// The `errors.As` calls of the programs, and a diagnostic for each use of
+// errors.As that is not a call.
+function findSites(programs) {
+	const sites = [];
+	const diagnostics = [];
+	for (const program of programs) {
+		const aliases = errorsAliases(program);
+		if (aliases.size === 0) continue;
+		const callees = new Set();
+		const refs = [];
+		walkNodes(program.decls, (node) => {
+			if (isAsCall(node, aliases)) {
+				sites.push({ call: node, program });
+				callees.add(node.func);
+			} else if (isAsRef(node, aliases)) {
+				refs.push(node);
+			}
+		});
+		for (const node of refs)
+			if (!callees.has(node))
+				diagnostics.push({
+					program,
+					node: node.expr,
+					message: "errors.As cannot be used as a value",
+					hint: "call errors.As directly",
+				});
+	}
+	return { sites, diagnostics };
+}
+
+// What a call's target type allows: { base } for a target to generate for, or
+// { message, hint } for one the generator rejects.
+function classifyTarget(call) {
+	const argType = call.args[1]?._type;
+	if (argType?.kind !== "pointer") return { message: NOT_POINTER };
+	const base = argType.base;
+	if (base?.kind === "interface" && !base.name && base.methods?.size > 0)
+		return {
+			message:
+				"errors.As with a target of an anonymous interface type is not yet available",
+			hint: "declare a named interface type for the target",
+		};
+	if (base?.kind !== "typeParam" && mentionsTypeParam(base))
+		return {
+			message:
+				"errors.As with a target that mentions a type parameter is not yet available",
+			hint: "use a target that is a type parameter itself, or a concrete type",
+		};
+	return { base };
+}
+
+// Generates the `errors.As` functions for a package's call sites.  Returns
+// null when it has none; otherwise { body, imports, diagnostics, link } and
+// marks each call's SelectorExpr with `_genEntry`.
+export function generateErrorsAs(programs, _checker, pkgName) {
+	const { sites, diagnostics } = findSites(programs);
+	if (sites.length + diagnostics.length === 0) return null;
+	const qualifiers = new Map();
+	const speller = new TypeSpeller(pkgName, qualifiers, programs);
+	const prefix = `gfe_${String(pkgName).replace(/[^A-Za-z0-9_]/g, "_")}_as_`;
+	const names = new Map(); // spelled target -> function name
+	const out = [];
+	const sharedSites = []; // targets that are a type parameter
+	for (const { call, program } of sites) {
+		const { base, message, hint } = classifyTarget(call);
+		let target;
+		try {
+			if (base?.kind === "typeParam") sharedSites.push(call);
+			else if (base) target = speller.spell(base);
+		} catch (e) {
+			diagnostics.push({
+				program,
+				node: call.func.expr,
+				message: `errors.As: ${e.message}`,
+			});
+			continue;
+		}
+		if (!base) {
+			diagnostics.push({ program, node: call.func.expr, message, hint });
+			continue;
+		}
+		if (target === undefined) continue;
+		if (!names.has(target)) {
+			names.set(target, `${prefix}${names.size}`);
+			out.push(asFunction(names.get(target), target));
+		}
+		markCall(call, names.get(target));
+	}
+	const sharedName = `${prefix}t`;
+	if (sharedSites.length > 0) out.push(asFunction(sharedName, "T", "[T any]"));
+	for (const call of sharedSites) markCall(call, sharedName);
+	// The shared function is generic: once it is checked, its call sites take
+	// the type arguments the checker would have inferred.
+	const link = (chk) => {
+		const generic = chk.globals.symbols.get(sharedName);
+		for (const call of sharedSites) {
+			const typeArgs = [call.args[1]._type.base];
+			for (const n of [call, call.func]) {
+				n._typeArgs = typeArgs;
+				n._genericFnType = generic;
+			}
+		}
+	};
+	return {
+		body: out.join("\n\n"),
+		imports: importsFor(qualifiers),
+		diagnostics,
+		link,
+	};
+}