gofront 1.7.0 → 1.9.0

package/src/link/type-names.js

@@ -0,0 +1,148 @@
+// 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`).  Returns whether anything was renamed.
+let localTypeCounter = 0;
+
+export function renameLocalTypes(programs) {
+	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(([, n]) => n > 1).map(([k]) => k));
+	if (dup.size === 0) return false;
+	let changed = false;
+	// Inner scopes first, so an outer rename never touches a nested
+	// declaration that already has its own name.
+	const scan = (node) => {
+		if (!node || typeof node !== "object") return;
+		if (Array.isArray(node)) {
+			node.forEach(scan);
+			for (let i = 0; i < node.length; i++) {
+				const d = node[i];
+				if (d?.kind !== "TypeDecl" || !dup.has(d.name)) continue;
+				const renamed = new Map([
+					[d.name, `${d.name}__L${++localTypeCounter}`],
+				]);
+				for (let j = i; j < node.length; j++)
+					renameTypeRefs(node[j], renamed, new Set(), new Set());
+				changed = true;
+			}
+			return;
+		}
+		forEachChild(node, scan);
+	};
+	for (const p of programs)
+		for (const d of p.decls ?? []) if (d.kind !== "TypeDecl") scan(d);
+	return changed;
+}
+
+// `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

@@ -0,0 +1,318 @@
+// Linking of `wasm`/`both` package units into one `app.wasm`: unit
+// registration, collision checks, link-copy AST rewrites and the facade splice.
+
+import { compileWasmModule } from "../backend/wasm/index.js";
+import { lower } from "../lower/index.js";
+import { reachableStdlibDecls } from "../lower/reachability.js";
+import { forEachChild } from "../lower/walk.js";
+import { TypeCheckError, TypeChecker } from "../typechecker/index.js";
+
+// ── WASM linking ──────────────────────────────────────────────
+//
+// Every `wasm`/`both` package reached during a build registers a unit in the
+// shared `options.wasmUnits` array.  The root compile links all units into a
+// single `app.wasm` and splices the generated JS facade into the bundle where
+// the first wasm package's JS would have been.
+
+const WASM_MARKER_RE = /^\/\*__GOFRONT_WASM_UNIT:[^*]*\*\/$/m;
+
+export function wasmMarker(pkgName) {
+	return `/*__GOFRONT_WASM_UNIT:${pkgName}*/`;
+}
+
+export function registerWasmUnit(options, unit) {
+	const units = options.wasmUnits;
+	if (!units) return;
+	if (units.some((u) => u.key === unit.key)) return;
+	units.push(unit);
+}
+
+// Registers a `wasm`/`both` package as a link unit and returns the target the
+// package's own code is emitted for.  `options.wasmTests` runs a `both`
+// package's tests through the wasm backend (the package is then treated as
+// `wasm` for linking so its test functions are exposed by the facade).
+export function registerPackageUnit(options, unit) {
+	const { pkgTarget, programs } = unit;
+	if (pkgTarget !== "wasm" && pkgTarget !== "both") return pkgTarget;
+	const emitTarget =
+		options.wasmTests && options.isTest && pkgTarget === "both"
+			? "wasm"
+			: pkgTarget;
+	registerWasmUnit(options, {
+		...unit,
+		target: emitTarget,
+		programs:
+			emitTarget === pkgTarget
+				? programs
+				: programs.map((p) => ({ ...p, target: emitTarget })),
+	});
+	return emitTarget;
+}
+
+function linkWasmUnits(
+	units,
+	{
+		emitWat = false,
+		rootTarget = "js",
+		sourceMappingURL = null,
+		natives = true,
+	} = {},
+) {
+	if (!units.some((u) => u.target === "wasm")) return null;
+	checkLinkCollisions(units);
+
+	const types = new Map();
+	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));
+		programs.push(...copies);
+		if (u.key.startsWith("stdlib:")) stdlibPrograms.push(...copies);
+	}
+	lowerStdlibRefs(programs);
+	dequalifyBundledRefs(programs, bundledPackages);
+	const keepType = pruneStdlibPrograms(programs, stdlibPrograms);
+	for (const u of units)
+		for (const [k, v] of u.types) if (keepType(v)) types.set(k, v);
+	const checker = Object.assign(new TypeChecker(), {
+		types,
+		errors: [],
+		err(msg, node) {
+			const e = new TypeCheckError(
+				msg,
+				node,
+				this._currentFile,
+				this._currentSource,
+			);
+			this.errors.push(e);
+			return e;
+		},
+	});
+	const lowerRes = lower(programs, checker);
+	return compileWasmModule(programs, checker, lowerRes, {
+		boundary: true,
+		bundledPackages,
+		natives,
+		emitWat,
+		callMain: rootTarget === "wasm",
+		sourceMappingURL,
+	});
+}
+
+// The WASM pipeline rewrites ASTs in place (package dequalification,
+// monomorphisation, variadic desugaring).  Parsed ASTs are cached across
+// builds and shared with JS codegen, so the link works on a structural copy;
+// side tables (`_type`, …) are shared by reference.
+function cloneAstForWasm(node, seen = new Map()) {
+	if (!node || typeof node !== "object") return node;
+	const prev = seen.get(node);
+	if (prev) return prev;
+	const copy = Array.isArray(node) ? [] : {};
+	seen.set(node, copy);
+	if (Array.isArray(node)) {
+		for (const n of node) copy.push(cloneAstForWasm(n, seen));
+		return copy;
+	}
+	for (const [k, v] of Object.entries(node)) {
+		copy[k] = k.charCodeAt(0) === 95 ? v : cloneAstForWasm(v, seen);
+	}
+	return copy;
+}
+
+// Drops unreachable Go-source stdlib declarations from the link copy and
+// returns a filter that drops their (mangled) named types.
+function pruneStdlibPrograms(programs, stdlibPrograms) {
+	if (stdlibPrograms.length === 0) return () => true;
+	const std = new Set(stdlibPrograms);
+	const reached = reachableStdlibDecls(
+		programs.filter((p) => !std.has(p)),
+		stdlibPrograms,
+	);
+	const types = new Set();
+	for (const p of stdlibPrograms) {
+		p.decls = p.decls.filter((d) => reached.has(d));
+		for (const d of p.decls) if (d.kind === "TypeDecl") types.add(d.name);
+	}
+	return (t) => {
+		const name = typeof t?.name === "string" ? t.name : "";
+		return !name.includes("$$") || types.has(name.replace(/\[.*$/, ""));
+	};
+}
+
+// The linked module is flat, so `util.Two` names the top-level `Two`.  Done on
+// the link copy before monomorphisation, whose re-check of all programs has no
+// package namespaces.  A local variable that shadows the package is typed and
+// is left alone.
+function isBundledSelector(node, bundled) {
+	const base = node.expr;
+	return (
+		base?.kind === "Ident" &&
+		bundled.has(base.name) &&
+		(base._type == null || base._type.kind === "namespace")
+	);
+}
+
+function dequalifyBundledRefs(node, bundled) {
+	if (!node || typeof node !== "object") return;
+	if (Array.isArray(node)) {
+		for (const n of node) dequalifyBundledRefs(n, bundled);
+		return;
+	}
+	if (node.kind === "SelectorExpr" && isBundledSelector(node, bundled)) {
+		node.kind = "Ident";
+		node.name = node.field;
+		delete node.expr;
+		delete node.field;
+	} else if (node.kind === "TypeName" || node.kind === "GenericTypeName") {
+		const dot = node.name?.indexOf(".") ?? -1;
+		if (dot > 0 && bundled.has(node.name.slice(0, dot)))
+			node.name = node.name.slice(dot + 1);
+	}
+	forEachChild(node, (child) => dequalifyBundledRefs(child, bundled));
+}
+
+// The linked module is one flat namespace (like the JS bundle), so a top-level
+// name declared by two different packages would silently resolve to whichever
+// was emitted last.  Reject it up front.
+function topLevelDeclNames(decl) {
+	switch (decl.kind) {
+		case "FuncDecl":
+			return [decl.name];
+		case "MethodDecl":
+			return [`${decl.recvType?.name ?? "?"}.${decl.name}`];
+		case "TypeDecl":
+			return [decl.name];
+		case "VarDecl":
+		case "ConstDecl":
+			return (decl.decls ?? []).flatMap((spec) => spec.names ?? []);
+		default:
+			return [];
+	}
+}
+
+export function checkLinkCollisions(units) {
+	const owner = new Map(); // name -> pkgName
+	const errors = [];
+	for (const u of units) {
+		for (const p of u.programs) {
+			for (const d of p.decls ?? []) {
+				for (const name of topLevelDeclNames(d)) {
+					if (name === "_") continue;
+					const prev = owner.get(name);
+					if (prev === undefined) owner.set(name, u.pkgName);
+					else if (prev !== u.pkgName)
+						errors.push(
+							`cannot link wasm packages: '${name}' is declared in both '${prev}' and '${u.pkgName}' (linked wasm packages share one namespace)`,
+						);
+				}
+			}
+		}
+	}
+	if (errors.length > 0) throw new Error([...new Set(errors)].join("\n"));
+}
+
+// Replaces the first wasm marker with the facade (dropping the others) and
+// shifts source-map lines that follow it.
+function spliceFacade(merged, facade) {
+	const lines = merged.js.split("\n");
+	const first = lines.findIndex((l) => WASM_MARKER_RE.test(l));
+	if (first < 0) {
+		merged.js = `${facade}\n${merged.js}`;
+		const shift = facade.split("\n").length;
+		for (const m of merged.mappings) m.genLine += shift;
+		return;
+	}
+	const facadeLines = facade.split("\n");
+	const delta = facadeLines.length - 1;
+	for (const m of merged.mappings) {
+		if (m.genLine > first) m.genLine += delta;
+	}
+	const out = [...lines.slice(0, first), ...facadeLines];
+	for (let i = first + 1; i < lines.length; i++) {
+		if (!WASM_MARKER_RE.test(lines[i])) out.push(lines[i]);
+	}
+	merged.js = out.join("\n");
+}
+
+// Root compiles only: link every registered unit into app.wasm and splice the
+// facade into the merged bundle.  Returns `{ wasm, wat, sourceMapInfo }`
+// (nulls when there is nothing to link).
+export function linkIntoBundle(
+	options,
+	merged,
+	pkgTarget,
+	{ sourceMappingURL } = {},
+) {
+	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,
+	});
+	if (!linked) return none;
+	spliceFacade(merged, linked.facade);
+	return {
+		wasm: linked.wasm,
+		wat: linked.wat ?? null,
+		sourceMapInfo: linked.sourceMapInfo ?? null,
+		stringTable: linked.stringTable ?? null,
+	};
+}
+
+// Turns `cmp.Compare` / `cmp.Ordered` references (marked `_stdName` by the
+// checker) into plain identifiers with the mangled name, so WASM
+// monomorphisation sees ordinary top-level references.  Only for ASTs that
+// are not cached: a stdlib package's own parse and the WASM link copy (user
+// ASTs are re-checked on the next build; the JS backend reads `_stdName`).
+export function lowerStdlibRefs(node) {
+	if (!node || typeof node !== "object") return;
+	if (Array.isArray(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;
+			delete node.field;
+			node.kind = "Ident";
+		}
+		node.name = node._stdName;
+		delete node._stdName;
+	}
+	if (node.kind === "CallExpr" && node.func?._jsonStream) {
+		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._genEntry;
+		node.func.kind = "Ident";
+		node.func.name = entry;
+	} else if (node._genEntry && node.kind === "SelectorExpr") {
+		delete node.expr;
+		delete node.field;
+		node.kind = "Ident";
+		node.name = node._genEntry;
+	}
+	forEachChild(node, lowerStdlibRefs);
+}