@cplieger/deadset-ts 7.0.0-dev.1 → 7.0.0-dev.3

package/dist/src/findings/self-check.js

@@ -1,5 +1,6 @@
 import { REPOSITORY_DOCUMENT } from "../config.js";
-import { STALE_SUPPRESSION, SUPPRESSION_WITHOUT_REASON, } from "../suppress.js";
+import { FIXED_SEVERITY_CODES } from "../kinds.js";
+import { isDependencyCode, isUnsuppressibleCode, STALE_SUPPRESSION, SUPPRESSION_WITHOUT_REASON, } from "../suppress.js";
 /** The code a configured root that matches nothing is reported under. */
 const UNMATCHED_ROOT = "DS1704";
 /** The code a configured declaration that names nothing is reported under. */
@@ -12,13 +13,6 @@ const SUPPRESSION_SUBJECT = "suppression";
 const ROOT_SUBJECT = "root";
 /** The fixed position of a finding about a document rather than about a line of one. */
 const DOCUMENT_POSITION = 1;
-/** A run with nothing for the self-check family to report. */
-export const NO_SELF_CHECK = {
-    refusals: [],
-    unmatchedRoots: [],
-    rootsDocument: "",
-    unmatchedDeclarations: [],
-};
 /** The words a message names a mechanism by. */
 const WRITTEN = {
     inline: "inline directive",
@@ -68,7 +62,7 @@ function suppressionRef(symbol, path, files) {
     return symbol === "" ? (files(path) ?? path) : symbol;
 }
 /** One finding per refused suppression: the grammar's reason refusal and its scope refusal. */
-export function refusedSuppressions(refusals, files) {
+function refusedSuppressions(refusals, files) {
     return refusals.map((refused) => aboutSuppression(refused.reported, suppressionRef(refused.symbol, refused.path, files), refused.site, `${WRITTEN[refused.mechanism]} for ${refused.code} ${refused.reported === SUPPRESSION_WITHOUT_REASON
         ? "carries no reason"
         : "names a symbol and no path"}`, { mechanism: refused.mechanism, entry: writtenEntry(refused) }));
@@ -93,7 +87,30 @@ export function staleSuppressions(stale, files) {
         const reports = [...new Set(records.flatMap((one) => one.reports))]
             .filter((code) => !codes.includes(code))
             .sort();
-        const instead = reports.length === 0 ? "" : `, and its declaration reports ${spelled(reports)}`;
+        const rows = codes.filter(isUnsuppressibleCode);
+        const dependencies = first.mechanism === "inline" ? codes.filter(isDependencyCode) : [];
+        const settable = rows.filter((code) => !FIXED_SEVERITY_CODES.includes(code));
+        const remedy = settable.length === 0
+            ? "fix what the finding names instead"
+            : `fix what the finding names or set the severity of ${spelled(settable)} instead`;
+        const declared = reports.length === 0 ? "" : `its declaration reports ${spelled(reports)}`;
+        const because = [
+            ...(rows.length > 0
+                ? [
+                    `${spelled(rows)} ${rows.length === 1 ? "reports a row" : "report rows"} of a document, which no suppression can name; ${remedy}`,
+                ]
+                : []),
+            ...(dependencies.length > 0
+                ? [
+                    `${spelled(dependencies)} ${dependencies.length === 1 ? "reports a dependency row" : "report dependency rows"}, which only an ignore entry or a baseline row can name`,
+                ]
+                : []),
+        ];
+        const instead = because.length > 0
+            ? `, because ${because.join("; ")}${declared === "" ? "" : `; ${declared}`}`
+            : declared === ""
+                ? ""
+                : `, and ${declared}`;
         return {
             code: STALE_SUPPRESSION,
             mechanism: first.mechanism,

package/dist/src/findings-pass.js

@@ -6,7 +6,7 @@
 import { fails } from "./config.js";
 import { decidedFindings } from "./findings/emitters.js";
 import { fileRefsOf, staleSuppressions, } from "./findings/self-check.js";
-import { isRowSubject, pairs, suppressionCounts } from "./suppress.js";
+import { isDependencySubject, isRowSubject, pairs, suppressionCounts, } from "./suppress.js";
 import { EXIT_CLEAN, EXIT_FINDINGS } from "./verbs/verb.js";
 /** The exit code of a report holding at least one pending finding. */
 export const EXIT_PENDING = 4;
@@ -78,14 +78,15 @@ export function verdictOf(result, config) {
 }
 /**
  * The rows one round of a baseline write records from its findings, in their order. A
- * finding about a row of a document is not recorded: no record withholds one, so a row
- * recording it would be stale on the first read back. Two findings that would record the
- * same row, two parts of one declaration under one code, record it once.
+ * finding about a row of a document other than a dependency row is not recorded: no record
+ * withholds one, so a row recording it would be stale on the first read back. Two findings
+ * that would record the same row, two parts of one declaration under one code, record it
+ * once.
  */
 export function recordedFindings(findings) {
     const rows = new Map();
     for (const finding of findings) {
-        if (isRowSubject(finding.symbol.kind)) {
+        if (isRowSubject(finding.symbol.kind) && !isDependencySubject(finding.symbol.kind)) {
             continue;
         }
         const row = { code: finding.code, symbol: finding.symbol.ref, path: finding.position.path };

package/dist/src/in-operands.js

@@ -0,0 +1,30 @@
+/**
+ * The property names `in` tests in a project's production files. A value narrowed by
+ * `"name" in value` is read back by that name, often through `unknown`, where no type
+ * links the read to a declaration, so only a text match can tell which member it reads.
+ */
+import { isBinaryExpression, isNoSubstitutionTemplateLiteral, isStringLiteral, SyntaxKind, } from "@typescript/native/unstable/ast";
+import { sourceFilesOf } from "./source-files.js";
+/**
+ * The text of each string literal, or template literal with no substitution, written as
+ * the left operand of an `in` expression in a file of the project that is no test file.
+ * `testFiles` holds the test files by their path below the target root.
+ */
+export function inOperandNames(project, targetRoot, testFiles) {
+    const tests = new Set(testFiles);
+    const found = new Set();
+    const visit = (node) => {
+        if (isBinaryExpression(node) &&
+            node.operatorToken.kind === SyntaxKind.InKeyword &&
+            (isStringLiteral(node.left) || isNoSubstitutionTemplateLiteral(node.left))) {
+            found.add(node.left.text);
+        }
+        node.forEachChild(visit);
+    };
+    for (const [path, file] of sourceFilesOf(project, targetRoot).byPath) {
+        if (!tests.has(path)) {
+            file.forEachChild(visit);
+        }
+    }
+    return [...found].sort();
+}

package/dist/src/indexed-access.js

@@ -4,8 +4,8 @@
  * that parameter, and a call of a method of a generic receiver fixes the receiver's by its
  * type arguments. The type query of a type-query alias is no reference.
  */
-import { isArrowFunction, isCallExpression, isClassDeclaration, isClassExpression, isFunctionDeclaration, isFunctionExpression, isIdentifier, isNonNullExpression, isParenthesizedExpression, isNamedImports, isNamespaceImport, isImportDeclaration, isIndexedAccessTypeNode, isInterfaceDeclaration, isLiteralTypeNode, isMethodDeclaration, isMethodSignatureDeclaration, isNewExpression, isNoSubstitutionTemplateLiteral, isNumericLiteral, isParenthesizedTypeNode, isPropertyAccessExpression, isStringLiteral, isTypeAliasDeclaration, isTypeReferenceNode, isUnionTypeNode, isVariableDeclaration, } from "@typescript/native/unstable/ast";
-import { SymbolFlags } from "@typescript/native/unstable/sync";
+import { isArrowFunction, isBindingElement, isCallExpression, isClassDeclaration, isClassExpression, isFunctionDeclaration, isFunctionExpression, isFunctionTypeNode, isIdentifier, isIndexedAccessTypeNode, isInterfaceDeclaration, isLiteralTypeNode, isMappedTypeNode, isMethodDeclaration, isMethodSignatureDeclaration, isNewExpression, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectBindingPattern, isParenthesizedTypeNode, isPropertyAccessExpression, isPropertySignatureDeclaration, isStringLiteral, isTypeAliasDeclaration, isTypeOperatorNode, isTypeReferenceNode, isUnionTypeNode, isVariableDeclaration, SyntaxKind, } from "@typescript/native/unstable/ast";
+import { SignatureKind, SymbolFlags, } from "@typescript/native/unstable/sync";
 import { nodeKey } from "./inventory.js";
 import { renderPosition } from "./position.js";
 import { UNANSWERED } from "./query.js";
@@ -16,6 +16,7 @@ function isGeneric(node) {
         isMethodSignatureDeclaration(node) ||
         isArrowFunction(node) ||
         isFunctionExpression(node) ||
+        isFunctionTypeNode(node) ||
         isTypeAliasDeclaration(node) ||
         isInterfaceDeclaration(node) ||
         isClassDeclaration(node) ||
@@ -26,6 +27,29 @@ function isGeneric(node) {
 function isReceiver(node) {
     return isInterfaceDeclaration(node) || isClassDeclaration(node) || isClassExpression(node);
 }
+/**
+ * The class or the interface one member function belongs to: a method's parent, or for a
+ * function type a property declares, the declaration that holds the property.
+ */
+function receiverOf(member) {
+    const parent = member.parent;
+    if (isFunctionTypeNode(member) &&
+        parent !== undefined &&
+        isPropertySignatureDeclaration(parent)) {
+        return parent.parent;
+    }
+    return parent;
+}
+/** Whether a member function of a generic receiver declares no type parameter of its own. */
+function isReceiverMember(node) {
+    if (!(isMethodDeclaration(node) ||
+        isMethodSignatureDeclaration(node) ||
+        isFunctionTypeNode(node))) {
+        return false;
+    }
+    const receiver = receiverOf(node);
+    return receiver !== undefined && isReceiver(receiver) && isGeneric(receiver);
+}
 function unwrappedType(node) {
     return isParenthesizedTypeNode(node) ? unwrappedType(node.type) : node;
 }
@@ -86,6 +110,28 @@ function namedParameter(node, enclosing) {
     }
     return undefined;
 }
+/**
+ * The constraint of the mapped type whose type parameter one type node names whole: a
+ * mapped type instantiates what it holds once per constituent of that constraint.
+ */
+function mappedConstraint(node) {
+    const type = unwrappedType(node);
+    if (!isTypeReferenceNode(type) ||
+        !isIdentifier(type.typeName) ||
+        type.typeArguments !== undefined) {
+        return undefined;
+    }
+    const spelled = type.typeName.text;
+    for (let at = type.parent; at !== undefined; at = at.parent) {
+        if (isMappedTypeNode(at)) {
+            const { name, constraint } = at.typeParameter;
+            if (isIdentifier(name) && name.text === spelled) {
+                return constraint;
+            }
+        }
+    }
+    return undefined;
+}
 /** The name a site writes to reach one generic: its own, or its variable's. */
 function calledName(generic) {
     const own = generic.name;
@@ -93,15 +139,23 @@ function calledName(generic) {
         return own.text;
     }
     const parent = generic.parent;
-    return parent !== undefined && isVariableDeclaration(parent) && isIdentifier(parent.name)
+    return parent !== undefined &&
+        (isVariableDeclaration(parent) || isPropertySignatureDeclaration(parent)) &&
+        isIdentifier(parent.name)
         ? parent.name.text
         : undefined;
 }
 /** The generic a declaration a symbol names is: the function a variable is initialized with included. */
 function genericOf(node) {
-    if (isGeneric(node)) {
+    if (isGeneric(node) || isReceiverMember(node)) {
         return node;
     }
+    if (isPropertySignatureDeclaration(node)) {
+        // The typings mark the annotation present; a signature written without one has none.
+        const declared = node.type;
+        const type = declared === undefined ? undefined : unwrappedType(declared);
+        return type !== undefined && isFunctionTypeNode(type) ? genericOf(type) : undefined;
+    }
     if (isVariableDeclaration(node) &&
         node.initializer !== undefined &&
         isGeneric(node.initializer)) {
@@ -109,29 +163,60 @@ function genericOf(node) {
     }
     return undefined;
 }
+/** The operand of each `keyof` one type node holds, through every type node it is built of. */
+function keyofOperands(node) {
+    const found = [];
+    const visit = (at) => {
+        if (isTypeOperatorNode(at) && at.operator === SyntaxKind.KeyOfKeyword) {
+            found.push(at.type);
+            return;
+        }
+        at.forEachChild(visit);
+    };
+    visit(node);
+    return found;
+}
 /**
  * Each indexed access inside one generic whose index names a type parameter of it, read
  * from its own text: the object side is a type parameter of the same generic, one of the
- * receiver it is a method of, or a type it writes.
+ * receiver it is a member of, or a type it writes. A type parameter whose constraint holds
+ * `keyof X` is an index into `X` as `X[K]` is, and so is a parameter whose declared type
+ * holds `keyof X`, indexed by the argument a call passes it.
  */
 function carriedIn(generic) {
     const found = [];
-    const receiver = generic.parent;
+    const receiver = receiverOf(generic);
     const outer = receiver !== undefined && isReceiver(receiver) && isGeneric(receiver) ? receiver : undefined;
+    const sideOf = (object) => {
+        const own = namedParameter(object, [generic]);
+        const fromReceiver = own === undefined && outer !== undefined ? namedParameter(object, [outer]) : undefined;
+        return own !== undefined
+            ? { kind: "parameter", index: own.index }
+            : fromReceiver !== undefined
+                ? { kind: "receiver", index: fromReceiver.index }
+                : { kind: "written", node: object };
+    };
+    (generic.typeParameters ?? []).forEach((parameter, index) => {
+        const constraint = parameter.constraint;
+        for (const object of constraint === undefined ? [] : keyofOperands(constraint)) {
+            found.push({ object: sideOf(object), index: { kind: "parameter", index } });
+        }
+    });
+    (generic.parameters ?? []).forEach((parameter, index) => {
+        for (const object of parameter.type === undefined ? [] : keyofOperands(parameter.type)) {
+            if (namedParameter(object, [generic]) === undefined) {
+                found.push({ object: sideOf(object), index: { kind: "argument", index } });
+            }
+        }
+    });
     const visit = (node) => {
         if (isIndexedAccessTypeNode(node)) {
             const index = namedParameter(node.indexType, [generic]);
             if (index !== undefined) {
-                const own = namedParameter(node.objectType, [generic]);
-                const fromReceiver = own === undefined && outer !== undefined
-                    ? namedParameter(node.objectType, [outer])
-                    : undefined;
-                const object = own !== undefined
-                    ? { kind: "parameter", index: own.index }
-                    : fromReceiver !== undefined
-                        ? { kind: "receiver", index: fromReceiver.index }
-                        : { kind: "written", node: node.objectType };
-                found.push({ object, index: { kind: "parameter", index: index.index } });
+                found.push({
+                    object: sideOf(node.objectType),
+                    index: { kind: "parameter", index: index.index },
+                });
             }
         }
         if (node !== generic && isGeneric(node)) {
@@ -153,8 +238,8 @@ export function indexedAccessReferences(project, held, chains, root, testFiles)
     const carried = new Map();
     const names = new Set();
     const sites = [];
-    /** Calls passing a literal argument whose callee a package binding heads, which a dependency's generic may fix. */
-    const literalCalls = [];
+    /** 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)));
@@ -174,7 +259,6 @@ export function indexedAccessReferences(project, held, chains, root, testFiles)
             continue;
         }
         const aliasTypes = new Set(typeQueryAliases(file).map((alias) => alias.type));
-        const imported = packageBindings(file);
         const visit = (node, from, enclosing) => {
             const own = held.declarations.get(nodeKey(file, node));
             const holder = own ?? from;
@@ -203,10 +287,8 @@ export function indexedAccessReferences(project, held, chains, root, testFiles)
                 if (name !== undefined) {
                     const site = { file, from: holder, node, name, enclosing: inside };
                     sites.push(site);
-                    const literal = (node.arguments ?? []).some((argument) => isStringLiteral(argument) || isNumericLiteral(argument));
-                    const head = rootName(callee);
-                    if (literal && isCallExpression(node) && head !== undefined && imported.has(head)) {
-                        literalCalls.push(site);
+                    if (isCallExpression(node) && node.arguments.length > 0) {
+                        argumentCalls.push(site);
                     }
                 }
             }
@@ -234,6 +316,47 @@ export function indexedAccessReferences(project, held, chains, root, testFiles)
             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) => {
+        if (isPropertyAccessExpression(callee)) {
+            const type = queries.typeAt(callee.expression);
+            const args = type === UNANSWERED || type === undefined ? [] : queries.typeArguments(type);
+            if (type !== UNANSWERED && type !== undefined && args !== UNANSWERED && args.length > 0) {
+                return type;
+            }
+        }
+        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 undefined;
+        }
+        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 undefined;
+    };
     /** What one site fixes for one side of a carried access. */
     const fixedAt = (site, side, generic) => {
         if (side.kind === "written") {
@@ -242,23 +365,26 @@ export function indexedAccessReferences(project, held, chains, root, testFiles)
         const { node } = site;
         if (side.kind === "receiver") {
             const callee = isCallExpression(node) ? node.expression : undefined;
-            if (callee === undefined || !isPropertyAccessExpression(callee)) {
-                return undefined;
-            }
-            const receiver = queries.typeAt(callee.expression);
-            if (receiver === UNANSWERED || receiver === undefined) {
+            const receiver = callee === undefined ? undefined : receiverTypeOf(callee);
+            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);
-            return passed === undefined
-                ? { kind: "node", node: written }
-                : { kind: "passed", generic: passed.generic, index: passed.index };
+            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;
@@ -352,40 +478,120 @@ export function indexedAccessReferences(project, held, chains, root, testFiles)
             }
         });
     }
-    // A generic function or method declared outside the project's own files carries what
-    // its own text indexes by its type parameters and its receiver's.
-    const outside = literalCalls.filter((site) => !resolvedGenerics.has(site));
-    const methods = outside.length === 0
-        ? []
-        : queries.symbolsAt(outside.map((site) => {
-            const callee = site.node.expression;
-            return isPropertyAccessExpression(callee) ? callee.name : callee;
-        }));
+    // 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) => [
+        ...site.node.arguments,
+    ]);
+    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) > 0) {
+            literalArgument.add(node);
+        }
+    });
     const own = project.ownPaths();
-    outside.forEach((site, at) => {
-        const named = methods[at];
-        const symbol = named === UNANSWERED || named === undefined || (named.flags & SymbolFlags.Alias) === 0
-            ? named
-            : queries.aliased(named);
-        if (symbol === UNANSWERED ||
-            symbol === undefined ||
-            (symbol.flags & (SymbolFlags.Function | SymbolFlags.Method)) === 0) {
-            return;
+    for (const site of outside) {
+        if (!site.node.arguments.some((one) => literalArgument.has(one))) {
+            continue;
         }
-        for (const handle of symbol.declarations) {
-            if (own.has(handle.path)) {
-                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 (site.node.arguments.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 = site.node.arguments.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 node = project.declarationAt(handle)?.node;
-            const generic = node === undefined ? undefined : genericOf(node);
-            if (generic === undefined) {
+        }
+        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;
             }
-            for (const one of carriedIn(generic)) {
-                readAt(site, generic, one);
+            const names = access.index.isTypeParameter()
+                ? parameters.flatMap((parameter, at) => {
+                    if (parameter.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] : []),
@@ -437,67 +643,6 @@ export function indexedAccessReferences(project, held, chains, root, testFiles)
     }
     return found;
 }
-/**
- * The local names one file binds to a package: each name an import declaration with a
- * bare specifier binds, and each variable initialized by a call or a construction whose
- * callee such a name heads, read in source order.
- */
-function packageBindings(file) {
-    const names = new Set();
-    for (const statement of file.statements) {
-        if (!isImportDeclaration(statement) ||
-            !isStringLiteral(statement.moduleSpecifier) ||
-            /^[./]/u.test(statement.moduleSpecifier.text)) {
-            continue;
-        }
-        const clause = statement.importClause;
-        if (clause?.name !== undefined) {
-            names.add(clause.name.text);
-        }
-        const bindings = clause?.namedBindings;
-        if (bindings !== undefined && isNamespaceImport(bindings)) {
-            names.add(bindings.name.text);
-        }
-        else if (bindings !== undefined && isNamedImports(bindings)) {
-            bindings.elements.forEach((element) => names.add(element.name.text));
-        }
-    }
-    if (names.size === 0) {
-        return names;
-    }
-    const visit = (node) => {
-        if (isVariableDeclaration(node) &&
-            isIdentifier(node.name) &&
-            node.initializer !== undefined &&
-            (isCallExpression(node.initializer) || isNewExpression(node.initializer))) {
-            const head = rootName(node.initializer.expression);
-            if (head !== undefined && names.has(head)) {
-                names.add(node.name.text);
-            }
-        }
-        node.forEachChild(visit);
-    };
-    visit(file);
-    return names;
-}
-/** The identifier an expression is headed by, through property accesses and calls. */
-function rootName(expression) {
-    let at = expression;
-    for (;;) {
-        if (isIdentifier(at)) {
-            return at.text;
-        }
-        if (isPropertyAccessExpression(at) || isCallExpression(at) || isNewExpression(at)) {
-            at = at.expression;
-            continue;
-        }
-        if (isParenthesizedExpression(at) || isNonNullExpression(at)) {
-            at = at.expression;
-            continue;
-        }
-        return undefined;
-    }
-}
 /** What makes two carried accesses one: the kind and position of each side, or its written node. */
 function sideKey(one) {
     const key = (side) => side.kind === "written" ? ["written", side.node.pos, side.node.end] : [side.kind, side.index];