@scriptc/compiler 0.3.6 → 0.4.1

package/dist/frontend/lowering/call-signatures.js

@@ -1,9 +1,10 @@
+import { typedArgumentsCandidate, typedArgumentsShapes, typedArgumentsTarget, } from "./typed-arguments.js";
 import { InternalCompilerError } from "../../errors.js";
 import * as ts from "../ts7/adapter.js";
-import { bodyReadsArguments } from "../arguments-usage.js";
-import { DYN, UNDEFINED_T, VOID, isUnitType, typeEquals, } from "../../ir/ir.js";
+import { argumentsAliasingUnobservable, bodyReadsArguments } from "../arguments-usage.js";
+import { canBoxFuncIntoDyn, DYN, UNDEFINED_T, VOID, isUnitType, typeEquals, } from "../../ir/ir.js";
 import { isJsSourceFile, isNodeEsmFile } from "../program.js";
-import { genResultRecord, jsOpenObjectType } from "../type-mapper.js";
+import { genResultRecord, restTupleParamTypes, isAnyArrayType, isUnitOnlyTsType, jsOpenObjectType, unitOnlyUnion, } from "../type-mapper.js";
 import { dynFallbackType } from "./lowerer.js";
 import { builtinModuleFnOf } from "./surfaces.js";
 import { mixinFnShapeOf } from "./lower-mixins.js";
@@ -11,6 +12,7 @@ import { isStreamUndefCallExpr } from "./lower-server.js";
 import { nsPathPrefix } from "./lower-namespaces.js";
 import { declSymbolOf } from "./lower-modules.js";
 import { npmStaticPackageOfPath } from "../npm-static.js";
+import { restPackingAdapterFits } from "./coercions/function-adapters.js";
 import { implicitMonoFile, implicitAnyParamSymbolsOf } from "./generic-functions.js";
 export function funcTypeFromParamShapes(shapes, ret) {
     const typedRest = shapes.some((shape) => shape.mode === "rest");
@@ -65,6 +67,36 @@ export function generatorMeta(lowerer, type) {
     }
     return { yieldT: type.yieldT, nextT: type.nextT, resultType };
 }
+/** A function expression stored as a prototype method: `C.prototype.name =
+ * function (...) {}` or `C.prototype[key] = function (...) {}`
+ * (parentheses allowed around the function). */
+export function prototypeAssignedFunction(fn) {
+    if (fn === undefined || !ts.isFunctionExpression(fn))
+        return false;
+    let node = fn;
+    while (node.parent !== undefined && ts.isParenthesizedExpression(node.parent))
+        node = node.parent;
+    const parent = node.parent;
+    if (parent === undefined ||
+        !ts.isBinaryExpression(parent) ||
+        parent.right !== node ||
+        parent.operatorToken.kind !== ts.SyntaxKind.EqualsToken ||
+        !(ts.isPropertyAccessExpression(parent.left) || ts.isElementAccessExpression(parent.left)))
+        return false;
+    const owner = parent.left.expression;
+    return ts.isPropertyAccessExpression(owner) && owner.name.text === "prototype";
+}
+/** A parameter with a type annotation or a JSDoc `@param`/`@type` tag. */
+export function documentedParameter(param) {
+    return (param.type !== undefined ||
+        /@(?:param|type)\b/.test(ts
+            .getSourceFileOfNode(param)
+            .text.slice(param.parent?.pos ?? param.pos, ts.tokenStartOfNode(param))));
+}
+/** A documented parameter in a JavaScript file TypeScript checks. */
+export function checkedJsDocumentedParameter(lowerer, param) {
+    return lowerer.checkedJsFile(ts.getSourceFileOfNode(param)) && documentedParameter(param);
+}
 /** One parameter's ParamShape — the shared signature-shaped collection
  * point for function declarations, methods, constructors, and lambdas
  * (generic declarations defer to their call sites, where the resolved
@@ -85,14 +117,29 @@ export function paramShape(lowerer, param) {
     const stage = lowerer.stageSourceType(param.name);
     if (stage)
         return { type: stage, mode: "required" };
-    if (isJsSourceFile(param.getSourceFile()) && ts.isSetAccessorDeclaration(param.parent))
+    if (isJsSourceFile(ts.getSourceFileOfNode(param)) && ts.isSetAccessorDeclaration(param.parent))
         return { type: DYN, mode: "required" };
-    if (isJsSourceFile(param.getSourceFile()) &&
+    if (isJsSourceFile(ts.getSourceFileOfNode(param)) &&
         ts.isConstructorDeclaration(param.parent) &&
-        !param.dotDotDotToken) {
+        !param.dotDotDotToken &&
+        !checkedJsDocumentedParameter(lowerer, param)) {
         // Reflective JavaScript construction can supply values outside the
         // constructor's documented usual types. Retain the actual arguments
         // and apply checked conversions only at operations that need them.
+        // In a file TypeScript checks, documented types are enforced like
+        // TypeScript annotations.
+        return param.initializer
+            ? { type: DYN, mode: "omittable", bodyType: DYN }
+            : { type: DYN, mode: param.questionToken ? "omittable" : "required" };
+    }
+    if (isJsSourceFile(ts.getSourceFileOfNode(param)) &&
+        !param.dotDotDotToken &&
+        prototypeAssignedFunction(param.parent) &&
+        !checkedJsDocumentedParameter(lowerer, param)) {
+        // A prototype method (`C.prototype.m = function (a) {}`) is called
+        // through dynamic dispatch, where callers pass whatever they hold. As
+        // for constructors, JSDoc in a file TypeScript does not check
+        // documents the usual types without constraining callers.
         return param.initializer
             ? { type: DYN, mode: "omittable", bodyType: DYN }
             : { type: DYN, mode: param.questionToken ? "omittable" : "required" };
@@ -102,30 +149,36 @@ export function paramShape(lowerer, param) {
     const nativeExecutor = executor &&
         (ts.isArrowFunction(executor) || ts.isFunctionExpression(executor)) &&
         ts.isNewExpression(construction) &&
-        construction.arguments?.[0] === executor &&
+        construction.arguments?.nodes[0] === executor &&
         lowerer.isStdlibGlobal(construction.expression, "Promise");
     if (!nativeExecutor &&
-        isJsSourceFile(param.getSourceFile()) &&
+        isJsSourceFile(ts.getSourceFileOfNode(param)) &&
         !param.type &&
         !param.dotDotDotToken &&
         !ts.isSetAccessorDeclaration(param.parent) &&
-        !/@(?:param|type)\b/.test(param.getSourceFile().text.slice(param.parent?.pos ?? param.pos, param.getStart()))) {
+        !/@(?:param|type)\b/.test(ts
+            .getSourceFileOfNode(param)
+            .text.slice(param.parent?.pos ?? param.pos, ts.tokenStartOfNode(param)))) {
         return param.initializer
             ? { type: DYN, mode: "omittable", bodyType: DYN }
             : { type: DYN, mode: "required" };
     }
     if (param.initializer &&
-        isJsSourceFile(param.getSourceFile()) &&
+        isJsSourceFile(ts.getSourceFileOfNode(param)) &&
         !param.type &&
-        !/@(?:param|type)\b/.test(param.getSourceFile().text.slice(param.parent?.pos ?? param.pos, param.getStart()))) {
+        !/@(?:param|type)\b/.test(ts
+            .getSourceFileOfNode(param)
+            .text.slice(param.parent?.pos ?? param.pos, ts.tokenStartOfNode(param)))) {
         return { type: DYN, mode: "omittable", bodyType: DYN };
     }
     // Inferred JS array patterns describe the bindings, not an exact tuple
     // contract. Consume the actual iterable, including surplus elements.
     if (ts.isArrayBindingPattern(param.name) &&
-        isJsSourceFile(param.getSourceFile()) &&
+        isJsSourceFile(ts.getSourceFileOfNode(param)) &&
         !param.type &&
-        !/@(?:param|type)\b/.test(param.getSourceFile().text.slice(param.parent?.pos ?? param.pos, param.getStart()))) {
+        !/@(?:param|type)\b/.test(ts
+            .getSourceFileOfNode(param)
+            .text.slice(param.parent?.pos ?? param.pos, ts.tokenStartOfNode(param)))) {
         if (param.dotDotDotToken)
             return { type: DYN, mode: "dynRest" };
         return param.initializer
@@ -187,18 +240,27 @@ export function paramShape(lowerer, param) {
         // ARRAY param the dyn call thunk fills with the call's surplus
         // arguments; the binding is that array (dynRest — funcType marks
         // `rest`, and the value only ever calls through the boxed thunk).
-        if (isJsSourceFile(param.getSourceFile())) {
+        if (isJsSourceFile(ts.getSourceFileOfNode(param))) {
             const restMapped = lowerer.mapTypeOf(lowerer.typeOf(param.name));
             // Unmapped JS rest parameters use the native variadic checked-value ABI.
             if (restMapped?.kind !== "array") {
                 return { type: DYN, mode: "dynRest" };
             }
         }
+        // `...args: unknown[]` / `...args: any[]` in TypeScript: the binding is
+        // the checked-dynamic array (how `unknown[]` maps everywhere), so the
+        // ABI is the JS variadic dyn form above — the function type marks it
+        // with `rest` and no typed slot (the type mapper agrees).
+        const restTs = lowerer.typeOf(param.name);
+        if (isAnyArrayType(restTs, lowerer.checker))
+            return { type: DYN, mode: "dynRest" };
         const type = lowerer.runtimeOptionalBindingType(param.name, lowerer.irTypeOf(param.name));
+        if (type.kind === "dyn")
+            return { type: DYN, mode: "dynRest" };
         // Tuple-typed rest params don't map to an array; generic rest is the
         // generic path's business. Anything non-array here is unmappable.
         if (type.kind !== "array")
-            lowerer.badType(param.name, lowerer.typeOf(param.name));
+            lowerer.badType(param.name, restTs);
         return { type, mode: "rest" };
     }
     if (param.initializer) {
@@ -206,7 +268,7 @@ export function paramShape(lowerer, param) {
         // An optional JS array parameter is a live caller-owned buffer,
         // including typed arrays passed through checked callbacks. Extracting
         // a native array here would copy it and discard element writes.
-        if (isJsSourceFile(param.getSourceFile()) &&
+        if (isJsSourceFile(ts.getSourceFileOfNode(param)) &&
             !param.type &&
             (raw.kind === "array" ||
                 (raw.kind === "union" &&
@@ -217,7 +279,7 @@ export function paramShape(lowerer, param) {
     }
     let type = lowerer.runtimeOptionalBindingType(param.name, lowerer.irTypeOf(param.name));
     const body = param.parent?.body;
-    if (isJsSourceFile(param.getSourceFile()) && body && type.kind !== "dyn") {
+    if (isJsSourceFile(ts.getSourceFileOfNode(param)) && body && type.kind !== "dyn") {
         const symbol = lowerer.checker.getSymbolAtLocation(param.name);
         let acceptsUndefined = false;
         ts.walkPreorder(body, (node) => {
@@ -260,12 +322,38 @@ export function paramShape(lowerer, param) {
 export function isThisParameter(param) {
     return ts.isIdentifier(param.name) && param.name.text === "this";
 }
+/** A TypeScript rest parameter bound to a name whose type is a fixed tuple
+ * (`...args: [A, B]`, `...args: A` with A bound to a tuple, `...args:
+ * Parameters<F>` with F bound): one required shape per position. Call
+ * sites and function values see the equivalent fixed signature; the body
+ * rebuilds the tuple (declareParams) unless it only forwards it. Null for
+ * every other parameter. */
+export function restTupleShapes(lowerer, param, tsType) {
+    if (param.dotDotDotToken === undefined ||
+        !ts.isIdentifier(param.name) ||
+        isJsSourceFile(ts.getSourceFileOfNode(param))) {
+        return null;
+    }
+    const elems = restTupleParamTypes(tsType ?? lowerer.typeOf(param.name), lowerer.typeCtx);
+    return elems ? elems.map((type) => ({ type, mode: "required", restTuple: true })) : null;
+}
 /** ParamShapes for a whole parameter list. */
 export function paramShapes(lowerer, params, signature, blameOf) {
-    if (!signature)
-        return params.filter((p) => !isThisParameter(p)).map((param) => lowerer.paramShape(param));
+    const out = [];
+    if (!signature) {
+        for (const param of params) {
+            if (isThisParameter(param))
+                continue;
+            const flattened = restTupleShapes(lowerer, param);
+            if (flattened)
+                out.push(...flattened);
+            else
+                out.push(lowerer.paramShape(param));
+        }
+        return out;
+    }
     const symbols = signature.getParameters();
-    return params.map((declParam, i) => {
+    const shapeAt = (declParam, i) => {
         const stage = lowerer.stageSourceType(declParam.name);
         if (stage)
             return { type: stage, mode: "required" };
@@ -273,7 +361,30 @@ export function paramShapes(lowerer, params, signature, blameOf) {
         const tsType = symbol
             ? lowerer.checker.getTypeOfSymbol(symbol)
             : lowerer.typeOf(declParam.name);
-        const mapped = jsOpenObjectType(declParam, lowerer.runtimeOptionalBindingType(declParam.name, lowerer.mapTypeOf(tsType) ?? lowerer.irTypeOf(declParam.name)), lowerer.shapes, lowerer.unions);
+        // A call-site instantiation whose concrete argument type does not map
+        // is that argument's blocker: name it there, with its concrete type,
+        // rather than as the declaration's unbound type parameter.
+        if (blameOf !== undefined &&
+            !isJsSourceFile(ts.getSourceFileOfNode(declParam)) &&
+            (tsType.flags & ts.TypeFlags.Any) === 0 &&
+            declParam.type !== undefined &&
+            mentionsTypeParameter(lowerer, lowerer.checker.getTypeFromTypeNode(declParam.type)) &&
+            lowerer.mapTypeOf(tsType) === null) {
+            lowerer.badType(blameOf(declParam, i), tsType);
+        }
+        let mapped = jsOpenObjectType(declParam, lowerer.runtimeOptionalBindingType(declParam.name, lowerer.mapTypeOf(tsType) ??
+            // A TypeScript instantiation at `any` (a type argument inferred
+            // from an untyped value) takes the checked-dynamic slot.
+            ((tsType.flags & ts.TypeFlags.Any) !== 0 &&
+                !isJsSourceFile(ts.getSourceFileOfNode(declParam))
+                ? DYN
+                : lowerer.irTypeOf(declParam.name))), lowerer.shapes, lowerer.unions);
+        // An instantiation with a literal `undefined` argument (`id(undefined)`
+        // binds T = undefined): standalone undefined maps to VOID (the return
+        // convention), and a parameter is a value position, so it takes the
+        // unit-only slot like a declared `v: undefined` parameter.
+        if (mapped?.kind === "void" && isUnitOnlyTsType(tsType))
+            mapped = unitOnlyUnion(lowerer.unions);
         if (!mapped || mapped.kind === "void")
             lowerer.badType(blameOf?.(declParam, i) ?? declParam.name, tsType);
         if (declParam.dotDotDotToken) {
@@ -283,11 +394,40 @@ export function paramShapes(lowerer, params, signature, blameOf) {
         }
         if (declParam.initializer)
             return defaultParameterShape(lowerer, declParam, mapped);
-        if (declParam.questionToken && !lowerer.bareUndefinedArmedUnion(mapped)) {
+        // A checked-value slot holds undefined directly, so an omitted
+        // argument needs no union arm (paramShape's declared-signature rule;
+        // an erased type parameter and a class-implemented interface view
+        // both map here).
+        if (declParam.questionToken &&
+            !lowerer.bareUndefinedArmedUnion(mapped) &&
+            mapped.kind !== "dyn") {
             lowerer.unsupported("SC1090", declParam, `optional parameters of type '${lowerer.fmt(mapped)}'`);
         }
         return { type: mapped, mode: declParam.questionToken ? "omittable" : "required" };
+    };
+    params.forEach((declParam, i) => {
+        const symbol = symbols[i];
+        const flattened = restTupleShapes(lowerer, declParam, symbol ? lowerer.checker.getTypeOfSymbol(symbol) : undefined);
+        if (flattened)
+            out.push(...flattened);
+        else
+            out.push(shapeAt(declParam, i));
     });
+    return out;
+}
+/** A declared type that is (or is a union over) a bare type parameter
+ * or an instantiation of a generic alias/interface over type arguments. */
+function mentionsTypeParameter(lowerer, t) {
+    if (t.flags & ts.TypeFlags.TypeParameter)
+        return true;
+    const mentions = (part) => mentionsTypeParameter(lowerer, part);
+    if (t.isUnionType())
+        return ts.constituentTypes(t).some(mentions);
+    if (t.getAliasTypeArguments().some(mentions))
+        return true;
+    return ((t.flags & ts.TypeFlags.Object) !== 0 &&
+        (t.objectFlags & ts.ObjectFlags.Reference) !== 0 &&
+        lowerer.checker.getTypeArguments(t).some(mentions));
 }
 /** A default expression may itself yield undefined. Keep that arm in the
  * body and parameter-property storage, including for literal `undefined`
@@ -356,6 +496,20 @@ export function requireExactArityValue(lowerer, blame, contextual, shapes, funcT
     // optional/defaulted params spell their `T | undefined` slots (mapType's
     // completed-signature contract), so omitted trailing args complete with
     // the undefined arm like any direct call.
+    // A nested function declaration whose only non-required parameter is a
+    // typed rest: its value carries the typed-rest ABI its own type spells,
+    // and every use converts it at its slot (same signature, or the rest
+    // packing adapter for fixed parameters).
+    if (contextual === null &&
+        ts.isFunctionDeclaration(blame) &&
+        blame.name !== undefined &&
+        funcType.kind === "func" &&
+        funcType.restAbi === "typed" &&
+        shapes.every((s) => s.mode === "required" || s.mode === "rest")) {
+        const own = lowerer.mapTypeOf(lowerer.typeOf(blame.name));
+        if (own && typeEquals(own, funcType))
+            return;
+    }
     const target = contextual ? lowerer.checker.getContextualType(contextual) : undefined;
     const mapped = target
         ? lowerer.mapTypeOf(target)
@@ -364,6 +518,32 @@ export function requireExactArityValue(lowerer, blame, contextual, shapes, funcT
             : null;
     if (mapped && typeEquals(mapped, funcType))
         return;
+    // An 'any' slot (`C.prototype.m = function (a, b) {…}` through an
+    // untyped receiver) boxes the value into a checked-dynamic function:
+    // the box completes omitted arguments with undefined and checks every
+    // argument into the completed ABI, so any boxable signature passes.
+    if (target !== undefined &&
+        (target.flags & ts.TypeFlags.Any) !== 0 &&
+        canBoxFuncIntoDyn(funcType, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id))) {
+        return;
+    }
+    // An object-literal METHOD has no contextual type of its own: the
+    // literal's contextual type names the member slot it fills. An
+    // overloaded member's slot holds its erased function, which spells the
+    // completed parameters of an implementation like `m(a?: string)`.
+    if (contextual === null &&
+        ts.isMethodDeclaration(blame) &&
+        blame.parent !== undefined &&
+        ts.isObjectLiteralExpression(blame.parent) &&
+        (ts.isIdentifier(blame.name) || ts.isStringLiteral(blame.name))) {
+        const literalType = lowerer.checker.getContextualType(blame.parent);
+        const member = literalType
+            ? lowerer.checker.getPropertyOfType(literalType, blame.name.text)
+            : undefined;
+        const slot = member ? lowerer.memberSlotTypeOf(lowerer.checker.getTypeOfSymbol(member)) : null;
+        if (slot && typeEquals(slot, funcType))
+            return;
+    }
     // A union-typed slot (`runner || defaultRunner` under a
     // `CommandRunner | undefined` context): the value can only inhabit
     // the union's one func arm — judge by it.
@@ -381,7 +561,7 @@ export function requireExactArityValue(lowerer, blame, contextual, shapes, funcT
         const ownType = lowerer.typeOf(contextual);
         mappedFn =
             lowerer.mapTypeOf(ownType) ??
-                (isJsSourceFile(contextual.getSourceFile())
+                (isJsSourceFile(ts.getSourceFileOfNode(contextual))
                     ? dynFallbackType(lowerer, contextual, ownType)
                     : null);
     }
@@ -396,6 +576,14 @@ export function requireExactArityValue(lowerer, blame, contextual, shapes, funcT
         lowerer.spawnResFnAdapterPlan(funcType, mappedFn) !== null) {
         return;
     }
+    // A typed-rest function in a slot with fixed parameters (`log(...m:
+    // string[])` into `(m: string) => void`): the slot coercion's packing
+    // adapter collects the slot's arguments into the rest array.
+    if (mappedFn?.kind === "func" &&
+        funcType.kind === "func" &&
+        restPackingAdapterFits(lowerer, funcType, mappedFn)) {
+        return;
+    }
     // An uncontextualized npm-static implementation function can still
     // have a declaration-backed completed ABI: the package's .d.ts
     // projection supplies the body-facing parameter/return types while
@@ -407,7 +595,7 @@ export function requireExactArityValue(lowerer, blame, contextual, shapes, funcT
     if (target === undefined &&
         contextual !== null &&
         (ts.isArrowFunction(contextual) || ts.isFunctionExpression(contextual)) &&
-        npmStaticPackageOfPath(contextual.getSourceFile().fileName) !== null) {
+        npmStaticPackageOfPath(ts.getSourceFileOfNode(contextual).fileName) !== null) {
         return;
     }
     lowerer.unsupported("SC1090", blame, "functions with optional or defaulted parameters as values, except where the " +
@@ -445,11 +633,11 @@ export function collectSignatureInner(lowerer, decl) {
     // body (run()/discover() skip by the same test). Generic mixins still
     // register their generic signature below: non-mixin-shaped calls
     // degrade to the generic machinery's own per-site fences.
-    if (!decl.typeParameters && mixinFnShapeOf(lowerer, decl))
+    if (!decl.typeParameters?.nodes && mixinFnShapeOf(lowerer, decl))
         return;
-    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 isGenerator = decl.asteriskToken !== undefined;
-    if (decl.typeParameters) {
+    if (decl.typeParameters?.nodes) {
         // Generic async composes: each monomorphized instance is an async
         // IrFunction like any other — its own spawn wrapper, its body
         // returning the resolved promise's inner (lowerGenericInstance).
@@ -463,7 +651,7 @@ export function collectSignatureInner(lowerer, decl) {
     // routes generic declarations (direct calls, namespace/CJS member
     // calls, value references) resolves it through genericFnsBySymbol
     // unchanged.
-    if (implicitMonoFile(decl.getSourceFile()) && !isAsync && !isGenerator) {
+    if (implicitMonoFile(ts.getSourceFileOfNode(decl)) && !isAsync && !isGenerator) {
         const implicit = implicitAnyParamSymbolsOf(lowerer, decl);
         if (implicit) {
             const nameText = decl.name?.text ?? "%default";
@@ -473,7 +661,7 @@ export function collectSignatureInner(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(),
                 implicitParams: implicit,
@@ -481,12 +669,24 @@ export function collectSignatureInner(lowerer, decl) {
             return;
         }
     }
-    const params = lowerer.paramShapes(decl.parameters);
+    const params = lowerer.paramShapes(decl.parameters.nodes);
     // The zero-parameter declaration retains its dynRest ABI; value
     // functions use the full arguments slot even with no named parameters.
-    appendArgumentsParameter(lowerer, decl, params, decl.parameters.length > 0 ? "arguments" : "dynRest");
+    appendArgumentsParameter(lowerer, decl, params, decl.parameters.nodes.length > 0 ? "arguments" : "dynRest");
     const nameBlame = decl.name ?? decl;
-    const returnType = lowerer.declaredReturnType(decl, nameBlame);
+    let returnType = lowerer.declaredReturnType(decl, nameBlame);
+    // A JavaScript generator whose inferred return the checker leaves `any`
+    // (it delegates to itself: `yield* walkTree(sub)`) is still a generator:
+    // its channels are checked-dynamic values.
+    if (isGenerator && returnType.kind === "dyn" && isJsSourceFile(ts.getSourceFileOfNode(decl))) {
+        returnType = {
+            kind: "generator",
+            ...(isAsync ? { async: true } : {}),
+            yieldT: DYN,
+            retT: DYN,
+            nextT: DYN,
+        };
+    }
     if (isAsync && !isGenerator && returnType.kind !== "promise") {
         lowerer.badType(nameBlame, lowerer.typeOf(nameBlame));
     }
@@ -501,7 +701,7 @@ export function collectSignatureInner(lowerer, decl) {
         // so `namespace A { export function f }` and a top-level `f` never
         // collide. The anonymous default export takes the synthetic
         // "%default" spelling ('%' cannot appear in a user identifier).
-        name: lowerer.qualify(decl.getSourceFile(), nsPathPrefix(decl) + (decl.name?.text ?? "%default")),
+        name: lowerer.qualify(ts.getSourceFileOfNode(decl), nsPathPrefix(decl) + (decl.name?.text ?? "%default")),
         params,
         returnType,
         isAsync,
@@ -513,24 +713,54 @@ export function collectSignatureInner(lowerer, decl) {
 /** Arrows inherit arguments. Ordinary JS functions receive a hidden
  * array unless a declared rest parameter already owns that contract.
  * Class methods are strict; other parameterized forms require ES modules
- * because sloppy-mode arguments alias named parameters. */
+ * because sloppy-mode arguments alias named parameters, unless the body
+ * cannot observe that aliasing (argumentsAliasingUnobservable). */
 function appendArgumentsParameter(lowerer, node, shapes, mode) {
     if (shapes.some((s) => s.mode === "rest" || s.mode === "dynRest") ||
         !(ts.isFunctionExpression(node) ||
             ts.isFunctionDeclaration(node) ||
             ts.isMethodDeclaration(node)) ||
-        !isJsSourceFile(node.getSourceFile()) ||
+        !isJsSourceFile(ts.getSourceFileOfNode(node)) ||
         !bodyReadsArguments(node))
         return;
-    if (node.parameters.length > 0 || ts.isMethodDeclaration(node)) {
+    if (node.parameters.nodes.length > 0 || ts.isMethodDeclaration(node)) {
         const classMethod = ts.isMethodDeclaration(node) &&
             (ts.isClassDeclaration(node.parent) || ts.isClassExpression(node.parent));
-        if (!classMethod && !isNodeEsmFile(node.getSourceFile(), lowerer.program)) {
+        if (!classMethod &&
+            !isNodeEsmFile(ts.getSourceFileOfNode(node), lowerer.program) &&
+            !unmappedArguments(node) &&
+            !argumentsAliasingUnobservable(node)) {
             lowerer.unsupported("SC1090", node, "parameterized 'arguments' outside an ES module (sloppy-mode parameter aliases)");
         }
     }
     shapes.push({ type: DYN, mode });
 }
+/** Whether `arguments` inside `node` is Node's unmapped object: strict code
+ * (a 'use strict' prologue on the file or an enclosing function, or a class
+ * body) or a non-simple parameter list (defaults, rest, destructuring). Its
+ * elements then never alias the parameters, which is the ES module case. */
+function unmappedArguments(node) {
+    if (node.parameters.nodes.some((p) => p.initializer !== undefined || p.dotDotDotToken !== undefined || !ts.isIdentifier(p.name)))
+        return true;
+    const useStrict = (statements) => {
+        for (const statement of statements) {
+            if (!ts.isExpressionStatement(statement) || !ts.isStringLiteral(statement.expression))
+                return false;
+            if (statement.expression.text === "use strict")
+                return true;
+        }
+        return false;
+    };
+    for (let n = node; n; n = n.parent) {
+        if (ts.isClassDeclaration(n) || ts.isClassExpression(n))
+            return true;
+        if (ts.isFunctionLike(n) && n.body && ts.isBlock(n.body) && useStrict(n.body.statements.nodes))
+            return true;
+        if (ts.isSourceFile(n))
+            return useStrict(n.statements.nodes);
+    }
+    return false;
+}
 /** Signature checks + param shapes + IR func type for any lambda-like
  * node. The func type's params are the ABI types: optional/default params
  * become `T | undefined`, and typed rest becomes one packed-array slot.
@@ -538,13 +768,23 @@ function appendArgumentsParameter(lowerer, node, shapes, mode) {
 export function lambdaSignature(lowerer, node) {
     if (!node.body)
         lowerer.unsupported("SC1090", node, "function overload signatures");
+    // A parameterless function expression forwarding its `arguments`,
+    // asserted to a fixed signature: that signature is its ABI.
+    if (typedArgumentsCandidate(node) && !node.typeParameters?.nodes.length) {
+        const target = typedArgumentsTarget(lowerer, node);
+        if (target) {
+            const shapes = typedArgumentsShapes(target);
+            lowerer.typedArgumentsLambdas.add(node);
+            return { shapes, funcType: funcTypeFromParamShapes(shapes, target.ret) };
+        }
+    }
     // A JS replacement of a native stream's write method receives the
     // actual call tuple, including overloads and omitted arguments. Node's
     // contextual overload signature cannot define this closure's ABI.
-    if (isJsSourceFile(node.getSourceFile()) &&
+    if (isJsSourceFile(ts.getSourceFileOfNode(node)) &&
         !node.type &&
         (ts.isFunctionExpression(node) || ts.isArrowFunction(node)) &&
-        node.parameters.every((param) => !param.type && !param.dotDotDotToken && !param.initializer) &&
+        node.parameters.nodes.every((param) => !param.type && !param.dotDotDotToken && !param.initializer) &&
         ts.isBinaryExpression(node.parent) &&
         node.parent.right === node &&
         node.parent.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
@@ -553,11 +793,34 @@ export function lambdaSignature(lowerer, node) {
         lowerer.isStdlibMember(node.parent.left)) {
         const receiver = lowerer.lowerExpr(node.parent.left.expression);
         if (receiver.type.kind === "dyn") {
-            const shapes = node.parameters.map(() => ({ type: DYN, mode: "required" }));
+            const shapes = node.parameters.nodes.map(() => ({
+                type: DYN,
+                mode: "required",
+            }));
             return { shapes, funcType: funcTypeFromParamShapes(shapes, DYN) };
         }
     }
-    if (node.typeParameters) {
+    // A callback whose arguments arrive as the runtime produced them, wider
+    // than its contextual overload says (dns.lookup's callback when the
+    // options are only known at run time: the address is a string or an
+    // address list): every parameter binds as a checked-dynamic value.
+    // Rest parameters keep their packing and optional or defaulted ones stay
+    // omittable (the prologue applies a default to an undefined argument).
+    // The slot discards the result, so a sync callback returns void and an
+    // async one keeps its promise.
+    if (lowerer.dynParamLambdas.has(node)) {
+        const shapes = node.parameters.nodes
+            .filter((param) => !isThisParameter(param))
+            .map((param) => param.dotDotDotToken
+            ? { type: DYN, mode: "dynRest" }
+            : param.initializer
+                ? { type: DYN, mode: "omittable", bodyType: DYN }
+                : { type: DYN, mode: param.questionToken ? "omittable" : "required" });
+        const isAsync = node.modifiers?.nodes.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword);
+        const ret = isAsync ? lowerer.declaredReturnType(node, node) : VOID;
+        return { shapes, funcType: funcTypeFromParamShapes(shapes, ret) };
+    }
+    if (node.typeParameters?.nodes && !lowerer.erasingLambdas.has(node)) {
         // Generic function-like forms monomorphize only where a static home
         // exists: top-level generic function declarations, generic methods
         // (class and object-literal), and module-scope never-reassigned
@@ -571,13 +834,13 @@ export function lambdaSignature(lowerer, node) {
                 ? "generic nested functions (only top-level generic function declarations are supported)"
                 : "generic arrow/function expressions outside a never-reassigned module-scope binding (only `const f = <T>(x: T) => ...` bindings and top-level generic function declarations monomorphize)");
     }
-    const shapes = lowerer.paramShapes(node.parameters);
+    const shapes = lowerer.paramShapes(node.parameters.nodes);
     // Error-first callbacks captured by native filesystem adapters receive
     // the selected runtime overload. Ambient contextual inference can pick
     // the string overload even when options request a Buffer.
     if ((ts.isArrowFunction(node) || ts.isFunctionExpression(node)) &&
         ts.isCallExpression(node.parent) &&
-        node.parent.arguments.at(-1) === node) {
+        node.parent.arguments.nodes.at(-1) === node) {
         const builtin = ts.isPropertyAccessExpression(node.parent.expression)
             ? lowerer.builtinMemberOf(node.parent.expression)
             : ts.isIdentifier(node.parent.expression)
@@ -587,7 +850,7 @@ export function lambdaSignature(lowerer, node) {
             builtin.member !== "rename" &&
             builtinModuleFnOf(lowerer, builtin.module, builtin.member)?.fn === "fs.callbackCall") {
             for (let index = 0; index < shapes.length; index++) {
-                if (!node.parameters[index]?.type) {
+                if (!node.parameters.nodes[index]?.type) {
                     shapes[index].type = DYN;
                     if (shapes[index].bodyType)
                         shapes[index].bodyType = DYN;
@@ -622,30 +885,61 @@ export function lambdaSignature(lowerer, node) {
     // construction: a callback building IrStmt[] must wrap each element at
     // that recursive layout instead of first inferring narrower arrays.
     const isAsyncLike = !ts.isMethodDeclaration(node) &&
-        node.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) === true;
+        node.modifiers?.nodes.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) === true;
     const innerRet = isAsyncLike && ret.kind === "promise" ? ret.inner : ret;
     // Union-inferred returns adopt too (a mixed-return body inferring a
     // SUB-union of the slot's union — adopting is a no-op when the two
-    if ((ts.isArrowFunction(node) || ts.isFunctionExpression(node)) &&
-        (!isAsyncLike || ret.kind === "promise")) {
+    // A synchronous object-literal method adopts its slot's return the same
+    // way: its slot is the property of that name on the literal's
+    // contextual type. A literal under `satisfies` keeps its own type (the
+    // constraint is only checked), so its methods keep their inferred
+    // returns: callers of the value see those, not the constraint's.
+    const literalMethod = ts.isMethodDeclaration(node) &&
+        ts.isObjectLiteralExpression(node.parent) &&
+        !node.asteriskToken &&
+        node.modifiers?.nodes.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) !== true &&
+        !isSatisfiesOperand(node.parent);
+    if (((ts.isArrowFunction(node) || ts.isFunctionExpression(node)) &&
+        (!isAsyncLike || ret.kind === "promise")) ||
+        literalMethod) {
         // The slot's signature: the contextual type stripped of its nullish
         // parts (an OPTIONAL callback field's context is the whole
         // `(...) | undefined` union) with exactly one call signature — and
         // declared in USER code: stdlib callback slots (flatMap's
         // `U | readonly U[]`, sort comparators) have intrinsic lowerings
         // that inspect the INFERRED type, so they must not widen.
-        const ctxType = lowerer.checker.getContextualType(node);
+        const ctxType = literalMethod && ts.isMethodDeclaration(node) && node.parent
+            ? objectLiteralMethodSlot(lowerer, node, node.parent)
+            : lowerer.checker.getContextualType(node);
         const ctxSigs = ctxType
             ? lowerer.checker.getCallSignatures(lowerer.checker.getNonNullableType(ctxType))
             : [];
-        const ctxDecl = ctxSigs.length === 1 ? lowerer.checker.signatureDeclaration(ctxSigs[0]) : undefined;
-        const ctxRetRaw = ctxDecl && !ctxDecl.getSourceFile().isDeclarationFile
+        const ctxDecl = ctxSigs.length === 1 ? ctxSigs[0].declaration : undefined;
+        const ctxRetRaw = ctxDecl && !ts.getSourceFileOfNode(ctxDecl).isDeclarationFile
             ? lowerer.mapTypeOf(lowerer.checker.getReturnTypeOfSignature(ctxSigs[0]))
             : null;
-        const ctxRet = isAsyncLike && ctxRetRaw?.kind === "promise" ? ctxRetRaw.inner : ctxRetRaw;
-        if ((ctxRet?.kind === "union" || ctxRet?.kind === "array" || ctxRet?.kind === "record") &&
-            (innerRet.kind !== "void" ||
-                (ctxRet.kind === "union" && lowerer.armTag(ctxRet.unionId, UNDEFINED_T) >= 0))) {
+        // An async lambda always produces a promise, so a slot returning a
+        // promise-armed union (`Promise<R | void> | R | void`, `Promise<void>
+        // | void`) is met through that promise arm: its payload is the ABI.
+        const ctxPromiseArm = isAsyncLike && ctxRetRaw?.kind === "union"
+            ? lowerer.unions.get(ctxRetRaw.unionId)?.arms.filter((arm) => arm.kind === "promise")
+            : undefined;
+        const ctxRet = isAsyncLike && ctxRetRaw?.kind === "promise"
+            ? ctxRetRaw.inner
+            : ctxPromiseArm?.length === 1 && ctxPromiseArm[0].kind === "promise"
+                ? ctxPromiseArm[0].inner
+                : ctxRetRaw;
+        // A TypeScript variadic lambda (`(...args) => handler(...args)`) in a
+        // checked-dynamic variadic slot returning `unknown` adopts that result
+        // too: rest closures have no function-value adapter, so the closure
+        // must match the slot's ABI exactly.
+        const dynVariadicSlot = ctxRet?.kind === "dyn" &&
+            !isJsSourceFile(ts.getSourceFileOfNode(node)) &&
+            shapes.some((shape) => shape.mode === "dynRest");
+        if (dynVariadicSlot ||
+            ((ctxRet?.kind === "union" || ctxRet?.kind === "array" || ctxRet?.kind === "record") &&
+                (innerRet.kind !== "void" ||
+                    (ctxRet.kind === "union" && lowerer.armTag(ctxRet.unionId, UNDEFINED_T) >= 0)))) {
             ret = isAsyncLike ? { kind: "promise", inner: ctxRet } : ctxRet;
         }
         // A VOID slot discards the callback's result (TS's void-returning
@@ -674,7 +968,8 @@ export function lambdaSignature(lowerer, node) {
             ? lowerer.mapTypeOf(lowerer.checker.getNonNullableType(literalSlot))
             : null;
         const inferredLiteral = literalSlot !== undefined && (literalType === null || literalType.kind === "dyn");
-        if (!isAsyncLike &&
+        if (!literalMethod &&
+            !isAsyncLike &&
             !node.type &&
             !inferredLiteral &&
             ret.kind !== "void" &&
@@ -688,4 +983,33 @@ export function lambdaSignature(lowerer, node) {
     const funcType = funcTypeFromParamShapes(shapes, ret);
     return { shapes, funcType };
 }
+/** Whether the object literal `literal` is the operand of a `satisfies`
+ * expression, directly or as a property value of literals that are. */
+function isSatisfiesOperand(literal) {
+    let n = literal;
+    while (n !== undefined) {
+        const parent = n.parent;
+        if (parent === undefined)
+            return false;
+        if (ts.isParenthesizedExpression(parent))
+            n = parent;
+        else if (ts.isPropertyAssignment(parent) && parent.initializer === n)
+            n = parent.parent;
+        else
+            return ts.isSatisfiesExpression(parent) && parent.expression === n;
+    }
+    return false;
+}
+/** The type of the property an object-literal method fills on the
+ * literal's contextual type; undefined when the literal has no contextual
+ * type or the method has a computed name. */
+function objectLiteralMethodSlot(lowerer, node, literal) {
+    if (!ts.isIdentifier(node.name) && !ts.isStringLiteral(node.name))
+        return undefined;
+    const literalType = lowerer.checker.getContextualType(literal);
+    if (!literalType)
+        return undefined;
+    const property = lowerer.checker.getPropertyOfType(lowerer.checker.getNonNullableType(literalType), node.name.text);
+    return property ? lowerer.checker.getTypeOfSymbol(property) : undefined;
+}
 //# sourceMappingURL=call-signatures.js.map