gofront 1.8.0 → 1.9.1

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.
@@ -72,9 +73,20 @@ function rawTypeKey(t) {
 	if (t.kind === "map" || t.kind === "MapType") {
 		return `map_${typeKey(t.key)}_${typeKey(t.value)}`;
 	}
-	if (t.kind === "func" || t.kind === "FuncType") {
+	if (t.kind === "func") {
 		const params = (t.params ?? []).map(typeKey).join("_");
-		const rets = (t.returns ?? []).map(typeKey).join("_");
+		const rets = (t.returns ?? [])
+			.filter((r) => !(r?.kind === "basic" && r.name === "void"))
+			.map(typeKey)
+			.join("_");
+		return `fn_${params}_ret_${rets}`;
+	}
+	if (t.kind === "FuncType") {
+		const params = (t.params ?? []).map((p) => typeKey(p.type)).join("_");
+		const rt = t.returnType;
+		const rets = rt
+			? (rt.kind === "TupleType" ? rt.types : [rt]).map(typeKey).join("_")
+			: "";
 		return `fn_${params}_ret_${rets}`;
 	}
 	if (t.name) return t.name;
@@ -118,7 +130,11 @@ export 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),
 		};
 	}
@@ -130,16 +146,77 @@ export function typeToTypeNode(t) {
 		};
 	}
 	if (t.kind === "typeParam") return { kind: "TypeName", name: t.name };
+	// Without this a func type argument fell through to `any`, so a
+	// `map[string]V` built in `mk[func()]` was a `map[string]any`.
+	if (t.kind === "func") return funcTypeNode(t);
 	return { kind: "TypeName", name: t.name ?? "any" };
 }
 
+// A checker func type as a `FuncType` node (several results as a `TupleType`).
+function funcTypeNode(t) {
+	// A variadic func lists its last parameter by element type.
+	const params = (t.params ?? []).map((p, i, all) => ({
+		name: "_",
+		type: typeToTypeNode(p),
+		variadic: !!t.variadic && i === all.length - 1,
+	}));
+	const rets = (t.returns ?? []).filter(
+		(r) => !(r?.kind === "basic" && r.name === "void"),
+	);
+	// Several results come as one tuple type or as a list.
+	const results = rets.length === 1 && rets[0]?.types ? rets[0].types : rets;
+	let returnType = null;
+	if (results.length === 1) returnType = typeToTypeNode(results[0]);
+	else if (results.length > 1)
+		returnType = { kind: "TupleType", types: results.map(typeToTypeNode) };
+	return { kind: "FuncType", params, returnType };
+}
+
+// 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"]);
+const KEPT_CLONE_KEYS = new Set(["_typeArgs", "_line", "_col", "_spread"]);
 
 function cloneAst(node) {
 	if (!node || typeof node !== "object") return node;
@@ -252,6 +329,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) {
@@ -271,6 +349,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],
@@ -301,6 +386,18 @@ function substituteTypesInAst(
 				_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) {
@@ -309,7 +406,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);
@@ -559,9 +656,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 (
@@ -611,6 +713,7 @@ export function monomorphise(programs, checker) {
 		}
 	}
 
+	const typeInstances = new Map();
 	const specializedFuncs = new Map();
 	const specializedTypes = new Map();
 	const specializedMethods = new Map();
@@ -638,6 +741,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;
@@ -650,6 +754,7 @@ export function monomorphise(programs, checker) {
 			);
 			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) ?? [];
@@ -669,6 +774,7 @@ export function monomorphise(programs, checker) {
 				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);
@@ -693,6 +799,7 @@ export function monomorphise(programs, checker) {
 			);
 			rebindNamedResults(monoFuncDecl);
 			specializedFuncs.set(item.specializedName, monoFuncDecl);
+			homeOf.set(monoFuncDecl, homeOf.get(genDecl));
 		}
 	}
 
@@ -744,15 +851,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)) {
@@ -764,6 +878,23 @@ export function monomorphise(programs, checker) {
 	// 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);
+	}
+}