@cplieger/deadset-ts 5.1.1 → 5.2.1

package/src/contextual-uses.ts

@@ -97,12 +97,19 @@ interface Called {
 interface Checked {
   readonly source: Type;
   readonly targets: readonly Type[];
+  /**
+   * Whether the source is declared outside the target, so code the analysis does not
+   * hold reads the members of the target's types it declares.
+   */
+  readonly outside: boolean;
 }
 
 /** One member of an object type, by the inventory's declarations and the checker's declaration handles. */
 interface Member {
   readonly ids: readonly string[];
   readonly handles: ReadonlySet<string>;
+  /** Whether a declaration of it is in one of the target's own files. */
+  readonly own: boolean;
 }
 
 /**
@@ -120,6 +127,7 @@ export function contextualUses<Brand>(
   properties: PropertyTables,
 ): ContextualUses {
   const queries = project.queries;
+  const ownPaths = project.ownPaths();
   const kinds = new Map(held.symbols.map((symbol) => [symbol.id, symbol.kind]));
   let batches = 0;
   let lookups = 0;
@@ -162,6 +170,7 @@ export function contextualUses<Brand>(
         handles: new Set(
           property.declarations.map((handle) => `${handle.path}#${String(handle.index)}`),
         ),
+        own: property.declarations.some((handle) => ownPaths.has(handle.path)),
       });
     }
     tables.set(type.id, table);
@@ -203,6 +212,11 @@ export function contextualUses<Brand>(
     member.ids.filter((id) => kinds.get(id) === "type-member");
   const carries = (part: Type): boolean =>
     [...membersOf(part).values()].some((member) => readable(member).length > 0);
+  /** Whether an object type has members and declares none of them in the target. */
+  const outside = (part: Type): boolean => {
+    const members = [...membersOf(part).values()];
+    return members.length > 0 && members.every((member) => !member.own);
+  };
 
   const elements = new Map<number, Type | undefined>();
   /** The element type of an array type, read once per type. */
@@ -272,7 +286,9 @@ export function contextualUses<Brand>(
     const sources = partsOf(source).filter((one) => !targets.some((part) => part.id === one.id));
     for (const one of sources) {
       if (carries(one)) {
-        into.push({ source: one, targets });
+        into.push({ source: one, targets, outside: false });
+      } else if (outside(one)) {
+        into.push({ source: one, targets, outside: true });
       }
       const element = elementOf(one);
       const called = element === undefined ? callOf(one) : undefined;
@@ -303,7 +319,7 @@ export function contextualUses<Brand>(
     }
     seen.add(type.id);
     return partsOf(type).some((part) => {
-      if (carries(part)) {
+      if (carries(part) || outside(part)) {
         return true;
       }
       const element = elementOf(part);
@@ -332,9 +348,20 @@ export function contextualUses<Brand>(
     const checked: Checked[] = [];
     compared(type, position, checked, new Set());
     const ids = new Set<string>();
-    for (const { source, targets } of checked) {
+    for (const { source, targets, outside: held } of checked) {
       const tables = targets.map(membersOf);
-      for (const [name, member] of membersOf(source)) {
+      const sourceMembers = membersOf(source);
+      if (held) {
+        for (const table of tables) {
+          for (const [name, member] of table) {
+            if (sourceMembers.has(name)) {
+              member.ids.forEach((id) => ids.add(id));
+            }
+          }
+        }
+        continue;
+      }
+      for (const [name, member] of sourceMembers) {
         const read = tables.some((table) => {
           const declared = table.get(name);
           return (

package/src/convention-rows.ts

@@ -25,6 +25,12 @@ interface MoveReading {
   readonly call?: OptionsCall;
 }
 
+/** One configuration property whose value names a package by a short name. */
+export interface ShortNameReading extends MoveReading {
+  /** The package name a value stands for, written with `{}` where the value goes. */
+  readonly package: string;
+}
+
 /** One directory a row's globs name that a configuration property moves. */
 export interface DirectoryMove {
   /** The placeholder the row's globs and later moves write as `<id>`. */
@@ -56,6 +62,8 @@ export interface ConventionRow {
   readonly generated?: readonly string[];
   /** The directories configuration moves, in the order their placeholders depend on each other. */
   readonly moves: readonly DirectoryMove[];
+  /** The properties that name a package the configuration uses by a short name. */
+  readonly shortNames?: readonly ShortNameReading[];
 }
 
 const SCRIPT = "{js,jsx,ts,tsx}";
@@ -444,5 +452,12 @@ export const CONVENTION_ROWS: readonly ConventionRow[] = [
       `**/{vitest,vite}.*.config.${ANY_MODULE}`,
     ],
     moves: [],
+    shortNames: [
+      {
+        property: "test.coverage.provider",
+        files: [`{vitest,vite}.config.${ANY_MODULE}`],
+        package: "@vitest/coverage-{}",
+      },
+    ],
   },
 ];

package/src/conventions.ts

@@ -7,6 +7,7 @@
  */
 
 import {
+  isArrayLiteralExpression,
   isAsExpression,
   isBinaryExpression,
   isCallExpression,
@@ -50,6 +51,7 @@ import {
   type ConventionRow,
   type DirectoryMove,
   type OptionsCall,
+  type ShortNameReading,
 } from "./convention-rows.ts";
 import { globExpression } from "./glob.ts";
 import type { Host } from "./host.ts";
@@ -106,6 +108,8 @@ 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. */
+  readonly uses: readonly string[];
 }
 
 /** One file a row roots. */
@@ -445,6 +449,28 @@ function objectOf(
   return at;
 }
 
+/** The text of a string literal or a template literal with no substitution, or undefined. */
+function literalText(node: Node): string | undefined {
+  const at = unwrapped(node);
+  return isStringLiteral(at) || isNoSubstitutionTemplateLiteral(at) ? at.text : undefined;
+}
+
+/**
+ * The literal texts one value at a path's end writes: the literal itself, or, where
+ * `elements`, each element of an array literal of literals. Undefined for any other value.
+ */
+function literalTexts(held: Node, elements: boolean): readonly string[] | undefined {
+  const one = literalText(held);
+  if (one !== undefined) {
+    return [one];
+  }
+  if (!elements || !isArrayLiteralExpression(held)) {
+    return undefined;
+  }
+  const texts = held.elements.map(literalText);
+  return texts.every((text) => text !== undefined) ? texts : undefined;
+}
+
 /**
  * Reads the values at one path of keys below one object literal into `values`, and
  * answers the first member that does not write its value out: a spread, a value that is
@@ -454,6 +480,7 @@ function readPath(
   object: ObjectLiteralExpression,
   keys: readonly string[],
   values: string[],
+  elements: boolean,
 ): Node | undefined {
   const [key, ...rest] = keys;
   for (const member of object.properties) {
@@ -465,15 +492,16 @@ function readPath(
     }
     const held = isPropertyAssignment(member) ? unwrapped(member.initializer) : undefined;
     if (rest.length === 0) {
-      if (held === undefined || !(isStringLiteral(held) || isNoSubstitutionTemplateLiteral(held))) {
+      const texts = held === undefined ? undefined : literalTexts(held, elements);
+      if (texts === undefined) {
         return member;
       }
-      values.push(held.text);
+      values.push(...texts);
     } else {
       if (held === undefined || !isObjectLiteralExpression(held)) {
         return member;
       }
-      const failed = readPath(held, rest, values);
+      const failed = readPath(held, rest, values, elements);
       if (failed !== undefined) {
         return failed;
       }
@@ -493,14 +521,16 @@ interface PropertyReading {
 /**
  * Every value one file writes at one property's path inside the object it is read from:
  * the options argument of every call `call` names, or the file's default export. A string
- * literal or a template literal with no substitution is the value. A read object, or an
- * object along the path, that is not written out as an object literal, or that spreads
- * another object into itself, is not a literal, and neither is any other value at the path.
+ * literal or a template literal with no substitution is the value, and so is each element
+ * of an array literal of them where `elements`. A read object, or an object along the
+ * path, that is not written out as an object literal, or that spreads another object into
+ * itself, is not a literal, and neither is any other value at the path.
  */
 export function readProperty(
   file: SourceFile,
   property: string,
   call?: OptionsCall,
+  elements = false,
 ): PropertyReading {
   const declared = declaredValues(file);
   const objects =
@@ -515,7 +545,7 @@ export function readProperty(
       continue;
     }
     const notLiteral = isObjectLiteralExpression(object)
-      ? readPath(object, property.split("."), values)
+      ? readPath(object, property.split("."), values, elements)
       : object;
     if (notLiteral !== undefined) {
       return { values, notLiteral };
@@ -585,29 +615,19 @@ function resolveMove(
 ): MoveResult {
   const set: string[] = [];
   for (const reading of move.readings) {
-    for (const glob of reading.files) {
-      for (const name of configurationFiles(host, dir, glob)) {
-        const path = joinPath(dir, name);
-        let text: string;
-        try {
-          text = host.readFile(path);
-        } catch {
-          continue;
-        }
-        const file = parse(path, text);
-        const read = readProperty(file, reading.property, reading.call);
-        if (read.notLiteral !== undefined) {
-          const line = lineOf(text, read.notLiteral.getStart());
-          return {
-            failure:
-              `${name}:${String(line)} sets ${reading.property}, which moves a directory ` +
-              `the convention row ${row.name} reads, to a value that is not a string literal: ` +
-              `write it as a literal, or name ${row.name} in ts.disabled_conventions and its ` +
-              `files in ts.entry_files`,
-          };
-        }
-        set.push(...read.values);
+    for (const { name, text, file } of readingFiles(host, parse, dir, reading.files)) {
+      const read = readProperty(file, reading.property, reading.call);
+      if (read.notLiteral !== undefined) {
+        const line = lineOf(text, read.notLiteral.getStart());
+        return {
+          failure:
+            `${name}:${String(line)} sets ${reading.property}, which moves a directory ` +
+            `the convention row ${row.name} reads, to a value that is not a string literal: ` +
+            `write it as a literal, or name ${row.name} in ts.disabled_conventions and its ` +
+            `files in ts.entry_files`,
+        };
       }
+      set.push(...read.values);
     }
   }
   const dirs: (string | undefined)[] = [];
@@ -621,6 +641,71 @@ function resolveMove(
   return { dirs: [...new Set(dirs)] };
 }
 
+/** The texts each configuration file a reading names holds, parsed, in name order. */
+function readingFiles(
+  host: Host,
+  parse: ParseSource,
+  dir: string,
+  files: readonly string[],
+): readonly { readonly name: string; readonly text: string; readonly file: SourceFile }[] {
+  const found = [];
+  for (const glob of files) {
+    for (const name of configurationFiles(host, dir, glob)) {
+      const path = joinPath(dir, name);
+      let text: string;
+      try {
+        text = host.readFile(path);
+      } catch {
+        continue;
+      }
+      found.push({ name, text, file: parse(path, text) });
+    }
+  }
+  return found;
+}
+
+/**
+ * The dependencies one manifest declares that an applied row's short names use: the
+ * package each literal value stands for, and, for a value that is not a literal, every
+ * declared dependency the row's package name stands for with some value.
+ */
+function shortNameUses(
+  host: Host,
+  parse: ParseSource,
+  dir: string,
+  manifest: unknown,
+  readings: readonly ShortNameReading[],
+): readonly string[] {
+  const declared = new Set(
+    DEPENDENCY_SECTIONS.flatMap((section) => {
+      const held = isRecord(manifest) ? manifest[section] : undefined;
+      return isRecord(held) ? Object.keys(held) : [];
+    }),
+  );
+  const used = new Set<string>();
+  for (const reading of readings) {
+    const [before = "", after = ""] = reading.package.split("{}");
+    for (const { file } of readingFiles(host, parse, dir, reading.files)) {
+      const read = readProperty(file, reading.property, reading.call, true);
+      for (const value of read.values) {
+        used.add(`${before}${value}${after}`);
+      }
+      if (read.notLiteral !== undefined) {
+        for (const name of declared) {
+          if (
+            name.length >= before.length + after.length &&
+            name.startsWith(before) &&
+            name.endsWith(after)
+          ) {
+            used.add(name);
+          }
+        }
+      }
+    }
+  }
+  return [...used].filter((name) => declared.has(name)).sort(compare);
+}
+
 /** Two strings ordered bytewise. */
 function compare(a: string, b: string): number {
   if (a === b) {
@@ -644,6 +729,7 @@ export function readConventions(
   const globs: ConventionGlob[] = [];
   const generated: GeneratedDirectory[] = [];
   const failures: ConventionFailure[] = [];
+  const uses = new Set<string>();
   for (const manifest of manifests) {
     const declared = readJSON(host, joinPath(manifest.dir, "package.json"));
     const versions = new Map<string, string | undefined>();
@@ -702,6 +788,9 @@ export function readConventions(
         version,
         manifest: manifest.path,
       });
+      for (const name of shortNameUses(host, parse, manifest.dir, declared, row.shortNames ?? [])) {
+        uses.add(name);
+      }
       const excludes = [
         ...new Set((row.excludes ?? []).flatMap((one) => expand(one, resolved))),
       ].map(globExpression);
@@ -725,7 +814,7 @@ export function readConventions(
       compare(a.manifest, b.manifest) ||
       compare(JSON.stringify(a), JSON.stringify(b)),
   );
-  return { applied: unique, globs, generated, failures };
+  return { applied: unique, globs, generated, failures, uses: [...uses].sort(compare) };
 }
 
 /**

package/src/dependencies.ts

@@ -61,6 +61,15 @@ export interface DeclaredDependency {
   readonly position: FindingPosition;
 }
 
+/** What a configuration's own reading needs: packages no deletion of a declaration removes. */
+export function configurationNeeds(packages: readonly string[]): ProjectNeeds {
+  return {
+    packages: new Set(packages),
+    uses: new Map([[PROJECT_OWNER, new Set(packages)]]),
+    unanswered: false,
+  };
+}
+
 /** What the installed copy of one declared dependency states about itself. */
 export interface InstalledDependency {
   /** Whether its manifest declares a command. */

package/src/entry-point-gaps.ts

@@ -26,10 +26,10 @@ const UNREAD =
   "file only it loads is reported as never imported unless ts.entry_files or roots.patterns " +
   "names it.";
 
-/** Why a configuration's file names that are not relative literals are declined. */
-const NOT_RELATIVE =
-  "A string of a configuration file names a file only where it is a literal starting with ./ " +
-  "or ../, so a file named otherwise is reported as never imported.";
+/** Why a configuration's file names that are not literals are declined. */
+const NOT_LITERAL =
+  "A string of a configuration file names a file only where it is a literal, so a file a " +
+  "computed value names is reported as never imported.";
 
 /** The tools whose own conventions are not read. */
 const UNREAD_TOOLS: readonly string[] = [
@@ -230,11 +230,6 @@ const PARTLY_ENTERED: readonly DeclinedConvention[] = [
       "A testMatch that is not a string literal leaves the test-file set unknown, and an " +
       "unknown set enters nothing.",
   },
-  {
-    tool: "playwright",
-    convention: "a globalSetup or globalTeardown file named without a leading ./ or ../",
-    reason: NOT_RELATIVE,
-  },
   {
     tool: "playwright",
     convention: "the testDir and testMatch of an entry in projects",
@@ -300,22 +295,15 @@ const PARTLY_ENTERED: readonly DeclinedConvention[] = [
   },
   {
     tool: "vite",
-    convention: "an entry point its configuration names without a leading ./ or ../, or computes",
-    reason: NOT_RELATIVE,
-  },
-  {
-    tool: "vite",
-    convention: "the module scripts an index.html loads",
-    reason:
-      "No rule reads an HTML file, so a script only index.html loads is reported as never " +
-      "imported unless ts.entry_files names it.",
+    convention: "an entry point its configuration computes",
+    reason: NOT_LITERAL,
   },
   {
     tool: "vitest",
-    convention: "the benchmark and type-test files",
+    convention: "the benchmark files",
     reason:
-      "A test file is one ts.test_files classifies, so a *.bench.* or *.test-d.* file is " +
-      "entered only where a configured pattern names it.",
+      "A test file is one ts.test_files classifies, so a *.bench.* file is entered only " +
+      "where a configured pattern names it.",
   },
   {
     tool: "vitest",
@@ -324,11 +312,6 @@ const PARTLY_ENTERED: readonly DeclinedConvention[] = [
       "A string is read against the configuration file's directory, so a setup file named " +
       "against a root the configuration moves is not entered.",
   },
-  {
-    tool: "vitest",
-    convention: "a setup file named without a leading ./ or ../",
-    reason: NOT_RELATIVE,
-  },
   {
     tool: "vitest",
     convention: "the test files a configuration's include member names",
@@ -338,8 +321,8 @@ const PARTLY_ENTERED: readonly DeclinedConvention[] = [
   },
   {
     tool: "webpack",
-    convention: "an entry point its configuration names without a leading ./ or ../, or computes",
-    reason: NOT_RELATIVE,
+    convention: "an entry point its configuration computes",
+    reason: NOT_LITERAL,
   },
 ];
 

package/src/entry-points.ts

@@ -38,6 +38,7 @@ import {
 } from "./configuration-files.ts";
 import { globExpression } from "./glob.ts";
 import type { Host } from "./host.ts";
+import { htmlEntries } from "./html-entries.ts";
 import { dirnamePath, relativePath, resolvePath } from "./paths.ts";
 import { UNANSWERED } from "./query.ts";
 import type { ProjectView } from "./session.ts";
@@ -56,7 +57,9 @@ export type EntryRule =
   /** 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";
+  | "worker"
+  /** A file a module script of an HTML file below the target root loads. */
+  | "html-entry";
 
 /** One file a rule enters. */
 export interface EntryPoint {
@@ -542,5 +545,8 @@ export function entryPoints<Brand>(
     }
     found.push(...workersOf(project, file, files));
   }
+  for (const { file, source } of htmlEntries(host, targetRoot, files, parse)) {
+    found.push({ file, rule: "html-entry", source, exports: true });
+  }
   return found;
 }

package/src/exempt.ts

@@ -48,10 +48,7 @@ export interface DetectorInput<Brand> {
   readonly ts: TSSection;
   /** The absolute path of each declared consumer, whose modules are part of the analysis. */
   readonly consumers: readonly string[];
-  /**
-   * The project's generated files, by path below the target root, each with the
-   * convention row that names its directory as generated.
-   */
+  /** The project's generated files, by path below the target root, each with the detail its retentions name. */
   readonly generated?: ReadonlyMap<string, string>;
 }
 

package/src/file-facts.ts

@@ -47,7 +47,7 @@ export interface FileFacts {
    * reference names is included by the file that names it.
    */
   readonly heldByInclusion: ReadonlySet<string>;
-  /** The paths below the target root of the files below a directory an applied row names as generated. */
+  /** The paths below the target root of the generated files. */
   readonly generated?: ReadonlySet<string>;
 }
 

package/src/findings/completion.ts

@@ -55,16 +55,19 @@ function publishedIds(union: Graph): ReadonlySet<string> {
 
 /**
  * The reachability class of one declaration of the run. A declaration of a library's
- * published API, a public member of a published type included, has callers outside the
- * target: it is `certain` where the run loaded every consumer the scope declared and
- * declared at least one, `probable` where it declared consumers and did not load them
- * all, and `possible` where it declared none. Whether the configuration declares the
- * consumer set complete decides nothing here. Every other declaration has every reference
- * in the loaded program, a private member and a `#private` name among them, and is
- * `certain`.
+ * published API, a public member of a published type included, is `certain` where the
+ * run loaded every consumer the scope declared and declared one, `probable` where one did
+ * not load, and `possible` where it declared none, whatever the configuration says of the
+ * consumer set. A declaration of test-support code that test code references, outside the
+ * test-of-dead-code rule, is `possible`. Every other declaration is `certain`.
  */
 function reachabilityClasses(input: EmitterInput): (id: string) => Confidence {
   const published = publishedIds(input.swept.matrix.union);
+  const usedByTests = new Set(
+    input.swept.sweep.candidates
+      .filter((candidate) => candidate.heldByTests === candidate.id)
+      .map((candidate) => candidate.id),
+  );
   const { declared } = input.boundary.consumers;
   const outside: Confidence =
     declared.length === 0
@@ -72,7 +75,12 @@ function reachabilityClasses(input: EmitterInput): (id: string) => Confidence {
       : everyDeclaredLoaded(input.boundary)
         ? "certain"
         : "probable";
-  return (id) => (published.has(id) ? outside : "certain");
+  return (id) => {
+    if (usedByTests.has(id)) {
+      return "possible";
+    }
+    return published.has(id) ? outside : "certain";
+  };
 }
 
 /**
@@ -147,6 +155,12 @@ export function completed(
   const componentOf = findingComponents(swept, input.config.reporters.cascade);
   let minted = swept.sweep.components.length;
   const dead = new Set(swept.sweep.components.map((component) => component.id));
+  const fallingWith = new Map<string, number>();
+  for (const { heldByTests } of swept.sweep.candidates) {
+    if (heldByTests !== undefined) {
+      fallingWith.set(heldByTests, (fallingWith.get(heldByTests) ?? 0) + 1);
+    }
+  }
 
   const done = findings.map((finding): CompletedFinding => {
     const row = kinds.get(finding.code);
@@ -165,8 +179,14 @@ export function completed(
     const judged = !part && union.subject[at] === true ? symbol : undefined;
     const candidate = judged === undefined ? undefined : candidates.get(judged.id);
     const found = symbol === undefined || part ? undefined : componentOf(symbol.id);
-    // A test file's declaration is a component member only as a test of dead code.
-    if (candidate !== undefined && found === undefined && union.test[at] !== true) {
+    // A test file's declaration is a component member only as a test of dead code, and
+    // test code keeps the test-support code it references out of every component.
+    if (
+      candidate !== undefined &&
+      found === undefined &&
+      union.test[at] !== true &&
+      candidate.heldByTests === undefined
+    ) {
       throw new Error(`${candidate.id} is judged dead and falls in no dead component`);
     }
     let component = found;
@@ -175,7 +195,7 @@ export function completed(
       component = {
         id: componentId(minted),
         root: true,
-        symbolCount: 1,
+        symbolCount: symbol?.kind === "interface" ? (fallingWith.get(symbol.id) ?? 1) : 1,
         deletableLines: 0,
       };
     }

package/src/findings/interfaces.ts

@@ -31,7 +31,6 @@ function compare(a: string, b: string): number {
 function indexed(input: EmitterInput): {
   readonly symbolOf: (id: string) => InventorySymbol | undefined;
   readonly inTest: (id: string) => boolean;
-  readonly inSupport: (id: string) => boolean;
   readonly candidateOf: (id: string) => Candidate | undefined;
   readonly implementationsOf: (id: string) => readonly PositionedSymbol[];
 } {
@@ -44,7 +43,6 @@ function indexed(input: EmitterInput): {
   return {
     symbolOf,
     inTest: (id) => union.test[union.at(id)] === true,
-    inSupport: (id) => union.support[union.at(id)] === true,
     candidateOf: (id) => candidates.get(id),
     implementationsOf: (id) =>
       [...(input.implementations.classes.get(id) ?? [])]
@@ -82,19 +80,14 @@ function findingOf(
  * interface, whose members fall with it unreported; and `DS1203`, a method of a live
  * interface no reference names, unless it is a marker, a method whose every
  * implementation has an empty body. A test file's declaration is neither kind's
- * subject, because a production sweep counts none of the references it can have, and
- * neither is a test-support declaration test code references, which that code keeps live.
+ * subject, because a production sweep counts none of the references it can have.
  */
 export const interfaces: Emitter = (input) => {
   const run = indexed(input);
   const found: Finding[] = [];
   for (const candidate of input.swept.sweep.candidates) {
     const symbol = run.symbolOf(candidate.id);
-    if (
-      symbol === undefined ||
-      run.inTest(candidate.id) ||
-      (run.inSupport(candidate.id) && candidate.testRefs > 0)
-    ) {
+    if (symbol === undefined || run.inTest(candidate.id)) {
       continue;
     }
     if (symbol.kind === "interface") {