gofront 1.8.0 → 1.9.1

package/src/typechecker/expressions.js

@@ -1,9 +1,14 @@
 // TypeChecker expression-checking methods — installed as a mixin on TypeChecker.prototype.
 
-import { EXCLUDED_STDLIB_MEMBERS } from "./stdlib/excluded.js";
+import { exprText, operandKind } from "./operand-text.js";
+import {
+	EXCLUDED_STDLIB_MEMBERS,
+	EXCLUDED_STDLIB_PACKAGES,
+} from "./stdlib/excluded.js";
 import { sharedInfo } from "./stdlib/shared.js";
 import {
 	ANY,
+	BASIC_TYPES,
 	BOOL,
 	BROWSER_GLOBALS,
 	COMPLEX64,
@@ -11,9 +16,12 @@ import {
 	compositeLitMaxIndex,
 	displayTypeName,
 	ERROR,
+	embeddedFieldName,
 	FLOAT32,
 	FLOAT64,
+	FMT_PRINT_FUNCS,
 	INT,
+	is64BitInt,
 	isAny,
 	isArray,
 	isBool,
@@ -21,6 +29,7 @@ import {
 	isComplex64,
 	isComplexOrNumeric,
 	isInteger,
+	isNil,
 	isNumeric,
 	isString,
 	NIL,
@@ -30,14 +39,25 @@ import {
 	STRING,
 	TAINTED_ANY,
 	typeStr,
+	UINT8,
 	UNTYPED_BOOL,
 	UNTYPED_COMPLEX,
 	UNTYPED_FLOAT,
 	UNTYPED_INT,
+	UNTYPED_RUNE,
 	UNTYPED_STRING,
 	VOID,
 } from "./types.js";
 
+const NILABLE_KINDS = new Set([
+	"slice",
+	"map",
+	"pointer",
+	"func",
+	"interface",
+	"chan",
+]);
+
 /** @typedef {import('./index.js').TypeChecker} TypeChecker */
 
 // min/max: the type of the first typed operand; with only untyped constants,
@@ -52,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)) {
@@ -68,15 +88,23 @@ const BUILTIN_CHECK = {
 		}
 		const sb = s.resolveType(st?.kind === "named" ? st.underlying : st);
 		if (sb?.kind === "slice") {
+			const is64 = is64BitInt(sb.elem);
 			for (let i = 1; i < e.args.length; i++) {
 				if (e.args[i]._spread)
 					s._rejectSeqAsSlice(at[i], e.args[i], "a spread argument");
-				if (!e.args[i]._spread && at[i])
+				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]),
 						e.args[i],
 					);
+				}
 			}
 		}
 		return st;
@@ -84,14 +112,23 @@ 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) => {
 		if (e.args.length < 1) return ANY;
 		const ta = e.args[0];
 		const tn = ta.kind === "TypeExpr" ? ta.type : ta;
-		return s.resolveTypeNode(tn, sc) ?? ANY;
+		const made = s.resolveTypeNode(tn, sc) ?? ANY;
+		// `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) => {
 		if (e.args.length < 1) return ANY;
@@ -101,17 +138,44 @@ const BUILTIN_CHECK = {
 	},
 	print: (s, n, e, at) => s._checkPrintArgs(n, e, at),
 	println: (s, n, e, at) => s._checkPrintArgs(n, e, at),
-	panic: () => VOID,
+	panic: (s, _n, e, at) => {
+		// The operand converts to `any`, so a defined type keeps its identity.
+		if (e.args[0] && at?.[0]) s._markIfaceBox(ANY, at[0], e.args[0]);
+		return VOID;
+	},
 	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",
@@ -141,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":
@@ -157,8 +221,35 @@ export const expressionCheckMethods = {
 				return UNTYPED_COMPLEX;
 			case "Ident": {
 				const t = scope.lookup(expr.name);
-				if (!t) return this.err(`Undefined: '${expr.name}'`, expr);
-				if (this.types.has(expr.name) || t.kind === "typeParam")
+				// `(*int)(nil)`: a predeclared type named where a type may stand.
+				if (!t && expr._typeRefOk && Object.hasOwn(BASIC_TYPES, expr.name)) {
+					expr._isTypeRef = true;
+					return BASIC_TYPES[expr.name];
+				}
+				if (!t) {
+					// The import of an excluded package already reported; its
+					// uses are not a second root cause.
+					const imported = this._fileImports
+						?.get(this._currentFile)
+						?.get(expr.name);
+					if (imported && EXCLUDED_STDLIB_PACKAGES.has(imported))
+						return TAINTED_ANY;
+					if (this._unavailableImports?.has(expr.name)) return TAINTED_ANY;
+					// `gom` needs no import in a js package; wasm packages get
+					// the same answer as an `import "gom"`.
+					if (
+						expr.name === "gom" &&
+						(this.target === "wasm" || this.target === "both")
+					) {
+						this.recordBlocker("gom usage", "gom");
+						return this.err(
+							"package 'gom' is not available in wasm packages",
+							expr,
+						);
+					}
+					return this.err(`Undefined: '${expr.name}'`, expr);
+				}
+				if (this._namesType(expr.name, t, scope) || t.kind === "typeParam")
 					expr._isTypeRef = true;
 				// A Go declaration that shadows a browser global: JS output renames
 				// it so generated code keeps reaching the real global.  Package
@@ -188,14 +279,6 @@ export const expressionCheckMethods = {
 						`(package '${this.pkgName}' is //gofront:target ${this.target} — browser globals are only available in js packages)`,
 					);
 				}
-				if (
-					(this.target === "wasm" || this.target === "both") &&
-					expr.name === "gom" &&
-					scope.lookup(expr.name) === this.globals.lookup(expr.name)
-				) {
-					this.recordBlocker("gom usage", "gom");
-					this.err("package 'gom' is not available in wasm packages", expr);
-				}
 				return t;
 			}
 			case "BinaryExpr": {
@@ -205,7 +288,21 @@ export const expressionCheckMethods = {
 				if (isAny(lt) || isAny(rt))
 					return this.binaryResultType(expr.op, ANY, ANY, expr);
 				this._checkConstOperands(expr.op, lt, rt, expr);
-				return this.binaryResultType(expr.op, lt, rt, expr);
+				this._markTypeParamMapNil(expr, lt, rt, scope);
+				const res = this.binaryResultType(expr.op, lt, rt, expr);
+				if (expr.op !== "<<" && expr.op !== ">>") {
+					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)
+					expr.left._is64Bit = true;
+				return res;
 			}
 			case "AwaitExpr": {
 				if (this.target === "wasm" || this.target === "both") {
@@ -251,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) {
@@ -281,23 +379,32 @@ export const expressionCheckMethods = {
 		return terms !== null && terms.length > 0 && terms.every(pred);
 	},
 
-	_constraintTerms(c, seen) {
+	// `scope` resolves the type parameters a term mentions (`~[]E`); it
+	// defaults to the package scope.
+	_constraintTerms(c, seen, scope = this.globals) {
 		if (!c || seen.has(c)) return null;
 		seen.add(c);
 		// Receiver type parameters keep their constraint as an AST node.
-		if (c.kind === "TypeName" || c.kind === "InterfaceType")
-			return this._constraintTerms(this.resolveTypeNode(c, this.globals), seen);
-		if (c.kind === "named") return this._constraintTerms(c.underlying, seen);
-		if (c.kind === "interface") return this._interfaceTerms(c, seen);
+		if (
+			c.kind === "TypeName" ||
+			c.kind === "InterfaceType" ||
+			c.kind === "GenericTypeName" ||
+			c.kind === "InstantiationExpr" ||
+			c.kind === "IndexExpr"
+		)
+			return this._constraintTerms(this.resolveTypeNode(c, scope), seen, scope);
+		if (c.kind === "named")
+			return this._constraintTerms(c.underlying, seen, scope);
+		if (c.kind === "interface") return this._interfaceTerms(c, seen, scope);
 		if (c.kind === "typeParam")
-			return this._constraintTerms(c.constraint, seen);
+			return this._constraintTerms(c.constraint, seen, scope);
 		if (c.kind !== "UnionConstraint") return isAny(c) ? null : [c];
 		const out = [];
 		for (const term of c.terms) {
-			const t = this.resolveTypeNode(term.type, this.globals);
+			const t = term.resolved ?? this.resolveTypeNode(term.type, scope);
 			const inner =
 				t?.kind === "named" && t.underlying?.kind === "interface"
-					? this._constraintTerms(t, seen)
+					? this._constraintTerms(t, seen, scope)
 					: [t];
 			if (inner === null) return null;
 			out.push(...inner);
@@ -307,10 +414,10 @@ export const expressionCheckMethods = {
 
 	// An interface's type set is the intersection of its own union and the
 	// type sets of the interfaces it embeds; null when it has none.
-	_interfaceTerms(iface, seen) {
+	_interfaceTerms(iface, seen, scope) {
 		const sets = [iface.unionConstraint, ...(iface._typeSetEmbeds ?? [])]
 			.filter(Boolean)
-			.map((s) => this._constraintTerms(s, new Set(seen)));
+			.map((s) => this._constraintTerms(s, new Set(seen), scope));
 		if (sets.length === 0 || sets.includes(null)) return null;
 		const [first, ...rest] = sets;
 		return first.filter((t) =>
@@ -608,6 +715,11 @@ export const expressionCheckMethods = {
 		const base = this.resolveType(
 			recvT?.kind === "named" ? recvT.underlying : recvT,
 		);
+		if (base?.kind === "interface" && base.methods?.has(expr.field)) {
+			// `i.M` binds the interface value; the call dispatches when it runs.
+			expr._isMethodValue = true;
+			return;
+		}
 		if (!recvT || !this._isStructOrNamedMethod(recvT, base, expr.field)) return;
 		expr._isMethodValue = true;
 		if (baseType.kind === "pointer")
@@ -615,6 +727,16 @@ export const expressionCheckMethods = {
 		else this._markPtrRecvAddress(expr, base, ft, scope);
 	},
 
+	// Whether the identifier `name`, which resolved to `t`, names a type.  A
+	// local variable or parameter that shares its name with a type of the
+	// build (the type table spans packages) is a value.
+	_namesType(name, t, scope) {
+		if (!this.types.has(name)) return false;
+		return (
+			scope.lookupScope(name) === this.globals || this.types.get(name) === t
+		);
+	},
+
 	_checkSelectorExpr(expr, scope) {
 		expr.expr._typeRefOk = true;
 		const baseType = this.checkExpr(expr.expr, scope);
@@ -688,10 +810,70 @@ export const expressionCheckMethods = {
 		return u;
 	},
 
+	// Core type of type parameter `tp`: the one underlying type shared by every
+	// type in its constraint (`~[]E`, `~map[K]V`), or null when there is none.
+	_coreType(tp, scope) {
+		if (tp?.kind !== "typeParam") return null;
+		const terms = this._constraintTerms(tp.constraint, new Set(), scope);
+		if (!terms || terms.length === 0) return null;
+		const unders = terms.map((t) => this._deepUnderlying(this.resolveType(t)));
+		const key = typeStr(unders[0]);
+		if (unders.some((u) => !u || typeStr(u) !== key)) return null;
+		return unders[0];
+	},
+
+	// `m == nil` on a type parameter whose core type is a map: the backends
+	// compare it as a map, so record the core type on the operand.
+	_markTypeParamMapNil(expr, lt, rt, scope) {
+		if (expr.op !== "==" && expr.op !== "!=") return;
+		const [operand, other] =
+			rt === NIL
+				? [expr.left, lt]
+				: lt === NIL
+					? [expr.right, rt]
+					: [null, null];
+		if (!operand || other?.kind !== "typeParam") return;
+		const core = this._coreType(other, scope);
+		if (core?.kind === "map") operand._coreType = core;
+	},
+
+	// Underlying type of `t` for indexing, slicing, ranging and the like; a
+	// type parameter stands for its core type.
+	_coreUnderlying(t, scope) {
+		if (t?.kind === "typeParam") return this._coreType(t, scope) ?? t;
+		return this._deepUnderlying(t);
+	},
+
+	// One step of underlying type, or the core type for a type parameter.
+	_underlyingOrCore(t, scope) {
+		if (t?.kind === "typeParam") return this._coreType(t, scope) ?? t;
+		return t?.kind === "named" ? t.underlying : t;
+	},
+
+	_markCompositeKey(key, kb, node, srcType) {
+		if (!node || !srcType || isAny(key) || kb?.kind === "interface")
+			return false;
+		// Arrays, anonymous structs and pointers are not JS property names: the
+		// backend encodes them by value (`sk`) or by identity (`pk`).
+		if (kb?.kind === "pointer") node._mapKeyEnc = "pk";
+		else if (kb?.kind === "array" || (key?.kind === "struct" && kb === key))
+			node._mapKeyEnc = "sk";
+		return true;
+	},
+
 	// A key of an interface-keyed map (`map[any]T`): the backend encodes it
 	// 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;
@@ -705,8 +887,10 @@ export const expressionCheckMethods = {
 			}
 			return;
 		}
+		if (this._markCompositeKey(key, kb, node, srcType)) return;
 		if (!node || !srcType || (!isAny(key) && kb?.kind !== "interface")) return;
 		node._ifaceKey = true;
+		node._ifaceKeyType = src;
 		this._markIfaceBox(key, this.resolveType(srcType), node);
 		if (node._ifaceBox === "named" || node._ifaceBox === "named_ptr") return;
 		node._ifaceBox = undefined;
@@ -729,13 +913,16 @@ export const expressionCheckMethods = {
 		const indexType = this.checkExpr(expr.index, scope);
 		if (bt?._tainted) return TAINTED_ANY;
 		if (isAny(bt)) return ANY;
-		const btu = this._deepUnderlying(bt);
+		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;
 		}
 		if (btu.kind === "map") {
 			expr._mapValueType = btu.value;
+			this.assertAssignable(btu.key, indexType, expr.index);
 			this._markIfaceKey(btu, expr.index, indexType);
 			return btu.value;
 		}
@@ -746,7 +933,7 @@ export const expressionCheckMethods = {
 				this.err(`invalid index ${idx} (index must not be negative)`, expr);
 			return btu.elem;
 		}
-		if (isString(bt)) return INT;
+		if (isString(bt)) return UINT8;
 		return this.err(`Cannot index type ${typeStr(bt)}`, expr);
 	},
 
@@ -756,6 +943,12 @@ export const expressionCheckMethods = {
 	_genericFuncValueAsInstantiation(expr) {
 		const toTypeNode = (n) => {
 			if (n?.kind === "TypeExpr") return n.type;
+			// `Id[*int]`: the parser sees a dereference; on a generic function
+			// it is a pointer type argument.
+			if (n?.kind === "UnaryExpr" && n.op === "*") {
+				const base = toTypeNode(n.operand);
+				return base && { kind: "PointerType", base, _line: n._line };
+			}
 			const parts = [];
 			let cur = n;
 			while (cur?.kind === "SelectorExpr") {
@@ -812,18 +1005,64 @@ 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._deepUnderlying(bt);
+		const btu = this._coreUnderlying(bt, scope);
 		if (btu.kind === "slice" || btu.kind === "array")
 			return { kind: "slice", elem: btu.elem };
 		if (isString(bt)) return STRING;
@@ -862,9 +1101,12 @@ export const expressionCheckMethods = {
 		const ret = expr.returnType
 			? this.resolveTypeNode(expr.returnType, scope)
 			: VOID;
+		const bodyRet = this._injectNamedReturns(expr.returnType, inner)
+			? { ...ret, _hasNamedReturns: true }
+			: ret;
 		const savedDefer = this._deferCount;
 		this._deferCount = 0;
-		this.checkBlock(expr.body, inner, ret);
+		this.checkBlock(expr.body, inner, bodyRet);
 		this._reportUnused(inner, expr);
 		if (this._deferCount > 0) expr.body._hasDefer = true;
 		this._deferCount = savedDefer;
@@ -923,6 +1165,17 @@ export const expressionCheckMethods = {
 		const targetType = this.resolveTypeNode(expr.targetType, scope);
 		// `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 =
@@ -943,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)) {
@@ -964,12 +1219,59 @@ export const expressionCheckMethods = {
 		return targetType;
 	},
 
+	// `int(nil)`: only a type with a nil value converts from `nil`.
+	_rejectNilConversion(srcType, targetType, expr) {
+		if (!isNil(srcType) || !targetType || isAny(targetType)) return;
+		if (targetType.kind === "typeParam") return;
+		const kind = this._deepUnderlying(targetType)?.kind;
+		if (!kind || NILABLE_KINDS.has(kind)) return;
+		this.err(`cannot convert nil to ${typeStr(targetType)}`, expr);
+	},
+
+	// Pointers convert when their base types share an underlying type.
+	_pointerConversionOk(srcPtr, tgtPtr, srcType, targetType, expr) {
+		const sBase = this._deepUnderlying(srcPtr.base);
+		const tBase = this._deepUnderlying(tgtPtr.base);
+		if (typeStr(sBase) === typeStr(tBase)) return true;
+		if (!this._sameStructFields(sBase, tBase)) return false;
+		// WebAssembly struct types are nominal: the two pointers could not
+		// share one object.
+		if (this.target === "wasm" || this.target === "both") {
+			this.recordBlocker("pointer conversion between struct types");
+			this.err(
+				`cannot convert ${typeStr(srcType)} to ${typeStr(targetType)} in a wasm package: pointers to distinct struct types cannot share storage; keep this code in a js package`,
+				expr,
+			);
+		}
+		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;
 
+		// `nil` converts to any type that has a nil value.
+		if (isNil(srcType) && NILABLE_KINDS.has(tgtResolved?.kind)) return;
+
 		if (isNumeric(targetType) && isComplex(srcType)) {
 			this.err(
 				`cannot convert ${typeStr(srcType)} to ${typeStr(targetType)} (use real() or imag())`,
@@ -1032,17 +1334,18 @@ export const expressionCheckMethods = {
 						srcResolved.elem?.name === "int32")))
 		)
 			return;
-		if (srcResolved?.kind === "pointer" && tgtResolved?.kind === "pointer") {
-			const sBase =
-				srcResolved.base?.kind === "named"
-					? srcResolved.base.underlying
-					: srcResolved.base;
-			const tBase =
-				tgtResolved.base?.kind === "named"
-					? tgtResolved.base.underlying
-					: tgtResolved.base;
-			if (typeStr(sBase) === typeStr(tBase)) return;
-		}
+		if (
+			srcResolved?.kind === "pointer" &&
+			tgtResolved?.kind === "pointer" &&
+			this._pointerConversionOk(
+				srcResolved,
+				tgtResolved,
+				srcType,
+				targetType,
+				expr,
+			)
+		)
+			return;
 		this.err(
 			`cannot convert ${typeStr(srcType)} to ${typeStr(targetType)}`,
 			expr,
@@ -1052,6 +1355,7 @@ export const expressionCheckMethods = {
 	_checkTypeAssertExpr(expr, scope) {
 		const srcType = this.checkExpr(expr.expr, scope);
 		const targetType = this.resolveTypeNode(expr.type, scope);
+		this._markDynamicType(expr.type, targetType);
 
 		// In Go, the source of a type assertion must be an interface type.
 		// We allow `any` (which is GoFront's basic any) and interface types.
@@ -1091,8 +1395,10 @@ export const expressionCheckMethods = {
 			"expr",
 			this.checkExpr(expr.expr, scope),
 		);
-		const resolved =
-			collType?.kind === "named" ? collType.underlying : collType;
+		const resolved = this._underlyingOrCore(collType, scope);
+		// Backends range over the core type of a type parameter.
+		if (collType?.kind === "typeParam" && resolved !== collType)
+			expr.expr._coreType = resolved;
 		return this._rangeCollTypeTuple(resolved, collType);
 	},
 
@@ -1119,7 +1425,10 @@ export const expressionCheckMethods = {
 			) {
 				const tp = baseType.typeParams[i];
 				const constraint = tp.constraint
-					? this.resolveTypeNode(tp.constraint, scope)
+					? this.resolveTypeNode(
+							tp.constraint,
+							this._typeArgScope(baseType.typeParams, typeArgs, scope),
+						)
 					: null;
 				if (constraint) this.checkConstraint(typeArgs[i], constraint, expr);
 			}
@@ -1298,12 +1607,12 @@ export const expressionCheckMethods = {
 			if (!resolved) return null;
 			fnType = resolved;
 		}
-		return this._completePartialInstantiation(expr, argTypes) ?? fnType;
+		return this._completePartialInstantiation(expr, argTypes, scope) ?? fnType;
 	},
 
 	// `F[int](x)` with fewer explicit type arguments than type parameters:
 	// infer the rest from the call arguments and record the full list.
-	_completePartialInstantiation(expr, argTypes) {
+	_completePartialInstantiation(expr, argTypes, scope) {
 		const inst = expr.func;
 		const generic = inst?.kind === "InstantiationExpr" && inst._genericFnType;
 		if (!generic || inst._typeArgs.length >= generic.typeParams.length)
@@ -1312,6 +1621,7 @@ export const expressionCheckMethods = {
 			generic,
 			this._inferArgTypes(expr, argTypes),
 			inst._typeArgs,
+			scope,
 		);
 		if (!typeArgs) {
 			this.err(
@@ -1327,7 +1637,7 @@ export const expressionCheckMethods = {
 
 	// `T(x)` with T a type parameter: only a numeric x converts (the constraint
 	// decides the target at instantiation).
-	_checkTypeParamConversion(tp, argTypes, expr) {
+	_checkTypeParamConversion(tp, argTypes, expr, scope) {
 		expr._isTypeConversion = true;
 		expr._conversionTargetType = tp;
 		if (expr.args.length !== 1) {
@@ -1336,7 +1646,23 @@ export const expressionCheckMethods = {
 				expr,
 			);
 		}
-		if (isNumeric(argTypes[0]) && !this._constraintHasTypeSet(tp.constraint))
+		// A constraint with a core type (`~[]E`) converts as that type does.
+		const core = this._coreType(tp, scope);
+		if (core) {
+			const src = argTypes[0];
+			const nilOk = ["slice", "map", "pointer", "func", "chan", "interface"];
+			if (src === NIL || (src?.kind === "basic" && src.name === "nil")) {
+				if (!nilOk.includes(core.kind))
+					this.err(`cannot convert nil to ${typeStr(tp)}`, expr);
+			} else if (src?.kind !== "typeParam") {
+				this._checkConversionValidity(src, core, expr);
+			}
+			return tp;
+		}
+		if (
+			isNumeric(argTypes[0]) &&
+			!this._constraintHasTypeSet(tp.constraint, scope)
+		)
 			return this.err(
 				`cannot convert ${typeStr(argTypes[0])} to type ${typeStr(tp)}: ${typeStr(tp)} is not constrained to a set of convertible types`,
 				expr,
@@ -1356,18 +1682,38 @@ export const expressionCheckMethods = {
 	// A conversion to a type parameter needs a constraint that lists types
 	// (`~int | ~float64`, or an interface embedding such a union); `any`,
 	// `comparable` and method-only constraints allow every type argument.
-	_constraintHasTypeSet(constraint) {
+	_constraintHasTypeSet(constraint, scope = this.globals) {
 		if (!constraint) return true;
 		if (constraint.kind === "UnionConstraint") return true;
-		const c = this.resolveType(constraint);
+		// Receiver type parameters keep their constraint as an AST node.
+		const c = this.resolveType(
+			constraint.kind === "TypeName" || constraint.kind === "InterfaceType"
+				? this.resolveTypeNode(constraint, scope)
+				: constraint,
+		);
 		const base = c?.kind === "named" ? this.resolveType(c.underlying) : c;
 		if (base?.kind !== "interface") return false;
 		if (base.unionConstraint) return true;
 		return (base._typeSetEmbeds ?? []).some((e) =>
-			this._constraintHasTypeSet(e),
+			this._constraintHasTypeSet(e, scope),
 		);
 	},
 
+	// A direct call of a `//gofront:native` function is marked `_native` so a
+	// backend may substitute host code.  A function used as a value (`f :=
+	// str.Index; f(a, b)`) is not a direct reference and calls the Go body.
+	_markNativeCall(expr, fnType, scope) {
+		const callee =
+			expr.func.kind === "InstantiationExpr" ? expr.func.expr : expr.func;
+		const native = fnType?.native ?? fnType?.underlying?.native ?? null;
+		const direct =
+			callee.kind === "Ident"
+				? scope.lookupScope(callee.name) === this.globals &&
+					Boolean(this._funcDeclNames?.has(callee.name))
+				: callee.kind === "SelectorExpr" && Boolean(callee._stdName);
+		expr._native = native && direct ? native : null;
+	},
+
 	checkCall(expr, scope) {
 		expr.func._typeRefOk = true;
 		let fnType = this.checkExpr(expr.func, scope);
@@ -1391,6 +1737,7 @@ export const expressionCheckMethods = {
 			return this.checkBuiltin(fnType.name, expr, argTypes, scope);
 		}
 
+		this._markNativeCall(expr, fnType, scope);
 		const argTypes = this._resolveCallArgTypes(expr, scope);
 
 		if (fnType?._tainted) return TAINTED_ANY;
@@ -1401,7 +1748,12 @@ export const expressionCheckMethods = {
 
 		// Named type used as a constructor/conversion: Greeter(fn), NodeFunc(fn)
 		// The callee is a type name, not a callable variable.
-		if (fnType.kind === "named" && expr.func._isTypeRef) {
+		if (
+			(fnType.kind === "named" ||
+				fnType.kind === "pointer" ||
+				fnType.kind === "basic") &&
+			expr.func._isTypeRef
+		) {
 			expr._isTypeConversion = true;
 			expr._conversionTargetType = fnType;
 			if (expr.args.length !== 1) {
@@ -1416,7 +1768,7 @@ export const expressionCheckMethods = {
 		}
 
 		if (fnType.kind === "typeParam" && expr.func._isTypeRef) {
-			return this._checkTypeParamConversion(fnType, argTypes, expr);
+			return this._checkTypeParamConversion(fnType, argTypes, expr, scope);
 		}
 
 		fnType = this._resolveCallFnType(fnType, argTypes, expr, scope);
@@ -1427,13 +1779,6 @@ export const expressionCheckMethods = {
 
 		this._checkCallArgs(fnType, argTypes, expr, scope);
 
-		// Pseudo-generic stdlib helpers (maps.Keys, slices.Clone, ...) declare
-		// how their result derives from the first argument.
-		if (fnType._derivedReturn) {
-			const derived = this._derivedReturnType(fnType._derivedReturn, argTypes);
-			if (derived) return derived;
-		}
-
 		const ret = fnType.returns;
 		if (!ret || ret.length === 0) return VOID;
 		if (ret.length === 1) return ret[0];
@@ -1483,19 +1828,6 @@ export const expressionCheckMethods = {
 		);
 	},
 
-	_derivedReturnType(mode, argTypes) {
-		const arg = argTypes[0];
-		const under = arg?.kind === "named" ? arg.underlying : arg;
-		switch (mode) {
-			case "arg0":
-				return under ? arg : null;
-			case "elemOfArg0":
-				return under?.elem ?? null;
-			default:
-				return null;
-		}
-	},
-
 	// Argument types for inference: a spread argument `xs...` stands for its
 	// elements, which is what the variadic parameter type describes.
 	_inferArgTypes(expr, argTypes) {
@@ -1506,10 +1838,23 @@ export const expressionCheckMethods = {
 		});
 	},
 
+	// Scope where each type parameter name stands for its type argument, so a
+	// constraint that mentions another parameter (`S ~[]E`) resolves.
+	_typeArgScope(typeParams, typeArgs, scope) {
+		const out = new Scope(scope);
+		typeParams.forEach((tp, i) => {
+			if (typeArgs[i])
+				out.define(tp.name, { kind: "aliasArg", type: typeArgs[i] });
+		});
+		return out;
+	},
+
 	_resolveGenericFnType(fnType, argTypes, expr, scope) {
 		const typeArgs = this.inferTypeArgs(
 			fnType,
 			this._inferArgTypes(expr, argTypes),
+			[],
+			scope,
 		);
 		if (!typeArgs) {
 			this.err(
@@ -1522,7 +1867,10 @@ export const expressionCheckMethods = {
 		for (let i = 0; i < fnType.typeParams.length && i < typeArgs.length; i++) {
 			const tp = fnType.typeParams[i];
 			const constraint = tp.constraint
-				? this.resolveTypeNode(tp.constraint, scope)
+				? this.resolveTypeNode(
+						tp.constraint,
+						this._typeArgScope(fnType.typeParams, typeArgs, scope),
+					)
 				: null;
 			if (constraint) this.checkConstraint(typeArgs[i], constraint, expr);
 		}
@@ -1562,6 +1910,9 @@ export const expressionCheckMethods = {
 			!ns._gofront &&
 			!ns._mangle?.has(expr.func.field);
 		if (emitterBacked) return;
+		// The generated wrapper of a Print-family call takes the results as
+		// separate parameters (src/lower/fmt-formatters.js).
+		if (ns?.name === "fmt" && FMT_PRINT_FUNCS.has(expr.func.field)) return;
 		this.err(
 			"passing multiple return values to a variadic function is not supported in wasm packages; assign them to variables first",
 			expr,
@@ -1587,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);
 	},
@@ -1652,18 +2011,51 @@ 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)
 			argTypes[0] = this._derefArrayPtr(expr.args, 0, argTypes[0]);
-		if (name === "len") {
-			const size = this._constLenFromType(argTypes[0]);
-			if (size != null) expr._constLen = size;
-		} else if (sharedInfo(argTypes[0])) {
-			this.err(
-				`cannot use cap() on ${typeStr(argTypes[0])}: shared buffers have a fixed size; use len()`,
-				expr,
-			);
+		// `len` and `cap` of an array (or pointer to one) are its length.
+		const size = this._constLenFromType(argTypes[0]);
+		if (size != null) {
+			expr._constLen = size;
+			// The operand is not dereferenced: a nil `*[N]T` has length N.
+			if (expr.args.length === 1) expr.args[0] = operand;
+		}
+		if (name === "cap") {
+			if (sharedInfo(argTypes[0])) {
+				this.err(
+					`cannot use cap() on ${typeStr(argTypes[0])}: shared buffers have a fixed size; use len()`,
+					expr,
+				);
+			} else if (!this._capOperandOk(argTypes[0], scope)) {
+				this.err(
+					`invalid argument: ${exprText(expr.args?.[0])} (${this._capOperandKind(expr.args?.[0], argTypes[0])}) for cap`,
+					expr,
+				);
+			}
 		}
 		return INT;
 	},
@@ -1694,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;
@@ -1778,17 +2173,7 @@ export const expressionCheckMethods = {
 	_checkStructPositionalElems(expr, scope, t, base) {
 		const fieldNames = base._structFields
 			? base._structFields.flatMap((f) =>
-					f.embedded
-						? [
-								(
-									(f.type?.kind === "pointer"
-										? f.type.base?.name
-										: f.type?.name) ?? ""
-								)
-									.split(".")
-									.pop(),
-							]
-						: f.names,
+					f.embedded ? [embeddedFieldName(f)] : f.names,
 				)
 			: [...(base.fields?.keys() ?? [])];
 		for (let i = 0; i < expr.elems.length; i++) {
@@ -1810,12 +2195,9 @@ export const expressionCheckMethods = {
 		for (const elem of expr.elems) {
 			if (elem.kind === "KeyValueExpr") {
 				const keyName = elem.key.name;
-				const embed = base._embeds?.find((e) => {
-					const inner = e.kind === "pointer" ? e.base : e;
-					const name =
-						inner.kind === "named" ? inner.name.split(".").pop() : null;
-					return name === keyName;
-				});
+				const embed = base._structFields?.find(
+					(f) => f.embedded && embeddedFieldName(f) === keyName,
+				)?.type;
 				if (embed) elem._isEmbedInit = true;
 				const fieldType = base.fields?.get(keyName) ?? embed;
 				if (fieldType) {