gofront 1.7.0 → 1.9.0

package/src/parser/types.js

@@ -1,6 +1,6 @@
 // Parser type-expression methods — installed as a mixin on Parser.prototype.
 
-import { T } from "../tokens.js";
+import { T } from "../lexer/tokens.js";
 
 // Token types that directly map to parseTypeName().
 const TYPE_NAME_TOKENS = new Set([
@@ -76,8 +76,10 @@ export const typeParserMethods = {
 				i++;
 				continue;
 			}
-			// Reject literals — it's an index/array expression
-			if (tt === T.INT || tt === T.FLOAT || tt === T.STRING) return false;
+			// Reject literals — it's an index/array expression. A literal nested
+			// deeper is an array length inside a type argument: Stack[[2]int].
+			if (depth === 1 && (tt === T.INT || tt === T.FLOAT || tt === T.STRING))
+				return false;
 			i++;
 		}
 		return depth === 0;
@@ -86,11 +88,17 @@ export const typeParserMethods = {
 	parseTypeParamList() {
 		this.expect(T.LBRACKET);
 		const params = [];
-		do {
-			const name = this.expect(T.IDENT).value;
+		while (!this.check(T.RBRACKET) && !this.check(T.EOF)) {
+			const names = [this.expect(T.IDENT).value];
+			while (this.match(T.COMMA)) {
+				names.push(this.expect(T.IDENT).value);
+			}
 			const constraint = this.parseConstraint();
-			params.push({ kind: "TypeParam", name, constraint });
-		} while (this.match(T.COMMA));
+			for (const name of names) {
+				params.push({ kind: "TypeParam", name, constraint });
+			}
+			if (!this.match(T.COMMA)) break;
+		}
 		this.expect(T.RBRACKET);
 		return params;
 	},
@@ -185,7 +193,7 @@ export const typeParserMethods = {
 				}
 				const type = {
 					kind: "PointerType",
-					base: { kind: "TypeName", name: typeName },
+					base: this._embeddedTypeName(typeName, true),
 				};
 				let tag = null;
 				if (this.check(T.STRING)) {
@@ -195,6 +203,7 @@ export const typeParserMethods = {
 					names: [],
 					type,
 					embedded: true,
+					embeddedName: type.base.name,
 					tag,
 				});
 				this.semi();
@@ -206,14 +215,38 @@ export const typeParserMethods = {
 			if (names.length === 1 && this.check(T.DOT)) {
 				this.advance();
 				const typeName = `${names[0]}.${this.expect(T.IDENT).value}`;
+				const embeddedType = this._embeddedTypeName(typeName, true);
 				let tag = null;
 				if (this.check(T.STRING)) {
 					tag = this.advance().value;
 				}
 				fields.push({
 					names: [],
-					type: { kind: "TypeName", name: typeName },
+					type: embeddedType,
 					embedded: true,
+					embeddedName: typeName,
+					tag,
+				});
+				this.semi();
+				continue;
+			}
+
+			// Embedded generic instance: Inner[T] (not an array field `a [N]T`)
+			if (
+				names.length === 1 &&
+				this.check(T.LBRACKET) &&
+				this._bracketEndsEmbeddedField()
+			) {
+				const embeddedType = this._embeddedTypeName(names[0], true);
+				let tag = null;
+				if (this.check(T.STRING)) {
+					tag = this.advance().value;
+				}
+				fields.push({
+					names: [],
+					type: embeddedType,
+					embedded: true,
+					embeddedName: names[0],
 					tag,
 				});
 				this.semi();
@@ -236,6 +269,7 @@ export const typeParserMethods = {
 					names: [],
 					type: { kind: "TypeName", name: typeName },
 					embedded: true,
+					embeddedName: typeName,
 					tag,
 				});
 				this.semi();
@@ -255,6 +289,33 @@ export const typeParserMethods = {
 		return { kind: "StructType", fields };
 	},
 
+	// True when the `[...]` at the cursor is followed by the end of a field
+	// (`Inner[T]` embedded), rather than an element type (`a [N]T`).
+	_bracketEndsEmbeddedField() {
+		let depth = 0;
+		for (let i = this.pos; i < this.tokens.length; i++) {
+			const tt = this.tokens[i].type;
+			if (tt === T.LBRACKET) depth++;
+			else if (tt === T.RBRACKET && --depth === 0) {
+				const next = this.tokens[i + 1]?.type;
+				return next === T.SEMICOLON || next === T.RBRACE || next === T.STRING;
+			}
+		}
+		return false;
+	},
+
+	// Embedded field type: `name`, or `name[Args]` when type arguments follow.
+	_embeddedTypeName(name, allowArgs) {
+		if (allowArgs && this.check(T.LBRACKET)) {
+			this.expect(T.LBRACKET);
+			const typeArgs = [this.parseType()];
+			while (this.match(T.COMMA)) typeArgs.push(this.parseType());
+			this.expect(T.RBRACKET);
+			return { kind: "GenericTypeName", name, typeArgs };
+		}
+		return { kind: "TypeName", name };
+	},
+
 	parseInterfaceType() {
 		this.expect(T.INTERFACE);
 		this.expect(T.LBRACE);

package/src/resolver.js

@@ -12,6 +12,7 @@
 
 import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
 
 // Walk up from startDir looking for a node_modules directory
 function findNodeModules(startDir) {
@@ -25,6 +26,7 @@ function findNodeModules(startDir) {
 	}
 }
 
+import { EXCLUDED_STDLIB_PACKAGES } from "./typechecker/stdlib/excluded.js";
 import { STDLIB_PACKAGES } from "./typechecker/types.js";
 
 // Returns true for local relative paths (start with ./ or ../)
@@ -36,6 +38,22 @@ export function isBuiltinPackage(importPath) {
 	return STDLIB_PACKAGES.has(importPath);
 }
 
+// Go-source stdlib: `stdlib/<import path>/*.go`, written in GoFront Go
+// and compiled into the caller's target.
+const STDLIB_SOURCE_ROOT = fileURLToPath(
+	new URL("../stdlib/", import.meta.url),
+);
+const STDLIB_PATH_RE = /^[a-z0-9]+(\/[a-z0-9]+)*$/;
+
+// Returns the source directory for a Go-source stdlib import path, or null.
+// `root` replaces stdlib/ (tests use a temporary tree).
+export function resolveStdlibSource(importPath, root = null) {
+	if (!STDLIB_PATH_RE.test(importPath)) return null;
+	const dir = join(root ?? STDLIB_SOURCE_ROOT, importPath);
+	if (!existsSync(dir)) return null;
+	return readdirSync(dir).some((f) => f.endsWith(".go")) ? dir : null;
+}
+
 // Resolve a local relative import path to an absolute directory of .go files.
 // Returns the absolute dir path, or null if it doesn't contain any .go files.
 export function resolveGwDir(importPath, fromFile) {
@@ -86,14 +104,16 @@ function resolveImport(importPath, fromFile) {
 
 // Given an AST's import list, resolve all imports.
 // Returns Map<importPath, { dtsPath, importPath, types, values }>
-export function resolveAll(imports, fromFile, parseDts) {
+export function resolveAll(imports, fromFile, parseDts, stdlibRoot = null) {
 	const resolved = new Map();
 
 	for (const imp of imports) {
 		for (const { path } of imp.imports) {
 			if (path.startsWith("js:")) continue; // handled separately
 			if (isLocalPath(path)) continue; // local .go packages — handled by compiler
+			if (EXCLUDED_STDLIB_PACKAGES.has(path)) continue; // the checker reports it
 			if (isBuiltinPackage(path)) continue; // built-in stdlib namespaces — always available
+			if (resolveStdlibSource(path, stdlibRoot)) continue; // Go-source stdlib — handled by compiler
 
 			if (resolved.has(path)) continue;
 

package/src/typechecker/assignability.js

@@ -1,6 +1,8 @@
 // Assignability, binary result types, and interface satisfaction.
 // Installed as a mixin on TypeChecker.prototype.
 
+import { constIntValue } from "./const-fold.js";
+import { exprText, operandKind } from "./operand-text.js";
 import { sharedInfo } from "./stdlib/shared.js";
 import {
 	ANY,
@@ -8,9 +10,12 @@ import {
 	CMP_OPS,
 	COMPLEX128,
 	FLOAT64,
+	is64BitInt,
 	isAny,
 	isComplex,
+	isComplex64,
 	isComplexOrNumeric,
+	isInteger,
 	isNil,
 	isNumeric,
 	isPointer,
@@ -79,6 +84,8 @@ export const assignabilityMethods = {
 		if (isAny(lt) || isAny(rt)) return ANY;
 		if (isComplex(lt) || isComplex(rt))
 			return this._binaryResultTypeComplex(op, lt, rt, node);
+		if ((op === "<<" || op === ">>") && isNumeric(lt) && isNumeric(rt))
+			return this._binaryResultTypeShift(op, lt, rt, node);
 		if (isNumeric(lt) && isNumeric(rt))
 			return this._binaryResultTypeNumeric(lt, rt);
 		if (isString(lt) && isString(rt) && op === "+")
@@ -88,6 +95,37 @@ export const assignabilityMethods = {
 		return ANY;
 	},
 
+	// A shift has the type of its left operand; the count may be any integer
+	// type or an untyped constant representable as uint.
+	_binaryResultTypeShift(_op, lt, rt, node) {
+		if (node) this.checkShiftCount(rt, node.right);
+		if (node && lt.kind !== "untyped" && !isInteger(lt))
+			this.err(`shifted operand ${typeStr(lt)} must be integer`, node.left);
+		return lt;
+	},
+
+	// Reports a shift count that is not an integer or is a negative constant.
+	checkShiftCount(rt, countExpr) {
+		const v = this._constValue(countExpr);
+		if (v) {
+			const n = constIntValue(v);
+			if (n === null) {
+				this.err(
+					`invalid shift count ${typeStr(rt)} constant: not an integer`,
+					countExpr,
+				);
+			} else if (n < 0n) {
+				this.err(`invalid shift count: ${n} is negative`, countExpr);
+			}
+			return;
+		}
+		if (!isInteger(rt))
+			this.err(
+				`invalid shift count: ${typeStr(rt)} is not an integer type`,
+				countExpr,
+			);
+	},
+
 	_binaryResultTypeString(lt, rt) {
 		if (lt.kind === "untyped" && rt.kind === "untyped") return lt;
 		if (lt.kind === "untyped") return rt;
@@ -97,6 +135,7 @@ export const assignabilityMethods = {
 
 	_binaryResultTypeCmp(op, lt, rt, node) {
 		if (this._checkComplexCmpOp(op, lt, rt, node)) return ANY;
+		this._checkIntegerCmpKinds(op, lt, rt, node);
 		this._checkEqualityComparable(op, lt, rt, node);
 		return BOOL;
 	},
@@ -111,6 +150,9 @@ export const assignabilityMethods = {
 			return ANY;
 		}
 		if (lt.kind === "untyped" && rt.kind === "untyped") return UNTYPED_COMPLEX;
+		if (lt.kind === "untyped") return rt;
+		if (rt.kind === "untyped") return lt;
+		if (isComplex64(lt) && isComplex64(rt)) return lt;
 		return COMPLEX128;
 	},
 
@@ -134,6 +176,17 @@ export const assignabilityMethods = {
 		return isFloat ? FLOAT64 : lt;
 	},
 
+	// Comparing two typed integers of different types (`byte != int`) is a
+	// mismatch in Go; untyped constants adapt to either side.
+	_checkIntegerCmpKinds(op, lt, rt, node) {
+		if (!node || lt.kind === "untyped" || rt.kind === "untyped") return;
+		if (!isInteger(lt) || !isInteger(rt) || typeStr(lt) === typeStr(rt)) return;
+		this.err(
+			`invalid operation: ${exprText(node)} (mismatched types ${typeStr(lt)} and ${typeStr(rt)})`,
+			node,
+		);
+	},
+
 	_checkComplexCmpOp(op, lt, rt, node) {
 		if (isComplex(lt) || isComplex(rt)) {
 			if (op !== "==" && op !== "!=") {
@@ -165,12 +218,68 @@ export const assignabilityMethods = {
 
 	// ── Assignability ─────────────────────────────────────────────────
 
-	assertAssignable(target, source, node) {
+	_tag64BitNode(target, node) {
+		if (node && typeof node === "object" && is64BitInt(target)) {
+			node._is64Bit = true;
+			if (node.kind === "KeyValueExpr" && node.value)
+				node.value._is64Bit = true;
+			if (node.kind === "UnaryExpr" && node.operand)
+				node.operand._is64Bit = true;
+			if (node.kind === "ParenExpr" && node.expr) node.expr._is64Bit = true;
+		}
+	},
+
+	// `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).
+	_retypeUntypedShift(target, source, valueNode) {
+		if (!isUntyped(source) || !isInteger(target)) return;
+		this._retypeShiftTree(valueNode, target);
+	},
+
+	_retypeShiftTree(e, target) {
+		if (!e || typeof e !== "object" || e._type?.kind !== "untyped") return;
+		if (e.kind === "ParenExpr") this._retypeShiftTree(e.expr, target);
+		else if (e.kind === "UnaryExpr") this._retypeShiftTree(e.operand, target);
+		else if (e.kind === "BinaryExpr" && !this._constValue(e)) {
+			const isShift = e.op === "<<" || e.op === ">>";
+			this._retypeShiftTree(e.left, target);
+			if (isShift && e.left._type?.kind === "untyped") {
+				e.left._type = target;
+				if (is64BitInt(target)) e.left._is64Bit = true;
+			} else if (!isShift) this._retypeShiftTree(e.right, target);
+		} else return;
+		if (this._constValue(e)) return;
+		e._type = target;
+		if (is64BitInt(target)) e._is64Bit = true;
+	},
+
+	// An untyped real constant flowing into a complex type becomes a complex
+	// value in codegen.
+	_tagComplexConst(target, source, valueNode) {
+		if (
+			valueNode &&
+			typeof valueNode === "object" &&
+			isComplex(target) &&
+			isUntyped(source) &&
+			!isComplex(source)
+		)
+			valueNode._asComplex = true;
+	},
+
+	// `operand` is the expression whose value flows in, when `node` (the
+	// position and codegen tag) is not that expression.
+	assertAssignable(target, source, node, ctx = "assignment", operand = node) {
 		if (!target || !source) return;
+		if (this._checkConstOverflow(target, source, node, ctx)) return;
 		target = this.resolveType(target);
 		source = this.resolveType(source);
+		this._tag64BitNode(target, node);
+		this._retypeUntypedShift(target, source, operand ?? node);
+		this._tagComplexConst(target, source, operand ?? node);
 		this._markIfaceBox(target, source, node);
 		this._checkWasmIfaceProvider(target, source, node);
+		if (this._checkIfaceToConcrete(target, source, node, ctx, operand)) return;
 		if (this._assertAssignableEarlyReturn(target, source)) return;
 		if (isPointer(target) && isPointer(source)) {
 			this.assertAssignable(
@@ -181,7 +290,7 @@ export const assignabilityMethods = {
 			return;
 		}
 		if (isUntyped(source) && this._isUntypedAssignable(target, source)) return;
-		if (this._isNumericCoercible(target, source)) return;
+		if (this._checkNumericCoercion(target, source, node, ctx, operand)) return;
 		if (this._checkArrayAssignable(target, source, node)) return;
 		if (this._checkTypedArrayAssignable(target, source, node)) return;
 		if (this._checkFuncAssignable(target, source, node)) return;
@@ -201,23 +310,32 @@ export const assignabilityMethods = {
 		)
 			return;
 		if (target.kind === "typeParam") return;
-		const tBase = this.resolveType(
-			target.kind === "named" ? target.underlying : target,
-		);
+		let tBase = this.resolveType(target);
+		if (tBase?.kind === "named") tBase = this.resolveType(tBase.underlying);
 		if (!isAny(target) && tBase?.kind !== "interface") return;
+		// The static type behind the interface value: codegen derives the
+		// fmt metadata (Stringer elements of slices and maps) from it.
+		node._ifaceSrc = source;
+		const meta = this._ifaceBoxMeta(source);
+		if (!meta) return;
+		node._ifaceBox = meta.box;
+		if (meta.type) node._ifaceNamedType = meta.type;
+		if (meta.ptrFields) node._ifacePtrFields = meta.ptrFields;
+	},
+
+	// How a value of static type `source` is boxed on entering an interface:
+	// { box, type? (named kinds), ptrFields? }, or null when it stays raw.
+	// Shared by _markIfaceBox and the JS backend's multi-value fmt operands.
+	_ifaceBoxMeta(source) {
 		const named = this._namedMethodBoxSource(source);
-		if (named) {
-			node._ifaceBox = named.ptr ? "named_ptr" : "named";
-			node._ifaceNamedType = named.type;
-			return;
-		}
+		if (named)
+			return { box: named.ptr ? "named_ptr" : "named", type: named.type };
 		const sBase = this.resolveType(
 			source.kind === "named" ? source.underlying : source,
 		);
 		const info = this._classifyIfaceBox(sBase);
-		if (!info) return;
-		node._ifaceBox = info.box;
-		if (info.ptrFields) node._ifacePtrFields = info.ptrFields;
+		if (!info) return null;
+		return { box: info.box, ptrFields: info.ptrFields };
 	},
 
 	// A named non-struct type with methods (or a pointer to one) entering an
@@ -225,14 +343,26 @@ export const assignabilityMethods = {
 	// dynamic method dispatch works.
 	_namedMethodBoxSource(source) {
 		const isPtr = source?.kind === "pointer";
-		const t = isPtr ? source.base : source;
+		let t = isPtr ? source.base : source;
+		if (t?.kind === "TypeName" || t?.kind === "Ident") t = this.resolveType(t);
 		if (t?.kind !== "named") return null;
 		const u = this.resolveType(t.underlying);
 		if (!u || u.kind === "struct" || u.kind === "interface") return null;
 		const methods = t.methods ?? t._generic?.methods;
+		// A user-declared named basic type without methods is boxed as well, so
+		// a type assertion to its underlying type fails like Go.
+		if (
+			u.kind === "basic" &&
+			!t._generic &&
+			t.methods instanceof Map &&
+			t.methods.size === 0 &&
+			t._target !== undefined &&
+			t._target !== "wasm"
+		)
+			return { type: t, ptr: isPtr };
 		if (!methods || methods.size === 0) return null;
 		// Only user-declared types (methods carry _ptrRecv); stdlib named types
-		// such as time.Duration have no box class.
+		// such as strings.Builder have no box class.
 		if (![...methods.values()].some((m) => Object.hasOwn(m ?? {}, "_ptrRecv")))
 			return null;
 		return { type: t, ptr: isPtr };
@@ -311,6 +441,28 @@ export const assignabilityMethods = {
 		);
 	},
 
+	// An interface-typed operand needs an explicit type assertion before it can
+	// flow into a concrete (non-interface) type.
+	_checkIfaceToConcrete(target, source, node, ctx, operand) {
+		if (!source?._declared || !operand || typeof operand !== "object")
+			return false;
+		if (!this._isConcreteTarget(target)) return false;
+		this.err(
+			`cannot use ${exprText(operand)} (${operandKind(operand, typeStr(source))}) as ${typeStr(target)} value in ${ctx}: need type assertion`,
+			node,
+		);
+		return true;
+	},
+
+	_isConcreteTarget(target) {
+		if (!target || target.kind === "typeParam" || isAny(target)) return false;
+		if (isNil(target) || isUntyped(target)) return false;
+		const base = this.resolveType(
+			target.kind === "named" ? target.underlying : target,
+		);
+		return !!base && base.kind !== "interface" && base.kind !== "typeParam";
+	},
+
 	_assertAssignableEarlyReturn(target, source) {
 		return (
 			target?.kind === "typeParam" ||
@@ -351,7 +503,45 @@ export const assignabilityMethods = {
 			return;
 		}
 		if (this._identicalUnderlyingLiteral(target, source, tBase, sBase)) return;
-		this.err(`Cannot assign ${typeStr(source)} to ${typeStr(target)}`, node);
+		this.err(
+			`Cannot assign ${typeStr(source)} to ${typeStr(target)}`,
+			node,
+			this._seqToSliceHint(source, tBase, node),
+		);
+	},
+
+	// maps.Keys/Values (and every iter.Seq) no longer return a slice: point the
+	// slice-expecting caller at slices.Collect.
+	_seqToSliceHint(source, tBase, node) {
+		if (tBase?.kind !== "slice" || !this._isIterSeq(source)) return null;
+		return this._seqCollectHint(node);
+	},
+
+	_isIterSeq(t) {
+		return t?.kind === "named" && /^iter\.Seq\d*\[/.test(typeStr(t));
+	},
+
+	_seqCollectHint(node) {
+		const f = node?.kind === "CallExpr" ? node.func : null;
+		if (
+			f?.kind === "SelectorExpr" &&
+			f.expr?.kind === "Ident" &&
+			f.expr.name === "maps" &&
+			(f.field === "Keys" || f.field === "Values")
+		)
+			return `use slices.Collect(maps.${f.field}(m)) for a slice`;
+		return "use slices.Collect(seq) for a slice";
+	},
+
+	// len/cap, spread and slice conversion are lenient on func types, and an
+	// iter.Seq value is one: reject it there instead of miscompiling.
+	_rejectSeqAsSlice(type, node, use) {
+		if (!this._isIterSeq(type)) return;
+		this.err(
+			`cannot use ${typeStr(type)} in ${use}`,
+			node,
+			this._seqCollectHint(node),
+		);
 	},
 
 	// Identical underlying types are assignable when one side is an unnamed
@@ -377,18 +567,61 @@ export const assignabilityMethods = {
 		);
 	},
 
+	// A value computed from a generic call (`3 + Sum[float64](1, 2)`) has the
+	// exact instantiated type, so the loose int/float64 promotion that plain
+	// code enjoys does not apply to it.
+	_isGenericCallResult(node) {
+		if (!node || typeof node !== "object") return false;
+		if (node.kind === "ParenExpr") return this._isGenericCallResult(node.expr);
+		if (node.kind === "BinaryExpr")
+			return (
+				this._isGenericCallResult(node.left) ||
+				this._isGenericCallResult(node.right)
+			);
+		return node.kind === "CallExpr" && Boolean(node.func?._genericFnType);
+	},
+
 	_isNumericCoercible(target, source) {
 		if (target.kind !== "basic" || source.kind !== "basic") return false;
 		const pair = `${target.name}:${source.name}`;
 		return (
 			pair === "float64:int" ||
-			pair === "int:float64" ||
 			// rune was historically int in GoFront; keep rune/int interchangeable.
 			pair === "int:int32" ||
 			pair === "int32:int"
 		);
 	},
 
+	// The lenient numeric pairs: accepted, except that a generic call result
+	// is a mismatch and a float64 never reaches an int implicitly.
+	// Returns true when the pair was handled.
+	_checkNumericCoercion(target, source, node, ctx, operand) {
+		const floatToInt = this._isFloatToInt(target, source);
+		if (!floatToInt && !this._isNumericCoercible(target, source)) return false;
+		if (this._isGenericCallResult(node))
+			this.err(
+				`mismatched types ${typeStr(source)} and ${typeStr(target)} in ${ctx}`,
+				node,
+			);
+		else if (floatToInt)
+			this.err(
+				`cannot use ${exprText(operand)} (${operandKind(operand, typeStr(source))}) as ${typeStr(target)} value in ${ctx}`,
+				node,
+			);
+		return true;
+	},
+
+	// Go has no implicit float64 -> int conversion; only an untyped constant
+	// (handled earlier) or an explicit `int(x)` reaches an int.
+	_isFloatToInt(target, source) {
+		return (
+			target.kind === "basic" &&
+			source.kind === "basic" &&
+			target.name === "int" &&
+			source.name === "float64"
+		);
+	},
+
 	_checkArrayAssignable(target, source, node) {
 		if (target.kind === "array" && source.kind === "array") {
 			if (
@@ -465,10 +698,47 @@ export const assignabilityMethods = {
 
 	// ── Interface satisfaction ────────────────────────────────────────
 
+	// `interface{}` and `any` are the same type, but print differently.
+	_sigTypeStr(t) {
+		switch (t?.kind) {
+			case "interface":
+				if (
+					!t.name &&
+					t.methods.size === 0 &&
+					!t.unionConstraint &&
+					!t._typeSetEmbeds
+				)
+					return "any";
+				return typeStr(t);
+			case "slice":
+				return `[]${this._sigTypeStr(t.elem)}`;
+			case "array":
+				return `[${t.size ?? "..."}]${this._sigTypeStr(t.elem)}`;
+			case "pointer":
+				return `*${this._sigTypeStr(t.base)}`;
+			case "map":
+				return `map[${this._sigTypeStr(t.key)}]${this._sigTypeStr(t.value)}`;
+			case "tuple":
+				return `(${t.types.map((x) => this._sigTypeStr(x)).join(", ")})`;
+			case "func": {
+				const ret =
+					t.returns.length > 1
+						? `(${t.returns.map((x) => this._sigTypeStr(x)).join(", ")})`
+						: t.returns[0]
+							? this._sigTypeStr(t.returns[0])
+							: "void";
+				return `func(${t.params.map((x) => this._sigTypeStr(x)).join(", ")}) ${ret}`;
+			}
+			default:
+				return typeStr(t);
+		}
+	},
+
 	_sigParamsMatch(reqList, actList) {
 		if (reqList.length !== actList.length) return false;
 		for (let i = 0; i < reqList.length; i++) {
-			if (typeStr(reqList[i]) !== typeStr(actList[i])) return false;
+			if (this._sigTypeStr(reqList[i]) !== this._sigTypeStr(actList[i]))
+				return false;
 		}
 		return true;
 	},
@@ -511,7 +781,9 @@ export const assignabilityMethods = {
 		}
 		const methodMap =
 			base?.kind === "struct"
-				? base.methods || srcType.methods
+				? base.methods?.size
+					? base.methods
+					: srcType.methods || base.methods
 				: srcType.kind === "named"
 					? srcType.methods
 					: null;