gofront 1.8.0 → 1.9.1

package/src/typechecker/constants.js

@@ -14,9 +14,29 @@ import {
 	foldUnary,
 	INT_RANGES,
 	intConst,
-	MATH_INT_CONSTS,
 } from "./const-fold.js";
-import { defaultType, isAny, typeStr, VOID } from "./types.js";
+import {
+	compositeLitMaxIndex,
+	defaultType,
+	isAny,
+	isComplex,
+	isComplex64,
+	isUntyped,
+	typeStr,
+	VOID,
+} from "./types.js";
+
+// True when evaluating `node` runs a call or a channel receive (conversions
+// excluded): such an operand makes `len` of an array a non-constant.
+function hasCallOrReceive(node) {
+	if (!node || typeof node !== "object") return false;
+	if (Array.isArray(node)) return node.some(hasCallOrReceive);
+	if (node.kind === "CallExpr" && !node._isTypeConversion) return true;
+	if (node.kind === "UnaryExpr" && node.op === "<-") return true;
+	return Object.keys(node).some(
+		(key) => key.charCodeAt(0) !== 95 && hasCallOrReceive(node[key]),
+	);
+}
 
 // Basic type names usable as conversion functions (`int32(x)`).
 const BASIC_CONVERSIONS = new Set([
@@ -39,6 +59,17 @@ const CONST_KINDS = new Set([
 	"SelectorExpr",
 ]);
 
+// Describes a constant that is not integer-valued (`float64 constant`), or
+// null for an integer, an untyped float with an integer value, or a rune.
+function nonIntegerConstKind(v) {
+	if (v.k === "INT") return null;
+	if (v.k === "FLOAT") {
+		if (v.t) return `${v.t} constant`;
+		return constIntValue(v) === null ? "untyped float constant" : null;
+	}
+	return `${v.k.toLowerCase()} constant`;
+}
+
 const NEGATIVE_SHIFT_ERROR = "invalid shift count: negative shift count";
 
 /** @type {ThisType<import('./index.js').TypeChecker>} */
@@ -50,6 +81,23 @@ export const constantCheckMethods = {
 		return raw && !raw.overflow && !raw.error ? raw : null;
 	},
 
+	// What makes `expr` a constant that cannot be an array length, index or
+	// size (`untyped bool constant`, `untyped nil`), or null when it is an
+	// integer constant or not a constant at all.
+	_nonIntegerConst(expr, scope = null) {
+		let e = expr;
+		while (e?.kind === "ParenExpr") e = e.expr;
+		if (e?.kind === "ImagLit") return "untyped complex constant";
+		if (e?.kind === "BasicLit" && e.litKind === "NIL") return "untyped nil";
+		let v = null;
+		try {
+			v = this._constValue(expr, scope);
+		} catch {
+			// not a constant the evaluator understands
+		}
+		return v ? nonIntegerConstKind(v) : null;
+	},
+
 	// Integer value of an integer (or untyped integral float) constant as a
 	// Number, or null.
 	_constIntValue(expr, scope = null) {
@@ -59,6 +107,23 @@ export const constantCheckMethods = {
 		return i === null ? null : Number(i);
 	},
 
+	// A named untyped complex constant has no folded value (`_const`): its
+	// initializer goes on the identifier as `_complexInit`, so the backends
+	// can fold it where it takes type complex64.
+	// A named `complex64` constant is tagged `_c64Const` as well, so a use
+	// takes float32 components as in Go.
+	_noteComplexConstInit(expr, scope) {
+		if (expr.kind !== "Ident") return;
+		const typed64 = !isUntyped(expr._type) && isComplex64(expr._type);
+		if (!typed64 && !(isUntyped(expr._type) && isComplex(expr._type))) return;
+		const owner = scope.lookupScope(expr.name);
+		if (!owner?._consts.has(expr.name)) return;
+		const init = owner.lookupConstExpr(expr.name);
+		if (!init) return;
+		expr._complexInit = init;
+		if (typed64) expr._c64Const = true;
+	},
+
 	// Raw evaluation result, memoized on checked nodes: a value, a value with
 	// `overflow`, `{ error }`, or null.
 	_constRaw(expr, scope) {
@@ -84,6 +149,7 @@ export const constantCheckMethods = {
 	// overflow / division by zero once per node.
 	_noteConst(expr, scope) {
 		if (!CONST_KINDS.has(expr.kind)) return;
+		this._noteComplexConstInit(expr, scope ?? this.globals);
 		const raw = this._constRaw(expr, scope);
 		expr._const = raw && !raw.overflow && !raw.error ? raw : null;
 		if (!raw || expr._constReported) return;
@@ -129,7 +195,13 @@ export const constantCheckMethods = {
 
 	_evalConstIdent(expr, scope) {
 		const owner = scope.lookupScope(expr.name);
-		if (!owner?._consts.has(expr.name)) return null;
+		// A constant declared after the type that uses it (`type B [k]int`) has
+		// no symbol yet, but its initializer is registered.
+		if (!owner) {
+			const early = scope.lookupConstExpr(expr.name);
+			return early ? this._constValue(early, scope) : null;
+		}
+		if (!owner._consts.has(expr.name)) return null;
 		const init = owner.lookupConstExpr(expr.name);
 		const v = init
 			? this._constValue(init, owner)
@@ -142,14 +214,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.
@@ -162,6 +232,8 @@ export const constantCheckMethods = {
 		const fn = expr.func;
 		if (fn?.kind !== "Ident" || scope.lookup(fn.name)?.kind !== "builtin")
 			return null;
+		const arrayLen = this._constArrayLen(fn.name, expr.args, scope);
+		if (arrayLen !== null) return intConst(BigInt(arrayLen));
 		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")
@@ -171,6 +243,53 @@ export const constantCheckMethods = {
 		return isLen ? intConst(BigInt(vals[0].v.length)) : null;
 	},
 
+	// A package variable named in an array length may be declared after the
+	// type (or variable) that uses it, so it is not defined yet: its declared
+	// type, or the type of its composite literal, is resolved from the spec.
+	_earlyPackageVarType(arg, scope) {
+		let e = arg;
+		while (e?.kind === "ParenExpr") e = e.expr;
+		if (e?.kind !== "Ident") return null;
+		// An untyped package variable is `any` until its initializer is typed.
+		const known = scope.lookup(e.name);
+		if (known && !isAny(known)) return null;
+		const entry = this._pkgVarSpecs?.get(e.name);
+		if (!entry || entry.busy) return null;
+		const { spec, index } = entry;
+		const lit = spec.value?.[index];
+		const typeNode =
+			spec.type ?? (lit?.kind === "CompositeLit" ? lit.typeExpr : null);
+		if (!typeNode) return null;
+		entry.busy = true;
+		try {
+			const t = this.resolveTypeNode(typeNode, this.globals);
+			// `[...]T{...}`: the length is the literal's highest index + 1.
+			return t?.kind === "array" && t.size === null && lit?.elems
+				? { ...t, size: compositeLitMaxIndex(lit.elems) + 1 }
+				: t;
+		} finally {
+			entry.busy = false;
+		}
+	},
+
+	// `len(a)` and `cap(a)` of an array (or pointer to an array) are constants
+	// unless `a` contains a function call or channel receive; `a` itself is not
+	// evaluated.  Returns the length, or null.
+	_constArrayLen(name, args, scope) {
+		if ((name !== "len" && name !== "cap") || args?.length !== 1) return null;
+		const arg = args[0];
+		if (hasCallOrReceive(arg)) return null;
+		let t = this._earlyPackageVarType(arg, scope);
+		if (!t) {
+			if (arg._type === undefined) this.checkExpr(arg, scope);
+			t = arg._type;
+		}
+		t = this.resolveType(t);
+		if (t?.kind === "pointer") t = this.resolveType(t.base);
+		if (t?.kind === "named") t = this.resolveType(t.underlying);
+		return t?.kind === "array" && Number.isInteger(t.size) ? t.size : null;
+	},
+
 	// Target type of a conversion call (`MyInt(x)`, `int32(x)`), or null.
 	_constConversionTarget(expr, scope) {
 		if (expr.args?.length !== 1) return null;
@@ -201,7 +320,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 +353,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);