gofront 1.9.0 → 1.9.1

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;

package/src/typechecker/expressions.js

@@ -44,6 +44,7 @@ import {
 	UNTYPED_COMPLEX,
 	UNTYPED_FLOAT,
 	UNTYPED_INT,
+	UNTYPED_RUNE,
 	UNTYPED_STRING,
 	VOID,
 } from "./types.js";
@@ -71,7 +72,7 @@ function minMaxType(at) {
 // Each value is (self, name, expr, argTypes, scope) => returnType.
 const BUILTIN_CHECK = {
 	len: (s, n, e, at) => s._checkBuiltinLen(n, e, at),
-	cap: (s, n, e, at) => s._checkBuiltinLen(n, e, at),
+	cap: (s, n, e, at, sc) => s._checkBuiltinLen(n, e, at, sc),
 	append: (s, _n, e, at) => {
 		const st = at[0] ?? ANY;
 		if (isArray(st)) {
@@ -93,6 +94,11 @@ const BUILTIN_CHECK = {
 					s._rejectSeqAsSlice(at[i], e.args[i], "a spread argument");
 				if (!e.args[i]._spread && at[i]) {
 					if (is64) e.args[i]._is64Bit = true;
+					s._tagComplexConst(
+						s.resolveType(sb.elem),
+						s.resolveType(at[i]),
+						e.args[i],
+					);
 					s._markIfaceBox(
 						s.resolveType(sb.elem),
 						s.resolveType(at[i]),
@@ -106,7 +112,10 @@ const BUILTIN_CHECK = {
 	copy: (s, _n, e, at) => s._checkBuiltinCopy(e, at),
 	delete: (s, _n, e, at) => {
 		const mt = s._deepUnderlying(at[0]);
-		if (mt?.kind === "map" && e.args[1]) s._markIfaceKey(mt, e.args[1], at[1]);
+		if (mt?.kind === "map" && e.args[1]) {
+			s._tagFloat32Const(s.resolveType(mt.key), at[1], e.args[1]);
+			s._markIfaceKey(mt, e.args[1], at[1]);
+		}
 		return VOID;
 	},
 	make: (s, _n, e, _at, sc) => {
@@ -117,6 +126,8 @@ const BUILTIN_CHECK = {
 		// `make(S, n)` with S a type parameter makes its core type.
 		const core = made.kind === "typeParam" ? s._coreType(made, sc) : null;
 		if (core) ta._coreType = core;
+		for (const size of e.args.slice(1, 3))
+			s._checkIntegerConstOperand(size, "size", sc);
 		return made;
 	},
 	new: (s, _n, e, _at, sc) => {
@@ -134,14 +145,37 @@ const BUILTIN_CHECK = {
 	},
 	recover: () => ANY,
 	error: () => ERROR,
-	min: (_s, _n, _e, at) => minMaxType(at),
-	max: (_s, _n, _e, at) => minMaxType(at),
+	min: (s, _n, e, at) => s._checkMinMax(e, at),
+	max: (s, _n, e, at) => s._checkMinMax(e, at),
 	clear: () => VOID,
 	complex: (s, _n, e, at) => s._checkBuiltinComplex(e, at),
 	real: (s, n, e, at) => s._checkBuiltinRealImag(n, e, at),
 	imag: (s, n, e, at) => s._checkBuiltinRealImag(n, e, at),
 };
 
+// Type kinds that are never valid as an index, slice bound or `make` size.
+const NON_INTEGER_KINDS = new Set([
+	"struct",
+	"pointer",
+	"slice",
+	"map",
+	"func",
+	"array",
+	"interface",
+	"simd",
+]);
+
+// Basic types that are never valid as an index, slice bound or `make` size.
+const NON_INTEGER_BASICS = new Set([
+	"float32",
+	"float64",
+	"complex64",
+	"complex128",
+	"bool",
+	"string",
+	"any",
+]);
+
 // Method-name dispatch for _checkExpr — string values add no static call edges.
 const CHECK_EXPR_DELEGATE = {
 	UnaryExpr: "_checkUnaryExpr",
@@ -171,7 +205,7 @@ export const expressionCheckMethods = {
 			case "BasicLit": {
 				switch (expr.litKind) {
 					case "INT":
-						return UNTYPED_INT;
+						return expr.rune ? UNTYPED_RUNE : UNTYPED_INT;
 					case "FLOAT":
 						return UNTYPED_FLOAT;
 					case "STRING":
@@ -260,6 +294,10 @@ export const expressionCheckMethods = {
 					this._retypeUntypedShift(lt, rt, expr.right);
 					this._retypeUntypedShift(rt, lt, expr.left);
 				}
+				this._tagFloat32Const(lt, rt, expr.right);
+				this._tagFloat32Const(rt, lt, expr.left);
+				this._tagComplex64Const(lt, rt, expr.right);
+				this._tagComplex64Const(rt, lt, expr.left);
 				if (is64BitInt(lt) && rt?.kind === "untyped" && expr.right)
 					expr.right._is64Bit = true;
 				if (is64BitInt(rt) && lt?.kind === "untyped" && expr.left)
@@ -310,7 +348,8 @@ export const expressionCheckMethods = {
 
 	_checkBoolUnaryOp(ot, expr) {
 		if (!isBool(ot) && !isAny(ot)) this.err("! requires bool", expr);
-		return BOOL;
+		// `!` keeps an untyped or defined bool type.
+		return isBool(ot) ? ot : BOOL;
 	},
 
 	_checkNumericUnaryOp(ot, expr) {
@@ -826,6 +865,15 @@ export const expressionCheckMethods = {
 	// with its dynamic type, so `L("1")`, `N(1)`, `"1"` and `1` stay distinct.
 	// A named basic value is boxed first, exactly as in any interface
 	// conversion; other values are keyed as they are.
+	// Untyped constant operands take the result type, so a float32 result
+	// rounds them like the typed operands.
+	_checkMinMax(e, at) {
+		const rt = minMaxType(at);
+		for (let i = 0; i < e.args.length; i++)
+			this._tagFloat32Const(rt, at[i], e.args[i]);
+		return rt;
+	},
+
 	_markIfaceKey(mapType, node, srcType) {
 		const key = this.resolveType(mapType.key);
 		const kb = key?.kind === "named" ? this.resolveType(key.underlying) : key;
@@ -866,6 +914,8 @@ export const expressionCheckMethods = {
 		if (bt?._tainted) return TAINTED_ANY;
 		if (isAny(bt)) return ANY;
 		const btu = this._coreUnderlying(bt, scope);
+		if (btu.kind !== "map")
+			this._checkIntegerConstOperand(expr.index, "index", scope);
 		if (btu.kind === "slice" || btu.kind === "array") {
 			this._checkArrayBoundsExpr(btu, bt, expr, scope);
 			return btu.elem;
@@ -955,15 +1005,61 @@ export const expressionCheckMethods = {
 		return t.base;
 	},
 
+	// An index, slice bound or `make` size that is a constant must be an
+	// integer (`s[1 == 1]`, `make([]int, "a")`).
+	// A typed operand must have an integer type too (`s[f]` with `f float64`).
+	_checkIntegerConstOperand(operand, what, scope) {
+		const kind = this._nonIntegerConst(operand, scope);
+		if (kind) {
+			this.err(
+				`invalid argument: ${what} ${exprText(operand)} (${kind}) must be integer`,
+				operand,
+			);
+			return;
+		}
+		const t = operand?._type;
+		if (!this._isNonIntegerType(t, scope)) return;
+		this.err(
+			`invalid argument: ${what} ${exprText(operand)} (${operandKind(operand, typeStr(t), false)}) must be integer`,
+			operand,
+		);
+	},
+
+	// Whether `t` is a type (or a defined type over one) that is not an
+	// integer: a float, complex, bool, string, `any`, struct, pointer, slice,
+	// map, func, array, interface, simd vector or a type parameter whose type
+	// set is not all integers.  Untyped constants are judged by
+	// `_nonIntegerConst`, so only untyped non-integers that reach here
+	// (`s[a == b]`) count.
+	_isNonIntegerType(t, scope) {
+		if (!t || t._tainted) return false;
+		// A type parameter is an integer only when every type in its type set
+		// is (`~int | ~uint8`); `any`, `comparable` and method-only
+		// constraints have no integer type set.
+		if (t.kind === "typeParam") {
+			const terms = this._constraintTerms(t.constraint, new Set(), scope);
+			return !(terms?.length > 0 && terms.every(isInteger));
+		}
+		if (t.kind === "untyped")
+			return (
+				t.base === "bool" || t.base === "string" || t.base === "complex128"
+			);
+		const u = this._deepUnderlying(t);
+		if (u?.kind === "basic") return NON_INTEGER_BASICS.has(u.name);
+		return NON_INTEGER_KINDS.has(u?.kind);
+	},
+
 	_checkSliceExpr(expr, scope) {
 		const bt = this._derefArrayPtr(
 			expr,
 			"expr",
 			this.checkExpr(expr.expr, scope),
 		);
-		if (expr.low) this.checkExpr(expr.low, scope);
-		if (expr.high) this.checkExpr(expr.high, scope);
-		if (expr.max) this.checkExpr(expr.max, scope);
+		for (const bound of [expr.low, expr.high, expr.max]) {
+			if (!bound) continue;
+			this.checkExpr(bound, scope);
+			this._checkIntegerConstOperand(bound, "index", scope);
+		}
 		if (bt?._tainted) return TAINTED_ANY;
 		if (isAny(bt)) return ANY;
 		const btu = this._coreUnderlying(bt, scope);
@@ -1070,6 +1166,16 @@ export const expressionCheckMethods = {
 		// `any(x)` / `error(x)`: box x as an implicit conversion would.
 		this._markIfaceBox(targetType, srcType, expr.expr);
 		this._rejectNilConversion(srcType, targetType, expr);
+		if (this._checkIfaceConversion(srcType, targetType, expr, expr.expr))
+			return targetType;
+		if (
+			srcType &&
+			targetType &&
+			!isAny(srcType) &&
+			!isAny(targetType) &&
+			this._checkIfaceTargetConversion(srcType, targetType, expr.expr)
+		)
+			return targetType;
 		const srcResolved =
 			srcType?.kind === "named" ? srcType.underlying : srcType;
 		const tgtResolved =
@@ -1090,6 +1196,8 @@ export const expressionCheckMethods = {
 				expr,
 			);
 		}
+		// `complex64(1 + 0.01i)`: the constant's components round to float32.
+		this._tagComplex64Const(targetType, srcType, expr.expr);
 		if (tgtResolved?.kind === "slice")
 			this._rejectSeqAsSlice(srcType, expr.expr, "a slice conversion");
 		if (this._isMutualArraySlice(tgtResolved, srcResolved)) {
@@ -1138,8 +1246,25 @@ export const expressionCheckMethods = {
 		return true;
 	},
 
+	// `I(x)` with I an interface type converts exactly when x is assignable to
+	// I, so the method-set check (and its wording) is the assignment one.
+	_checkIfaceTargetConversion(srcType, targetType, operand) {
+		// `error("msg")` builds an error value (GoFront extension).
+		if (targetType === ERROR && isString(srcType)) return false;
+		const base = this.resolveType(
+			targetType.kind === "named" ? targetType.underlying : targetType,
+		);
+		if (base?.kind !== "interface" || !operand) return false;
+		this.assertAssignable(targetType, srcType, operand, "conversion");
+		return true;
+	},
+
 	_checkConversionValidity(srcType, targetType, expr) {
+		if (this._checkIfaceConversion(srcType, targetType, expr, expr.args?.[0]))
+			return;
 		if (!srcType || !targetType || isAny(srcType) || isAny(targetType)) return;
+		if (this._checkIfaceTargetConversion(srcType, targetType, expr.args?.[0]))
+			return;
 		const srcResolved = srcType.kind === "named" ? srcType.underlying : srcType;
 		const tgtResolved =
 			targetType.kind === "named" ? targetType.underlying : targetType;
@@ -1813,6 +1938,14 @@ export const expressionCheckMethods = {
 			const node = expr._multiForward ? null : expr.args[i];
 			this.assertAssignable(targetParam, argTypes[i], node, "argument");
 		}
+		// `g(f())`: per-element box marks for lowering to split the forward.
+		if (
+			expr._multiForward &&
+			!fnType.variadic &&
+			!this._skipIfaceMark &&
+			fnType.params.length === argTypes.length
+		)
+			this._markForwardedElems(fnType.params, argTypes, expr.args[0]);
 
 		this._checkSimdLaneArgs(expr, scope);
 	},
@@ -1878,7 +2011,28 @@ export const expressionCheckMethods = {
 		return null;
 	},
 
-	_checkBuiltinLen(name, expr, argTypes) {
+	_capOperandKind(operand, type) {
+		const untypedConst = type?.kind === "untyped" && type.base !== "nil";
+		return untypedConst
+			? operandKind(operand, type.base, true)
+			: operandKind(operand, typeStr(type), false);
+	},
+
+	// `cap` takes a slice or an array (a pointer to an array is dereferenced
+	// before this check). A type parameter needs a slice or array core type;
+	// one with no single core type is left to instantiation. Unknown and
+	// `any` operands (JS interop) are not judged.
+	_capOperandOk(t, scope) {
+		if (!t || t._tainted || isAny(t)) return true;
+		if (t.kind === "typeParam") {
+			const core = this._coreType(t, scope);
+			return !core || core.kind === "slice" || core.kind === "array";
+		}
+		const kind = this._deepUnderlying(t)?.kind;
+		return kind === "slice" || kind === "array";
+	},
+
+	_checkBuiltinLen(name, expr, argTypes, scope) {
 		this._rejectSeqAsSlice(argTypes[0], expr.args?.[0], `${name}()`);
 		const operand = expr.args?.[0];
 		if (expr.args?.length === 1)
@@ -1891,17 +2045,14 @@ export const expressionCheckMethods = {
 			if (expr.args.length === 1) expr.args[0] = operand;
 		}
 		if (name === "cap") {
-			if (
-				(argTypes[0]?.underlying ?? argTypes[0])?.kind === "map" ||
-				isString(argTypes[0])
-			) {
+			if (sharedInfo(argTypes[0])) {
 				this.err(
-					`invalid argument: ${exprText(expr.args?.[0])} (${operandKind(expr.args?.[0], typeStr(argTypes[0]), false)}) for cap`,
+					`cannot use cap() on ${typeStr(argTypes[0])}: shared buffers have a fixed size; use len()`,
 					expr,
 				);
-			} else if (sharedInfo(argTypes[0])) {
+			} else if (!this._capOperandOk(argTypes[0], scope)) {
 				this.err(
-					`cannot use cap() on ${typeStr(argTypes[0])}: shared buffers have a fixed size; use len()`,
+					`invalid argument: ${exprText(expr.args?.[0])} (${this._capOperandKind(expr.args?.[0], argTypes[0])}) for cap`,
 					expr,
 				);
 			}
@@ -1935,6 +2086,9 @@ export const expressionCheckMethods = {
 					expr,
 				);
 			}
+			// An untyped operand takes type float32 (`complex(f, 0.01)`).
+			this._tagFloat32Const(FLOAT32, crt, expr.args[0]);
+			this._tagFloat32Const(FLOAT32, cit, expr.args[1]);
 			return COMPLEX64;
 		}
 		return COMPLEX128;