@scriptc/compiler 0.3.6 → 0.4.0

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,43 @@ 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;
+        const rdecl = rsig ? rsig.declaration : undefined;
         if (rdecl &&
             (ts.isFunctionDeclaration(rdecl) || ts.isMethodDeclaration(rdecl)) &&
             !rdecl.body) {
             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);
     }
+    // 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.
+    const returnType = lowerer.runtimeOptionalGenericReturns.has(info.decl)
+        ? mappedReturn.kind === "promise"
+            ? { kind: "promise", inner: lowerer.runtimeOptionalType(mappedReturn.inner) }
+            : lowerer.runtimeOptionalType(mappedReturn)
+        : 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,6 +145,7 @@ 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 named = staticNameBindings(lowerer, expr, info);
     const keyofTps = keyofConstrainedTypeParams(info);
     if (keyofTps.size > 0) {
         const tsBindings = new Map();
@@ -145,11 +162,146 @@ export function genericCallInstance(lowerer, expr, info) {
         })
             .join(",");
         return internGenericInstance(lowerer, expr, info, params, returnType, () => bindings, {
-            extraKey: `@${litKey}`,
+            extraKey: `@${litKey}${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 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 +332,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 +346,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 +362,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;
@@ -231,7 +384,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 +396,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 +451,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.
@@ -400,7 +557,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 +588,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 +619,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 +637,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 +652,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 +677,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 +750,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
@@ -654,7 +820,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 +839,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 +848,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 +859,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 +884,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 +893,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 +977,7 @@ function paramWrittenInBody(lowerer, body, sym, name) {
                     hit = true;
                     return;
                 }
-                m.forEachChild(scan);
+                ts.forEachChild(m, scan);
             };
             scan(n);
             return hit;
@@ -829,7 +1009,7 @@ function paramWrittenInBody(lowerer, body, sym, name) {
             written = true;
             return;
         }
-        n.forEachChild(walk);
+        ts.forEachChild(n, walk);
     };
     walk(body);
     return written;
@@ -845,6 +1025,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 +1136,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 +1173,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 +1190,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 +1240,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 +1273,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 +1301,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 +1346,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 +1370,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 +1380,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 +1389,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 +1422,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 +1452,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 +1461,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 +1498,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 +1521,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 +1567,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 +1604,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 +1642,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 +1689,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,9 +1706,7 @@ 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))
@@ -1407,9 +1725,9 @@ export function implicitLocalFnNodeOf(lowerer, decl) {
             }
             if (ts.isIdentifier(n)) {
                 const s = lowerer.checker.getSymbolAtLocation(n);
-                const d = s ? lowerer.checker.valueDeclarationOf(s) : undefined;
+                const d = s ? s.valueDeclaration : undefined;
                 if (d &&
-                    d.getSourceFile() === decl.getSourceFile() &&
+                    ts.getSourceFileOfNode(d) === ts.getSourceFileOfNode(decl) &&
                     !(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 —
@@ -1423,7 +1741,7 @@ export function implicitLocalFnNodeOf(lowerer, decl) {
                     }
                 }
             }
-            n.forEachChild(scan);
+            ts.forEachChild(n, scan);
         };
         scan(init.body);
         return captures ? null : init;
@@ -1458,7 +1776,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 +1795,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 +1829,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 +1843,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,
@@ -1618,7 +1936,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,12 +1954,12 @@ 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)
     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) + name),
         typeParams,
         instances: new Map(),
     };
@@ -1709,7 +2027,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) ||