gofront 1.9.0 → 1.9.1

package/src/typechecker/index.js

@@ -29,6 +29,7 @@ import {
 	isBool,
 	isVoid,
 	NATIVES,
+	promotedMethods,
 	Scope,
 	TAINTED_ANY,
 	TypeCheckError,
@@ -99,6 +100,50 @@ const JS_BUILTIN_CLASSES = new Set([
 	"WebAssembly",
 ]);
 
+// The promoted-method entry for candidate `cand`, reusing `prev` when
+// nothing changed so the method keeps its identity across passes. A pointer
+// method reached through an embedded pointer is in the value method set.
+function promotedEntry(cand, prev) {
+	if (cand.ambiguous) return { depth: cand.depth, ambiguous: true };
+	if (
+		!prev?.ambiguous &&
+		prev?.source === cand.source &&
+		prev.viaPtr === cand.viaPtr &&
+		prev.depth === cand.depth
+	)
+		return prev;
+	const mType =
+		cand.viaPtr && cand.source?._ptrRecv
+			? { ...cand.source, _ptrRecv: false }
+			: cand.source;
+	return { ...cand, mType };
+}
+
+// Offers every method of the embedded interface `iface` at depth 1.
+function offerInterfaceMethods(iface, offer) {
+	for (const [mName, mType] of iface.methods ?? [])
+		offer(mName, 1, mType, false);
+}
+
+// Replaces the promoted methods `old` with `next` in `methods`, leaving
+// the struct's own methods alone; returns whether anything changed.
+function applyPromotions(methods, old, next, isOwn) {
+	let changed = old.size !== next.size;
+	for (const [mName, prev] of old) {
+		const entry = next.get(mName);
+		if (entry?.mType) continue;
+		if (prev.mType && !isOwn(mName)) methods.delete(mName);
+		if (entry?.ambiguous !== prev.ambiguous || entry?.depth !== prev.depth)
+			changed = true;
+	}
+	for (const [mName, entry] of next) {
+		if (entry.ambiguous) continue;
+		if (old.get(mName)?.mType !== entry.mType) changed = true;
+		methods.set(mName, entry.mType);
+	}
+	return changed;
+}
+
 export class TypeChecker {
 	constructor() {
 		this.types = new Map(); // named types
@@ -130,6 +175,8 @@ export class TypeChecker {
 		this._constExprs = new Map(); // name -> AST initializer expr
 		this._importedConsts = new Map(); // dot-imported const name -> value
 		this._externalNames = new Set(); // package-scope names from .d.ts / npm definitions
+		this._importedTypes = new WeakSet(); // named types reached through an imported package
+		this._pendingConstraintUses = []; // constraint-interface checks waiting on a type declaration
 		this._setupGlobals();
 		// Register error as a named type (interface)
 		this.types.set("error", ERROR);
@@ -189,6 +236,7 @@ export class TypeChecker {
 			// otherwise reuse the imported placeholder. It is reached as `pkg.Pt`.
 			if (type.name === name) this.types.set(name, type);
 			this.types.set(`${pkgName}.${name}`, type);
+			this._importedTypes.add(type);
 		}
 	}
 
@@ -383,13 +431,17 @@ export class TypeChecker {
 
 		this._checkDirectivesAndImportsPass(programs);
 		this._registerConstExprs(programs);
+		this._registerVarSpecs(programs);
+		this._markConstraintPositions(programs);
 		this._collectTypesPass(programs);
+		this._flushConstraintUses();
 		this._collectFuncsPass(programs);
 		this._checkGlobalTypeNamesPass(programs);
 		this._promoteEmbeddedMethods();
 		this._collectVarsConstsPass(programs);
 		this._checkTopDeclsPass(programs);
 		this._reportInitCycles(programs);
+		this._flushConstraintUses();
 
 		if (this.target === "both") {
 			this._checkMutablePackageVars(programs);
@@ -707,6 +759,19 @@ export class TypeChecker {
 		}
 	}
 
+	// Package variables by name, so an array length such as `[len(base)]T`
+	// can use the type of one that is declared later.
+	_registerVarSpecs(programs) {
+		this._pkgVarSpecs = new Map();
+		for (const p of programs)
+			for (const d of p.decls)
+				if (d.kind === "VarDecl")
+					for (const spec of d.decls)
+						spec.names.forEach((name, index) => {
+							this._pkgVarSpecs.set(name, { spec, index, busy: false });
+						});
+	}
+
 	_collectVarsConstsPass(programs) {
 		for (const p of programs) {
 			this._setCurrentFile(p);
@@ -798,45 +863,100 @@ export class TypeChecker {
 			}
 		}
 		const count = () =>
-			structs.reduce(
-				(n, st) => n + (st?.methods?.size ?? 0) + (st?.fields?.size ?? 0),
-				0,
-			);
+			structs.reduce((n, st) => n + (st?.fields?.size ?? 0), 0);
 		let before;
+		let changed;
 		do {
 			before = count();
-			for (const st of structs) this._promoteEmbeddedInto(st);
-		} while (count() !== before);
+			changed = false;
+			for (const st of structs)
+				if (this._promoteEmbeddedInto(st)) changed = true;
+		} while (changed || count() !== before);
 	}
 
+	// Recomputes the methods `struct` gets from its embedded fields, as Go's
+	// method set: the shallowest method of each name wins, a method declared
+	// on the struct itself shadows every promoted one, and a pointer method
+	// reached through an embedded pointer belongs to the value method set.
+	// Returns whether the promoted methods changed.
 	_promoteEmbeddedInto(struct) {
-		if (struct?.kind !== "struct" || !struct._embeds) return;
-		for (const embed of struct._embeds) {
-			const inner = embed.kind === "pointer" ? embed.base : embed;
-			const base = inner.kind === "named" ? inner.underlying : inner;
-			// Fields of an embedded type declared after the embedder were not
-			// there when the embedder's fields were collected.
-			if (base?.kind === "struct" && struct.fields)
-				for (const [k, v] of base.fields)
-					if (!struct.fields.has(k)) struct.fields.set(k, v);
-			// A named non-struct type (`time.Duration`) keeps its methods on
-			// the named type itself.
-			const methods =
-				base?.kind === "struct"
-					? base.methods
-					: inner.kind === "named" && base?.kind !== "interface"
-						? inner.methods
-						: null;
-			if (!methods) continue;
-			for (const [mName, mType] of methods.entries()) {
-				if (!struct.methods.has(mName)) struct.methods.set(mName, mType);
-			}
+		if (struct?.kind !== "struct" || !struct._embeds) return false;
+		const old = promotedMethods.get(struct) ?? new Map();
+		const best = new Map();
+		for (const embed of struct._embeds)
+			this._offerEmbedMethods(struct, embed, best);
+		if (best.size === 0 && old.size === 0) return false;
+		struct.methods ??= new Map();
+		// A method declared on the struct (or set since the last pass) is
+		// not one this pass promoted.
+		const isOwn = (mName) =>
+			struct.methods.has(mName) &&
+			struct.methods.get(mName) !== old.get(mName)?.mType;
+		const next = new Map();
+		for (const [mName, cand] of best)
+			if (!isOwn(mName)) next.set(mName, promotedEntry(cand, old.get(mName)));
+		promotedMethods.set(struct, next);
+		return applyPromotions(struct.methods, old, next, isOwn);
+	}
+
+	// Adds the methods one embedded field offers to `best` (name -> the
+	// shallowest candidate), and copies its fields into the embedder.
+	_offerEmbedMethods(struct, embed, best) {
+		const isPtr = embed.kind === "pointer";
+		const inner = isPtr ? embed.base : embed;
+		const base = inner.kind === "named" ? inner.underlying : inner;
+		// Two candidates at the same depth make the name ambiguous, as does
+		// an ambiguous name of the embedded type.
+		const offer = (name, depth, source, viaPtr, ambiguous = false) => {
+			const cur = best.get(name);
+			if (!cur || depth < cur.depth)
+				best.set(name, { depth, source, viaPtr, ambiguous });
+			else if (depth === cur.depth) cur.ambiguous = true;
+		};
+		if (base?.kind === "struct") {
+			this._offerStructEmbed(struct, base, isPtr, offer);
+			return;
+		}
+		// An embedded interface (named, literal or `error`) promotes every
+		// method of its method set, as a value method.
+		if (base?.kind === "interface") {
+			if (!isPtr) offerInterfaceMethods(base, offer);
+			return;
+		}
+		// A named non-struct type (`time.Duration`) keeps its methods on the
+		// named type itself.
+		if (inner.kind === "named")
+			for (const [mName, mType] of inner.methods ?? [])
+				offer(mName, 1, mType, isPtr);
+	}
+
+	// Offers the methods of the embedded struct `base`, and copies its fields
+	// into the embedder.
+	_offerStructEmbed(struct, base, isPtr, offer) {
+		// Fields of an embedded type declared after the embedder were not
+		// there when the embedder's fields were collected.
+		if (struct.fields)
+			for (const [k, v] of base.fields)
+				if (!struct.fields.has(k)) struct.fields.set(k, v);
+		const innerPromoted = promotedMethods.get(base);
+		for (const [mName, mType] of base.methods ?? []) {
+			const p = innerPromoted?.get(mName);
+			offer(
+				mName,
+				1 + (p?.depth ?? 0),
+				p?.source ?? mType,
+				isPtr || Boolean(p?.viaPtr),
+			);
 		}
+		for (const [mName, p] of innerPromoted ?? [])
+			if (p.ambiguous) offer(mName, 1 + p.depth, null, false, true);
 	}
 
 	// ── Type collection ──────────────────────────────────────────
 
 	collectType(decl) {
+		// `type N interface{ ~int }` and `type D N` declare constraints.
+		this._markConstraintPos(decl.type);
 		if (decl.typeParams && decl.isAlias) {
 			this._collectGenericAlias(decl);
 			return;
@@ -897,8 +1017,10 @@ export class TypeChecker {
 			return;
 		}
 		const existing = this.types.get(decl.name);
+		// An imported package's type is never reused: a local declaration of
+		// the same name gets its own type and leaves `pkg.T` untouched.
 		const named =
-			existing?.kind === "named"
+			existing?.kind === "named" && !this._importedTypes.has(existing)
 				? existing
 				: { kind: "named", name: decl.name };
 		named.underlying = underlying;
@@ -917,7 +1039,8 @@ export class TypeChecker {
 	}
 
 	_registerLocalTypePlaceholder(decl) {
-		if (decl.isAlias || this.types.has(decl.name)) return;
+		const prior = this.types.get(decl.name);
+		if (decl.isAlias || (prior && !this._importedTypes.has(prior))) return;
 		const placeholder = { kind: "named", name: decl.name, underlying: null };
 		this.types.set(decl.name, placeholder);
 		this.globals.define(decl.name, placeholder);
@@ -1510,6 +1633,12 @@ export class TypeChecker {
 					);
 				// `const D Duration = 1` is a BigInt in JS.
 				if (spec.type && expr) this._tag64BitNode(this.resolveType(type), expr);
+				if (spec.type && expr)
+					this._tagFloat32Const(
+						this.resolveType(type),
+						valTypes[i] ?? valTypes[0],
+						expr,
+					);
 				scope.defineConst(name, type, expr);
 			}
 		}

package/src/typechecker/operand-text.js

@@ -16,6 +16,7 @@ function litText(node) {
 const PRINTERS = {
 	Ident: (n) => n.name,
 	BasicLit: litText,
+	ImagLit: (n) => `${n.value}i`,
 	ParenExpr: (n) => `(${exprText(n.expr)})`,
 	SelectorExpr: (n) => `${exprText(n.expr)}.${n.field}`,
 	UnaryExpr: (n) => `${n.op}${exprText(n.operand)}`,