gofront 1.7.0 → 1.9.0

package/src/typechecker/types.js

@@ -102,529 +102,183 @@ export const BROWSER_GLOBALS = new Set([
 	"TextDecoder",
 ]);
 
-// Stdlib packages the WASM backend can emit. Extend as src/backend/wasm/emit-stdlib.js
+// Stdlib packages the WASM backend can emit. Extend as src/backend/wasm/stdlib/
 // 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",
 ]);
 
-export const STDLIB_PACKAGES = new Set([
-	...WASM_SUPPORTED_STDLIB,
-	"os",
-	"gom",
-	"regexp",
-	"encoding/json",
-]);
+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([
-	["json", new Set()],
-	[
-		"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",
-			"Log2",
-			"Log10",
-			"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([
-			"LeadingZeros32",
-			"LeadingZeros64",
-			"TrailingZeros32",
-			"TrailingZeros64",
-			"OnesCount32",
-			"OnesCount64",
-			"RotateLeft32",
-			"RotateLeft64",
-			"ReverseBytes16",
-			"ReverseBytes32",
-			"ReverseBytes64",
-			"Len32",
-			"Len64",
-			"Reverse32",
-			"Reverse64",
-		]),
-	],
-	["errors", new Set(["New", "Is", "Unwrap", "As", "Join"])],
-	[
-		"utf8",
-		new Set([
-			"RuneCountInString",
-			"RuneLen",
-			"ValidString",
-			"ValidRune",
-			"DecodeRuneInString",
-			"DecodeLastRuneInString",
-			"FullRuneInString",
-			"RuneError",
-			"MaxRune",
-			"UTFMax",
-		]),
-	],
-	[
-		"sort",
-		new Set([
-			"Ints",
-			"Float64s",
-			"Strings",
-			"Slice",
-			"SliceStable",
-			"SliceIsSorted",
-			"Search",
-			"IntsAreSorted",
-			"Float64sAreSorted",
-			"StringsAreSorted",
-		]),
-	],
-	[
-		"fmt",
-		new Set([
-			"Sprintf",
-			"Errorf",
-			"Printf",
-			"Println",
-			"Print",
-			"Fprintf",
-			"Fprintln",
-			"Fprint",
-			"Sscan",
-			"Sscanln",
-			"Sscanf",
-		]),
-	],
-	[
-		"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",
-			"Builder",
-			"NewReader",
-			"Reader",
-		]),
-	],
-	[
-		"strconv",
-		new Set([
-			"Itoa",
-			"Atoi",
-			"FormatInt",
-			"FormatUint",
-			"FormatFloat",
-			"FormatBool",
-			"ParseInt",
-			"ParseUint",
-			"ParseFloat",
-			"ParseBool",
-			"Quote",
-			"Unquote",
-			"AppendInt",
-			"AppendUint",
-			"AppendFloat",
-			"AppendBool",
-			"ErrSyntax",
-			"ErrRange",
-		]),
-	],
-	[
-		"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([
-			"Keys",
-			"Values",
-			"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",
-			"NewReader",
-			"Reader",
-		]),
-	],
-	[
-		"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",
-			"ErrUnexpectedEOF",
-			"ErrShortWrite",
-			"ReadFull",
-			"ReadAll",
-			"Discard",
-			"WriteString",
-			"LimitReader",
-			"Copy",
-			"CopyN",
-		]),
-	],
-	[
-		"time",
-		new Set([
-			"Now",
-			"Since",
-			"Parse",
-			"Unix",
-			"UnixMicro",
-			"UnixMilli",
-			"Date",
-			"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",
-		]),
-	],
-	["testing", new Set(["T"])],
-	["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([
+	// 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(["==", "!=", "<", ">", "<=", ">="]);
 export const LOG_OPS = new Set(["&&", "||"]);
@@ -649,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" };
@@ -669,7 +326,7 @@ export const UNTYPED_BOOL = { kind: "untyped", base: "bool" };
 
 // ── Complex types ────────────────────────────────────────────
 export const COMPLEX128 = { kind: "basic", name: "complex128" };
-const COMPLEX64 = { kind: "basic", name: "complex64" };
+export const COMPLEX64 = { kind: "basic", name: "complex64" };
 export const UNTYPED_COMPLEX = { kind: "untyped", base: "complex128" };
 
 export const BASIC_TYPES = {
@@ -736,6 +393,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 = {
@@ -750,6 +434,32 @@ const TYPED_ARRAY_CONSTRUCTORS = {
 	rune: "Int32Array",
 };
 
+// Element indices of an array or slice literal (Go spec): `i: v` puts v at
+// index i, any other element goes right after the previous one, so
+// `[5]int{1, 3: 4, 5}` fills indices 0, 3 and 4.  Array literal keys are
+// resolved by the type checker (`_index`, which handles named constants and
+// constant expressions); otherwise only integer-literal keys are known and
+// another key is treated as a positional element.
+export function compositeLitIndices(elems) {
+	const out = [];
+	let next = 0;
+	for (const e of elems) {
+		if (e.kind === "KeyValueExpr" && e._index !== undefined) next = e._index;
+		else if (e.kind === "KeyValueExpr" && e.key?.value !== undefined)
+			next = Number(e.key.value);
+		out.push(next++);
+	}
+	return out;
+}
+
+// Highest element index of an array or slice literal (-1 when empty).  A
+// loop, not `Math.max(...)`: spreading a huge literal overflows the stack.
+export function compositeLitMaxIndex(elems) {
+	let max = -1;
+	for (const i of compositeLitIndices(elems)) if (i > max) max = i;
+	return max;
+}
+
 export function typedArrayConstructorForElem(elemType) {
 	if (!elemType) return null;
 	const name = elemType.kind === "basic" ? elemType.name : null;
@@ -765,12 +475,28 @@ export function isTypedArraySlice(type) {
 
 export function isComplex(t) {
 	if (!t) return false;
-	if (t.kind === "basic" && (t.name === "complex128" || t.name === "complex64"))
+	if (
+		(t.kind === "basic" || t.kind === "TypeName" || t.kind === "Ident") &&
+		(t.name === "complex128" || t.name === "complex64")
+	)
 		return true;
 	if (t.kind === "untyped" && t.base === "complex128") return true;
 	if (t.kind === "named") return isComplex(t.underlying);
 	return false;
 }
+export function isComplex64(t) {
+	if (!t) return false;
+	if (
+		(t.kind === "basic" || t.kind === "TypeName" || t.kind === "Ident") &&
+		t.name === "complex64"
+	)
+		return true;
+	if (t.kind === "untyped" && t.base === "complex64") return true;
+	if (t.kind === "named") return isComplex64(t.underlying);
+	if (t.name === "complex64") return true;
+	if (t.underlying) return isComplex64(t.underlying);
+	return false;
+}
 export function isComplexOrNumeric(t) {
 	return isNumeric(t) || isComplex(t);
 }
@@ -851,10 +577,12 @@ export function typeStr(t) {
 		}
 		case "tuple":
 			return `(${t.types.map(typeStr).join(", ")})`;
-		case "named":
+		case "named": {
+			const name = displayTypeName(t.name);
 			return t.typeArgs && t.typeArgs.length > 0
-				? `${t.name}[${t.typeArgs.map(typeStr).join(", ")}]`
-				: t.name;
+				? `${name}[${t.typeArgs.map(typeStr).join(", ")}]`
+				: name;
+		}
 		case "pointer":
 			return `*${typeStr(t.base)}`;
 		case "typeParam":
@@ -866,6 +594,32 @@ 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`.
+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(/\$\$.*$/, "");
+}
+
+// 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
+		.slice(i + 2)
+		.split("$")
+		.at(-1)}.${name.slice(0, i)}`;
+}
+
 // ── Iterator function detection (Go 1.23 range-over-func) ───
 
 /**