gofront 1.8.0 → 1.9.1

package/src/link/type-names.js

@@ -0,0 +1,204 @@
+// Same-named types in different local packages.
+//
+// Local packages are inlined into one flat JS module, so `a.Pt` and `b.Pt`
+// would both become `class Pt`.  A package that declares a type another
+// package already owns gets that type renamed to `Pt$$b` before it is
+// type-checked, the convention Go-source stdlib packages use: diagnostics and
+// `%T` show it as `b.Pt`, and importers reach it through `b.Pt` as usual.
+
+import { forEachChild } from "../lower/walk.js";
+
+function topLevelTypeNames(programs) {
+	const names = [];
+	for (const p of programs)
+		for (const d of p.decls ?? [])
+			if (d.kind === "TypeDecl") names.push(d.name);
+	return names;
+}
+
+// Registers the package's type names in `owners` (name -> package key) and
+// renames those another package registered first.  Returns Map<name, mangled>
+// for the renamed types, empty when nothing collides.
+export function mangleCollidingTypes(programs, pkgKey, pkgName, owners) {
+	const renamed = new Map();
+	for (const name of topLevelTypeNames(programs)) {
+		const owner = owners.get(name);
+		if (owner === undefined) owners.set(name, pkgKey);
+		else if (owner !== pkgKey) renamed.set(name, `${name}$$${pkgName}`);
+	}
+	if (renamed.size > 0)
+		for (const p of programs)
+			for (const d of p.decls ?? [])
+				renameTypeRefs(d, renamed, new Set(), new Set());
+	return renamed;
+}
+
+// Function-local types are scoped to their block, but the checker and both
+// backends key types by bare name.  A local type whose name another type of the
+// package also uses (a package-level type or a local of another function)
+// is renamed to `Name__L<n>` for its scope; `%T` and diagnostics drop the
+// suffix (see `displayTypeName`).  `reserved` holds type names other packages
+// own: a local type spelled like one is renamed too, so it cannot clash with
+// the imported type in the flat module.  Returns whether anything was renamed.
+let localTypeCounter = 0;
+
+export function renameLocalTypes(programs, reserved = new Set()) {
+	const counts = new Map();
+	const count = (node) => {
+		if (!node || typeof node !== "object") return;
+		if (Array.isArray(node)) return node.forEach(count);
+		if (node.kind === "TypeDecl")
+			counts.set(node.name, (counts.get(node.name) ?? 0) + 1);
+		forEachChild(node, count);
+	};
+	for (const p of programs) count(p.decls);
+	const dup = new Set(
+		[...counts].filter(([k, n]) => n > 1 || reserved.has(k)).map(([k]) => k),
+	);
+	let changed = false;
+	// Inner scopes first, so an outer rename never touches a nested
+	// declaration that already has its own name.  `visible` holds the value
+	// names declared so far in the enclosing scopes.
+	const scan = (node, visible) => {
+		if (!node || typeof node !== "object") return;
+		if (Array.isArray(node)) {
+			const seen = new Set(visible);
+			for (let i = 0; i < node.length; i++) {
+				const d = node[i];
+				scan(d, seen);
+				if (d?.kind === "TypeDecl") {
+					// A value of the same name would clash with the type in JS.
+					const stop = node.findIndex(
+						(s, j) => j > i && declaresValue(s, d.name),
+					);
+					if (dup.has(d.name) || seen.has(d.name) || stop >= 0) {
+						const renamed = new Map([
+							[d.name, `${d.name}__L${++localTypeCounter}`],
+						]);
+						const end = stop >= 0 ? stop : node.length - 1;
+						for (let j = i; j <= end; j++) {
+							// The shadowing declaration's own right-hand side and type
+							// are evaluated before its new value is in scope.
+							const target =
+								j === stop && node[j].kind === "DefineStmt"
+									? node[j].rhs
+									: node[j];
+							renameTypeRefs(target, renamed, new Set(), new Set());
+						}
+						changed = true;
+					}
+				} else if (d) for (const n of valueNames(d)) seen.add(n);
+			}
+			return;
+		}
+		const here = FUNC_KINDS.has(node.kind)
+			? new Set([...visible, ...declaredParams(node)])
+			: visible;
+		forEachChild(node, (c) => scan(c, here));
+	};
+	for (const p of programs)
+		for (const d of p.decls ?? [])
+			if (d.kind !== "TypeDecl") scan(d, new Set());
+	return changed;
+}
+
+const VALUE_DECL_KINDS = new Set(["DefineStmt", "VarDecl", "ConstDecl"]);
+
+// Names a statement declares as values in its own scope.
+function valueNames(stmt) {
+	return VALUE_DECL_KINDS.has(stmt.kind) ? declaredNames(stmt) : [];
+}
+
+function declaresValue(stmt, name) {
+	return valueNames(stmt).includes(name);
+}
+
+function declaredParams(fn) {
+	const names = (fn.params ?? []).map((p) => p.name).filter(Boolean);
+	if (fn.recvName) names.push(fn.recvName);
+	return names;
+}
+
+// A package compiled later that declares a type this package only declares
+// inside a function is renamed by `mangleCollidingTypes`, so `Pt` of one package
+// and a local `Pt` of another never meet in the flat module.
+export function registerLocalTypeOwners(programs, pkgKey, owners) {
+	if (!owners) return;
+	const visit = (node) => {
+		if (!node || typeof node !== "object") return;
+		if (Array.isArray(node)) return node.forEach(visit);
+		if (node.kind === "TypeDecl" && !owners.has(node.name))
+			owners.set(node.name, pkgKey);
+		forEachChild(node, visit);
+	};
+	for (const p of programs) visit(p.decls);
+}
+
+// `tparams` are type parameters in scope; `values` are names a function
+// declares as parameters or locals, which shadow a same-spelled bare `Ident`.
+function renameTypeRefs(node, renamed, tparams, values) {
+	if (!node || typeof node !== "object") return;
+	if (Array.isArray(node)) {
+		for (const n of node) renameTypeRefs(n, renamed, tparams, values);
+		return;
+	}
+	const tp = withTypeParams(node, tparams);
+	const vals = FUNC_KINDS.has(node.kind) ? withLocals(node, values) : values;
+	if (isTypeRef(node, vals) && renamed.has(node.name) && !tp.has(node.name))
+		node.name = renamed.get(node.name);
+	forEachChild(node, (child) => {
+		if (node.kind === "KeyValueExpr" && child === node.key) return;
+		renameTypeRefs(child, renamed, tp, vals);
+	});
+}
+
+const FUNC_KINDS = new Set(["FuncDecl", "MethodDecl", "FuncLit"]);
+
+// Adds every parameter and local name declared anywhere inside a function.
+function withLocals(fn, values) {
+	const out = new Set(values);
+	const visit = (node) => {
+		if (!node || typeof node !== "object") return;
+		if (Array.isArray(node)) return node.forEach(visit);
+		for (const n of declaredNames(node)) out.add(n);
+		forEachChild(node, visit);
+	};
+	visit(fn);
+	return out;
+}
+
+function declaredNames(node) {
+	const names = [];
+	if (node.kind === "DefineStmt")
+		for (const l of node.lhs) if (l.kind === "Ident") names.push(l.name);
+	if (node.kind === "VarDecl" || node.kind === "ConstDecl")
+		for (const d of node.decls ?? []) names.push(...(d.names ?? []));
+	if (node.kind === "TypeSwitchStmt" && node.assign) names.push(node.assign);
+	for (const p of node.params ?? []) if (p.name) names.push(p.name);
+	if (node.recvName) names.push(node.recvName);
+	return names;
+}
+
+function withTypeParams(node, tparams) {
+	if (!(node.typeParams?.length > 0)) return tparams;
+	return new Set([...tparams, ...node.typeParams.map((t) => t.name)]);
+}
+
+const TYPE_REF_KINDS = new Set([
+	"TypeDecl",
+	"TypeName",
+	"GenericTypeName",
+	"Ident",
+]);
+
+function isTypeRef(node, values) {
+	if (node.kind === "Ident") return !values.has(node.name);
+	return TYPE_REF_KINDS.has(node.kind);
+}
+
+// Importers name a renamed type by its declared name (`b.Pt`).
+export function withOriginalTypeNames(types, renamed) {
+	for (const [name, mangled] of renamed)
+		if (types.has(mangled)) types.set(name, types.get(mangled));
+	return types;
+}

package/src/link/wasm.js

@@ -51,7 +51,12 @@ export function registerPackageUnit(options, unit) {
 
 function linkWasmUnits(
 	units,
-	{ emitWat = false, rootTarget = "js", sourceMappingURL = null } = {},
+	{
+		emitWat = false,
+		rootTarget = "js",
+		sourceMappingURL = null,
+		natives = true,
+	} = {},
 ) {
 	if (!units.some((u) => u.target === "wasm")) return null;
 	checkLinkCollisions(units);
@@ -60,6 +65,14 @@ function linkWasmUnits(
 	const bundledPackages = new Set();
 	const programs = [];
 	const stdlibPrograms = [];
+	// Check the stdlib bodies the linked code reaches before the ASTs are
+	// copied; lazily checked bodies are annotated and mangled in place.
+	reachableStdlibDecls(
+		units
+			.filter((u) => !u.key.startsWith("stdlib:"))
+			.flatMap((u) => u.programs),
+		units.filter((u) => u.key.startsWith("stdlib:")).flatMap((u) => u.programs),
+	);
 	for (const u of units) {
 		for (const b of u.bundledPackages) bundledPackages.add(b);
 		const copies = u.programs.map((p) => cloneAstForWasm(p));
@@ -89,6 +102,7 @@ function linkWasmUnits(
 	return compileWasmModule(programs, checker, lowerRes, {
 		boundary: true,
 		bundledPackages,
+		natives,
 		emitWat,
 		callMain: rootTarget === "wasm",
 		sourceMappingURL,
@@ -239,10 +253,16 @@ export function linkIntoBundle(
 	pkgTarget,
 	{ sourceMappingURL } = {},
 ) {
-	const none = { wasm: null, wat: null, sourceMapInfo: null };
+	const none = {
+		wasm: null,
+		wat: null,
+		sourceMapInfo: null,
+		stringTable: null,
+	};
 	if (options.isDependency) return none;
 	const linked = linkWasmUnits(options.wasmUnits, {
 		emitWat: options.emitWat,
+		natives: options.natives,
 		rootTarget: pkgTarget,
 		sourceMappingURL,
 	});
@@ -252,6 +272,7 @@ export function linkIntoBundle(
 		wasm: linked.wasm,
 		wat: linked.wat ?? null,
 		sourceMapInfo: linked.sourceMapInfo ?? null,
+		stringTable: linked.stringTable ?? null,
 	};
 }
 
@@ -266,6 +287,9 @@ export function lowerStdlibRefs(node) {
 		for (const n of node) lowerStdlibRefs(n);
 		return;
 	}
+	// A generated entry replaces the stdlib declaration the checker resolved
+	// (errors.As) the call to.
+	if (node._genEntry && node._stdName) delete node._stdName;
 	if (node._stdName) {
 		if (node.kind === "SelectorExpr") {
 			delete node.expr;
@@ -276,19 +300,19 @@ export function lowerStdlibRefs(node) {
 		delete node._stdName;
 	}
 	if (node.kind === "CallExpr" && node.func?._jsonStream) {
-		const entry = node.func._jsonGen;
+		const entry = node.func._genEntry;
 		node.args.unshift(node.func.expr);
 		delete node.func.expr;
 		delete node.func.field;
 		delete node.func._jsonStream;
-		delete node.func._jsonGen;
+		delete node.func._genEntry;
 		node.func.kind = "Ident";
 		node.func.name = entry;
-	} else if (node._jsonGen && node.kind === "SelectorExpr") {
+	} else if (node._genEntry && node.kind === "SelectorExpr") {
 		delete node.expr;
 		delete node.field;
 		node.kind = "Ident";
-		node.name = node._jsonGen;
+		node.name = node._genEntry;
 	}
 	forEachChild(node, lowerStdlibRefs);
 }

package/src/lower/bounds.js

@@ -385,6 +385,159 @@ function paramNames(decl) {
 	return names;
 }
 
+// ── Nil-check elision ───────────────────────────────────────────
+//
+// A pointer parameter or receiver that is declared once and never assigned
+// or address-taken stays the same pointer for the whole function.  Strict mode
+// checks it for nil at a field access (`__nilcall`); marking later accesses
+// `_nonNil` drops the repeats, and a receiver of a method that never compares
+// itself to nil cannot be nil at all (a nil receiver fails at the call).
+
+function isPointerIdent(node, names) {
+	return (
+		isIdent(node) &&
+		names.has(node.name) &&
+		underlying(node._type)?.kind === "pointer"
+	);
+}
+
+function derefBase(node) {
+	if (node.kind === "SelectorExpr") return node.expr;
+	if (node.kind === "UnaryExpr" && node.op === "*") return node.operand;
+	return null;
+}
+
+// Names whose address is taken anywhere under `body`.
+function addressTakenNames(body) {
+	const taken = new Set();
+	const visit = (node) => {
+		if (!node || typeof node !== "object") return;
+		if (Array.isArray(node)) {
+			for (const n of node) visit(n);
+			return;
+		}
+		if (node.kind === "UnaryExpr" && node.op === "&" && isIdent(node.operand))
+			taken.add(node.operand.name);
+		forEachChild(node, visit);
+	};
+	visit(body);
+	return taken;
+}
+
+function hasLabelOrGoto(body) {
+	let hit = false;
+	const visit = (node) => {
+		if (hit || !node || typeof node !== "object") return;
+		if (Array.isArray(node)) {
+			for (const n of node) visit(n);
+			return;
+		}
+		if (
+			node.kind === "LabeledStmt" ||
+			(node.kind === "BranchStmt" && node.tok === "goto")
+		)
+			hit = true;
+		forEachChild(node, visit);
+	};
+	visit(body);
+	return hit;
+}
+
+// The children of `node` that run whenever `node` runs, or null when all do.
+function alwaysRunChildren(node) {
+	switch (node.kind) {
+		case "FuncLit":
+		case "DeferStmt":
+		case "GoStmt":
+			return [];
+		case "IfStmt":
+			return [node.init, node.cond];
+		case "ForStmt":
+			return [node.init];
+		case "SwitchStmt":
+		case "TypeSwitchStmt":
+			return [node.init, node.tag];
+		case "BinaryExpr":
+			return node.op === "&&" || node.op === "||" ? [node.left] : null;
+		default:
+			return null;
+	}
+}
+
+// Marks derefs of `names` under `root` that run whenever `root` runs and
+// follow the first one per name (`seen`) or are in `always`.
+function markRepeats(root, names, seen, always) {
+	const visit = (node) => {
+		if (!node || typeof node !== "object") return;
+		if (Array.isArray(node)) {
+			for (const n of node) visit(n);
+			return;
+		}
+		const kids = alwaysRunChildren(node);
+		if (kids) {
+			for (const k of kids) visit(k);
+			return;
+		}
+		const base = derefBase(node);
+		if (base && isPointerIdent(base, names)) {
+			if (seen.has(base.name) || always.has(base.name)) node._nonNil = true;
+			else seen.add(base.name);
+		}
+		forEachChild(node, visit);
+	};
+	visit(root);
+}
+
+// Marks every deref of `names` under `root` (receivers that cannot be nil).
+function markAll(root, names) {
+	const visit = (node) => {
+		if (!node || typeof node !== "object") return;
+		if (Array.isArray(node)) {
+			for (const n of node) visit(n);
+			return;
+		}
+		const base = derefBase(node);
+		if (base && isPointerIdent(base, names)) node._nonNil = true;
+		forEachChild(node, visit);
+	};
+	visit(root);
+}
+
+function markNilFunc(decl, nilSafeRecv) {
+	const body = decl.body;
+	const params = paramNames(decl);
+	const stats = nameStats(params, body);
+	const taken = addressTakenNames(body);
+	const stable = (n) =>
+		n && stats.declared.get(n) === 1 && !stats.assigned.has(n) && !taken.has(n);
+	const always = new Set();
+	if (decl.kind === "MethodDecl" && decl.recvPointer && !nilSafeRecv(decl))
+		if (stable(decl.recvName)) always.add(decl.recvName);
+	const candidates = new Set(
+		(decl.params ?? []).map((p) => p.name).filter(stable),
+	);
+	for (const n of always) candidates.add(n);
+	if (candidates.size === 0) return;
+	if (always.size > 0) markAll(body, always);
+	if (hasLabelOrGoto(body)) return;
+	const seen = new Set();
+	for (const stmt of body.stmts ?? [])
+		markRepeats(stmt, candidates, seen, always);
+}
+
+/**
+ * Marks pointer derefs that need no nil check in strict mode: those of a
+ * receiver that cannot be nil and repeats after the first unconditional
+ * deref of an unchanged pointer parameter.  `nilSafeRecv(decl)` tells
+ * whether a method accepts a nil receiver.
+ */
+export function markRedundantNilChecks(program, nilSafeRecv) {
+	for (const d of program?.decls ?? []) {
+		if ((d.kind === "FuncDecl" || d.kind === "MethodDecl") && d.body)
+			markNilFunc(d, nilSafeRecv);
+	}
+}
+
 /** Marks provably in-range IndexExprs `_inBounds` in every function. */
 export function markInBoundsIndexes(program) {
 	for (const d of program?.decls ?? []) {

package/src/lower/captures.js

@@ -13,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();
 	}
@@ -48,48 +51,94 @@ export function collectDeclaredNames(node, names = new Set()) {
 }
 
 /**
- * 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;
 }
 
@@ -226,6 +275,7 @@ export function analyzeCaptures(fnDecl) {
 		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 allOuterScope = new Set();
@@ -233,14 +283,23 @@ export function analyzeCaptures(fnDecl) {
 			for (const name of scope) allOuterScope.add(name);
 		}
 
-		const allRefs = collectReferencedNames(node.body, closureLocals);
+		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.captureTypes.set(node, capturedTypes);
 
 		for (const varName of captured) {
 			if (mutatedVars.has(varName)) {