gofront 1.6.1 → 1.8.0

package/src/typechecker/assignability.js

@@ -1,6 +1,7 @@
 // Assignability, binary result types, and interface satisfaction.
 // Installed as a mixin on TypeChecker.prototype.
 
+import { constIntValue } from "./const-fold.js";
 import { sharedInfo } from "./stdlib/shared.js";
 import {
 	ANY,
@@ -10,7 +11,9 @@ import {
 	FLOAT64,
 	isAny,
 	isComplex,
+	isComplex64,
 	isComplexOrNumeric,
+	isInteger,
 	isNil,
 	isNumeric,
 	isPointer,
@@ -27,6 +30,16 @@ import {
 	UNTYPED_INT,
 } from "./types.js";
 
+// Unnamed type literal kinds for Go's "identical underlying types" assignability rule.
+const TYPE_LITERAL_KINDS = new Set([
+	"slice",
+	"map",
+	"func",
+	"pointer",
+	"array",
+	"struct",
+]);
+
 /** @typedef {import('./index.js').TypeChecker} TypeChecker */
 
 // Untyped constant assignability: maps source.base → Set of compatible target.name values
@@ -69,6 +82,8 @@ export const assignabilityMethods = {
 		if (isAny(lt) || isAny(rt)) return ANY;
 		if (isComplex(lt) || isComplex(rt))
 			return this._binaryResultTypeComplex(op, lt, rt, node);
+		if ((op === "<<" || op === ">>") && isNumeric(lt) && isNumeric(rt))
+			return this._binaryResultTypeShift(op, lt, rt, node);
 		if (isNumeric(lt) && isNumeric(rt))
 			return this._binaryResultTypeNumeric(lt, rt);
 		if (isString(lt) && isString(rt) && op === "+")
@@ -78,6 +93,37 @@ export const assignabilityMethods = {
 		return ANY;
 	},
 
+	// A shift has the type of its left operand; the count may be any integer
+	// type or an untyped constant representable as uint.
+	_binaryResultTypeShift(_op, lt, rt, node) {
+		if (node) this.checkShiftCount(rt, node.right);
+		if (node && lt.kind !== "untyped" && !isInteger(lt))
+			this.err(`shifted operand ${typeStr(lt)} must be integer`, node.left);
+		return lt;
+	},
+
+	// Reports a shift count that is not an integer or is a negative constant.
+	checkShiftCount(rt, countExpr) {
+		const v = this._constValue(countExpr);
+		if (v) {
+			const n = constIntValue(v);
+			if (n === null) {
+				this.err(
+					`invalid shift count ${typeStr(rt)} constant: not an integer`,
+					countExpr,
+				);
+			} else if (n < 0n) {
+				this.err(`invalid shift count: ${n} is negative`, countExpr);
+			}
+			return;
+		}
+		if (!isInteger(rt))
+			this.err(
+				`invalid shift count: ${typeStr(rt)} is not an integer type`,
+				countExpr,
+			);
+	},
+
 	_binaryResultTypeString(lt, rt) {
 		if (lt.kind === "untyped" && rt.kind === "untyped") return lt;
 		if (lt.kind === "untyped") return rt;
@@ -101,6 +147,9 @@ export const assignabilityMethods = {
 			return ANY;
 		}
 		if (lt.kind === "untyped" && rt.kind === "untyped") return UNTYPED_COMPLEX;
+		if (lt.kind === "untyped") return rt;
+		if (rt.kind === "untyped") return lt;
+		if (isComplex64(lt) && isComplex64(rt)) return lt;
 		return COMPLEX128;
 	},
 
@@ -155,8 +204,9 @@ export const assignabilityMethods = {
 
 	// ── Assignability ─────────────────────────────────────────────────
 
-	assertAssignable(target, source, node) {
+	assertAssignable(target, source, node, ctx = "assignment") {
 		if (!target || !source) return;
+		if (this._checkConstOverflow(target, source, node, ctx)) return;
 		target = this.resolveType(target);
 		source = this.resolveType(source);
 		this._markIfaceBox(target, source, node);
@@ -171,7 +221,14 @@ export const assignabilityMethods = {
 			return;
 		}
 		if (isUntyped(source) && this._isUntypedAssignable(target, source)) return;
-		if (this._isNumericCoercible(target, source)) return;
+		if (this._isNumericCoercible(target, source)) {
+			if (!this._isGenericCallResult(node)) return;
+			this.err(
+				`mismatched types ${typeStr(source)} and ${typeStr(target)} in ${ctx}`,
+				node,
+			);
+			return;
+		}
 		if (this._checkArrayAssignable(target, source, node)) return;
 		if (this._checkTypedArrayAssignable(target, source, node)) return;
 		if (this._checkFuncAssignable(target, source, node)) return;
@@ -191,17 +248,62 @@ export const assignabilityMethods = {
 		)
 			return;
 		if (target.kind === "typeParam") return;
-		const tBase = this.resolveType(
-			target.kind === "named" ? target.underlying : target,
-		);
+		let tBase = this.resolveType(target);
+		if (tBase?.kind === "named") tBase = this.resolveType(tBase.underlying);
 		if (!isAny(target) && tBase?.kind !== "interface") return;
+		// The static type behind the interface value: codegen derives the
+		// fmt metadata (Stringer elements of slices and maps) from it.
+		node._ifaceSrc = source;
+		const meta = this._ifaceBoxMeta(source);
+		if (!meta) return;
+		node._ifaceBox = meta.box;
+		if (meta.type) node._ifaceNamedType = meta.type;
+		if (meta.ptrFields) node._ifacePtrFields = meta.ptrFields;
+	},
+
+	// How a value of static type `source` is boxed on entering an interface:
+	// { box, type? (named kinds), ptrFields? }, or null when it stays raw.
+	// Shared by _markIfaceBox and the JS backend's multi-value fmt operands.
+	_ifaceBoxMeta(source) {
+		const named = this._namedMethodBoxSource(source);
+		if (named)
+			return { box: named.ptr ? "named_ptr" : "named", type: named.type };
 		const sBase = this.resolveType(
 			source.kind === "named" ? source.underlying : source,
 		);
 		const info = this._classifyIfaceBox(sBase);
-		if (!info) return;
-		node._ifaceBox = info.box;
-		if (info.ptrFields) node._ifacePtrFields = info.ptrFields;
+		if (!info) return null;
+		return { box: info.box, ptrFields: info.ptrFields };
+	},
+
+	// A named non-struct type with methods (or a pointer to one) entering an
+	// interface: the JS backend keeps such values raw and boxes them here so
+	// dynamic method dispatch works.
+	_namedMethodBoxSource(source) {
+		const isPtr = source?.kind === "pointer";
+		let t = isPtr ? source.base : source;
+		if (t?.kind === "TypeName" || t?.kind === "Ident") t = this.resolveType(t);
+		if (t?.kind !== "named") return null;
+		const u = this.resolveType(t.underlying);
+		if (!u || u.kind === "struct" || u.kind === "interface") return null;
+		const methods = t.methods ?? t._generic?.methods;
+		// A user-declared named basic type without methods is boxed as well, so
+		// a type assertion to its underlying type fails like Go.
+		if (
+			u.kind === "basic" &&
+			!t._generic &&
+			t.methods instanceof Map &&
+			t.methods.size === 0 &&
+			t._target !== undefined &&
+			t._target !== "wasm"
+		)
+			return { type: t, ptr: isPtr };
+		if (!methods || methods.size === 0) return null;
+		// Only user-declared types (methods carry _ptrRecv); stdlib named types
+		// such as time.Duration have no box class.
+		if (![...methods.values()].some((m) => Object.hasOwn(m ?? {}, "_ptrRecv")))
+			return null;
+		return { type: t, ptr: isPtr };
 	},
 
 	_getStructPtrFields(st, prefix = "", seen = new Set()) {
@@ -316,7 +418,56 @@ export const assignabilityMethods = {
 			);
 			return;
 		}
-		this.err(`Cannot assign ${typeStr(source)} to ${typeStr(target)}`, node);
+		if (this._identicalUnderlyingLiteral(target, source, tBase, sBase)) return;
+		this.err(
+			`Cannot assign ${typeStr(source)} to ${typeStr(target)}`,
+			node,
+			this._seqToSliceHint(source, tBase, node),
+		);
+	},
+
+	// maps.Keys/Values (and every iter.Seq) no longer return a slice: point the
+	// slice-expecting caller at slices.Collect.
+	_seqToSliceHint(source, tBase, node) {
+		if (tBase?.kind !== "slice" || !this._isIterSeq(source)) return null;
+		return this._seqCollectHint(node);
+	},
+
+	_isIterSeq(t) {
+		return t?.kind === "named" && /^iter\.Seq\d*\[/.test(typeStr(t));
+	},
+
+	_seqCollectHint(node) {
+		const f = node?.kind === "CallExpr" ? node.func : null;
+		if (
+			f?.kind === "SelectorExpr" &&
+			f.expr?.kind === "Ident" &&
+			f.expr.name === "maps" &&
+			(f.field === "Keys" || f.field === "Values")
+		)
+			return `use slices.Collect(maps.${f.field}(m)) for a slice`;
+		return "use slices.Collect(seq) for a slice";
+	},
+
+	// len/cap, spread and slice conversion are lenient on func types, and an
+	// iter.Seq value is one: reject it there instead of miscompiling.
+	_rejectSeqAsSlice(type, node, use) {
+		if (!this._isIterSeq(type)) return;
+		this.err(
+			`cannot use ${typeStr(type)} in ${use}`,
+			node,
+			this._seqCollectHint(node),
+		);
+	},
+
+	// Identical underlying types are assignable when one side is an unnamed
+	// type literal (`var n Names = []string{...}`), as in Go.
+	_identicalUnderlyingLiteral(target, source, tBase, sBase) {
+		if ((target.kind === "named") === (source.kind === "named")) return false;
+		const unnamed = target.kind === "named" ? source : target;
+		return (
+			TYPE_LITERAL_KINDS.has(unnamed.kind) && typeStr(tBase) === typeStr(sBase)
+		);
 	},
 
 	_isUntypedAssignable(target, source) {
@@ -332,6 +483,20 @@ export const assignabilityMethods = {
 		);
 	},
 
+	// A value computed from a generic call (`3 + Sum[float64](1, 2)`) has the
+	// exact instantiated type, so the loose int/float64 promotion that plain
+	// code enjoys does not apply to it.
+	_isGenericCallResult(node) {
+		if (!node || typeof node !== "object") return false;
+		if (node.kind === "ParenExpr") return this._isGenericCallResult(node.expr);
+		if (node.kind === "BinaryExpr")
+			return (
+				this._isGenericCallResult(node.left) ||
+				this._isGenericCallResult(node.right)
+			);
+		return node.kind === "CallExpr" && Boolean(node.func?._genericFnType);
+	},
+
 	_isNumericCoercible(target, source) {
 		if (target.kind !== "basic" || source.kind !== "basic") return false;
 		const pair = `${target.name}:${source.name}`;
@@ -420,10 +585,47 @@ export const assignabilityMethods = {
 
 	// ── Interface satisfaction ────────────────────────────────────────
 
+	// `interface{}` and `any` are the same type, but print differently.
+	_sigTypeStr(t) {
+		switch (t?.kind) {
+			case "interface":
+				if (
+					!t.name &&
+					t.methods.size === 0 &&
+					!t.unionConstraint &&
+					!t._typeSetEmbeds
+				)
+					return "any";
+				return typeStr(t);
+			case "slice":
+				return `[]${this._sigTypeStr(t.elem)}`;
+			case "array":
+				return `[${t.size ?? "..."}]${this._sigTypeStr(t.elem)}`;
+			case "pointer":
+				return `*${this._sigTypeStr(t.base)}`;
+			case "map":
+				return `map[${this._sigTypeStr(t.key)}]${this._sigTypeStr(t.value)}`;
+			case "tuple":
+				return `(${t.types.map((x) => this._sigTypeStr(x)).join(", ")})`;
+			case "func": {
+				const ret =
+					t.returns.length > 1
+						? `(${t.returns.map((x) => this._sigTypeStr(x)).join(", ")})`
+						: t.returns[0]
+							? this._sigTypeStr(t.returns[0])
+							: "void";
+				return `func(${t.params.map((x) => this._sigTypeStr(x)).join(", ")}) ${ret}`;
+			}
+			default:
+				return typeStr(t);
+		}
+	},
+
 	_sigParamsMatch(reqList, actList) {
 		if (reqList.length !== actList.length) return false;
 		for (let i = 0; i < reqList.length; i++) {
-			if (typeStr(reqList[i]) !== typeStr(actList[i])) return false;
+			if (this._sigTypeStr(reqList[i]) !== this._sigTypeStr(actList[i]))
+				return false;
 		}
 		return true;
 	},
@@ -466,7 +668,9 @@ export const assignabilityMethods = {
 		}
 		const methodMap =
 			base?.kind === "struct"
-				? base.methods || srcType.methods
+				? base.methods?.size
+					? base.methods
+					: srcType.methods || base.methods
 				: srcType.kind === "named"
 					? srcType.methods
 					: null;

package/src/typechecker/const-fold.js

@@ -0,0 +1,356 @@
+// Backend-independent evaluation of Go constant expressions.
+//
+// A constant value is `{ k, v, t, i }`:
+//   k — "INT" | "FLOAT" | "STRING" | "BOOL"
+//   v — BigInt (INT), Number (FLOAT), string or boolean
+//   t — basic type name of a typed constant ("int8", "float64", …); absent
+//       for untyped constants, which are exact (BigInt) and may exceed every
+//       Go type until they are converted or assigned
+//   i — for an untyped integral FLOAT, its exact BigInt value, so that
+//       `1e18 + 1` stays exact when it later becomes an integer
+//
+// The checker evaluates constant expressions with these helpers and attaches
+// the result to the AST node (`_const`); both backends emit that value.
+// `foldConstExpr` folds an AST directly (the WASM backend uses it for
+// package-level constants).
+
+const INT = "INT";
+const FLOAT = "FLOAT";
+const STRING = "STRING";
+const BOOL = "BOOL";
+
+// Shift counts beyond this are left to the runtime (Go allows larger shifts
+// of untyped constants, but no program needs a 4096-bit intermediate).
+const MAX_SHIFT = 4096n;
+
+// Value ranges of the integer types.
+export const INT_RANGES = {
+	int8: [-(2n ** 7n), 2n ** 7n - 1n],
+	int16: [-(2n ** 15n), 2n ** 15n - 1n],
+	int32: [-(2n ** 31n), 2n ** 31n - 1n],
+	rune: [-(2n ** 31n), 2n ** 31n - 1n],
+	int64: [-(2n ** 63n), 2n ** 63n - 1n],
+	int: [-(2n ** 63n), 2n ** 63n - 1n],
+	uint8: [0n, 2n ** 8n - 1n],
+	byte: [0n, 2n ** 8n - 1n],
+	uint16: [0n, 2n ** 16n - 1n],
+	uint32: [0n, 2n ** 32n - 1n],
+	uint64: [0n, 2n ** 64n - 1n],
+	uint: [0n, 2n ** 64n - 1n],
+	uintptr: [0n, 2n ** 64n - 1n],
+};
+
+const FLOAT_TYPES = new Set(["float32", "float64"]);
+
+// Untyped integer constants of package `math` (Go declares them untyped).
+// `MaxInt`, `MinInt` and `MaxUint` are left out: the JS backend maps them to
+// the safe-integer range on purpose.
+export const MATH_INT_CONSTS = {
+	MaxInt8: 2n ** 7n - 1n,
+	MinInt8: -(2n ** 7n),
+	MaxInt16: 2n ** 15n - 1n,
+	MinInt16: -(2n ** 15n),
+	MaxInt32: 2n ** 31n - 1n,
+	MinInt32: -(2n ** 31n),
+	MaxInt64: 2n ** 63n - 1n,
+	MinInt64: -(2n ** 63n),
+	MaxUint8: 2n ** 8n - 1n,
+	MaxUint16: 2n ** 16n - 1n,
+	MaxUint32: 2n ** 32n - 1n,
+	MaxUint64: 2n ** 64n - 1n,
+};
+
+export const intConst = (v) => ({ k: INT, v });
+
+// Exact integer value of a decimal float literal (`1e18`, `2.50e1`), or null.
+function exactIntOfFloatText(text) {
+	const m = /^(\d*)(?:\.(\d*))?(?:[eE]([+-]?\d+))?$/.exec(text);
+	if (!m) return null;
+	const frac = m[2] ?? "";
+	const digits = `${m[1]}${frac}` || "0";
+	const exp = Number(m[3] ?? 0) - frac.length;
+	if (exp > 400) return null;
+	if (exp >= 0) return BigInt(digits) * 10n ** BigInt(exp);
+	const cut = digits.length + exp;
+	if (!/^0*$/.test(digits.slice(Math.max(cut, 0)))) return null;
+	return cut > 0 ? BigInt(digits.slice(0, cut)) : 0n;
+}
+
+export function constFromLit(lit) {
+	switch (lit.litKind) {
+		case INT: {
+			const s = String(lit.value).replaceAll("_", "");
+			const clean = /^0[0-7]+$/.test(s) ? `0o${s.slice(1)}` : s;
+			return { k: INT, v: BigInt(clean) };
+		}
+		case FLOAT: {
+			const s = String(lit.value).replaceAll("_", "");
+			const n = Number(s);
+			if (!Number.isFinite(n)) return null;
+			const i = exactIntOfFloatText(s);
+			return i === null ? { k: FLOAT, v: n } : { k: FLOAT, v: n, i };
+		}
+		case STRING:
+			return { k: STRING, v: String(lit.value ?? "") };
+		case BOOL:
+			return { k: BOOL, v: lit.value === "true" || lit.value === true };
+		default:
+			return null;
+	}
+}
+
+export function constToLit(val) {
+	switch (val.k) {
+		case INT:
+			return { kind: "BasicLit", litKind: INT, value: val.v.toString() };
+		case FLOAT:
+			return {
+				kind: "BasicLit",
+				litKind: FLOAT,
+				value: Object.is(val.v, -0) ? "-0" : String(val.v),
+			};
+		case STRING:
+			return { kind: "BasicLit", litKind: STRING, value: val.v };
+		default:
+			return {
+				kind: "BasicLit",
+				litKind: BOOL,
+				value: val.v ? "true" : "false",
+			};
+	}
+}
+
+// Exact integer value of an INT or integral FLOAT, else null.
+export function constIntValue(val) {
+	if (val?.k === INT) return val.v;
+	if (val?.k !== FLOAT) return null;
+	if (val.i !== undefined) return val.i;
+	return Number.isInteger(val.v) ? BigInt(val.v) : null;
+}
+
+function asFloat(val) {
+	return val.k === INT ? Number(val.v) : val.v;
+}
+
+// An integer result typed `t` that does not fit is an overflow.
+function typedInt(v, t) {
+	const range = t ? INT_RANGES[t] : null;
+	if (range && (v < range[0] || v > range[1]))
+		return { k: INT, v, t, overflow: true };
+	return t ? { k: INT, v, t } : { k: INT, v };
+}
+
+function typedFloat(v, t) {
+	if (!Number.isFinite(v)) return null;
+	const r = t === "float32" ? Math.fround(v) : v;
+	return t ? { k: FLOAT, v: r, t } : { k: FLOAT, v: r };
+}
+
+export function foldUnary(op, x) {
+	if (op === "+" && (x.k === INT || x.k === FLOAT)) return x;
+	if (op === "!" && x.k === BOOL) return { ...x, v: !x.v };
+	if (op === "-" && x.k === INT) return typedInt(-x.v, x.t);
+	if (op === "-" && x.k === FLOAT) {
+		const r = typedFloat(-x.v, x.t);
+		return r && x.i !== undefined ? { ...r, i: -x.i } : r;
+	}
+	if (op === "^" && x.k === INT) {
+		// Unsigned: flip the bits of the type's width; otherwise -x-1.
+		const range = x.t ? INT_RANGES[x.t] : null;
+		if (range && range[0] === 0n) return { k: INT, v: range[1] ^ x.v, t: x.t };
+		return typedInt(~x.v, x.t);
+	}
+	return null;
+}
+
+function compare(op, a, b) {
+	switch (op) {
+		case "==":
+			return a === b;
+		case "!=":
+			return a !== b;
+		case "<":
+			return a < b;
+		case "<=":
+			return a <= b;
+		case ">":
+			return a > b;
+		case ">=":
+			return a >= b;
+		default:
+			return null;
+	}
+}
+
+function foldInts(op, a, b, t) {
+	switch (op) {
+		case "+":
+			return typedInt(a + b, t);
+		case "-":
+			return typedInt(a - b, t);
+		case "*":
+			return typedInt(a * b, t);
+		case "/":
+			if (b === 0n) throw new Error("invalid operation: division by zero");
+			return typedInt(a / b, t);
+		case "%":
+			if (b === 0n) throw new Error("invalid operation: division by zero");
+			return typedInt(a % b, t);
+		case "&":
+			return typedInt(a & b, t);
+		case "|":
+			return typedInt(a | b, t);
+		case "^":
+			return typedInt(a ^ b, t);
+		case "&^":
+			return typedInt(a & ~b, t);
+		default: {
+			const r = compare(op, a, b);
+			return r === null ? null : { k: BOOL, v: r };
+		}
+	}
+}
+
+function foldFloats(op, a, b, t) {
+	// Untyped integral operands stay exact for + - * (`1e18 + 1`).
+	const ai = t ? null : constIntValue(a);
+	const bi = t ? null : constIntValue(b);
+	if (ai !== null && bi !== null && (op === "+" || op === "-" || op === "*")) {
+		const i = op === "+" ? ai + bi : op === "-" ? ai - bi : ai * bi;
+		return { k: FLOAT, v: Number(i), i };
+	}
+	const x = asFloat(a);
+	const y = asFloat(b);
+	switch (op) {
+		case "+":
+			return typedFloat(x + y, t);
+		case "-":
+			return typedFloat(x - y, t);
+		case "*":
+			return typedFloat(x * y, t);
+		case "/":
+			if (y === 0) throw new Error("invalid operation: division by zero");
+			return typedFloat(x / y, t);
+		default: {
+			const r = compare(op, x, y);
+			return r === null ? null : { k: BOOL, v: r };
+		}
+	}
+}
+
+function foldShift(op, a, b) {
+	const n = constIntValue(b);
+	const x = constIntValue(a);
+	if (n === null || x === null) return null;
+	if (n < 0n) throw new Error("invalid shift count: negative shift count");
+	if (n > MAX_SHIFT) return null;
+	return typedInt(op === "<<" ? x << n : x >> n, a.t);
+}
+
+function foldBools(op, a, b) {
+	if (op === "&&") return { k: BOOL, v: a.v && b.v };
+	if (op === "||") return { k: BOOL, v: a.v || b.v };
+	const r = op === "==" || op === "!=" ? compare(op, a.v, b.v) : null;
+	return r === null ? null : { k: BOOL, v: r };
+}
+
+function foldStrings(op, a, b) {
+	if (op === "+") return { k: STRING, v: a.v + b.v, t: a.t ?? b.t };
+	const r = compare(op, a.v, b.v);
+	return r === null ? null : { k: BOOL, v: r };
+}
+
+export function foldBinary(op, a, b) {
+	if (op === "<<" || op === ">>") return foldShift(op, a, b);
+	if (a.k === BOOL && b.k === BOOL) return foldBools(op, a, b);
+	if (a.k === STRING && b.k === STRING) return foldStrings(op, a, b);
+	const t = a.t ?? b.t;
+	const numeric = (x) => x.k === INT || x.k === FLOAT;
+	if (!numeric(a) || !numeric(b)) return null;
+	if (FLOAT_TYPES.has(t) || (!t && (a.k === FLOAT || b.k === FLOAT)))
+		return foldFloats(op, a, b, t);
+	const ai = constIntValue(a);
+	const bi = constIntValue(b);
+	if (ai === null || bi === null) return foldFloats(op, a, b, t);
+	return foldInts(op, ai, bi, t);
+}
+
+// Converts `val` to the basic type `name`.  Returns the typed value, a value
+// with `overflow: true` when an integer does not fit, or null when the
+// conversion is not a constant one this folder handles.
+export function convertConst(val, name) {
+	if (INT_RANGES[name]) {
+		const i = constIntValue(val);
+		return i === null ? null : typedInt(i, name);
+	}
+	if (FLOAT_TYPES.has(name)) {
+		if (val.k !== INT && val.k !== FLOAT) return null;
+		return typedFloat(asFloat(val), name);
+	}
+	if (name === "string") {
+		if (val.k === STRING) return { k: STRING, v: val.v, t: name };
+		const i = constIntValue(val);
+		if (val.k !== INT || i === null) return null;
+		const valid = i >= 0n && i <= 0x10ffffn && !(i >= 0xd800n && i <= 0xdfffn);
+		return {
+			k: STRING,
+			v: valid ? String.fromCodePoint(Number(i)) : "�",
+			t: name,
+		};
+	}
+	if (name === "bool" && val.k === BOOL) return { k: BOOL, v: val.v, t: name };
+	return null;
+}
+
+// min/max over constants of one kind.
+export function foldMinMax(isMin, vals) {
+	let best = vals[0];
+	for (const x of vals.slice(1)) {
+		const less = foldBinary("<", x, best);
+		if (!less) return null;
+		if (less.v === isMin) best = x;
+	}
+	return best;
+}
+
+function foldExpr(expr, resolve) {
+	switch (expr?.kind) {
+		case "BasicLit":
+			return constFromLit(expr);
+		case "Ident": {
+			if (expr.name === "true" || expr.name === "false")
+				return { k: BOOL, v: expr.name === "true" };
+			const lit = resolve(expr.name);
+			return lit ? constFromLit(lit) : null;
+		}
+		case "ParenExpr":
+			return foldExpr(expr.expr, resolve);
+		case "UnaryExpr": {
+			const x = foldExpr(expr.operand, resolve);
+			return x ? foldUnary(expr.op, x) : null;
+		}
+		case "BinaryExpr": {
+			const a = foldExpr(expr.left, resolve);
+			const b = a ? foldExpr(expr.right, resolve) : null;
+			return a && b ? foldBinary(expr.op, a, b) : null;
+		}
+		case "CallExpr": {
+			if (expr.func?.kind !== "Ident" || expr.func.name !== "len") return null;
+			if (expr.args?.length !== 1) return null;
+			const s = foldExpr(expr.args[0], resolve);
+			if (s?.k !== STRING) return null;
+			// Gofront strings across JS and WASM runtime use UTF-16 code units (s.length).
+			return { k: INT, v: BigInt(s.v.length) };
+		}
+		default:
+			return null;
+	}
+}
+
+// Folds `expr` into a BasicLit, or returns null when it needs the runtime.
+// `resolve(name)` yields the BasicLit of an already-folded constant, if any.
+// Throws on a constant division by zero or a negative shift count.
+export function foldConstExpr(expr, resolve) {
+	const val = foldExpr(expr, resolve);
+	return val && !val.overflow ? constToLit(val) : null;
+}