@cplieger/deadset-ts 8.0.0-dev.20 → 8.0.0-dev.22

package/dist/src/{serialization-contract.js → exemptions/serialization-contract.js}

@@ -6,26 +6,22 @@
  * the project handing such a parameter to a destination is one, to a fixpoint, and a
  * function invoked through `call`, `apply` or `bind` is the callee.
  */
-import { isArrayLiteralExpression, isArrowFunction, isAsExpression, isAwaitExpression, isCallExpression, isClassDeclaration, isClassExpression, isClassStaticBlockDeclaration, isElementAccessExpression, isExpressionStatement, isFunctionDeclaration, isFunctionExpression, isFunctionLikeDeclaration, isGetAccessorDeclaration, isIdentifier, isInterfaceDeclaration, isMethodDeclaration, isNonNullExpression, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectLiteralExpression, isParenthesizedExpression, isForInStatement, isPropertyAccessExpression, isPropertyDeclaration, isReturnStatement, isSatisfiesExpression, isSetAccessorDeclaration, isSourceFile, isSpreadAssignment, isSpreadElement, isStringLiteral, isTypeAssertion, isTypeLiteralNode, isVariableDeclaration, ModifierFlags, NodeFlags, SyntaxKind, } from "@typescript/native/ast";
-import { parenthesesRemoved } from "./unwrap.js";
+import { isArrowFunction, isAsExpression, isAwaitExpression, isCallExpression, isClassDeclaration, isClassExpression, isElementAccessExpression, isExpressionStatement, isFunctionDeclaration, isFunctionExpression, isFunctionLikeDeclaration, isGetAccessorDeclaration, isIdentifier, isInterfaceDeclaration, isMethodDeclaration, isNonNullExpression, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectLiteralExpression, isParenthesizedExpression, isForInStatement, isPropertyAccessExpression, isPropertyDeclaration, isReturnStatement, isSatisfiesExpression, isSetAccessorDeclaration, isSourceFile, isSpreadAssignment, isSpreadElement, isStringLiteral, isTypeAssertion, isTypeLiteralNode, isVariableDeclaration, NodeFlags, SyntaxKind, } from "@typescript/native/ast";
 import { SignatureKind, SymbolFlags, TypeFlags, } from "@typescript/native/sync";
-import { aliasChains } from "./alias-chain.js";
-import { calleeName, resolvedTargets, valuesPassed } from "./calls.js";
-import { classMembers, memberComponent, typesAt } from "./class-members.js";
-import { names, namesADeclaration, resolveEntries, spelledEntry, } from "./roots/configured-declarations.js";
-import { nodeKey } from "./inventory.js";
-import { renderPosition } from "./position.js";
-import { must, Unanswerable } from "./query.js";
+import { aliasChains } from "../alias-chain.js";
+import { carriedValues, valuesOf } from "../index/values.js";
+import { parenthesesRemoved } from "../unwrap.js";
+import { fills, knownElements, layoutOf, placesIn, spansOf, } from "./argument-places.js";
+import { classMembers, memberComponent, typesAt } from "../class-members.js";
+import { names, namesADeclaration, resolveEntries, spelledEntry, } from "../roots/configured-declarations.js";
+import { renderPosition } from "../position.js";
+import { must, Unanswerable } from "../query.js";
 import { erasedStores } from "./erased-stores.js";
-import { checkedTypes, CONVERSION_MEMBERS, valueReach } from "./value-reach.js";
+import { checkedTypes, CONVERSION_MEMBERS, CONVERSION_NAMES, ERASED, valueReach, } from "./value-reach.js";
 /** The serializer every run reads, whatever the configuration names. */
 const JSON_STRINGIFY = { global: "JSON.stringify" };
-/** The methods a serializer and a formatter resolve by name on a value that left the analysis. */
-const CONVERSIONS = new Set(["toJSON", "toString"]);
 /** The method a serializer calls on a value that carries one, wherever the value goes. */
 const SERIALIZED_CONVERSION = "toJSON";
-/** The parameter types that keep nothing of the value they are given. */
-const ERASED = TypeFlags.Any | TypeFlags.Unknown;
 /** The standard library's promise types, whose value is their one type argument. */
 const PROMISES = new Set(["Promise", "PromiseLike"]);
 /** How deep a callee's result is searched for a type parameter: `Promise<Box<T>>` is two levels. */
@@ -34,39 +30,6 @@ const MENTION_DEPTH = 3;
 function wider(a, b) {
     return a === "conversions" || b === "conversions" ? "conversions" : (a ?? b);
 }
-/** Whether one node declares a static member, whose `this` is the class itself. */
-function isStatic(node) {
-    const flags = node.modifierFlags ?? 0;
-    return (flags & ModifierFlags.Static) !== 0;
-}
-/** Whether one node opens a body whose `this` is not an instance of the enclosing class. */
-function resetsThis(node) {
-    return (isFunctionDeclaration(node) ||
-        isFunctionExpression(node) ||
-        isClassStaticBlockDeclaration(node) ||
-        isStatic(node) ||
-        ((isMethodDeclaration(node) ||
-            isGetAccessorDeclaration(node) ||
-            isSetAccessorDeclaration(node)) &&
-            isObjectLiteralExpression(node.parent)));
-}
-/** The parameters and declaring node of one function-like declaration of the project. */
-function functionOf(node) {
-    if (isFunctionDeclaration(node) ||
-        (isMethodDeclaration(node) && !isObjectLiteralExpression(node.parent))) {
-        return { declared: node, parameters: node.parameters };
-    }
-    if (isVariableDeclaration(node) &&
-        node.initializer !== undefined &&
-        (isArrowFunction(node.initializer) || isFunctionExpression(node.initializer))) {
-        return { declared: node, parameters: node.initializer.parameters };
-    }
-    return undefined;
-}
-/** Whether one parameter is a `this` parameter, which types `this` and binds no argument. */
-function isThisParameter(parameter) {
-    return isIdentifier(parameter.name) && parameter.name.text === "this";
-}
 /** Whether an argument is written in a form that holds no class instance, which saves a type. */
 function holdsNoInstance(argument) {
     return (isArrowFunction(argument) ||
@@ -76,108 +39,6 @@ function holdsNoInstance(argument) {
         isNoSubstitutionTemplateLiteral(argument) ||
         argument.kind === SyntaxKind.TemplateExpression);
 }
-/** The expression an argument evaluates, through parentheses and a spread. */
-function evaluated(argument) {
-    const value = isSpreadElement(argument) ? argument.expression : argument;
-    return isParenthesizedExpression(value) ? evaluated(value.expression) : value;
-}
-/** The methods of `Function.prototype` that invoke a function with arguments of their own. */
-const FUNCTION_METHODS = new Set(["call", "apply", "bind"]);
-/** The interfaces of the standard library that declare those methods for a function value. */
-const FUNCTION_INTERFACES = new Set([
-    "Function",
-    "CallableFunction",
-    "NewableFunction",
-]);
-/**
- * The invocation a call writes through a method of `Function.prototype`, read from
- * the syntax alone: `f.call(self, a)`, `f.apply(self, [a])`, `f.bind(self, a)`, which
- * binds `a`, and `f.bind(self, a)(b)`, which passes `b` after it. An `apply` argument
- * that is no array literal is the value of the first parameter, whose elements it
- * carries. Whether the method is the prototype's is resolution's to say.
- */
-function throughMethod(call) {
-    const expression = parenthesesRemoved(call.expression);
-    if (isPropertyAccessExpression(expression) && FUNCTION_METHODS.has(expression.name.text)) {
-        const [, ...rest] = call.arguments;
-        let passed = rest;
-        if (expression.name.text === "apply") {
-            const list = rest[0] === undefined ? undefined : parenthesesRemoved(rest[0]);
-            passed = list === undefined ? [] : isArrayLiteralExpression(list) ? list.elements : [list];
-        }
-        return {
-            method: expression.name,
-            invocation: { callee: expression.expression, arguments: passed, indirect: true },
-        };
-    }
-    if (isCallExpression(expression)) {
-        const bound = parenthesesRemoved(expression.expression);
-        if (isPropertyAccessExpression(bound) && bound.name.text === "bind") {
-            return {
-                method: bound.name,
-                invocation: {
-                    callee: bound.expression,
-                    arguments: [...expression.arguments.slice(1), ...call.arguments],
-                    indirect: true,
-                },
-            };
-        }
-    }
-    return undefined;
-}
-/**
- * Every call of the project's own files with the class `this` stands for there, and
- * every identifier-named parameter of every function, method and function-valued
- * variable the project declares, at the position of the argument it binds.
- */
-function walkProject(project, held) {
-    const sites = [];
-    const parameters = [];
-    const initialized = new Set();
-    for (const file of project.ownSourceFiles()) {
-        const visit = (node, self) => {
-            let inner = self;
-            if (isPropertyDeclaration(node) && node.initializer !== undefined) {
-                const id = held.declarations.get(nodeKey(file, node));
-                if (id !== undefined) {
-                    initialized.add(id);
-                }
-            }
-            if (isClassDeclaration(node) || isClassExpression(node)) {
-                inner = held.declarations.get(nodeKey(file, node));
-            }
-            else if (resetsThis(node)) {
-                inner = undefined;
-            }
-            if (node.kind === SyntaxKind.CallExpression) {
-                sites.push({ call: node, self });
-            }
-            const fn = functionOf(node);
-            const id = fn === undefined ? undefined : held.declarations.get(nodeKey(file, fn.declared));
-            if (fn !== undefined && id !== undefined) {
-                fn.parameters
-                    .filter((parameter) => !isThisParameter(parameter))
-                    .forEach((parameter, index) => {
-                    if (isIdentifier(parameter.name)) {
-                        parameters.push({
-                            fn: id,
-                            index,
-                            rest: parameter.dotDotDotToken !== undefined,
-                            name: parameter.name,
-                        });
-                    }
-                });
-            }
-            node.forEachChild((child) => {
-                visit(child, inner);
-            });
-        };
-        file.forEachChild((child) => {
-            visit(child, undefined);
-        });
-    }
-    return { sites, parameters, initialized };
-}
 /** The calls of `Object` that read every own property of their argument by name. */
 const ENUMERATIONS = new Set([
     "keys",
@@ -202,7 +63,9 @@ function keepsNoName(project, type) {
 }
 /**
  * The parameters that keep no member name of the value they are given, as `keepsNoName`
- * reads it, and a rest parameter whose elements keep none, each by its symbol.
+ * reads it, and a rest parameter whose number index holds a type that keeps none, an
+ * element of an array, a tuple, an array-like interface or a union or an intersection of
+ * them, each by its symbol. A rest a type parameter types is left to its calls' flows.
  */
 function erasedParameters(project, parameters) {
     const types = typesAt(project, parameters.map((parameter) => parameter.name));
@@ -214,8 +77,11 @@ function erasedParameters(project, parameters) {
         if (!parameter.rest) {
             return keepsNoName(project, type);
         }
-        const [element] = must(project.queries.typeArguments(type));
-        return element !== undefined && keepsNoName(project, element);
+        const element = (type.flags & TypeFlags.Instantiable) === 0
+            ? must(project.queries.numberIndexOf(type))
+            : undefined;
+        return (element !== undefined &&
+            must(project.queries.constituents(element)).some((part) => keepsNoName(project, part)));
     });
     const bySymbol = new Map();
     project
@@ -229,6 +95,14 @@ function erasedParameters(project, parameters) {
     });
     return bySymbol;
 }
+/**
+ * The type any place of a signature's rest may take, the number index of the rest's type;
+ * none where it has no rest or the type no number index.
+ */
+function restElementOf(project, signature) {
+    const rest = must(project.queries.restTypeOf(signature));
+    return rest === undefined ? undefined : must(project.queries.numberIndexOf(rest));
+}
 /** Whether one node is a function, whose body runs only where something calls it. */
 function isFunctionNode(node) {
     return (isFunctionDeclaration(node) ||
@@ -299,7 +173,7 @@ function enumeratedParameters(project, erased) {
             else if (isForInStatement(node)) {
                 read.push(node.expression);
             }
-            for (const value of read.map(evaluated)) {
+            for (const value of read.flatMap(valuesOf)) {
                 if (isIdentifier(value) && value.text === spelled) {
                     asked.push({ node: value, parameter, object });
                 }
@@ -327,11 +201,13 @@ function enumeratedParameters(project, erased) {
     ];
 }
 /** Each place a call's argument passes one of the erased parameters it can see. */
-function handedOn(project, sites, erased, invocationOf) {
+function handedOn(project, sites, erased) {
     const spellings = new Set([...erased.values()].map((parameter) => parameter.name.getText()));
-    const candidates = sites.flatMap((site) => invocationOf(site.call).arguments.flatMap((argument, index) => valuesPassed(argument)
-        .filter((value) => spellings.has(value.name.getText()))
-        .map((value) => ({ site, argument: index, value }))));
+    const candidates = sites.calls.flatMap((site) => sites.invocations
+        .of(site.call)
+        .arguments.flatMap((argument, index) => carriedValues(argument).flatMap((value) => value.name !== undefined && spellings.has(value.name.getText())
+        ? [{ site, argument: index, value: { ...value, name: value.name } }]
+        : [])));
     const plain = candidates.filter((one) => !one.value.shorthand);
     const resolved = project.symbolsAt(plain.map((one) => project.handle(one.value.name))).map(must);
     const symbolOf = new Map(plain.map((one, index) => [one, resolved[index]]));
@@ -373,11 +249,11 @@ function implementedOwners(project, inAnalysis) {
             else if ((isVariableDeclaration(node) || isPropertyDeclaration(node)) &&
                 node.type !== undefined &&
                 node.initializer !== undefined &&
-                isObjectLiteralExpression(evaluated(node.initializer))) {
+                isObjectLiteralExpression(parenthesesRemoved(node.initializer))) {
                 naming.push(node.type);
             }
             else if ((isSatisfiesExpression(node) || isAsExpression(node)) &&
-                isObjectLiteralExpression(evaluated(node.expression))) {
+                isObjectLiteralExpression(parenthesesRemoved(node.expression))) {
                 naming.push(node.type);
             }
             node.forEachChild(visit);
@@ -412,26 +288,13 @@ function implementedOwners(project, inAnalysis) {
  * parameter the function enumerates or hands on to a destination, holding back the widest
  * of what those hold back, settled by widening until no parameter moves.
  */
-function destinations(input, chains, walked) {
-    const { project, held } = input;
+function destinations(input, chains) {
+    const { project, held, sites } = input;
     const queries = project.queries;
     const own = project.ownPaths();
     const named = resolveEntries(project, held, [JSON_STRINGIFY, ...input.ts.serializers]).filter(namesADeclaration);
-    const forms = new Map();
-    for (const site of walked.sites) {
-        const form = throughMethod(site.call);
-        if (form !== undefined) {
-            forms.set(site.call, form);
-        }
-    }
-    const callees = resolvedTargets(project, [
-        ...walked.sites.flatMap((site) => calleeName(site.call.expression) ?? []),
-        ...[...forms.values()].flatMap((form) => {
-            const name = calleeName(form.invocation.callee);
-            return name === undefined ? [form.method] : [form.method, name];
-        }),
-    ]);
-    const erased = erasedParameters(project, walked.parameters);
+    const { of: invocation, callee: calleeOf } = sites.invocations;
+    const erased = erasedParameters(project, sites.parameters);
     const byFunction = new Map();
     for (const parameter of erased.values()) {
         byFunction.set(parameter.fn, [...(byFunction.get(parameter.fn) ?? []), parameter]);
@@ -466,37 +329,16 @@ function destinations(input, chains, walked) {
      * library's beside it, so a call can still resolve to the library's.
      */
     const mayBeOutside = (target) => target.declarations.some((handle) => outside(target, false, [handle]));
-    const invocation = (call) => {
-        const form = forms.get(call);
-        const method = form === undefined ? undefined : callees.get(form.method);
-        // Only the standard library's function methods pass their arguments on: the
-        // program's own `call` and `Reflect.apply` invoke nothing here.
-        if (form !== undefined &&
-            method !== undefined &&
-            mayBeOutside(method) &&
-            FUNCTION_INTERFACES.has(must(project.queries.parentOf(method))?.name ?? "")) {
-            return form.invocation;
-        }
-        return { callee: call.expression, arguments: call.arguments, indirect: false };
-    };
-    const calleeOf = (call) => {
-        const name = calleeName(invocation(call).callee);
-        return name === undefined ? undefined : callees.get(name);
-    };
-    const signatures = new Map();
-    const resolvedOf = (call) => {
-        if (!signatures.has(call)) {
-            signatures.set(call, must(queries.resolvedSignature(call)));
-        }
-        return signatures.get(call);
-    };
+    const bindings = callBindings(project, invocation);
     /**
      * The declarations of a callee that the declaration of a direct call's resolved
      * signature lies in, or all of them where it lies in none: a declaration merged into
      * the callee's symbol that the call does not resolve to does not decide where it runs.
      */
     const calledDeclarations = (call, target) => {
-        const declaration = invocation(call).indirect ? undefined : resolvedOf(call)?.declaration;
+        const declaration = invocation(call).indirect
+            ? undefined
+            : bindings.of(call)[0]?.signature.declaration;
         const signature = declaration === undefined ? undefined : project.declarationAt(declaration)?.node;
         if (declaration === undefined || signature === undefined) {
             return target.declarations;
@@ -529,54 +371,111 @@ function destinations(input, chains, walked) {
         ];
         return inner.some((one) => mentions(one, parameter, depth + 1));
     };
-    const erasedArguments = new Map();
-    const erasedAt = (call, argument) => {
-        let indexes = erasedArguments.get(call);
-        if (indexes === undefined) {
-            const invoked = invocation(call);
-            // Through a method of the prototype the resolved signature is the method's, so
-            // the parameters are read off the callee's own signatures, any one erasing.
-            const type = invoked.indirect ? must(queries.typeAt(invoked.callee)) : undefined;
-            const signatures = invoked.indirect
-                ? type === undefined
-                    ? []
-                    : must(queries.signaturesOf(type, SignatureKind.Call))
-                : [resolvedOf(call)].filter((one) => one !== undefined);
-            // A type parameter of the callee that nothing constrains and its result does not name
-            // keeps nothing of the value either: the instantiated signature names the value's own
-            // type there instead, and a result that names it hands the value back.
-            const generic = invoked.indirect ? undefined : resolvedOf(call);
-            const declared = generic === undefined ? undefined : must(queries.genericOf(generic));
-            const unconstrained = (index) => {
-                const parameter = declared === undefined ? undefined : must(queries.parameterType(declared, index));
-                const parts = parameter === undefined
-                    ? []
-                    : parameter.isUnionType()
-                        ? must(queries.constituents(parameter))
-                        : [parameter];
-                const result = declared === undefined ? undefined : must(queries.returnTypeOf(declared));
-                return parts.some((part) => {
-                    if (!part.isTypeParameter() || (result !== undefined && mentions(result, part, 0))) {
-                        return false;
-                    }
-                    const constraint = must(queries.constraintOf(part));
-                    return constraint === undefined || (constraint.flags & ERASED) !== 0;
-                });
+    const erasedPlaces = new Map();
+    /**
+     * Whether an argument of a call is erased: where `element` is given, that element of a
+     * span of known length at the one place it fills, and otherwise at any place the
+     * argument fills, in any signature the call binds. An argument no signature the call
+     * binds has a place for says nothing of what it keeps, so it counts as erased.
+     */
+    const erasedAt = (call, argument, element) => {
+        let erased = erasedPlaces.get(call);
+        if (erased === undefined) {
+            // A type parameter or an indexed access over one keeps nothing of the value where its
+            // base constraint is erased or absent, unless the result names the type parameter:
+            // the instantiated result is then the value's own type, handed back. A mapped type
+            // over type parameters keeps nothing where any of theirs is erased, whatever the
+            // result names, because the checker infers through it a copy without the class's
+            // non-public members, and which keys the mapping keeps is not read.
+            const erasedConstraint = (generic) => {
+                const constraint = must(queries.baseConstraintOf(generic));
+                return constraint === undefined || (constraint.flags & ERASED) !== 0;
             };
-            indexes = new Set(invoked.arguments.flatMap((_unused, index) => unconstrained(index) ||
-                signatures.some((signature) => {
-                    const parameter = must(queries.parameterType(signature, index));
-                    return parameter !== undefined && (parameter.flags & ERASED) !== 0;
-                })
-                ? [index]
-                : []));
-            erasedArguments.set(call, indexes);
+            const keepsNothing = (part, result) => {
+                const mapped = must(queries.mappedParametersOf(part));
+                if (mapped.length > 0) {
+                    return mapped.some(erasedConstraint);
+                }
+                if ((part.flags & TypeFlags.Instantiable) === 0) {
+                    return false;
+                }
+                const free = part.isTypeParameter() ? part : must(queries.indexedAccessOf(part))?.object;
+                if (free?.isTypeParameter() === true && result !== undefined && mentions(result, free, 0)) {
+                    return false;
+                }
+                return erasedConstraint(part);
+            };
+            // At a rest placement the declaration's type is its rest's element, the number index,
+            // which the checker reads through the base constraint of a rest a type parameter
+            // types, so an element erased there is one the declaration leaves generic.
+            const unconstrained = (declared, placed) => {
+                if (declared === undefined) {
+                    return false;
+                }
+                const result = must(queries.returnTypeOf(declared));
+                if (!placed.rest) {
+                    const parameter = must(queries.parameterType(declared, placed.place));
+                    return (parameter === undefined ? [] : must(queries.constituents(parameter))).some((part) => keepsNothing(part, result));
+                }
+                const rest = must(queries.restTypeOf(declared));
+                const element = restElementOf(project, declared);
+                if (rest?.isTypeParameter() === true && result !== undefined && mentions(result, rest, 0)) {
+                    return false;
+                }
+                return (element === undefined ||
+                    must(queries.constituents(element)).some((part) => (part.flags & ERASED) !== 0 || keepsNothing(part, result)));
+            };
+            const found = new Set();
+            const placedAt = new Set();
+            const unplaced = new Map();
+            for (const one of bindings.of(call)) {
+                const asked = new Set();
+                for (const placed of one.placed()) {
+                    const { argument: at, element: given, place, uncovered, rest } = placed;
+                    const key = `${String(at)}:${String(given)}`;
+                    if (uncovered) {
+                        unplaced.set(key, at);
+                        continue;
+                    }
+                    placedAt.add(key);
+                    const where = `${key}:${rest ? "rest" : String(place)}`;
+                    if (found.has(key) || asked.has(where)) {
+                        continue;
+                    }
+                    asked.add(where);
+                    // A signature that is its own declaration, as one an indirect call binds, has its
+                    // rest's element judged as the declaration's alone.
+                    const own = rest && one.signature === one.declared;
+                    const parameter = own
+                        ? undefined
+                        : rest
+                            ? restElementOf(project, one.signature)
+                            : must(queries.parameterType(one.signature, place));
+                    if ((rest && !own && parameter === undefined) ||
+                        (parameter !== undefined && (parameter.flags & ERASED) !== 0) ||
+                        unconstrained(one.declared, placed)) {
+                        found.add(key);
+                        found.add(String(at));
+                    }
+                }
+            }
+            for (const [key, at] of unplaced) {
+                if (!placedAt.has(key)) {
+                    found.add(key);
+                    found.add(String(at));
+                }
+            }
+            erased = found;
+            erasedPlaces.set(call, erased);
         }
-        return indexes.has(argument);
+        const span = bindings.spans(call).find((one) => one.argument === argument);
+        return element === undefined || span?.open !== false
+            ? erased.has(String(argument))
+            : erased.has(`${String(argument)}:${String(element)}`);
     };
     const forwards = new Map();
     const keyOf = (parameter) => `${parameter.fn}\u0000${String(parameter.index)}`;
-    const at = (call, argument) => {
+    const at = (call, argument, element) => {
         const target = calleeOf(call);
         if (target === undefined) {
             return undefined;
@@ -586,16 +485,18 @@ function destinations(input, chains, walked) {
             return { reach: "properties", callee: spelledEntry(entry.entry, held) };
         }
         if (outside(target, true, calledDeclarations(call, target))) {
-            return erasedAt(call, argument)
+            return erasedAt(call, argument, element)
                 ? {
                     reach: "conversions",
                     callee: invocation(call).callee.getText().replace(/\s+/gu, ""),
                 }
                 : undefined;
         }
+        const spans = bindings.spans(call).filter((span) => span.argument === argument);
         for (const fn of chains.declarationsOf(target)) {
-            const parameter = (byFunction.get(fn) ?? []).find((one) => one.index === argument || (one.rest && one.index <= argument));
-            const reach = parameter === undefined ? undefined : forwards.get(keyOf(parameter));
+            const reach = (byFunction.get(fn) ?? [])
+                .filter((one) => spans.some((span) => fills(span, one.index, one.rest, element)))
+                .reduce((widest, one) => wider(widest, forwards.get(keyOf(one))), undefined);
             if (reach !== undefined) {
                 return { reach, callee: held.symbols.find((symbol) => symbol.id === fn)?.name ?? fn };
             }
@@ -605,7 +506,7 @@ function destinations(input, chains, walked) {
     for (const parameter of enumeratedParameters(project, erased)) {
         forwards.set(keyOf(parameter), "properties");
     }
-    const forwarded = handedOn(project, walked.sites, erased, invocation);
+    const forwarded = handedOn(project, sites, erased);
     for (let moved = true; moved;) {
         moved = false;
         for (const one of forwarded) {
@@ -630,7 +531,7 @@ function destinations(input, chains, walked) {
             .declarationsOf(target)
             .some((fn) => (byFunction.get(fn) ?? []).some((parameter) => forwards.has(keyOf(parameter))));
     };
-    return { invocation, at, mayReceive };
+    return { invocation, bindings, at, mayReceive };
 }
 /** What two reaches carry together. */
 function joined(a, b) {
@@ -640,51 +541,86 @@ function joined(a, b) {
 function flowsOf(project, held, sites, to, stores) {
     const reach = valueReach(project, held, stores.inside);
     const arguments_ = sites.flatMap((site) => to.mayReceive(site.call)
-        ? to.invocation(site.call).arguments.flatMap((argument, index) => {
-            const value = evaluated(argument);
-            return holdsNoInstance(value) ? [] : [{ site, argument: index, value }];
-        })
+        ? to
+            .invocation(site.call)
+            .arguments.flatMap((argument, index) => valuesOf(argument).flatMap((value) => holdsNoInstance(value) ? [] : [{ site, argument: index, value }]))
         : []);
     const asked = arguments_.filter((one) => one.value.kind !== SyntaxKind.ThisKeyword);
     const types = typesAt(project, asked.map((one) => one.value));
     const typeOf = new Map(asked.map((one, index) => [one.value, types[index]]));
     const checked = checkedTypes(project, arguments_.map((one) => one.value));
-    const passed = arguments_.flatMap((one, index) => {
-        const type = typeOf.get(one.value);
-        let reached = { classes: new Set(), members: [] };
-        if (one.value.kind === SyntaxKind.ThisKeyword) {
-            reached = {
-                classes: new Set(one.site.self === undefined ? [] : [one.site.self]),
-                members: [],
-            };
-        }
-        else if (type !== undefined) {
-            reached = reach.reachedFrom(type);
+    /**
+     * The types one argument's value carries, each with the element of the argument's span
+     * it fills. A spread's value is its elements, which a container other than an array does
+     * not walk to, so the span's element types join. A spread of known length gives each
+     * element at its own place, as does any type read for it that is a tuple of that length,
+     * and every other type fills every place the argument does.
+     */
+    const partsOf = (one, types) => {
+        const span = to.bindings.spans(one.site.call).find((at) => at.argument === one.argument);
+        const given = span?.spread === true ? span.given.filter((type) => type !== undefined) : [];
+        if (span === undefined || !span.spread || span.open) {
+            return [{ element: undefined, types: [...types, ...given] }];
         }
-        for (const stored of [...(checked[index] ?? []), ...(stores.ofVariable(one.value) ?? [])]) {
-            reached = joined(reached, reach.reachedFrom(stored));
+        const whole = [];
+        const elements = span.given.map((type) => (type === undefined ? [] : [type]));
+        for (const type of types) {
+            const known = knownElements(project, type, elements.length);
+            if (known === undefined) {
+                whole.push(type);
+            }
+            else {
+                known.forEach((part, element) => {
+                    if (part !== undefined) {
+                        elements[element]?.push(part);
+                    }
+                });
+            }
         }
-        const carries = reached.classes.size > 0 || reached.members.length > 0;
-        const destination = carries ? to.at(one.site.call, one.argument) : undefined;
-        return destination === undefined
-            ? []
-            : [
-                {
-                    site: one.value,
-                    classes: reached.classes,
-                    members: reached.members,
-                    to: destination,
-                    detail: `passed to ${destination.callee}`,
-                },
-            ];
+        return [
+            { element: undefined, types: whole },
+            ...elements.map((parts, element) => ({ element, types: parts })),
+        ];
+    };
+    const passed = arguments_.flatMap((one, index) => {
+        const type = typeOf.get(one.value);
+        const self = {
+            classes: new Set(one.value.kind === SyntaxKind.ThisKeyword && one.site.self !== undefined
+                ? [one.site.self]
+                : []),
+            members: [],
+        };
+        const types = [
+            ...(type === undefined ? [] : [type]),
+            ...(checked[index] ?? []),
+            ...(stores.ofVariable(one.value) ?? []),
+        ];
+        return partsOf(one, types).flatMap(({ element, types: parts }) => {
+            const reached = parts.reduce((all, part) => joined(all, reach.reachedFrom(part)), element === undefined ? self : { classes: new Set(), members: [] });
+            const carries = reached.classes.size > 0 || reached.members.length > 0;
+            const destination = carries ? to.at(one.site.call, one.argument, element) : undefined;
+            return destination === undefined
+                ? []
+                : [
+                    {
+                        site: one.value,
+                        classes: reached.classes,
+                        members: reached.members,
+                        to: destination,
+                        detail: `passed to ${destination.callee}`,
+                    },
+                ];
+        });
     });
-    const generic = typeParameterFlows(project, reach, sites, arguments_.flatMap((one) => {
+    const generic = typeParameterFlows(project, reach, sites, to.bindings, arguments_.flatMap((one) => {
         const type = typeOf.get(one.value);
-        const parameters = type === undefined ? [] : typeParametersOf(project, type, 0);
-        const destination = parameters.length === 0 ? undefined : to.at(one.site.call, one.argument);
-        return destination === undefined
-            ? []
-            : parameters.map((parameter) => ({ parameter, to: destination }));
+        return partsOf(one, type === undefined ? [] : [type]).flatMap(({ element, types }) => {
+            const parameters = types.flatMap((part) => typeParametersOf(project, part, 0));
+            const destination = parameters.length === 0 ? undefined : to.at(one.site.call, one.argument, element);
+            return destination === undefined
+                ? []
+                : parameters.map((parameter) => ({ parameter, to: destination }));
+        });
     }));
     const left = stores.outside.flatMap((store) => {
         const reached = reach.reachedFrom(store.type);
@@ -702,10 +638,14 @@ function flowsOf(project, held, sites, to, stores) {
     });
     return [...passed, ...generic, ...left];
 }
-/** The type parameters one type names, through constituents and type arguments. */
+/**
+ * The type parameters one type names, through constituents, type arguments and the type
+ * parameters a mapped type is over. A class's polymorphic `this` type is no parameter a
+ * call binds: the reach walks it as its class.
+ */
 function typeParametersOf(project, type, depth) {
     if (type.isTypeParameter()) {
-        return [type];
+        return type.isThisType === true ? [] : [type];
     }
     if (depth >= MENTION_DEPTH) {
         return [];
@@ -714,6 +654,7 @@ function typeParametersOf(project, type, depth) {
     return [
         ...(type.isUnionType() || type.isIntersectionType() ? must(queries.constituents(type)) : []),
         ...must(queries.typeArguments(type)),
+        ...must(queries.mappedParametersOf(type)),
     ].flatMap((one) => typeParametersOf(project, one, depth + 1));
 }
 /**
@@ -757,6 +698,11 @@ function bound(project, declared, instantiated, parameter, depth) {
         return [];
     }
     const { queries } = project;
+    // A place of a rest the parameter types is declared as an indexed access over it, and
+    // what the call passes there is one element of the type it binds.
+    if (must(queries.indexedAccessOf(declared))?.object.id === parameter.id) {
+        return [instantiated];
+    }
     if (declared.isUnionType()) {
         const parts = must(queries.constituents(declared));
         if (parts.some((part) => part.id === parameter.id)) {
@@ -776,68 +722,208 @@ function bound(project, declared, instantiated, parameter, depth) {
             return given === undefined ? [] : bound(project, one, given, parameter, depth + 1);
         });
 }
+/** One value read once, at its first use. */
+function once(read) {
+    let held;
+    return () => (held ??= { value: read() }).value;
+}
+/**
+ * The signatures a project's calls bind, and the place each argument binds in each. A
+ * direct call binds the signature the checker resolves, its places taking the types the
+ * checker instantiates there. Through `call`, `apply` or `bind` a call binds every call
+ * signature of the function, a place taking the type of the argument that fills it: the
+ * checker instantiates those methods from the arguments, not from the function's own
+ * parameters, so no instantiation of them says what the function keeps.
+ */
+function callBindings(project, invocation) {
+    const { queries } = project;
+    const known = new Map();
+    const passed = new Map();
+    const spanned = new Map();
+    const layouts = new Map();
+    const valueOf = (argument) => isSpreadElement(argument) ? argument.expression : argument;
+    // An indirect call's places take its arguments' types, and a spread's type says how
+    // many places it fills; a direct call with neither reads no argument's type.
+    const typed = (call) => {
+        const invoked = invocation(call);
+        return invoked.indirect || invoked.arguments.some(isSpreadElement);
+    };
+    const typesPassed = (call) => {
+        let types = passed.get(call);
+        if (types === undefined) {
+            types = typesAt(project, invocation(call).arguments.map(valueOf));
+            passed.set(call, types);
+        }
+        return types;
+    };
+    const spans = (call) => {
+        let found = spanned.get(call);
+        if (found === undefined) {
+            const invoked = invocation(call);
+            found = spansOf(project, invoked.arguments, invoked.listed, typed(call) ? typesPassed(call) : []);
+            spanned.set(call, found);
+        }
+        return found;
+    };
+    const layout = (signature) => {
+        let found = layouts.get(signature.id);
+        if (found === undefined) {
+            found = layoutOf(project, signature);
+            layouts.set(signature.id, found);
+        }
+        return found;
+    };
+    const distinct = (pairs) => [
+        ...new Map(pairs.map((pair) => [`${String(pair.from.id)}:${String(pair.into.id)}`, pair])).values(),
+    ];
+    // The checker infers a type parameter a mapped type is over by reversing the mapping,
+    // into a copy that names no class, so at a place declared as one the value passed is
+    // what each of its type parameters carries.
+    const mappedFrom = (from, value) => value === undefined
+        ? []
+        : must(queries.constituents(from)).flatMap((part) => must(queries.mappedParametersOf(part)).map((source) => ({ from: source, into: value })));
+    const direct = (call, resolved) => {
+        if (resolved === undefined) {
+            return [];
+        }
+        const declared = must(queries.genericOf(resolved));
+        const placed = once(() => placesIn(spans(call), layout(resolved)));
+        const places = () => {
+            if (declared === undefined) {
+                return [];
+            }
+            return distinct(placed().flatMap((one) => {
+                const from = one.uncovered ? undefined : must(queries.parameterType(declared, one.place));
+                if (from === undefined) {
+                    return [];
+                }
+                const into = must(queries.parameterType(resolved, one.place));
+                const element = one.rest ? restElementOf(project, declared) : undefined;
+                const elements = one.rest ? restElementOf(project, resolved) : undefined;
+                return [
+                    ...(into === undefined ? [] : [{ from, into }]),
+                    ...(element === undefined || elements === undefined
+                        ? []
+                        : [{ from: element, into: elements }]),
+                    ...mappedFrom(from, one.given ?? typesPassed(call)[one.argument]),
+                ];
+            }));
+        };
+        return [{ call, signature: resolved, declared, placed, places, written: call.typeArguments }];
+    };
+    const indirect = (call, callee) => (callee === undefined ? [] : must(queries.signaturesOf(callee, SignatureKind.Call))).map((signature) => {
+        const placed = once(() => placesIn(spans(call), layout(signature)));
+        return {
+            call,
+            signature,
+            declared: signature,
+            placed,
+            places: () => distinct(placed().flatMap(({ place, given, uncovered, rest }) => {
+                const from = uncovered ? undefined : must(queries.parameterType(signature, place));
+                const element = rest ? restElementOf(project, signature) : undefined;
+                return from === undefined || given === undefined
+                    ? []
+                    : [
+                        { from, into: given },
+                        ...(element === undefined ? [] : [{ from: element, into: given }]),
+                        ...mappedFrom(from, given),
+                    ];
+            })),
+            written: undefined,
+        };
+    });
+    const of = (call) => {
+        let bound = known.get(call);
+        if (bound === undefined) {
+            const invoked = invocation(call);
+            bound = invoked.indirect
+                ? indirect(call, must(queries.typeAt(invoked.callee)))
+                : direct(call, must(queries.resolvedSignature(call)));
+            known.set(call, bound);
+        }
+        return bound;
+    };
+    const all = (calls) => {
+        const asked = calls.filter((call) => !known.has(call));
+        const plain = asked.filter((call) => !invocation(call).indirect);
+        queries
+            .resolvedSignatures(plain)
+            .map(must)
+            .forEach((resolved, at) => {
+            const call = plain[at];
+            if (call !== undefined) {
+                known.set(call, direct(call, resolved));
+            }
+        });
+        const through = asked.filter((call) => invocation(call).indirect);
+        const callees = typesAt(project, through.map((call) => invocation(call).callee));
+        const typing = asked.filter((call) => typed(call) && !passed.has(call));
+        const values = typesAt(project, typing.flatMap((call) => invocation(call).arguments.map(valueOf)));
+        let offset = 0;
+        for (const call of typing) {
+            const count = invocation(call).arguments.length;
+            passed.set(call, values.slice(offset, offset + count));
+            offset += count;
+        }
+        through.forEach((call, at) => {
+            known.set(call, indirect(call, callees[at]));
+        });
+        return calls.flatMap(of);
+    };
+    return { of, all, spans };
+}
 /**
  * The flows a type parameter of a function of the project carries where a value its type
  * names reaches a destination: each call of the function passes its type argument there,
  * written or inferred from the arguments, and a type argument that is a type parameter
  * of the calling function is followed on to that function's calls, to a fixpoint.
  */
-function typeParameterFlows(project, reach, sites, pending) {
+function typeParameterFlows(project, reach, sites, bindings, pending) {
     const { queries } = project;
-    const byName = new Map();
-    for (const site of sites) {
-        const name = calleeName(site.call.expression)?.getText();
-        if (name !== undefined) {
-            byName.set(name, [...(byName.get(name) ?? []), site]);
+    let calls;
+    const byDeclaration = () => {
+        const found = new Map();
+        for (const one of bindings.all(sites.map((site) => site.call))) {
+            const handle = one.declared?.declaration;
+            const node = handle === undefined ? undefined : project.declarationAt(handle)?.node;
+            if (node !== undefined) {
+                found.set(node, [...(found.get(node) ?? []), one]);
+            }
         }
-    }
+        return found;
+    };
     const found = [];
+    // One type parameter reaches each of its destinations, each holding back its own.
     const seen = new Set();
     for (let next = pending.pop(); next !== undefined; next = pending.pop()) {
         const { parameter, to } = next;
-        if (seen.has(parameter.id)) {
+        const key = `${String(parameter.id)}\u0000${to.reach}\u0000${to.callee}`;
+        if (seen.has(key)) {
             continue;
         }
-        seen.add(parameter.id);
+        seen.add(key);
         const symbol = must(queries.symbolOfType(parameter));
         const [handle] = symbol?.declarations ?? [];
         const declaration = handle === undefined ? undefined : project.declarationAt(handle)?.node;
         const fn = declaration?.parent;
-        const index = fn === undefined || !isFunctionLikeDeclaration(fn)
-            ? -1
-            : (fn.typeParameters ?? []).findIndex((one) => one === declaration);
-        const name = fn === undefined
-            ? undefined
-            : isMethodDeclaration(fn) && isIdentifier(fn.name)
-                ? fn.name.text
-                : nestedName(fn);
-        if (symbol === undefined || fn === undefined || index < 0 || name === undefined) {
+        if (symbol === undefined || fn === undefined || !isFunctionLikeDeclaration(fn)) {
             continue;
         }
-        for (const site of byName.get(name) ?? []) {
-            const resolved = must(queries.resolvedSignature(site.call));
-            const declared = resolved === undefined ? undefined : must(queries.genericOf(resolved));
-            const called = declared?.declaration === undefined
-                ? undefined
-                : project.declarationAt(declared.declaration)?.node;
-            if (resolved === undefined || declared === undefined || called !== fn) {
-                continue;
-            }
-            const written = site.call.typeArguments?.[index];
+        const index = (fn.typeParameters ?? []).findIndex((one) => one === declaration);
+        if (index < 0) {
+            continue;
+        }
+        calls ??= byDeclaration();
+        for (const one of calls.get(fn) ?? []) {
+            const written = one.written?.[index];
             const given = written === undefined
-                ? site.call.arguments.flatMap((_argument, at) => {
-                    const from = must(queries.parameterType(declared, at));
-                    const into = must(queries.parameterType(resolved, at));
-                    return from === undefined || into === undefined
-                        ? []
-                        : bound(project, from, into, parameter, 0);
-                })
+                ? one.places().flatMap(({ from, into }) => bound(project, from, into, parameter, 0))
                 : typesAt(project, [written]).filter((type) => type !== undefined);
             for (const type of given) {
                 const reached = reach.reachedFrom(type);
                 if (reached.classes.size > 0 || reached.members.length > 0) {
                     found.push({
-                        site: site.call,
+                        site: one.call,
                         classes: reached.classes,
                         members: reached.members,
                         to,
@@ -857,10 +943,9 @@ function typeParameterFlows(project, reach, sites, pending) {
  * the callee named.
  */
 export function serializationContract(input) {
-    const { project, held, targetRoot } = input;
-    const walked = walkProject(project, held);
+    const { project, held, sites, targetRoot } = input;
     const chains = aliasChains(project, held);
-    const flows = flowsOf(project, held, walked.sites, destinations(input, chains, walked), erasedStores(project));
+    const flows = flowsOf(project, held, sites.calls, destinations(input, chains), erasedStores(project));
     if (flows.length === 0) {
         return [];
     }
@@ -870,9 +955,10 @@ export function serializationContract(input) {
     // the value left the analysis.
     const holdsBack = (flags, name, to) => (flags & SymbolFlags.Property) !== 0 ||
         ((flags & CONVERSION_MEMBERS) !== 0 &&
-            (name === SERIALIZED_CONVERSION || (to.reach === "conversions" && CONVERSIONS.has(name))));
+            (name === SERIALIZED_CONVERSION ||
+                (to.reach === "conversions" && CONVERSION_NAMES.has(name))));
     // The receiver reads only what the program wrote, so a data member holds while written.
-    const evidence = (id, flags, detail, site) => (flags & SymbolFlags.Property) !== 0 && !walked.initialized.has(id)
+    const evidence = (id, flags, detail, site) => (flags & SymbolFlags.Property) !== 0 && !sites.initialized.has(id)
         ? { id, detail, site, whileWritten: true }
         : { id, detail, site };
     const found = [];
@@ -1112,7 +1198,7 @@ function readTypes(project, values) {
         const parse = parses[at];
         const parsed = parse !== undefined && standard.has(parse);
         const type = valueTypes[at];
-        const untyped = type !== undefined && (type.flags & (TypeFlags.Any | TypeFlags.Unknown)) !== 0;
+        const untyped = type !== undefined && (type.flags & ERASED) !== 0;
         return parsed || untyped ? [{ ...readAs(value), parsed }] : [];
     });
     // Each type node and each outermost expression, with whether a `JSON.parse` call is read as it.