gofront 1.8.0 → 1.9.0

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,6 +10,7 @@ import {
 	CMP_OPS,
 	COMPLEX128,
 	FLOAT64,
+	is64BitInt,
 	isAny,
 	isComplex,
 	isComplex64,
@@ -133,6 +135,7 @@ 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;
 	},
@@ -173,6 +176,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 +218,68 @@ 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;
+		}
+	},
+
+	// `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;
+	},
+
+	// `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._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 +290,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 +362,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 +441,28 @@ export const assignabilityMethods = {
 		);
 	},
 
+	// An interface-typed operand needs an explicit type assertion before it can
+	// flow into a concrete (non-interface) type.
+	_checkIfaceToConcrete(target, source, node, ctx, operand) {
+		if (!source?._declared || !operand || typeof operand !== "object")
+			return false;
+		if (!this._isConcreteTarget(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;
+	},
+
+	_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" ||
@@ -502,13 +586,42 @@ export const assignabilityMethods = {
 		const pair = `${target.name}:${source.name}`;
 		return (
 			pair === "float64:int" ||
-			pair === "int:float64" ||
 			// rune was historically int in GoFront; keep rune/int interchangeable.
 			pair === "int:int32" ||
 			pair === "int32: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 (
+			target.kind === "basic" &&
+			source.kind === "basic" &&
+			target.name === "int" &&
+			source.name === "float64"
+		);
+	},
+
 	_checkArrayAssignable(target, source, node) {
 		if (target.kind === "array" && source.kind === "array") {
 			if (

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) {

package/src/typechecker/constants.js

@@ -14,7 +14,6 @@ import {
 	foldUnary,
 	INT_RANGES,
 	intConst,
-	MATH_INT_CONSTS,
 } from "./const-fold.js";
 import { defaultType, isAny, typeStr, VOID } from "./types.js";
 
@@ -142,14 +141,12 @@ export const constantCheckMethods = {
 		return typed?.overflow ? null : typed;
 	},
 
-	// `pkg.K` (an imported GoFront package) and the integer `math` constants.
+	// `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;
-		if (ns._gofront) return ns._consts?.get(expr.field) ?? null;
-		const m = ns.name === "math" ? MATH_INT_CONSTS[expr.field] : undefined;
-		return m === undefined ? null : intConst(m);
+		return ns._gofront ? (ns._consts?.get(expr.field) ?? null) : null;
 	},
 
 	// Conversions, `len` of a constant string, and `min`/`max` of constants.
@@ -201,7 +198,18 @@ export const constantCheckMethods = {
 		);
 		if (base?.kind === "interface" || isAny(base)) target = defaultType(source);
 		const i = constIntValue(node._const);
-		const range = i === null ? null : this._intRange(target);
+		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
@@ -223,6 +231,24 @@ export const constantCheckMethods = {
 		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);