@cplieger/deadset-ts 5.2.3 → 6.0.1

package/dist/src/suppress-file.js

@@ -7,6 +7,7 @@
 import { jsonChunks } from "./json-chunks.js";
 import { joinPath } from "./paths.js";
 import { positionAt, walkDocument } from "./json-document.js";
+import { declarationKey } from "./ref.js";
 import { CODE_FORM, SUPPRESSION_WITHOUT_REASON, SuppressionError, UNSCOPED_ENTRY, blankReason, isEntryPath, isSymbolRef, siteText, } from "./suppress.js";
 /** The name and the location the grammar fixes for the ignore file. */
 export const IGNORE_FILE = "deadset-ignore.json";
@@ -38,9 +39,6 @@ function documentSite(shape) {
 function isObject(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function referenceKey(ref, path) {
-    return `${ref}\u0000${path}`;
-}
 /**
  * Reads one entry or row: the records it binds, the refusals it carries, or the
  * malformed value that ends the run.
@@ -100,7 +98,7 @@ function readRecord(value, site, byReference, shape) {
     if (refusals.length > 0) {
         return { records: [], refusals };
     }
-    const named = byReference.get(referenceKey(symbol, written.path)) ?? [];
+    const named = byReference.get(declarationKey(symbol, written.path)) ?? [];
     if (named.length === 0) {
         return { records: [{ ...written, bound: "" }], refusals: [] };
     }
@@ -109,7 +107,7 @@ function readRecord(value, site, byReference, shape) {
 function byReferenceOf(symbols) {
     const byReference = new Map();
     for (const symbol of symbols) {
-        const key = referenceKey(symbol.ref, symbol.position.path);
+        const key = declarationKey(symbol.ref, symbol.position.path);
         byReference.set(key, [...(byReference.get(key) ?? []), symbol]);
     }
     return byReference;

package/dist/src/version.js

@@ -4,4 +4,4 @@
  * independently of the analyzer's own version, which is the one the host answers
  * from the package the analyzer was installed from.
  */
-export const CONTRACT_VERSION = "5.3.0";
+export const CONTRACT_VERSION = "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/dist/src/workspace-programs.js

@@ -7,7 +7,7 @@
  */
 import { ModuleKind, ModuleResolutionKind } from "@typescript/native/unstable/sync";
 import { isStringLiteralLikeNode } from "@typescript/native/unstable/ast";
-import { dirnamePath, joinPath, resolvePath } from "./paths.js";
+import { dirnamePath, resolvePath } from "./paths.js";
 /** The most questions one round trip carries. */
 const BATCH = 2048;
 /**
@@ -20,31 +20,6 @@ function analysisOptions(parsed) {
     const { composite, rootDir: _rootDir, outDir: _outDir, declarationDir: _declarationDir, tsBuildInfoFile: _tsBuildInfoFile, ...kept } = parsed.options;
     return composite === true ? { ...kept, declaration: true } : kept;
 }
-/**
- * The references a built program can carry: only where every referenced
- * configuration reads and is composite with output, because the compiler reports a
- * broken reference at syntax a built program does not have.
- */
-function carriedReferences(engine, parsed) {
-    const references = parsed.projectReferences ?? [];
-    for (const reference of references) {
-        // A reference that names a directory names the `tsconfig.json` in it.
-        const configFile = reference.path.endsWith(".json")
-            ? reference.path
-            : joinPath(reference.path, "tsconfig.json");
-        let options;
-        try {
-            options = engine.parseConfigFile(configFile).options;
-        }
-        catch {
-            return [];
-        }
-        if (options.composite !== true || options.noEmit === true) {
-            return [];
-        }
-    }
-    return references;
-}
 /** The conditions an `exports` lookup under one configuration and one resolution mode reads. */
 function conditionsOf(parsed, mode) {
     const resolution = parsed.options.moduleResolution;
@@ -94,7 +69,7 @@ function configurationOf(engine, host, reading) {
     if (reason !== undefined) {
         return { kind: "unread", reason };
     }
-    const { options } = reading.parsed;
+    const { options, projectReferences: references = [] } = reading.parsed;
     const raw = options["pathsBasePath"];
     const base = typeof raw === "string" ? raw : dirnamePath(reading.configFile);
     const paths = {};
@@ -117,8 +92,8 @@ function configurationOf(engine, host, reading) {
             ...(options.composite === true ? { composite: false, declaration: true } : {}),
             paths,
         },
-        ...(reading.references.length > 0
-            ? { references: reading.references.map((reference) => ({ path: reference.path })) }
+        ...(references.length > 0
+            ? { references: references.map((reference) => ({ path: reference.path })) }
             : {}),
         ...(exclude === undefined ? {} : { exclude }),
     });
@@ -150,6 +125,7 @@ function configurationOf(engine, host, reading) {
 /** The program one configuration is built as, under the answers it holds so far. */
 function programOf(engine, reading) {
     const compilerOptions = analysisOptions(reading.parsed);
+    const references = reading.parsed.projectReferences ?? [];
     const resolver = engine.createModuleResolver(compilerOptions, reading.entries);
     return {
         resolver,
@@ -159,7 +135,7 @@ function programOf(engine, reading) {
             options: {
                 moduleResolver: resolver,
                 configFileParsingDiagnostics: reading.parsed.errors,
-                ...(reading.references.length > 0 ? { projectReferences: reading.references } : {}),
+                ...(references.length > 0 ? { projectReferences: references } : {}),
             },
         },
     };
@@ -292,7 +268,6 @@ export function workspacePrograms(engine, host, configFiles, resolver) {
             {
                 configFile,
                 parsed,
-                references: carriedReferences(engine, parsed),
                 entries: [],
                 seen: new Set(),
                 bound: new Map(),

package/jsr.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "5.2.3",
+  "version": "6.0.1",
   "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.1",
   "type": "module",
   "sideEffects": false,
   "description": "Deterministic dead-code analysis for TypeScript, class and type members included",
@@ -29,10 +29,16 @@
     "lint:fix": "eslint . --fix && prettier --write ."
   },
   "dependencies": {
-    "@typescript/native": "npm:typescript@7.1.0-dev.20261006.1"
+    "@typescript/native": "npm:typescript@7.1.0-dev.20261007.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] },
+    ],
   },
 ];