gofront 1.8.0 → 1.9.1

package/src/lower/embedding.js

@@ -1,26 +1,83 @@
 // src/lower/embedding.js
 // Computes promoted methods and delegation stubs for embedded structs.
 
+import {
+	ambiguousPromotions,
+	embeddedFieldName,
+} from "../typechecker/types.js";
+
+// A method promoted from an embedded struct value but declared on its
+// pointer receiver is outside the method set of the outer struct's value.
+function isPtrOnlyPromotion(rawEmbed, embed, mName, mType) {
+	if (rawEmbed.kind === "pointer") return false;
+	return Boolean((mType ?? embed.methods?.get(mName))?._ptrRecv);
+}
+
+// A pointer-receiver method reached through an embedded pointer, which may
+// be nil.
+function isNilablePtrRecv(rawEmbed, mType) {
+	return rawEmbed.kind === "pointer" && Boolean(mType?._ptrRecv);
+}
+
+// An embedded interface (named, literal or `error`) forwards each method of
+// its method set to the interface value in the field.
+function pushInterfaceStubs(stubs, declared, iface, fieldName) {
+	for (const mName of iface.methods?.keys() ?? []) {
+		if (declared.has(mName)) continue;
+		stubs.push({ methodName: mName, fieldName, ifaceEmbed: true });
+		declared.add(mName);
+	}
+}
+
+function pushValueEmbedStubs(stubs, declared, embed, embedName, fieldName) {
+	for (const [mName, mType] of embed.methods?.entries() ?? []) {
+		if (declared.has(mName) || mType?._ptrRecv) continue;
+		stubs.push({ methodName: mName, embedName, fieldName, valueEmbed: true });
+		declared.add(mName);
+	}
+}
+
 export function computeEmbeddedStubs(name, methodDecls, checker) {
 	if (!checker) return [];
 	const resolvedType = checker.types.get(name)?.underlying;
 	if (resolvedType?.kind !== "struct" || !resolvedType._embeds) return [];
 
-	const declared = new Set(methodDecls.map((m) => m.name));
+	// A method two embeds declare at the same depth is in neither method set:
+	// no stub, so the value does not satisfy an interface that needs it.
+	const declared = new Set([
+		...methodDecls.map((m) => m.name),
+		...ambiguousPromotions(resolvedType),
+	]);
 	const stubs = [];
 
-	for (const rawEmbed of resolvedType._embeds) {
+	const embedded = (resolvedType._structFields ?? []).filter((f) => f.embedded);
+	for (const [i, rawEmbed] of resolvedType._embeds.entries()) {
+		const fieldName = embedded[i] ? embeddedFieldName(embedded[i]) : null;
 		const embed = rawEmbed.kind === "pointer" ? rawEmbed.base : rawEmbed;
+		const embedBase = embed.kind === "named" ? embed.underlying : embed;
+		if (embedBase?.kind === "interface") {
+			if (rawEmbed.kind !== "pointer" && fieldName)
+				pushInterfaceStubs(stubs, declared, embedBase, fieldName);
+			continue;
+		}
 		const embedName = embed.kind === "named" ? embed.name : null;
 		if (!embedName) continue;
-		const embedBase = embed.kind === "named" ? embed.underlying : embed;
-		if (embedBase?.kind !== "struct" || !embedBase.methods) continue;
+		if (embedBase?.kind !== "struct" || !embedBase.methods) {
+			// A named non-struct type (`time.Duration`) promotes its value
+			// methods; the stub passes the embedded value as the receiver.
+			if (rawEmbed.kind !== "pointer")
+				pushValueEmbedStubs(stubs, declared, embed, embedName, fieldName);
+			continue;
+		}
 
-		for (const [mName] of embedBase.methods.entries()) {
+		for (const [mName, mType] of embedBase.methods.entries()) {
 			if (!declared.has(mName)) {
 				stubs.push({
 					methodName: mName,
 					embedName,
+					fieldName,
+					ptrOnly: isPtrOnlyPromotion(rawEmbed, embed, mName, mType),
+					nilPtrRecv: isNilablePtrRecv(rawEmbed, mType),
 				});
 				declared.add(mName); // Prevent duplicate stubs for diamond embeds
 			}

package/src/lower/errors-as.js

@@ -0,0 +1,196 @@
+// src/lower/errors-as.js
+// errors.As as generated Go source.
+//
+// `errors.As(err, &x)` stores through a pointer whose type only the checker
+// knows.  Each call site gets a function generated for its static target
+// type; it walks the error tree like the real package and honours custom
+// `As(any) bool` methods.  The functions are ordinary Go, parsed and checked
+// as part of the package's generated file (src/link/stdlib.js), so both
+// backends compile the same code.
+
+import {
+	importsFor,
+	mentionsTypeParam,
+	TypeSpeller,
+	walkNodes,
+} from "./gen-types.js";
+
+const ERRORS_PATH = "errors";
+const NOT_POINTER =
+	"errors.As: second argument must be a non-nil pointer to a type that implements error or to any interface type";
+
+// The names the file imports `errors` as.
+function errorsAliases(program) {
+	const aliases = new Set();
+	for (const imp of program.imports ?? [])
+		for (const spec of imp.imports)
+			if (spec.path === ERRORS_PATH && spec.alias !== "_")
+				aliases.add(spec.alias ?? "errors");
+	return aliases;
+}
+
+const isAsRef = (node, aliases) =>
+	node.kind === "SelectorExpr" &&
+	node.expr?.kind === "Ident" &&
+	node.expr._type?.kind === "namespace" &&
+	aliases.has(node.expr.name) &&
+	node.field === "As";
+
+const isAsCall = (node, aliases) =>
+	node.kind === "CallExpr" && isAsRef(node.func, aliases);
+
+// Marks `call` to call the generated function `name`.  The function takes the
+// typed pointer: the target is not boxed into an interface the way
+// errors.As's `any` parameter asked.
+function markCall(call, name) {
+	call.func._genEntry = name;
+	const arg = call.args[1];
+	arg._ifaceBox = undefined;
+	arg._ifaceSrc = undefined;
+	arg._ifaceNamedType = undefined;
+	arg._ifacePtrFields = undefined;
+}
+
+// One function per distinct target type; `tparams` ("[T any]") makes it the
+// shared function for targets that are a type parameter.
+function asFunction(name, target, tparams = "") {
+	return `func ${name}${tparams}(err error, target *${target}) bool {
+	if target == nil {
+		panic("errors: target must be a non-nil pointer")
+	}
+	for err != nil {
+		if v, ok := err.(${target}); ok {
+			*target = v
+			return true
+		}
+		if a, ok := err.(interface{ As(any) bool }); ok && a.As(target) {
+			return true
+		}
+		switch u := err.(type) {
+		case interface{ Unwrap() error }:
+			err = u.Unwrap()
+		case interface{ Unwrap() []error }:
+			for _, e := range u.Unwrap() {
+				if e != nil && ${name}${tparams ? "[T]" : ""}(e, target) {
+					return true
+				}
+			}
+			return false
+		default:
+			return false
+		}
+	}
+	return false
+}`;
+}
+
+// The `errors.As` calls of the programs, and a diagnostic for each use of
+// errors.As that is not a call.
+function findSites(programs) {
+	const sites = [];
+	const diagnostics = [];
+	for (const program of programs) {
+		const aliases = errorsAliases(program);
+		if (aliases.size === 0) continue;
+		const callees = new Set();
+		const refs = [];
+		walkNodes(program.decls, (node) => {
+			if (isAsCall(node, aliases)) {
+				sites.push({ call: node, program });
+				callees.add(node.func);
+			} else if (isAsRef(node, aliases)) {
+				refs.push(node);
+			}
+		});
+		for (const node of refs)
+			if (!callees.has(node))
+				diagnostics.push({
+					program,
+					node: node.expr,
+					message: "errors.As cannot be used as a value",
+					hint: "call errors.As directly",
+				});
+	}
+	return { sites, diagnostics };
+}
+
+// What a call's target type allows: { base } for a target to generate for, or
+// { message, hint } for one the generator rejects.
+function classifyTarget(call) {
+	const argType = call.args[1]?._type;
+	if (argType?.kind !== "pointer") return { message: NOT_POINTER };
+	const base = argType.base;
+	if (base?.kind === "interface" && !base.name && base.methods?.size > 0)
+		return {
+			message:
+				"errors.As with a target of an anonymous interface type is not yet available",
+			hint: "declare a named interface type for the target",
+		};
+	if (base?.kind !== "typeParam" && mentionsTypeParam(base))
+		return {
+			message:
+				"errors.As with a target that mentions a type parameter is not yet available",
+			hint: "use a target that is a type parameter itself, or a concrete type",
+		};
+	return { base };
+}
+
+// Generates the `errors.As` functions for a package's call sites.  Returns
+// null when it has none; otherwise { body, imports, diagnostics, link } and
+// marks each call's SelectorExpr with `_genEntry`.
+export function generateErrorsAs(programs, _checker, pkgName) {
+	const { sites, diagnostics } = findSites(programs);
+	if (sites.length + diagnostics.length === 0) return null;
+	const qualifiers = new Map();
+	const speller = new TypeSpeller(pkgName, qualifiers, programs);
+	const prefix = `gfe_${String(pkgName).replace(/[^A-Za-z0-9_]/g, "_")}_as_`;
+	const names = new Map(); // spelled target -> function name
+	const out = [];
+	const sharedSites = []; // targets that are a type parameter
+	for (const { call, program } of sites) {
+		const { base, message, hint } = classifyTarget(call);
+		let target;
+		try {
+			if (base?.kind === "typeParam") sharedSites.push(call);
+			else if (base) target = speller.spell(base);
+		} catch (e) {
+			diagnostics.push({
+				program,
+				node: call.func.expr,
+				message: `errors.As: ${e.message}`,
+			});
+			continue;
+		}
+		if (!base) {
+			diagnostics.push({ program, node: call.func.expr, message, hint });
+			continue;
+		}
+		if (target === undefined) continue;
+		if (!names.has(target)) {
+			names.set(target, `${prefix}${names.size}`);
+			out.push(asFunction(names.get(target), target));
+		}
+		markCall(call, names.get(target));
+	}
+	const sharedName = `${prefix}t`;
+	if (sharedSites.length > 0) out.push(asFunction(sharedName, "T", "[T any]"));
+	for (const call of sharedSites) markCall(call, sharedName);
+	// The shared function is generic: once it is checked, its call sites take
+	// the type arguments the checker would have inferred.
+	const link = (chk) => {
+		const generic = chk.globals.symbols.get(sharedName);
+		for (const call of sharedSites) {
+			const typeArgs = [call.args[1]._type.base];
+			for (const n of [call, call.func]) {
+				n._typeArgs = typeArgs;
+				n._genericFnType = generic;
+			}
+		}
+	};
+	return {
+		body: out.join("\n\n"),
+		imports: importsFor(qualifiers),
+		diagnostics,
+		link,
+	};
+}