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

package/src/indexed-access.ts

@@ -31,6 +31,7 @@ import {
   isPropertyAccessExpression,
   isPropertyAssignment,
   isPropertySignatureDeclaration,
+  isSourceFile,
   isStringLiteral,
   isTypeAliasDeclaration,
   isTypeOperatorNode,
@@ -52,12 +53,9 @@ import {
   type Symbol as TSSymbol,
   type Type,
 } from "@typescript/native/sync";
-import type { AliasChains } from "./alias-chain.ts";
-import { nodeKey, type Inventory } from "./inventory.ts";
-import { renderPosition } from "./position.ts";
+import { nodeKey } from "./inventory.ts";
 import { UNANSWERED } from "./query.ts";
-import type { Reference } from "./references.ts";
-import type { ProjectView } from "./session.ts";
+import type { Read, ReadRule } from "./references/read-rule.ts";
 import { typeQueryAliases } from "./type-query-alias.ts";
 
 /** A declaration that declares type parameters, by the kinds of node that can. */
@@ -384,548 +382,593 @@ function carriedIn(generic: Generic): readonly Carried[] {
   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, the reference or the call,
- * or by the file.
- */
-export function indexedAccessReferences<Brand>(
-  project: ProjectView<Brand>,
-  held: Inventory,
-  chains: AliasChains,
-  root: string,
-  testFiles: ReadonlySet<string>,
-): readonly Reference[] {
-  const queries = project.queries;
-  const accesses: Access[] = [];
-  const carried = new Map<Generic, Carried[]>();
-  const names = new Set<string>();
-  const sites: Site[] = [];
-  /** Accesses indexed by a type parameter whose constraint is no `keyof`: it requires each key it names. */
-  const constrained: (Omit<Access, "index"> & { readonly constraint: TypeNode })[] = [];
-  /** Calls passing an argument, which a generic declared outside the own files may fix. */
-  const argumentCalls: 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);
+/** The generics enclosing one node, itself included, outermost first. */
+function enclosingGenerics(node: Node): readonly Generic[] {
+  const found: Generic[] = [];
+  for (let at = node; !isSourceFile(at); at = at.parent) {
+    if (isGeneric(at)) {
+      found.push(at);
     }
-    return true;
-  };
+  }
+  return found.reverse();
+}
 
-  for (const file of project.ownSourceFiles()) {
-    const fileId = held.declarations.get(nodeKey(file, file));
-    if (fileId === undefined) {
-      continue;
-    }
-    const aliasTypes = new Set(typeQueryAliases(file).map((alias) => alias.type));
-    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) || takesKeyof(node)) {
-        carriedIn(node).forEach((one) => carry(node, one));
-      }
-      if (isIndexedAccessTypeNode(node) && !aliasTypes.has(node)) {
-        const literal = literalNames(node.indexType);
-        const parameter =
-          literal === undefined ? namedParameter(node.indexType, inside) : undefined;
-        const constraint =
-          parameter === undefined
-            ? undefined
-            : (
-                parameter.generic.typeParameters?.[parameter.index] as
-                  { readonly constraint?: TypeNode } | undefined
-              )?.constraint;
-        if (literal !== undefined) {
-          accesses.push({ file, from: holder, at: node, object: node.objectType, index: literal });
-        } else if (
-          constraint !== undefined &&
-          keyofOperands(constraint).length === 0 &&
-          namedParameter(node.objectType, inside) === undefined
-        ) {
-          constrained.push({ file, from: holder, at: node, object: node.objectType, constraint });
-        }
-      }
-      if (
-        isTypeReferenceNode(node) &&
-        node.typeArguments !== undefined &&
-        isIdentifier(node.typeName)
-      ) {
-        sites.push({ file, from: holder, node, name: node.typeName.text, enclosing: inside });
+/**
+ * The reads the indexed-access types of a side's files make of the members they name, each
+ * made by the declaration that holds the type, the reference or the call, or by the file. A
+ * question the checker leaves unanswered holds what its answer could have read.
+ */
+export const indexedAccess: ReadRule = {
+  start() {
+    const accesses: Access[] = [];
+    const carried = new Map<Generic, Carried[]>();
+    const names = new Set<string>();
+    const sites: Site[] = [];
+    /** Accesses indexed by a type parameter whose constraint is no `keyof`: it requires each key it names. */
+    const constrained: (Omit<Access, "index"> & { readonly constraint: TypeNode })[] = [];
+    /** Calls passing an argument, which a generic declared outside the own files may fix. */
+    const argumentCalls: 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;
       }
-      if (isCallExpression(node) || isNewExpression(node)) {
-        const callee = node.expression;
-        const name = isIdentifier(callee)
-          ? callee.text
-          : isPropertyAccessExpression(callee) && isIdentifier(callee.name)
-            ? callee.name.text
-            : undefined;
-        if (name !== undefined) {
-          const site = { file, from: holder, node, name, enclosing: inside };
-          sites.push(site);
-          if (argumentsOf(node).length > 0) {
-            argumentCalls.push(site);
-          }
-        }
+      carried.set(generic, [...known, one]);
+      const name = calledName(generic);
+      if (name !== undefined) {
+        names.add(name);
       }
-      node.forEachChild((child) => {
-        visit(child, holder, inside);
-      });
+      return true;
     };
-    file.forEachChild((child) => {
-      visit(child, fileId, []);
-    });
-  }
 
-  /** The literal keys one constraint names, through the type aliases it references. */
-  const requiredNames = (node: TypeNode, seen: ReadonlySet<Node>): readonly string[] => {
-    const type = unwrappedType(node);
-    if (isUnionTypeNode(type)) {
-      return type.types.flatMap((one) => requiredNames(one, seen));
-    }
-    if (!isTypeReferenceNode(type) || type.typeArguments !== undefined) {
-      return literalNames(type) ?? [];
-    }
-    const [symbol] = queries.symbolsAt([type.typeName]);
-    if (symbol === UNANSWERED || symbol === undefined) {
-      return [];
-    }
-    return symbol.declarations.flatMap((handle) => {
-      const declared = project.declarationAt(handle)?.node;
-      return declared !== undefined &&
-        isTypeAliasDeclaration(declared) &&
-        declared.typeParameters === undefined &&
-        !seen.has(declared)
-        ? requiredNames(declared.type, new Set([...seen, declared]))
-        : [];
-    });
-  };
-  for (const { constraint, ...access } of constrained) {
-    const index = requiredNames(constraint, new Set());
-    if (index.length > 0) {
-      accesses.push({ ...access, index });
-    }
-  }
-
-  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 [];
-    }
-    return target.declarations.flatMap((handle) => {
-      const node = project.declarationAt(handle)?.node;
-      const generic = node === undefined ? undefined : genericOf(node);
-      return generic === undefined ? [] : [generic];
-    });
-  };
-
-  /**
-   * The type a call's callee is read off: the receiver of a property access, the value an
-   * object binding pattern destructures the callee from, or the value whose member a
-   * variable holding the callee is initialized with.
-   */
-  const receiverTypeOf = (callee: Expression): Type | undefined => {
-    let operand: Type | undefined;
-    if (isPropertyAccessExpression(callee)) {
-      const type = queries.typeAt(callee.expression);
-      operand = type === UNANSWERED ? undefined : type;
-      const args = operand === undefined ? [] : queries.typeArguments(operand);
-      if (operand !== undefined && args !== UNANSWERED && args.length > 0) {
-        return operand;
+    const aliasTypes = new Map<SourceFile, ReadonlySet<Node>>();
+    const aliasTypesOf = (file: SourceFile): ReadonlySet<Node> => {
+      let known = aliasTypes.get(file);
+      if (known === undefined) {
+        known = new Set(typeQueryAliases(file).map((alias) => alias.type));
+        aliasTypes.set(file, known);
       }
-    }
-    const name = isPropertyAccessExpression(callee) ? callee.name : callee;
-    const [named] = queries.symbolsAt([name]);
-    const symbol =
-      named === UNANSWERED || named === undefined || (named.flags & SymbolFlags.Alias) === 0
-        ? named
-        : queries.aliased(named);
-    if (symbol === UNANSWERED || symbol === undefined) {
-      return operand;
-    }
-    for (const handle of symbol.declarations) {
-      const node = project.declarationAt(handle)?.node;
-      const holder =
-        node !== undefined &&
-        isBindingElement(node) &&
-        isObjectBindingPattern(node.parent) &&
-        isVariableDeclaration(node.parent.parent)
-          ? node.parent.parent.initializer
-          : node !== undefined &&
-              isVariableDeclaration(node) &&
-              node.initializer !== undefined &&
-              isPropertyAccessExpression(node.initializer)
-            ? node.initializer.expression
-            : undefined;
-      const type = holder === undefined ? undefined : queries.typeAt(holder);
-      if (type !== UNANSWERED && type !== undefined) {
-        return type;
-      }
-    }
-    return operand;
-  };
-
-  /**
-   * The instantiation of `owner` a receiver's type is, or the first one among the base
-   * types it extends, breadth first: a subclass fixes its base's type parameters, and
-   * `this` stands for its class.
-   */
-  const instantiationOf = (type: Type, owner: Node): Type | undefined => {
-    const seen = new Set<number>();
-    for (let queue = [type]; queue.length > 0;) {
-      const next: Type[] = [];
-      for (const at of queue) {
-        if (seen.has(at.id)) {
-          continue;
+      return known;
+    };
+    return {
+      visit(node, { file, from }) {
+        const holder = from;
+        const inside = enclosingGenerics(node);
+        if (isGeneric(node) || takesKeyof(node)) {
+          carriedIn(node).forEach((one) => carry(node, one));
         }
-        seen.add(at.id);
-        const target = at.isTypeReference() ? queries.targetOf(at) : at;
-        const symbol = target === UNANSWERED ? undefined : queries.symbolOfType(target);
-        const declares =
-          symbol !== undefined &&
-          symbol !== UNANSWERED &&
-          symbol.declarations.some((handle) => project.declarationAt(handle)?.node === owner);
-        if (declares) {
-          return at;
+        if (isIndexedAccessTypeNode(node) && !aliasTypesOf(file).has(node)) {
+          const literal = literalNames(node.indexType);
+          const parameter =
+            literal === undefined ? namedParameter(node.indexType, inside) : undefined;
+          const constraint =
+            parameter === undefined
+              ? undefined
+              : (
+                  parameter.generic.typeParameters?.[parameter.index] as
+                    { readonly constraint?: TypeNode } | undefined
+                )?.constraint;
+          if (literal !== undefined) {
+            accesses.push({
+              file,
+              from: holder,
+              at: node,
+              object: node.objectType,
+              index: literal,
+            });
+          } else if (
+            constraint !== undefined &&
+            keyofOperands(constraint).length === 0 &&
+            namedParameter(node.objectType, inside) === undefined
+          ) {
+            constrained.push({ file, from: holder, at: node, object: node.objectType, constraint });
+          }
         }
-        const constraint = at.isTypeParameter() ? queries.constraintOf(at) : undefined;
-        const bases = at.isTypeParameter() ? [] : queries.baseTypes(at);
-        next.push(...(bases === UNANSWERED ? [] : bases));
-        if (constraint !== undefined && constraint !== UNANSWERED) {
-          next.push(constraint);
+        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)
+            ? callee.text
+            : isPropertyAccessExpression(callee) && isIdentifier(callee.name)
+              ? callee.name.text
+              : undefined;
+          if (name !== undefined) {
+            const site = { file, from: holder, node, name, enclosing: inside };
+            sites.push(site);
+            if (argumentsOf(node).length > 0) {
+              argumentCalls.push(site);
+            }
+          }
+        }
+      },
+      reads({ project, chains }) {
+        const queries = project.queries;
+        const found: Read[] = [];
+        /**
+         * A site whose generic the checker cannot name may fix any generic of its name, whose
+         * accesses may then read any member.
+         */
+        const holdSite = (site: Site): void => {
+          found.push({ kind: "held", from: site.from, members: true });
+        };
+        /** The literal keys one constraint names, through the type aliases it references. */
+        const requiredNames = (node: TypeNode, seen: ReadonlySet<Node>): readonly string[] => {
+          const type = unwrappedType(node);
+          if (isUnionTypeNode(type)) {
+            return type.types.flatMap((one) => requiredNames(one, seen));
+          }
+          if (!isTypeReferenceNode(type) || type.typeArguments !== undefined) {
+            return literalNames(type) ?? [];
+          }
+          const [symbol] = queries.symbolsAt([type.typeName]);
+          if (symbol === UNANSWERED || symbol === undefined) {
+            return [];
+          }
+          return symbol.declarations.flatMap((handle) => {
+            const declared = project.declarationAt(handle)?.node;
+            return declared !== undefined &&
+              isTypeAliasDeclaration(declared) &&
+              declared.typeParameters === undefined &&
+              !seen.has(declared)
+              ? requiredNames(declared.type, new Set([...seen, declared]))
+              : [];
+          });
+        };
+        for (const { constraint, ...access } of constrained) {
+          const index = requiredNames(constraint, new Set());
+          if (index.length > 0) {
+            accesses.push({ ...access, index });
+          }
         }
-      }
-      queue = next;
-    }
-    return type;
-  };
 
-  /** 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 };
-    }
-    const { node } = site;
-    if (side.kind === "receiver") {
-      const callee = isCallExpression(node) ? node.expression : undefined;
-      const owner = receiverOf(generic);
-      const typed = callee === undefined ? undefined : receiverTypeOf(callee);
-      const receiver =
-        typed === undefined || owner === undefined ? typed : instantiationOf(typed, owner);
-      if (receiver === undefined) {
-        return undefined;
-      }
-      const args = queries.typeArguments(receiver);
-      const type = args === UNANSWERED ? undefined : args[side.index];
-      return type === undefined ? undefined : { kind: "type", type };
-    }
-    if (side.kind === "argument") {
-      const argument = isTypeReferenceNode(node) ? undefined : node.arguments?.[side.index];
-      const type = argument === undefined ? undefined : queries.typeAt(argument);
-      return type === UNANSWERED || type === undefined ? undefined : { kind: "type", type };
-    }
-    const written = node.typeArguments?.[side.index];
-    if (written !== undefined) {
-      const passed = namedParameter(written, site.enclosing);
-      const mapped = passed === undefined ? mappedConstraint(written) : undefined;
-      return passed !== undefined
-        ? { kind: "passed", generic: passed.generic, index: passed.index }
-        : { kind: "node", node: mapped ?? written };
-    }
-    if (isTypeReferenceNode(node)) {
-      return undefined;
-    }
-    const at = parametersOf(generic).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;
-  };
+        /** 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 [];
+          }
+          return target.declarations.flatMap((handle) => {
+            const node = project.declarationAt(handle)?.node;
+            const generic = node === undefined ? undefined : genericOf(node);
+            return generic === undefined ? [] : [generic];
+          });
+        };
+
+        /**
+         * The type a call's callee is read off: the receiver of a property access, the value an
+         * object binding pattern destructures the callee from, or the value whose member a
+         * variable holding the callee is initialized with.
+         */
+        const receiverTypeOf = (callee: Expression): Type | undefined => {
+          let operand: Type | undefined;
+          if (isPropertyAccessExpression(callee)) {
+            const type = queries.typeAt(callee.expression);
+            operand = type === UNANSWERED ? undefined : type;
+            const args = operand === undefined ? [] : queries.typeArguments(operand);
+            if (operand !== undefined && args !== UNANSWERED && args.length > 0) {
+              return operand;
+            }
+          }
+          const name = isPropertyAccessExpression(callee) ? callee.name : callee;
+          const [named] = queries.symbolsAt([name]);
+          const symbol =
+            named === UNANSWERED || named === undefined || (named.flags & SymbolFlags.Alias) === 0
+              ? named
+              : queries.aliased(named);
+          if (symbol === UNANSWERED || symbol === undefined) {
+            return operand;
+          }
+          for (const handle of symbol.declarations) {
+            const node = project.declarationAt(handle)?.node;
+            const holder =
+              node !== undefined &&
+              isBindingElement(node) &&
+              isObjectBindingPattern(node.parent) &&
+              isVariableDeclaration(node.parent.parent)
+                ? node.parent.parent.initializer
+                : node !== undefined &&
+                    isVariableDeclaration(node) &&
+                    node.initializer !== undefined &&
+                    isPropertyAccessExpression(node.initializer)
+                  ? node.initializer.expression
+                  : undefined;
+            const type = holder === undefined ? undefined : queries.typeAt(holder);
+            if (type !== UNANSWERED && type !== undefined) {
+              return type;
+            }
+          }
+          return operand;
+        };
+
+        /**
+         * The instantiation of `owner` a receiver's type is, or the first one among the base
+         * types it extends, breadth first: a subclass fixes its base's type parameters, and
+         * `this` stands for its class.
+         */
+        const instantiationOf = (type: Type, owner: Node): Type | undefined => {
+          const seen = new Set<number>();
+          for (let queue = [type]; queue.length > 0;) {
+            const next: Type[] = [];
+            for (const at of queue) {
+              if (seen.has(at.id)) {
+                continue;
+              }
+              seen.add(at.id);
+              const target = at.isTypeReference() ? queries.targetOf(at) : at;
+              const symbol = target === UNANSWERED ? undefined : queries.symbolOfType(target);
+              const declares =
+                symbol !== undefined &&
+                symbol !== UNANSWERED &&
+                symbol.declarations.some((handle) => project.declarationAt(handle)?.node === owner);
+              if (declares) {
+                return at;
+              }
+              const constraint = at.isTypeParameter() ? queries.constraintOf(at) : undefined;
+              const bases = at.isTypeParameter() ? [] : queries.baseTypes(at);
+              next.push(...(bases === UNANSWERED ? [] : bases));
+              if (constraint !== undefined && constraint !== UNANSWERED) {
+                next.push(constraint);
+              }
+            }
+            queue = next;
+          }
+          return type;
+        };
 
-  // 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;
-        });
-      }
-    });
-  }
+        /** 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 };
+          }
+          const { node } = site;
+          if (side.kind === "receiver") {
+            const callee = isCallExpression(node) ? node.expression : undefined;
+            const owner = receiverOf(generic);
+            const typed = callee === undefined ? undefined : receiverTypeOf(callee);
+            const receiver =
+              typed === undefined || owner === undefined ? typed : instantiationOf(typed, owner);
+            if (receiver === undefined) {
+              return undefined;
+            }
+            const args = queries.typeArguments(receiver);
+            const type = args === UNANSWERED ? undefined : args[side.index];
+            return type === undefined ? undefined : { kind: "type", type };
+          }
+          if (side.kind === "argument") {
+            const argument = isTypeReferenceNode(node) ? undefined : node.arguments?.[side.index];
+            const type = argument === undefined ? undefined : queries.typeAt(argument);
+            return type === UNANSWERED || type === undefined ? undefined : { kind: "type", type };
+          }
+          const written = node.typeArguments?.[side.index];
+          if (written !== undefined) {
+            const passed = namedParameter(written, site.enclosing);
+            const mapped = passed === undefined ? mappedConstraint(written) : undefined;
+            return passed !== undefined
+              ? { kind: "passed", generic: passed.generic, index: passed.index }
+              : { kind: "node", node: mapped ?? written };
+          }
+          if (isTypeReferenceNode(node)) {
+            return undefined;
+          }
+          const at = parametersOf(generic).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 };
+        };
+
+        /** 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];
+            if (symbol === UNANSWERED) {
+              holdSite(site);
+            }
+            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);
+            if (resolved === UNANSWERED) {
+              holdSite(site);
+            }
+            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;
+              });
+            }
+          });
+        }
 
-  // A generic declared outside the project's own files carries what its own text indexes
-  // by its type parameters and its receiver's. Only a call passing an argument the compiler
-  // types as a literal can fix an index, so only such a call's signature is resolved.
-  const outside = argumentCalls.filter((site) => !resolvedGenerics.has(site));
-  const argumentNodes = argumentCalls.flatMap((site) => argumentsOf(site.node));
-  const argumentTypes = queries.typesAt(argumentNodes);
-  const literalArgument = new Set<Node>();
-  argumentTypes.forEach((type, at) => {
-    const node = argumentNodes[at];
-    if (
-      node !== undefined &&
-      type !== UNANSWERED &&
-      type !== undefined &&
-      literalTypeNames(type, partsOf).length > 0
-    ) {
-      literalArgument.add(node);
-    }
-  });
-  const own = project.ownPaths();
-  for (const site of outside) {
-    if (!argumentsOf(site.node).some((one) => literalArgument.has(one))) {
-      continue;
-    }
-    const resolved = queries.resolvedSignature(site.node);
-    const handle =
-      resolved === UNANSWERED || resolved === undefined ? undefined : resolved.declaration;
-    if (handle === undefined || 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);
-    }
-  }
-  for (const site of argumentCalls) {
-    if (argumentsOf(site.node).some((one) => literalArgument.has(one))) {
-      accesses.push(...instantiatedAccesses(site));
-    }
-  }
+        // A generic declared outside the project's own files carries what its own text indexes
+        // by its type parameters and its receiver's. Only a call passing an argument the compiler
+        // types as a literal can fix an index, so only such a call's signature is resolved.
+        const outside = argumentCalls.filter((site) => !resolvedGenerics.has(site));
+        const argumentNodes = argumentCalls.flatMap((site) => argumentsOf(site.node));
+        const argumentTypes = queries.typesAt(argumentNodes);
+        const literalArgument = new Set<Node>();
+        argumentTypes.forEach((type, at) => {
+          const node = argumentNodes[at];
+          if (
+            node !== undefined &&
+            type !== UNANSWERED &&
+            type !== undefined &&
+            literalTypeNames(type, partsOf).length > 0
+          ) {
+            literalArgument.add(node);
+          }
+        });
+        const own = project.ownPaths();
+        for (const site of outside) {
+          if (!argumentsOf(site.node).some((one) => literalArgument.has(one))) {
+            continue;
+          }
+          const resolved = queries.resolvedSignature(site.node);
+          const handle =
+            resolved === UNANSWERED || resolved === undefined ? undefined : resolved.declaration;
+          if (handle === undefined || 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);
+          }
+        }
+        for (const site of argumentCalls) {
+          if (argumentsOf(site.node).some((one) => literalArgument.has(one))) {
+            accesses.push(...instantiatedAccesses(site));
+          }
+        }
 
-  /**
-   * The indexed accesses the generic signature a call instantiates holds, read through the
-   * checker: the signature its receiver's instantiation gives, so an object type its
-   * receiver fixes is concrete whatever declaration spells the receiver's type, a type
-   * literal a generic function returns among them. An index naming a type parameter is the
-   * literal type the call passes at each parameter of that type.
-   */
-  function instantiatedAccesses(site: Site): readonly Access[] {
-    const resolved = queries.resolvedSignature(site.node);
-    const generic =
-      resolved === UNANSWERED || resolved === undefined ? undefined : queries.genericOf(resolved);
-    if (
-      resolved === UNANSWERED ||
-      resolved === undefined ||
-      generic === UNANSWERED ||
-      generic === undefined
-    ) {
-      return [];
-    }
-    const count = argumentsOf(site.node).length;
-    const parameters: Type[] = [];
-    for (let at = 0; at < count; at += 1) {
-      const type = queries.parameterType(generic, at);
-      if (type !== UNANSWERED && type !== undefined) {
-        parameters[at] = type;
-      }
-    }
-    const result = queries.returnTypeOf(generic);
-    const held: Type[] = [
-      ...parameters,
-      ...(result === UNANSWERED || result === undefined ? [] : [result]),
-    ];
-    // A parameter of a callback and a type argument, a rest tuple's among them, hold the
-    // accesses one level down: `fn: (payload: M[K]) => void` and `...[M[K]]`.
-    const nested = held.flatMap((type) => [
-      ...partsOf(type),
-      ...partsOf(type).flatMap((part) => {
-        const args = queries.typeArguments(part);
-        const calls = queries.signaturesOf(part, SignatureKind.Call);
-        return [
-          ...(args === UNANSWERED ? [] : args),
-          ...(calls === UNANSWERED ? [] : calls).flatMap((signature) =>
-            signature.parameters.flatMap((_parameter, index) => {
-              const one = queries.parameterType(signature, index);
-              return one === UNANSWERED || one === undefined ? [] : [one];
+        /**
+         * The indexed accesses the generic signature a call instantiates holds, read through the
+         * checker: the signature its receiver's instantiation gives, so an object type its
+         * receiver fixes is concrete whatever declaration spells the receiver's type, a type
+         * literal a generic function returns among them. An index naming a type parameter is the
+         * literal type the call passes at each parameter of that type.
+         */
+        function instantiatedAccesses(site: Site): readonly Access[] {
+          const resolved = queries.resolvedSignature(site.node);
+          const generic =
+            resolved === UNANSWERED || resolved === undefined
+              ? undefined
+              : queries.genericOf(resolved);
+          if (
+            resolved === UNANSWERED ||
+            resolved === undefined ||
+            generic === UNANSWERED ||
+            generic === undefined
+          ) {
+            return [];
+          }
+          const count = argumentsOf(site.node).length;
+          const parameters: Type[] = [];
+          for (let at = 0; at < count; at += 1) {
+            const type = queries.parameterType(generic, at);
+            if (type !== UNANSWERED && type !== undefined) {
+              parameters[at] = type;
+            }
+          }
+          const result = queries.returnTypeOf(generic);
+          const held: Type[] = [
+            ...parameters,
+            ...(result === UNANSWERED || result === undefined ? [] : [result]),
+          ];
+          // A parameter of a callback and a type argument, a rest tuple's among them, hold the
+          // accesses one level down: `fn: (payload: M[K]) => void` and `...[M[K]]`.
+          const nested = held.flatMap((type) => [
+            ...partsOf(type),
+            ...partsOf(type).flatMap((part) => {
+              const args = queries.typeArguments(part);
+              const calls = queries.signaturesOf(part, SignatureKind.Call);
+              return [
+                ...(args === UNANSWERED ? [] : args),
+                ...(calls === UNANSWERED ? [] : calls).flatMap((signature) =>
+                  signature.parameters.flatMap((_parameter, index) => {
+                    const one = queries.parameterType(signature, index);
+                    return one === UNANSWERED || one === undefined ? [] : [one];
+                  }),
+                ),
+              ];
             }),
-          ),
-        ];
-      }),
-    ]);
-    const found: Access[] = [];
-    for (const type of nested) {
-      const access = queries.indexedAccessOf(type);
-      if (access === UNANSWERED || access === undefined || access.object.isTypeParameter()) {
-        continue;
-      }
-      const names = access.index.isTypeParameter()
-        ? parameters.flatMap((parameter, at) => {
-            if (!partsOf(parameter).some((part) => part.id === access.index.id)) {
-              return [];
+          ]);
+          const found: Access[] = [];
+          for (const type of nested) {
+            const access = queries.indexedAccessOf(type);
+            if (access === UNANSWERED || access === undefined || access.object.isTypeParameter()) {
+              continue;
             }
-            const passed = queries.typeAtPosition(resolved, at);
-            return passed === UNANSWERED ? [] : literalTypeNames(passed, partsOf);
-          })
-        : literalTypeNames(access.index, partsOf);
-      if (names.length > 0) {
-        found.push({
-          file: site.file,
-          from: site.from,
-          at: site.node,
-          object: access.object,
-          index: names,
+            const names = access.index.isTypeParameter()
+              ? parameters.flatMap((parameter, at) => {
+                  if (!partsOf(parameter).some((part) => part.id === access.index.id)) {
+                    return [];
+                  }
+                  const passed = queries.typeAtPosition(resolved, at);
+                  return passed === UNANSWERED ? [] : literalTypeNames(passed, partsOf);
+                })
+              : literalTypeNames(access.index, partsOf);
+            if (names.length > 0) {
+              found.push({
+                file: site.file,
+                from: site.from,
+                at: site.node,
+                object: access.object,
+                index: names,
+              });
+            }
+          }
+          return found;
+        }
+
+        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 | typeof UNANSWERED>();
+        queries.typesAt(typeNodes).forEach((answer, index) => {
+          const node = typeNodes[index];
+          if (answer !== undefined && node !== undefined) {
+            typeOf.set(node, answer);
+          }
         });
-      }
-    }
-    return found;
-  }
+        const asType = (side: TypeNode | Type): Type | typeof UNANSWERED | undefined =>
+          "kind" in side ? typeOf.get(side) : side;
 
-  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(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 = 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());
-    for (const part of partsOf(type)) {
-      const properties = queries.propertiesOf(part);
-      if (properties === UNANSWERED) {
-        continue;
-      }
-      for (const property of properties) {
-        if (!accessed.includes(property.escapedName)) {
-          continue;
-        }
-        for (const to of chains.declarationsOf(property)) {
-          found.push({
-            from: access.from,
-            to,
-            position,
-            use: "read",
-            resolution: "batch",
-            test: testFiles.has(position.path),
-          });
+        for (const access of accesses) {
+          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 || indexType === UNANSWERED
+              ? undefined
+              : literalTypeNames(indexType, partsOf);
+          if (type === UNANSWERED || indexType === UNANSWERED) {
+            found.push({
+              kind: "held",
+              from: access.from,
+              ...(accessed === undefined ? {} : { names: accessed }),
+              ...(type === UNANSWERED || type === undefined
+                ? accessed === undefined
+                  ? { members: true as const }
+                  : {}
+                : { types: partsOf(type) }),
+            });
+            continue;
+          }
+          if (type === undefined || accessed === undefined) {
+            continue;
+          }
+          for (const part of partsOf(type)) {
+            const properties = queries.propertiesOf(part);
+            if (properties === UNANSWERED) {
+              found.push({ kind: "held", from: access.from, names: accessed });
+              continue;
+            }
+            for (const property of properties) {
+              if (!accessed.includes(property.escapedName)) {
+                continue;
+              }
+              for (const to of chains.declarationsOf(property)) {
+                found.push({
+                  kind: "named",
+                  from: access.from,
+                  to,
+                  file: access.file,
+                  at: access.at,
+                  use: "read",
+                  via: "batch",
+                });
+              }
+            }
+          }
         }
-      }
-    }
-  }
-  return found;
-}
+        return found;
+      },
+    };
+  },
+};
 
 /** The arguments a call or a `new` expression passes, none for a type reference. */
 function argumentsOf(node: Site["node"]): readonly Expression[] {