gofront 1.9.0 → 1.9.2

package/src/typechecker/assignability.js

@@ -12,6 +12,7 @@ import {
 	FLOAT64,
 	is64BitInt,
 	isAny,
+	isBool,
 	isComplex,
 	isComplex64,
 	isComplexOrNumeric,
@@ -27,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.
@@ -63,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 ───────────────────────────────────────────
@@ -71,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;
 	},
 
@@ -137,7 +171,8 @@ export const assignabilityMethods = {
 		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) {
@@ -163,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
@@ -229,6 +264,19 @@ export const assignabilityMethods = {
 		}
 	},
 
+	// 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).
@@ -265,6 +313,17 @@ export const assignabilityMethods = {
 			!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
@@ -275,6 +334,7 @@ export const assignabilityMethods = {
 		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);
@@ -442,11 +502,13 @@ export const assignabilityMethods = {
 	},
 
 	// An interface-typed operand needs an explicit type assertion before it can
-	// flow into a concrete (non-interface) type.
+	// 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)) 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,
@@ -454,6 +516,31 @@ export const assignabilityMethods = {
 		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;
@@ -584,12 +671,7 @@ 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" ||
-			// rune was historically int in GoFront; keep rune/int interchangeable.
-			pair === "int:int32" ||
-			pair === "int32:int"
-		);
+		return pair === "float64:int";
 	},
 
 	// The lenient numeric pairs: accepted, except that a generic call result

package/src/typechecker/constants.js

@@ -15,7 +15,28 @@ import {
 	INT_RANGES,
 	intConst,
 } 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([
@@ -38,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>} */
@@ -49,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) {
@@ -58,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) {
@@ -83,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;
@@ -128,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)
@@ -159,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")
@@ -168,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;