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

package/src/kinds.ts

@@ -19,6 +19,8 @@ export interface KindRow {
   /** The highest confidence a finding of the kind carries. */
   readonly maxClass: Confidence;
   readonly fixability: Fixability;
+  /** Each fixability a finding of the kind may carry in place of `fixability`. */
+  readonly findingFixabilities?: readonly Fixability[];
   /**
    * Whether the Contract fixes the kind on at its default severity, so a severity key
    * naming the code, or a family prefix whose range holds it, is an unimplemented key.
@@ -43,6 +45,7 @@ const ROWS: readonly KindRow[] = [
     defaultSeverity: "deny",
     maxClass: "certain",
     fixability: "deletable",
+    findingFixabilities: ["manual"],
     fixed: false,
   },
   {
@@ -53,6 +56,7 @@ const ROWS: readonly KindRow[] = [
     defaultSeverity: "deny",
     maxClass: "certain",
     fixability: "deletable",
+    findingFixabilities: ["manual"],
     fixed: false,
   },
   {
@@ -65,6 +69,7 @@ const ROWS: readonly KindRow[] = [
     defaultSeverity: "deny",
     maxClass: "certain",
     fixability: "deletable",
+    findingFixabilities: ["manual"],
     fixed: false,
   },
   {
@@ -75,6 +80,7 @@ const ROWS: readonly KindRow[] = [
     defaultSeverity: "deny",
     maxClass: "certain",
     fixability: "deletable",
+    findingFixabilities: ["manual"],
     fixed: false,
   },
   {
@@ -85,6 +91,7 @@ const ROWS: readonly KindRow[] = [
     defaultSeverity: "deny",
     maxClass: "certain",
     fixability: "deletable",
+    findingFixabilities: ["manual"],
     fixed: false,
   },
   {
@@ -95,6 +102,7 @@ const ROWS: readonly KindRow[] = [
     defaultSeverity: "deny",
     maxClass: "certain",
     fixability: "deletable",
+    findingFixabilities: ["manual"],
     fixed: false,
   },
   {
@@ -103,7 +111,7 @@ const ROWS: readonly KindRow[] = [
     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, 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.",
+      "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. A package-level declaration whose name a string literal spells carries the class grammar/analysis.md gives it.",
     defaultSeverity: "warn",
     maxClass: "certain",
     fixability: "narrowable",
@@ -125,10 +133,11 @@ const ROWS: readonly KindRow[] = [
     code: "DS1103",
     name: "unreachable-export",
     languages: ["go", "ts"],
-    rule: "An unused exported symbol in a package or file no external code can import: an unused-exported candidate whose enclosing package or file is unimportable from outside, reported once under this code at the certain class, because unimportability is a property of the package graph rather than of the consumer set.",
+    rule: "An unused exported symbol in a package or file no external code can import: an unused-exported candidate whose enclosing package or file is unimportable from outside, reported once under this code at the certain class, because unimportability is a property of the package graph rather than of the consumer set, except where the confidence rule of grammar/analysis.md gives a declaration a string literal spells the class possible.",
     defaultSeverity: "deny",
     maxClass: "certain",
     fixability: "deletable",
+    findingFixabilities: ["manual"],
     fixed: false,
   },
   {
@@ -151,6 +160,7 @@ const ROWS: readonly KindRow[] = [
     defaultSeverity: "deny",
     maxClass: "certain",
     fixability: "deletable",
+    findingFixabilities: ["manual"],
     fixed: false,
   },
   {
@@ -170,6 +180,8 @@ const ROWS: readonly KindRow[] = [
     name: "unused-satisfaction-assertion",
     languages: ["go"],
     rule: "A compile-time satisfaction assertion whose interface no symbol uses as a type.",
+    precondition:
+      "In a library, an assertion whose interface is published API, an exported interface of a package outside programs can import, has the reachability class possible, whatever consumers the run declares and loads. The assertion checks a promise the published API makes, that the type satisfies the published interface, and that promise is made to every program that imports the package, not only to the consumers the run declares. A loaded consumer that names the interface as a type uses it, and the assertion is not reported.",
     defaultSeverity: "deny",
     maxClass: "certain",
     fixability: "deletable",
@@ -179,7 +191,7 @@ const ROWS: readonly KindRow[] = [
     code: "DS1301",
     name: "write-only-symbol",
     languages: ["go", "ts"],
-    rule: "A package-level or module-level variable, struct field, class member, type member or collection that production code writes and never reads. In production mode a read from a test file counts as no read. A write from a loaded consumer's code counts as a read, because the deletion the finding names would break a consumer the target does not own. A write in a consumer's test file counts as a read in the run that counts test references. It counts in a production sweep only where the configuration counts consumer tests as production. A comparison of struct values reads every field of the type: in Go, a value of a struct type used as an operand of `==` or `!=`, as a map key, or as a `switch` tag or `case` expression is a read of every field of that type, transitively through the fields of every struct type it holds, recorded at the comparison, because equality reads every field and a field that decides equality carries information. In Go a type argument the program instantiates a type parameter with, where the parameter's constraint is `comparable` or embeds it, is compared as an operand of `==` of that type is, recorded at the instantiation, so the struct values `slices.Equal`, `slices.Index` or `maps.Equal` compares have every field read. `reflect.DeepEqual` is not a comparison under this rule. In TypeScript a comparison of two object references reads no member, because `===` compares identity and never a member. In TypeScript a property of an object literal writes the member of the same name that the literal's contextual type declares, whether or not the compiler checks the literal for excess properties. Where that contextual type is a union or an intersection, the property writes the member of that name on each constituent that declares one. So a literal that a declaration annotates, a function returns, a call passes or a `satisfies` expression checks writes the members of the type it is given. A store through the value a field or a member holds reads that field or member rather than writing it, because the store lands in storage every other holder of the value reads. In Go that store is an assignment, an increment, a compound assignment or a `delete` whose target is reached through a struct field holding a map, a slice or a pointer. Examples are `s.f[k] = v`, `s.f.x = v` and `delete(s.f, k)`. The same store through a field holding an array or a struct is a store into the field itself. TypeScript holds every object by reference, so an element or property store through a member's value reads the member. The finding names each write position, so the deletion set is visible. Deleting the subject and its writes also deletes every declaration whose only uses they hold. Such a declaration is a type parameter of the subject's declaring type that the subject's type alone names, an import binding the writes alone use, or a declaration whose every use is in the type annotation of the subject or of another subject this rule reports, or in the writes those findings name. The finding's message names each such declaration, and no finding is reported about the declaration itself.",
+    rule: "A package-level or module-level variable, struct field, class member, type member or collection that production code writes and never reads. In production mode a read from a test file counts as no read. A write from a loaded consumer's code counts as a read, because the deletion the finding names would break a consumer the target does not own. A write in a consumer's test file counts as a read in the run that counts test references. It counts in a production sweep only where the configuration counts consumer tests as production. A comparison of struct values reads every field of the type: in Go, a value of a struct type used as an operand of `==` or `!=`, as a map key, or as a `switch` tag or `case` expression is a read of every field of that type, transitively through the fields of every struct type it holds, recorded at the comparison, because equality reads every field and a field that decides equality carries information. In Go a type argument the program instantiates a type parameter with, where the parameter's constraint is `comparable` or embeds it, is compared as an operand of `==` of that type is, recorded at the instantiation, so the struct values `slices.Equal`, `slices.Index` or `maps.Equal` compares have every field read. `reflect.DeepEqual` is not a comparison under this rule. In Go, a conversion the compiler accepts between two struct types, or between two pointer types that are not named types and whose base types are struct types, reads every field of the two struct types where their struct type literals are distinct, recorded at the conversion, because the conversion is legal only while their fields are identical, ignoring tags, and so no field of either can be deleted alone. It reads in the same way every field of each pair of distinct struct type literals the identity of the two types compares in turn: through each field's type, and from there through the element, key, base, parameter and result types of the type literals it reaches, through the method signatures of an interface type literal, and through the type arguments of an instantiated generic type. A field reached there has no reference of its own, as grammar/symbol-ref.md states, so it is never a subject and those reads hold no finding back. It stops at a defined type, whose fields the conversion does not read, because a defined type is identical to itself whatever fields it declares. A pair whose two sides are one struct type literal, the two struct types themselves included, as where one type is declared from the other or the conversion is to the operand's own type, reads nothing, because a field deleted from that literal leaves both sides identical. Where the operand's type or the conversion's type is a type parameter, the struct type its constraint's core type is takes that side's place, and a type parameter operand reads in the same way the fields of each struct type argument an instantiation the program holds gives it, an instantiation made through another generic declaration's own type parameters included. A conversion to any other type, an interface type among them, reads no field under this rule. In TypeScript a comparison of two object references reads no member, because `===` compares identity and never a member. In TypeScript a property of an object literal writes the member of the same name that the literal's contextual type declares, whether or not the compiler checks the literal for excess properties. Where that contextual type is a union or an intersection, the property writes the member of that name on each constituent that declares one. So a literal that a declaration annotates, a function returns, a call passes or a `satisfies` expression checks writes the members of the type it is given. An object literal handed to a callee the target does not implement has its members read, as grammar/analysis.md states. A store through the value a field or a member holds reads that field or member rather than writing it, because the store lands in storage every other holder of the value reads. In Go that store is an assignment, an increment, a compound assignment or a `delete` whose target is reached through a struct field holding a map, a slice or a pointer. Examples are `s.f[k] = v`, `s.f.x = v` and `delete(s.f, k)`. The same store through a field holding an array or a struct is a store into the field itself. TypeScript holds every object by reference, so an element or property store through a member's value reads the member. The finding names each write position, so the deletion set is visible. Deleting the subject and its writes also deletes every declaration whose only uses they hold. Such a declaration is a type parameter of the subject's declaring type that the subject's type alone names, an import binding the writes alone use, or a declaration whose every use is in the type annotation of the subject or of another subject this rule reports, or in the writes those findings name. The finding's message names each such declaration, and no finding is reported about the declaration itself.",
     defaultSeverity: "deny",
     maxClass: "certain",
     fixability: "deletable",
@@ -193,6 +205,7 @@ const ROWS: readonly KindRow[] = [
     defaultSeverity: "deny",
     maxClass: "certain",
     fixability: "deletable",
+    findingFixabilities: ["manual"],
     fixed: false,
   },
   {
@@ -211,7 +224,7 @@ const ROWS: readonly KindRow[] = [
     code: "DS1501",
     name: "file-never-built",
     languages: ["go", "ts"],
-    rule: "A source file no configuration in the build matrix builds. On the Go side the finding names the build constraint that excluded the file. A file whose build constraint is the ignore tag is never reported: the toolchain applies no build constraint to a file named on its own command line, so that tag is the toolchain's convention for a file built by hand. A file any other custom tag excludes is reported under a matrix the configuration declares complete, because completeness is the maintainer's assertion that the listed configurations are every one the target builds, and a configuration the maintainer builds by hand belongs in that list.",
+    rule: "A source file no configuration in the build matrix builds. On the Go side the finding names the build constraint that excluded the file. A file whose build constraint holds only when the ignore tag is set is never reported, because grammar/analysis.md keeps such a file outside the analysis wherever no configuration builds it: the tag is the toolchain's convention for a file kept out of ordinary package builds unless a configuration explicitly satisfies the tag, and built by hand, the toolchain applying no build constraint to a file named on its own command line. A file any other custom tag excludes is reported under a matrix the configuration declares complete, because completeness is the maintainer's assertion that the listed configurations are every one the target builds, and a configuration the maintainer builds by hand belongs in that list.",
     precondition:
       'Reported only when the configuration declares the build matrix complete, and never for a file the toolchain ignored solely because it imports "C" under a build with cgo disabled. Such a file is recorded as excluded by cgo rather than as never built.',
     defaultSeverity: "deny",
@@ -235,7 +248,7 @@ const ROWS: readonly KindRow[] = [
     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 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.",
+      "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. Four 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, and one that a needed dependency names as a peer, as stated below. A command no script entry and no workflow step runs needs nothing. A declared dependency that the installed manifest of a needed declared dependency names in its peerDependencies is needed, and so on until no further dependency joins. A peer dependency is a package the needed dependency expects beside it at a version its manifest states, whether or not it imports the package, and the project's declaration is what keeps that package present at a version the project chooses, so removing the declaration can break the needed dependency where nothing the analysis reads imports the peer. A peer that peerDependenciesMeta marks optional is needed in the same way, because the needed dependency's manifest still names it as a package it works with, and a package manager may leave an optional peer out where the project does not declare it, so the project's declaration is what keeps it present for the needed dependency. A declared dependency that only dependencies nothing needs name as a peer is needed by nothing. 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 directory of the manifest that declares the dependency, and a dependency with none is decided by the import closure alone. On the TypeScript side, the dependencies judged are those of every manifest grammar/analysis.md says the analysis reads, a nested package's among them, each read against its own directory: a dependency is needed by a use written in a file at or below the directory of the manifest that declares it, by a use no one file holds, and as a peer of a needed dependency of the same manifest or of a manifest below it. A dependency a nested package's manifest declares whose installed manifest the analysis cannot find is not judged, because no run requires a nested package to be installed and its commands and peers cannot be read, while a workspace member's and the target's own are judged as above.",
     defaultSeverity: "deny",
     maxClass: "certain",
     fixability: "manual",
@@ -277,7 +290,7 @@ const ROWS: readonly KindRow[] = [
     code: "DS1703",
     name: "stale-suppression",
     languages: ["go", "ts"],
-    rule: "A suppression that matches no current finding, at either mechanism and in the baseline alike. The run exits with the findings code when at least one is reported. The kind is fixed on at deny: no flag, no severity setting and no per-mechanism exception reduces it below a finding, and a configuration naming this code under a severity key is an unimplemented key.",
+    rule: "A suppression record that is stale, as grammar/suppression.md defines it, at either mechanism and in the baseline alike. The run exits with the findings code when at least one is reported. The kind is fixed on at deny: no flag, no severity setting and no per-mechanism exception reduces it below a finding, and a configuration naming this code under a severity key is an unimplemented key.",
     defaultSeverity: "deny",
     maxClass: "certain",
     fixability: "none",
@@ -345,7 +358,7 @@ const ROWS: readonly KindRow[] = [
     languages: ["go", "ts"],
     rule: "A result value that no call site of the function uses, on a function whose signature is free to change.",
     precondition:
-      "The same free-signature rule as unused-parameter, plus a closed-world condition: every call site of the function must be in the loaded graph, because an unknown caller may consume the result, so the kind reports only for a function whose callers are all visible.",
+      "The same free-signature rule as unused-parameter, plus a closed-world condition: every call site of the function must be in the loaded graph, because an unknown caller may consume the result, so the kind reports only for a function whose callers are all visible. A call that is the operand of an await expression written as a statement of its own uses a result whose type has a member named then, a promise or another thenable, because the caller sequences on it, and discards any other result. A call written as a statement of its own, or as the operand of void, discards its result whatever its type.",
     defaultSeverity: "warn",
     maxClass: "certain",
     fixability: "manual",

package/src/manifest.ts

@@ -6,7 +6,7 @@
  */
 
 import type { Host } from "./host.ts";
-import { dirnamePath, isAbsolutePath, joinPath, relativePath, resolvePath } from "./paths.ts";
+import { isAbsolutePath, joinPath, relativePath, resolvePath } from "./paths.ts";
 
 /** The manifest's own name. */
 const MANIFEST = "package.json";
@@ -15,7 +15,7 @@ const MANIFEST = "package.json";
 const LEGACY_MEMBERS = ["main", "module", "types"] as const;
 
 /** What reaches one entry point the manifest names. */
-export type EntryRole =
+type EntryRole =
   /** A consumer importing the package, which is a caller the analysis cannot see. */
   | "import"
   /** A shell running the package's command, which is a caller that exists. */
@@ -212,31 +212,16 @@ export function readManifest(host: Host, targetRoot: string): Manifest {
 }
 
 /**
- * The entry points every package manifest between the target root and each compiler
- * configuration names: each directory holding a `package.json` that a configuration sits
- * in or below, the target root and `known` excluded, whose manifests the run reads
- * otherwise. Each entry is spelled under its manifest's path below the target root, and
- * is published by its own manifest's rule, as the target's own entries are.
+ * The entry points the manifests of the nested packages in `dirs` name. Each entry is
+ * spelled under its manifest's path below the target root, and is published by its own
+ * manifest's rule, as the target's own entries are.
  */
 export function packageEntries(
   host: Host,
   targetRoot: string,
-  configFiles: readonly string[],
-  known: ReadonlySet<string>,
+  dirs: readonly string[],
 ): readonly ManifestEntry[] {
-  const dirs = new Set<string>();
-  for (const configFile of configFiles) {
-    for (
-      let dir = dirnamePath(resolvePath(targetRoot, configFile));
-      dir !== targetRoot && relativePath(targetRoot, dir) !== undefined;
-      dir = dirnamePath(dir)
-    ) {
-      if (!known.has(dir) && host.kindOf(joinPath(dir, MANIFEST)) === "file") {
-        dirs.add(dir);
-      }
-    }
-  }
-  return [...dirs].sort().flatMap((dir) => {
+  return dirs.flatMap((dir) => {
     const manifest = readManifest(host, dir);
     const where = `${relativePath(targetRoot, dir) ?? dir}/${MANIFEST}`;
     return manifest.entries.map((entry) => ({

package/src/matrix.ts

@@ -4,7 +4,7 @@
  * and intersected, with the dead components computed once over every configuration.
  */
 
-import { componentsOf, type Component } from "./components.ts";
+import { componentsOf, type Component, type Positional } from "./components.ts";
 import { graphOf, OUTSIDE, type Graph } from "./graph.ts";
 import type { InventorySymbol } from "./inventory.ts";
 import { byPosition } from "./position.ts";
@@ -36,6 +36,8 @@ export interface Configured {
    * finding.
    */
   readonly referenceOnly?: readonly string[] | undefined;
+  /** Each declaration's dependents, by id, as the configuration's inventory states them. */
+  readonly dependents?: ReadonlyMap<string, readonly string[]> | undefined;
 }
 
 /** The run's configurations, indexed for the sweep. */
@@ -56,6 +58,8 @@ export interface Matrix {
    * whose project holds it, in the run's order.
    */
   readonly heldIn: readonly (readonly string[])[];
+  /** Each declaration's dependents, by id, as the first configuration holding it states them. */
+  readonly dependents: ReadonlyMap<string, readonly string[]>;
 }
 
 /** One declaration dead in every configuration that holds it. */
@@ -128,7 +132,13 @@ export function matrixOf(per: readonly Configured[]): Matrix {
   const references: Reference[] = [];
   const firstSeen = new Map<string, number>();
   const judged = new Set<string>();
+  const dependents = new Map<string, readonly string[]>();
   per.forEach((one, index) => {
+    for (const [id, after] of one.dependents ?? []) {
+      if (!dependents.has(id)) {
+        dependents.set(id, after);
+      }
+    }
     const referenceOnly = new Set(one.referenceOnly);
     for (const symbol of one.symbols) {
       const held = holders.get(symbol.id);
@@ -168,6 +178,7 @@ export function matrixOf(per: readonly Configured[]): Matrix {
       [...new Set(per.flatMap((one) => one.supportFiles ?? []))],
     ),
     heldIn: symbols.map((symbol) => holders.get(symbol.id) ?? []),
+    dependents,
   };
 }
 
@@ -257,14 +268,16 @@ export function sweepMatrix(matrix: Matrix, input: SweepInput): SweepResult {
     });
   });
 
+  const liveUnder = liveAnywhere(union.symbols, per);
   return {
-    liveUnder: liveAnywhere(union.symbols, per),
+    liveUnder,
     candidates,
     components: componentsOf(
       union,
       dead.map((one, at) => one && heldBy[at] === undefined),
       testOfDeadCode,
       unreferencedTest,
+      positionsOf(union, matrix.dependents, liveUnder),
     ),
   };
 }
@@ -286,6 +299,25 @@ export function liveFilesAt(
   );
 }
 
+/**
+ * Each declaration's dependents by its place in the union, and per place whether the
+ * declaration is live under reachability in some configuration.
+ */
+function positionsOf(
+  union: Graph,
+  dependents: ReadonlyMap<string, readonly string[]>,
+  liveUnder: ReadonlyMap<string, readonly Relation[]>,
+): Positional {
+  return {
+    dependents: union.symbols.map((symbol) =>
+      (dependents.get(symbol.id) ?? []).map((id) => union.at(id)).filter((at) => at !== OUTSIDE),
+    ),
+    live: union.symbols.map(
+      (symbol) => liveUnder.get(symbol.id)?.includes("reachability") === true,
+    ),
+  };
+}
+
 /** The relations in the order a declaration's entry lists them. */
 const RELATIONS: readonly Relation[] = ["reference-counting", "reachability"];
 

package/src/namespace-objects.ts

@@ -34,7 +34,7 @@ import {
 } from "@typescript/native/unstable/ast";
 
 /** What one use of a namespace object reads beyond the names the checker resolves. */
-export type NamespaceUse =
+type NamespaceUse =
   /** Every export of the module `specifier` names. */
   | { readonly kind: "whole"; readonly specifier: Node }
   /** The export a literal index names, the literal being the node to resolve. */

package/src/pnpm-workspace.ts

@@ -6,7 +6,7 @@
  */
 
 /** What the document says about `packages`. */
-export type PnpmPackages =
+type PnpmPackages =
   | { readonly kind: "listed"; readonly patterns: readonly string[] }
   /** The document declares no `packages` key. */
   | { readonly kind: "absent" }

package/src/query.ts

@@ -205,6 +205,8 @@ export interface Queries {
   targetOf(type: Type): Answer<Type>;
   /** The constraint of a type parameter, where it declares one; none for another type. */
   constraintOf(type: Type): Answer<Type | undefined>;
+  /** The object and the index of an indexed-access type; none for another type. */
+  indexedAccessOf(type: Type): Answer<{ readonly object: Type; readonly index: Type } | undefined>;
   /** The symbol a type is declared by. */
   symbolOfType(type: Type): Answer<TSSymbol | undefined>;
   signaturesOf(type: Type, kind: SignatureKind): Answer<readonly Signature[]>;
@@ -516,6 +518,14 @@ export function queriesOf(
             () => type.getConstraint(),
           )
         : undefined,
+    indexedAccessOf: (type) =>
+      type.isIndexedAccessType()
+        ? one(
+            "getObjectType",
+            () => typeLocation(type),
+            () => ({ object: type.getObjectType(), index: type.getIndexType() }),
+          )
+        : undefined,
     symbolOfType: (type) =>
       one(
         "getSymbol",

package/src/references.ts

@@ -43,7 +43,10 @@ import { namespaceUses } from "./namespace-objects.ts";
 import { globExpression } from "./glob.ts";
 import { declarationsByName, nodeKey, type Inventory, type InventorySymbol } from "./inventory.ts";
 import { augmentationReferences } from "./augmentations.ts";
+import { elementAccessReferences } from "./element-access.ts";
 import { indexedAccessReferences } from "./indexed-access.ts";
+import { keyofComparisonReferences } from "./keyof-comparisons.ts";
+import { unimplementedCalleeReads } from "./unimplemented-callees.ts";
 import { moduleDeclarationReferences } from "./module-declarations.ts";
 import { overrideReferences } from "./overrides.ts";
 import { dirnamePath, queriedModulePath, relativePath, resolvePath } from "./paths.ts";
@@ -78,7 +81,7 @@ import { handedOn, valuesOf } from "./value-flow.ts";
  * `decorator` names the declaration a decorator expression is attached to, which the
  * decorator receives when the class is defined.
  */
-export type Use = "read" | "write" | "evaluation" | "decorator";
+type Use = "read" | "write" | "evaluation" | "decorator";
 
 /**
  * Which path answered for one reference: `batch`, a file's batched lookup; `resolved-symbol`, the
@@ -88,7 +91,7 @@ export type Use = "read" | "write" | "evaluation" | "decorator";
  * or a value's position reads; `override`, the override a base call dispatches to; `keyed`, the
  * member a symbol key selects; `by-name`, each declaration so spelled, where the checker failed.
  */
-export type Resolution =
+type Resolution =
   | "batch"
   | "resolved-symbol"
   | "shorthand"
@@ -185,12 +188,17 @@ export interface ReferenceCost {
   readonly contextualBatches: number;
   /** Per-type lookups for the contextual uses: each distinct type's constituents, properties and symbol. */
   readonly contextualLookups: number;
+  /**
+   * The requests the passes that read members through the checker's types make: element
+   * accesses, key comparisons, instantiated signatures and values handed to unimplemented
+   * callees. They are
+   * counted where the caller measures the client, through `requestCount`, and are 0 otherwise.
+   */
+  readonly typedLookups: number;
 }
 
 /** One project's references, in position order, and what reading them cost. */
 export interface References {
-  /** The compiler configuration the project was opened from. */
-  readonly configFile: string;
   readonly references: readonly Reference[];
   /**
    * Every file the rules classified as a test file, by its path below the target root,
@@ -214,6 +222,8 @@ export interface ReferenceOptions {
    * Each pattern is a rule of its own, which {@link testFileRulesOf} counts.
    */
   readonly testFiles: readonly string[];
+  /** The files, absolute, that are test files beside those the patterns name. */
+  readonly testFileNames?: ReadonlySet<string>;
   /**
    * The consumer whose files the pass walks instead of the target's. Its files are the
    * program's own files below its root and not below the target root, each position is
@@ -221,6 +231,8 @@ export interface ReferenceOptions {
    * reference to a declaration of `held`, the target's, is recorded.
    */
   readonly consumer?: ConsumerSide;
+  /** The client's running request count, where the caller measures the client. */
+  readonly requestCount?: () => number;
 }
 
 /**
@@ -1225,7 +1237,9 @@ export function references<Brand>(
   const testFile = new Map<SourceFile, boolean>();
   for (const { file } of walked) {
     const path = renderPosition(file, root, 0).path;
-    const test = patterns.some((pattern) => pattern.test(path));
+    const test =
+      patterns.some((pattern) => pattern.test(path)) ||
+      options.testFileNames?.has(file.fileName) === true;
     testFile.set(file, test);
     if (test) {
       tests.push(path);
@@ -1554,12 +1568,21 @@ export function references<Brand>(
     }
   }
 
+  let typedLookups = 0;
   if (consumer === undefined) {
     found.push(...overrideReferences(project, held, chains, new Set(tests)));
+    const before = options.requestCount?.() ?? 0;
     found.push(...indexedAccessReferences(project, held, chains, root, new Set(tests)));
+    found.push(...elementAccessReferences(project, held, chains, root, new Set(tests)));
+    found.push(...keyofComparisonReferences(project, held, chains, root, new Set(tests)));
+    found.push(...unimplementedCalleeReads(project, held, chains, root, new Set(tests)));
+    typedLookups = (options.requestCount?.() ?? 0) - before;
     found.push(...moduleDeclarationReferences(project, held, root, new Set(tests)));
   }
-  found.push(...augmentationReferences(held, found));
+  const scripts = new Set(
+    walked.filter((one) => one.file.externalModuleIndicator === undefined).map((one) => one.fileId),
+  );
+  found.push(...augmentationReferences(held, found, scripts));
   found.sort(
     (a, b) =>
       byPosition(a.position, b.position) ||
@@ -1569,7 +1592,6 @@ export function references<Brand>(
   );
 
   return {
-    configFile: project.configFile,
     references:
       consumer === undefined
         ? found
@@ -1585,6 +1607,7 @@ export function references<Brand>(
       patternLookups: destructured.cost.patternLookups,
       contextualBatches: contextual.batches,
       contextualLookups: contextual.lookups,
+      typedLookups,
     },
   };
 }

package/src/report.ts

@@ -19,7 +19,7 @@ import type { StaleSuppression } from "./findings/self-check.ts";
 import type { TestFileRule } from "./references.ts";
 
 /** The version of the report schema this analyzer writes a report to. */
-const SCHEMA_VERSION = "8.0.0";
+const SCHEMA_VERSION = "8.1.0";
 
 /** Every report schema version this analyzer reads: the one the Contract it implements admits. */
 export const SCHEMA_VERSIONS_ACCEPTED: readonly string[] = [SCHEMA_VERSION];
@@ -30,14 +30,14 @@ export const ANALYZER_NAME = "deadset-ts";
 /** The language this analyzer claims. */
 export const LANGUAGE = "ts";
 
-export interface WirePosition {
+interface WirePosition {
   readonly path: string;
   readonly line: number;
   readonly column: number;
   readonly end_line: number;
 }
 
-export interface WireDetails {
+interface WireDetails {
   readonly narrower_visibility?: string;
   readonly implementations?: readonly {
     readonly ref: string;
@@ -45,6 +45,8 @@ export interface WireDetails {
     readonly position: WirePosition;
   }[];
   readonly write_positions?: readonly WirePosition[];
+  /** Set under the name-literal rule, which no finding of this analyzer meets; SARIF still maps it. */
+  readonly name_literal?: WirePosition;
   readonly dependency_class?: string;
   readonly mechanism?: string;
   readonly entry?: {
@@ -54,6 +56,7 @@ export interface WireDetails {
     readonly reason?: string;
   };
   readonly overlap?: readonly string[];
+  readonly removes_last_use_of?: readonly string[];
 }
 
 /** One finding as the finding schema spells it. */
@@ -93,7 +96,7 @@ export interface WireFinding {
   readonly details: WireDetails;
 }
 
-export interface WireEdgeEvaluation {
+interface WireEdgeEvaluation {
   readonly edge: string;
   readonly side: string;
   readonly symbol: string;
@@ -178,7 +181,7 @@ interface ReportConsumer {
 }
 
 /** One consumer the scope declared and the run did not load, with why. */
-export interface UnavailableConsumer {
+interface UnavailableConsumer {
   readonly id: string;
   readonly reason: string;
 }
@@ -297,6 +300,9 @@ function wireDetails(details: FindingDetails): WireDetails {
           },
         }),
     ...(details.overlap === undefined ? {} : { overlap: details.overlap }),
+    ...(details.removesLastUseOf === undefined
+      ? {}
+      : { removes_last_use_of: details.removesLastUseOf }),
   };
 }
 

package/src/reporters/sarif.ts

@@ -160,6 +160,10 @@ function relatedOf(found: WireFinding): readonly Related[] {
   for (const at of found.details.write_positions ?? []) {
     related.push({ label: "write", at, endLine: at.end_line });
   }
+  if (found.details.name_literal !== undefined) {
+    const at = found.details.name_literal;
+    related.push({ label: "name", at, endLine: at.end_line });
+  }
   for (const one of found.component.members ?? []) {
     if (
       declarationKey(one.ref, one.position.path) !==

package/src/roots.ts

@@ -81,8 +81,6 @@ export interface Root {
 
 /** One project's roots, and every configured string that named nothing in it. */
 export interface Roots {
-  /** The compiler configuration the project was opened from. */
-  readonly configFile: string;
   /**
    * Every root of this project, ordered by the site of the declaration it names,
    * then by kind, then by the string that named it. A declaration that is a root for
@@ -432,7 +430,6 @@ export function roots<Brand>(
   });
 
   return {
-    configFile: project.configFile,
     liveUnderReachability: ordered,
     unmatched,
     unanswered: answered ? api.guessed : held.symbols.map((symbol) => symbol.id),

package/src/run.ts

@@ -1,6 +1,5 @@
 import { ConfigError, REPOSITORY_DOCUMENT, type Inputs } from "./config.ts";
 import { DiscoveryError, renderDiagnostic } from "./discover.ts";
-import { EMITTERS } from "./findings/emitters.ts";
 import type { Host } from "./host.ts";
 import { joinPath, resolvePath } from "./paths.ts";
 import { readScope, ScopeError, scopeForDir, type Scope } from "./scope.ts";
@@ -264,7 +263,6 @@ function invoke(
         });
         return opened;
       },
-      emitters: EMITTERS,
     });
   } catch (error: unknown) {
     opened?.close();

package/src/schema.ts

@@ -15,7 +15,7 @@ import { ConfigError } from "./config.ts";
  * - `object` is one setting written as an object: its member names are declared
  *   and a source supplies the object whole.
  */
-export type KeyKind = "leaf" | "section" | "map" | "list" | "object";
+type KeyKind = "leaf" | "section" | "map" | "list" | "object";
 
 /**
  * One node of the closed key list. `members` holds a section's declared members,
@@ -259,7 +259,7 @@ export function malformed(label: string, path: string, detail: string): ConfigEr
  * A refusal of a key the closed key list does not declare, naming the nearest key
  * it does.
  */
-export function unimplementedKey(label: string, path: string): ConfigError {
+function unimplementedKey(label: string, path: string): ConfigError {
   const nearest = nearestKey(path);
   let hint = "";
   if (nearest === path) {

package/src/scope.ts

@@ -4,8 +4,8 @@ import { dirnamePath, isAbsolutePath, joinPath, resolvePath } from "./paths.ts";
 import { checkDocument, type KeyNode } from "./schema.ts";
 
 /** The roles a scope document declares for a module. */
-export const ROLE_TARGET = "target";
-export const ROLE_CONSUMER = "consumer";
+const ROLE_TARGET = "target";
+const ROLE_CONSUMER = "consumer";
 
 /**
  * A scope document above this length is refused rather than decoded. It names one