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

package/dist/src/indexed-access.js

@@ -4,10 +4,9 @@
  * 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, isBindingElement, isCallExpression, isClassDeclaration, isClassExpression, isConstructorDeclaration, isConstructorTypeNode, isFunctionDeclaration, isFunctionExpression, isFunctionTypeNode, isIdentifier, isIndexedAccessTypeNode, isInterfaceDeclaration, isLiteralTypeNode, isMappedTypeNode, isMethodDeclaration, isMethodSignatureDeclaration, isNewExpression, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectBindingPattern, isParenthesizedTypeNode, isPropertyAccessExpression, isPropertyAssignment, isPropertySignatureDeclaration, isStringLiteral, isTypeAliasDeclaration, isTypeOperatorNode, isTypeReferenceNode, isUnionTypeNode, isVariableDeclaration, SyntaxKind, } from "@typescript/native/ast";
+import { isArrowFunction, isBindingElement, isCallExpression, isClassDeclaration, isClassExpression, isConstructorDeclaration, isConstructorTypeNode, isFunctionDeclaration, isFunctionExpression, isFunctionTypeNode, isIdentifier, isIndexedAccessTypeNode, isInterfaceDeclaration, isLiteralTypeNode, isMappedTypeNode, isMethodDeclaration, isMethodSignatureDeclaration, isNewExpression, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectBindingPattern, isParenthesizedTypeNode, isPropertyAccessExpression, isPropertyAssignment, isPropertySignatureDeclaration, isSourceFile, isStringLiteral, isTypeAliasDeclaration, isTypeOperatorNode, isTypeReferenceNode, isUnionTypeNode, isVariableDeclaration, SyntaxKind, } from "@typescript/native/ast";
 import { SignatureKind, SymbolFlags, } from "@typescript/native/sync";
 import { nodeKey } from "./inventory.js";
-import { renderPosition } from "./position.js";
 import { UNANSWERED } from "./query.js";
 import { typeQueryAliases } from "./type-query-alias.js";
 function isGeneric(node) {
@@ -242,497 +241,543 @@ function carriedIn(generic) {
     visit(generic);
     return found;
 }
+/** The generics enclosing one node, itself included, outermost first. */
+function enclosingGenerics(node) {
+    const found = [];
+    for (let at = node; !isSourceFile(at); at = at.parent) {
+        if (isGeneric(at)) {
+            found.push(at);
+        }
+    }
+    return found.reverse();
+}
 /**
- * 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.
+ * 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 function indexedAccessReferences(project, held, chains, root, testFiles) {
-    const queries = project.queries;
-    const accesses = [];
-    const carried = new Map();
-    const names = new Set();
-    const sites = [];
-    /** Accesses indexed by a type parameter whose constraint is no `keyof`: it requires each key it names. */
-    const constrained = [];
-    /** Calls passing an argument, which a generic declared outside the own files may fix. */
-    const argumentCalls = [];
-    const carry = (generic, one) => {
-        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));
-        if (fileId === undefined) {
-            continue;
-        }
-        const aliasTypes = new Set(typeQueryAliases(file).map((alias) => alias.type));
-        const visit = (node, from, enclosing) => {
-            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));
+export const indexedAccess = {
+    start() {
+        const accesses = [];
+        const carried = new Map();
+        const names = new Set();
+        const sites = [];
+        /** Accesses indexed by a type parameter whose constraint is no `keyof`: it requires each key it names. */
+        const constrained = [];
+        /** Calls passing an argument, which a generic declared outside the own files may fix. */
+        const argumentCalls = [];
+        const carry = (generic, one) => {
+            const known = carried.get(generic) ?? [];
+            const same = known.some((other) => JSON.stringify(sideKey(other)) === JSON.stringify(sideKey(one)));
+            if (same) {
+                return false;
             }
-            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]?.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 });
-                }
+            carried.set(generic, [...known, one]);
+            const name = calledName(generic);
+            if (name !== undefined) {
+                names.add(name);
             }
-            if (isTypeReferenceNode(node) &&
-                node.typeArguments !== undefined &&
-                isIdentifier(node.typeName)) {
-                sites.push({ file, from: holder, node, name: node.typeName.text, enclosing: inside });
+            return true;
+        };
+        const aliasTypes = new Map();
+        const aliasTypesOf = (file) => {
+            let known = aliasTypes.get(file);
+            if (known === undefined) {
+                known = new Set(typeQueryAliases(file).map((alias) => alias.type));
+                aliasTypes.set(file, known);
             }
-            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);
+            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));
+                }
+                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]?.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 });
                     }
                 }
-            }
-            node.forEachChild((child) => {
-                visit(child, holder, inside);
-            });
-        };
-        file.forEachChild((child) => {
-            visit(child, fileId, []);
-        });
-    }
-    /** The literal keys one constraint names, through the type aliases it references. */
-    const requiredNames = (node, seen) => {
-        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) {
-        const parts = queries.constituents(type);
-        return parts === UNANSWERED ? [type] : parts;
-    }
-    /** The generics one symbol declares, through the alias it may be. */
-    const genericsOf = (symbol) => {
-        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) => {
-        let operand;
-        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, owner) => {
-        const seen = new Set();
-        for (let queue = [type]; queue.length > 0;) {
-            const next = [];
-            for (const at of queue) {
-                if (seen.has(at.id)) {
-                    continue;
+                if (isTypeReferenceNode(node) &&
+                    node.typeArguments !== undefined &&
+                    isIdentifier(node.typeName)) {
+                    sites.push({ file, from: holder, node, name: node.typeName.text, enclosing: inside });
                 }
-                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 (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);
+                        }
+                    }
                 }
-                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);
+            },
+            reads({ project, chains }) {
+                const queries = project.queries;
+                const found = [];
+                /**
+                 * 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) => {
+                    found.push({ kind: "held", from: site.from, members: true });
+                };
+                /** The literal keys one constraint names, through the type aliases it references. */
+                const requiredNames = (node, seen) => {
+                    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, side, generic) => {
-        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, generic, one) => {
-        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.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();
-    const read = new Set();
-    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.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;
-                });
-            }
-        });
-    }
-    // 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();
-    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) {
-        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 = [];
-        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 = [
-            ...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 = [];
-        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)) {
+                function partsOf(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) => {
+                    const target = (symbol.flags & SymbolFlags.Alias) === 0 ? symbol : queries.aliased(symbol);
+                    if (target === UNANSWERED) {
                         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 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) => {
+                    let operand;
+                    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, owner) => {
+                    const seen = new Set();
+                    for (let queue = [type]; queue.length > 0;) {
+                        const next = [];
+                        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;
+                };
+                /** What one site fixes for one side of a carried access. */
+                const fixedAt = (site, side, generic) => {
+                    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, generic, one) => {
+                    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.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();
+                const read = new Set();
+                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.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();
+                argumentTypes.forEach((type, at) => {
+                    const node = argumentNodes[at];
+                    if (node !== undefined &&
+                        type !== UNANSWERED &&
+                        type !== undefined &&
+                        literalTypeNames(type, partsOf).length > 0) {
+                        literalArgument.add(node);
+                    }
                 });
-            }
-        }
-        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();
-    queries.typesAt(typeNodes).forEach((answer, index) => {
-        const node = typeNodes[index];
-        if (answer !== UNANSWERED && answer !== undefined && node !== undefined) {
-            typeOf.set(node, answer);
-        }
-    });
-    const asType = (side) => "kind" in side ? typeOf.get(side) : side;
-    const found = [];
-    for (const access of accesses) {
-        const type = asType(access.object);
-        const indexType = Array.isArray(access.index)
-            ? undefined
-            : asType(access.index);
-        const accessed = Array.isArray(access.index)
-            ? access.index
-            : 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;
+                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 to of chains.declarationsOf(property)) {
-                    found.push({
-                        from: access.from,
-                        to,
-                        position,
-                        use: "read",
-                        resolution: "batch",
-                        test: testFiles.has(position.path),
-                    });
+                for (const site of argumentCalls) {
+                    if (argumentsOf(site.node).some((one) => literalArgument.has(one))) {
+                        accesses.push(...instantiatedAccesses(site));
+                    }
                 }
-            }
-        }
-    }
-    return found;
-}
+                /**
+                 * 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) {
+                    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 = [];
+                    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 = [
+                        ...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 = [];
+                    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 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();
+                queries.typesAt(typeNodes).forEach((answer, index) => {
+                    const node = typeNodes[index];
+                    if (answer !== undefined && node !== undefined) {
+                        typeOf.set(node, answer);
+                    }
+                });
+                const asType = (side) => "kind" in side ? typeOf.get(side) : side;
+                for (const access of accesses) {
+                    const type = asType(access.object);
+                    const indexType = Array.isArray(access.index)
+                        ? undefined
+                        : asType(access.index);
+                    const accessed = Array.isArray(access.index)
+                        ? access.index
+                        : 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 }
+                                    : {}
+                                : { 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;
+            },
+        };
+    },
+};
 /** The arguments a call or a `new` expression passes, none for a type reference. */
 function argumentsOf(node) {
     return isTypeReferenceNode(node) ? [] : (node.arguments ?? []);