gofront 1.8.0 → 1.9.1

package/src/typechecker/index.js

@@ -21,12 +21,15 @@ import { setupGlobals } from "./stdlib/index.js";
 import { terminationMethods } from "./termination.js";
 import {
 	ANY,
+	BOOL,
 	defaultType,
 	ERROR,
 	INTRINSICS,
 	isAny,
 	isBool,
 	isVoid,
+	NATIVES,
+	promotedMethods,
 	Scope,
 	TAINTED_ANY,
 	TypeCheckError,
@@ -39,6 +42,7 @@ import {
 const TEMPL_NODE_CHECKS = {
 	TemplElement: "_checkTemplElement",
 	TemplExpr: "_checkTemplLeaf",
+	TemplChildren: "_checkTemplChildren",
 	TemplComponent: "_checkTemplLeaf",
 	TemplIf: "_checkTemplIf",
 	TemplFor: "_checkTemplFor",
@@ -96,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
@@ -105,6 +153,7 @@ export class TypeChecker {
 		this.universe = new Scope();
 		this.globals = new Scope(this.universe);
 		this.errors = [];
+		this._reportedAt = new WeakMap();
 		this.warnings = []; // non-fatal diagnostics (e.g. boundary-call-in-loop hints)
 		this.target = "js";
 		this.pkgName = null;
@@ -117,9 +166,17 @@ export class TypeChecker {
 		this._typeSwitchDepth = 0; // for rejecting fallthrough in type switch
 		this._deferCount = 0; // tracks defer usage in current function body
 		this._imports = []; // tracked imports for unused-import detection
+		// Lazy body checking (Go-source stdlib): with `lazyBodies` set, checkAll
+		// types declarations only and `checkBody` types a function or method
+		// body when it is first reached.
+		this.lazyBodies = false;
+		this.stats = { bodiesChecked: 0 };
+		this._lazyBodies = new Map(); // FuncDecl/MethodDecl -> its program
 		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);
@@ -174,8 +231,12 @@ export class TypeChecker {
 				this._ambiguousImported.add(prior);
 				this._ambiguousImported.add(type);
 			}
-			this.types.set(name, type);
+			// A renamed type (`Pt` declared as `Pt$$b`) never takes the bare name:
+			// another package owns it, and this package's own declaration would
+			// 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);
 		}
 	}
 
@@ -255,6 +316,14 @@ export class TypeChecker {
 	}
 
 	err(msg, node, hint = null) {
+		// One diagnostic per root cause: a node revisited by a later pass (a
+		// signature resolved at declaration and again in the body) reports once.
+		if (node && typeof node === "object") {
+			const seen = this._reportedAt.get(node) ?? new Set();
+			this._reportedAt.set(node, seen);
+			if (seen.has(msg)) return TAINTED_ANY;
+			seen.add(msg);
+		}
 		const e = new TypeCheckError(
 			msg,
 			node,
@@ -362,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);
@@ -686,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);
@@ -702,7 +788,11 @@ export class TypeChecker {
 		const { cycles } = orderPackageInits(programs);
 		for (const c of cycles) {
 			const owner = programs.find((p) =>
-				p.decls?.some((d) => d.kind === "VarDecl" && d.decls?.includes(c.spec)),
+				p.decls?.some(
+					(d) =>
+						(d.kind === "VarDecl" || d.kind === "ConstDecl") &&
+						d.decls?.includes(c.spec),
+				),
 			);
 			if (owner) this._setCurrentFile(owner);
 			this.err(c.message, c.spec);
@@ -725,6 +815,11 @@ export class TypeChecker {
 			this._setCurrentFile(p);
 			for (const d of p.decls) {
 				if (
+					this.lazyBodies &&
+					(d.kind === "FuncDecl" || d.kind === "MethodDecl")
+				)
+					this._deferBody(d, p);
+				else if (
 					d.kind === "FuncDecl" ||
 					d.kind === "MethodDecl" ||
 					d.kind === "TemplDecl"
@@ -735,31 +830,133 @@ export class TypeChecker {
 		}
 	}
 
+	// Lazy mode: validate what does not need the body now, check it on demand.
+	_deferBody(decl, program) {
+		if (decl.intrinsic) this._checkIntrinsic(decl);
+		if (decl.native) this._checkNative(decl);
+		this._lazyBodies.set(decl, program);
+	}
+
+	// Types the body of a function or method deferred by `lazyBodies`; a
+	// declaration checked already (or not deferred) is left alone.
+	checkBody(decl) {
+		const program = this._lazyBodies.get(decl);
+		if (!program) return;
+		this._lazyBodies.delete(decl);
+		this._setCurrentFile(program);
+		this.checkTopDecl(decl, this.globals);
+	}
+
 	// ── Shared pass helpers ──────────────────────────────────────
 
+	// Instances made while types were collected (`struct{ Inner[int] }`) have
+	// no methods yet, and a type embedding another embedder (`Deep` over `E`
+	// over `Base`) needs the inner promotion first, so repeat until nothing
+	// new is promoted.
 	_promoteEmbeddedMethods() {
+		const structs = [];
 		for (const type of this.types.values()) {
-			this._promoteEmbeddedInto(type.underlying);
-			for (const inst of type._generic?._instances?.values() ?? [])
-				this._promoteEmbeddedInto(inst.underlying);
+			structs.push(type.underlying);
+			for (const inst of type._generic?._instances?.values() ?? []) {
+				this._syncInstanceMethods(type._generic, inst);
+				structs.push(inst.underlying);
+			}
 		}
-	}
-
+		const count = () =>
+			structs.reduce((n, st) => n + (st?.fields?.size ?? 0), 0);
+		let before;
+		let changed;
+		do {
+			before = count();
+			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;
-			if (base?.kind !== "struct" || !base.methods) continue;
-			for (const [mName, mType] of base.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;
@@ -801,6 +998,9 @@ export class TypeChecker {
 			this.globals.define(decl.name, named);
 			return;
 		}
+		// A type declared inside a function is registered before its fields
+		// resolve so `next *L` finds it; package-level types already are.
+		this._registerLocalTypePlaceholder(decl);
 		let underlying = this.resolveTypeNode(decl.type, this.globals);
 		// `type W V` with V a named array: W's underlying type is V's array.
 		if (!decl.isAlias && underlying.kind === "named") {
@@ -817,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;
@@ -836,6 +1038,14 @@ export class TypeChecker {
 		this.globals.define(decl.name, named);
 	}
 
+	_registerLocalTypePlaceholder(decl) {
+		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);
+	}
+
 	// type A[P any] = T[P] — Go 1.24 generic alias. The declaration is a
 	// template only: each instantiation A[X] substitutes X into the aliased
 	// type and resolves to exactly that type (no new named type).
@@ -888,6 +1098,9 @@ export class TypeChecker {
 	_registerFuncDecl(decl, funcType, typeParamTypes) {
 		if (this.globals.symbols.has(decl.name) && decl.name !== "init")
 			this.err(`${decl.name} redeclared in this block`, decl);
+		if (decl.native) funcType.native = decl.native;
+		this._funcDeclNames ??= new Set();
+		this._funcDeclNames.add(decl.name);
 		if (typeParamTypes) {
 			this.globals.define(decl.name, {
 				kind: "generic",
@@ -932,6 +1145,9 @@ export class TypeChecker {
 	}
 
 	_attachNonGenericMethod(decl, funcType) {
+		// Codegen of an importing package reads the body of a Go-source
+		// method (does it accept a nil receiver?).
+		funcType._methodDecl = decl;
 		const recvType = this.resolveTypeNodeName(decl.recvType, this.globals);
 		const base = recvType?.underlying ?? recvType;
 		if (base?.kind === "struct") {
@@ -1008,12 +1224,26 @@ export class TypeChecker {
 
 	_checkTemplElement(n, scope) {
 		for (const a of n.attrs ?? []) {
-			if (a.kind === "expr" || a.kind === "cond-bool")
-				this._checkTemplExpr(a, a.tokens, scope);
+			if (a.kind === "expr") this._checkTemplExpr(a, a.tokens, scope);
+			else if (a.kind === "cond-bool") this._checkTemplCondAttr(a, scope);
 		}
 		this._checkTemplNodes(n.children, scope);
 	}
 
+	// `name?={ cond }` sets the attribute when `cond` is true.
+	_checkTemplCondAttr(a, scope) {
+		const t = this._checkTemplExpr(a, a.tokens, scope);
+		if (t && !isBool(t) && !isAny(t))
+			this.err(`Conditional attribute '${a.name}' must be bool`, a.expr);
+	}
+
+	// `{ name... }` names a variadic parameter. A templ without a `children`
+	// parameter may still write `{ children... }` (it mounts nothing).
+	_checkTemplChildren(n, scope) {
+		if (n.name === "children" && !scope.lookup("children")) return;
+		this._checkTemplExpr(n, [], scope);
+	}
+
 	_checkTemplLeaf(n, scope) {
 		this._checkTemplExpr(n, n.tokens, scope);
 	}
@@ -1028,8 +1258,13 @@ export class TypeChecker {
 
 	_checkTemplSwitch(n, scope) {
 		this._checkTemplExpr(n, n.exprTokens, scope);
+		// A tag that failed to parse leaves `n.expr` unset: not a tagless switch.
+		const tagless = !n.exprTokens?.length;
 		for (const c of n.cases ?? []) {
 			this._checkTemplExpr(c, c.caseTokens, scope);
+			for (const e of c.exprs?.slice(1) ?? []) this.checkExpr(e, scope);
+			if (n.expr || tagless)
+				for (const e of c.exprs ?? []) this._checkCaseValue(n.expr, e);
 			this._checkTemplNodes(c.body, scope);
 		}
 	}
@@ -1147,8 +1382,27 @@ export class TypeChecker {
 			);
 	}
 
+	_checkNative(decl) {
+		if (!this.isStdlib && !this.nativesChecked)
+			return this.err(
+				"//gofront:native is reserved for the standard library",
+				decl,
+			);
+		if (decl.kind !== "FuncDecl")
+			return this.err(
+				`native '${decl.native}' must mark a function, not a method`,
+				decl,
+			);
+		if (!NATIVES.has(decl.native))
+			return this.err(`unknown native '${decl.native}'`, decl);
+		if (decl._bodyless)
+			this.err(`native '${decl.native}' must have a Go body`, decl);
+	}
+
 	checkFuncDecl(decl, outer) {
+		this.stats.bodiesChecked++;
 		if (decl.intrinsic) this._checkIntrinsic(decl);
+		if (decl.native) this._checkNative(decl);
 		if (
 			(this.target === "wasm" || this.target === "both") &&
 			(decl.async || decl.isAsync)
@@ -1173,6 +1427,8 @@ export class TypeChecker {
 	}
 
 	checkMethodDecl(decl, outer) {
+		this.stats.bodiesChecked++;
+		if (decl.native) this._checkNative(decl);
 		if (
 			(this.target === "wasm" || this.target === "both") &&
 			(decl.async || decl.isAsync)
@@ -1199,7 +1455,13 @@ export class TypeChecker {
 			inner.define(p.name, this._paramType(p, inner));
 		}
 		const returnType = this._setupFuncReturnType(decl, inner);
-		this._runFuncBody(decl, inner, returnType);
+		const savedRecvGeneric = this._recvGeneric;
+		this._recvGeneric = recvNamedType?._generic;
+		try {
+			this._runFuncBody(decl, inner, returnType);
+		} finally {
+			this._recvGeneric = savedRecvGeneric;
+		}
 		this._checkMissingReturn(decl, returnType, "method");
 	}
 
@@ -1210,14 +1472,19 @@ export class TypeChecker {
 		return p.variadic ? { kind: "slice", elem: t } : t;
 	}
 
-	_injectTypeParams(decl, inner, outer) {
+	_injectTypeParams(decl, inner, _outer) {
 		if (!decl.typeParams) return;
-		for (const tp of decl.typeParams) {
-			const constraint = tp.constraint
-				? this.resolveTypeNode(tp.constraint, outer)
-				: ANY;
-			inner.define(tp.name, { kind: "typeParam", name: tp.name, constraint });
-		}
+		// Declare every parameter first so a constraint may mention one that
+		// comes later in the list (`[S ~[]E, E any]`).
+		const params = decl.typeParams.map((tp) => {
+			const t = { kind: "typeParam", name: tp.name, constraint: ANY };
+			inner.define(tp.name, t);
+			return t;
+		});
+		decl.typeParams.forEach((tp, i) => {
+			if (tp.constraint)
+				params[i].constraint = this.resolveTypeNode(tp.constraint, inner);
+		});
 	}
 
 	// Inside a method of `G[T]` the receiver is the instance `G[T]` over the
@@ -1258,7 +1525,11 @@ export class TypeChecker {
 	}
 
 	_checkMissingReturn(decl, returnType, kind) {
-		if (!isVoid(returnType) && !returnType._hasNamedReturns) {
+		if (
+			!decl._bodyless &&
+			!isVoid(returnType) &&
+			!returnType._hasNamedReturns
+		) {
 			if (!this._isTerminating(decl.body)) {
 				this.err(`missing return at end of ${kind} '${decl.name}'`, decl);
 			}
@@ -1281,21 +1552,7 @@ export class TypeChecker {
 		for (const spec of decl.decls) {
 			let type = spec.type ? this.resolveTypeNode(spec.type, scope) : null;
 			if (spec.value) {
-				const valTypes = spec.value.map((v) => this.checkExpr(v, scope));
-				const isTuple = valTypes.length === 1 && valTypes[0]?.kind === "tuple";
-				const valTypesFlat = isTuple ? valTypes[0].types : valTypes;
-				if (spec.names.length !== valTypesFlat.length) {
-					const vars =
-						spec.names.length === 1
-							? "1 variable"
-							: `${spec.names.length} variables`;
-					const vals = isTuple
-						? `returns ${valTypesFlat.length} values`
-						: valTypesFlat.length === 1
-							? "1 value"
-							: `${valTypesFlat.length} values`;
-					this.err(`assignment mismatch: ${vars} but ${vals}`, spec);
-				}
+				const valTypesFlat = this._varSpecValueTypes(spec, scope);
 				for (let i = 0; i < spec.names.length; i++) {
 					const vt = valTypesFlat[i] ?? ANY;
 					const varType = type ?? defaultType(vt) ?? ANY;
@@ -1318,6 +1575,45 @@ export class TypeChecker {
 		this._sharedAllocOk = savedSharedAlloc;
 	}
 
+	// The type of each value a `var` spec binds (a multi-value call or a
+	// comma-ok form spreads over several names); reports a count mismatch.
+	_varSpecValueTypes(spec, scope) {
+		const commaOk = this._checkVarCommaOk(spec, scope);
+		const valTypes = commaOk ?? spec.value.map((v) => this.checkExpr(v, scope));
+		const isTuple =
+			!commaOk && valTypes.length === 1 && valTypes[0]?.kind === "tuple";
+		const flat = isTuple ? valTypes[0].types : valTypes;
+		if (spec.names.length !== flat.length && !flat.some((t) => t?._tainted))
+			this._reportAssignMismatch(spec.names.length, flat.length, isTuple, spec);
+		return flat;
+	}
+
+	_reportAssignMismatch(nameCount, valueCount, isTuple, node) {
+		const vars = nameCount === 1 ? "1 variable" : `${nameCount} variables`;
+		const vals = isTuple
+			? `returns ${valueCount} values`
+			: valueCount === 1
+				? "1 value"
+				: `${valueCount} values`;
+		this.err(`assignment mismatch: ${vars} but ${vals}`, node);
+	}
+
+	// `var v, ok = m[k]` / `var v, ok = x.(T)`: the comma-ok forms yield the
+	// value and a bool. Returns their types, or null for any other spec.
+	_checkVarCommaOk(spec, scope) {
+		if (spec.names.length !== 2 || spec.value.length !== 1) return null;
+		const value = spec.value[0];
+		if (value.kind === "TypeAssertExpr") {
+			value._commaOk = true;
+			spec._commaOk = true;
+			return [this.checkExpr(value, scope), BOOL];
+		}
+		const stmt = { lhs: spec.names, rhs: spec.value };
+		const types = this._checkAssignCommaOkMap(stmt, scope);
+		if (types) spec._commaOk = true;
+		return types;
+	}
+
 	checkConstDecl(decl, scope) {
 		for (const spec of decl.decls) {
 			const valTypes = spec.value.map((v) => this.checkExpr(v, scope));
@@ -1335,6 +1631,14 @@ export class TypeChecker {
 						expr,
 						"constant declaration",
 					);
+				// `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);
 			}
 		}