gofront 1.8.0 → 1.9.1

package/src/lower/functions.js

@@ -1,7 +1,7 @@
 // src/lower/functions.js
 // Analyzes function signatures, named returns and defer structures.
 
-import { forEachChild, someChild } from "./walk.js";
+import { forEachChild, hasCallOrReceive, someChild } from "./walk.js";
 
 export function extractNamedReturns(decl) {
 	const named = decl?.returnType?._namedReturns;
@@ -146,6 +146,80 @@ function deferCalleeMayRecover(funcExpr, ctx) {
 	return true;
 }
 
+// A constant argument (`2.5`, `"a"`, `nil`, `k` for a constant `k`, `-1`)
+// has no value to capture at the `defer` statement, so it stays in the
+// deferred call, where it takes the callee's parameter type exactly as in a
+// direct call.  Hoisting it into a temporary would default its type (`float64`,
+// `int`) and reject a defined-type, interface, pointer or generic parameter.
+function isDeferConstant(arg) {
+	if (arg?.kind === "BasicLit" && arg.litKind === "NIL") return true;
+	if (arg?._type?.kind !== "untyped") return false;
+	if (arg._const) return true;
+	switch (arg.kind) {
+		case "BasicLit":
+		case "ImagLit":
+			return true;
+		case "ParenExpr":
+			return isDeferConstant(arg.expr);
+		case "UnaryExpr":
+			return isDeferConstant(arg.operand);
+		case "BinaryExpr":
+			return isDeferConstant(arg.left) && isDeferConstant(arg.right);
+		default:
+			return false;
+	}
+}
+
+// A package-level basic or defined type a temporary can be declared with by
+// its name; other parameter types (qualified, generic, composite) are not
+// hoisted with a declared type.
+function isNamedScalarParam(t) {
+	if (t?.kind === "basic")
+		return t.name !== "any" && /^[A-Za-z_]\w*$/.test(t.name ?? "");
+	return (
+		t?.kind === "named" &&
+		t.underlying?.kind === "basic" &&
+		!t.typeArgs?.length &&
+		/^[A-Za-z_]\w*$/.test(t.name ?? "")
+	);
+}
+
+// A non-constant untyped expression (`1 << n`) the typechecker already gave
+// its parameter's type: it is still untyped when the lowered code is checked
+// again, so its temporary needs that type declared.
+function isRetypedUntyped(e) {
+	if (!e || e._const) return false;
+	switch (e.kind) {
+		case "ParenExpr":
+			return isRetypedUntyped(e.expr);
+		case "UnaryExpr":
+			return isRetypedUntyped(e.operand);
+		case "BinaryExpr":
+			if (e.op === "<<" || e.op === ">>") return Boolean(e.left?._const);
+			return isRetypedUntyped(e.left) || isRetypedUntyped(e.right);
+		default:
+			return false;
+	}
+}
+
+// The type of the temporary that holds deferred argument `a`: an untyped
+// non-constant value (a shift, a comparison) takes its basic or defined
+// scalar parameter's type, as it does in a direct call.  A variadic call's
+// trailing arguments take the element type.
+function deferTempType(funcType, a, arg) {
+	const argType = arg._type;
+	if (argType?.kind !== "untyped" && !isRetypedUntyped(arg)) return argType;
+	const params = funcType?.params;
+	let param = params?.[a];
+	if (funcType?.variadic && a >= params.length - 1) {
+		// The last parameter's type is the element type (a slice only when
+		// a table spells it that way).
+		param = params[params.length - 1];
+		if (!isNamedScalarParam(param)) param = param?.elem;
+	}
+	return isNamedScalarParam(param) ? param : argType;
+}
+
 function normalizeDeferStmt(stmt, parentList = null, index = -1, ctx = null) {
 	if (stmt.call?.kind !== "CallExpr") return 0;
 	const call = stmt.call;
@@ -245,19 +319,40 @@ function normalizeDeferStmt(stmt, parentList = null, index = -1, ctx = null) {
 					lhs: tupleLhs,
 					rhs: [arg],
 				});
+			} else if (isDeferConstant(arg)) {
+				tempIdents.push(arg);
 			} else {
 				defargCounter++;
 				const tempName = `__defarg$${defargCounter}`;
+				const tempType = deferTempType(call.func?._type, a, arg);
 				tempIdents.push({
 					kind: "Ident",
 					name: tempName,
-					_type: arg._type,
-				});
-				tempStmts.push({
-					kind: "DefineStmt",
-					lhs: [{ kind: "Ident", name: tempName, _type: arg._type }],
-					rhs: [arg],
+					_type: tempType,
+					// A spread argument stays one: the call gets the slice itself.
+					...(arg._spread && { _spread: true }),
 				});
+				tempStmts.push(
+					tempType === arg._type &&
+						!(isRetypedUntyped(arg) && isNamedScalarParam(tempType))
+						? {
+								kind: "DefineStmt",
+								lhs: [{ kind: "Ident", name: tempName, _type: tempType }],
+								rhs: [arg],
+							}
+						: {
+								// Declared with the parameter's type so the lowered code
+								// type-checks again with the constant converted.
+								kind: "VarDecl",
+								decls: [
+									{
+										names: [tempName],
+										type: { kind: "TypeName", name: tempType.name },
+										value: [arg],
+									},
+								],
+							},
+				);
 			}
 		}
 	}
@@ -271,6 +366,8 @@ function normalizeDeferStmt(stmt, parentList = null, index = -1, ctx = null) {
 		...call,
 		func: funcExpr,
 		args: callArgs,
+		// A deferred native call runs the Go body, as on the JS backend.
+		_noNative: true,
 		_multiForward: tempIdents.length > 0 ? false : call._multiForward,
 	};
 	const synthFuncLit = {
@@ -300,3 +397,124 @@ function normalizeDeferStmt(stmt, parentList = null, index = -1, ctx = null) {
 
 	return tempStmts.length;
 }
+
+let fwdCounter = 0;
+
+/**
+ * Splits a multi-value call forwarded into interfaces into temps:
+ * `return f()` where some result is an interface becomes
+ * `__fwd$1, __fwd$2 := f(); return __fwd$1, __fwd$2`, and `g(f())` where
+ * some parameter is an interface becomes `…; g(__fwd$1, __fwd$2)`.  The
+ * typechecker records per-element interface-box marks in `call._fwdIface`;
+ * each temp takes its element's marks, so both backends box it through their
+ * ordinary per-value path.  Forwards with no interface element are left alone.
+ *
+ * `g(f())` is split only as the operand of a statement (expression
+ * statement, single-value `:=`/`=`/`var`/`return`) whose callee evaluates
+ * no call, so hoisting `f()` keeps Go's evaluation order.
+ */
+export function splitForwardedTuples(programOrPrograms) {
+	fwdCounter = 0;
+	const programs = Array.isArray(programOrPrograms)
+		? programOrPrograms
+		: [programOrPrograms];
+	for (const program of programs)
+		for (const d of program?.decls ?? []) splitForwardsIn(d);
+}
+
+function splitForwardsIn(node) {
+	if (!node || typeof node !== "object") return;
+	if (Array.isArray(node)) {
+		for (let i = 0; i < node.length; i++) {
+			const item = node[i];
+			splitForwardsIn(item);
+			const defines = splitForwardsInStmt(item);
+			node.splice(i, 0, ...defines);
+			i += defines.length;
+		}
+		return;
+	}
+	forEachChild(node, splitForwardsIn);
+}
+
+// The `:=` statements to insert before `stmt` (in order) after rewriting its
+// forwarded calls to read the temps.
+function splitForwardsInStmt(stmt) {
+	const defines = [];
+	const operand = statementOperand(stmt);
+	if (
+		operand?.kind === "CallExpr" &&
+		operand._multiForward &&
+		operand.args?.length === 1 &&
+		!hasCallOrReceive(operand.func)
+	) {
+		const split = forwardTemps(operand.args[0]);
+		if (split) {
+			operand.args = split.operands;
+			operand._multiForward = false;
+			defines.push(split.define);
+		}
+	}
+	if (stmt?.kind === "ReturnStmt") {
+		const define = splitForwardedReturn(stmt);
+		if (define) defines.push(define);
+	}
+	return defines;
+}
+
+// The single expression a statement evaluates last, or null.
+function statementOperand(stmt) {
+	switch (stmt?.kind) {
+		case "ExprStmt":
+			return stmt.expr;
+		case "DefineStmt":
+		case "AssignStmt":
+			return stmt.rhs?.length === 1 &&
+				stmt.lhs?.every((e) => e.kind === "Ident")
+				? stmt.rhs[0]
+				: null;
+		case "ReturnStmt":
+			return stmt.values?.length === 1 ? stmt.values[0] : null;
+		case "VarDecl":
+			return stmt.decls?.length === 1 && stmt.decls[0].value?.length === 1
+				? stmt.decls[0].value[0]
+				: null;
+		default:
+			return null;
+	}
+}
+
+// Splits one forwarded call into temps: returns the `:=` statement defining
+// them and the operand idents (carrying each element's interface-box marks),
+// or null when the call needs no split.
+function forwardTemps(call) {
+	const holders = call?._fwdIface;
+	const types = call?._type?.types;
+	if (!holders || !Array.isArray(types) || types.length !== holders.length)
+		return null;
+	const names = types.map(() => `__fwd$${++fwdCounter}`);
+	const define = {
+		kind: "DefineStmt",
+		lhs: names.map((name, i) => ({ kind: "Ident", name, _type: types[i] })),
+		rhs: [call],
+	};
+	// The call is no longer a forward; a cached AST must not split it again.
+	call._fwdIface = undefined;
+	const operands = names.map((name, i) => ({
+		kind: "Ident",
+		name,
+		_type: types[i],
+		...holders[i],
+	}));
+	return { define, operands };
+}
+
+function splitForwardedReturn(stmt) {
+	if (stmt.values?.length !== 1) return null;
+	const split = forwardTemps(stmt.values[0]);
+	if (!split) return null;
+	stmt.values = split.operands;
+	if (Array.isArray(stmt._types))
+		stmt._types = split.operands.map((o) => o._type);
+	return split.define;
+}

package/src/lower/gen-types.js

@@ -0,0 +1,293 @@
+// src/lower/gen-types.js
+// Spells checked types as Go source for the generated per-package file
+// (src/lower/json-codecs.js, src/lower/errors-as.js,
+// src/lower/fmt-formatters.js), and holds what those generators share: the
+// imports the spelled code needs and the enumeration of the program's types.
+
+import { defaultType } from "../typechecker/types.js";
+import { forEachChild } from "./walk.js";
+
+export function under(t) {
+	return t?.kind === "named" ? under(t.underlying) : t;
+}
+
+export const isEmptyIface = (t) =>
+	(t?.kind === "basic" && t.name === "any") ||
+	(under(t)?.kind === "interface" && under(t).methods?.size === 0);
+
+// Arrays and maps of these share one WebAssembly representation (and so one
+// type-switch case), so only literals may register them: a `[2]byte` conversion
+// must not shadow a `[2]int32` that is stored in an interface.  A slice of
+// them is tagged with its Go type in an interface and registers like any other.
+export const SHARED_REPR = new Set([
+	"bool",
+	"int8",
+	"int16",
+	"int32",
+	"uint8",
+	"uint16",
+	"uint32",
+	"byte",
+	"rune",
+]);
+
+export function hasSharedRepr(t, depth = 0) {
+	if (!t || depth > 8) return false;
+	const u = under(t);
+	if (u?.kind === "basic") return SHARED_REPR.has(u.name);
+	if (u?.kind === "slice" || u?.kind === "array")
+		return hasSharedRepr(u.elem, depth + 1);
+	if (u?.kind === "map")
+		return hasSharedRepr(u.key, depth + 1) || hasSharedRepr(u.value, depth + 1);
+	return false;
+}
+
+// A method's results; a multi-value result is one tuple type.
+export function results(m) {
+	const r = (m.returns ?? []).filter(
+		(t) => !(t?.kind === "basic" && t.name === "void"),
+	);
+	return r.length === 1 && r[0]?.kind === "tuple" ? r[0].types : r;
+}
+
+// Calls every `fn(node)` for the AST nodes under `root`.
+export function walkNodes(root, fn) {
+	if (!root || typeof root !== "object") return;
+	if (Array.isArray(root)) {
+		for (const n of root) walkNodes(n, fn);
+		return;
+	}
+	fn(root);
+	forEachChild(root, (c) => walkNodes(c, fn));
+	// templ bodies keep their Go expressions in non-enumerable properties
+	// (see parser/templ.js), which forEachChild does not visit.
+	for (const name of TEMPL_EXPR_PROPS) {
+		const d = Object.getOwnPropertyDescriptor(root, name);
+		if (d && !d.enumerable) walkNodes(d.value, fn);
+	}
+}
+
+const TEMPL_EXPR_PROPS = ["expr", "exprs", "forStmt"];
+
+// True when `t` mentions a type parameter (a generic declaration, or a type
+// built from one inside a generic function).
+export function mentionsTypeParam(t, seen = new Set()) {
+	if (!t || seen.has(t)) return false;
+	seen.add(t);
+	const m = (x) => mentionsTypeParam(x, seen);
+	switch (t.kind) {
+		case "typeParam":
+			return true;
+		case "named":
+			return (t.typeArgs ?? []).some(m) || m(t.underlying);
+		case "pointer":
+			return m(t.base);
+		case "slice":
+		case "array":
+			return m(t.elem);
+		case "map":
+			return m(t.key) || m(t.value);
+		case "struct":
+			return (t._structFields ?? []).some((f) => m(f.type));
+		default:
+			return false;
+	}
+}
+
+// The last element of an import path: the package's name.
+const canonicalName = (modPath) => modPath.split("/").pop();
+
+// The names the programs declare at package level.
+function declaredNames(programs) {
+	const names = new Set();
+	for (const p of programs)
+		for (const d of p.decls ?? []) {
+			if (d.kind === "TypeDecl" || d.kind === "FuncDecl") names.add(d.name);
+			else if (d.kind === "VarDecl" || d.kind === "ConstDecl")
+				for (const spec of d.decls ?? [])
+					for (const n of spec.names ?? []) names.add(n);
+		}
+	return names;
+}
+
+// Every name an import answers to (its alias, its package name) -> its path.
+function importPaths(programs) {
+	const paths = new Map();
+	for (const p of programs)
+		for (const imp of p.imports ?? [])
+			for (const spec of imp.imports) {
+				if (spec.alias === "_" || spec.alias === ".") continue;
+				paths.set(canonicalName(spec.path), spec.path);
+				if (spec.alias) paths.set(spec.alias, spec.path);
+			}
+	return paths;
+}
+
+// The generated file's imports for the qualifiers (name -> path) its code
+// spells: a path, or { path, alias } for a qualifier renamed to stay clear of
+// a package-level name.
+export function importsFor(qualifiers) {
+	return [...qualifiers].map(([name, path]) =>
+		name === canonicalName(path) ? path : { path, alias: name },
+	);
+}
+
+// Every type a closed-world generator may need to describe: the entries
+// { type, node, via } for the type arguments of generic calls (`typeArg`),
+// the type of every expression (`expr`), the static type of every value
+// converted to an interface (`boxed`) and the package's declared named types
+// (`declared`, node null).
+export function collectProgramTypes(programs, checker) {
+	const found = [];
+	for (const p of programs)
+		walkNodes(p.decls, (node) => {
+			for (const a of node._typeArgs ?? [])
+				found.push({ type: defaultType(a), node, via: "typeArg" });
+			if (node._type)
+				found.push({ type: defaultType(node._type), node, via: "expr" });
+			if (node._ifaceSrc)
+				found.push({ type: defaultType(node._ifaceSrc), node, via: "boxed" });
+			// A multi-value call forwarded into interfaces (`return f()`,
+			// `g(f())`) keeps one mark holder per element until lowering
+			// splits it.
+			for (const h of node._fwdIface ?? [])
+				if (h?._ifaceSrc)
+					found.push({ type: defaultType(h._ifaceSrc), node, via: "boxed" });
+		});
+	for (const [name, t] of checker.types) {
+		if (t?.kind !== "named" || t.name !== name) continue;
+		if (name.includes(".") || name.includes("$$")) continue;
+		if (t._genericOf || t.typeArgs?.length) continue;
+		found.push({ type: t, node: null, via: "declared" });
+	}
+	return found;
+}
+
+export class TypeSpeller {
+	// `qualifiers` receives name -> import path for each package the spelled
+	// code names.
+	constructor(pkgName, qualifiers, programs = []) {
+		this.pkgName = pkgName;
+		this.qualifiers = qualifiers;
+		this.programs = programs;
+		this.importPaths = importPaths(programs);
+		this.declared = declaredNames(programs);
+	}
+
+	// Go source for the type.
+	spell(t) {
+		const sp = (x) => this.spell(x);
+		const byKind = {
+			basic: () => t.name,
+			named: () => this.spellNamed(t),
+			pointer: () => `*${sp(t.base)}`,
+			slice: () => `[]${sp(t.elem)}`,
+			array: () => `[${t.size}]${sp(t.elem)}`,
+			map: () => `map[${sp(t.key)}]${sp(t.value)}`,
+			struct: () => this.spellStruct(t),
+			interface: () => (t.name === "error" ? "error" : "any"),
+			func: () => this.funcString(t, sp),
+		};
+		if (!byKind[t.kind])
+			throw new Error(`json: cannot spell type kind ${t.kind}`);
+		return byKind[t.kind]();
+	}
+
+	// The package name `%T` and errors print for the bare-named type `t`: this
+	// package, or the local package an importer reaches it through as `p.Name`.
+	declaringPackage(t) {
+		if (this.declared.has(t.name) || !this.checker) return this.pkgName;
+		for (const [key, v] of this.checker.types) {
+			const dot = key.indexOf(".");
+			if (v !== t || dot <= 0 || key.slice(dot + 1) !== t.name) continue;
+			const modPath = this.importPaths.get(key.slice(0, dot));
+			if (modPath) return canonicalName(modPath);
+		}
+		return this.pkgName;
+	}
+
+	// The name the generated file uses for the package at `modPath`: its
+	// package name, or `_gf_<name>` when the package declares that name itself
+	// or another path took it.
+	qualifierFor(modPath) {
+		for (const [name, path] of this.qualifiers)
+			if (path === modPath) return name;
+		const base = canonicalName(modPath);
+		const taken = (n) => this.declared.has(n) || this.qualifiers.has(n);
+		let name = base;
+		for (let i = 1; taken(name); i++) name = `_gf_${base}${i > 1 ? i : ""}`;
+		this.qualifiers.set(name, modPath);
+		return name;
+	}
+
+	spellNamed(t) {
+		let name = t.name;
+		const at = name.indexOf("$$");
+		const dot = name.indexOf(".");
+		if (at >= 0) {
+			const orig = name.slice(0, at);
+			const modPath = name.slice(at + 2).replaceAll("$", "/");
+			name = `${this.qualifierFor(modPath)}.${orig}`;
+		} else if (dot > 0) {
+			const modPath = this.importPaths.get(name.slice(0, dot));
+			if (modPath) name = `${this.qualifierFor(modPath)}${name.slice(dot)}`;
+		}
+		return t.typeArgs?.length
+			? `${name}[${t.typeArgs.map((a) => this.spell(a)).join(", ")}]`
+			: name;
+	}
+
+	spellStruct(t) {
+		const fields = (t._structFields ?? []).map((f) => {
+			const tag = f.tag ? ` \`${f.tag}\`` : "";
+			if (f.embedded) return `${this.spell(f.type)}${tag}`;
+			return `${f.names.join(", ")} ${this.spell(f.type)}${tag}`;
+		});
+		return `struct { ${fields.join("; ")} }`;
+	}
+
+	funcString(t, name) {
+		const rs = results(t);
+		const res =
+			rs.length === 0
+				? ""
+				: rs.length === 1
+					? ` ${name(rs[0])}`
+					: ` (${rs.map(name).join(", ")})`;
+		// The signature keeps a variadic parameter's element type.
+		const params = t.params.map((p, i) =>
+			t.variadic && i === t.params.length - 1 ? `...${name(p)}` : name(p),
+		);
+		return `func(${params.join(", ")})${res}`;
+	}
+
+	// True when the type can be written as Go source in the generated file.
+	// Subclasses decide what a named type, an interface and a struct field
+	// need.
+	spellable(t, depth = 0, seen = new Set()) {
+		if (!t || depth > 8) return false;
+		const ok = (x) => this.spellable(x, depth + 1, seen);
+		const byKind = {
+			basic: () => t.name !== "void" && t.name !== "nil",
+			named: () => this.spellableNamed(t, ok, seen),
+			// A JS-interop (.d.ts) type has no Go source to write.
+			namespace: () => false,
+			pointer: () => ok(t.base),
+			slice: () => ok(t.elem),
+			array: () => ok(t.elem),
+			map: () => ok(t.key) && ok(t.value),
+			interface: () => this.spellableInterface(t),
+			struct: () => this.spellableStruct(t, ok),
+			func: () => t.params.every(ok) && results(t).every(ok),
+		};
+		return byKind[t.kind]?.() ?? false;
+	}
+
+	spellableInterface(_t) {
+		return true;
+	}
+
+	spellableStruct(t, ok) {
+		return (t._structFields ?? []).every((f) => ok(f.type));
+	}
+}

package/src/lower/index.js

@@ -16,9 +16,16 @@ import { scanAddressTaken } from "./boxing.js";
 import { analyzeCaptures } from "./captures.js";
 import { computeEmbeddedStubs } from "./embedding.js";
 import { paramEscapes } from "./escape.js";
-import { extractNamedReturns, hasDefer, normalizeDefers } from "./functions.js";
+import {
+	extractNamedReturns,
+	hasDefer,
+	normalizeDefers,
+	splitForwardedTuples,
+} from "./functions.js";
 import { computeGlobalAnalysis } from "./globals.js";
-import { OwnershipContext } from "./ownership.js";
+import { OwnershipContext, takesElementAddress } from "./ownership.js";
+
+export { takesElementAddress };
 
 class LowerResult {
 	constructor() {
@@ -40,6 +47,8 @@ class LowerResult {
 		this.initPathFunctions = new Set();
 		// Map<ASTNode, Array<string>>
 		this.cachedGlobalsByFunc = new Map();
+		// True when some code takes `&xs[i]` (see takesElementAddress)
+		this.elemAddrTaken = false;
 	}
 }
 
@@ -79,8 +88,11 @@ export function lower(programOrPrograms, checker = null) {
 		? programOrPrograms
 		: [programOrPrograms];
 
+	splitForwardedTuples(programs);
 	normalizeDefers(programs);
 
+	res.elemAddrTaken = programs.some((p) => takesElementAddress(p?.decls));
+
 	// 1. Aggregate methods across all files in the package
 	const methodMap = new Map();
 	for (const program of programs) {