@cplieger/deadset-ts 5.2.3 → 6.0.0

package/dist/src/workflow-steps.js

@@ -0,0 +1,82 @@
+/**
+ * The source files a CI workflow's `run:` steps name by their path from the target root.
+ * A workflow file is read as text, line by line, with no YAML parsed.
+ */
+import { scriptTokens } from "./manifest.js";
+import { joinPath, resolvePath } from "./paths.js";
+const WORKFLOWS = ".github/workflows";
+/** A line holding a run command: indentation and one sequence marker before `run:`. */
+const RUN_LINE = /^(\s*(?:- )?)run:(.*)$/u;
+const BLOCK_SCALAR = /^[|>][+-]?$/u;
+const QUOTED = /^(["'])(.*)\1$/su;
+/** A token holding one of these is computed or a pattern, so it names no file. */
+const COMPUTED = /[${*?[]/u;
+const INDENT = /^\s*/u;
+function workflowFiles(host, dir) {
+    let entries;
+    try {
+        entries = host.readDirectory(dir);
+    }
+    catch {
+        return [];
+    }
+    return entries
+        .filter((entry) => !entry.directory && /\.ya?ml$/u.test(entry.name))
+        .map((entry) => joinPath(dir, entry.name))
+        .sort();
+}
+/** Every command line one workflow file's `run:` steps hold. */
+export function runCommands(text) {
+    const lines = text.split(/\r?\n/u);
+    const found = [];
+    for (let at = 0; at < lines.length; at += 1) {
+        const match = RUN_LINE.exec(lines[at] ?? "");
+        if (match === null) {
+            continue;
+        }
+        const column = (match[1] ?? "").length;
+        const value = (match[2] ?? "").trim().replace(QUOTED, "$2");
+        if (!BLOCK_SCALAR.test(value)) {
+            found.push(value);
+            continue;
+        }
+        for (let next = at + 1; next < lines.length; next += 1) {
+            const line = lines[next] ?? "";
+            if (line.trim() !== "" && (INDENT.exec(line)?.[0].length ?? 0) <= column) {
+                break;
+            }
+            found.push(line);
+        }
+    }
+    return found;
+}
+/**
+ * The own files the `run:` steps of every workflow file in the target root's
+ * `.github/workflows` name: a token equal to a file's path below the target root, with or
+ * without a leading `./`, whatever directory the step runs in.
+ */
+export function workflowEntries(host, targetRoot, files) {
+    const dir = joinPath(resolvePath(host.workingDirectory(), targetRoot), WORKFLOWS);
+    const found = [];
+    for (const path of workflowFiles(host, dir)) {
+        let text;
+        try {
+            text = host.readFile(path);
+        }
+        catch {
+            continue;
+        }
+        for (const command of runCommands(text)) {
+            for (const token of scriptTokens(command)) {
+                if (COMPUTED.test(token)) {
+                    continue;
+                }
+                const file = files.byPath.get(token.startsWith("./") ? token.slice(2) : token);
+                if (file !== undefined) {
+                    found.push({ file, source: token });
+                }
+            }
+        }
+    }
+    return found;
+}

package/jsr.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "5.2.3",
+  "version": "6.0.0",
   "license": "GPL-3.0-or-later",
   "exports": {
     ".": "./src/index.ts"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "5.2.3",
+  "version": "6.0.0",
   "type": "module",
   "sideEffects": false,
   "description": "Deterministic dead-code analysis for TypeScript, class and type members included",
@@ -31,8 +31,14 @@
   "dependencies": {
     "@typescript/native": "npm:typescript@7.1.0-dev.20261006.1"
   },
+  "overrides": {
+    "qs": "^6.15.2"
+  },
   "devDependencies": {
     "@eslint/js": "10.0.1",
+    "@stryker-mutator/core": "10.0.0",
+    "@stryker-mutator/typescript-checker": "10.0.0",
+    "@stryker-mutator/vitest-runner": "10.0.0",
     "@types/node": "24.19.1",
     "eslint": "10.12.0",
     "fast-check": "4.10.2",

package/src/analysis.ts

@@ -71,7 +71,7 @@ import { frameworkLifecycle } from "./framework-lifecycle.ts";
 import type { Host } from "./host.ts";
 import { implementations, mergeImplementations } from "./implementations.ts";
 import { injectionContainer } from "./injection-container.ts";
-import { interfaceSatisfaction } from "./interface-satisfaction.ts";
+import { interfaceSatisfaction, settledSatisfaction } from "./interface-satisfaction.ts";
 import { intraFunctionFacts, projectParts, type ProjectParts } from "./intra-function-parts.ts";
 import { inventory, type Inventory, type InventorySymbol } from "./inventory.ts";
 import { packageEntries, readManifest } from "./manifest.ts";
@@ -224,6 +224,8 @@ interface ReadProjects<Answer> {
   readonly conventionsApplied: readonly AppliedConvention[];
   /** The dependencies the applied rows' short names use. */
   readonly conventionUses: readonly string[];
+  /** The directory of every workspace member, absolute. */
+  readonly memberDirs: readonly string[];
   /** The test files below the target root no project the run reads holds, parsed. */
   readonly outsideTests: readonly OutsideTest[];
 }
@@ -508,6 +510,7 @@ function readProjects<Answer>(
     componentsUnread: workspace?.componentsUnread ?? [],
     conventionsApplied: conventions.applied,
     conventionUses: conventions.uses,
+    memberDirs: workspace?.memberDirs ?? [],
     outsideTests,
   };
 }
@@ -694,6 +697,8 @@ interface ReadRun<Extra> {
   readonly conventionsApplied: readonly AppliedConvention[];
   /** The dependencies the applied rows' short names use. */
   readonly conventionUses: readonly string[];
+  /** The directory of every workspace member, absolute. */
+  readonly memberDirs: readonly string[];
 }
 
 /**
@@ -777,15 +782,20 @@ function readRun<Extra>(
     withOutside.flatMap((one) => one.projectRead.rooted.liveUnderReachability),
     withOutside.flatMap((one) => one.testFiles),
   );
-  const answers = withOutside.map((one): SweptProject<Extra> => {
+  const settled = settledSatisfaction(
+    withOutside.map((one) => ({ evidence: one.evidence, held: one.projectRead.held })),
+    [...withOutside.flatMap((one) => one.references), ...read.consumers.references],
+  );
+  const answers = withOutside.map((one, index): SweptProject<Extra> => {
     const { projectRead } = one;
-    const detected = heldRecords(one.evidence, {
+    const satisfied = settled[index];
+    const detected = heldRecords(satisfied?.evidence ?? one.evidence, {
       disabled,
       mode,
       testFiles: new Set([...one.testFiles, ...support]),
     });
     const exempt = detected.records;
-    const made = supportReferences(one.references, support);
+    const made = supportReferences([...one.references, ...(satisfied?.references ?? [])], support);
     const held = new Set(projectRead.held.symbols.map((symbol) => symbol.position.path));
     const supportFiles = [...support].filter((path) => held.has(path)).sort();
     const configured: Configured = {
@@ -846,6 +856,7 @@ function readRun<Extra>(
     componentsUnread: read.componentsUnread,
     conventionsApplied: read.conventionsApplied,
     conventionUses: read.conventionUses,
+    memberDirs: read.memberDirs,
   };
 }
 
@@ -1070,6 +1081,30 @@ function readEmitterRun(
     : { ...run, unansweredHeld: [...new Set([...run.unansweredHeld, ...unread])] };
 }
 
+/**
+ * The workspace members whose manifest the run reads whole enough to judge its
+ * dependencies: a built project holds a file below the member's directory, and no derived
+ * configuration at or below it was dropped. A file no built project holds may import any
+ * dependency the member declares.
+ */
+function membersWhollyRead(
+  host: Host,
+  targetRoot: string,
+  read: ReadRun<EmitterExtra>,
+): readonly string[] {
+  const root = resolvePath(host.workingDirectory(), targetRoot);
+  const held = new Set(read.matrix.union.symbols.map((symbol) => symbol.position.path));
+  const dropped = read.notBuilt.map((one) => relativePath(root, one.configFile) ?? "");
+  return read.memberDirs.filter((dir) => {
+    const below = relativePath(root, dir);
+    if (below === undefined) {
+      return false;
+    }
+    const inside = (path: string): boolean => path.startsWith(`${below}/`);
+    return [...held].some(inside) && !dropped.some(inside);
+  });
+}
+
 /**
  * The input every emitter reads over one sweep of a read run: the facts beside the sweep
  * each kind family reads, every per-project one read in the same session as the sweep.
@@ -1102,6 +1137,7 @@ function emitterInputOver(
       targetRoot,
       [...projects.map((one) => one.extra.needs), configurationNeeds(read.conventionUses)],
       swept.sweep.candidates.map((candidate) => candidate.id),
+      membersWhollyRead(host, targetRoot, read),
     ),
     implementations: mergeImplementations(projects.map((one) => one.extra.implementations)),
     files: {

package/src/augmentations.ts

@@ -0,0 +1,72 @@
+/**
+ * The references a use of an augmentation's declaration makes to what holds it. No name
+ * spells a `declare global` block, so a use of a declaration it holds is a use of the
+ * block. An interface or namespace an augmentation block holds merges with the one of its
+ * name, which the language or a library may type a value by where the target never names
+ * it, as it types `import.meta` or `process.env`, so a use of its member is a use of it.
+ */
+
+import type { Inventory, InventorySymbol } from "./inventory.ts";
+import type { Reference } from "./references.ts";
+
+/** Whether one declaration is a `declare global` block: a module-level namespace named `global`. */
+function isGlobalBlock(
+  symbol: InventorySymbol,
+  held: Inventory,
+  files: ReadonlySet<string>,
+): boolean {
+  return (
+    symbol.kind === "namespace" &&
+    files.has(symbol.parent) &&
+    symbol.ref.endsWith("#global") &&
+    !held.modules.has(symbol.id)
+  );
+}
+
+/**
+ * For each reference to a declaration an augmentation block holds, a read at the same place
+ * of every interface and namespace between it and the block, and of a `declare global` block
+ * itself.
+ */
+export function augmentationReferences(
+  held: Inventory,
+  found: readonly Reference[],
+): readonly Reference[] {
+  const files = new Set(held.symbols.filter((one) => one.kind === "file").map((one) => one.id));
+  const globals = new Set(
+    held.symbols.filter((one) => isGlobalBlock(one, held, files)).map((one) => one.id),
+  );
+  if (globals.size === 0 && held.modules.size === 0) {
+    return [];
+  }
+  const byId = new Map(held.symbols.map((one) => [one.id, one]));
+  const holders = (id: string): string[] => {
+    const ids: string[] = [];
+    for (
+      let at = byId.get(byId.get(id)?.parent ?? "");
+      at !== undefined;
+      at = byId.get(at.parent)
+    ) {
+      if (globals.has(at.id)) {
+        return [...ids, at.id];
+      }
+      if (held.modules.has(at.id)) {
+        return ids;
+      }
+      if (at.kind === "interface" || at.kind === "namespace") {
+        ids.push(at.id);
+      }
+    }
+    return [];
+  };
+  return found.flatMap((reference) =>
+    holders(reference.to).map((to) => ({
+      from: reference.from,
+      to,
+      position: reference.position,
+      use: "read" as const,
+      resolution: reference.resolution,
+      test: reference.test,
+    })),
+  );
+}

package/src/components.ts

@@ -62,17 +62,18 @@ export function listing(component: Component, cascade: Cascade): Listing {
 
 /**
  * Groups the declarations `dead` marks into components, ordered by their first member's
- * site; `dead` and `testOfDeadCode` hold one flag per declaration of the graph. Root
- * members sit on the cycles no other cycle references. A cycle two roots both reach is
- * dead only through both, so a component is a weakly connected part of the dead
- * subgraph: no dead declaration of one references a declaration of another.
+ * site; `dead`, `testOfDeadCode` and `unreferencedTest` hold one flag per declaration of
+ * the graph. Root members sit on the cycles no other cycle references. A cycle two roots
+ * both reach is dead only through both, so a component is a weakly connected part of the
+ * dead subgraph: no dead declaration of one references a declaration of another.
  */
 export function componentsOf(
   graph: Graph,
   dead: readonly boolean[],
   testOfDeadCode: readonly boolean[],
+  unreferencedTest: readonly boolean[] = [],
 ): readonly Component[] {
-  const { at, adjacent } = deadSubgraph(graph, dead, testOfDeadCode);
+  const { at, adjacent } = deadSubgraph(graph, dead, testOfDeadCode, unreferencedTest);
   if (at.length === 0) {
     return [];
   }
@@ -133,21 +134,22 @@ function linesSpanned(symbols: readonly (InventorySymbol | undefined)[]): number
 
 /**
  * The dead declarations by their place in the subgraph, a test file's declaration only
- * where it is a test of dead code, and the edges between them: each
- * reference one makes to another, an edge each way between a dead member and its dead
- * container (one direction alone leaves the member a component the container reaches),
- * and an edge back from each production target of an admitted test, which puts the test in
- * the component of the code it exercises because a subject never references its test.
+ * where it is a test of dead code or nothing the tests reach, and the edges between them:
+ * each reference one makes to another, except an unreferenced test-file declaration's
+ * reference to production code, which decides nothing of its target, an edge each way
+ * between a dead member and its dead container, and an edge back from each production
+ * target of an admitted test, which puts the test in its subject's component.
  */
 function deadSubgraph(
   graph: Graph,
   dead: readonly boolean[],
   testOfDeadCode: readonly boolean[],
+  unreferencedTest: readonly boolean[],
 ): { readonly at: readonly number[]; readonly adjacent: readonly (readonly number[])[] } {
   const at: number[] = [];
   const position = graph.symbols.map((_symbol, index) => {
-    // A test file's declaration belongs to a component only as a test of dead code.
-    if (dead[index] !== true || (graph.test[index] === true && testOfDeadCode[index] !== true)) {
+    const judged = testOfDeadCode[index] === true || unreferencedTest[index] === true;
+    if (dead[index] !== true || (graph.test[index] === true && !judged)) {
       return UNVISITED;
     }
     at.push(index);
@@ -157,7 +159,7 @@ function deadSubgraph(
   at.forEach((index, from) => {
     for (const edge of graph.out[index] ?? []) {
       const to = position[edge.to] ?? UNVISITED;
-      if (to === UNVISITED) {
+      if (to === UNVISITED || (unreferencedTest[index] === true && graph.test[edge.to] !== true)) {
         continue;
       }
       adjacent[from]?.push(to);

package/src/conformance-record.ts

@@ -2,9 +2,9 @@
 // Regenerate it with `UPDATE_GOLDEN=1 npx vitest --run src/conformance.corpus.test.ts`.
 export const RECORD = {
   conformance: {
-    corpusVersion: "3.0.0",
+    corpusVersion: "4.0.0",
     result: "pass",
-    digest: "sha256:db52e3164347cab70f45f438b4ac9ce89573be9303503daeb237a3c40361b001",
+    digest: "sha256:8250b61deb71467139bf4cbcaf10802cdabb1a2c2261a11a571fc1ff55bfc3dc",
   },
   gaps: [],
 } as const;

package/src/convention-rows.ts

@@ -16,7 +16,7 @@ export interface OptionsCall {
 }
 
 /** One configuration property, and the configuration files it is read from. */
-interface MoveReading {
+export interface MoveReading {
   /** The property's path through nested object literals, its keys joined by `.`. */
   readonly property: string;
   /** Globs naming the configuration files, matched in the manifest's directory alone. */
@@ -64,6 +64,13 @@ export interface ConventionRow {
   readonly moves: readonly DirectoryMove[];
   /** The properties that name a package the configuration uses by a short name. */
   readonly shortNames?: readonly ShortNameReading[];
+  /**
+   * The properties whose value only selects files to test, mutate, cover or ignore, so a
+   * string there names no file the tool runs or loads.
+   */
+  readonly selections?: readonly MoveReading[];
+  /** The members of a `package.json` the tool reads its configuration from. */
+  readonly manifestKeys?: readonly string[];
 }
 
 const SCRIPT = "{js,jsx,ts,tsx}";
@@ -99,6 +106,8 @@ const SOLIDSTART_PLUGIN = { module: "@solidjs/start/config", export: "solidStart
 const NUXT_CONFIG = [`nuxt.config.${ANY_MODULE}`];
 
 const STRYKER_CONFIG = "{stryker,.stryker}.{conf,config}.{json,js,mjs,cjs}";
+const STRYKER_MODULE = "{stryker,.stryker}.{conf,config}.{js,mjs,cjs}";
+const VITEST_CONFIG = `{vitest,vite}.config.${ANY_MODULE}`;
 
 /** Every row, ordered by name and then by range. */
 export const CONVENTION_ROWS: readonly ConventionRow[] = [
@@ -214,6 +223,14 @@ export const CONVENTION_ROWS: readonly ConventionRow[] = [
       },
     ],
   },
+  {
+    name: "prettier",
+    package: "prettier",
+    range: ">=3.0.0 <4.0.0",
+    entries: [`{prettier.config,.prettierrc}.${ANY_MODULE}`],
+    moves: [],
+    manifestKeys: ["prettier"],
+  },
   {
     name: "qwik-city",
     package: "@builder.io/qwik-city",
@@ -331,8 +348,9 @@ export const CONVENTION_ROWS: readonly ConventionRow[] = [
     name: "stryker",
     package: "@stryker-mutator/core",
     range: ">=7.0.0 <11.0.0",
-    entries: [],
+    entries: [STRYKER_MODULE],
     moves: [],
+    selections: [{ property: "mutate", files: [STRYKER_CONFIG] }],
     shortNames: [
       {
         property: "testRunner",
@@ -476,9 +494,13 @@ export const CONVENTION_ROWS: readonly ConventionRow[] = [
     shortNames: [
       {
         property: "test.coverage.provider",
-        files: [`{vitest,vite}.config.${ANY_MODULE}`],
+        files: [VITEST_CONFIG],
         package: "@vitest/coverage-{}",
       },
     ],
+    selections: [
+      { property: "test.coverage.include", files: [VITEST_CONFIG] },
+      { property: "test.coverage.exclude", files: [VITEST_CONFIG] },
+    ],
   },
 ];

package/src/conventions.ts

@@ -50,9 +50,11 @@ import {
   CONVENTION_ROWS,
   type ConventionRow,
   type DirectoryMove,
+  type MoveReading,
   type OptionsCall,
   type ShortNameReading,
 } from "./convention-rows.ts";
+import { documentStrings } from "./configuration-files.ts";
 import { globExpression } from "./glob.ts";
 import type { Host } from "./host.ts";
 import { dirnamePath, joinPath, normalizePath, relativePath, resolvePath } from "./paths.ts";
@@ -108,8 +110,18 @@ export interface Conventions {
   readonly globs: readonly ConventionGlob[];
   readonly generated: readonly GeneratedDirectory[];
   readonly failures: readonly ConventionFailure[];
-  /** The dependencies the applied rows' short names use, by name, each once. */
+  /** The dependencies the applied rows' short names and manifest keys use, by name, each once. */
   readonly uses: readonly string[];
+  /** Per configuration file, absolute, the strings its applied rows' selection keys hold. */
+  readonly selected: ReadonlyMap<string, Selected>;
+}
+
+/** The strings one configuration file holds at selection keys, which root no file. */
+export interface Selected {
+  /** Where each string starts in the file's text. */
+  readonly starts: ReadonlySet<number>;
+  /** Each string's text, once per occurrence. */
+  readonly texts: readonly string[];
 }
 
 /** One file a row roots. */
@@ -520,6 +532,86 @@ function readPath(
   return undefined;
 }
 
+/**
+ * Every string literal one file writes at one property's path inside the objects it is
+ * read from, as {@link readProperty} reads them: the value itself, or each element of an
+ * array value, whatever else the path holds.
+ */
+function stringsAt(file: SourceFile, property: string, call?: OptionsCall): readonly Node[] {
+  const declared = declaredValues(file);
+  const objects =
+    call === undefined
+      ? defaultExports(file).map((one) => objectOf(one, declared, true))
+      : optionsArguments(file, call).map((one) =>
+          one === undefined ? undefined : objectOf(one, declared, false),
+        );
+  const found: Node[] = [];
+  const visit = (object: Node, keys: readonly string[]): void => {
+    if (!isObjectLiteralExpression(object)) {
+      return;
+    }
+    const [key, ...rest] = keys;
+    for (const member of object.properties) {
+      if (!isPropertyAssignment(member) || keyOf(member) !== key) {
+        continue;
+      }
+      const held = unwrapped(member.initializer);
+      if (rest.length > 0) {
+        visit(held, rest);
+      } else if (literalText(held) !== undefined) {
+        found.push(held);
+      } else if (isArrayLiteralExpression(held)) {
+        found.push(...held.elements.map(unwrapped).filter((one) => literalText(one) !== undefined));
+      }
+    }
+  };
+  for (const object of objects) {
+    if (object !== undefined) {
+      visit(object, property.split("."));
+    }
+  }
+  return found;
+}
+
+/** The strings an applied row's selection keys hold, added per configuration file to `into`. */
+function selectedStrings(
+  host: Host,
+  parse: ParseSource,
+  dir: string,
+  readings: readonly MoveReading[],
+  into: Map<string, { starts: Set<number>; texts: string[] }>,
+): void {
+  for (const reading of readings) {
+    for (const { name, file } of readingFiles(host, parse, dir, reading.files)) {
+      const path = joinPath(dir, name);
+      const held = into.get(path) ?? { starts: new Set<number>(), texts: [] };
+      for (const node of stringsAt(file, reading.property, reading.call)) {
+        held.starts.add(node.getStart());
+        held.texts.push(literalText(node) ?? "");
+      }
+      into.set(path, held);
+    }
+  }
+}
+
+/**
+ * The dependencies one manifest declares that a string at any depth of one of its members
+ * names, alone or followed by `/` and a subpath, a member's name aside.
+ */
+function manifestKeyUses(manifest: unknown, keys: readonly string[]): readonly string[] {
+  if (!isRecord(manifest)) {
+    return [];
+  }
+  const declared = DEPENDENCY_SECTIONS.flatMap((section) => {
+    const held = manifest[section];
+    return isRecord(held) ? Object.keys(held) : [];
+  });
+  const strings = keys.flatMap((key) => documentStrings(manifest[key]));
+  return declared.filter((name) =>
+    strings.some((text) => text === name || text.startsWith(`${name}/`)),
+  );
+}
+
 /** What one configuration file states about one property. */
 interface PropertyReading {
   /** The literal values the file sets the property to. */
@@ -740,6 +832,7 @@ export function readConventions(
   const generated: GeneratedDirectory[] = [];
   const failures: ConventionFailure[] = [];
   const uses = new Set<string>();
+  const selected = new Map<string, { starts: Set<number>; texts: string[] }>();
   for (const manifest of manifests) {
     const declared = readJSON(host, joinPath(manifest.dir, "package.json"));
     const versions = new Map<string, string | undefined>();
@@ -801,6 +894,10 @@ export function readConventions(
       for (const name of shortNameUses(host, parse, manifest.dir, declared, row.shortNames ?? [])) {
         uses.add(name);
       }
+      for (const name of manifestKeyUses(declared, row.manifestKeys ?? [])) {
+        uses.add(name);
+      }
+      selectedStrings(host, parse, manifest.dir, row.selections ?? [], selected);
       const excludes = [
         ...new Set((row.excludes ?? []).flatMap((one) => expand(one, resolved))),
       ].map(globExpression);
@@ -824,7 +921,14 @@ export function readConventions(
       compare(a.manifest, b.manifest) ||
       compare(JSON.stringify(a), JSON.stringify(b)),
   );
-  return { applied: unique, globs, generated, failures, uses: [...uses].sort(compare) };
+  return {
+    applied: unique,
+    globs,
+    generated,
+    failures,
+    uses: [...uses].sort(compare),
+    selected,
+  };
 }
 
 /**