gofront 1.7.0 → 1.9.0

package/src/backend/wasm/monomorph.js

@@ -7,6 +7,7 @@
 // (e.g. Identity$int, Box$int, Stack$int.Push) and re-typechecks the monomorphised AST.
 
 import { TypeChecker } from "../../typechecker/index.js";
+import { goTypeName } from "../shared/fmt-types.js";
 
 /**
  * Returns true if the AST contains any generic declarations.
@@ -33,7 +34,13 @@ export function hasGenerics(programs) {
 /**
  * Returns a stable identifier-safe string key for any Go type or AST type node.
  */
+// A qualified type argument (`time.Duration`) becomes part of a JS and wasm
+// export identifier, so its dot is replaced.
 function typeKey(t) {
+	return rawTypeKey(t).replaceAll(".", "_");
+}
+
+function rawTypeKey(t) {
 	if (!t) return "any";
 	if (typeof t === "string") return t;
 	if (t.kind === "basic") return t.name;
@@ -78,7 +85,7 @@ function typeKey(t) {
 /**
  * Converts a Go type representation or AST type node into a concrete AST type node.
  */
-function typeToTypeNode(t) {
+export function typeToTypeNode(t) {
 	if (!t) return { kind: "TypeName", name: "any" };
 	if (typeof t === "string") return { kind: "TypeName", name: t };
 	if (
@@ -112,7 +119,11 @@ function typeToTypeNode(t) {
 	if (t.kind === "array") {
 		return {
 			kind: "ArrayType",
-			len: t.len ?? t.size ?? 0,
+			size: {
+				kind: "BasicLit",
+				litKind: "INT",
+				value: String(t.len ?? t.size ?? 0),
+			},
 			elem: typeToTypeNode(t.elem),
 		};
 	}
@@ -127,22 +138,92 @@ function typeToTypeNode(t) {
 	return { kind: "TypeName", name: t.name ?? "any" };
 }
 
+// Replaces the type parameters inside a checker type (`[]E`, `map[K]V`,
+// `Box[E]`) by their type arguments; the result mixes checker types and the
+// AST type nodes of the substitution, which `typeKey` and `typeToTypeNode`
+// both accept.
+function substituteInType(t, map) {
+	if (!t || typeof t !== "object") return t;
+	const sub = (x) => substituteInType(x, map);
+	switch (t.kind) {
+		case "typeParam":
+			return map.has(t.name) ? map.get(t.name) : t;
+		case "slice":
+		case "array":
+			return { ...t, elem: sub(t.elem) };
+		case "pointer":
+			return { ...t, base: sub(t.base) };
+		case "map":
+			return { ...t, key: sub(t.key), value: sub(t.value) };
+		case "func":
+			return {
+				...t,
+				params: (t.params ?? []).map(sub),
+				returns: (t.returns ?? []).map(sub),
+			};
+		case "named":
+			return t.typeArgs?.length ? { ...t, typeArgs: t.typeArgs.map(sub) } : t;
+		default:
+			return t;
+	}
+}
+
+// A partial instantiation (`Grow[S](nil, n)`) lists only the explicit type
+// arguments; the checker recorded the complete list, which replaces it.
+function completeTypeArgs(node, typeSubstMap) {
+	if (node._typeArgs?.length > (node.typeArgs?.length ?? 0))
+		return node._typeArgs.map((t) => substituteInType(t, typeSubstMap));
+	return node.typeArgs;
+}
+
 function getSpecializedName(baseName, typeArgs) {
 	if (!typeArgs || typeArgs.length === 0) return baseName;
 	const keys = typeArgs.map(typeKey).join("$");
 	return `${baseName}$${keys}`;
 }
 
+const KEPT_CLONE_KEYS = new Set(["_typeArgs", "_line", "_col", "_spread"]);
+
 function cloneAst(node) {
 	if (!node || typeof node !== "object") return node;
 	if (Array.isArray(node)) return node.map(cloneAst);
 	const copy = {};
 	for (const [k, v] of Object.entries(node)) {
+		// Side tables are dropped, except source positions (for diagnostics in
+		// the specialised body) and the inferred type arguments of a generic
+		// call inside a generic body: substitution needs them to specialise the
+		// callee (`isNaN(x)` inside `Compare[T]`).
+		if (k.startsWith("_") && !KEPT_CLONE_KEYS.has(k)) continue;
 		copy[k] = cloneAst(v);
 	}
+	// Named results hang off the return type node and alias its types; keep
+	// just the names so `rebindNamedResults` can rebuild them after the types
+	// are substituted.
+	const named = node.returnType?._namedReturns;
+	if (named) copy._resultNames = named.map((r) => r.name);
 	return copy;
 }
 
+// Re-attaches named results (`(old *T)`) to every function in a cloned and
+// substituted tree, pointing at the substituted type nodes.
+function rebindNamedResults(node) {
+	if (!node || typeof node !== "object") return;
+	if (Array.isArray(node)) {
+		for (const n of node) rebindNamedResults(n);
+		return;
+	}
+	if (node._resultNames && node.returnType) {
+		const rt = node.returnType;
+		rt._namedReturns = node._resultNames.map((name, i) => ({
+			name,
+			type: rt.kind === "TupleType" ? rt.types[i] : rt,
+		}));
+	}
+	for (const [k, v] of Object.entries(node)) {
+		if (!k.startsWith("_")) rebindNamedResults(v);
+	}
+}
+
 /**
  * Replaces references to type parameters in AST nodes with concrete types.
  */
@@ -214,6 +295,7 @@ function substituteTypesInAst(
 		}
 		const baseName = node.expr?.name;
 		if (baseName) {
+			node.typeArgs = completeTypeArgs(node, typeSubstMap);
 			const sName = getSpecializedName(baseName, node.typeArgs);
 			const isType = genericTypes ? genericTypes.has(baseName) : false;
 			if (onGenericUsage) {
@@ -233,6 +315,13 @@ function substituteTypesInAst(
 	// 3b. CompositeLit
 	if (node.kind === "CompositeLit") {
 		const targetProp = node.typeExpr ? "typeExpr" : node.type ? "type" : null;
+		// `S{a, b}` with S a type parameter: the type is a bare identifier.
+		if (
+			targetProp &&
+			node[targetProp]?.kind === "Ident" &&
+			typeSubstMap.has(node[targetProp].name)
+		)
+			node[targetProp] = cloneAst(typeSubstMap.get(node[targetProp].name));
 		if (targetProp && node[targetProp]) {
 			node[targetProp] = substituteTypesInAst(
 				node[targetProp],
@@ -246,6 +335,35 @@ function substituteTypesInAst(
 
 	// 4. CallExpr
 	if (node.kind === "CallExpr") {
+		// `T(x)` with T a type parameter becomes the conversion `int8(x)`.
+		const conv =
+			node.func?.kind === "Ident" ? typeSubstMap.get(node.func.name) : null;
+		if (conv && node.args?.length === 1) {
+			return {
+				kind: "TypeConversion",
+				targetType: cloneAst(conv),
+				expr: substituteTypesInAst(
+					node.args[0],
+					typeSubstMap,
+					onGenericUsage,
+					genericTypes,
+					genericFuncs,
+				),
+				_line: node._line,
+			};
+		}
+		// `make(S, n)` / `new(S)`: the type argument is a bare identifier.
+		if (
+			node.func?.kind === "Ident" &&
+			(node.func.name === "make" || node.func.name === "new") &&
+			node.args?.[0]?.kind === "Ident" &&
+			typeSubstMap.has(node.args[0].name)
+		) {
+			node.args[0] = {
+				kind: "TypeExpr",
+				type: cloneAst(typeSubstMap.get(node.args[0].name)),
+			};
+		}
 		if (node.func?.kind === "Ident") {
 			let typeArgs = node._typeArgs ?? node.func._typeArgs;
 			if (typeArgs) {
@@ -254,7 +372,7 @@ function substituteTypesInAst(
 					if (name && typeSubstMap.has(name)) {
 						return typeSubstMap.get(name);
 					}
-					return t;
+					return substituteInType(t, typeSubstMap);
 				});
 				const baseName = node.func.name;
 				const sName = getSpecializedName(baseName, typeArgs);
@@ -504,9 +622,14 @@ export function monomorphise(programs, checker) {
 	const genericFuncs = new Map();
 	const genericTypes = new Map();
 	const genericMethods = new Map(); // recvBaseName -> Array<MethodDecl>
+	// Template declaration -> its program; a specialization joins the program
+	// of its template, so a wasm package's instances stay wasm-package
+	// declarations even when a Go-source stdlib package is linked first.
+	const homeOf = new Map();
 
 	for (const p of progs) {
 		for (const d of p?.decls ?? []) {
+			homeOf.set(d, p);
 			if (d.kind === "FuncDecl" && d.typeParams && d.typeParams.length > 0) {
 				genericFuncs.set(d.name, d);
 			} else if (
@@ -556,6 +679,7 @@ export function monomorphise(programs, checker) {
 		}
 	}
 
+	const typeInstances = new Map();
 	const specializedFuncs = new Map();
 	const specializedTypes = new Map();
 	const specializedMethods = new Map();
@@ -583,6 +707,7 @@ export function monomorphise(programs, checker) {
 				typeSubstMap.set(tp.name, typeToTypeNode(concrete));
 			}
 
+			typeInstances.set(item.specializedName, item);
 			const monoTypeDecl = cloneAst(genDecl);
 			monoTypeDecl.name = item.specializedName;
 			monoTypeDecl.typeParams = null;
@@ -593,7 +718,9 @@ export function monomorphise(programs, checker) {
 				genericTypes,
 				genericFuncs,
 			);
+			rebindNamedResults(monoTypeDecl);
 			specializedTypes.set(item.specializedName, monoTypeDecl);
+			homeOf.set(monoTypeDecl, homeOf.get(genDecl));
 
 			// Specialize all methods declared on this generic type
 			const methods = genericMethods.get(item.genericName) ?? [];
@@ -610,8 +737,10 @@ export function monomorphise(programs, checker) {
 					genericTypes,
 					genericFuncs,
 				);
+				rebindNamedResults(monoMethod);
 				const mKey = `${item.specializedName}.${monoMethod.name}`;
 				specializedMethods.set(mKey, monoMethod);
+				homeOf.set(monoMethod, homeOf.get(m));
 			}
 		} else if (item.kind === "func") {
 			const genDecl = genericFuncs.get(item.genericName);
@@ -634,7 +763,9 @@ export function monomorphise(programs, checker) {
 				genericTypes,
 				genericFuncs,
 			);
+			rebindNamedResults(monoFuncDecl);
 			specializedFuncs.set(item.specializedName, monoFuncDecl);
+			homeOf.set(monoFuncDecl, homeOf.get(genDecl));
 		}
 	}
 
@@ -686,15 +817,22 @@ export function monomorphise(programs, checker) {
 
 	const targetProg = progs[0];
 	if (targetProg) {
-		targetProg.decls.push(...specializedTypes.values());
-		targetProg.decls.push(...specializedMethods.values());
-		targetProg.decls.push(...specializedFuncs.values());
+		for (const group of [
+			specializedTypes,
+			specializedMethods,
+			specializedFuncs,
+		])
+			for (const d of group.values())
+				(homeOf.get(d) ?? targetProg).decls.push(d);
 	}
 
 	// 6. Typecheck the monomorphised program to annotate all concrete types
 	const monoChecker = new TypeChecker();
 	monoChecker.target = "wasm";
 	monoChecker.pkgName = targetProg?.pkg?.name ?? "main";
+	// The programs were checked once already, where `//gofront:native` is
+	// limited to the standard library; this pass only re-annotates them.
+	monoChecker.nativesChecked = true;
 	if (checker?.types) {
 		for (const [name, type] of checker.types.entries()) {
 			if (!monoChecker.types.has(name)) {
@@ -703,9 +841,26 @@ export function monomorphise(programs, checker) {
 		}
 	}
 
-	for (const p of progs) {
-		monoChecker.check(p);
-	}
+	// One pass over all programs: declarations of every linked package are
+	// visible to the others (cross-package references are dequalified).
+	monoChecker.checkAll(progs);
+	nameInstances(monoChecker, typeInstances);
 
 	return { programs: progs, checker: monoChecker };
 }
+
+// Records Go's spelling of each generic instance (`Box[int]`) on its
+// monomorphised type, which is named `Box$int`; `%T` prints the spelling.
+function nameInstances(checker, instances) {
+	const spelling = {
+		has: (name) => instances.has(name),
+		get: (name) => {
+			const { genericName, typeArgs } = instances.get(name);
+			return `${genericName}[${typeArgs.map((a) => goTypeName(a, spelling)).join(",")}]`;
+		},
+	};
+	for (const name of instances.keys()) {
+		const type = checker.types.get(name);
+		if (type) type._goName = spelling.get(name);
+	}
+}