gofront 1.9.0 → 1.9.2

package/src/typechecker/statements.js

@@ -24,6 +24,7 @@ import {
 	isAny,
 	isBool,
 	isNil,
+	isString,
 	isUntyped,
 	isVoid,
 	iteratorYieldParams,
@@ -33,6 +34,9 @@ import {
 
 /** @typedef {import('./index.js').TypeChecker} TypeChecker */
 
+// Tag kinds with no nil value: `case nil` against them cannot compile.
+const NON_NILABLE_TAG_KINDS = new Set(["basic", "struct", "array"]);
+
 /** @type {ThisType<TypeChecker>} */
 export const statementCheckMethods = {
 	checkBlock(block, scope, returnType) {
@@ -79,11 +83,34 @@ export const statementCheckMethods = {
 		return true;
 	},
 
+	_assignOperand(stmt, i) {
+		if (stmt.rhs.length === stmt.lhs.length) return stmt.rhs[i];
+		return stmt.rhs.length === 1 ? stmt.rhs[0] : undefined;
+	},
+
+	_checkRedeclAssign(target, source, stmt, i) {
+		if (!target || !source || !this._needsAssignCheck(target, source)) return;
+		this._skipIfaceMark = true;
+		this.assertAssignable(
+			target,
+			source,
+			stmt.lhs[i],
+			"assignment",
+			this._assignOperand(stmt, i),
+		);
+		this._skipIfaceMark = false;
+	},
+
 	_declareDefineVars(stmt, rhsFlat, scope) {
 		for (let i = 0; i < stmt.lhs.length; i++) {
 			const name = stmt.lhs[i].name ?? stmt.lhs[i];
 			if (name === "_") continue;
-			if (scope.symbols.has(name)) stmt.lhs[i]._redecl = true;
+			if (scope.symbols.has(name)) {
+				stmt.lhs[i]._redecl = true;
+				// Redeclared variables keep their type; the value must be assignable.
+				this._checkRedeclAssign(scope.symbols.get(name), rhsFlat[i], stmt, i);
+				continue;
+			}
 			if (stmt.rhs.length === stmt.lhs.length)
 				this._checkConstDefault(
 					rhsFlat[i],
@@ -195,10 +222,37 @@ export const statementCheckMethods = {
 		return this.checkExpr(e, scope);
 	},
 
+	// A source-written `any` operand still goes through assertAssignable so a
+	// concrete target reports `need type assertion`; interop `any` stays exempt.
+	_needsAssignCheck(target, source) {
+		return !isAny(target) && (!isAny(source) || !!source._declared);
+	},
+
+	// A range assignment (`for _, s = range xs`) stores each key and element
+	// into an existing variable; one of interface type boxes the value as
+	// any other conversion does. The box is recorded on a holder, not on the
+	// target, which codegen also reads as an assignable expression.
+	_markRangeAssignBox(stmt, i, target, source) {
+		if (stmt.rhs[0]?.kind !== "RangeExpr") return;
+		this._markRangeTargetBox(stmt.lhs[i], target, source);
+	},
+
+	_markRangeTargetBox(node, target, source) {
+		if (!target || !source) return;
+		const holder = {};
+		this._markIfaceBox(
+			this.resolveType(target),
+			this.resolveType(source),
+			holder,
+		);
+		if (holder._ifaceBox) node._rangeBox = holder;
+	},
+
 	_checkAssignTypes(stmt, rhsFlat, lhsTypes) {
 		for (let i = 0; i < lhsTypes.length; i++) {
 			if (stmt.lhs[i]?.kind === "Ident" && stmt.lhs[i]?.name === "_") continue;
 			const r = rhsFlat[i] ?? ANY;
+			this._markRangeAssignBox(stmt, i, lhsTypes[i], r);
 			if (stmt.rhs.length === lhsTypes.length && lhsTypes[i] && r)
 				this._markIfaceBox(
 					this.resolveType(lhsTypes[i]),
@@ -215,14 +269,14 @@ export const statementCheckMethods = {
 				this._checkConstOverflow(lhsTypes[i], r, stmt.rhs[i], "assignment")
 			)
 				continue;
-			if (!isAny(lhsTypes[i]) && !isAny(r)) {
+			if (this._needsAssignCheck(lhsTypes[i], r)) {
 				this._skipIfaceMark = true;
 				this.assertAssignable(
 					lhsTypes[i],
 					r,
 					stmt.lhs[i],
 					"assignment",
-					stmt.rhs.length === lhsTypes.length ? stmt.rhs[i] : undefined,
+					this._assignOperand(stmt, i),
 				);
 				this._skipIfaceMark = false;
 			}
@@ -260,9 +314,34 @@ export const statementCheckMethods = {
 			}
 		}
 		const lhsTypes = stmt.lhs.map((e) => this._checkAssignLhsType(e, scope));
+		// A rejected range index is not checked again as an ordinary value.
+		if (this._checkRangeIndexAssign(stmt, lhsTypes))
+			rhsFlat = [ANY, ...rhsFlat.slice(1)];
 		this._checkAssignTypes(stmt, rhsFlat, lhsTypes);
 	},
 
+	// The index of a string, slice or array range is a typed `int`: Go assigns
+	// it only to `int` (or an interface), never to another integer type.
+	_checkRangeIndexAssign(stmt, lhsTypes) {
+		const range = stmt.rhs[0];
+		const lhs = stmt.lhs[0];
+		if (range?.kind !== "RangeExpr" || range._isIterator) return false;
+		if (!lhs || (lhs.kind === "Ident" && lhs.name === "_")) return false;
+		const target = lhsTypes[0];
+		if (!target || isAny(target) || typeStr(target) === "int") return false;
+		const coll = this.resolveType(range.expr._coreType ?? range.expr._type);
+		const cu =
+			coll?.kind === "named" ? this.resolveType(coll.underlying) : coll;
+		if (!isString(cu) && cu?.kind !== "slice" && cu?.kind !== "array")
+			return false;
+		const tu = this.resolveType(
+			target.kind === "named" ? target.underlying : target,
+		);
+		if (tu?.kind === "interface") return false;
+		this.err(`Cannot assign int to ${typeStr(target)}`, lhs);
+		return true;
+	},
+
 	_checkReturnStmt(stmt, scope, returnType) {
 		const types = stmt.values.map((v) => this.checkExpr(v, scope));
 		stmt._types = types;
@@ -287,14 +366,12 @@ export const statementCheckMethods = {
 					);
 					return;
 				}
-				for (let i = 0; i < expected.length; i++) {
-					this.assertAssignable(
-						expected[i],
-						forwarded[i],
-						stmt.values[0],
-						"return statement",
-					);
-				}
+				this._checkForwardedValues(
+					expected,
+					forwarded,
+					stmt.values[0],
+					"return statement",
+				);
 				return;
 			}
 			for (let i = 0; i < expected.length; i++) {
@@ -309,6 +386,35 @@ export const statementCheckMethods = {
 		}
 	},
 
+	// Checks each result of a forwarded multi-value call (`return f()`,
+	// `g(f())`) against its target.  Every element gets its own interface-box
+	// marks in `call._fwdIface` (null where nothing is boxed): tagging the
+	// shared call node would give every element the marks of the last one.
+	// Lowering splits such forwards into temps that carry these marks.
+	_checkForwardedValues(expected, forwarded, call, ctx) {
+		const skip = this._skipIfaceMark;
+		this._skipIfaceMark = true;
+		try {
+			for (let i = 0; i < expected.length; i++)
+				this.assertAssignable(expected[i], forwarded[i], call, ctx);
+		} finally {
+			this._skipIfaceMark = skip;
+		}
+		if (!skip) this._markForwardedElems(expected, forwarded, call);
+	},
+
+	// Records in `call._fwdIface` one interface-box mark holder per forwarded
+	// element (null where the element is not boxed), or clears it when no
+	// element enters an interface.
+	_markForwardedElems(expected, forwarded, call) {
+		const holders = expected.map((t, i) => {
+			const holder = {};
+			this._markIfaceBox(t, forwarded[i], holder);
+			return "_ifaceSrc" in holder ? holder : null;
+		});
+		call._fwdIface = holders.some(Boolean) ? holders : undefined;
+	},
+
 	_checkIfStmt(stmt, scope, returnType) {
 		const inner = new Scope(scope);
 		if (stmt.init) this.checkStmt(stmt.init, inner, returnType);
@@ -382,6 +488,7 @@ export const statementCheckMethods = {
 				for (const e of c.list) {
 					this.checkExpr(e, caseScope);
 					this._checkCaseValue(stmt.tag, e);
+					if (stmt.tag) this._tagFloat32Const(stmt.tag._type, e._type, e);
 					if (tagIs64 && e._type?.kind === "untyped") e._is64Bit = true;
 				}
 			}
@@ -402,9 +509,12 @@ export const statementCheckMethods = {
 		}
 		let tagType = this.resolveType(tag._type);
 		// `switch "foo" {` compares as the constant's default type.
-		if (isUntyped(tagType) && !isNil(tagType) && tagType.base !== "bool")
-			tagType = defaultType(tagType);
+		if (isUntyped(tagType) && !isNil(tagType)) tagType = defaultType(tagType);
 		if (this._caseValueUnchecked(tagType, caseType)) return;
+		if (isNil(caseType)) {
+			this.err(`cannot convert nil to type ${typeStr(tagType)}`, e);
+			return;
+		}
 		if (isUntyped(caseType)) {
 			if (this._isUntypedAssignable(tagType, caseType)) return;
 			this.err(
@@ -427,7 +537,11 @@ export const statementCheckMethods = {
 	// A tagless `switch` is `switch true`, so every case must be boolean.
 	_checkTaglessCase(e, caseType) {
 		if (!caseType || caseType._tainted || caseType.kind === "typeParam") return;
-		if (isAny(caseType) || isNil(caseType) || isBool(caseType)) return;
+		if (isNil(caseType)) {
+			this.err(`cannot convert nil to type bool`, e);
+			return;
+		}
+		if (isAny(caseType) || isBool(caseType)) return;
 		if (isUntyped(caseType) && caseType.base === "bool") return;
 		const under = this.resolveType(caseType.underlying ?? caseType);
 		if (isBool(under)) return;
@@ -442,13 +556,22 @@ export const statementCheckMethods = {
 	_caseValueUnchecked(tagType, caseType) {
 		if (!tagType || !caseType || tagType._tainted || caseType._tainted)
 			return true;
-		if (isAny(tagType) || isAny(caseType) || isNil(caseType)) return true;
+		if (isAny(tagType) || isAny(caseType)) return true;
 		if (isUntyped(tagType) || tagType.kind === "typeParam") return true;
+		if (isNil(caseType)) return this._nilCaseOk(tagType);
 		return (
 			this.resolveType(tagType.underlying ?? tagType)?.kind === "interface"
 		);
 	},
 
+	// `case nil` needs a tag with a nil value (pointer, slice, map, func,
+	// chan, interface); a basic, struct or array tag makes the caller report
+	// `cannot convert nil`.
+	_nilCaseOk(tagType) {
+		const kind = this._deepUnderlying(tagType)?.kind;
+		return !NON_NILABLE_TAG_KINDS.has(kind);
+	},
+
 	// Whether assertAssignable(target, source) reports nothing.
 	_assignableQuietly(target, source) {
 		const saved = this.errors;
@@ -509,7 +632,8 @@ export const statementCheckMethods = {
 					this._markDynamicType(t, this.resolveTypeNode(t, inner));
 			}
 			if (stmt.assign) {
-				// Bind the variable to the single case type, or any for multi/default.
+				// Bind the variable to the single case type, or the switch operand's type
+				// for multi-type and default clauses, as Go does.
 				// `case nil` binds the switch expression's own type, as in Go.
 				const only = c.types?.length === 1 ? c.types[0] : null;
 				const isNilCase = only?.kind === "TypeName" && only.name === "nil";
@@ -517,7 +641,7 @@ export const statementCheckMethods = {
 					? (stmt.expr._type ?? ANY)
 					: only
 						? this.resolveTypeNode(only, inner)
-						: ANY;
+						: (stmt.expr._type ?? ANY);
 				caseScope.defineLocal(stmt.assign, bindType);
 				// The capture variable is always considered used — it's the whole
 				// point of the switch-with-assign form. Each case body uses its own
@@ -564,9 +688,35 @@ export const statementCheckMethods = {
 		}
 	},
 
-	_checkRangeIterAssignVars(lhs, scope) {
-		for (const e of lhs) {
-			if (e.kind === "Ident" && e.name !== "_") this.checkExpr(e, scope);
+	// Each yielded value is stored into an existing variable; one of
+	// interface type boxes the value as any other conversion does.
+	_checkRangeIterAssignVars(lhs, scope, yieldParams = []) {
+		lhs.forEach((e, i) => {
+			if (e.kind === "Ident" && e.name === "_") return;
+			const target = this.checkExpr(e, scope);
+			this._markRangeTargetBox(e, target, yieldParams[i]);
+			this._checkRangeIterAssignable(e, target, yieldParams[i]);
+		});
+	},
+
+	// The yielded value is assigned to the target, so it must be assignable
+	// to it (`for s = range seq` with `s string` and `seq` yielding `int`).
+	// The lenient `float64 = int` pair of plain assignments is reported here:
+	// the iterator loop stores the yielded value without converting it.
+	_checkRangeIterAssignable(node, target, source) {
+		if (!target || !source) return;
+		const t = this.resolveType(target);
+		const v = this.resolveType(source);
+		if (this._isNumericCoercible(t, v)) {
+			this.err(`Cannot assign ${typeStr(v)} to ${typeStr(t)}`, node);
+			return;
+		}
+		if (!this._needsAssignCheck(target, source)) return;
+		this._skipIfaceMark = true;
+		try {
+			this.assertAssignable(target, source, node, "assignment");
+		} finally {
+			this._skipIfaceMark = false;
 		}
 	},
 
@@ -592,7 +742,7 @@ export const statementCheckMethods = {
 
 		if (initStmt.kind === "DefineStmt")
 			this._bindRangeIterDefineVars(lhs, info, scope);
-		else this._checkRangeIterAssignVars(lhs, scope);
+		else this._checkRangeIterAssignVars(lhs, scope, info.yieldParams);
 		return info;
 	},
 };

package/src/typechecker/types.js

@@ -323,6 +323,9 @@ export const UNTYPED_INT = { kind: "untyped", base: "int" };
 export const UNTYPED_FLOAT = { kind: "untyped", base: "float64" };
 export const UNTYPED_STRING = { kind: "untyped", base: "string" };
 export const UNTYPED_BOOL = { kind: "untyped", base: "bool" };
+// An untyped rune constant is an untyped integer whose default type is
+// `rune`; every `base === "int"` rule applies to it unchanged.
+export const UNTYPED_RUNE = { kind: "untyped", base: "int", rune: true };
 
 // ── Complex types ────────────────────────────────────────────
 export const COMPLEX128 = { kind: "basic", name: "complex128" };
@@ -530,7 +533,7 @@ export function defaultType(t) {
 	if (t?.kind !== "untyped") return t;
 	switch (t.base) {
 		case "int":
-			return INT;
+			return t.rune ? RUNE : INT;
 		case "float64":
 			return FLOAT64;
 		case "string":
@@ -551,7 +554,7 @@ export function typeStr(t) {
 		case "basic":
 			return t.name;
 		case "untyped":
-			return `untyped ${t.base}`;
+			return t.rune ? "untyped rune" : `untyped ${t.base}`;
 		case "slice":
 			return `[]${typeStr(t.elem)}`;
 		case "shared":
@@ -596,6 +599,27 @@ export function typeStr(t) {
 
 // The field an embedded type declares is named after the type as written, so
 // an alias (`type A = Base; struct{ A }`) gives the field `A`.
+// Per struct type, the methods promoted into its method set from embedded
+// fields: name -> { depth, viaPtr, source, mType }. `depth` counts embeds
+// from the struct, `viaPtr` is set when an embed on the path is a pointer
+// and `source` is the method as declared. Kept outside the struct object so
+// a copy of the struct (`type S Base`) does not share it.
+export const promotedMethods = new WeakMap();
+
+// Two embedded fields at the same, shallowest depth declare method `name`,
+// so it is in neither method set of `struct` and selecting it is an error.
+export function isAmbiguousPromotion(struct, name) {
+	return promotedMethods.get(struct)?.get(name)?.ambiguous === true;
+}
+
+// The ambiguous method names of `struct` (see isAmbiguousPromotion).
+export function ambiguousPromotions(struct) {
+	const names = [];
+	for (const [name, p] of promotedMethods.get(struct) ?? [])
+		if (p.ambiguous) names.push(name);
+	return names;
+}
+
 export function embeddedFieldName(f) {
 	const ast = f.astType?.kind === "PointerType" ? f.astType.base : f.astType;
 	const t = f.type?.kind === "pointer" ? f.type.base : f.type;
@@ -605,6 +629,64 @@ export function embeddedFieldName(f) {
 		.replace(/\$\$.*$/, "");
 }
 
+// Whether `st` declares `name` itself: a field of that name or an embedded
+// field named after its type.
+function declaresField(st, name) {
+	return (st._structFields ?? []).some((f) =>
+		f.embedded ? embeddedFieldName(f) === name : f.names?.includes(name),
+	);
+}
+
+// The shallowest depth at which `struct` promotes a field `name` from its
+// embedded types, and how many promotion paths reach it at that depth:
+// { depth, count }, or null when no embedded type offers one.
+function promotedFieldDepth(struct, name, path = new Set()) {
+	if (path.has(struct)) return null;
+	path.add(struct);
+	let best = null;
+	for (const e of struct._embeds ?? []) {
+		const inner = e?.kind === "pointer" ? e.base : e;
+		const st = inner?.kind === "named" ? inner.underlying : inner;
+		if (st?.kind !== "struct" || !st._structFields) continue;
+		const sub = declaresField(st, name)
+			? { depth: 0, count: 1 }
+			: promotedFieldDepth(st, name, path);
+		if (!sub) continue;
+		const depth = 1 + sub.depth;
+		if (!best || depth < best.depth) best = { depth, count: sub.count };
+		else if (depth === best.depth) best.count += sub.count;
+	}
+	path.delete(struct);
+	return best;
+}
+
+// Whether selecting `name` on `struct`, whose flattened field map has it, is
+// ambiguous: two promotion paths reach a field of that name at the same
+// shallowest depth, or a field and a method promoted at that depth do. A
+// field declared on the struct itself and a method declared on it always win.
+export function isAmbiguousFieldSelector(struct, name) {
+	if (declaresField(struct, name)) return false;
+	const promoted = promotedMethods.get(struct)?.get(name);
+	if (struct.methods?.has(name) && promoted?.mType !== struct.methods.get(name))
+		return false;
+	const field = promotedFieldDepth(struct, name);
+	if (!field) return false;
+	if (!promoted || field.depth < promoted.depth) return field.count > 1;
+	return field.depth === promoted.depth || promoted.ambiguous === true;
+}
+
+// Whether selecting `name` on `struct`, whose flattened field map has it,
+// reaches a method promoted at a shallower depth than the field (Go's depth
+// rule): the method is selected and the deeper field is shadowed.
+export function isMethodPromotedOverField(struct, name) {
+	if (declaresField(struct, name)) return false;
+	const promoted = promotedMethods.get(struct)?.get(name);
+	if (!promoted?.mType || promoted.ambiguous) return false;
+	if (struct.methods?.get(name) !== promoted.mType) return false;
+	const field = promotedFieldDepth(struct, name);
+	return field !== null && promoted.depth < field.depth;
+}
+
 // A function-local type shadowed by another type is renamed `Name__L<n>`.
 export const LOCAL_TYPE_SUFFIX = /__L\d+/;