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

package/dist/src/intra-function-parts.js

@@ -4,7 +4,7 @@
  * call sites that use or discard it, each statement control flow cannot reach, each
  * write to a local that no read reaches, and each case an earlier case covers.
  */
-import { isArrowFunction, isAwaitExpression, isBigIntLiteral, isBinaryExpression, isBlock, isBreakStatement, isBindingElement, isCallExpression, isCaseClause, isCatchClause, isClassDeclaration, isClassExpression, isContinueStatement, isDecorator, isDefaultClause, isEmptyStatement, isExportAssignment, isExportSpecifier, isExpressionStatement, isFunctionDeclaration, isFunctionExpression, isHeritageClause, isIdentifier, isIfStatement, isImportClause, isImportSpecifier, isInterfaceDeclaration, isMethodDeclaration, isModuleDeclaration, isNamespaceImport, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectBindingPattern, isObjectLiteralExpression, isParenthesizedExpression, isPrefixUnaryExpression, isPropertyAccessExpression, isQualifiedName, isReturnStatement, isShorthandPropertyAssignment, isStringLiteral, isSwitchStatement, isThrowStatement, isTypeAliasDeclaration, isTypeReferenceNode, isVariableStatement, isVoidExpression, NodeFlags, SyntaxKind, } from "@typescript/native/unstable/ast";
+import { isArrayBindingPattern, isArrowFunction, isAwaitExpression, isBigIntLiteral, isBinaryExpression, isBlock, isBreakStatement, isBindingElement, isCallExpression, isCaseClause, isCatchClause, isClassDeclaration, isClassExpression, isContinueStatement, isDecorator, isDefaultClause, isEmptyStatement, isExportAssignment, isExportSpecifier, isExpressionStatement, isFunctionDeclaration, isFunctionExpression, isHeritageClause, isIdentifier, isIfStatement, isImportClause, isImportSpecifier, isInterfaceDeclaration, isMethodDeclaration, isModuleDeclaration, isNamespaceImport, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectBindingPattern, isObjectLiteralExpression, isParenthesizedExpression, isPrefixUnaryExpression, isPropertyAccessExpression, isQualifiedName, isReturnStatement, isShorthandPropertyAssignment, isStringLiteral, isSwitchStatement, isThrowStatement, isTypeAliasDeclaration, isTypeReferenceNode, isVariableStatement, isVoidExpression, NodeFlags, SyntaxKind, } from "@typescript/native/unstable/ast";
 import { nodeKey } from "./inventory.js";
 import { positionKey, renderPosition } from "./position.js";
 import { isAnswered, UNANSWERED } from "./query.js";
@@ -277,6 +277,7 @@ export function projectParts(project, held, references, targetRoot) {
     const calls = new Map();
     const specifiers = new Set();
     const sites = [];
+    const contextual = [];
     for (const file of files) {
         const declarationAt = (node) => {
             const id = held.declarations.get(nodeKey(file, node));
@@ -421,13 +422,17 @@ export function projectParts(project, held, references, targetRoot) {
             });
             const reader = readers.get(one.signature);
             if (reader !== undefined) {
-                parts.push(...parameterParts(file, targetRoot, one.id, one.signature, reader, ids, false));
+                const found = parameterParts(file, targetRoot, one.id, one.signature, reader, ids, false);
+                parts.push(...found.parts);
+                contextual.push(...found.contextual);
             }
         }
         for (const one of walk.values) {
             const reader = readers.get(one.signature);
             if (reader !== undefined) {
-                parts.push(...parameterParts(file, targetRoot, one.holder, one.signature, reader, ids, true));
+                const found = parameterParts(file, targetRoot, one.holder, one.signature, reader, ids, true);
+                parts.push(...found.parts);
+                contextual.push(...found.contextual);
             }
         }
         walk.catches.forEach(({ name, holder }, at) => {
@@ -471,7 +476,7 @@ export function projectParts(project, held, references, targetRoot) {
         }
     }
     parts.push(...resultParts(project, targetRoot, sites, references, calls));
-    return { parts, signatures, calls, specifiers };
+    return { parts: withContextualRead(project, parts, contextual), signatures, calls, specifiers };
 }
 /**
  * A function written in place that no declaration declares: an arrow, a function
@@ -533,8 +538,26 @@ function parameterNames(signature) {
     return found;
 }
 /**
- * Each name one function's parameters bind and whether the function reads it. A binding
- * pattern counts as read where its function reads any name it binds.
+ * The parts with each name of `contextual` read where the compiler gives its function a
+ * contextual type: the inference of the call holding the function may read a parameter's
+ * annotation, and the code handing the argument may act on what an object pattern reads.
+ * A question the checker leaves unanswered keeps the name read.
+ */
+function withContextualRead(project, parts, contextual) {
+    if (contextual.length === 0) {
+        return parts;
+    }
+    const signatures = [...new Set(contextual.map((one) => one.signature))];
+    const answers = project.queries.contextualTypes(signatures);
+    const typed = new Set(signatures.filter((_signature, at) => answers[at] !== undefined));
+    const read = new Set(contextual.filter((one) => typed.has(one.signature)).map((one) => one.part));
+    return parts.map((part) => (read.has(part) ? { ...part, used: true } : part));
+}
+/**
+ * Each name one function's parameters bind and whether the function reads it, and the
+ * unread names a contextual type of a function expression may keep: those of a parameter
+ * that carries a type annotation or is an object binding pattern. A binding pattern counts
+ * as read where its function reads any name it binds.
  */
 function parameterParts(file, root, declaration, signature, reader, ids, inValue) {
     // A function that reads `arguments` reads every parameter by position.
@@ -543,11 +566,13 @@ function parameterParts(file, root, declaration, signature, reader, ids, inValue
         reader.uses.some((use) => use.text === name.text && readsBinding(use, name, ids)));
     const lastRead = Math.max(-1, ...reader.names.filter((_, at) => read[at]).map((one) => one.at));
     const found = [];
+    const contextual = [];
+    const expression = isArrowFunction(signature) || isFunctionExpression(signature) ? signature : undefined;
     reader.names.forEach(({ name, at, pattern, exempt }, index) => {
         if (exempt) {
             return;
         }
-        found.push({
+        const part = {
             code: UNUSED_PARAMETER,
             declaration,
             kind: "parameter",
@@ -556,9 +581,30 @@ function parameterParts(file, root, declaration, signature, reader, ids, inValue
             message: `parameter ${name.text} is never read in the body`,
             used: read[index] === true,
             parameter: { beforeARead: !pattern && at < lastRead, inValue },
-        });
+        };
+        found.push(part);
+        const parameter = signature.parameters[at];
+        if (expression !== undefined &&
+            !part.used &&
+            parameter !== undefined &&
+            (parameter.type !== undefined || isObjectBindingPattern(parameter.name))) {
+            contextual.push({ part, signature: expression });
+        }
     });
-    return found;
+    return { parts: found, contextual };
+}
+/**
+ * The names one declaration binds that a write of its initializer stores each on its own:
+ * the declared name, or each element name of an array binding pattern at any depth.
+ */
+function arrayPatternNames(name) {
+    if (isIdentifier(name)) {
+        return [name];
+    }
+    if (!isArrayBindingPattern(name)) {
+        return [];
+    }
+    return name.elements.flatMap((element) => isBindingElement(element) && element.name !== undefined ? arrayPatternNames(element.name) : []);
 }
 /** The locals one block declares with `let` or `const`, each with the names that spell it. */
 function localsOf(block) {
@@ -573,9 +619,9 @@ function localsOf(block) {
             return;
         }
         for (const declaration of list.declarations) {
-            if (isIdentifier(declaration.name)) {
+            for (const name of arrayPatternNames(declaration.name)) {
                 declared.push({
-                    name: declaration.name,
+                    name,
                     statement: at,
                     initialized: declaration.initializer !== undefined,
                 });

package/dist/src/kinds.js

@@ -70,7 +70,7 @@ const ROWS = [
         code: "DS1101",
         name: "unnecessary-export",
         languages: ["go", "ts"],
-        rule: "An exported symbol whose every reference is inside the symbol's own package or module, reported as a candidate for unexporting. The subject is a package-level declaration or a method. Three subjects are excluded. An interface method is excluded because its exportedness is the contract of the interface that declares it. A struct field is excluded because an encoder reads it by name. A method that satisfies an interface some symbol uses as a type is excluded because it cannot be unexported without its type ceasing to satisfy that interface. The finding names the narrower visibility the references support. A declared cross-language edge counts as an out-of-package reference. Where the edge's other side is unknown to the analyzer, the finding is emitted pending.",
+        rule: "An exported symbol whose every reference is inside the symbol's own package or module, reported as a candidate for unexporting. The subject is a package-level declaration or a method. Three subjects are excluded. An interface method is excluded because its exportedness is the contract of the interface that declares it. A struct field is excluded because an encoder reads it by name. A method that satisfies an interface some symbol uses as a type is excluded because it cannot be unexported without its type ceasing to satisfy that interface, and so is a method whose name and signature are those of a method of an exported interface type declared by a package outside the target that the import closure holds, because that interface fixes them whether or not the program converts the method's type to it. The finding names the narrower visibility the references support. A declared cross-language edge counts as an out-of-package reference. Where the edge's other side is unknown to the analyzer, the finding is emitted pending. A reference from a Go external test package, a test file whose package clause names its directory's package with the suffix _test, is a reference from outside the package, because that test builds as another package and needs the export.",
         precondition: "Closed world only. A Go main package, and an internal/ directory tree for importers outside its parent, are closed worlds whatever the configuration declares, because no other program can import them, so this finding is reported there always. A published package is a closed world only when the configuration declares the consumer set complete and every declared consumer loads. A library with no consumer loaded and no complete consumer set declared gets this finding on its internal/ tree and its main packages and never on its published API. A symbol the rule of DS1301 holds for is not reported under this code, whatever severity the configuration gives DS1301, because the write-only finding names the defect to fix first. A type that a parameter or a result of an exported function or method of its own package names is not reported when a reference from outside the package references that function or method, because the caller holds values of the type, and unexporting it would leave an exported signature naming a type its callers cannot name.",
         defaultSeverity: "warn",
         maxClass: "certain",
@@ -81,7 +81,7 @@ const ROWS = [
         code: "DS1102",
         name: "unnecessary-exposure",
         languages: ["go"],
-        rule: "An exported symbol of a non-internal package whose every reference is inside the target module, reported as a candidate for relocation behind an internal boundary. The subject is a package-level declaration or a method. Three subjects are excluded. An interface method is excluded because its exportedness is the contract of the interface that declares it. A struct field is excluded because an encoder reads it by name. A method that satisfies an interface some symbol uses as a type is excluded because it cannot be unexported without its type ceasing to satisfy that interface. The finding names the narrower visibility the references support. A declared cross-language edge counts as an out-of-package reference. Where the edge's other side is unknown to the analyzer, the finding is emitted pending.",
+        rule: "An exported symbol of a non-internal package whose every reference is inside the target module, reported as a candidate for relocation behind an internal boundary. The subject is a package-level declaration or a method. Three subjects are excluded. An interface method is excluded because its exportedness is the contract of the interface that declares it. A struct field is excluded because an encoder reads it by name. A method that satisfies an interface some symbol uses as a type is excluded because it cannot be unexported without its type ceasing to satisfy that interface, and so is a method whose name and signature are those of a method of an exported interface type declared by a package outside the target that the import closure holds, because that interface fixes them whether or not the program converts the method's type to it. The finding names the narrower visibility the references support. A declared cross-language edge counts as an out-of-package reference. Where the edge's other side is unknown to the analyzer, the finding is emitted pending. A reference from a Go external test package, a test file whose package clause names its directory's package with the suffix _test, is a reference from outside the package, because that test builds as another package and needs the export.",
         precondition: "Closed world only. Reported always for a main package and an internal/ directory tree, and for a published package only when the configuration declares the consumer set complete and every declared consumer loads. A library with no consumer loaded and no complete consumer set declared gets this finding on its internal/ tree and its main packages and never on its published API. A symbol the rule of DS1301 holds for is not reported under this code, whatever severity the configuration gives DS1301, because the write-only finding names the defect to fix first. A type that a parameter or a result of an exported function or method of its own package names is not reported when a reference from outside the target module references that function or method, because the caller holds values of the type, and moving it behind an internal boundary would leave an exported signature naming a type its callers cannot name.",
         defaultSeverity: "warn",
         maxClass: "certain",
@@ -197,7 +197,7 @@ const ROWS = [
         name: "unused-dependency",
         languages: ["go", "ts"],
         rule: "A directly declared dependency that no import in the target needs. On the Go side, a direct require whose module provides no package any target package or test variant imports. On the TypeScript side, a manifest dependency, development dependency or peer dependency the project's import closure does not need. A deletion finding whose fix would remove the last use of a dependency names that dependency.",
-        precondition: "On the Go side the rule is the semantics of `go mod tidy -diff` exactly: a requirement marked indirect is never reported, because it exists to pin a transitive version and removing it changes the build list. On the TypeScript side the import closure is the files of the run's projects, and four more dependencies are needed. The first is one whose installed manifest declares a command, because a command is run by name rather than imported. The second is one that the installed manifest of a needed dependency declares as a peer and does not mark optional. The third is every required peer of a dependency so held, to a fixpoint. The fourth is one that a string names under a manifest key of an applied convention row, as grammar/analysis.md states. An installed manifest is the package's manifest in the nearest node_modules directory at or above the target, and a dependency with none is decided by the import closure alone.",
+        precondition: "On the Go side the rule is the semantics of `go mod tidy -diff` exactly: a requirement marked indirect is never reported, because it exists to pin a transitive version and removing it changes the build list. On the TypeScript side the import closure is the files of the run's projects, and a call of `import.meta.resolve` or of `require.resolve` in them, whatever `require` names, whose first argument is a string literal or a template literal with no substitution needs each dependency an import of that specifier needs. Three more dependencies are needed: one whose command a script entry or a workflow step runs, one that a string of a configuration file names, and one that a string names under a manifest key or a package key of an applied convention row, each as grammar/analysis.md states. A command no script entry and no workflow step runs needs nothing, and a peer the installed manifest of a needed dependency requires is needed only as any other dependency is, because the package manager installs a required peer itself. A dependency of a manifest whose directory holds source only in configurations the run lists in configurations_not_built is reported at the reachability class possible, because the source that may import it was not analyzed. An installed manifest is the package's manifest in the nearest node_modules directory at or above the target, and a dependency with none is decided by the import closure alone.",
         defaultSeverity: "deny",
         maxClass: "certain",
         fixability: "manual",
@@ -279,7 +279,7 @@ const ROWS = [
         name: "unused-parameter",
         languages: ["go", "ts"],
         rule: "A parameter with no reference inside its function body, on a function whose signature is free to change.",
-        precondition: "The signature must be free, defined as follows: the function is not a method retained by interface satisfaction, is not used as a value, is not a go:linkname or cgo target, is not a function the Go test driver runs (a test, benchmark or fuzz test of a test file, or TestMain), and is not a stub whose body is empty or only panics. A parameter its body never names is dead whatever the callers, so a published declaration of a library is reported too, with the fixability the vocabulary gives the kind: the signature change is a breaking change. In TypeScript a caller may pass a function used as a value more arguments than it declares parameters, so in such a function whose signature is free but for that use, a parameter its body never reads is reported when its body reads no parameter after it, and an unread parameter before the last read one is not. A TypeScript parameter that is a binding pattern is judged by the names it binds: each name the body never reads is reported wherever the pattern stands, because removing it from the pattern moves no argument, except a name beside a rest element of the same object pattern, whose removal changes what that element holds, and the pattern counts as a read parameter when the body reads any name it binds. A rest parameter is judged as the last parameter. A TypeScript `this` parameter declares the type of `this` and receives no argument, so it is never reported. No name exempts a parameter. A TypeScript parameter whose name starts with an underscore is judged as any other is, and a Go parameter named by the blank identifier declares no name a body could read and is never reported.",
+        precondition: "The signature must be free, defined as follows: the function is not a method retained by interface satisfaction, is not a method whose name and signature are those of a method of an exported interface type declared by a package outside the target that the import closure holds, is not used as a value, is not a go:linkname or cgo target, is not a function the Go test driver runs (a test, benchmark or fuzz test of a test file, or TestMain), and is not a stub whose body is empty or only panics. A function literal or function expression that initializes a variable the program only calls, never passing, storing, returning or assigning it, is called by name and is not used as a value. A parameter its body never names is dead whatever the callers, so a published declaration of a library is reported too, with the fixability the vocabulary gives the kind: the signature change is a breaking change. In TypeScript a caller may pass a function used as a value more arguments than it declares parameters, so in such a function whose signature is free but for that use, a parameter its body never reads is reported when its body reads no parameter after it, and an unread parameter before the last read one is not. A parameter of a TypeScript function expression or arrow function that the compiler gives a contextual type is not reported when it carries a type annotation, because the inference of the call that holds the function may read the annotation, or when it is an object binding pattern, because the pattern reads each property it names from the argument and the code that hands the argument may act on that read. No name such a pattern binds is reported either. Any other TypeScript parameter that is a binding pattern is judged by the names it binds: each name the body never reads is reported wherever the pattern stands, because removing it from the pattern moves no argument, except a name beside a rest element of the same object pattern, whose removal changes what that element holds, and the pattern counts as a read parameter when the body reads any name it binds. A rest parameter is judged as the last parameter. A TypeScript `this` parameter declares the type of `this` and receives no argument, so it is never reported. No name exempts a parameter. A TypeScript parameter whose name starts with an underscore is judged as any other is, and a Go parameter named by the blank identifier declares no name a body could read and is never reported.",
         defaultSeverity: "warn",
         maxClass: "certain",
         fixability: "manual",
@@ -290,8 +290,8 @@ const ROWS = [
         code: "DS1802",
         name: "unused-receiver",
         languages: ["go"],
-        rule: "A named method receiver with no reference inside the method body, on a method whose signature is free to change. Go permits a method with no receiver name, so the fix deletes an identifier and changes no signature.",
-        precondition: "The same free-signature rule as unused-parameter, applied to the receiver.",
+        rule: "A named method receiver with no reference inside the method body. Go permits a method with no receiver name, so the fix deletes an identifier and changes no signature.",
+        precondition: "None beyond the rule. Deleting a receiver name changes no signature, so a method retained by interface satisfaction, a method used as a value and a stub are reported as any other method is.",
         defaultSeverity: "warn",
         maxClass: "certain",
         fixability: "deletable",

package/dist/src/references.js

@@ -14,6 +14,7 @@ import { dirnamePath, queriedModulePath, relativePath, resolvePath } from "./pat
 import { byPosition, isComponentFile, renderPosition } from "./position.js";
 import { DEFAULT_BATCH_CAP, propertyTables, UNANSWERED } from "./query.js";
 import { typeQueryAliases } from "./type-query-alias.js";
+import { computedKeyNames, keyNameOf, keyedUses } from "./symbol-keys.js";
 import { handedOn, valuesOf } from "./value-flow.js";
 /**
  * The operators whose left side one assignment stores into. A compound assignment is
@@ -84,12 +85,11 @@ function unparenthesized(node) {
  * Records the name one store writes into.
  *
  * A property access writes the member it names. An element access writes the collection
- * it stores into, because a collection a module only ever stores into holds nothing
- * anything reads, and the key is no declaration of the target. A destructuring target
- * writes each name it binds, through the spreads and the nested patterns it binds them
- * in.
+ * it stores into, since a collection a module only stores into holds nothing anything
+ * reads, and joins `accesses` for the member a unique-symbol key selects. A destructuring
+ * target writes each name it binds, through its spreads and nested patterns.
  */
-function markWrite(target, writes) {
+function markWrite(target, writes, accesses) {
     const held = unparenthesized(target);
     if (isName(held)) {
         writes.add(held.pos);
@@ -102,37 +102,38 @@ function markWrite(target, writes) {
         return;
     }
     if (isElementAccessExpression(held)) {
+        accesses.add(held);
         // A store through a member's value lands in storage every holder of the value
         // reads, so it reads the member; a variable only ever stored into stays written.
         if (!isPropertyAccessExpression(unparenthesized(held.expression))) {
-            markWrite(held.expression, writes);
+            markWrite(held.expression, writes, accesses);
         }
         return;
     }
     if (isArrayLiteralExpression(held)) {
         for (const element of held.elements) {
-            markWrite(element, writes);
+            markWrite(element, writes, accesses);
         }
         return;
     }
     if (isObjectLiteralExpression(held)) {
         for (const property of held.properties) {
             if (isPropertyAssignment(property)) {
-                markWrite(property.initializer, writes);
+                markWrite(property.initializer, writes, accesses);
                 continue;
             }
             if (isShorthandPropertyAssignment(property)) {
-                markWrite(property.name, writes);
+                markWrite(property.name, writes, accesses);
                 continue;
             }
             if (isSpreadAssignment(property)) {
-                markWrite(property.expression, writes);
+                markWrite(property.expression, writes, accesses);
             }
         }
         return;
     }
     if (isSpreadElement(held)) {
-        markWrite(held.expression, writes);
+        markWrite(held.expression, writes, accesses);
     }
 }
 /**
@@ -142,14 +143,14 @@ function markWrite(target, writes) {
  * holds. A store that reads its target as well records it in `reads`: a logical
  * assignment, and a compound assignment, an increment or a decrement whose value is used.
  */
-function markStores(node, writes, reads) {
+function markStores(node, writes, reads, accesses) {
     if (isBinaryExpression(node)) {
         const operator = node.operatorToken.kind;
         if (ASSIGNMENTS.has(operator)) {
-            markWrite(node.left, writes);
+            markWrite(node.left, writes, accesses.written);
             if (LOGICAL_ASSIGNMENTS.has(operator) ||
                 (operator !== SyntaxKind.EqualsToken && !valueDiscarded(node))) {
-                markWrite(node.left, reads);
+                markWrite(node.left, reads, accesses.read);
             }
         }
         return;
@@ -157,20 +158,20 @@ function markStores(node, writes, reads) {
     if (isPrefixUnaryExpression(node) || isPostfixUnaryExpression(node)) {
         if (node.operator === SyntaxKind.PlusPlusToken ||
             node.operator === SyntaxKind.MinusMinusToken) {
-            markWrite(node.operand, writes);
+            markWrite(node.operand, writes, accesses.written);
             if (!valueDiscarded(node)) {
-                markWrite(node.operand, reads);
+                markWrite(node.operand, reads, accesses.read);
             }
         }
         return;
     }
     if (isDeleteExpression(node)) {
-        markWrite(node.expression, writes);
+        markWrite(node.expression, writes, accesses.written);
         return;
     }
     if (isForInStatement(node) || isForOfStatement(node)) {
         if (node.initializer.kind !== SyntaxKind.VariableDeclarationList) {
-            markWrite(node.initializer, writes);
+            markWrite(node.initializer, writes, accesses.written);
         }
     }
 }
@@ -337,6 +338,8 @@ function sitesOf(file, declarations, fileId, unread) {
     const flows = [];
     const writes = new Set();
     const alsoRead = new Set();
+    const accesses = { written: new Set(), read: new Set() };
+    const keyed = [];
     const declared = new Set();
     const shorthands = new Map();
     let enclosing = fileId;
@@ -381,7 +384,17 @@ function sitesOf(file, declarations, fileId, unread) {
             return;
         }
         markNames(node);
-        markStores(node, writes, alsoRead);
+        markStores(node, writes, alsoRead, accesses);
+        const key = isElementAccessExpression(node) ? keyNameOf(node.argumentExpression) : undefined;
+        if (key !== undefined && isElementAccessExpression(node)) {
+            const written = accesses.written.has(node);
+            keyed.push({
+                access: node,
+                key,
+                from: enclosing,
+                use: written ? (accesses.read.has(node) ? "both" : "write") : "read",
+            });
+        }
         if (isObjectLiteralExpression(node) && !isAssignmentPattern(node)) {
             literals.push({ literal: node, from: enclosing });
         }
@@ -415,7 +428,18 @@ function sitesOf(file, declarations, fileId, unread) {
         enclosing = outer;
     };
     file.forEachChild(visit);
-    return { uses: found, literals, flows, reads, links, evaluations, wholes, urls, decorated };
+    return {
+        uses: found,
+        literals,
+        flows,
+        reads,
+        links,
+        evaluations,
+        wholes,
+        urls,
+        decorated,
+        keyed,
+    };
 }
 /** The declaration kinds of a property an object literal declares. */
 const LITERAL_PROPERTY_KINDS = new Set([
@@ -827,7 +851,8 @@ export function references(project, held, targetRoot, options) {
             }
         }
     }
-    for (const { file, fileId, uses, reads, links, evaluations, wholes, urls, decorated } of walked) {
+    const keyNames = computedKeyNames(held.symbols);
+    for (const { file, fileId, uses, reads, links, evaluations, wholes, urls, decorated, keyed, } of walked) {
         const test = testFile.get(file) === true;
         // A component file's markup may use any binding its blocks declare at the top level.
         const markup = isComponentFile(file);
@@ -1029,6 +1054,20 @@ export function references(project, held, targetRoot, options) {
                 });
             }
         });
+        const resolvedKeys = keyed.flatMap((access) => {
+            const symbol = isIdentifier(access.key) && keyNames.has(access.key.text)
+                ? answered.get(access.key)
+                : undefined;
+            return typeof symbol === "object" ? [{ access, symbol }] : [];
+        });
+        for (const { access, ids } of keyedUses(project, chains, resolvedKeys, tables, cap)) {
+            const position = renderPosition(file, root, access.access.argumentExpression.getStart());
+            for (const id of ids) {
+                for (const use of access.use === "both" ? ["read", "write"] : [access.use]) {
+                    found.push({ from: access.from, to: id, position, use, resolution: "keyed", test });
+                }
+            }
+        }
         for (const site of uses) {
             const direct = site.shorthand !== undefined
                 ? "shorthand"

package/dist/src/roots.js

@@ -7,7 +7,7 @@
  * decides; the published API only supposes a consumer, so a published export is live
  * under reachability and still a candidate under reference counting.
  */
-import { isExpressionWithTypeArguments, isFunctionLikeDeclaration, isPropertyAccessExpression, isQualifiedName, isTypeQueryNode, isTypeReferenceNode, isVariableStatement, } from "@typescript/native/unstable/ast";
+import { isExpressionWithTypeArguments, isFunctionLikeDeclaration, isPropertyAccessExpression, isQualifiedName, isTypeQueryNode, isTypeReferenceNode, isPropertyDeclaration, isVariableDeclaration, isVariableStatement, } from "@typescript/native/unstable/ast";
 import { aliasChains } from "./alias-chain.js";
 import { conventionEntries } from "./conventions.js";
 import { entryPoints } from "./entry-points.js";
@@ -18,6 +18,15 @@ import { byPosition } from "./position.js";
 import { UNANSWERED } from "./query.js";
 import { sourceFilesOf } from "./source-files.js";
 import { typeQueryAliases } from "./type-query-alias.js";
+/** Whether one declaration is written below the directory of a published workspace member. */
+function inPublishedMember(held, id, root, members) {
+    const path = held.symbols.find((symbol) => symbol.id === id)?.position.path;
+    if (path === undefined || members === undefined) {
+        return false;
+    }
+    const file = resolvePath(root, path);
+    return [...members].some((dir) => file.startsWith(`${dir}/`));
+}
 /** The kind of root each role of a manifest entry makes. */
 const ENTRY_KINDS = {
     import: "manifest-entry",
@@ -167,10 +176,15 @@ export function roots(project, held, targetRoot, options) {
     const entries = [
         ...options.manifest.entries.map((entry) => ({
             entry,
-            publishes: entry.published &&
+            publishes: options.publishedAPI &&
+                entry.published &&
                 (options.manifest.declaresExports ? entry.member.startsWith("exports") : true),
         })),
-        ...(options.otherPackages ?? []).map((entry) => ({ entry, publishes: entry.published })),
+        ...(options.otherPackages ?? []).map((entry) => ({
+            entry,
+            publishes: entry.published &&
+                (options.publishedAPI || options.publishedMembers?.has(entry.dir) === true),
+        })),
     ];
     const scripted = entries.flatMap(({ entry }) => entry.role === "script" ? files.named(entry.path) : []);
     const readBackTo = [
@@ -184,7 +198,7 @@ export function roots(project, held, targetRoot, options) {
             : readBackByName(options.host, entry, readBackTo);
     };
     for (const { entry, publishes } of entries) {
-        if (options.publishedAPI && publishes) {
+        if (publishes) {
             published.push(...entryFiles(entry));
         }
     }
@@ -238,8 +252,9 @@ export function roots(project, held, targetRoot, options) {
             }
         }
     }
-    const api = options.publishedAPI
-        ? publishedAPI(project, published, exportsOf, held, files.byPath, releaseTagged(held, files))
+    const tagged = releaseTagged(held, files).filter((id) => options.publishedAPI || inPublishedMember(held, id, targetRoot, options.publishedMembers));
+    const api = published.length > 0 || tagged.length > 0
+        ? publishedAPI(project, published, exportsOf, held, files.byPath, tagged)
         : { ids: [], guessed: [] };
     for (const id of api.ids) {
         add(id, "published-api", "");
@@ -395,6 +410,15 @@ function publishedAPI(project, published, exportsOf, held, byPath, tagged) {
             const symbol = byId.get(id);
             return symbol === undefined || symbol.kind === "file" ? [] : nodes.typeNamesOf(symbol);
         });
+        for (const symbol of inferredTypeSymbols(project, round.flatMap((id) => {
+            const symbol = byId.get(id);
+            const node = symbol === undefined ? undefined : nodes.nodeOf(symbol);
+            return node === undefined ? [] : [node];
+        }))) {
+            for (const target of chains.chainOf(symbol)) {
+                reach(target.id);
+            }
+        }
         project.symbolsAt(named.map((node) => project.handle(node))).forEach((symbol, index) => {
             if (symbol === UNANSWERED) {
                 for (const id of held.byName.get(named[index]?.getText() ?? "") ?? []) {
@@ -443,8 +467,74 @@ function declarationNodes(held, byPath) {
             const declaration = byId.get(symbol.id);
             return declaration === undefined ? [] : typeNamesOf(declaration, nodes);
         },
+        nodeOf: (symbol) => nodesIn(symbol.position.path).byId.get(symbol.id),
     };
 }
+/** How deep the type arguments and constituents of an inferred type are followed. */
+const INFERRED_DEPTH = 4;
+/**
+ * The declarations of the types the compiler infers where a declaration writes none: the
+ * type of a variable or a property with no annotation, and the result of a function or a
+ * method with no result annotation, each with the types its type arguments and its union
+ * or intersection constituents name, to a fixed depth. A question the checker leaves
+ * unanswered names nothing.
+ */
+function inferredTypeSymbols(project, declarations) {
+    const { queries } = project;
+    const valued = declarations.flatMap((node) => (isVariableDeclaration(node) || isPropertyDeclaration(node)) &&
+        node.type === undefined &&
+        !isFunctionLikeDeclaration(node.initializer ?? node)
+        ? [node.name]
+        : []);
+    const types = [];
+    queries.typesAt(valued).forEach((type) => {
+        if (type !== UNANSWERED && type !== undefined) {
+            types.push(type);
+        }
+    });
+    for (const node of declarations) {
+        const signature = isFunctionLikeDeclaration(node)
+            ? node
+            : isVariableDeclaration(node) &&
+                node.type === undefined &&
+                node.initializer !== undefined &&
+                isFunctionLikeDeclaration(node.initializer)
+                ? node.initializer
+                : undefined;
+        if (signature === undefined || signature.type !== undefined || signature.body === undefined) {
+            continue;
+        }
+        const typed = queries.signatureOf(signature);
+        const result = typed === UNANSWERED || typed === undefined ? undefined : queries.returnTypeOf(typed);
+        if (result !== UNANSWERED && result !== undefined) {
+            types.push(result);
+        }
+    }
+    const found = new Map();
+    const seen = new Set();
+    const visit = (type, depth) => {
+        if (depth > INFERRED_DEPTH || seen.has(type)) {
+            return;
+        }
+        seen.add(type);
+        const symbol = queries.symbolOfType(type);
+        if (symbol !== UNANSWERED && symbol !== undefined) {
+            found.set(symbol.id, symbol);
+        }
+        const parts = queries.constituents(type);
+        const args = queries.typeArguments(type);
+        for (const next of [
+            ...(parts === UNANSWERED || (parts.length === 1 && parts[0] === type) ? [] : parts),
+            ...(args === UNANSWERED ? [] : args),
+        ]) {
+            visit(next, depth + 1);
+        }
+    };
+    types.forEach((type) => {
+        visit(type, 0);
+    });
+    return [...found.values()];
+}
 /**
  * The names of types one declaration's own syntax writes: in a type reference, a
  * heritage clause or a type query. A function body is not read, and neither is a

package/dist/src/session.js

@@ -129,7 +129,12 @@ function viewOf(project, configFile, engine, log) {
             if ((symbol.flags & SymbolFlags.Alias) === 0) {
                 return undefined;
             }
-            const held = queries.immediateAliased(symbol);
+            // An alias the checker synthesizes declares nothing, the default a module that assigns
+            // its export gets under esModuleInterop, and the immediate step fails on it while the
+            // whole resolution answers.
+            const held = symbol.declarations.length === 0
+                ? queries.aliased(symbol)
+                : queries.immediateAliased(symbol);
             // An alias that resolves to nothing answers with the checker's own unknown
             // symbol, which declares nothing; a symbol that is no alias answers with
             // nothing at all.

package/dist/src/source-files.js

@@ -48,6 +48,7 @@ export function sourceFilesOf(project, targetRoot) {
     return {
         byPath,
         byName,
+        outputDirs: [...new Set([outDir, declarationDir])].filter((dir) => dir !== undefined),
         named: (path) => {
             if (!path.includes(SUBPATH_WILDCARD)) {
                 for (const candidate of candidates(path)) {

package/dist/src/sweep.js

@@ -163,30 +163,42 @@ function reachable(graph, held, mode) {
 /**
  * Admits every test declaration whose set of referenced production declarations is
  * non-empty and wholly dead, and returns which it admitted. The set is read from every
- * reference the test makes, not the ones the mode counts: a production sweep counts none,
- * which is what makes the targets dead. A test referencing one live target is never
- * admitted, and neither is a marked or exempt test.
+ * reference the test makes, which a production sweep does not count. A test-support
+ * declaration that a test referencing a live target also references is a live target of
+ * every test referencing it. A marked or exempt test is never admitted.
  */
 function admitTestsOfDeadCode(graph, dead, held) {
-    const admitted = graph.symbols.map(() => false);
-    graph.symbols.forEach((_symbol, at) => {
-        const testCode = graph.test[at] === true || graph.support[at] === true;
-        if (!testCode || graph.subject[at] !== true || held[at] === true) {
-            return;
-        }
+    const testCode = (at) => graph.test[at] === true || graph.support[at] === true;
+    const judged = graph.symbols.map((_symbol, at) => {
         let targets = 0;
         let live = 0;
-        for (const edge of graph.out[at] ?? []) {
-            const target = graph.test[edge.to] === true || graph.support[edge.to] === true;
-            if (target || graph.subject[edge.to] !== true) {
-                continue;
+        if (testCode(at) && graph.subject[at] === true && held[at] !== true) {
+            for (const edge of graph.out[at] ?? []) {
+                if (testCode(edge.to) || graph.subject[edge.to] !== true) {
+                    continue;
+                }
+                targets += 1;
+                if (dead[edge.to] !== true) {
+                    live += 1;
+                }
             }
-            targets += 1;
-            if (dead[edge.to] !== true) {
-                live += 1;
+        }
+        return { targets, live };
+    });
+    const shared = new Set();
+    judged.forEach(({ live }, at) => {
+        if (live > 0) {
+            for (const edge of graph.out[at] ?? []) {
+                if (graph.support[edge.to] === true) {
+                    shared.add(edge.to);
+                }
             }
         }
-        if (targets > 0 && live === 0) {
+    });
+    const admitted = graph.symbols.map(() => false);
+    judged.forEach(({ targets, live }, at) => {
+        const sharing = (graph.out[at] ?? []).some((edge) => shared.has(edge.to) && edge.to !== at);
+        if (targets > 0 && live === 0 && !sharing) {
             dead[at] = true;
             admitted[at] = true;
         }