@cplieger/deadset-ts 6.1.1-dev.1 → 7.0.0-dev.2

package/src/indexed-access.ts

@@ -1,34 +1,46 @@
 /**
- * The members an indexed-access type names. `T["a" | "b"]` reads the members `a` and `b`
- * of `T` as a property access by either name would. Where the index is a type parameter
- * a call fixes, the call names the members the literal type argument names, written or
- * inferred, which is read off the parameter the type parameter annotates whole. The type
- * query of a type-query alias is no reference.
+ * The members an indexed-access type names: `T["a" | "b"]` reads `a` and `b` of `T`. An
+ * index naming a type parameter is read once the reference or the call holding it fixes
+ * that parameter, and a call of a method of a generic receiver fixes the receiver's by its
+ * type arguments. The type query of a type-query alias is no reference.
  */
 
 import {
   isArrowFunction,
   isCallExpression,
+  isClassDeclaration,
+  isClassExpression,
   isFunctionDeclaration,
   isFunctionExpression,
   isIdentifier,
+  isNonNullExpression,
+  isParenthesizedExpression,
+  isNamedImports,
+  isNamespaceImport,
+  isImportDeclaration,
   isIndexedAccessTypeNode,
+  isInterfaceDeclaration,
   isLiteralTypeNode,
   isMethodDeclaration,
+  isMethodSignatureDeclaration,
   isNewExpression,
   isNoSubstitutionTemplateLiteral,
   isNumericLiteral,
   isParenthesizedTypeNode,
   isPropertyAccessExpression,
   isStringLiteral,
+  isTypeAliasDeclaration,
   isTypeReferenceNode,
   isUnionTypeNode,
-  SyntaxKind,
+  isVariableDeclaration,
+  type CallExpression,
+  type NewExpression,
   type Node,
   type SourceFile,
   type TypeNode,
+  type TypeReferenceNode,
 } from "@typescript/native/unstable/ast";
-import type { Type } from "@typescript/native/unstable/sync";
+import { SymbolFlags, type Symbol as TSSymbol, type Type } from "@typescript/native/unstable/sync";
 import type { AliasChains } from "./alias-chain.ts";
 import { nodeKey, type Inventory } from "./inventory.ts";
 import { renderPosition } from "./position.ts";
@@ -37,22 +49,32 @@ import type { Reference } from "./references.ts";
 import type { ProjectView } from "./session.ts";
 import { typeQueryAliases } from "./type-query-alias.ts";
 
-/** A function whose signature declares type parameters, by the kinds of node that can. */
+/** A declaration that declares type parameters, by the kinds of node that can. */
 type Generic = Node & {
   readonly typeParameters?: readonly { readonly name: Node }[];
-  readonly parameters: readonly { readonly name: Node; readonly type?: TypeNode }[];
+  readonly parameters?: readonly { readonly name: Node; readonly type?: TypeNode }[];
 };
 
 function isGeneric(node: Node): node is Generic {
   return (
     (isFunctionDeclaration(node) ||
       isMethodDeclaration(node) ||
+      isMethodSignatureDeclaration(node) ||
       isArrowFunction(node) ||
-      isFunctionExpression(node)) &&
+      isFunctionExpression(node) ||
+      isTypeAliasDeclaration(node) ||
+      isInterfaceDeclaration(node) ||
+      isClassDeclaration(node) ||
+      isClassExpression(node)) &&
     (node as { readonly typeParameters?: readonly unknown[] }).typeParameters !== undefined
   );
 }
 
+/** Whether one generic is a receiver's: a class or an interface whose methods it parameterizes. */
+function isReceiver(node: Node): boolean {
+  return isInterfaceDeclaration(node) || isClassDeclaration(node) || isClassExpression(node);
+}
+
 function unwrappedType(node: TypeNode): TypeNode {
   return isParenthesizedTypeNode(node) ? unwrappedType(node.type) : node;
 }
@@ -92,25 +114,150 @@ function literalTypeNames(
   return names;
 }
 
-/** One indexed-access type whose index is a type parameter its function declares. */
-interface ByParameter {
-  readonly object: TypeNode;
-  /** The index of the parameter the type parameter annotates whole. */
-  readonly parameter: number;
+/**
+ * One side of an indexed access inside a generic, as a site of the generic fixes it: the
+ * type parameter of that position, a type the generic writes, or a type parameter of the
+ * receiver whose method the generic is.
+ */
+type Side =
+  | { readonly kind: "parameter"; readonly index: number }
+  | { readonly kind: "written"; readonly node: TypeNode }
+  | { readonly kind: "receiver"; readonly index: number };
+
+/** An indexed access inside one generic whose index names a type parameter. */
+interface Carried {
+  readonly object: Side;
+  readonly index: Side;
 }
 
-/** An indexed access to resolve: the object type, the names, and where the reference is made. */
+/** A side a site has fixed: a type node it writes, a type the compiler answers, or a type parameter it passes on. */
+type Fixed =
+  | { readonly kind: "node"; readonly node: TypeNode }
+  | { readonly kind: "type"; readonly type: Type }
+  | { readonly kind: "passed"; readonly generic: Generic; readonly index: number };
+
+/** An indexed access to resolve: the object type, the index, and where the reference is made. */
 interface Access {
   readonly file: SourceFile;
   readonly from: string;
   readonly at: Node;
   readonly object: TypeNode | Type;
-  readonly names: readonly string[];
+  /** The names a literal index spells, or the index to read as a type. */
+  readonly index: readonly string[] | TypeNode | Type;
+}
+
+/** A reference or a call that may fix a generic's type parameters. */
+interface Site {
+  readonly file: SourceFile;
+  readonly from: string;
+  readonly node: TypeReferenceNode | CallExpression | NewExpression;
+  readonly name: string;
+  readonly enclosing: readonly Generic[];
+}
+
+/** The type a fixed side stands for, or none where the site passes it on. */
+function concrete(fixed: Fixed): TypeNode | Type | undefined {
+  return fixed.kind === "node" ? fixed.node : fixed.kind === "type" ? fixed.type : undefined;
+}
+
+/** The position of the type parameter `name` among the ones a generic declares, or -1. */
+function parameterAt(generic: Generic, name: string): number {
+  return (generic.typeParameters ?? []).findIndex(
+    (parameter) => isIdentifier(parameter.name) && parameter.name.text === name,
+  );
+}
+
+/** The type parameter one type node names whole, among the enclosing generics, innermost first. */
+function namedParameter(
+  node: TypeNode,
+  enclosing: readonly Generic[],
+): { readonly generic: Generic; readonly index: number } | undefined {
+  const type = unwrappedType(node);
+  if (
+    !isTypeReferenceNode(type) ||
+    !isIdentifier(type.typeName) ||
+    type.typeArguments !== undefined
+  ) {
+    return undefined;
+  }
+  const spelled = type.typeName.text;
+  for (const generic of [...enclosing].reverse()) {
+    const index = parameterAt(generic, spelled);
+    if (index >= 0) {
+      return { generic, index };
+    }
+  }
+  return undefined;
+}
+
+/** The name a site writes to reach one generic: its own, or its variable's. */
+function calledName(generic: Generic): string | undefined {
+  const own = (generic as { readonly name?: Node }).name;
+  if (own !== undefined && isIdentifier(own)) {
+    return own.text;
+  }
+  const parent = generic.parent as Node | undefined;
+  return parent !== undefined && isVariableDeclaration(parent) && isIdentifier(parent.name)
+    ? parent.name.text
+    : undefined;
+}
+
+/** The generic a declaration a symbol names is: the function a variable is initialized with included. */
+function genericOf(node: Node): Generic | undefined {
+  if (isGeneric(node)) {
+    return node;
+  }
+  if (
+    isVariableDeclaration(node) &&
+    node.initializer !== undefined &&
+    isGeneric(node.initializer)
+  ) {
+    return node.initializer;
+  }
+  return undefined;
+}
+
+/**
+ * Each indexed access inside one generic whose index names a type parameter of it, read
+ * from its own text: the object side is a type parameter of the same generic, one of the
+ * receiver it is a method of, or a type it writes.
+ */
+function carriedIn(generic: Generic): readonly Carried[] {
+  const found: Carried[] = [];
+  const receiver = generic.parent as Node | undefined;
+  const outer =
+    receiver !== undefined && isReceiver(receiver) && isGeneric(receiver) ? receiver : undefined;
+  const visit = (node: Node): void => {
+    if (isIndexedAccessTypeNode(node)) {
+      const index = namedParameter(node.indexType, [generic]);
+      if (index !== undefined) {
+        const own = namedParameter(node.objectType, [generic]);
+        const fromReceiver =
+          own === undefined && outer !== undefined
+            ? namedParameter(node.objectType, [outer])
+            : undefined;
+        const object: Side =
+          own !== undefined
+            ? { kind: "parameter", index: own.index }
+            : fromReceiver !== undefined
+              ? { kind: "receiver", index: fromReceiver.index }
+              : { kind: "written", node: node.objectType };
+        found.push({ object, index: { kind: "parameter", index: index.index } });
+      }
+    }
+    if (node !== generic && isGeneric(node)) {
+      return;
+    }
+    node.forEachChild(visit);
+  };
+  visit(generic);
+  return found;
 }
 
 /**
  * The references the indexed-access types of one project's own files make to the members
- * they name, each made by the declaration that holds the type or the call, or by the file.
+ * they name, each made by the declaration that holds the type, the reference or the call,
+ * or by the file.
  */
 export function indexedAccessReferences<Brand>(
   project: ProjectView<Brand>,
@@ -121,9 +268,30 @@ export function indexedAccessReferences<Brand>(
 ): readonly Reference[] {
   const queries = project.queries;
   const accesses: Access[] = [];
-  const generics = new Map<string, ByParameter[]>();
-  const calls: { file: SourceFile; from: string; call: Node; name: string }[] = [];
+  const carried = new Map<Generic, Carried[]>();
   const names = new Set<string>();
+  const sites: Site[] = [];
+  /**
+   * Calls passing a literal argument whose callee a package binding heads, or that call a
+   * method, which a dependency's generic may fix.
+   */
+  const literalCalls: Site[] = [];
+
+  const carry = (generic: Generic, one: Carried): boolean => {
+    const known = carried.get(generic) ?? [];
+    const same = known.some(
+      (other) => JSON.stringify(sideKey(other)) === JSON.stringify(sideKey(one)),
+    );
+    if (same) {
+      return false;
+    }
+    carried.set(generic, [...known, one]);
+    const name = calledName(generic);
+    if (name !== undefined) {
+      names.add(name);
+    }
+    return true;
+  };
 
   for (const file of project.ownSourceFiles()) {
     const fileId = held.declarations.get(nodeKey(file, file));
@@ -131,18 +299,27 @@ export function indexedAccessReferences<Brand>(
       continue;
     }
     const aliasTypes = new Set(typeQueryAliases(file).map((alias) => alias.type));
+    const imported = packageBindings(file);
     const visit = (node: Node, from: string, enclosing: readonly Generic[]): void => {
       const own = held.declarations.get(nodeKey(file, node));
       const holder = own ?? from;
       const inside = isGeneric(node) ? [...enclosing, node] : enclosing;
+      if (isGeneric(node)) {
+        carriedIn(node).forEach((one) => carry(node, one));
+      }
       if (isIndexedAccessTypeNode(node) && !aliasTypes.has(node)) {
         const literal = literalNames(node.indexType);
         if (literal !== undefined) {
-          accesses.push({ file, from: holder, at: node, object: node.objectType, names: literal });
-        } else {
-          parameterIndex(node, inside, file, generics, names);
+          accesses.push({ file, from: holder, at: node, object: node.objectType, index: literal });
         }
       }
+      if (
+        isTypeReferenceNode(node) &&
+        node.typeArguments !== undefined &&
+        isIdentifier(node.typeName)
+      ) {
+        sites.push({ file, from: holder, node, name: node.typeName.text, enclosing: inside });
+      }
       if (isCallExpression(node) || isNewExpression(node)) {
         const callee = node.expression;
         const name = isIdentifier(callee)
@@ -151,7 +328,20 @@ export function indexedAccessReferences<Brand>(
             ? callee.name.text
             : undefined;
         if (name !== undefined) {
-          calls.push({ file, from: holder, call: node, name });
+          const site = { file, from: holder, node, name, enclosing: inside };
+          sites.push(site);
+          const literal = (node.arguments ?? []).some(
+            (argument) => isStringLiteral(argument) || isNumericLiteral(argument),
+          );
+          const head = rootName(callee);
+          const method = isPropertyAccessExpression(callee);
+          if (
+            literal &&
+            isCallExpression(node) &&
+            (method || (head !== undefined && imported.has(head)))
+          ) {
+            literalCalls.push(site);
+          }
         }
       }
       node.forEachChild((child) => {
@@ -163,50 +353,220 @@ export function indexedAccessReferences<Brand>(
     });
   }
 
-  for (const { file, from, call, name } of calls) {
-    if (!names.has(name)) {
-      continue;
-    }
-    const resolved = queries.resolvedSignature(call);
-    if (resolved === UNANSWERED || resolved?.declaration === undefined) {
-      continue;
+  function partsOf(type: Type): readonly Type[] {
+    const parts = queries.constituents(type);
+    return parts === UNANSWERED ? [type] : parts;
+  }
+
+  /** The generics one symbol declares, through the alias it may be. */
+  const genericsOf = (symbol: TSSymbol): readonly Generic[] => {
+    const target = (symbol.flags & SymbolFlags.Alias) === 0 ? symbol : queries.aliased(symbol);
+    if (target === UNANSWERED) {
+      return [];
     }
-    const declaration = project.declarationAt(resolved.declaration)?.node;
-    const byParameter =
-      declaration === undefined
-        ? undefined
-        : generics.get(nodeKey(declaration.getSourceFile(), declaration));
-    if (byParameter === undefined) {
-      continue;
+    return target.declarations.flatMap((handle) => {
+      const node = project.declarationAt(handle)?.node;
+      const generic = node === undefined ? undefined : genericOf(node);
+      return generic === undefined ? [] : [generic];
+    });
+  };
+
+  /** What one site fixes for one side of a carried access. */
+  const fixedAt = (site: Site, side: Side, generic: Generic): Fixed | undefined => {
+    if (side.kind === "written") {
+      return { kind: "node", node: side.node };
     }
-    for (const { object, parameter } of byParameter) {
-      const fixed = queries.typeAtPosition(resolved, parameter);
-      const literal =
-        fixed === UNANSWERED ? undefined : literalTypeNames(fixed, (type) => partsOf(type));
-      if (literal !== undefined) {
-        accesses.push({ file, from, at: call, object, names: literal });
+    const { node } = site;
+    if (side.kind === "receiver") {
+      const callee = isCallExpression(node) ? node.expression : undefined;
+      if (callee === undefined || !isPropertyAccessExpression(callee)) {
+        return undefined;
+      }
+      const receiver = queries.typeAt(callee.expression);
+      if (receiver === UNANSWERED || receiver === undefined) {
+        return undefined;
       }
+      const args = queries.typeArguments(receiver);
+      const type = args === UNANSWERED ? undefined : args[side.index];
+      return type === undefined ? undefined : { kind: "type", type };
     }
-  }
+    const written = node.typeArguments?.[side.index];
+    if (written !== undefined) {
+      const passed = namedParameter(written, site.enclosing);
+      return passed === undefined
+        ? { kind: "node", node: written }
+        : { kind: "passed", generic: passed.generic, index: passed.index };
+    }
+    if (isTypeReferenceNode(node)) {
+      return undefined;
+    }
+    const at = (generic.parameters ?? []).findIndex((parameter) => {
+      const type = parameter.type === undefined ? undefined : unwrappedType(parameter.type);
+      return (
+        type !== undefined &&
+        isTypeReferenceNode(type) &&
+        isIdentifier(type.typeName) &&
+        parameterAt(generic, type.typeName.text) === side.index
+      );
+    });
+    if (at < 0) {
+      return undefined;
+    }
+    const resolved = queries.resolvedSignature(node);
+    if (resolved === UNANSWERED || resolved === undefined) {
+      return undefined;
+    }
+    const type = queries.typeAtPosition(resolved, at);
+    return type === UNANSWERED ? undefined : { kind: "type", type };
+  };
 
-  function partsOf(type: Type): readonly Type[] {
-    const parts = queries.constituents(type);
-    return parts === UNANSWERED ? [type] : parts;
+  /** Reads one carried access at one site: an access where both sides are fixed, a carry where one is passed on. */
+  const readAt = (site: Site, generic: Generic, one: Carried): boolean => {
+    const object = fixedAt(site, one.object, generic);
+    const index = object === undefined ? undefined : fixedAt(site, one.index, generic);
+    if (object === undefined || index === undefined) {
+      return false;
+    }
+    const passed = [object, index].find((fixed) => fixed.kind === "passed");
+    if (passed !== undefined) {
+      const side = (fixed: Fixed): Side | undefined =>
+        fixed.kind === "passed"
+          ? fixed.generic === passed.generic
+            ? { kind: "parameter", index: fixed.index }
+            : undefined
+          : fixed.kind === "node"
+            ? { kind: "written", node: fixed.node }
+            : undefined;
+      const objectSide = side(object);
+      const indexSide = side(index);
+      return objectSide !== undefined && indexSide !== undefined
+        ? carry(passed.generic, { object: objectSide, index: indexSide })
+        : false;
+    }
+    const objectAt = concrete(object);
+    const indexAt = concrete(index);
+    if (objectAt === undefined || indexAt === undefined) {
+      return false;
+    }
+    accesses.push({
+      file: site.file,
+      from: site.from,
+      at: site.node,
+      object: objectAt,
+      index: "kind" in indexAt ? (literalNames(indexAt) ?? indexAt) : indexAt,
+    });
+    return false;
+  };
+
+  // A site passing a type parameter on carries the access to its own generic, so the
+  // sites are read again until no generic gains an access.
+  const resolvedGenerics = new Map<Site, readonly Generic[]>();
+  const read = new Set<string>();
+  for (let changed = true; changed;) {
+    changed = false;
+    const pending = sites.filter((site) => names.has(site.name) && !resolvedGenerics.has(site));
+    const typeSites = pending.filter((site) => isTypeReferenceNode(site.node));
+    const symbols =
+      typeSites.length === 0
+        ? []
+        : queries.symbolsAt(typeSites.map((site) => (site.node as TypeReferenceNode).typeName));
+    typeSites.forEach((site, at) => {
+      const symbol = symbols[at];
+      resolvedGenerics.set(
+        site,
+        symbol === UNANSWERED || symbol === undefined ? [] : genericsOf(symbol),
+      );
+    });
+    for (const site of pending.filter((one) => !isTypeReferenceNode(one.node))) {
+      const resolved = queries.resolvedSignature(site.node);
+      const declaration =
+        resolved === UNANSWERED || resolved?.declaration === undefined
+          ? undefined
+          : project.declarationAt(resolved.declaration)?.node;
+      const generic = declaration === undefined ? undefined : genericOf(declaration);
+      resolvedGenerics.set(site, generic === undefined ? [] : [generic]);
+    }
+    sites.forEach((site, siteAt) => {
+      for (const generic of resolvedGenerics.get(site) ?? []) {
+        (carried.get(generic) ?? []).forEach((one, at) => {
+          const key = `${String(siteAt)}:${String(at)}:${nodeKey(generic.getSourceFile(), generic)}`;
+          if (read.has(key)) {
+            return;
+          }
+          read.add(key);
+          changed = readAt(site, generic, one) || changed;
+        });
+      }
+    });
   }
 
-  const objectNodes = accesses.flatMap((one) => ("kind" in one.object ? [one.object] : []));
+  // A generic function or method declared outside the project's own files carries what
+  // its own text indexes by its type parameters and its receiver's.
+  const outside = literalCalls.filter((site) => !resolvedGenerics.has(site));
+  const methods =
+    outside.length === 0
+      ? []
+      : queries.symbolsAt(
+          outside.map((site) => {
+            const callee = (site.node as CallExpression).expression;
+            return isPropertyAccessExpression(callee) ? callee.name : callee;
+          }),
+        );
+  const own = project.ownPaths();
+  outside.forEach((site, at) => {
+    const named = methods[at];
+    const symbol =
+      named === UNANSWERED || named === undefined || (named.flags & SymbolFlags.Alias) === 0
+        ? named
+        : queries.aliased(named);
+    if (
+      symbol === UNANSWERED ||
+      symbol === undefined ||
+      (symbol.flags & (SymbolFlags.Function | SymbolFlags.Method)) === 0
+    ) {
+      return;
+    }
+    for (const handle of symbol.declarations) {
+      if (own.has(handle.path)) {
+        continue;
+      }
+      const node = project.declarationAt(handle)?.node;
+      const generic = node === undefined ? undefined : genericOf(node);
+      if (generic === undefined) {
+        continue;
+      }
+      for (const one of carriedIn(generic)) {
+        readAt(site, generic, one);
+      }
+    }
+  });
+
+  const typeNodes = accesses.flatMap((one) => [
+    ...("kind" in one.object ? [one.object] : []),
+    ...(!Array.isArray(one.index) && "kind" in one.index ? [one.index] : []),
+  ]);
   const typeOf = new Map<Node, Type>();
-  queries.typesAt(objectNodes).forEach((answer, index) => {
-    const node = objectNodes[index];
+  queries.typesAt(typeNodes).forEach((answer, index) => {
+    const node = typeNodes[index];
     if (answer !== UNANSWERED && answer !== undefined && node !== undefined) {
       typeOf.set(node, answer);
     }
   });
+  const asType = (side: TypeNode | Type): Type | undefined =>
+    "kind" in side ? typeOf.get(side) : side;
 
   const found: Reference[] = [];
   for (const access of accesses) {
-    const type = "kind" in access.object ? typeOf.get(access.object) : access.object;
-    if (type === undefined) {
+    const type = asType(access.object);
+    const indexType = Array.isArray(access.index)
+      ? undefined
+      : asType(access.index as TypeNode | Type);
+    const accessed = Array.isArray(access.index)
+      ? (access.index as readonly string[])
+      : indexType === undefined
+        ? undefined
+        : literalTypeNames(indexType, partsOf);
+    if (type === undefined || accessed === undefined) {
       continue;
     }
     const position = renderPosition(access.file, root, access.at.getStart());
@@ -216,7 +576,7 @@ export function indexedAccessReferences<Brand>(
         continue;
       }
       for (const property of properties) {
-        if (!access.names.includes(property.escapedName)) {
+        if (!accessed.includes(property.escapedName)) {
           continue;
         }
         for (const to of chains.declarationsOf(property)) {
@@ -236,60 +596,74 @@ export function indexedAccessReferences<Brand>(
 }
 
 /**
- * Records an indexed-access type whose index names a type parameter of an enclosing
- * function that a parameter of that function is annotated with whole, so a call's
- * argument for that parameter fixes the index.
+ * The local names one file binds to a package: each name an import declaration with a
+ * bare specifier binds, and each variable initialized by a call or a construction whose
+ * callee such a name heads, read in source order.
  */
-function parameterIndex(
-  node: Node & { readonly objectType: TypeNode; readonly indexType: TypeNode },
-  enclosing: readonly Generic[],
-  file: SourceFile,
-  generics: Map<string, ByParameter[]>,
-  names: Set<string>,
-): void {
-  const index = unwrappedType(node.indexType);
-  if (!isTypeReferenceNode(index) || !isIdentifier(index.typeName)) {
-    return;
-  }
-  const spelled = index.typeName.text;
-  for (const generic of [...enclosing].reverse()) {
-    const declares = (generic.typeParameters ?? []).some(
-      (parameter) => isIdentifier(parameter.name) && parameter.name.text === spelled,
-    );
-    if (!declares) {
+function packageBindings(file: SourceFile): ReadonlySet<string> {
+  const names = new Set<string>();
+  for (const statement of file.statements) {
+    if (
+      !isImportDeclaration(statement) ||
+      !isStringLiteral(statement.moduleSpecifier) ||
+      /^[./]/u.test(statement.moduleSpecifier.text)
+    ) {
       continue;
     }
-    const at = generic.parameters.findIndex((parameter) => {
-      const type = parameter.type === undefined ? undefined : unwrappedType(parameter.type);
-      return (
-        type !== undefined &&
-        isTypeReferenceNode(type) &&
-        isIdentifier(type.typeName) &&
-        type.typeName.text === spelled
-      );
-    });
-    if (at >= 0) {
-      const key = nodeKey(file, generic);
-      generics.set(key, [...(generics.get(key) ?? []), { object: node.objectType, parameter: at }]);
-      const name = calledName(generic);
-      if (name !== undefined) {
-        names.add(name);
-      }
+    const clause = statement.importClause;
+    if (clause?.name !== undefined) {
+      names.add(clause.name.text);
+    }
+    const bindings = clause?.namedBindings;
+    if (bindings !== undefined && isNamespaceImport(bindings)) {
+      names.add(bindings.name.text);
+    } else if (bindings !== undefined && isNamedImports(bindings)) {
+      bindings.elements.forEach((element) => names.add(element.name.text));
     }
-    return;
   }
+  if (names.size === 0) {
+    return names;
+  }
+  const visit = (node: Node): void => {
+    if (
+      isVariableDeclaration(node) &&
+      isIdentifier(node.name) &&
+      node.initializer !== undefined &&
+      (isCallExpression(node.initializer) || isNewExpression(node.initializer))
+    ) {
+      const head = rootName(node.initializer.expression);
+      if (head !== undefined && names.has(head)) {
+        names.add(node.name.text);
+      }
+    }
+    node.forEachChild(visit);
+  };
+  visit(file);
+  return names;
 }
 
-/** The name a call writes to call one generic function: its own, or its variable's. */
-function calledName(generic: Generic): string | undefined {
-  const own = (generic as { readonly name?: Node }).name;
-  if (own !== undefined && isIdentifier(own)) {
-    return own.text;
+/** The identifier an expression is headed by, through property accesses and calls. */
+function rootName(expression: Node): string | undefined {
+  let at: Node = expression;
+  for (;;) {
+    if (isIdentifier(at)) {
+      return at.text;
+    }
+    if (isPropertyAccessExpression(at) || isCallExpression(at) || isNewExpression(at)) {
+      at = at.expression;
+      continue;
+    }
+    if (isParenthesizedExpression(at) || isNonNullExpression(at)) {
+      at = at.expression;
+      continue;
+    }
+    return undefined;
   }
-  const parent = generic.parent as { readonly kind: SyntaxKind; readonly name?: Node };
-  return parent.kind === SyntaxKind.VariableDeclaration &&
-    parent.name !== undefined &&
-    isIdentifier(parent.name)
-    ? parent.name.text
-    : undefined;
+}
+
+/** What makes two carried accesses one: the kind and position of each side, or its written node. */
+function sideKey(one: Carried): readonly unknown[] {
+  const key = (side: Side): unknown =>
+    side.kind === "written" ? ["written", side.node.pos, side.node.end] : [side.kind, side.index];
+  return [key(one.object), key(one.index)];
 }