gofront 1.9.0 → 1.9.2

package/src/typechecker/expressions.js

@@ -44,6 +44,7 @@ import {
 	UNTYPED_COMPLEX,
 	UNTYPED_FLOAT,
 	UNTYPED_INT,
+	UNTYPED_RUNE,
 	UNTYPED_STRING,
 	VOID,
 } from "./types.js";
@@ -71,7 +72,7 @@ function minMaxType(at) {
 // Each value is (self, name, expr, argTypes, scope) => returnType.
 const BUILTIN_CHECK = {
 	len: (s, n, e, at) => s._checkBuiltinLen(n, e, at),
-	cap: (s, n, e, at) => s._checkBuiltinLen(n, e, at),
+	cap: (s, n, e, at, sc) => s._checkBuiltinLen(n, e, at, sc),
 	append: (s, _n, e, at) => {
 		const st = at[0] ?? ANY;
 		if (isArray(st)) {
@@ -93,6 +94,11 @@ const BUILTIN_CHECK = {
 					s._rejectSeqAsSlice(at[i], e.args[i], "a spread argument");
 				if (!e.args[i]._spread && at[i]) {
 					if (is64) e.args[i]._is64Bit = true;
+					s._tagComplexConst(
+						s.resolveType(sb.elem),
+						s.resolveType(at[i]),
+						e.args[i],
+					);
 					s._markIfaceBox(
 						s.resolveType(sb.elem),
 						s.resolveType(at[i]),
@@ -106,7 +112,10 @@ const BUILTIN_CHECK = {
 	copy: (s, _n, e, at) => s._checkBuiltinCopy(e, at),
 	delete: (s, _n, e, at) => {
 		const mt = s._deepUnderlying(at[0]);
-		if (mt?.kind === "map" && e.args[1]) s._markIfaceKey(mt, e.args[1], at[1]);
+		if (mt?.kind === "map" && e.args[1]) {
+			s._tagFloat32Const(s.resolveType(mt.key), at[1], e.args[1]);
+			s._markIfaceKey(mt, e.args[1], at[1]);
+		}
 		return VOID;
 	},
 	make: (s, _n, e, _at, sc) => {
@@ -117,6 +126,8 @@ const BUILTIN_CHECK = {
 		// `make(S, n)` with S a type parameter makes its core type.
 		const core = made.kind === "typeParam" ? s._coreType(made, sc) : null;
 		if (core) ta._coreType = core;
+		for (const size of e.args.slice(1, 3))
+			s._checkIntegerConstOperand(size, "size", sc);
 		return made;
 	},
 	new: (s, _n, e, _at, sc) => {
@@ -134,14 +145,37 @@ const BUILTIN_CHECK = {
 	},
 	recover: () => ANY,
 	error: () => ERROR,
-	min: (_s, _n, _e, at) => minMaxType(at),
-	max: (_s, _n, _e, at) => minMaxType(at),
+	min: (s, _n, e, at) => s._checkMinMax(e, at),
+	max: (s, _n, e, at) => s._checkMinMax(e, at),
 	clear: () => VOID,
 	complex: (s, _n, e, at) => s._checkBuiltinComplex(e, at),
 	real: (s, n, e, at) => s._checkBuiltinRealImag(n, e, at),
 	imag: (s, n, e, at) => s._checkBuiltinRealImag(n, e, at),
 };
 
+// Type kinds that are never valid as an index, slice bound or `make` size.
+const NON_INTEGER_KINDS = new Set([
+	"struct",
+	"pointer",
+	"slice",
+	"map",
+	"func",
+	"array",
+	"interface",
+	"simd",
+]);
+
+// Basic types that are never valid as an index, slice bound or `make` size.
+const NON_INTEGER_BASICS = new Set([
+	"float32",
+	"float64",
+	"complex64",
+	"complex128",
+	"bool",
+	"string",
+	"any",
+]);
+
 // Method-name dispatch for _checkExpr — string values add no static call edges.
 const CHECK_EXPR_DELEGATE = {
 	UnaryExpr: "_checkUnaryExpr",
@@ -171,7 +205,7 @@ export const expressionCheckMethods = {
 			case "BasicLit": {
 				switch (expr.litKind) {
 					case "INT":
-						return UNTYPED_INT;
+						return expr.rune ? UNTYPED_RUNE : UNTYPED_INT;
 					case "FLOAT":
 						return UNTYPED_FLOAT;
 					case "STRING":
@@ -260,6 +294,10 @@ export const expressionCheckMethods = {
 					this._retypeUntypedShift(lt, rt, expr.right);
 					this._retypeUntypedShift(rt, lt, expr.left);
 				}
+				this._tagFloat32Const(lt, rt, expr.right);
+				this._tagFloat32Const(rt, lt, expr.left);
+				this._tagComplex64Const(lt, rt, expr.right);
+				this._tagComplex64Const(rt, lt, expr.left);
 				if (is64BitInt(lt) && rt?.kind === "untyped" && expr.right)
 					expr.right._is64Bit = true;
 				if (is64BitInt(rt) && lt?.kind === "untyped" && expr.left)
@@ -310,7 +348,8 @@ export const expressionCheckMethods = {
 
 	_checkBoolUnaryOp(ot, expr) {
 		if (!isBool(ot) && !isAny(ot)) this.err("! requires bool", expr);
-		return BOOL;
+		// `!` keeps an untyped or defined bool type.
+		return isBool(ot) ? ot : BOOL;
 	},
 
 	_checkNumericUnaryOp(ot, expr) {
@@ -826,6 +865,15 @@ export const expressionCheckMethods = {
 	// with its dynamic type, so `L("1")`, `N(1)`, `"1"` and `1` stay distinct.
 	// A named basic value is boxed first, exactly as in any interface
 	// conversion; other values are keyed as they are.
+	// Untyped constant operands take the result type, so a float32 result
+	// rounds them like the typed operands.
+	_checkMinMax(e, at) {
+		const rt = minMaxType(at);
+		for (let i = 0; i < e.args.length; i++)
+			this._tagFloat32Const(rt, at[i], e.args[i]);
+		return rt;
+	},
+
 	_markIfaceKey(mapType, node, srcType) {
 		const key = this.resolveType(mapType.key);
 		const kb = key?.kind === "named" ? this.resolveType(key.underlying) : key;
@@ -866,6 +914,8 @@ export const expressionCheckMethods = {
 		if (bt?._tainted) return TAINTED_ANY;
 		if (isAny(bt)) return ANY;
 		const btu = this._coreUnderlying(bt, scope);
+		if (btu.kind !== "map")
+			this._checkIntegerConstOperand(expr.index, "index", scope);
 		if (btu.kind === "slice" || btu.kind === "array") {
 			this._checkArrayBoundsExpr(btu, bt, expr, scope);
 			return btu.elem;
@@ -955,15 +1005,61 @@ export const expressionCheckMethods = {
 		return t.base;
 	},
 
+	// An index, slice bound or `make` size that is a constant must be an
+	// integer (`s[1 == 1]`, `make([]int, "a")`).
+	// A typed operand must have an integer type too (`s[f]` with `f float64`).
+	_checkIntegerConstOperand(operand, what, scope) {
+		const kind = this._nonIntegerConst(operand, scope);
+		if (kind) {
+			this.err(
+				`invalid argument: ${what} ${exprText(operand)} (${kind}) must be integer`,
+				operand,
+			);
+			return;
+		}
+		const t = operand?._type;
+		if (!this._isNonIntegerType(t, scope)) return;
+		this.err(
+			`invalid argument: ${what} ${exprText(operand)} (${operandKind(operand, typeStr(t), false)}) must be integer`,
+			operand,
+		);
+	},
+
+	// Whether `t` is a type (or a defined type over one) that is not an
+	// integer: a float, complex, bool, string, `any`, struct, pointer, slice,
+	// map, func, array, interface, simd vector or a type parameter whose type
+	// set is not all integers.  Untyped constants are judged by
+	// `_nonIntegerConst`, so only untyped non-integers that reach here
+	// (`s[a == b]`) count.
+	_isNonIntegerType(t, scope) {
+		if (!t || t._tainted) return false;
+		// A type parameter is an integer only when every type in its type set
+		// is (`~int | ~uint8`); `any`, `comparable` and method-only
+		// constraints have no integer type set.
+		if (t.kind === "typeParam") {
+			const terms = this._constraintTerms(t.constraint, new Set(), scope);
+			return !(terms?.length > 0 && terms.every(isInteger));
+		}
+		if (t.kind === "untyped")
+			return (
+				t.base === "bool" || t.base === "string" || t.base === "complex128"
+			);
+		const u = this._deepUnderlying(t);
+		if (u?.kind === "basic") return NON_INTEGER_BASICS.has(u.name);
+		return NON_INTEGER_KINDS.has(u?.kind);
+	},
+
 	_checkSliceExpr(expr, scope) {
 		const bt = this._derefArrayPtr(
 			expr,
 			"expr",
 			this.checkExpr(expr.expr, scope),
 		);
-		if (expr.low) this.checkExpr(expr.low, scope);
-		if (expr.high) this.checkExpr(expr.high, scope);
-		if (expr.max) this.checkExpr(expr.max, scope);
+		for (const bound of [expr.low, expr.high, expr.max]) {
+			if (!bound) continue;
+			this.checkExpr(bound, scope);
+			this._checkIntegerConstOperand(bound, "index", scope);
+		}
 		if (bt?._tainted) return TAINTED_ANY;
 		if (isAny(bt)) return ANY;
 		const btu = this._coreUnderlying(bt, scope);
@@ -1070,6 +1166,16 @@ export const expressionCheckMethods = {
 		// `any(x)` / `error(x)`: box x as an implicit conversion would.
 		this._markIfaceBox(targetType, srcType, expr.expr);
 		this._rejectNilConversion(srcType, targetType, expr);
+		if (this._checkIfaceConversion(srcType, targetType, expr, expr.expr))
+			return targetType;
+		if (
+			srcType &&
+			targetType &&
+			!isAny(srcType) &&
+			!isAny(targetType) &&
+			this._checkIfaceTargetConversion(srcType, targetType, expr.expr)
+		)
+			return targetType;
 		const srcResolved =
 			srcType?.kind === "named" ? srcType.underlying : srcType;
 		const tgtResolved =
@@ -1090,6 +1196,8 @@ export const expressionCheckMethods = {
 				expr,
 			);
 		}
+		// `complex64(1 + 0.01i)`: the constant's components round to float32.
+		this._tagComplex64Const(targetType, srcType, expr.expr);
 		if (tgtResolved?.kind === "slice")
 			this._rejectSeqAsSlice(srcType, expr.expr, "a slice conversion");
 		if (this._isMutualArraySlice(tgtResolved, srcResolved)) {
@@ -1138,8 +1246,25 @@ export const expressionCheckMethods = {
 		return true;
 	},
 
+	// `I(x)` with I an interface type converts exactly when x is assignable to
+	// I, so the method-set check (and its wording) is the assignment one.
+	_checkIfaceTargetConversion(srcType, targetType, operand) {
+		// `error("msg")` builds an error value (GoFront extension).
+		if (targetType === ERROR && isString(srcType)) return false;
+		const base = this.resolveType(
+			targetType.kind === "named" ? targetType.underlying : targetType,
+		);
+		if (base?.kind !== "interface" || !operand) return false;
+		this.assertAssignable(targetType, srcType, operand, "conversion");
+		return true;
+	},
+
 	_checkConversionValidity(srcType, targetType, expr) {
+		if (this._checkIfaceConversion(srcType, targetType, expr, expr.args?.[0]))
+			return;
 		if (!srcType || !targetType || isAny(srcType) || isAny(targetType)) return;
+		if (this._checkIfaceTargetConversion(srcType, targetType, expr.args?.[0]))
+			return;
 		const srcResolved = srcType.kind === "named" ? srcType.underlying : srcType;
 		const tgtResolved =
 			targetType.kind === "named" ? targetType.underlying : targetType;
@@ -1813,6 +1938,14 @@ export const expressionCheckMethods = {
 			const node = expr._multiForward ? null : expr.args[i];
 			this.assertAssignable(targetParam, argTypes[i], node, "argument");
 		}
+		// `g(f())`: per-element box marks for lowering to split the forward.
+		if (
+			expr._multiForward &&
+			!fnType.variadic &&
+			!this._skipIfaceMark &&
+			fnType.params.length === argTypes.length
+		)
+			this._markForwardedElems(fnType.params, argTypes, expr.args[0]);
 
 		this._checkSimdLaneArgs(expr, scope);
 	},
@@ -1878,7 +2011,28 @@ export const expressionCheckMethods = {
 		return null;
 	},
 
-	_checkBuiltinLen(name, expr, argTypes) {
+	_capOperandKind(operand, type) {
+		const untypedConst = type?.kind === "untyped" && type.base !== "nil";
+		return untypedConst
+			? operandKind(operand, type.base, true)
+			: operandKind(operand, typeStr(type), false);
+	},
+
+	// `cap` takes a slice or an array (a pointer to an array is dereferenced
+	// before this check). A type parameter needs a slice or array core type;
+	// one with no single core type is left to instantiation. Unknown and
+	// `any` operands (JS interop) are not judged.
+	_capOperandOk(t, scope) {
+		if (!t || t._tainted || isAny(t)) return true;
+		if (t.kind === "typeParam") {
+			const core = this._coreType(t, scope);
+			return !core || core.kind === "slice" || core.kind === "array";
+		}
+		const kind = this._deepUnderlying(t)?.kind;
+		return kind === "slice" || kind === "array";
+	},
+
+	_checkBuiltinLen(name, expr, argTypes, scope) {
 		this._rejectSeqAsSlice(argTypes[0], expr.args?.[0], `${name}()`);
 		const operand = expr.args?.[0];
 		if (expr.args?.length === 1)
@@ -1891,17 +2045,14 @@ export const expressionCheckMethods = {
 			if (expr.args.length === 1) expr.args[0] = operand;
 		}
 		if (name === "cap") {
-			if (
-				(argTypes[0]?.underlying ?? argTypes[0])?.kind === "map" ||
-				isString(argTypes[0])
-			) {
+			if (sharedInfo(argTypes[0])) {
 				this.err(
-					`invalid argument: ${exprText(expr.args?.[0])} (${operandKind(expr.args?.[0], typeStr(argTypes[0]), false)}) for cap`,
+					`cannot use cap() on ${typeStr(argTypes[0])}: shared buffers have a fixed size; use len()`,
 					expr,
 				);
-			} else if (sharedInfo(argTypes[0])) {
+			} else if (!this._capOperandOk(argTypes[0], scope)) {
 				this.err(
-					`cannot use cap() on ${typeStr(argTypes[0])}: shared buffers have a fixed size; use len()`,
+					`invalid argument: ${exprText(expr.args?.[0])} (${this._capOperandKind(expr.args?.[0], argTypes[0])}) for cap`,
 					expr,
 				);
 			}
@@ -1935,6 +2086,9 @@ export const expressionCheckMethods = {
 					expr,
 				);
 			}
+			// An untyped operand takes type float32 (`complex(f, 0.01)`).
+			this._tagFloat32Const(FLOAT32, crt, expr.args[0]);
+			this._tagFloat32Const(FLOAT32, cit, expr.args[1]);
 			return COMPLEX64;
 		}
 		return COMPLEX128;

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)}`,