@scriptc/compiler 0.3.6 → 0.4.1

package/dist/frontend/lowering/generic-functions.js

@@ -1,11 +1,13 @@
+import { staticNameBindings } from "./static-function-names.js";
 import * as ts from "../ts7/adapter.js";
 import { bodyReadsArguments } from "../arguments-usage.js";
 import { DYN, isUnitType, typeEquals, } from "../../ir/ir.js";
 import { isJsSourceFile, locOf } from "../program.js";
 import { typeKey } from "../type-mapper.js";
+import { functionCanReturnUndefined } from "../function-completion.js";
 import { PoisonError, dynFallbackType, neverTaintedJsType, newFnCtx } from "./lowerer.js";
 import { tryLowerExpression } from "./expressions/try-lower-expression.js";
-import { findGenericMethodOn } from "./lower-classes.js";
+import { findGenericMethodOn, storedClassValueType } from "./lower-classes.js";
 import { nsPathPrefix } from "./lower-namespaces.js";
 import { declSymbolOf } from "./lower-modules.js";
 import { npmStaticPackageOfPath } from "../npm-static.js";
@@ -41,9 +43,7 @@ function checkGenericParameterNames(lowerer, parameters, allowPatterns) {
  * cannot see them; const bindings need no whole-file write scan. */
 function requireStableGenericBinding(lowerer, decl, symbol, name) {
     const isConst = (ts.getCombinedNodeFlags(decl) & ts.NodeFlags.Const) !== 0;
-    const redeclared = lowerer.checker
-        .declarationsOf(symbol)
-        .some((d) => d !== decl && ts.isVariableDeclaration(d) && d.initializer !== undefined);
+    const redeclared = symbol.declarations.some((d) => d !== decl && ts.isVariableDeclaration(d) && d.initializer !== undefined);
     if (!isConst && (redeclared || !bindingNeverReassigned(lowerer, symbol, decl))) {
         lowerer.unsupported("SC1090", decl.name, `generic function values in reassigned bindings (calls of '${name}' resolve statically against this initializer, so the binding must provably hold it — a const, or a let/var nothing in its declaring file writes)`);
     }
@@ -54,8 +54,8 @@ function requireStableGenericBinding(lowerer, decl, symbol, name) {
  * generic function requires no body lowering). Called inside
  * collectSignature's poison catch. */
 export function collectGenericSignature(lowerer, decl) {
-    const typeParams = declaredTypeParameterSymbols(lowerer, decl.typeParameters, decl, "this function form");
-    checkGenericParameterNames(lowerer, decl.parameters, true);
+    const typeParams = declaredTypeParameterSymbols(lowerer, decl.typeParameters.nodes, decl, "this function form");
+    checkGenericParameterNames(lowerer, decl.parameters.nodes, true);
     const nameText = decl.name?.text ?? "%default"; // nameless = the default export (checked by collectSignatureInner)
     const symbol = declSymbolOf(lowerer, decl);
     if (!symbol)
@@ -63,7 +63,7 @@ export function collectGenericSignature(lowerer, decl) {
     lowerer.genericFnsBySymbol.set(symbol, {
         decl,
         baseName: nameText,
-        qualifiedName: lowerer.qualify(decl.getSourceFile(), nsPathPrefix(decl) + nameText),
+        qualifiedName: lowerer.qualify(ts.getSourceFileOfNode(decl), nsPathPrefix(decl) + nameText),
         typeParams,
         instances: new Map(),
     });
@@ -84,7 +84,7 @@ export function lowerGenericCall(lowerer, expr, info) {
     const instance = info.implicitParams
         ? implicitCallInstance(lowerer, expr, info)
         : genericCallInstance(lowerer, expr, info);
-    const args = lowerer.completeArgs(expr.arguments, instance.params, loc, expr);
+    const args = lowerer.completeArgs(expr.arguments.nodes, instance.params, loc, expr);
     return { kind: "call", callee: instance.name, args, type: instance.returnType, loc };
 }
 /** The instance a CALL of a generic function-like names: resolved
@@ -100,27 +100,40 @@ export function genericCallInstance(lowerer, expr, info) {
     // honest story (monomorphize per implementation signature with the
     // reconcile bridge, like the non-generic path).
     {
-        const rdecl = rsig ? lowerer.checker.signatureDeclaration(rsig) : undefined;
-        if (rdecl &&
+        const rdecl = rsig ? rsig.declaration : undefined;
+        if (rsig &&
+            rdecl &&
             (ts.isFunctionDeclaration(rdecl) || ts.isMethodDeclaration(rdecl)) &&
             !rdecl.body) {
+            const overload = overloadCallInstance(lowerer, expr, info, rsig, rdecl);
+            if (overload)
+                return overload;
             lowerer.unsupported("SC1090", expr, `calls selecting an overload signature of a generic ${ts.isMethodDeclaration(rdecl) ? "method" : "function"} (only the implementation signature monomorphizes)`);
         }
     }
-    if (!rsig || rsig.getParameters().length !== info.decl.parameters.length) {
+    if (!rsig || rsig.getParameters().length !== info.decl.parameters.nodes.length) {
         lowerer.unsupported("SC1090", expr, "this call form");
     }
     // Per-param shapes from the RESOLVED signature (types substituted) plus
     // the declaration's modes: rest stays the resolved array, a default's
     // ABI union is synthesized over the resolved body type — exactly the
     // paramShape rules, applied to post-substitution types.
-    const params = paramShapes(lowerer, info.decl.parameters, rsig, (_param, i) => expr.arguments[i] ?? expr);
+    const params = paramShapes(lowerer, info.decl.parameters.nodes, rsig, (_param, i) => expr.arguments.nodes[i] ?? expr);
     const retTs = lowerer.checker.getReturnTypeOfSignature(rsig);
-    const returnType = lowerer.mapTypeOf(retTs);
-    if (!returnType) {
+    const local = localClassResultInstance(lowerer, expr, info, rsig, params, retTs);
+    if (local)
+        return local;
+    // A result instantiated at `any` (a type argument inferred from an
+    // untyped value, such as an untyped forwarding call) is checked-dynamic.
+    const mappedReturn = lowerer.mapTypeOf(retTs) ??
+        ((retTs.flags & ts.TypeFlags.Any) !== 0 && !isJsSourceFile(ts.getSourceFileOfNode(info.decl))
+            ? DYN
+            : null);
+    if (!mappedReturn) {
         fenceGenericSignatureResult(lowerer, expr, retTs);
         lowerer.badType(expr, retTs);
     }
+    const returnType = runtimeReturnType(lowerer, info, mappedReturn);
     // keyof-constrained type parameters (`K extends keyof T`): the bound
     // LITERAL is semantic — the instance body reads the named field — so
     // the bindings compute EAGERLY (the key needs them) and each literal
@@ -129,27 +142,246 @@ export function genericCallInstance(lowerer, expr, info) {
     // different fields). Non-literal bindings (a key union, plain string)
     // share one runtime-keyed instance per IR signature, exactly the
     // widened discipline.
-    const keyofTps = keyofConstrainedTypeParams(info);
-    if (keyofTps.size > 0) {
+    const named = staticNameBindings(lowerer, expr, info);
+    if (keyofConstrainedTypeParams(info).size > 0) {
         const tsBindings = new Map();
         const bindings = lowerer.inferTypeParamBindings(expr, info, rsig, tsBindings);
-        const litKey = info.typeParams
-            .filter((tp) => keyofTps.has(tp))
-            .map((tp) => {
-            const bound = tsBindings.get(tp);
-            return bound?.isStringLiteralType()
-                ? JSON.stringify(bound.value)
-                : bound?.isNumberLiteralType()
-                    ? String(bound.value)
-                    : "*";
-        })
-            .join(",");
         return internGenericInstance(lowerer, expr, info, params, returnType, () => bindings, {
-            extraKey: `@${litKey}`,
+            extraKey: `${keyofLiteralKey(info, tsBindings)}${named?.key ?? ""}`,
             tsBindings,
+            ...(named ? { staticFnNames: named.names } : {}),
         });
     }
-    return internGenericInstance(lowerer, expr, info, params, returnType, (tsBindings) => lowerer.inferTypeParamBindings(expr, info, rsig, tsBindings));
+    return internGenericInstance(lowerer, expr, info, params, returnType, (tsBindings) => lowerer.inferTypeParamBindings(expr, info, rsig, tsBindings), named ? { extraKey: named.key, staticFnNames: named.names } : undefined);
+}
+/** A call that resolved to an OVERLOAD signature of a generic function
+ * or method with an implementation (`request<T>(p: WithHandler<T>):
+ * Promise<T>; request(p: Plain): Promise<Res>; request<T>(p: Params<T>)
+ * {...}`): the implementation monomorphizes under the bindings the
+ * overload's resolved signature proves for its type parameters (the
+ * structural unification every generic call uses, run against the
+ * overload; unbound parameters take their declared defaults). The
+ * instance's parameters and result are the IMPLEMENTATION's under those
+ * bindings — the body was checked against them — and the call's
+ * arguments and result coerce across, exactly as a non-generic overload
+ * call reconciles with its implementation (parameters the overload omits
+ * must be optional in the implementation). Null when the overload does
+ * not belong to this implementation or the arities do not line up. */
+function overloadCallInstance(lowerer, expr, info, rsig, rdecl) {
+    const impl = info.decl;
+    if (rdecl.parent !== impl.parent ||
+        rdecl.name === undefined ||
+        impl.name === undefined ||
+        rdecl.name.getText() !== impl.name.getText() ||
+        rdecl.parameters.nodes.length > impl.parameters.nodes.length ||
+        impl.parameters.nodes
+            .slice(rdecl.parameters.nodes.length)
+            .some((p) => p.questionToken === undefined && p.initializer === undefined) ||
+        rdecl.parameters.nodes.some((p) => p.dotDotDotToken !== undefined))
+        return null;
+    const declSig = lowerer.checker.getSignatureFromDeclaration(impl);
+    if (!declSig)
+        return null;
+    const tsBindings = new Map();
+    const bindings = new Map();
+    unifySignatureBindings(lowerer, info, rsig, bindings, tsBindings);
+    // Explicit type arguments name the OVERLOAD's type parameters, which
+    // need not match the implementation's in order: the resolved overload
+    // already carries them, so unification binds first, and an explicit
+    // argument binds only a still-unbound implementation parameter of the
+    // same name.
+    const overloadTps = rdecl.typeParameters?.nodes ?? [];
+    expr.typeArguments?.nodes.forEach((ta, i) => {
+        const name = overloadTps[i]?.name.text;
+        const tp = info.typeParams.find((p) => ts.symbolName(p) === name);
+        if (!tp || bindings.has(tp))
+            return;
+        const taT = lowerer.checker.getTypeFromTypeNode(ta);
+        const mapped = lowerer.mapTypeOf(taT);
+        if (mapped) {
+            bindings.set(tp, mapped);
+            tsBindings.set(tp, taT);
+        }
+    });
+    bindDefaultTypeParams(lowerer, info.typeParams, impl.typeParameters?.nodes, bindings, tsBindings);
+    // A type parameter the overload never mentions (a handler the overload
+    // omits) is `unknown`, the checker's own answer for an uninferred one.
+    for (const tp of info.typeParams) {
+        if (bindings.has(tp))
+            continue;
+        bindings.set(tp, DYN);
+        tsBindings.set(tp, lowerer.checker.getUnknownType());
+    }
+    const previous = lowerer.typeParamBindings;
+    const previousTs = lowerer.typeParamTsBindings;
+    lowerer.typeParamBindings = bindings;
+    lowerer.typeParamTsBindings = tsBindings;
+    let params;
+    let returnType;
+    try {
+        params = paramShapes(lowerer, impl.parameters.nodes, declSig, (_param, i) => expr.arguments.nodes[i] ?? expr);
+        returnType = lowerer.mapTypeOf(lowerer.checker.getReturnTypeOfSignature(declSig));
+    }
+    finally {
+        lowerer.typeParamBindings = previous;
+        lowerer.typeParamTsBindings = previousTs;
+    }
+    if (!returnType)
+        return null;
+    // keyof-constrained parameters key their instance on the bound literal,
+    // as on the implementation-signature path.
+    const runtimeReturn = runtimeReturnType(lowerer, info, returnType);
+    return internGenericInstance(lowerer, expr, info, params, runtimeReturn, () => bindings, {
+        ...(keyofConstrainedTypeParams(info).size > 0
+            ? { extraKey: keyofLiteralKey(info, tsBindings) }
+            : {}),
+        tsBindings,
+    });
+}
+/** An instance's result type: a body that can return an indexed read
+ * that misses returns undefined there, as in JavaScript, whatever the
+ * declared result says. An async body's promise is always present and
+ * settles with undefined there. */
+function runtimeReturnType(lowerer, info, mapped) {
+    if (!lowerer.runtimeOptionalGenericReturns.has(info.decl))
+        return mapped;
+    return mapped.kind === "promise"
+        ? { kind: "promise", inner: lowerer.runtimeOptionalType(mapped.inner) }
+        : lowerer.runtimeOptionalType(mapped);
+}
+/** A generic factory whose result is one of its own local classes
+ * (`function base<T>(v: T) { return class { value: T = v }; }`). Each
+ * instance has its own class, so the instance is keyed on its bindings and
+ * the result maps inside it, where the local class takes the instance's
+ * name and bindings. */
+function localClassResultInstance(lowerer, expr, info, rsig, params, retTs) {
+    if (!localClassOfResult(lowerer, info, retTs))
+        return null;
+    const tsBindings = new Map();
+    const bindings = lowerer.inferTypeParamBindings(expr, info, rsig, tsBindings);
+    const bindingKey = info.typeParams
+        .map((tp) => {
+        const bound = bindings.get(tp);
+        return bound ? typeKey(bound) : "?";
+    })
+        .join(",");
+    const pending = { kind: "void" };
+    const inst = internGenericInstance(lowerer, expr, info, params, pending, () => bindings, {
+        extraKey: `@class<${bindingKey}>`,
+        tsBindings,
+    });
+    if (inst.returnType !== pending)
+        return inst;
+    const returnType = withInstanceScope(lowerer, info, inst, () => lowerer.mapTypeOf(retTs));
+    if (!returnType) {
+        fenceGenericSignatureResult(lowerer, expr, retTs);
+        lowerer.badType(expr, retTs);
+    }
+    inst.returnType = returnType;
+    // Values of the class outside the factory (`const b = new B()`, `b.read()`)
+    // carry the instantiated checker type; record which class it names. A
+    // call inside another generic instance can have a type that depends on
+    // that instance's parameters, which no single class answers.
+    if (lowerer.typeParamBindings !== null)
+        return inst;
+    const instance = returnType.kind === "classval"
+        ? lowerer.checker
+            .getConstructSignatures(retTs)
+            .map((sig) => lowerer.checker.getReturnTypeOfSignature(sig))
+        : [retTs];
+    const className = returnType.kind === "classval" || returnType.kind === "object" ? returnType.className : null;
+    if (className !== null)
+        for (const type of instance)
+            lowerer.localClassInstanceTypes.set(type.id, className);
+    return inst;
+}
+/** The class value a call of a generic factory returns when the result is
+ * one of the factory's local classes (`class C extends base(42) {}`), or
+ * null for any other call. */
+export function genericLocalClassResult(lowerer, expr) {
+    if (!ts.isIdentifier(expr.expression))
+        return null;
+    const info = lowerer.genericFnOf(expr.expression);
+    if (!info || info.implicitParams)
+        return null;
+    const rsig = lowerer.checker.getResolvedSignature(expr);
+    if (!rsig || !localClassOfResult(lowerer, info, lowerer.checker.getReturnTypeOfSignature(rsig)))
+        return null;
+    return genericCallInstance(lowerer, expr, info).returnType;
+}
+/** The type of a `const` binding whose initializer calls a generic factory
+ * returning one of its local classes (`const B = base(7)`), or constructs
+ * such a class (`const b = new B()`); null for any other binding. */
+export function genericLocalClassBinding(lowerer, node) {
+    const decl = node.parent;
+    if (!ts.isIdentifier(node) ||
+        !decl ||
+        !ts.isVariableDeclaration(decl) ||
+        decl.name !== node ||
+        !decl.initializer ||
+        (ts.getCombinedNodeFlags(decl) & ts.NodeFlags.Const) === 0)
+        return null;
+    // An `any` binding keeps the checked-dynamic representation.
+    if ((lowerer.typeOf(node).flags & ts.TypeFlags.Any) !== 0)
+        return null;
+    let init = decl.initializer;
+    while (ts.isParenthesizedExpression(init))
+        init = init.expression;
+    if (ts.isCallExpression(init))
+        return genericLocalClassResult(lowerer, init);
+    if (!ts.isNewExpression(init))
+        return null;
+    const constructed = storedClassValueType(lowerer, init.expression);
+    if (constructed?.kind !== "classval")
+        return null;
+    const classDecl = lowerer.classes.get(constructed.className)?.decl;
+    return classDecl && insideGenericFunction(classDecl)
+        ? { kind: "object", className: constructed.className }
+        : null;
+}
+/** Whether `node` is declared inside a function with type parameters. */
+function insideGenericFunction(node) {
+    for (let parent = node.parent; parent && !ts.isSourceFile(parent); parent = parent.parent)
+        if (ts.isFunctionLike(parent) && (parent.typeParameters?.nodes.length ?? 0) > 0)
+            return true;
+    return false;
+}
+/** The class declared inside a generic function that `type` is the
+ * constructor or instance type of, or null. */
+function localClassOfResult(lowerer, info, type) {
+    const symbol = type.getSymbol();
+    if (!symbol || !(symbol.flags & ts.SymbolFlags.Class))
+        return null;
+    const decl = symbol.valueDeclaration;
+    if (!decl || !(ts.isClassExpression(decl) || ts.isClassDeclaration(decl)))
+        return null;
+    for (let parent = decl.parent; parent && !ts.isSourceFile(parent); parent = parent.parent)
+        if (parent === info.decl)
+            return decl;
+    return null;
+}
+/** Runs `fn` under an instance's type bindings and local-class names, as
+ * its body lowers. */
+function withInstanceScope(lowerer, info, inst, fn) {
+    const prevBindings = lowerer.typeParamBindings;
+    const prevTsBindings = lowerer.typeParamTsBindings;
+    const previousPath = lowerer.genericInstantiationPath;
+    const prevContext = lowerer.instantiationContext;
+    lowerer.typeParamBindings = inst.bindings;
+    lowerer.typeParamTsBindings = inst.tsBindings ?? null;
+    lowerer.genericInstantiationPath = inst.path;
+    lowerer.instantiationContext = `instantiating '${info.baseName}' with ${inst.typeArgsText}`;
+    lowerer.localClassInstantiations.push({ owner: info.decl, name: inst.name });
+    try {
+        return fn();
+    }
+    finally {
+        lowerer.localClassInstantiations.pop();
+        lowerer.typeParamBindings = prevBindings;
+        lowerer.typeParamTsBindings = prevTsBindings;
+        lowerer.genericInstantiationPath = previousPath;
+        lowerer.instantiationContext = prevContext;
+    }
 }
 /** The one instance table both instantiation routes share: key identity IS
  * signature identity, so a call (`identity(1)`) and a pinned VALUE
@@ -180,7 +412,7 @@ function internGenericInstance(lowerer, blame, info, params, returnType, makeBin
                 return JSON.stringify(tsBound.value);
             }
             const bound = bindings.get(tp);
-            return bound ? lowerer.fmt(bound) : tp.name;
+            return bound ? lowerer.fmt(bound) : ts.symbolName(tp);
         })
             .join(", ");
         // Deep polymorphic recursion renders unbounded types — keep messages sane.
@@ -194,6 +426,7 @@ function internGenericInstance(lowerer, blame, info, params, returnType, makeBin
             bindings,
             tsBindings,
             typeArgsText,
+            ...(opts?.staticFnNames ? { staticFnNames: opts.staticFnNames } : {}),
         };
         info.instances.set(key, inst);
         lowerer.instantiationQueue.push({ info, inst });
@@ -209,7 +442,7 @@ function keyofConstrainedTypeParams(info) {
     if (info.keyofTps)
         return info.keyofTps;
     const out = new Set();
-    info.decl.typeParameters?.forEach((tpDecl, i) => {
+    info.decl.typeParameters?.nodes.forEach((tpDecl, i) => {
         const sym = info.typeParams[i];
         if (!sym || tpDecl.constraint === undefined)
             return;
@@ -221,6 +454,24 @@ function keyofConstrainedTypeParams(info) {
     info.keyofTps = out;
     return out;
 }
+/** The instance-key suffix of the literals bound to `info`'s
+ * keyof-constrained type parameters (`@"a"`; `*` for a non-literal
+ * binding): two literals can map to one IR signature while their bodies
+ * read different fields. */
+function keyofLiteralKey(info, tsBindings) {
+    const keyofTps = keyofConstrainedTypeParams(info);
+    const literals = info.typeParams
+        .filter((tp) => keyofTps.has(tp))
+        .map((tp) => {
+        const bound = tsBindings.get(tp);
+        return bound?.isStringLiteralType()
+            ? JSON.stringify(bound.value)
+            : bound?.isNumberLiteralType()
+                ? String(bound.value)
+                : "*";
+    });
+    return `@${literals.join(",")}`;
+}
 /** Type-parameter symbol → concrete IR type for one instantiation.
  * Explicit type arguments bind directly; the rest come from structurally
  * matching each DECLARED param/return type (which mentions the type
@@ -231,7 +482,7 @@ function keyofConstrainedTypeParams(info) {
  * (carrying the instantiation context). */
 export function inferTypeParamBindings(lowerer, expr, info, rsig, tsBindings) {
     const bindings = new Map();
-    expr.typeArguments?.forEach((ta, i) => {
+    expr.typeArguments?.nodes.forEach((ta, i) => {
         const tp = info.typeParams[i];
         if (!tp)
             return;
@@ -243,7 +494,7 @@ export function inferTypeParamBindings(lowerer, expr, info, rsig, tsBindings) {
         }
     });
     unifySignatureBindings(lowerer, info, rsig, bindings, tsBindings);
-    bindDefaultTypeParams(lowerer, info.typeParams, info.decl.typeParameters, bindings, tsBindings);
+    bindDefaultTypeParams(lowerer, info.typeParams, info.decl.typeParameters?.nodes, bindings, tsBindings);
     return bindings;
 }
 /** Type parameters still unbound after unification take their declared
@@ -298,7 +549,11 @@ function unifySignatureBindings(lowerer, info, rsig, bindings, tsBindings) {
                     tsBindings.set(sym, lowerer.typeParamTsResolver(inst) ?? inst);
                 }
                 if (!bindings.has(sym)) {
-                    const mapped = lowerer.mapTypeOf(inst);
+                    const mapped = lowerer.mapTypeOf(inst) ??
+                        ((inst.flags & ts.TypeFlags.Any) !== 0 &&
+                            !isJsSourceFile(ts.getSourceFileOfNode(info.decl))
+                            ? DYN
+                            : null);
                     // A visitor's inferred T can be void. It still binds the
                     // return convention of `(node) => T`; discarding it leaves
                     // the callback's return type spuriously uninstantiated.
@@ -334,6 +589,31 @@ function unifySignatureBindings(lowerer, info, rsig, bindings, tsBindings) {
                 // too is safe only when no undeclared null arm remains.
                 unify(dParts[0], lowerer.checker.getNonNullableType(inst), depth + 1);
             }
+            else if (dParts.length > 1 && iParts.length === dParts.length) {
+                // `T | Promise<T>` against `Res | Promise<Res>`: each declared
+                // part that names a generic target (Promise, an interface, an
+                // alias) pairs with the one instantiated part of the same target;
+                // a single remaining bare type parameter takes the single
+                // remaining instantiated part.
+                const remaining = [...iParts];
+                const bare = [];
+                for (const d of dParts) {
+                    if (d.flags & ts.TypeFlags.TypeParameter) {
+                        bare.push(d);
+                        continue;
+                    }
+                    const target = d.getSymbol() ?? d.getAliasSymbol();
+                    if (target === undefined)
+                        return;
+                    const matches = remaining.filter((i) => (i.getSymbol() ?? i.getAliasSymbol()) === target);
+                    if (matches.length !== 1)
+                        return;
+                    remaining.splice(remaining.indexOf(matches[0]), 1);
+                    unify(d, matches[0], depth + 1);
+                }
+                if (bare.length === 1 && remaining.length === 1)
+                    unify(bare[0], remaining[0], depth + 1);
+            }
             return;
         }
         // Instantiations of the SAME generic ALIAS (Partial<T> vs
@@ -400,7 +680,7 @@ function unifySignatureBindings(lowerer, info, rsig, bindings, tsBindings) {
         }
         if (declared.flags & ts.TypeFlags.Object) {
             for (const dp of lowerer.checker.getPropertiesOfType(declared)) {
-                const ip = lowerer.checker.getPropertyOfType(inst, dp.name);
+                const ip = lowerer.checker.getPropertyOfType(inst, ts.symbolName(dp));
                 if (ip)
                     unify(lowerer.checker.getTypeOfSymbol(dp), lowerer.checker.getTypeOfSymbol(ip), depth + 1);
             }
@@ -431,6 +711,8 @@ export function lowerGenericInstance(lowerer, info, inst) {
     const prevSuppress = lowerer.suppressStats;
     const prevClass = lowerer.currentClass;
     const prevImplicit = lowerer.implicitParamTypes;
+    const prevStaticFnNames = lowerer.staticFnNames;
+    lowerer.staticFnNames = inst.staticFnNames ?? null;
     // A generic METHOD of a generic-class INSTANTIATION lowers under BOTH
     // binding sets: the receiver instantiation's class type parameters
     // underneath, the method instantiation's own on top (disjoint symbol
@@ -460,7 +742,7 @@ export function lowerGenericInstance(lowerer, info, inst) {
     // body returns the resolved promise's INNER type, calls enter through
     // the instance's own spawn wrapper (the emitter routes by fn.async),
     // and awaits park this instance's fibers.
-    const isAsync = decl.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) === true;
+    const isAsync = decl.modifiers?.nodes.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) === true;
     const nameBlame = (ts.isArrowFunction(decl) ? undefined : decl.name) ?? decl;
     const isGenerator = decl.asteriskToken !== undefined;
     if (isAsync && !isGenerator && inst.returnType.kind !== "promise") {
@@ -478,6 +760,8 @@ export function lowerGenericInstance(lowerer, info, inst) {
         : lowerer.bodyReturnType(isAsync, inst.returnType);
     const fnCtx = newFnCtx(false, null, null, bodyReturn);
     fnCtx.isAsync = isAsync;
+    // Instances lower on demand, on top of whichever caller reached them.
+    fnCtx.thisBoundary = true;
     // Implicit-any instances whose declared return did not map lower in
     // return-INFERENCE mode: `return` statements record here bare, and the
     // post-pass (resolveInferredReturn) settles the type and wraps them.
@@ -491,6 +775,8 @@ export function lowerGenericInstance(lowerer, info, inst) {
     lowerer.fnStack.push(fnCtx);
     lowerer.localClassInstantiations.push({ owner: decl, name: inst.name });
     lowerer.genericInstantiationPath = inst.path;
+    if (inst.erased)
+        lowerer.erasingDepth++;
     try {
         // Static specializations bind lexical this only when the caller
         // proved its exact receiver. Other instances retain the fence;
@@ -514,12 +800,12 @@ export function lowerGenericInstance(lowerer, info, inst) {
         }
         // Default-param initializers lower per instance, with the bindings
         // threaded — a default mentioning T resolves like any body expression.
-        const declared = lowerer.declareParams(decl.parameters, inst.params);
+        const declared = lowerer.declareParams(decl.parameters.nodes, inst.params);
         params.push(...declared.params);
         const body = [...receiverInit, ...declared.prologue];
         const bodyBlock = blockBodyOf(decl);
         if (bodyBlock) {
-            body.push(...lowerer.lowerStmts(bodyBlock.statements));
+            body.push(...lowerer.lowerStmts(bodyBlock.statements.nodes));
             if (fnCtx.inferReturn) {
                 bodyReturn = resolveInferredReturn(lowerer, inst, fnCtx.inferReturn, body, decl);
                 inst.returnType = bodyReturn;
@@ -587,9 +873,12 @@ export function lowerGenericInstance(lowerer, info, inst) {
         lowerer.typeParamBindings = prevBindings;
         lowerer.typeParamTsBindings = prevTsBindings;
         lowerer.implicitParamTypes = prevImplicit;
+        lowerer.staticFnNames = prevStaticFnNames;
         lowerer.instantiationContext = prevContext;
         lowerer.localClassInstantiations.pop();
         lowerer.suppressStats = prevSuppress;
+        if (inst.erased)
+            lowerer.erasingDepth--;
     }
 }
 /** A generic function taken as a VALUE, monomorphized by flow. A function
@@ -617,6 +906,12 @@ export function lowerGenericFnValue(lowerer, ref, info) {
         lowerer.noteEdge(inst.name);
         return { kind: "closure", fnName: inst.name, captures: [], type: funcType, loc };
     }
+    // Each call of the enclosing function makes a new function object for a
+    // binding declared inside it (`make() !== make()` when make returns
+    // it), which one shared compiled instance cannot give.
+    if (info.functionScoped) {
+        lowerer.unsupported("SC1090", ref, `generic arrow/function-expression bindings declared inside functions as values (each call of the enclosing function makes a new '${info.baseName}' function object, while its compiled instances are shared module functions — call '${info.baseName}' directly, or declare it at module scope)`);
+    }
     const fenceUnpinned = () => lowerer.unsupported("SC1090", ref, `generic functions as values without a pinned concrete signature (annotate the destination — e.g. 'const f: (x: number) => number = ${info.baseName}' — instantiate explicitly ('${info.baseName}<number>'), or call '${info.baseName}' directly)`);
     // The PINNING type: an instantiation expression's own checker type
     // (explicit type arguments applied), else the reference's contextual
@@ -654,7 +949,7 @@ export function lowerGenericFnValue(lowerer, ref, info) {
     const hofBinding = runtimeOptionalHofGenericBinding(lowerer, ref, info);
     if (hofBinding)
         bindings.set(hofBinding.typeParam, hofBinding.type);
-    bindDefaultTypeParams(lowerer, info.typeParams, info.decl.typeParameters, bindings);
+    bindDefaultTypeParams(lowerer, info.typeParams, info.decl.typeParameters?.nodes, bindings);
     // A pinning signature that itself keeps type parameters (`let g: <T>(x:
     // T) => T = identity` — storing the generic signature as such) binds
     // nothing: mapType answers null for an unsubstituted parameter.
@@ -673,7 +968,7 @@ function runtimeOptionalHofGenericBinding(lowerer, ref, info) {
     while (argument.parent && ts.isParenthesizedExpression(argument.parent))
         argument = argument.parent;
     const call = argument.parent;
-    if (!ts.isCallExpression(call) || call.arguments[0] !== argument)
+    if (!ts.isCallExpression(call) || call.arguments.nodes[0] !== argument)
         return null;
     if (!ts.isPropertyAccessExpression(call.expression) || call.expression.name.text !== "map")
         return null;
@@ -682,7 +977,7 @@ function runtimeOptionalHofGenericBinding(lowerer, ref, info) {
     const receiver = lowerer.mapTypeOf(lowerer.typeOf(call.expression.expression));
     if (receiver?.kind !== "array")
         return null;
-    const parameter = info.decl.parameters[0];
+    const parameter = info.decl.parameters.nodes[0];
     if (!parameter || !ts.isIdentifier(parameter.name))
         return null;
     const parameterType = lowerer.typeOf(parameter.name);
@@ -693,6 +988,20 @@ function runtimeOptionalHofGenericBinding(lowerer, ref, info) {
         return null;
     return { typeParam, type: lowerer.runtimeOptionalType(receiver.elem) };
 }
+/** The erased instance of a generic declaration: every type parameter
+ * bound to `unknown`, the function JavaScript runs for any type arguments.
+ * Values of generic methods (dynamic dispatch, interface views) call it. */
+export function erasedGenericInstance(lowerer, blame, info) {
+    lowerer.erasingDepth++;
+    try {
+        const instance = genericValueInstance(lowerer, blame, info, new Map(info.typeParams.map((tp) => [tp, DYN])));
+        instance.erased = true;
+        return instance;
+    }
+    finally {
+        lowerer.erasingDepth--;
+    }
+}
 /** The instance a pinned VALUE reference names: the declaration's modes
  * over the DECLARED types mapped under the bindings (mapType's resolver
  * substitutes — the instance-body trick), which is the same result the
@@ -704,7 +1013,7 @@ function genericValueInstance(lowerer, ref, info, bindings) {
     const rendered = info.typeParams
         .map((tp) => {
         const bound = bindings.get(tp);
-        return bound ? lowerer.fmt(bound) : tp.name;
+        return bound ? lowerer.fmt(bound) : ts.symbolName(tp);
     })
         .join(", ");
     lowerer.typeParamBindings = bindings;
@@ -713,7 +1022,7 @@ function genericValueInstance(lowerer, ref, info, bindings) {
         const declSig = lowerer.checker.getSignatureFromDeclaration(info.decl);
         if (!declSig)
             lowerer.unsupported("SC1090", ref, "this function form");
-        const params = paramShapes(lowerer, info.decl.parameters, declSig);
+        const params = paramShapes(lowerer, info.decl.parameters.nodes, declSig);
         const retTs = lowerer.checker.getReturnTypeOfSignature(declSig);
         const returnType = lowerer.mapTypeOf(retTs);
         if (!returnType) {
@@ -797,7 +1106,7 @@ function paramWrittenInBody(lowerer, body, sym, name) {
                     hit = true;
                     return;
                 }
-                m.forEachChild(scan);
+                ts.forEachChild(m, scan);
             };
             scan(n);
             return hit;
@@ -829,7 +1138,7 @@ function paramWrittenInBody(lowerer, body, sym, name) {
             written = true;
             return;
         }
-        n.forEachChild(walk);
+        ts.forEachChild(n, walk);
     };
     walk(body);
     return written;
@@ -845,6 +1154,105 @@ function broadPromiseParam(lowerer, type) {
         arms.some((arm) => arm.kind === "promise" && arm.inner.kind === "dyn") &&
         arms.every((arm) => isUnitType(arm) || (arm.kind === "promise" && arm.inner.kind === "dyn")));
 }
+/** The destructured object parameters of a JS function-like that bind like
+ * implicit type parameters: every element a plain name (optionally renamed
+ * from an identifier or string key) with no default, no rest element, and
+ * no write in the body, under a broad inferred type. Parallel to
+ * decl.parameters. */
+export function implicitPatternsOf(lowerer, decl) {
+    return decl.parameters.nodes.map((param) => {
+        if (!ts.isObjectBindingPattern(param.name) || !decl.body)
+            return null;
+        if (param.dotDotDotToken || param.questionToken || param.initializer)
+            return null;
+        const elements = [];
+        for (const element of param.name.elements.nodes) {
+            if (element.dotDotDotToken || element.initializer || !ts.isIdentifier(element.name))
+                return null;
+            const key = element.propertyName ?? element.name;
+            if (!ts.isIdentifier(key) && !ts.isStringLiteral(key))
+                return null;
+            const symbol = lowerer.checker.getSymbolAtLocation(element.name);
+            if (!symbol || paramWrittenInBody(lowerer, decl.body, symbol, element.name.text))
+                return null;
+            // A JSDoc or contextual type names the properties: keep its ABI.
+            if ((lowerer.typeOf(element.name).flags & ts.TypeFlags.Any) === 0)
+                return null;
+            elements.push({ property: key.text, symbol });
+        }
+        return elements.length > 0 ? { elements } : null;
+    });
+}
+/** The type a destructured parameter takes at one call site (the object's
+ * own representation, a record or a checked value) and the checker type
+ * each destructured name binds. An object literal argument types the names
+ * from its property expressions, which see the enclosing instance's
+ * bindings (`makeClass({ Base, name })` inside a specialized
+ * `extend(Base, name)`); any other argument uses its checker type. Null
+ * when the argument lacks a destructured property, or passes a class the
+ * callee itself defines: each such class would instantiate the callee
+ * again (a static `extend` calling `makeClass({ Base: this })`). */
+function implicitPatternBinding(lowerer, callee, pattern, arg) {
+    let literal = arg;
+    while (ts.isParenthesizedExpression(literal))
+        literal = literal.expression;
+    const types = new Map();
+    if (ts.isObjectLiteralExpression(literal)) {
+        const values = new Map();
+        /** Shorthand properties name the binding they read. */
+        const shorthand = new Map();
+        for (const property of literal.properties.nodes) {
+            if (ts.isShorthandPropertyAssignment(property) && ts.isIdentifier(property.name)) {
+                values.set(property.name.text, property.name);
+                const read = lowerer.checker.getShorthandAssignmentValueSymbol(property);
+                if (read)
+                    shorthand.set(property.name.text, read);
+            }
+            else if (ts.isPropertyAssignment(property) &&
+                (ts.isIdentifier(property.name) || ts.isStringLiteral(property.name)))
+                values.set(property.name.text, property.initializer);
+            else
+                return null;
+        }
+        for (const element of pattern.elements) {
+            const value = values.get(element.property);
+            if (!value)
+                return null;
+            const read = shorthand.get(element.property);
+            const type = (read && lowerer.implicitParamTypes?.get(read)) ?? lowerer.typeOf(value);
+            types.set(element.symbol, lowerer.checker.getBaseTypeOfLiteralType(type));
+        }
+        // The object keeps the representation the call site lowers it to; the
+        // destructured names read their static types back out of it.
+        const lowered = tryLowerExpression(lowerer, literal);
+        if (lowered?.type.kind !== "record" && lowered?.type.kind !== "dyn")
+            return null;
+        if (lowered.type.kind === "record") {
+            for (const field of lowerer.shapes.get(lowered.type.shapeId)?.fields ?? [])
+                if (field.type.kind === "classval" && classDefinedIn(lowerer, field.type.className, callee))
+                    return null;
+        }
+        return { record: lowered.type, types };
+    }
+    const argType = lowerer.checker.getBaseTypeOfLiteralType(lowerer.typeOf(arg));
+    const record = lowerer.mapTypeOf(argType);
+    if (record?.kind !== "record")
+        return null;
+    for (const element of pattern.elements) {
+        const property = lowerer.checker.getPropertyOfType(argType, element.property);
+        if (!property)
+            return null;
+        types.set(element.symbol, lowerer.checker.getTypeOfSymbol(property));
+    }
+    return { record, types };
+}
+/** The class is declared inside `scope`. */
+function classDefinedIn(lowerer, className, scope) {
+    for (let n = lowerer.classes.get(className)?.decl ?? undefined; n; n = n.parent)
+        if (n === scope)
+            return true;
+    return false;
+}
 /** The implicit-type-parameter slots of a JS function-like: parallel to
  * decl.parameters, the param SYMBOL where the slot is a bindable
  * implicit param (identifier-named, broad inferred/JSDoc type, not
@@ -857,17 +1265,17 @@ export function implicitAnyParamSymbolsOf(lowerer, decl, classParams = false) {
         return null;
     if (decl.asteriskToken)
         return null;
-    if (decl.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword))
+    if (decl.modifiers?.nodes.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword))
         return null;
     if (decl.typeParameters !== undefined)
         return null; // real generics own the machinery
-    if (decl.parameters.length === 0)
+    if (decl.parameters.nodes.length === 0)
         return null;
     // The variadic-`arguments` form keeps its dynRest story whole.
     if (bodyReadsArguments(decl))
         return null;
     let hasImplicitParams = false;
-    const out = decl.parameters.map((param) => {
+    const out = decl.parameters.nodes.map((param) => {
         if (!ts.isIdentifier(param.name))
             return null;
         if (param.dotDotDotToken || param.questionToken || param.initializer)
@@ -894,6 +1302,10 @@ export function implicitAnyParamSymbolsOf(lowerer, decl, classParams = false) {
         hasImplicitParams = true;
         return sym;
     });
+    // Destructured object parameters monomorphize too (implicitPatternsOf);
+    // their slots stay null here.
+    if (!hasImplicitParams && isJsSourceFile(ts.getSourceFileOfNode(decl)))
+        hasImplicitParams = implicitPatternsOf(lowerer, decl).some((pattern) => pattern !== null);
     return hasImplicitParams ? out : null;
 }
 /** The checker-fallback return type an implicit instance PROMISES before
@@ -907,10 +1319,10 @@ function implicitDeclaredReturn(lowerer, info) {
         // narrower JSDoc (for example a Vector2 target documented as Vector3).
         // Infer their result from the specialized body as well.
         if (info.member?.kind === "static" &&
-            info.decl.parameters.some((param, index) => info.implicitParams?.[index] &&
+            info.decl.parameters.nodes.some((param, index) => info.implicitParams?.[index] &&
                 lowerer.mapTypeOf(lowerer.typeOf(param.name))?.kind === "object"))
             return null;
-        const broadCallbackSymbols = new Set(info.decl.parameters.flatMap((param, index) => {
+        const broadCallbackSymbols = new Set(info.decl.parameters.nodes.flatMap((param, index) => {
             const symbol = info.implicitParams?.[index];
             return symbol !== null &&
                 symbol !== undefined &&
@@ -957,7 +1369,7 @@ function implicitDeclaredReturn(lowerer, info) {
             // container instead of checking every element against that guess.
             if (!hasExplicitJsDocReturn(info.decl))
                 return null;
-            if (info.decl.parameters.some((param, index) => info.implicitParams?.[index] &&
+            if (info.decl.parameters.nodes.some((param, index) => info.implicitParams?.[index] &&
                 lowerer.mapTypeOf(lowerer.typeOf(param.name))?.kind === "array"))
                 return null;
             const elem = lowerer.checker.getTypeArguments(retTs)[0];
@@ -990,9 +1402,7 @@ function implicitDeclaredReturn(lowerer, info) {
                     return undefined;
                 const symbol = lowerer.resolveValueSymbol(node.expression);
                 if (symbol &&
-                    lowerer.checker
-                        .declarationsOf(symbol)
-                        .some((decl) => ts.isVariableDeclaration(decl) && jsBindingHasOpenWrites(lowerer, decl)))
+                    symbol.declarations.some((decl) => ts.isVariableDeclaration(decl) && jsBindingHasOpenWrites(lowerer, decl)))
                     openReturn = true;
                 return undefined;
             });
@@ -1020,6 +1430,14 @@ function implicitDeclaredReturn(lowerer, info) {
             return null;
         if (mapped !== null && promiseCarriesDyn(lowerer, mapped) && !hasExplicitJsDocReturn(info.decl))
             return null;
+        // A JavaScript body that can complete without returning yields
+        // undefined there, whatever its JSDoc claims (bcryptjs's `hash`
+        // returns a promise only when no callback is passed), exactly as
+        // declaredReturnType widens non-generic JavaScript functions.
+        if (mapped !== null &&
+            isJsSourceFile(ts.getSourceFileOfNode(info.decl)) &&
+            functionCanReturnUndefined(info.decl))
+            return lowerer.withUndefinedArmOf(mapped) ?? mapped;
         return mapped;
     }
     catch (e) {
@@ -1057,7 +1475,7 @@ function bindableImplicitIr(t) {
 function storedImplicitArgumentType(lowerer, arg) {
     while (ts.isParenthesizedExpression(arg))
         arg = arg.expression;
-    if (isJsSourceFile(arg.getSourceFile()) &&
+    if (isJsSourceFile(ts.getSourceFileOfNode(arg)) &&
         (ts.isArrowFunction(arg) || ts.isFunctionExpression(arg))) {
         const saved = lowerer.diagSink;
         const diagnostics = [];
@@ -1081,9 +1499,9 @@ function storedImplicitArgumentType(lowerer, arg) {
         return awaited?.kind === "promise" ? awaited.inner : awaited;
     }
     if (ts.isObjectLiteralExpression(arg) &&
-        isJsSourceFile(arg.getSourceFile()) &&
-        (arg.properties.length === 0 ||
-            arg.properties.some((property) => ts.isMethodDeclaration(property) ||
+        isJsSourceFile(ts.getSourceFileOfNode(arg)) &&
+        (arg.properties.nodes.length === 0 ||
+            arg.properties.nodes.some((property) => ts.isMethodDeclaration(property) ||
                 ts.isAccessor(property) ||
                 (!ts.isSpreadAssignment(property) &&
                     property.name !== undefined &&
@@ -1091,7 +1509,7 @@ function storedImplicitArgumentType(lowerer, arg) {
         return DYN;
     if (ts.isIdentifier(arg))
         return lowerer.peekLocal(arg)?.type ?? lowerer.globalOf(arg)?.type ?? null;
-    if (isJsSourceFile(arg.getSourceFile()) &&
+    if (isJsSourceFile(ts.getSourceFileOfNode(arg)) &&
         (ts.isPropertyAccessExpression(arg) || ts.isElementAccessExpression(arg))) {
         // Mutable JS members can retain an initializer-only checker type (for
         // example a linked-list slot initially null). Specialize to the value
@@ -1100,7 +1518,7 @@ function storedImplicitArgumentType(lowerer, arg) {
         if (represented)
             return represented.type;
     }
-    if (isJsSourceFile(arg.getSourceFile()) &&
+    if (isJsSourceFile(ts.getSourceFileOfNode(arg)) &&
         (ts.isCallExpression(arg) ||
             ts.isConditionalExpression(arg) ||
             (ts.isBinaryExpression(arg) &&
@@ -1133,7 +1551,27 @@ function storedImplicitArgumentType(lowerer, arg) {
 export function implicitCallInstance(lowerer, call, info) {
     const shapes = [];
     const argTypes = new Map();
-    info.decl.parameters.forEach((param, i) => {
+    const patterns = (info.implicitPatterns ??= implicitPatternsOf(lowerer, info.decl));
+    /** The destructured names' bound types, which the object's own
+     * representation does not always carry. */
+    const patternKey = [];
+    info.decl.parameters.nodes.forEach((param, i) => {
+        const pattern = patterns[i];
+        const patternArg = call.arguments.nodes[i];
+        if (pattern && patternArg && !ts.isSpreadElement(patternArg)) {
+            // The argument's object type binds each destructured name, so a
+            // class passed as `{ Base }` keeps its static class type.
+            const bound = implicitPatternBinding(lowerer, info.decl, pattern, patternArg);
+            if (bound) {
+                for (const [symbol, type] of bound.types) {
+                    argTypes.set(symbol, type);
+                    const mapped = lowerer.mapTypeOf(type);
+                    patternKey.push(mapped ? typeKey(mapped) : "?");
+                }
+                shapes.push({ type: bound.record, mode: "required" });
+                return;
+            }
+        }
         const sym = info.implicitParams[i];
         if (!sym) {
             shapes.push(lowerer.paramShape(param));
@@ -1143,7 +1581,7 @@ export function implicitCallInstance(lowerer, call, info) {
         const declared = lowerer.paramShape(param);
         if ((lowerer.typeOf(param.name).flags & ts.TypeFlags.Any) === 0)
             bound = declared.type;
-        const arg = call.arguments[i];
+        const arg = call.arguments.nodes[i];
         if (arg && !ts.isSpreadElement(arg)) {
             const stored = storedImplicitArgumentType(lowerer, arg);
             if (stored?.kind === "dyn") {
@@ -1152,6 +1590,17 @@ export function implicitCallInstance(lowerer, call, info) {
                 shapes.push({ type: bound, mode: "required" });
                 return;
             }
+            // `this` in a static method specialized for its receiver class is
+            // that class: bind it as a call naming the class would.
+            if (stored?.kind === "classval" && arg.kind === ts.SyntaxKind.ThisKeyword) {
+                const classDecl = lowerer.classes.get(stored.className)?.decl;
+                const classType = classDecl?.name ? lowerer.typeOf(classDecl.name) : null;
+                if (classType) {
+                    argTypes.set(sym, classType);
+                    shapes.push({ type: stored, mode: "required" });
+                    return;
+                }
+            }
             // A represented native array must keep its storage when a direct
             // inferred helper receives it. Re-boxing a checker-any array would
             // copy it, losing writes (and attempting to read unfilled slots).
@@ -1178,7 +1627,7 @@ export function implicitCallInstance(lowerer, call, info) {
             const t = lowerer.checker.getBaseTypeOfLiteralType(lowerer.typeOf(arg));
             const mapped = (neverTaintedJsType(lowerer, arg, t) ? null : lowerer.mapTypeOf(t)) ??
                 dynFallbackType(lowerer, arg, t);
-            if (isJsSourceFile(arg.getSourceFile()) &&
+            if (isJsSourceFile(ts.getSourceFileOfNode(arg)) &&
                 ts.isArrayLiteralExpression(arg) &&
                 mapped?.kind === "array" &&
                 (mapped.elem.kind === "classval" ||
@@ -1201,7 +1650,7 @@ export function implicitCallInstance(lowerer, call, info) {
             // That checker supertype is not an empty-record runtime layout:
             // preserve represented arms through the checked boundary instead
             // of specializing a call to a union that would discard them.
-            if (isJsSourceFile(arg.getSourceFile()) &&
+            if (isJsSourceFile(ts.getSourceFileOfNode(arg)) &&
                 mapped?.kind === "func" &&
                 !lowerer.dynConvertible(mapped)) {
                 argTypes.set(sym, lowerer.checker.getUnknownType());
@@ -1247,27 +1696,27 @@ export function implicitCallInstance(lowerer, call, info) {
         }
         shapes.push({ type: bound, mode: "required" });
     });
-    return internImplicitInstance(lowerer, call, info, shapes, argTypes);
+    return internImplicitInstance(lowerer, call, info, shapes, argTypes, patternKey.join(","));
 }
 /** The all-dyn DEFAULT instance — today's compiled body exactly: what a
  * VALUE reference of an implicit-any function names (indirect calls
  * carry no per-site types to bind). */
 export function implicitDefaultInstance(lowerer, blame, info) {
-    const shapes = info.decl.parameters.map((param, i) => info.implicitParams[i] ? { type: DYN, mode: "required" } : lowerer.paramShape(param));
+    const shapes = info.decl.parameters.nodes.map((param, i) => info.implicitParams[i] ? { type: DYN, mode: "required" } : lowerer.paramShape(param));
     const argTypes = new Map();
     // Newly bindable nominal class parameters must not retain their JSDoc
     // receiver type in the checked fallback. Keep existing broad JS inference.
-    for (let i = 0; i < info.decl.parameters.length; i++) {
+    for (let i = 0; i < info.decl.parameters.nodes.length; i++) {
         const symbol = info.implicitParams?.[i];
-        const kind = lowerer.mapTypeOf(lowerer.typeOf(info.decl.parameters[i].name))?.kind;
+        const kind = lowerer.mapTypeOf(lowerer.typeOf(info.decl.parameters.nodes[i].name))?.kind;
         if (symbol && (kind === "object" || kind === "array")) {
             argTypes.set(symbol, lowerer.checker.getUnknownType());
         }
     }
     return internImplicitInstance(lowerer, blame, info, shapes, argTypes);
 }
-function internImplicitInstance(lowerer, blame, info, shapes, argTypes) {
-    const key = shapes.map((s) => typeKey(s.type)).join(",");
+function internImplicitInstance(lowerer, blame, info, shapes, argTypes, patternKey = "") {
+    const key = shapes.map((s) => typeKey(s.type)).join(",") + (patternKey ? `|${patternKey}` : "");
     let inst = info.instances.get(key);
     if (inst?.implicitState === "failed")
         lowerer.unsupported("SC1090", blame, `the failed specialization of '${info.baseName}'`);
@@ -1284,7 +1733,7 @@ function internImplicitInstance(lowerer, blame, info, shapes, argTypes) {
             `${MAX_INSTANTIATION_RECURSION} recursive specializations on one demand path)`);
     }
     const rendered = shapes.map((s) => lowerer.fmt(s.type)).join(", ");
-    const dynamicBroadPromise = info.decl.parameters.some((param, index) => info.implicitParams?.[index] !== null &&
+    const dynamicBroadPromise = info.decl.parameters.nodes.some((param, index) => info.implicitParams?.[index] !== null &&
         info.implicitParams?.[index] !== undefined &&
         shapes[index]?.type.kind === "dyn" &&
         broadPromiseParam(lowerer, lowerer.typeOf(param.name)));
@@ -1322,7 +1771,7 @@ function internImplicitInstance(lowerer, blame, info, shapes, argTypes) {
         // this exact committed instance body here; repeated instantiations of
         // the same declaration find the facade memos warm.
         lowerer.checker.prefetchRoots([
-            ...info.decl.parameters.flatMap((param) => (param.initializer ? [param.initializer] : [])),
+            ...info.decl.parameters.nodes.flatMap((param) => param.initializer ? [param.initializer] : []),
             ...(info.decl.body ? [info.decl.body] : []),
         ]);
         const fn = lowerer.lowerGenericInstance(info, inst);
@@ -1369,7 +1818,7 @@ export function implicitLocalFnNodeOf(lowerer, decl) {
     if (cached !== undefined)
         return cached ? cached.decl : null;
     const probe = () => {
-        if (!implicitMonoFile(decl.getSourceFile()))
+        if (!implicitMonoFile(ts.getSourceFileOfNode(decl)))
             return null;
         if (!ts.isIdentifier(decl.name) || decl.initializer === undefined)
             return null;
@@ -1386,35 +1835,55 @@ export function implicitLocalFnNodeOf(lowerer, decl) {
         if (!sym)
             return null;
         const isConst = (ts.getCombinedNodeFlags(decl) & ts.NodeFlags.Const) !== 0;
-        const redeclared = lowerer.checker
-            .declarationsOf(sym)
-            .some((d) => d !== decl && ts.isVariableDeclaration(d) && d.initializer !== undefined);
+        const redeclared = sym.declarations.some((d) => d !== decl && ts.isVariableDeclaration(d) && d.initializer !== undefined);
         if (redeclared)
             return null;
         if (!isConst && !bindingNeverReassigned(lowerer, sym, decl))
             return null;
-        // The capture scan: instances are module functions with no frame.
-        let captures = false;
-        const scan = (n) => {
-            if (captures)
-                return;
-            if (n.kind === ts.SyntaxKind.ThisKeyword || n.kind === ts.SyntaxKind.SuperKeyword) {
-                // Arrow bodies see the ENCLOSING this; function expressions
-                // rebind their own — but a bare `this` there is untyped JS
-                // dynamism either way. Reject both, cheaply and soundly.
-                captures = true;
-                return;
+        // Instances are module functions with no frame.
+        return capturesEnclosingFrame(lowerer, init, decl, init.body) ? null : init;
+    };
+    const node = probe();
+    if (node === null) {
+        lowerer.implicitLocalFns.set(decl, null);
+        return null;
+    }
+    return node;
+}
+/** True when `fn`, bound by `decl`, uses its enclosing function's frame
+ * somewhere in `scope`: `this`, `super`, `arguments` or `new.target`, or
+ * a value or type declared in an enclosing function (a local, a parameter,
+ * an enclosing generic's type parameter). Module-scope declarations and
+ * the binding itself are reachable from the module functions the
+ * instances compile to. */
+function capturesEnclosingFrame(lowerer, fn, decl, scope) {
+    const file = ts.getSourceFileOfNode(decl);
+    const self = lowerer.checker.getSymbolAtLocation(decl.name);
+    let captures = false;
+    const scan = (n) => {
+        if (captures)
+            return;
+        if (n.kind === ts.SyntaxKind.ThisKeyword ||
+            n.kind === ts.SyntaxKind.SuperKeyword ||
+            ts.isMetaProperty(n)) {
+            // Arrow bodies see the ENCLOSING this; function expressions
+            // rebind their own — but a bare `this` there is untyped JS
+            // dynamism either way. Reject both, cheaply and soundly.
+            captures = true;
+            return;
+        }
+        if (ts.isIdentifier(n)) {
+            const s = lowerer.checker.getSymbolAtLocation(n);
+            if (s === undefined) {
+                if (n.text === "arguments")
+                    captures = true;
             }
-            if (ts.isIdentifier(n)) {
-                const s = lowerer.checker.getSymbolAtLocation(n);
-                const d = s ? lowerer.checker.valueDeclarationOf(s) : undefined;
-                if (d &&
-                    d.getSourceFile() === decl.getSourceFile() &&
-                    !(d.pos >= init.pos && d.end <= init.end)) {
-                    // Declared outside the initializer, in this file: a capture
-                    // exactly when some enclosing FUNCTION scope declares it —
-                    // module-scope declarations are reachable from any module
-                    // function.
+            else if (s !== self) {
+                for (const d of s.declarations) {
+                    if (ts.getSourceFileOfNode(d) !== file || (d.pos >= fn.pos && d.end <= fn.end))
+                        continue;
+                    // Declared outside the function, in this file: a capture
+                    // exactly when some enclosing FUNCTION scope declares it.
                     for (let p = d.parent; p !== undefined && !ts.isSourceFile(p); p = p.parent) {
                         if (ts.isFunctionLike(p)) {
                             captures = true;
@@ -1423,17 +1892,11 @@ export function implicitLocalFnNodeOf(lowerer, decl) {
                     }
                 }
             }
-            n.forEachChild(scan);
-        };
-        scan(init.body);
-        return captures ? null : init;
+        }
+        ts.forEachChild(n, scan);
     };
-    const node = probe();
-    if (node === null) {
-        lowerer.implicitLocalFns.set(decl, null);
-        return null;
-    }
-    return node;
+    scan(scope);
+    return captures;
 }
 /** Registers (or returns) the GenericFnInfo of a qualifying implicit-any
  * function-value binding — implicitLocalFnNodeOf's companion, the
@@ -1458,7 +1921,7 @@ export function implicitLocalFnInfoOf(lowerer, decl, fnNode) {
     const info = {
         decl: fnNode,
         baseName: name,
-        qualifiedName: lowerer.qualify(decl.getSourceFile(), nsPathPrefix(stmt ?? decl, decl) + `${name}%l${decl.getStart()}`),
+        qualifiedName: lowerer.qualify(ts.getSourceFileOfNode(decl), nsPathPrefix(stmt ?? decl, decl) + `${name}%l${ts.tokenStartOfNode(decl)}`),
         typeParams: [],
         instances: new Map(),
         implicitParams: implicit,
@@ -1477,7 +1940,7 @@ export function implicitLocalFnInfoOf(lowerer, decl, fnNode) {
  * arrow/function-expression property's initializer (`{ m: <T>(x: T) =>
  * ... }`). Null when the property's declaration isn't that shape. */
 export function objLitGenericFnNodeOf(lowerer, propSym) {
-    const decl = lowerer.checker.valueDeclarationOf(propSym);
+    const decl = propSym.valueDeclaration;
     if (!decl)
         return null;
     if (ts.isMethodDeclaration(decl) && ts.isObjectLiteralExpression(decl.parent)) {
@@ -1511,7 +1974,7 @@ export function objLitGenericFnInfoOf(lowerer, blame, name, found) {
         return existing;
     if (fnNode.asteriskToken)
         lowerer.unsupported("SC1071", blame);
-    if (fnNode.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword)) {
+    if (fnNode.modifiers?.nodes.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword)) {
         lowerer.unsupported("SC1090", blame, "async object-literal generic methods");
     }
     // `this` is the receiver object — records don't model it (the
@@ -1525,12 +1988,12 @@ export function objLitGenericFnInfoOf(lowerer, blame, name, found) {
             lowerer.unsupported("SC1090", blame, `object-literal generic methods declared inside functions (the compiled instantiations of '${name}' are module functions and cannot capture the enclosing frame — declare the object at module scope)`);
         }
     }
-    const typeParams = declaredTypeParameterSymbols(lowerer, fnNode.typeParameters, blame, "this method form");
-    checkGenericParameterNames(lowerer, fnNode.parameters, false);
+    const typeParams = declaredTypeParameterSymbols(lowerer, fnNode.typeParameters.nodes, blame, "this method form");
+    checkGenericParameterNames(lowerer, fnNode.parameters.nodes, false);
     const info = {
         decl: fnNode,
         baseName: name,
-        qualifiedName: lowerer.qualify(fnNode.getSourceFile(), `%ol${fnNode.getStart()}.${name}`),
+        qualifiedName: lowerer.qualify(ts.getSourceFileOfNode(fnNode), `%ol${ts.tokenStartOfNode(fnNode)}.${name}`),
         typeParams,
         instances: new Map(),
         objectLiteral: true,
@@ -1607,9 +2070,16 @@ export function bindingGenericFnInfoOf(lowerer, decl, fnNode) {
     const name = decl.name.text;
     if (fnNode.asteriskToken)
         lowerer.unsupported("SC1071", fnNode);
+    // Inside a function, the compiled instances are module functions, so
+    // the initializer may not use the enclosing frame.
+    let functionScoped = false;
     for (let n = decl.parent; n !== undefined && !ts.isSourceFile(n); n = n.parent) {
         if (ts.isFunctionLike(n)) {
-            lowerer.unsupported("SC1090", fnNode, `generic arrow/function-expression bindings declared inside functions (the compiled instantiations of '${name}' are module functions and cannot capture the enclosing frame — declare the binding at module scope)`);
+            if (capturesEnclosingFrame(lowerer, fnNode, decl, fnNode)) {
+                lowerer.unsupported("SC1090", fnNode, `generic arrow/function-expression bindings that use the frames of their enclosing functions (the compiled instantiations of '${name}' are module functions and cannot capture its locals, parameters, type parameters or 'this' — pass them as arguments, or declare the binding at module scope)`);
+            }
+            functionScoped = true;
+            break;
         }
     }
     const sym = lowerer.checker.getSymbolAtLocation(decl.name);
@@ -1618,7 +2088,7 @@ export function bindingGenericFnInfoOf(lowerer, decl, fnNode) {
     requireStableGenericBinding(lowerer, decl, sym, name);
     const typeParams = [];
     if (fnNode.typeParameters !== undefined) {
-        typeParams.push(...declaredTypeParameterSymbols(lowerer, fnNode.typeParameters, fnNode, "this function form"));
+        typeParams.push(...declaredTypeParameterSymbols(lowerer, fnNode.typeParameters.nodes, fnNode, "this function form"));
     }
     else {
         // The CONTEXTUAL shape (bindingContextualGenericFnNodeOf): the type
@@ -1636,14 +2106,19 @@ export function bindingGenericFnInfoOf(lowerer, decl, fnNode) {
             typeParams.push(tpSym);
         }
     }
-    checkGenericParameterNames(lowerer, fnNode.parameters, true);
+    checkGenericParameterNames(lowerer, fnNode.parameters.nodes, true);
     const stmt = decl.parent?.parent; // declarator → list → statement (nsPathPrefix wants the statement)
+    // A binding in a function or block can share its name with another; its
+    // instances take the declaration's position.
+    const topLevel = stmt?.parent !== undefined && (ts.isSourceFile(stmt.parent) || ts.isModuleBlock(stmt.parent));
     const info = {
         decl: fnNode,
         baseName: name,
-        qualifiedName: lowerer.qualify(decl.getSourceFile(), nsPathPrefix(stmt ?? decl, decl) + name),
+        qualifiedName: lowerer.qualify(ts.getSourceFileOfNode(decl), nsPathPrefix(stmt ?? decl, decl) +
+            (topLevel ? name : `${name}%l${ts.tokenStartOfNode(decl)}`)),
         typeParams,
         instances: new Map(),
+        ...(functionScoped ? { functionScoped: true } : {}),
     };
     lowerer.bindingGenericFns.set(fnNode, info);
     lowerer.genericFnsBySymbol.set(sym, info);
@@ -1709,7 +2184,7 @@ export function requireObjLitGenericReceiver(lowerer, blame, recvExpr, literal,
     if (!ts.isIdentifier(recv))
         fenceReceiver();
     const recvSym = lowerer.resolveValueSymbol(recv);
-    const recvDecl = recvSym ? lowerer.checker.valueDeclarationOf(recvSym) : undefined;
+    const recvDecl = recvSym ? recvSym.valueDeclaration : undefined;
     if (!recvDecl ||
         !ts.isVariableDeclaration(recvDecl) ||
         !ts.isVariableDeclarationList(recvDecl.parent) ||