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

package/src/{serialization-contract.ts → exemptions/serialization-contract.ts}

@@ -8,14 +8,12 @@
  */
 
 import {
-  isArrayLiteralExpression,
   isArrowFunction,
   isAsExpression,
   isAwaitExpression,
   isCallExpression,
   isClassDeclaration,
   isClassExpression,
-  isClassStaticBlockDeclaration,
   isElementAccessExpression,
   isExpressionStatement,
   isFunctionDeclaration,
@@ -43,17 +41,14 @@ import {
   isTypeAssertion,
   isTypeLiteralNode,
   isVariableDeclaration,
-  ModifierFlags,
   NodeFlags,
   SyntaxKind,
   type CallExpression,
   type Expression,
   type Node,
-  type ParameterDeclaration,
   type SourceFile,
   type SpreadAssignment,
 } from "@typescript/native/ast";
-import { parenthesesRemoved } from "./unwrap.ts";
 import {
   SignatureKind,
   SymbolFlags,
@@ -63,36 +58,50 @@ import {
   type Symbol as TSSymbol,
   type Type,
 } from "@typescript/native/sync";
-import { aliasChains, type AliasChains } from "./alias-chain.ts";
-import { calleeName, resolvedTargets, valuesPassed } from "./calls.ts";
-import { classMembers, memberComponent, typesAt } from "./class-members.ts";
-import type { DeclarationEntry } from "./config.ts";
+import { aliasChains, type AliasChains } from "../alias-chain.ts";
+import { carriedValues, valuesOf } from "../index/values.ts";
+import { parenthesesRemoved } from "../unwrap.ts";
+import {
+  fills,
+  knownElements,
+  layoutOf,
+  placesIn,
+  spansOf,
+  type Layout,
+  type Placed,
+  type Span,
+} from "./argument-places.ts";
+import type { Invocation } from "./calls.ts";
+import { classMembers, memberComponent, typesAt } from "../class-members.ts";
+import type { DeclarationEntry } from "../config.ts";
 import {
   names,
   namesADeclaration,
   resolveEntries,
   spelledEntry,
-} from "./roots/configured-declarations.ts";
-import type { DetectorInput, Evidence } from "./exempt.ts";
-import { nodeKey, type Inventory } from "./inventory.ts";
-import { renderPosition, type Position } from "./position.ts";
-import { must, Unanswerable } from "./query.ts";
-import type { ProjectView } from "./session.ts";
+} from "../roots/configured-declarations.ts";
+import type { DetectorInput, Evidence } from "./lifecycle.ts";
+import type { Inventory } from "../inventory.ts";
+import { renderPosition, type Position } from "../position.ts";
+import { must, Unanswerable } from "../query.ts";
+import type { ProjectView } from "../session.ts";
 import { erasedStores, type ErasedStores } from "./erased-stores.ts";
-import { checkedTypes, CONVERSION_MEMBERS, valueReach, type Reached } from "./value-reach.ts";
+import type { CallSite, ParameterSite, ProjectSites } from "./sites.ts";
+import {
+  checkedTypes,
+  CONVERSION_MEMBERS,
+  CONVERSION_NAMES,
+  ERASED,
+  valueReach,
+  type Reached,
+} from "./value-reach.ts";
 
 /** The serializer every run reads, whatever the configuration names. */
 const JSON_STRINGIFY: DeclarationEntry = { global: "JSON.stringify" };
 
-/** The methods a serializer and a formatter resolve by name on a value that left the analysis. */
-const CONVERSIONS: ReadonlySet<string> = 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: ReadonlySet<string> = new Set(["Promise", "PromiseLike"]);
 
@@ -105,25 +114,10 @@ const MENTION_DEPTH = 3;
  */
 type Reach = "properties" | "conversions";
 
-/** One call of the project's own files, and the class `this` is a value of where it is written. */
-interface Site {
-  readonly call: CallExpression;
-  readonly self: string | undefined;
-}
-
-/** One parameter of a function of the project that may hand on what it is given. */
-interface Parameter {
-  /** The inventory's identifier of the function's declaration. */
-  readonly fn: string;
-  readonly index: number;
-  readonly rest: boolean;
-  readonly name: Node;
-}
-
 /** One place a function hands a parameter of its own to the argument of a call. */
 interface Forwarded {
-  readonly parameter: Parameter;
-  readonly site: Site;
+  readonly parameter: ParameterSite;
+  readonly site: CallSite;
   readonly argument: number;
 }
 
@@ -138,51 +132,6 @@ function wider(a: Reach | undefined, b: Reach | undefined): Reach | undefined {
   return a === "conversions" || b === "conversions" ? "conversions" : (a ?? b);
 }
 
-/** Whether one node declares a static member, whose `this` is the class itself. */
-function isStatic(node: Node): boolean {
-  const flags = (node as { readonly modifierFlags?: number }).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: Node): boolean {
-  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: Node,
-): { readonly declared: Node; readonly parameters: readonly ParameterDeclaration[] } | undefined {
-  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: ParameterDeclaration): boolean {
-  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: Expression): boolean {
   return (
@@ -195,137 +144,6 @@ function holdsNoInstance(argument: Expression): boolean {
   );
 }
 
-/** The expression an argument evaluates, through parentheses and a spread. */
-function evaluated(argument: Expression): Expression {
-  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: ReadonlySet<string> = new Set(["call", "apply", "bind"]);
-
-/** The interfaces of the standard library that declare those methods for a function value. */
-const FUNCTION_INTERFACES: ReadonlySet<string> = new Set([
-  "Function",
-  "CallableFunction",
-  "NewableFunction",
-]);
-
-/**
- * One call as the function it invokes sees it: the expression naming that function,
- * and the argument each of its parameters binds, in order.
- */
-interface Invocation {
-  readonly callee: Expression;
-  readonly arguments: readonly Expression[];
-  /** Whether the call reaches the callee through a method of `Function.prototype`. */
-  readonly indirect: boolean;
-}
-
-/** A call through a method of `Function.prototype`: the method's name and the invocation. */
-interface MethodForm {
-  readonly method: Node;
-  readonly invocation: Invocation;
-}
-
-/**
- * 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: CallExpression): MethodForm | undefined {
-  const expression = parenthesesRemoved(call.expression);
-  if (isPropertyAccessExpression(expression) && FUNCTION_METHODS.has(expression.name.text)) {
-    const [, ...rest] = call.arguments;
-    let passed: readonly Expression[] = 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;
-}
-
-/** What one walk of the project's own files found: its calls and its functions' parameters. */
-interface Walked {
-  readonly sites: readonly Site[];
-  readonly parameters: readonly Parameter[];
-  /** The class properties whose declaration writes an initializer, by identifier. */
-  readonly initialized: ReadonlySet<string>;
-}
-
-/**
- * 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<Brand>(project: ProjectView<Brand>, held: Inventory): Walked {
-  const sites: Site[] = [];
-  const parameters: Parameter[] = [];
-  const initialized = new Set<string>();
-  for (const file of project.ownSourceFiles()) {
-    const visit = (node: Node, self: string | undefined): void => {
-      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 as CallExpression, 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: ReadonlySet<string> = new Set([
   "keys",
@@ -354,12 +172,14 @@ function keepsNoName<Brand>(project: ProjectView<Brand>, type: Type): boolean {
 
 /**
  * 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<Brand>(
   project: ProjectView<Brand>,
-  parameters: readonly Parameter[],
-): ReadonlyMap<number, Parameter> {
+  parameters: readonly ParameterSite[],
+): ReadonlyMap<number, ParameterSite> {
   const types = typesAt(
     project,
     parameters.map((parameter) => parameter.name),
@@ -372,10 +192,16 @@ function erasedParameters<Brand>(
     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<number, Parameter>();
+  const bySymbol = new Map<number, ParameterSite>();
   project
     .symbolsAt(erased.map((parameter) => project.handle(parameter.name)))
     .map(must)
@@ -388,6 +214,15 @@ function erasedParameters<Brand>(
   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<Brand>(project: ProjectView<Brand>, signature: Signature): Type | undefined {
+  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: Node): boolean {
   return (
@@ -437,11 +272,11 @@ function namesWritten(fn: Node): ReadonlySet<string> {
  */
 function enumeratedParameters<Brand>(
   project: ProjectView<Brand>,
-  erased: ReadonlyMap<number, Parameter>,
-): readonly Parameter[] {
+  erased: ReadonlyMap<number, ParameterSite>,
+): readonly ParameterSite[] {
   const asked: {
     readonly node: Node;
-    readonly parameter: Parameter;
+    readonly parameter: ParameterSite;
     readonly object: Node | undefined;
   }[] = [];
   for (const parameter of erased.values()) {
@@ -472,7 +307,7 @@ function enumeratedParameters<Brand>(
       } 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 });
         }
@@ -509,17 +344,20 @@ function enumeratedParameters<Brand>(
 /** Each place a call's argument passes one of the erased parameters it can see. */
 function handedOn<Brand>(
   project: ProjectView<Brand>,
-  sites: readonly Site[],
-  erased: ReadonlyMap<number, Parameter>,
-  invocationOf: (call: CallExpression) => Invocation,
+  sites: ProjectSites,
+  erased: ReadonlyMap<number, ParameterSite>,
 ): readonly Forwarded[] {
   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);
@@ -566,12 +404,12 @@ function implementedOwners<Brand>(
         (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);
       }
@@ -603,9 +441,14 @@ function implementedOwners<Brand>(
 /** The destination of each call's arguments, with the project's forwarding functions settled. */
 interface Destinations {
   /** The function one call invokes and the arguments its parameters bind. */
-  invocation(call: CallExpression): Invocation;
-  /** The destination one argument of one call is, if it is one. */
-  at(call: CallExpression, argument: number): Destination | undefined;
+  readonly invocation: (call: CallExpression) => Invocation;
+  /** The signatures each call binds. */
+  readonly bindings: Bindings;
+  /**
+   * The destination one argument of one call is, if it is one; with `element`, the
+   * destination of that element of a spread of known length, at the one place it fills.
+   */
+  at(call: CallExpression, argument: number, element?: number): Destination | undefined;
   /** Whether a call can be a destination at any argument, read without a round trip. */
   mayReceive(call: CallExpression): boolean;
 }
@@ -618,33 +461,16 @@ interface Destinations {
  * 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<Brand>(
-  input: DetectorInput<Brand>,
-  chains: AliasChains,
-  walked: Walked,
-): Destinations {
-  const { project, held } = input;
+function destinations<Brand>(input: DetectorInput<Brand>, chains: AliasChains): Destinations {
+  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<CallExpression, MethodForm>();
-  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 byFunction = new Map<string, Parameter[]>();
+  const { of: invocation, callee: calleeOf } = sites.invocations;
+  const erased = erasedParameters(project, sites.parameters);
+  const byFunction = new Map<string, ParameterSite[]>();
   for (const parameter of erased.values()) {
     byFunction.set(parameter.fn, [...(byFunction.get(parameter.fn) ?? []), parameter]);
   }
@@ -685,39 +511,16 @@ function destinations<Brand>(
    */
   const mayBeOutside = (target: TSSymbol): boolean =>
     target.declarations.some((handle) => outside(target, false, [handle]));
-  const invocation = (call: CallExpression): Invocation => {
-    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: CallExpression): TSSymbol | undefined => {
-    const name = calleeName(invocation(call).callee);
-    return name === undefined ? undefined : callees.get(name);
-  };
-  const signatures = new Map<CallExpression, Signature | undefined>();
-  const resolvedOf = (call: CallExpression): Signature | undefined => {
-    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: CallExpression, target: TSSymbol): readonly NodeHandle[] => {
-    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) {
@@ -754,61 +557,125 @@ function destinations<Brand>(
     ];
     return inner.some((one) => mentions(one, parameter, depth + 1));
   };
-  const erasedArguments = new Map<CallExpression, ReadonlySet<number>>();
-  const erasedAt = (call: CallExpression, argument: number): boolean => {
-    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: number): boolean => {
-        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<CallExpression, ReadonlySet<string>>();
+  /**
+   * 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: CallExpression, argument: number, element?: number): boolean => {
+    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: Type): boolean => {
+        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: Type, result: Type | undefined): boolean => {
+        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: Signature | undefined, placed: Placed): boolean => {
+        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<string>();
+      const placedAt = new Set<string>();
+      const unplaced = new Map<string, number>();
+      for (const one of bindings.of(call)) {
+        const asked = new Set<string>();
+        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<string, Reach>();
-  const keyOf = (parameter: Parameter): string => `${parameter.fn}\u0000${String(parameter.index)}`;
-  const at = (call: CallExpression, argument: number): Destination | undefined => {
+  const keyOf = (parameter: ParameterSite): string =>
+    `${parameter.fn}\u0000${String(parameter.index)}`;
+  const at = (
+    call: CallExpression,
+    argument: number,
+    element?: number,
+  ): Destination | undefined => {
     const target = calleeOf(call);
     if (target === undefined) {
       return undefined;
@@ -818,18 +685,21 @@ function destinations<Brand>(
       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<Reach | undefined>(
+          (widest, one) => wider(widest, forwards.get(keyOf(one))),
+          undefined,
+        );
       if (reach !== undefined) {
         return { reach, callee: held.symbols.find((symbol) => symbol.id === fn)?.name ?? fn };
       }
@@ -840,7 +710,7 @@ function destinations<Brand>(
   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) {
@@ -866,7 +736,7 @@ function destinations<Brand>(
       .declarationsOf(target)
       .some((fn) => (byFunction.get(fn) ?? []).some((parameter) => forwards.has(keyOf(parameter))));
   };
-  return { invocation, at, mayReceive };
+  return { invocation, bindings, at, mayReceive };
 }
 
 /** One value that carries classes and object types of the target into a destination. */
@@ -889,17 +759,20 @@ function joined(a: Reached, b: Reached): Reached {
 function flowsOf<Brand>(
   project: ProjectView<Brand>,
   held: Inventory,
-  sites: readonly Site[],
+  sites: readonly CallSite[],
   to: Destinations,
   stores: ErasedStores,
 ): readonly Flow[] {
   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);
@@ -914,45 +787,91 @@ function flowsOf<Brand>(
     project,
     arguments_.map((one) => one.value),
   );
-  const passed = arguments_.flatMap((one, index) => {
-    const type = typeOf.get(one.value);
-    let reached: Reached = { classes: new Set<string>(), 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: (typeof arguments_)[number],
+    types: readonly Type[],
+  ): readonly { readonly element: number | undefined; readonly types: readonly Type[] }[] => {
+    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: Type[] = [];
+    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: Reached = {
+      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<Reached>(
+        (all, part) => joined(all, reach.reachedFrom(part)),
+        element === undefined ? self : { classes: new Set<string>(), 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,
+    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) => {
@@ -972,10 +891,14 @@ function flowsOf<Brand>(
   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<Brand>(project: ProjectView<Brand>, type: Type, depth: number): Type[] {
   if (type.isTypeParameter()) {
-    return [type];
+    return type.isThisType === true ? [] : [type];
   }
   if (depth >= MENTION_DEPTH) {
     return [];
@@ -984,6 +907,7 @@ function typeParametersOf<Brand>(project: ProjectView<Brand>, type: 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));
 }
 
@@ -1039,6 +963,11 @@ function bound<Brand>(
     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)) {
@@ -1059,6 +988,223 @@ function bound<Brand>(
       });
 }
 
+/** A declared type at a place and the type a call puts there. */
+interface Placing {
+  readonly from: Type;
+  readonly into: Type;
+}
+
+/**
+ * One signature a call binds its arguments to: the one the checker resolves for a direct
+ * call, and each call signature of the value the method is read from for one through
+ * `call`, `apply` or `bind`, whose resolved signature is the method's.
+ */
+interface Binding {
+  readonly call: CallExpression;
+  /** The signature whose parameter types the arguments meet. */
+  readonly signature: Signature;
+  /** The generic signature the call instantiates: the resolved one's, or the callee's own. */
+  readonly declared: Signature | undefined;
+  /** The parameter place each argument binds in `signature`. */
+  readonly placed: () => readonly Placed[];
+  /**
+   * The declared and the instantiated type at each place an argument binds, and an open
+   * rest's element type.
+   */
+  readonly places: () => readonly Placing[];
+  /** The type arguments the call writes for the declared signature, if it writes them. */
+  readonly written: readonly Node[] | undefined;
+}
+
+/** The signatures each call binds, each call read once. */
+interface Bindings {
+  of(call: CallExpression): readonly Binding[];
+  /** Those of every call, asked of the checker in batches. */
+  all(calls: readonly CallExpression[]): readonly Binding[];
+  /** The places each argument of one call fills, read as `argument-places.ts` reads them. */
+  spans(call: CallExpression): readonly Span[];
+}
+
+/** One value read once, at its first use. */
+function once<T>(read: () => T): () => T {
+  let held: { readonly value: T } | undefined;
+  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<Brand>(
+  project: ProjectView<Brand>,
+  invocation: (call: CallExpression) => Invocation,
+): Bindings {
+  const { queries } = project;
+  const known = new Map<CallExpression, readonly Binding[]>();
+  const passed = new Map<CallExpression, readonly (Type | undefined)[]>();
+  const spanned = new Map<CallExpression, readonly Span[]>();
+  const layouts = new Map<number, Layout>();
+  const valueOf = (argument: Expression): Expression =>
+    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: CallExpression): boolean => {
+    const invoked = invocation(call);
+    return invoked.indirect || invoked.arguments.some(isSpreadElement);
+  };
+  const typesPassed = (call: CallExpression): readonly (Type | undefined)[] => {
+    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: CallExpression): readonly Span[] => {
+    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: Signature): Layout => {
+    let found = layouts.get(signature.id);
+    if (found === undefined) {
+      found = layoutOf(project, signature);
+      layouts.set(signature.id, found);
+    }
+    return found;
+  };
+  const distinct = (pairs: readonly Placing[]): readonly Placing[] => [
+    ...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: Type, value: Type | undefined): readonly Placing[] =>
+    value === undefined
+      ? []
+      : must(queries.constituents(from)).flatMap((part) =>
+          must(queries.mappedParametersOf(part)).map((source) => ({ from: source, into: value })),
+        );
+  const direct = (call: CallExpression, resolved: Signature | undefined): readonly Binding[] => {
+    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: CallExpression, callee: Type | undefined): readonly Binding[] =>
+    (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: CallExpression): readonly Binding[] => {
+    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: readonly CallExpression[]): readonly Binding[] => {
+    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,
@@ -1068,68 +1214,56 @@ function bound<Brand>(
 function typeParameterFlows<Brand>(
   project: ProjectView<Brand>,
   reach: ReturnType<typeof valueReach>,
-  sites: readonly Site[],
+  sites: readonly CallSite[],
+  bindings: Bindings,
   pending: { readonly parameter: Type; readonly to: Destination }[],
 ): readonly Flow[] {
   const { queries } = project;
-  const byName = new Map<string, Site[]>();
-  for (const site of sites) {
-    const name = calleeName(site.call.expression)?.getText();
-    if (name !== undefined) {
-      byName.set(name, [...(byName.get(name) ?? []), site]);
+  let calls: ReadonlyMap<Node, readonly Binding[]> | undefined;
+  const byDeclaration = (): ReadonlyMap<Node, readonly Binding[]> => {
+    const found = new Map<Node, Binding[]>();
+    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: Flow[] = [];
-  const seen = new Set<number>();
+  // One type parameter reaches each of its destinations, each holding back its own.
+  const seen = new Set<string>();
   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,
@@ -1150,14 +1284,13 @@ function typeParameterFlows<Brand>(
  * the callee named.
  */
 export function serializationContract<Brand>(input: DetectorInput<Brand>): readonly Evidence[] {
-  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),
+    sites.calls,
+    destinations(input, chains),
     erasedStores(project),
   );
   if (flows.length === 0) {
@@ -1175,10 +1308,11 @@ export function serializationContract<Brand>(input: DetectorInput<Brand>): reado
   const holdsBack = (flags: SymbolFlags, name: string, to: Destination): boolean =>
     (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: string, flags: SymbolFlags, detail: string, site: Position): Evidence =>
-    (flags & SymbolFlags.Property) !== 0 && !walked.initialized.has(id)
+    (flags & SymbolFlags.Property) !== 0 && !sites.initialized.has(id)
       ? { id, detail, site, whileWritten: true }
       : { id, detail, site };
   const found: Evidence[] = [];
@@ -1489,7 +1623,7 @@ function readTypes<Brand>(
     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.