gofront 1.7.0 → 1.9.0

package/src/typechecker/const-fold.js

@@ -0,0 +1,399 @@
+// 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
+//   r — for an untyped decimal FLOAT, its exact value `{ n, e }` = n * 10^-e
+//       (BigInt n), so `0.2 + 0.1` is exactly 0.3 before it rounds to float64
+//
+// 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;
+const MAX_DECIMAL_EXP = 400;
+
+// 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"]);
+
+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;
+}
+
+// Exact decimal value `{ n, e }` (n * 10^-e) of a decimal float literal, or null.
+function exactDecimalOfFloatText(text) {
+	const m = /^(\d*)(?:\.(\d*))?(?:[eE]([+-]?\d+))?$/.exec(text);
+	if (!m) return null;
+	const frac = m[2] ?? "";
+	const digits = `${m[1]}${frac}` || "0";
+	const e = frac.length - Number(m[3] ?? 0);
+	if (Math.abs(e) > MAX_DECIMAL_EXP) return null;
+	return e >= 0
+		? { n: BigInt(digits), e }
+		: { n: BigInt(digits) * 10n ** BigInt(-e), e: 0 };
+}
+
+// Exact decimal value of an untyped INT or FLOAT constant, or null.
+function exactDecimal(val) {
+	if (val.t) return null;
+	if (val.r) return val.r;
+	const i = constIntValue(val);
+	return i === null ? null : { n: i, e: 0 };
+}
+
+function decimalToFloat({ n, e }) {
+	return Number(`${n}e-${e}`);
+}
+
+function floatConstFromText(s) {
+	const n = Number(s);
+	if (!Number.isFinite(n)) return null;
+	const i = exactIntOfFloatText(s);
+	const r = exactDecimalOfFloatText(s);
+	const out = i === null ? { k: FLOAT, v: n } : { k: FLOAT, v: n, i };
+	return r === null ? out : { ...out, r };
+}
+
+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:
+			return floatConstFromText(String(lit.value).replaceAll("_", ""));
+		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 };
+}
+
+function negateFloat(x) {
+	const r = typedFloat(-x.v, x.t);
+	if (r && x.i !== undefined) r.i = -x.i;
+	if (r && x.r && !x.t) r.r = { n: -x.r.n, e: x.r.e };
+	return 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) {
+		return negateFloat(x);
+	}
+	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 };
+		}
+	}
+}
+
+// `x op y` on exact decimals for + - *.
+function combineDecimals(op, x, y) {
+	if (op === "*") return { n: x.n * y.n, e: x.e + y.e };
+	const e = Math.max(x.e, y.e);
+	const xn = x.n * 10n ** BigInt(e - x.e);
+	const yn = y.n * 10n ** BigInt(e - y.e);
+	return { n: op === "+" ? xn + yn : xn - yn, e };
+}
+
+// Untyped decimal + - * in exact arithmetic, rounded to float64 once at the end.
+function foldExactDecimals(op, a, b) {
+	if (op !== "+" && op !== "-" && op !== "*") return null;
+	const x = exactDecimal(a);
+	const y = exactDecimal(b);
+	if (!x || !y) return null;
+	const r = combineDecimals(op, x, y);
+	if (r.e > MAX_DECIMAL_EXP) return null;
+	const v = decimalToFloat(r);
+	return Number.isFinite(v) ? { k: FLOAT, v, r } : null;
+}
+
+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 exact = t ? null : foldExactDecimals(op, a, b);
+	if (exact) return exact;
+	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;
+}

package/src/typechecker/constants.js

@@ -0,0 +1,282 @@
+// TypeChecker constant evaluation — installed as a mixin on TypeChecker.prototype.
+//
+// Every constant expression gets its exact value from the shared folder
+// (src/typechecker/const-fold.js) and carries it on the AST node as `_const`, so
+// both backends emit the same value.  Typed constant overflow and constant
+// division by zero are reported here.
+
+import {
+	constFromLit,
+	constIntValue,
+	convertConst,
+	foldBinary,
+	foldMinMax,
+	foldUnary,
+	INT_RANGES,
+	intConst,
+} from "./const-fold.js";
+import { defaultType, isAny, typeStr, VOID } from "./types.js";
+
+// Basic type names usable as conversion functions (`int32(x)`).
+const BASIC_CONVERSIONS = new Set([
+	...Object.keys(INT_RANGES),
+	"float32",
+	"float64",
+	"string",
+	"bool",
+]);
+
+// Node kinds that can be constant expressions.
+const CONST_KINDS = new Set([
+	"BasicLit",
+	"Ident",
+	"ParenExpr",
+	"UnaryExpr",
+	"BinaryExpr",
+	"CallExpr",
+	"TypeConversion",
+	"SelectorExpr",
+]);
+
+const NEGATIVE_SHIFT_ERROR = "invalid shift count: negative shift count";
+
+/** @type {ThisType<import('./index.js').TypeChecker>} */
+export const constantCheckMethods = {
+	// The value of a constant expression, or null when `expr` is not one (or
+	// is an overflowing or erroneous one).
+	_constValue(expr, scope = null) {
+		const raw = this._constRaw(expr, scope ?? this.globals);
+		return raw && !raw.overflow && !raw.error ? raw : null;
+	},
+
+	// Integer value of an integer (or untyped integral float) constant as a
+	// Number, or null.
+	_constIntValue(expr, scope = null) {
+		const v = this._constValue(expr, scope);
+		if (!v || (v.k === "FLOAT" && v.t)) return null;
+		const i = constIntValue(v);
+		return i === null ? null : Number(i);
+	},
+
+	// Raw evaluation result, memoized on checked nodes: a value, a value with
+	// `overflow`, `{ error }`, or null.
+	_constRaw(expr, scope) {
+		if (!expr || typeof expr !== "object" || !CONST_KINDS.has(expr.kind))
+			return null;
+		if (expr._constRaw !== undefined) return expr._constRaw;
+		if (expr._constBusy) return null; // cyclic constant
+		expr._constBusy = true;
+		let raw;
+		try {
+			raw = this._evalConst(expr, scope);
+		} catch (err) {
+			raw = { error: err.message };
+		} finally {
+			expr._constBusy = false;
+		}
+		// Conversions are only resolved once the node has been checked.
+		if (expr._type !== undefined) expr._constRaw = raw;
+		return raw;
+	},
+
+	// Called by checkExpr after typing `expr`: attaches `_const` and reports
+	// overflow / division by zero once per node.
+	_noteConst(expr, scope) {
+		if (!CONST_KINDS.has(expr.kind)) return;
+		const raw = this._constRaw(expr, scope);
+		expr._const = raw && !raw.overflow && !raw.error ? raw : null;
+		if (!raw || expr._constReported) return;
+		if (raw.error) {
+			expr._constReported = true;
+			// checkShiftCount already reports a negative count at its operand.
+			if (raw.error === NEGATIVE_SHIFT_ERROR) return;
+			this.err(raw.error, expr);
+		} else if (raw.overflow) {
+			expr._constReported = true;
+			this.err(`constant ${raw.v} overflows ${raw.typeName ?? raw.t}`, expr);
+		}
+	},
+
+	_evalConst(expr, scope) {
+		switch (expr.kind) {
+			case "BasicLit":
+				return constFromLit(expr);
+			case "ParenExpr":
+				return this._constValue(expr.expr, scope);
+			case "UnaryExpr": {
+				const x = this._constValue(expr.operand, scope);
+				return x ? foldUnary(expr.op, x) : null;
+			}
+			case "BinaryExpr": {
+				const a = this._constValue(expr.left, scope);
+				const b = a ? this._constValue(expr.right, scope) : null;
+				return a && b ? foldBinary(expr.op, a, b) : null;
+			}
+			case "Ident":
+				return this._evalConstIdent(expr, scope);
+			case "SelectorExpr":
+				return this._evalConstSelector(expr, scope);
+			case "TypeConversion": {
+				const v = this._constValue(expr.expr, scope);
+				const target = v ? this.resolveTypeNode(expr.targetType, scope) : null;
+				return target ? this._convertConstTo(v, target) : null;
+			}
+			default:
+				return this._evalConstCall(expr, scope);
+		}
+	},
+
+	_evalConstIdent(expr, scope) {
+		const owner = scope.lookupScope(expr.name);
+		if (!owner?._consts.has(expr.name)) return null;
+		const init = owner.lookupConstExpr(expr.name);
+		const v = init
+			? this._constValue(init, owner)
+			: (this._importedConsts?.get(expr.name) ?? null);
+		if (!v) return null;
+		const declared = owner.symbols.get(expr.name);
+		if (!declared || declared.kind === "untyped" || declared.kind === "any")
+			return v;
+		const typed = this._convertConstTo(v, declared);
+		return typed?.overflow ? null : typed;
+	},
+
+	// `pkg.K` of an imported GoFront package.
+	_evalConstSelector(expr, scope) {
+		if (expr.expr?.kind !== "Ident") return null;
+		const ns = scope.lookup(expr.expr.name);
+		if (ns?.kind !== "namespace") return null;
+		return ns._gofront ? (ns._consts?.get(expr.field) ?? null) : null;
+	},
+
+	// Conversions, `len` of a constant string, and `min`/`max` of constants.
+	_evalConstCall(expr, scope) {
+		const target = this._constConversionTarget(expr, scope);
+		if (target) {
+			const v = this._constValue(expr.args[0], scope);
+			return v ? this._convertConstTo(v, target) : null;
+		}
+		const fn = expr.func;
+		if (fn?.kind !== "Ident" || scope.lookup(fn.name)?.kind !== "builtin")
+			return null;
+		const vals = (expr.args ?? []).map((a) => this._constValue(a, scope));
+		if (vals.length === 0 || vals.some((v) => !v)) return null;
+		if (fn.name === "min" || fn.name === "max")
+			return foldMinMax(fn.name === "min", vals);
+		// GoFront strings use UTF-16 code units on both backends.
+		const isLen = fn.name === "len" && vals[0].k === "STRING";
+		return isLen ? intConst(BigInt(vals[0].v.length)) : null;
+	},
+
+	// Target type of a conversion call (`MyInt(x)`, `int32(x)`), or null.
+	_constConversionTarget(expr, scope) {
+		if (expr.args?.length !== 1) return null;
+		if (expr._isTypeConversion) return expr._conversionTargetType ?? null;
+		const fn = expr.func;
+		if (fn?.kind !== "Ident" || !BASIC_CONVERSIONS.has(fn.name)) return null;
+		const owner = scope.lookupScope(fn.name);
+		return !owner || owner === this.universe
+			? { kind: "basic", name: fn.name }
+			: null;
+	},
+
+	// Converts a constant to Go type `t` (basic or named over a basic type).
+	_convertConstTo(v, t) {
+		const u = this.resolveType(t?.kind === "named" ? t.underlying : t);
+		if (u?.kind !== "basic") return null;
+		const r = convertConst(v, u.name);
+		return r?.overflow ? { ...r, typeName: typeStr(t) } : r;
+	},
+
+	// `var x int8 = 200`: an untyped integer constant must fit the target.  An
+	// interface target takes the constant's default type (`var v any = 1 << 64`).
+	// A null `ctx` reports an operand converted to the other operand's type.
+	_checkConstOverflow(target, source, node, ctx) {
+		if (source?.kind !== "untyped" || !node?._const) return false;
+		const base = this.resolveType(
+			target?.kind === "named" ? target.underlying : target,
+		);
+		if (base?.kind === "interface" || isAny(base)) target = defaultType(source);
+		const i = constIntValue(node._const);
+		const range = this._intRange(target);
+		if (i === null && range)
+			return this._reportTruncatedConst(target, node, ctx);
+		// A float or complex target holds the constant as a Number: Go rounds
+		// the same way, so the JS backend has nothing to warn about.
+		if (!range && node.kind) {
+			const u = this.resolveType(
+				target?.kind === "named" ? target.underlying : target,
+			);
+			if (u?.kind === "basic" && /^(float|complex)/.test(u.name))
+				node._floatConst = true;
+		}
+		if (!range) return false;
+		if (i >= range[0] && i <= range[1]) {
+			node._intConst = true; // the JS backend's precision warning reads this
+			return false;
+		}
+		const isInt = node._const.k === "INT";
+		const text = isInt ? String(i) : String(node._const.v);
+		const what = `untyped ${isInt ? "int" : "float"} constant`;
+		const shown =
+			node.kind === "BasicLit"
+				? `${node.value} (${what})`
+				: `${text} (${what} ${text})`;
+		this.err(
+			ctx
+				? `cannot use ${shown} as ${typeStr(target)} value in ${ctx} (overflows)`
+				: `${shown} overflows ${typeStr(target)}`,
+			node,
+		);
+		return true;
+	},
+
+	// `var i int = 1.5`: an untyped float constant with a fractional part
+	// cannot become an integer.
+	_reportTruncatedConst(target, node, ctx) {
+		const c = node._const;
+		if (c.k !== "FLOAT" || c.t) return false;
+		const shown =
+			node.kind === "BasicLit"
+				? `${node.value} (untyped float constant)`
+				: `${c.v} (untyped float constant ${c.v})`;
+		this.err(
+			ctx
+				? `cannot use ${shown} as ${typeStr(target)} value in ${ctx} (truncated)`
+				: `${shown} truncated to ${typeStr(target)}`,
+			node,
+		);
+		return true;
+	},
+
+	// `x := 1 << 63`, `println(1 << 64)`: the constant takes its default type.
+	_checkConstDefault(source, node, ctx) {
+		return this._checkConstOverflow(defaultType(source), source, node, ctx);
+	},
+
+	// print/println arguments take their default type.
+	_checkPrintArgs(name, expr, argTypes) {
+		for (let i = 0; i < expr.args.length; i++)
+			this._checkConstDefault(
+				argTypes[i],
+				expr.args[i],
+				`argument to built-in ${name}`,
+			);
+		return VOID;
+	},
+
+	// `x + 300` with `x int8`: the untyped operand is converted to the other
+	// operand's type.
+	_checkConstOperands(op, lt, rt, expr) {
+		if (op === "<<" || op === ">>" || op === "&&" || op === "||") return;
+		if (rt?.kind === "untyped" && lt?.kind !== "untyped")
+			this._checkConstOverflow(lt, rt, expr.right, null);
+		else if (lt?.kind === "untyped" && rt?.kind !== "untyped")
+			this._checkConstOverflow(rt, lt, expr.left, null);
+	},
+
+	_intRange(t) {
+		const u = this.resolveType(t?.kind === "named" ? t.underlying : t);
+		return u?.kind === "basic" ? (INT_RANGES[u.name] ?? null) : null;
+	},
+};