gofront 1.8.0 → 1.9.1

package/src/parser/templ.js

@@ -10,11 +10,12 @@
 //   TemplText   { kind, value }
 //   TemplExpr   { kind, tokens }          ← raw Go token array
 //   TemplComponent { kind, tokens }       ← raw Go token array for call
-//   TemplChildren  { kind }
+//   TemplChildren  { kind, name }         ← `{ name... }`, name of a variadic slot
 //   TemplIf     { kind, condTokens, then: TemplNode[], else_: TemplNode[] | null }
 //   TemplFor    { kind, stmtTokens, body: TemplNode[] }
 //   TemplSwitch { kind, exprTokens, cases: TemplCase[] }
 //   TemplCase   { kind, caseTokens: tokens | null (null = default), body: TemplNode[] }
+//               (a `case a, b:` also carries `exprs`, one expression per value)
 //
 // Go expressions embedded in templ (`{ expr }`, attribute values, `if`
 // conditions, `switch` and `case` expressions, `@Comp(...)` calls) and `for`
@@ -71,12 +72,45 @@ function parseExprTokens(tokens, allowEmpty = true) {
 	if (allowEmpty && (!tokens || tokens.length === 0)) return { expr: null };
 	try {
 		const eofTok = new Token(T.EOF, "", 1, 1);
-		return { expr: new Parser([...tokens, eofTok]).parseExpr() };
+		const p = new Parser([...tokens, eofTok]);
+		const expr = p.parseExpr();
+		while (p.check(T.SEMICOLON)) p.advance();
+		if (!p.check(T.EOF))
+			p.err(`unexpected '${p.peek().value}' after expression`);
+		return { expr };
 	} catch (exprError) {
 		return { expr: null, exprError };
 	}
 }
 
+// Parses `tokens` as a comma-separated expression list (`case 1, 2:`). `expr`
+// and `exprError` describe the first expression (or the first error); `exprs`
+// holds every parsed expression.
+function parseExprListTokens(tokens) {
+	if (!tokens || tokens.length === 0) return { expr: null };
+	const parts = [[]];
+	let depth = 0;
+	for (const t of trimSemicolons(tokens ?? [])) {
+		if (t.type === T.LPAREN || t.type === T.LBRACKET || t.type === T.LBRACE)
+			depth++;
+		else if (
+			t.type === T.RPAREN ||
+			t.type === T.RBRACKET ||
+			t.type === T.RBRACE
+		)
+			depth--;
+		if (t.type === T.COMMA && depth === 0) parts.push([]);
+		else parts[parts.length - 1].push(t);
+	}
+	const exprs = [];
+	for (const part of parts) {
+		const parsed = parseExprTokens(part, false);
+		if (parsed.exprError) return { expr: null, exprError: parsed.exprError };
+		exprs.push(parsed.expr);
+	}
+	return { expr: exprs[0] ?? null, exprs };
+}
+
 // Parses an `if` condition; the lexer may leave the `if` keyword in front.
 function parseCondTokens(tokens) {
 	if (!tokens || tokens.length === 0) return { expr: null };
@@ -220,7 +254,10 @@ export class TemplParser extends Parser {
 				return this.templComponent(t.value);
 			case TT.TEMPL_CHILDREN:
 				this.advance();
-				return { kind: "TemplChildren" };
+				return attach(
+					{ kind: "TemplChildren", name: t.value },
+					parseExprTokens([new Token(T.IDENT, t.value, t.line, t.col)]),
+				);
 			case TT.TEMPL_IF: {
 				this.advance();
 				return this.parseTemplIf(t);
@@ -243,7 +280,9 @@ export class TemplParser extends Parser {
 	// `@templ.Raw(arg)` parses `arg`; any other component parses the whole call.
 	templComponent(tokens) {
 		const raw = isTemplRaw(tokens);
-		const parsed = parseExprTokens(raw ? tokens.slice(4, -1) : tokens);
+		const parsed = parseExprTokens(
+			raw ? trimSemicolons(tokens).slice(4, -1) : tokens,
+		);
 		return attach({ kind: "TemplComponent", tokens }, { raw, ...parsed });
 	}
 
@@ -331,7 +370,7 @@ export class TemplParser extends Parser {
 				cases.push(
 					attach(
 						{ kind: "TemplCase", caseTokens, body },
-						isDefault ? { expr: null } : parseExprTokens(caseTokens),
+						isDefault ? { expr: null } : parseExprListTokens(caseTokens),
 					),
 				);
 			} else {

package/src/parser/types.js

@@ -269,6 +269,7 @@ export const typeParserMethods = {
 					names: [],
 					type: { kind: "TypeName", name: typeName },
 					embedded: true,
+					embeddedName: typeName,
 					tag,
 				});
 				this.semi();
@@ -328,6 +329,17 @@ export const typeParserMethods = {
 				this.semi();
 				continue;
 			}
+			// Type-set element that is not a bare name: *T, []int, map[K]V, ...
+			if (!this.check(T.IDENT)) {
+				const terms = [{ approx: false, type: this.parseType() }];
+				while (this.match(T.PIPE)) {
+					const approx = this.match(T.TILDE);
+					terms.push({ approx, type: this.parseType() });
+				}
+				unionConstraint = { kind: "UnionConstraint", terms };
+				this.semi();
+				continue;
+			}
 			const name = this.expect(T.IDENT).value;
 			if (this.check(T.LPAREN)) {
 				// Method signature: Name(params) returnType

package/src/resolver.js

@@ -39,8 +39,7 @@ export function isBuiltinPackage(importPath) {
 }
 
 // Go-source stdlib: `stdlib/<import path>/*.go`, written in GoFront Go
-// and compiled into the caller's target.  A directory for a path that is also
-// in STDLIB_PACKAGES is an overlay: its declarations extend that namespace.
+// and compiled into the caller's target.
 const STDLIB_SOURCE_ROOT = fileURLToPath(
 	new URL("../stdlib/", import.meta.url),
 );

package/src/typechecker/assignability.js

@@ -2,6 +2,7 @@
 // Installed as a mixin on TypeChecker.prototype.
 
 import { constIntValue } from "./const-fold.js";
+import { exprText, operandKind } from "./operand-text.js";
 import { sharedInfo } from "./stdlib/shared.js";
 import {
 	ANY,
@@ -9,7 +10,9 @@ import {
 	CMP_OPS,
 	COMPLEX128,
 	FLOAT64,
+	is64BitInt,
 	isAny,
+	isBool,
 	isComplex,
 	isComplex64,
 	isComplexOrNumeric,
@@ -25,9 +28,11 @@ import {
 	SIZED_INT_NAMES,
 	STRING,
 	typeStr,
+	UNTYPED_BOOL,
 	UNTYPED_COMPLEX,
 	UNTYPED_FLOAT,
 	UNTYPED_INT,
+	UNTYPED_RUNE,
 } from "./types.js";
 
 // Unnamed type literal kinds for Go's "identical underlying types" assignability rule.
@@ -61,6 +66,23 @@ const UNTYPED_COMPAT = {
 	complex128: new Set(["complex128", "complex64"]),
 };
 
+// `&&` and `||` of two untyped bools stay untyped; a typed operand (including
+// a defined bool type) gives its type, as in Go.
+// Two typed operands must have the same type, and the result has it.
+function logicalResultType(lt, rt) {
+	if (lt?.kind === "untyped" && rt?.kind === "untyped") return UNTYPED_BOOL;
+	if (rt?.kind === "untyped" && isBool(lt)) return lt;
+	if (lt?.kind === "untyped" && isBool(rt)) return rt;
+	if (isBool(lt) && isBool(rt) && typeStr(lt) === typeStr(rt)) return lt;
+	return BOOL;
+}
+
+// Two untyped numeric operands combine to the later of int, rune, float.
+function untypedIntegerKind(isFloat, lt, rt) {
+	if (isFloat) return UNTYPED_FLOAT;
+	return lt.rune || rt.rune ? UNTYPED_RUNE : UNTYPED_INT;
+}
+
 /** @type {ThisType<TypeChecker>} */
 export const assignabilityMethods = {
 	// ── Binary result types ───────────────────────────────────────────
@@ -69,12 +91,26 @@ export const assignabilityMethods = {
 		if (lt?.kind === "typeParam" || rt?.kind === "typeParam")
 			return this._binaryResultTypeTypeParam(op, lt, rt);
 		if (CMP_OPS.has(op)) return this._binaryResultTypeCmp(op, lt, rt, node);
-		if (LOG_OPS.has(op)) return BOOL;
+		if (LOG_OPS.has(op)) {
+			this._checkLogicalOperands(lt, rt, node);
+			return logicalResultType(lt, rt);
+		}
 		return this._binaryResultTypeNonComplex(op, lt, rt, node);
 	},
 
+	// `B && bool` mixes two distinct bool types, which Go rejects.
+	_checkLogicalOperands(lt, rt, node) {
+		if (!node || lt?.kind === "untyped" || rt?.kind === "untyped") return;
+		if (!isBool(lt) || !isBool(rt) || typeStr(lt) === typeStr(rt)) return;
+		this.err(
+			`invalid operation: ${exprText(node)} (mismatched types ${typeStr(lt)} and ${typeStr(rt)})`,
+			node,
+		);
+	},
+
 	_binaryResultTypeTypeParam(op, lt, rt) {
-		if (CMP_OPS.has(op) || LOG_OPS.has(op)) return BOOL;
+		if (CMP_OPS.has(op)) return UNTYPED_BOOL;
+		if (LOG_OPS.has(op)) return BOOL;
 		return lt?.kind === "typeParam" ? lt : rt;
 	},
 
@@ -133,8 +169,10 @@ export const assignabilityMethods = {
 
 	_binaryResultTypeCmp(op, lt, rt, node) {
 		if (this._checkComplexCmpOp(op, lt, rt, node)) return ANY;
+		this._checkIntegerCmpKinds(op, lt, rt, node);
 		this._checkEqualityComparable(op, lt, rt, node);
-		return BOOL;
+		// A comparison is an untyped bool: it also fits a defined bool type.
+		return UNTYPED_BOOL;
 	},
 
 	_binaryResultTypeComplex(op, lt, rt, node) {
@@ -160,7 +198,7 @@ export const assignabilityMethods = {
 		const rFloat = rName === "float32" || rName === "float64";
 		const isFloat = lFloat || rFloat;
 		if (lt.kind === "untyped" && rt.kind === "untyped")
-			return isFloat ? UNTYPED_FLOAT : UNTYPED_INT;
+			return untypedIntegerKind(isFloat, lt, rt);
 		if (lt.kind === "untyped")
 			return isFloat && rt.name !== "float64" && rt.name !== "float32"
 				? FLOAT64
@@ -173,6 +211,17 @@ export const assignabilityMethods = {
 		return isFloat ? FLOAT64 : lt;
 	},
 
+	// Comparing two typed integers of different types (`byte != int`) is a
+	// mismatch in Go; untyped constants adapt to either side.
+	_checkIntegerCmpKinds(op, lt, rt, node) {
+		if (!node || lt.kind === "untyped" || rt.kind === "untyped") return;
+		if (!isInteger(lt) || !isInteger(rt) || typeStr(lt) === typeStr(rt)) return;
+		this.err(
+			`invalid operation: ${exprText(node)} (mismatched types ${typeStr(lt)} and ${typeStr(rt)})`,
+			node,
+		);
+	},
+
 	_checkComplexCmpOp(op, lt, rt, node) {
 		if (isComplex(lt) || isComplex(rt)) {
 			if (op !== "==" && op !== "!=") {
@@ -204,13 +253,93 @@ export const assignabilityMethods = {
 
 	// ── Assignability ─────────────────────────────────────────────────
 
-	assertAssignable(target, source, node, ctx = "assignment") {
+	_tag64BitNode(target, node) {
+		if (node && typeof node === "object" && is64BitInt(target)) {
+			node._is64Bit = true;
+			if (node.kind === "KeyValueExpr" && node.value)
+				node.value._is64Bit = true;
+			if (node.kind === "UnaryExpr" && node.operand)
+				node.operand._is64Bit = true;
+			if (node.kind === "ParenExpr" && node.expr) node.expr._is64Bit = true;
+		}
+	},
+
+	// An untyped numeric constant that takes type float32 is rounded to
+	// float32 in JS output (`var c float32 = 0.01`, `v == 0.01`).
+	_tagFloat32Const(target, source, node) {
+		if (!node || typeof node !== "object" || !node._const) return;
+		if (!isUntyped(source) || this._float32Base(target) !== "float32") return;
+		node._f32Const = true;
+	},
+
+	_float32Base(t) {
+		const r = t?.kind === "named" ? t.underlying : t;
+		return r?.kind === "basic" || r?.kind === "untyped" ? r.name : null;
+	},
+
+	// `var m uint64 = (1 << k) - 1`: a non-constant shift whose left operand is
+	// an untyped constant takes the type its context gives it, so codegen
+	// computes it in that type (BigInt for 64-bit integers).
+	_retypeUntypedShift(target, source, valueNode) {
+		if (!isUntyped(source) || !isInteger(target)) return;
+		this._retypeShiftTree(valueNode, target);
+	},
+
+	_retypeShiftTree(e, target) {
+		if (!e || typeof e !== "object" || e._type?.kind !== "untyped") return;
+		if (e.kind === "ParenExpr") this._retypeShiftTree(e.expr, target);
+		else if (e.kind === "UnaryExpr") this._retypeShiftTree(e.operand, target);
+		else if (e.kind === "BinaryExpr" && !this._constValue(e)) {
+			const isShift = e.op === "<<" || e.op === ">>";
+			this._retypeShiftTree(e.left, target);
+			if (isShift && e.left._type?.kind === "untyped") {
+				e.left._type = target;
+				if (is64BitInt(target)) e.left._is64Bit = true;
+			} else if (!isShift) this._retypeShiftTree(e.right, target);
+		} else return;
+		if (this._constValue(e)) return;
+		e._type = target;
+		if (is64BitInt(target)) e._is64Bit = true;
+	},
+
+	// An untyped real constant flowing into a complex type becomes a complex
+	// value in codegen.
+	_tagComplexConst(target, source, valueNode) {
+		if (
+			valueNode &&
+			typeof valueNode === "object" &&
+			isComplex(target) &&
+			isUntyped(source) &&
+			!isComplex(source)
+		)
+			valueNode._asComplex = true;
+		this._tagComplex64Const(target, source, valueNode);
+	},
+
+	// An untyped constant that takes type complex64 is rounded to float32 in
+	// JS output: a real constant through `_f32Const`, a complex constant
+	// (`1 + 0.01i`) through `_c64Const`.
+	_tagComplex64Const(target, source, node) {
+		if (!node || typeof node !== "object") return;
+		if (!isComplex64(target) || !isUntyped(source)) return;
+		if (isComplex(source)) node._c64Const = true;
+		else if (node._const) node._f32Const = true;
+	},
+
+	// `operand` is the expression whose value flows in, when `node` (the
+	// position and codegen tag) is not that expression.
+	assertAssignable(target, source, node, ctx = "assignment", operand = node) {
 		if (!target || !source) return;
 		if (this._checkConstOverflow(target, source, node, ctx)) return;
 		target = this.resolveType(target);
 		source = this.resolveType(source);
+		this._tag64BitNode(target, node);
+		this._tagFloat32Const(target, source, operand ?? node);
+		this._retypeUntypedShift(target, source, operand ?? node);
+		this._tagComplexConst(target, source, operand ?? node);
 		this._markIfaceBox(target, source, node);
 		this._checkWasmIfaceProvider(target, source, node);
+		if (this._checkIfaceToConcrete(target, source, node, ctx, operand)) return;
 		if (this._assertAssignableEarlyReturn(target, source)) return;
 		if (isPointer(target) && isPointer(source)) {
 			this.assertAssignable(
@@ -221,14 +350,7 @@ export const assignabilityMethods = {
 			return;
 		}
 		if (isUntyped(source) && this._isUntypedAssignable(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._checkNumericCoercion(target, source, node, ctx, operand)) return;
 		if (this._checkArrayAssignable(target, source, node)) return;
 		if (this._checkTypedArrayAssignable(target, source, node)) return;
 		if (this._checkFuncAssignable(target, source, node)) return;
@@ -300,7 +422,7 @@ export const assignabilityMethods = {
 			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.
+		// such as strings.Builder have no box class.
 		if (![...methods.values()].some((m) => Object.hasOwn(m ?? {}, "_ptrRecv")))
 			return null;
 		return { type: t, ptr: isPtr };
@@ -379,6 +501,55 @@ export const assignabilityMethods = {
 		);
 	},
 
+	// An interface-typed operand needs an explicit type assertion before it can
+	// flow into a concrete (non-interface) type, or into an interface with
+	// methods (`var e error = b` with `b any`).
+	_checkIfaceToConcrete(target, source, node, ctx, operand) {
+		if (!source?._declared || !operand || typeof operand !== "object")
+			return false;
+		if (!this._isConcreteTarget(target) && !this._isMethodIfaceTarget(target))
+			return false;
+		this.err(
+			`cannot use ${exprText(operand)} (${operandKind(operand, typeStr(source))}) as ${typeStr(target)} value in ${ctx}: need type assertion`,
+			node,
+		);
+		return true;
+	},
+
+	// `int(x)`, `(*T)(x)` and `I(x)` (I with methods) with a source-written
+	// `any` operand need an assertion.
+	_checkIfaceConversion(srcType, targetType, expr, operand) {
+		if (!srcType?._declared || !operand) return false;
+		if (
+			!this._isConcreteTarget(targetType) &&
+			!this._isMethodIfaceTarget(targetType)
+		)
+			return false;
+		this.err(
+			`cannot convert ${exprText(operand)} (${operandKind(operand, typeStr(srcType))}) to type ${typeStr(targetType)}: need type assertion`,
+			expr,
+		);
+		return true;
+	},
+
+	// An interface type (named or literal) with at least one method.
+	_isMethodIfaceTarget(target) {
+		if (!target || isAny(target)) return false;
+		const base = this.resolveType(
+			target.kind === "named" ? target.underlying : target,
+		);
+		return base?.kind === "interface" && base.methods?.size > 0;
+	},
+
+	_isConcreteTarget(target) {
+		if (!target || target.kind === "typeParam" || isAny(target)) return false;
+		if (isNil(target) || isUntyped(target)) return false;
+		const base = this.resolveType(
+			target.kind === "named" ? target.underlying : target,
+		);
+		return !!base && base.kind !== "interface" && base.kind !== "typeParam";
+	},
+
 	_assertAssignableEarlyReturn(target, source) {
 		return (
 			target?.kind === "typeParam" ||
@@ -500,12 +671,36 @@ export const assignabilityMethods = {
 	_isNumericCoercible(target, source) {
 		if (target.kind !== "basic" || source.kind !== "basic") return false;
 		const pair = `${target.name}:${source.name}`;
+		return pair === "float64:int";
+	},
+
+	// The lenient numeric pairs: accepted, except that a generic call result
+	// is a mismatch and a float64 never reaches an int implicitly.
+	// Returns true when the pair was handled.
+	_checkNumericCoercion(target, source, node, ctx, operand) {
+		const floatToInt = this._isFloatToInt(target, source);
+		if (!floatToInt && !this._isNumericCoercible(target, source)) return false;
+		if (this._isGenericCallResult(node))
+			this.err(
+				`mismatched types ${typeStr(source)} and ${typeStr(target)} in ${ctx}`,
+				node,
+			);
+		else if (floatToInt)
+			this.err(
+				`cannot use ${exprText(operand)} (${operandKind(operand, typeStr(source))}) as ${typeStr(target)} value in ${ctx}`,
+				node,
+			);
+		return true;
+	},
+
+	// Go has no implicit float64 -> int conversion; only an untyped constant
+	// (handled earlier) or an explicit `int(x)` reaches an int.
+	_isFloatToInt(target, source) {
 		return (
-			pair === "float64:int" ||
-			pair === "int:float64" ||
-			// rune was historically int in GoFront; keep rune/int interchangeable.
-			pair === "int:int32" ||
-			pair === "int32:int"
+			target.kind === "basic" &&
+			source.kind === "basic" &&
+			target.name === "int" &&
+			source.name === "float64"
 		);
 	},
 

package/src/typechecker/const-fold.js

@@ -8,6 +8,8 @@
 //       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.
@@ -22,6 +24,7 @@ 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 = {
@@ -42,24 +45,6 @@ export const INT_RANGES = {
 
 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.
@@ -76,6 +61,40 @@ function exactIntOfFloatText(text) {
 	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: {
@@ -83,13 +102,8 @@ export function constFromLit(lit) {
 			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 FLOAT:
+			return floatConstFromText(String(lit.value).replaceAll("_", ""));
 		case STRING:
 			return { k: STRING, v: String(lit.value ?? "") };
 		case BOOL:
@@ -146,13 +160,19 @@ function typedFloat(v, t) {
 	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) {
-		const r = typedFloat(-x.v, x.t);
-		return r && x.i !== undefined ? { ...r, i: -x.i } : r;
+		return negateFloat(x);
 	}
 	if (op === "^" && x.k === INT) {
 		// Unsigned: flip the bits of the type's width; otherwise -x-1.
@@ -211,6 +231,27 @@ function foldInts(op, a, b, t) {
 	}
 }
 
+// `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);
@@ -219,6 +260,8 @@ function foldFloats(op, a, b, t) {
 		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) {