gofront 1.8.0 → 1.9.1

package/src/typechecker/types.js

@@ -106,593 +106,178 @@ export const BROWSER_GLOBALS = new Set([
 // gains support; anything not listed is rejected at import with "not yet available in
 // wasm packages".
 export const WASM_SUPPORTED_STDLIB = new Set([
-	"math",
-	"math/bits",
-	"math/rand",
-	"errors",
-	"fmt",
-	"strings",
-	"bytes",
-	"strconv",
-	"unicode",
-	"unicode/utf8",
-	"slices",
-	"maps",
-	"sort",
-	"path",
-	"path/filepath",
-	"html",
-	"io",
-	"time",
-	"testing",
 	"gofront/shared",
 	"gofront/simd",
-	"sync",
-	"crypto/rand",
-	"crypto/sha256",
-	"encoding/binary",
-	"encoding/hex",
-	"encoding/base64",
-	"os",
-	"encoding/json",
 ]);
 
-export const STDLIB_PACKAGES = new Set([
-	...WASM_SUPPORTED_STDLIB,
-	"gom",
-	"regexp",
-]);
+export const STDLIB_PACKAGES = WASM_SUPPORTED_STDLIB;
 
 // Per-namespace member subset the WASM backend implements. `null` means every
 // member the checker knows about. Members outside the set are rejected in
 // wasm/both packages with "'strings.Split' is not yet available in wasm packages".
-export const WASM_STDLIB_MEMBERS = new Map([
-	["os", new Set(["Stdout", "Stderr", "Stdin", "File"])],
-	[
-		"math",
-		new Set([
-			"Sqrt",
-			"Floor",
-			"Ceil",
-			"Trunc",
-			"Abs",
-			"Min",
-			"Max",
-			"Copysign",
-			"Dim",
-			"Inf",
-			"NaN",
-			"IsNaN",
-			"IsInf",
-			"Signbit",
-			"Sin",
-			"Cos",
-			"Tan",
-			"Asin",
-			"Acos",
-			"Atan",
-			"Atan2",
-			"Pow",
-			"Mod",
-			"Hypot",
-			"Cbrt",
-			"Exp",
-			"Exp2",
-			"Log",
-			"Log1p",
-			"Log2",
-			"Log10",
-			"Expm1",
-			"Round",
-			"Remainder",
-			"Float64bits",
-			"Float64frombits",
-			"Float32bits",
-			"Float32frombits",
-			"Sinh",
-			"Cosh",
-			"Tanh",
-			// constants
-			"E",
-			"Pi",
-			"Phi",
-			"Sqrt2",
-			"SqrtE",
-			"SqrtPi",
-			"SqrtPhi",
-			"Ln2",
-			"Log2E",
-			"Ln10",
-			"Log10E",
-			"MaxFloat32",
-			"SmallestNonzeroFloat32",
-			"MaxFloat64",
-			"SmallestNonzeroFloat64",
-			"MaxInt",
-			"MinInt",
-			"MaxInt8",
-			"MinInt8",
-			"MaxInt16",
-			"MinInt16",
-			"MaxInt32",
-			"MinInt32",
-			"MaxInt64",
-			"MinInt64",
-			"MaxUint8",
-			"MaxUint16",
-			"MaxUint32",
-			"MaxUint",
-			"MaxUint64",
-		]),
-	],
-	[
-		"bits",
-		new Set([
-			"Add",
-			"Add32",
-			"Add64",
-			"Sub",
-			"Sub32",
-			"Sub64",
-			"Mul",
-			"Mul32",
-			"Mul64",
-			"Div",
-			"Div32",
-			"Div64",
-			"Rem",
-			"Rem32",
-			"Rem64",
-			"LeadingZeros",
-			"LeadingZeros8",
-			"LeadingZeros16",
-			"LeadingZeros32",
-			"LeadingZeros64",
-			"TrailingZeros",
-			"TrailingZeros8",
-			"TrailingZeros16",
-			"TrailingZeros32",
-			"TrailingZeros64",
-			"OnesCount",
-			"OnesCount8",
-			"OnesCount16",
-			"OnesCount32",
-			"OnesCount64",
-			"RotateLeft",
-			"RotateLeft8",
-			"RotateLeft16",
-			"RotateLeft32",
-			"RotateLeft64",
-			"Reverse",
-			"Reverse8",
-			"Reverse16",
-			"Reverse32",
-			"Reverse64",
-			"ReverseBytes",
-			"ReverseBytes16",
-			"ReverseBytes32",
-			"ReverseBytes64",
-			"Len",
-			"Len8",
-			"Len16",
-			"Len32",
-			"Len64",
-			"UintSize",
-		]),
-	],
-	["errors", new Set(["New", "Is", "Unwrap", "As", "Join"])],
-	[
-		"utf8",
-		new Set([
-			"RuneCountInString",
-			"RuneLen",
-			"ValidString",
-			"ValidRune",
-			"DecodeRuneInString",
-			"DecodeLastRuneInString",
-			"FullRuneInString",
-			"RuneError",
-			"MaxRune",
-			"UTFMax",
-			"RuneSelf",
-			"EncodeRune",
-			"AppendRune",
-			"DecodeRune",
-			"DecodeLastRune",
-			"RuneCount",
-			"FullRune",
-			"Valid",
-			"RuneStart",
-		]),
-	],
-	[
-		"sort",
-		new Set([
-			"Ints",
-			"Float64s",
-			"Strings",
-			"Slice",
-			"SliceStable",
-			"SliceIsSorted",
-			"Search",
-			"IntsAreSorted",
-			"Float64sAreSorted",
-			"StringsAreSorted",
-		]),
-	],
-	[
-		"fmt",
-		new Set([
-			"Sprintf",
-			"Sprint",
-			"Sprintln",
-			"Append",
-			"Appendf",
-			"Appendln",
-			"Errorf",
-			"Printf",
-			"Println",
-			"Print",
-			"Fprintf",
-			"Fprintln",
-			"Fprint",
-			"Sscan",
-			"Sscanln",
-			"Sscanf",
-			"Stringer",
-		]),
-	],
-	[
-		"strings",
-		new Set([
-			"Contains",
-			"ContainsAny",
-			"ContainsRune",
-			"HasPrefix",
-			"HasSuffix",
-			"Index",
-			"IndexAny",
-			"IndexByte",
-			"IndexRune",
-			"LastIndex",
-			"LastIndexByte",
-			"Count",
-			"Repeat",
-			"Replace",
-			"ReplaceAll",
-			"ToUpper",
-			"ToLower",
-			"Title",
-			"ToTitle",
-			"TrimSpace",
-			"Trim",
-			"TrimLeft",
-			"TrimRight",
-			"TrimPrefix",
-			"TrimSuffix",
-			"EqualFold",
-			"Split",
-			"Fields",
-			"Join",
-			"Cut",
-			"CutPrefix",
-			"CutSuffix",
-			"SplitN",
-			"SplitAfter",
-			"SplitAfterN",
-			"LastIndexAny",
-			"Map",
-			"IndexFunc",
-			"LastIndexFunc",
-			"TrimFunc",
-			"TrimLeftFunc",
-			"TrimRightFunc",
-			"FieldsFunc",
-			"NewReplacer",
-			"Replacer",
-			"Builder",
-			"NewReader",
-			"Reader",
-			"ToValidUTF8",
-		]),
-	],
-	[
-		"strconv",
-		new Set([
-			"Itoa",
-			"Atoi",
-			"FormatInt",
-			"FormatUint",
-			"FormatFloat",
-			"FormatBool",
-			"ParseInt",
-			"ParseUint",
-			"ParseFloat",
-			"ParseBool",
-			"Quote",
-			"Unquote",
-			"AppendInt",
-			"AppendUint",
-			"AppendFloat",
-			"AppendBool",
-			"ErrSyntax",
-			"ErrRange",
-			"IntSize",
-			"NumError",
-			"QuoteRune",
-			"QuoteToASCII",
-			"QuoteRuneToASCII",
-			"AppendQuote",
-			"AppendQuoteToASCII",
-			"AppendQuoteRune",
-			"AppendQuoteRuneToASCII",
-			"CanBackquote",
-			"UnquoteChar",
-			"QuotedPrefix",
-			"IsPrint",
-			"IsGraphic",
-		]),
-	],
-	[
-		"slices",
-		new Set([
-			"Sort",
-			"Reverse",
-			"Contains",
-			"Index",
-			"IndexFunc",
-			"ContainsFunc",
-			"BinarySearch",
-			"BinarySearchFunc",
-			"Equal",
-			"Clone",
-			"Compare",
-			"SortFunc",
-			"SortStableFunc",
-			"IsSorted",
-			"IsSortedFunc",
-			"Min",
-			"Max",
-			"MinFunc",
-			"MaxFunc",
-			"Compact",
-			"CompactFunc",
-			"Concat",
-			"Delete",
-			"DeleteFunc",
-			"Insert",
-			"Replace",
-			"Grow",
-			"Clip",
-		]),
-	],
-	[
-		"maps",
-		new Set(["Clone", "Copy", "Equal", "EqualFunc", "Delete", "DeleteFunc"]),
-	],
-	[
-		"unicode",
-		new Set([
-			"IsLetter",
-			"IsDigit",
-			"IsSpace",
-			"IsUpper",
-			"IsLower",
-			"IsPunct",
-			"IsControl",
-			"IsPrint",
-			"IsGraphic",
-			"ToUpper",
-			"ToLower",
-		]),
-	],
-	[
-		"rand",
-		new Set([
-			"Intn",
-			"Float64",
-			"Float32",
-			"Int",
-			"Int63",
-			"Int63n",
-			"Int31",
-			"Int31n",
-			"Seed",
-			"Shuffle",
-			"Perm",
-			"Read",
-			"Reader",
-		]),
-	],
-	[
-		"bytes",
-		new Set([
-			"Contains",
-			"HasPrefix",
-			"HasSuffix",
-			"Index",
-			"Count",
-			"Repeat",
-			"Replace",
-			"ReplaceAll",
-			"ToUpper",
-			"ToLower",
-			"TrimSpace",
-			"Trim",
-			"Equal",
-			"Split",
-			"Join",
-			"TrimPrefix",
-			"TrimSuffix",
-			"TrimLeft",
-			"TrimRight",
-			"TrimFunc",
-			"IndexByte",
-			"LastIndex",
-			"LastIndexByte",
-			"Fields",
-			"FieldsFunc",
-			"Clone",
-			"Cut",
-			"ToTitle",
-			"ContainsAny",
-			"ContainsRune",
-			"Map",
-			"SplitN",
-			"Buffer",
-			"NewBuffer",
-			"NewBufferString",
-			"NewReader",
-			"Reader",
-			"ToValidUTF8",
-		]),
-	],
-	[
-		"path",
-		new Set([
-			"Base",
-			"Dir",
-			"Ext",
-			"Join",
-			"Clean",
-			"IsAbs",
-			"Split",
-			"Match",
-			"ErrBadPattern",
-		]),
-	],
-	[
-		"filepath",
-		new Set([
-			"Base",
-			"Dir",
-			"Ext",
-			"Join",
-			"Clean",
-			"IsAbs",
-			"Split",
-			"Match",
-			"ErrBadPattern",
-		]),
-	],
-	["html", new Set(["EscapeString", "UnescapeString"])],
-	[
-		"io",
-		new Set([
-			"Writer",
-			"Reader",
-			"ReadWriter",
-			"Closer",
-			"EOF",
-			"ReadAll",
-			"Discard",
-			"WriteString",
-			"LimitReader",
-			"Copy",
-			"CopyN",
-		]),
-	],
-	[
-		"time",
-		new Set([
-			"Now",
-			"Since",
-			"Parse",
-			"ParseDuration",
-			"Unix",
-			"UnixMicro",
-			"UnixMilli",
-			"Date",
-			"FixedZone",
-			"Duration",
-			"Nanosecond",
-			"Microsecond",
-			"Millisecond",
-			"Second",
-			"Minute",
-			"Hour",
-			"RFC3339",
-			"RFC3339Nano",
-			"DateOnly",
-			"TimeOnly",
-			"DateTime",
-			"UTC",
-			"Local",
-			"January",
-			"February",
-			"March",
-			"April",
-			"May",
-			"June",
-			"July",
-			"August",
-			"September",
-			"October",
-			"November",
-			"December",
-			"Sunday",
-			"Monday",
-			"Tuesday",
-			"Wednesday",
-			"Thursday",
-			"Friday",
-			"Saturday",
-			"Time",
-			"Month",
-			"Weekday",
-			"Location",
-		]),
-	],
-	["testing", new Set(["T", "B", "M", "TB", "BenchmarkResult"])],
-	["sync", new Set(["Mutex", "RWMutex", "Once", "WaitGroup", "Locker"])],
-	["sha256", new Set(["Sum256", "New", "Size", "BlockSize"])],
-	[
-		"binary",
-		new Set([
-			"LittleEndian",
-			"BigEndian",
-			"ByteOrder",
-			"Read",
-			"Write",
-			"Size",
-			"AppendUint16",
-			"AppendUint32",
-			"AppendUint64",
-		]),
-	],
-	[
-		"hex",
-		new Set([
-			"EncodeToString",
-			"DecodeString",
-			"Encode",
-			"Decode",
-			"EncodedLen",
-			"DecodedLen",
-			"ErrLength",
-		]),
-	],
-	[
-		"base64",
-		new Set([
-			"StdEncoding",
-			"URLEncoding",
-			"RawStdEncoding",
-			"RawURLEncoding",
-			"Encoding",
-			"NewEncoding",
-			"StdPadding",
-			"NoPadding",
-		]),
-	],
-]);
+export const WASM_STDLIB_MEMBERS = new Map();
 
 export const VALID_TARGETS = new Set(["js", "wasm", "both"]);
 
 // Backend-provided implementations for body-less Go-source stdlib functions
 // marked `//gofront:intrinsic <name>`: name -> required signature.  New
 // intrinsics need a plan change.
-export const INTRINSICS = new Map([]);
+export const INTRINSICS = new Map([
+	// A uniformly distributed float64 in [0, 1) from the host source
+	// (`Math.random`); the only entropy math/rand draws.
+	["rand_source", "func() float64"],
+	// The host clock in nanoseconds since the Unix epoch, and the offset in
+	// seconds east of UTC of the host's time zone at a Unix time (time).
+	["time_now", "func() int64"],
+	["time_zone_offset", "func(int64) int"],
+	// time (js only): suspend for a number of nanoseconds; the declaration is
+	// `async`.
+	["time_sleep", "func(int64) void"],
+	// os: write a string to a file descriptor (0 stdin, 1 stdout, 2 stderr),
+	// exit the process, and read and set environment variables.
+	["os_write", "func(int, string) void"],
+	["os_exit", "func(int) void"],
+	["os_getenv", "func(string) string"],
+	["os_setenv", "func(string, string) void"],
+	// unicode: the host's answer for runes above ASCII, by class (the
+	// constants of stdlib/unicode), and its case mappings.
+	["unicode_is", "func(int32, int) bool"],
+	["unicode_to_upper", "func(int32) int32"],
+	["unicode_to_lower", "func(int32) int32"],
+	// crypto/rand: four random bytes from the host's secure source.
+	["crypto_rand_u32", "func() uint32"],
+	// testing: a monotonic clock in nanoseconds, and an unanchored regular
+	// expression match for -run and -bench patterns.
+	["testing_nanotime", "func() int64"],
+	["testing_match", "func(string, string) bool"],
+	// testing (js only): call a test body and return what it returned (a
+	// promise for an async body, otherwise nil).
+	["testing_call", "func(any, any) any"],
+	// fmt: a stable number for a pointer, function or other reference.
+	["fmt_ptr_id", "func(any) uint64"],
+	// math: IEEE-754 bit casts, and the host's `Math.*` (`%` for Mod).
+	["math_float64bits", "func(float64) uint64"],
+	["math_float64frombits", "func(uint64) float64"],
+	["math_float32bits", "func(float32) uint32"],
+	["math_float32frombits", "func(uint32) float32"],
+	...[
+		"sin",
+		"cos",
+		"tan",
+		"asin",
+		"acos",
+		"atan",
+		"sinh",
+		"cosh",
+		"tanh",
+		"exp",
+		"expm1",
+		"log",
+		"log1p",
+		"log2",
+		"log10",
+		"cbrt",
+	].map((f) => [`math_${f}`, "func(float64) float64"]),
+	...["atan2", "pow", "hypot", "mod"].map((f) => [
+		`math_${f}`,
+		"func(float64, float64) float64",
+	]),
+]);
+
+// The fmt functions whose calls the compiler wraps with a generated function
+// (src/lower/fmt-formatters.js); a wrapped call may forward `f()`'s results.
+export const FMT_PRINT_FUNCS = new Set([
+	"Sprint",
+	"Sprintln",
+	"Print",
+	"Println",
+	"Fprint",
+	"Fprintln",
+	"Append",
+	"Appendln",
+	"Sprintf",
+	"Printf",
+	"Errorf",
+	"Fprintf",
+	"Appendf",
+]);
+
+// Names a standard-library function may carry in `//gofront:native <name>`:
+// the function keeps its Go body, and a backend registry may replace calls to
+// it with host code (or decline).  A closed set; new names need a plan change.
+export const NATIVES = new Set([
+	"slices.Contains",
+	"slices.Index",
+	"slices.Reverse",
+	"slices.Clone",
+	"bytes.Compare",
+	"bytes.Equal",
+	"bytes.IndexByte",
+	"slices.Sort",
+	"sort.Ints",
+	"sort.Strings",
+	"utf8.RuneCountInString",
+	"strings.Index",
+	"strings.LastIndex",
+	"strings.IndexByte",
+	"strings.LastIndexByte",
+	"strings.IndexRune",
+	"strings.IndexAny",
+	"strings.LastIndexAny",
+	"strings.Contains",
+	"strings.ContainsAny",
+	"strings.ContainsRune",
+	"strings.HasPrefix",
+	"strings.HasSuffix",
+	"strings.Count",
+	"strings.Repeat",
+	"strings.Join",
+	"strings.Replace",
+	"strings.ReplaceAll",
+	"strings.Split",
+	"strings.Fields",
+	"strings.ToUpper",
+	"strings.ToLower",
+	"strings.TrimSpace",
+	"strings.Trim",
+	"strings.TrimLeft",
+	"strings.TrimRight",
+	"strings.TrimPrefix",
+	"strings.TrimSuffix",
+	"strconv.shortest",
+	"strconv.fixed",
+	"strconv.parseDecimal",
+	// internal/jsonrt: the encoder's writes into its output buffer.
+	"jsonrt.putString",
+	"jsonrt.putInt",
+	"jsonrt.putUint",
+	"jsonrt.putFloat",
+	"jsonrt.putQuoted",
+	"jsonrt.readStr",
+	"jsonrt.readNum",
+	"jsonrt.CheckValid",
+	"jsonrt.LooksFloat32",
+	// math: the functions with a single host expression or instruction.
+	"math.IsNaN",
+	"math.IsInf",
+	"math.Inf",
+	"math.NaN",
+	"math.Signbit",
+	"math.Copysign",
+	"math.Abs",
+	"math.Max",
+	"math.Min",
+	"math.Trunc",
+	"math.Floor",
+	"math.Ceil",
+	"math.Round",
+	"math.Sqrt",
+	// math/bits: one host instruction per width (`Math.clz32`, WASM `clz`,
+	// `ctz` and `popcnt`).
+	...["Len", "LeadingZeros", "TrailingZeros", "OnesCount"].flatMap((f) =>
+		["", "8", "16", "32", "64"].map((w) => `bits.${f}${w}`),
+	),
+]);
 
 // ── Static operator sets (module-level for reuse) ────────────
 export const CMP_OPS = new Set(["==", "!=", "<", ">", "<=", ">="]);
@@ -718,6 +303,9 @@ export const FLOAT64 = { kind: "basic", name: "float64" };
 export const STRING = { kind: "basic", name: "string" };
 export const BOOL = { kind: "basic", name: "bool" };
 export const ANY = { kind: "basic", name: "any" };
+// `any` written in source. Untyped JS interop also yields plain ANY, which stays
+// freely assignable; only a declared `any` needs a type assertion.
+export const DECLARED_ANY = { kind: "basic", name: "any", _declared: true };
 export const TAINTED_ANY = { kind: "basic", name: "any", _tainted: true };
 export const VOID = { kind: "basic", name: "void" };
 export const NIL = { kind: "basic", name: "nil" };
@@ -735,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" };
@@ -805,6 +396,33 @@ export const isFloat = makeBasicPredicate(...SIZED_FLOAT_NAMES);
 export const isString = makeBasicPredicate("string");
 export const isBool = makeBasicPredicate("bool");
 
+// True when type t represents an int64 or uint64 (including named types like time.Duration).
+export function is64BitInt(t) {
+	if (!t) return false;
+	if (t.kind === "untyped") return t.base === "int64" || t.base === "uint64";
+	let cur = t;
+	while (cur?.kind === "named") cur = cur.underlying;
+	return (
+		cur?.kind === "basic" && (cur.name === "int64" || cur.name === "uint64")
+	);
+}
+
+export function is64BitSigned(t) {
+	if (!t) return false;
+	if (t.kind === "untyped") return t.base === "int64";
+	let cur = t;
+	while (cur?.kind === "named") cur = cur.underlying;
+	return cur?.kind === "basic" && cur.name === "int64";
+}
+
+export function is64BitUnsigned(t) {
+	if (!t) return false;
+	if (t.kind === "untyped") return t.base === "uint64";
+	let cur = t;
+	while (cur?.kind === "named") cur = cur.underlying;
+	return cur?.kind === "basic" && cur.name === "uint64";
+}
+
 // ── TypedArray mappings ──────────────────────────────────────
 // []float64 deliberately stays a plain Array for JSON / JS-library interop.
 const TYPED_ARRAY_CONSTRUCTORS = {
@@ -915,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":
@@ -936,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":
@@ -979,9 +597,103 @@ 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;
+	return (ast?.name ?? t?.name ?? "")
+		.split(".")
+		.pop()
+		.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+/;
+
 // Go-source stdlib names are mangled to `Name$$path` (`List$$container$list`);
 // diagnostics show them qualified, as Go does (`list.List`).
 export function displayTypeName(name) {
+	if (typeof name === "string") name = name.replace(LOCAL_TYPE_SUFFIX, "");
 	const i = typeof name === "string" ? name.indexOf("$$") : -1;
 	if (i < 0) return name;
 	return `${name