@cplieger/deadset-ts 5.2.3 → 6.0.1

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,
+  };
 }
 
 /**

package/src/dependencies.ts

@@ -1,10 +1,10 @@
 /**
- * The dependencies the target's manifest declares, and what the projects' own files
- * need from outside the target. A file needs a package it imports, re-exports from,
- * augments or references the types of, by name or through the file the specifier
- * resolves to; a compiler configuration needs one it names, and a configuration file a
- * tool loads needs each dependency its strings spell. A package one dependency pulls in
- * for itself is that dependency's need, not the target's.
+ * The dependencies the target's manifest and its workspace members' manifests declare, and
+ * what the projects' own files need from outside the target. A file needs a package it
+ * imports, re-exports from, augments or references the types of, by name or through the
+ * file the specifier resolves to; a compiler configuration needs one it names, and a
+ * configuration file a tool loads needs each dependency its strings spell. A package one
+ * dependency pulls in for itself is that dependency's need, not the target's.
  */
 
 import {
@@ -32,7 +32,7 @@ import {
 import type { FindingPosition } from "./finding.ts";
 import type { Host } from "./host.ts";
 import { nodeKey, packageScope, type Inventory } from "./inventory.ts";
-import { dirnamePath, isAbsolutePath, joinPath, resolvePath } from "./paths.ts";
+import { dirnamePath, isAbsolutePath, joinPath, relativePath, resolvePath } from "./paths.ts";
 import type { DependencySection, Module } from "./ref.ts";
 import { UNANSWERED } from "./query.ts";
 import type { Handle, ProjectView } from "./session.ts";
@@ -53,12 +53,14 @@ const SECTIONS: readonly (readonly [string, DependencySection])[] = [
 /** The owner of a use no declaration of the inventory holds: a configuration's. */
 const PROJECT_OWNER = "";
 
-/** One dependency the target's manifest declares. */
+/** One dependency a manifest the run reads declares. */
 export interface DeclaredDependency {
   readonly name: string;
   readonly section: DependencySection;
   /** Where the manifest writes the dependency's key, below the target root. */
   readonly position: FindingPosition;
+  /** The scope the dependency's reference is written in: its manifest's. */
+  readonly manifest: Module;
 }
 
 /** What a configuration's own reading needs: packages no deletion of a declaration removes. */
@@ -97,9 +99,7 @@ export interface ProjectNeeds {
 
 /** The run's dependency evidence. */
 export interface Dependencies {
-  /** The scope every dependency's reference is written in: the target's manifest. */
-  readonly manifest: Module;
-  /** Every declared dependency, in the order the manifest writes them. */
+  /** Every declared dependency, manifest by manifest, in the order each writes them. */
   readonly declared: readonly DeclaredDependency[];
   /** The installed copy of each declared dependency the run found, by name. */
   readonly installed: ReadonlyMap<string, InstalledDependency>;
@@ -608,8 +608,13 @@ function installedOf(host: Host, root: string, name: string): InstalledDependenc
   }
 }
 
-/** Every dependency the manifest text declares, in the order the text writes them. */
-function declaredIn(text: string, manifest: Record<string, unknown>): DeclaredDependency[] {
+/** Every dependency the manifest text at `path` declares, in the order the text writes them. */
+function declaredIn(
+  text: string,
+  manifest: Record<string, unknown>,
+  path: string,
+  scope: Module,
+): DeclaredDependency[] {
   const sections = membersAt(text, skipWhitespace(text, 0));
   const declared: { readonly dependency: DeclaredDependency; readonly at: number }[] = [];
   for (const [member, section] of SECTIONS) {
@@ -621,7 +626,12 @@ function declaredIn(text: string, manifest: Record<string, unknown>): DeclaredDe
     for (const [name, { key }] of membersAt(text, held.value)) {
       const { line, column } = lineAndColumn(text, key);
       declared.push({
-        dependency: { name, section, position: { path: MANIFEST, line, column, endLine: line } },
+        dependency: {
+          name,
+          section,
+          position: { path, line, column, endLine: line },
+          manifest: scope,
+        },
         at: key,
       });
     }
@@ -630,11 +640,10 @@ function declaredIn(text: string, manifest: Record<string, unknown>): DeclaredDe
 }
 
 /**
- * The run's dependency evidence: the target's manifest read with the position of every
- * dependency it declares, the installed copy of each, what the projects need, and the
- * last uses each deletion candidate holds.
- *
- * Only the manifest at the target root is read, as for entry points. A manifest the
+ * The run's dependency evidence: the target's manifest and each workspace member's in
+ * `members` below the target root, read with the position of every dependency each
+ * declares, the installed copy of each found from its manifest's directory, what the
+ * projects need, and the last uses each deletion candidate holds. A manifest the
  * program cannot read declares nothing.
  */
 export function dependenciesOf(
@@ -642,20 +651,31 @@ export function dependenciesOf(
   targetRoot: string,
   perProject: readonly ProjectNeeds[],
   candidates: readonly string[],
+  members: readonly string[] = [],
 ): Dependencies {
-  const read = readJSON(host, joinPath(targetRoot, MANIFEST));
-  const manifest = isRecord(read?.value) ? read.value : undefined;
-  const scope = packageScope(host, targetRoot)(MANIFEST);
-  const declared =
-    read !== undefined && manifest !== undefined ? declaredIn(read.text, manifest) : [];
-
   const root = resolvePath(host.workingDirectory(), targetRoot);
+  const scopeOf = packageScope(host, targetRoot);
+  const manifests = new Map<string, string>([[root, MANIFEST]]);
+  for (const dir of members) {
+    const below = relativePath(root, dir);
+    if (below !== undefined && !manifests.has(dir)) {
+      manifests.set(dir, `${below}/${MANIFEST}`);
+    }
+  }
+  const declared: DeclaredDependency[] = [];
   const installed = new Map<string, InstalledDependency>();
-  for (const dependency of declared) {
-    if (!installed.has(dependency.name)) {
-      const found = installedOf(host, root, dependency.name);
-      if (found !== undefined) {
-        installed.set(dependency.name, found);
+  for (const [dir, path] of manifests) {
+    const read = readJSON(host, joinPath(dir, MANIFEST));
+    if (read === undefined || !isRecord(read.value)) {
+      continue;
+    }
+    for (const dependency of declaredIn(read.text, read.value, path, scopeOf(path))) {
+      declared.push(dependency);
+      if (!installed.has(dependency.name)) {
+        const found = installedOf(host, dir, dependency.name);
+        if (found !== undefined) {
+          installed.set(dependency.name, found);
+        }
       }
     }
   }
@@ -691,5 +711,5 @@ export function dependenciesOf(
       );
     }
   }
-  return { manifest: scope, declared, installed, needed, lastUses };
+  return { declared, installed, needed, lastUses };
 }

package/src/entry-points.ts

@@ -36,6 +36,7 @@ import {
   moduleStrings,
   type ParseFile,
 } from "./configuration-files.ts";
+import type { Selected } from "./conventions.ts";
 import { globExpression } from "./glob.ts";
 import type { Host } from "./host.ts";
 import { htmlEntries } from "./html-entries.ts";
@@ -43,6 +44,7 @@ import { dirnamePath, relativePath, resolvePath } from "./paths.ts";
 import { UNANSWERED } from "./query.ts";
 import type { ProjectView } from "./session.ts";
 import type { SourceFiles } from "./source-files.ts";
+import { workflowEntries } from "./workflow-steps.ts";
 
 /** Which rule entered a file. */
 export type EntryRule =
@@ -52,14 +54,14 @@ export type EntryRule =
   | "configuration-string"
   /** The test runner: its workspace configuration, its setup files and the test files. */
   | "test-runner"
-  /** The mutation tester's configuration under a name the configuration form does not cover. */
-  | "mutation-testing"
   /** The test files below the browser-test runner's test directory. */
   | "browser-tests"
   /** A worker or service worker a call addresses by a string literal. */
   | "worker"
   /** A file a module script of an HTML file below the target root loads. */
-  | "html-entry";
+  | "html-entry"
+  /** A file a `run:` step of a workflow in the target root's `.github/workflows` names. */
+  | "workflow-step";
 
 /** One file a rule enters. */
 export interface EntryPoint {
@@ -90,9 +92,6 @@ interface Convention {
 /** The extensions the test runner and the browser-test runner load a configuration from. */
 const MODULE_EXTENSIONS = ["js", "mjs", "cjs", "ts", "mts", "cts"] as const;
 
-/** The extensions the mutation tester's configuration is loaded from. */
-const SCRIPT_EXTENSIONS = ["js", "mjs", "cjs"] as const;
-
 /** The tool file names the configuration form does not cover. */
 const CONVENTIONS: readonly Convention[] = [
   {
@@ -101,12 +100,6 @@ const CONVENTIONS: readonly Convention[] = [
     extensions: MODULE_EXTENSIONS,
     testRunner: true,
   },
-  {
-    rule: "mutation-testing",
-    stems: ["stryker.conf", ".stryker.config", ".stryker.conf"],
-    extensions: SCRIPT_EXTENSIONS,
-    testRunner: false,
-  },
 ];
 
 /** The stem of the browser-test runner's configuration, whose test directory is read. */
@@ -262,16 +255,35 @@ function isBrowserTestConfig(name: string): boolean {
 /**
  * The files the configuration files of one project enter: each configuration module,
  * with what it exports, and each own file a relative string of a configuration module
- * or a JSON configuration file names, read against that file's directory.
+ * or a JSON configuration file names, read against that file's directory. A string at a
+ * selection key of an applied convention row names no file.
  */
 function configurationEntries(
   host: Host,
   targetRoot: string,
   files: SourceFiles,
   parse: ParseFile | undefined,
+  selected: ReadonlyMap<string, Selected>,
 ): readonly EntryPoint[] {
   const { modules, documents, outside } = configurationFiles(host, targetRoot, files, parse);
   const found: EntryPoint[] = [];
+  const unselected = (file: SourceFile): readonly string[] => {
+    const starts = selected.get(file.fileName)?.starts;
+    return moduleStrings(file)
+      .filter((one) => starts?.has(one.node.getStart()) !== true)
+      .map((one) => one.text);
+  };
+  const unselectedIn = (path: string, texts: readonly string[]): readonly string[] => {
+    const left = [...(selected.get(path)?.texts ?? [])];
+    return texts.filter((text) => {
+      const at = left.indexOf(text);
+      if (at < 0) {
+        return true;
+      }
+      left.splice(at, 1);
+      return false;
+    });
+  };
   const strings = (dir: string, texts: readonly string[]): void => {
     for (const text of texts) {
       for (const file of filesNamedBy(files, dir, text)) {
@@ -281,13 +293,10 @@ function configurationEntries(
   };
   for (const { file, form } of modules) {
     found.push({ file, rule: "configuration-file", source: form, exports: true });
-    strings(
-      dirnamePath(file.fileName),
-      moduleStrings(file).map((one) => one.text),
-    );
+    strings(dirnamePath(file.fileName), unselected(file));
   }
   for (const document of documents) {
-    strings(dirnamePath(document.path), document.strings);
+    strings(dirnamePath(document.path), unselectedIn(document.path, document.strings));
   }
   for (const { file } of outside) {
     strings(
@@ -523,8 +532,9 @@ export function entryPoints<Brand>(
   host: Host,
   targetRoot: string,
   parse?: ParseFile,
+  selected: ReadonlyMap<string, Selected> = new Map(),
 ): readonly EntryPoint[] {
-  const found: EntryPoint[] = [...configurationEntries(host, targetRoot, files, parse)];
+  const found: EntryPoint[] = [...configurationEntries(host, targetRoot, files, parse, selected)];
   const tests = testFiles.map((pattern) => ({ pattern, expression: globExpression(pattern) }));
   for (const [path, file] of files.byPath) {
     const name = basename(path);
@@ -548,5 +558,8 @@ export function entryPoints<Brand>(
   for (const { file, source } of htmlEntries(host, targetRoot, files, parse)) {
     found.push({ file, rule: "html-entry", source, exports: true });
   }
+  for (const { file, source } of workflowEntries(host, targetRoot, files)) {
+    found.push({ file, rule: "workflow-step", source, exports: true });
+  }
   return found;
 }

package/src/exempt.ts

@@ -24,7 +24,7 @@ import { byPosition, positionKey, type Position } from "./position.ts";
 import { Unanswerable } from "./query.ts";
 import type { ProjectView } from "./session.ts";
 import type { Templates } from "./template-field.ts";
-import { sweep, type Exemption, type Mode, type SweepInput } from "./sweep.ts";
+import { sweep, type Exemption, type Implementing, type Mode, type SweepInput } from "./sweep.ts";
 
 /** One declaration a detector holds back, and where and why. */
 export interface Evidence {
@@ -35,6 +35,8 @@ export interface Evidence {
   readonly site: Position;
   /** The component file, below the target root, whose markup holds the evidence. */
   readonly whileLive?: string;
+  /** Where the evidence is an implementation of interface methods, which and how. */
+  readonly implementing?: Implementing;
 }
 
 /** What a detector reads of one project, while the project's view is open. */
@@ -214,6 +216,7 @@ export function evidenceRecords<Brand>(
         detail: evidence.detail,
         site: evidence.site,
         ...(evidence.whileLive === undefined ? {} : { whileLive: evidence.whileLive }),
+        ...(evidence.implementing === undefined ? {} : { implementing: evidence.implementing }),
       });
     }
   }

package/src/findings/completion.ts

@@ -10,7 +10,8 @@ import type { Cascade, Confidence, Severity } from "../config.ts";
 import type { CompletedFinding, Finding, FindingComponent, PositionedSymbol } from "../finding.ts";
 import { OUTSIDE, type Graph } from "../graph.ts";
 import { KINDS, type KindRow } from "../kinds.ts";
-import { byPosition } from "../position.ts";
+import { byPosition, positionKey } from "../position.ts";
+import { declarationKey } from "../ref.ts";
 import { FAMILY_KEY_LENGTH } from "../resolve.ts";
 import { isPartSubject, isRowSubject, type Dials } from "../suppress.ts";
 import type { Boundary } from "./boundary.ts";
@@ -149,7 +150,9 @@ export function completed(
 ): readonly CompletedFinding[] {
   const { swept } = input;
   const union = swept.matrix.union;
-  const positions = new Map(union.symbols.map((symbol, at) => [symbol.ref, at]));
+  const positions = new Map(
+    union.symbols.map((symbol, at) => [declarationKey(symbol.ref, symbol.position.path), at]),
+  );
   const candidates = new Map(swept.sweep.candidates.map((candidate) => [candidate.id, candidate]));
   const classOf = reachabilityClasses(input);
   const componentOf = findingComponents(swept, input.config.reporters.cascade);
@@ -168,10 +171,14 @@ export function completed(
       throw new Error(`${finding.code} names no live row of the issue-kind vocabulary`);
     }
     // A row's reference may spell a declaration's, as an ignore entry naming one does, and
-    // a row is still never the declaration.
+    // a row is still never the declaration. Two declarations of one file can share a
+    // reference, so the one the finding is positioned at is the subject where there is one.
+    const declared = union.at(positionKey(finding.position));
     const at = isRowSubject(finding.symbol.kind)
       ? OUTSIDE
-      : (positions.get(finding.symbol.ref) ?? OUTSIDE);
+      : union.symbols[declared]?.ref === finding.symbol.ref
+        ? declared
+        : (positions.get(declarationKey(finding.symbol.ref, finding.position.path)) ?? OUTSIDE);
     // A part names the declaration that holds it, and is decided inside it rather than by
     // the declaration's liveness, so it carries none of the declaration's sweep facts.
     const part = isPartSubject(finding.symbol.kind);

package/src/findings/dependencies-and-module-machinery.ts

@@ -37,7 +37,7 @@ function neededBy(dependencies: Dependencies): ReadonlySet<string> {
 }
 
 /**
- * A dependency, development dependency or peer dependency of the target's manifest
+ * A dependency, development dependency or peer dependency of a manifest the run reads
  * that the target does not need, at the position of its key.
  */
 function unusedDependencies(dependencies: Dependencies): Finding[] {
@@ -48,7 +48,7 @@ function unusedDependencies(dependencies: Dependencies): Finding[] {
       code: UNUSED_DEPENDENCY,
       position: dependency.position,
       symbol: {
-        ref: renderRef(dependencies.manifest, {
+        ref: renderRef(dependency.manifest, {
           of: "dependency",
           name: dependency.name,
           section: dependency.section,