@cplieger/deadset-ts 7.2.0-dev.4 → 8.0.0-dev.2

package/src/base-url.ts

@@ -0,0 +1,24 @@
+import { resolvePath } from "./paths.ts";
+import type { Engine } from "./session.ts";
+
+type CompilerOptions = ReturnType<Engine["parseConfigFile"]>["options"];
+
+/**
+ * The `paths` one configuration's resolved options map under the compilers before version
+ * 7, each target absolute: a target is read against the effective `baseUrl`, and a specifier
+ * no other pattern maps is looked up below it. Undefined where no `baseUrl` is set, so the
+ * options' own `paths` stand. Version 7 reads no `baseUrl`:
+ * https://github.com/microsoft/TypeScript/issues/62207
+ */
+export function baseUrlPaths(options: CompilerOptions): Record<string, string[]> | undefined {
+  const baseUrl: unknown = Reflect.get(options, "baseUrl");
+  if (typeof baseUrl !== "string") {
+    return undefined;
+  }
+  return Object.fromEntries(
+    Object.entries({ "*": ["*"], ...options.paths }).map(([key, targets]) => [
+      key,
+      targets.map((target) => resolvePath(baseUrl, target)),
+    ]),
+  );
+}

package/src/components.ts

@@ -208,12 +208,12 @@ function linesSpanned(symbols: readonly (InventorySymbol | undefined)[]): number
 }
 
 /**
- * The dead declarations by subgraph place (`at`, and `position` per graph declaration),
- * a test file's only where it tests dead code or nothing the tests reach. `adjacent` holds
- * each reference one makes to another, except an unreferenced test-file declaration's to
- * production code, which decides nothing of its target; an edge each way between a dead
- * member and its dead container; and one back from each production target of an admitted
- * test, which puts the test in its subject's component. `references` holds the first alone.
+ * The dead declarations by subgraph place (`at`, and `position` per graph declaration), a
+ * test file's only where it tests dead code or nothing the tests reach. `adjacent` holds each
+ * reference one makes to another, but an unreferenced test-file declaration's to production
+ * code, which decides nothing; an edge each way between a dead member and its dead container;
+ * and one back from each non-ambient production target of an admitted test, which puts the
+ * test in its subject's component. `references` holds the first alone.
  */
 function deadSubgraph(
   graph: Graph,
@@ -248,6 +248,7 @@ function deadSubgraph(
       if (
         testOfDeadCode[index] === true &&
         graph.test[edge.to] !== true &&
+        graph.ambient[edge.to] !== true &&
         graph.subject[edge.to] === true
       ) {
         adjacent[to]?.push(from);

package/src/config.ts

@@ -175,6 +175,8 @@ export interface TSSection {
   readonly injectionRegistrations: readonly DeclarationEntry[];
   readonly lifecycleContracts: readonly LifecycleContract[];
   readonly serializers: readonly DeclarationEntry[];
+  /** Whether the maintainer declares the roots the analysis finds every root the target has. */
+  readonly rootsComplete: boolean;
 }
 
 /**
@@ -253,6 +255,7 @@ export function defaultConfig(): Config {
       injectionRegistrations: [],
       lifecycleContracts: [],
       serializers: [],
+      rootsComplete: false,
     },
   };
 }

package/src/configuration-files.ts

@@ -8,10 +8,13 @@
  */
 
 import {
+  isCallExpression,
   isExportDeclaration,
+  isIdentifier,
   isImportDeclaration,
   isNoSubstitutionTemplateLiteral,
   isStringLiteral,
+  SyntaxKind,
   type Node,
   type SourceFile,
 } from "@typescript/native/ast";
@@ -110,7 +113,7 @@ interface ConfigurationDocument {
 export type ParseFile = (fileName: string, text: string) => SourceFile;
 
 /** One file no program holds that a configuration module outside the program leads to. */
-interface OutsideModule {
+export interface OutsideModule {
   /** The file, parsed alone. */
   readonly file: SourceFile;
   /** The directories of the manifests of the configuration files the file was reached from. */
@@ -439,19 +442,70 @@ export function configurationFiles(
   };
 }
 
-/** The relative specifiers one file's imports and re-exports name. */
-function relativeSpecifiers(file: SourceFile): readonly string[] {
-  return file.statements.flatMap((statement) => {
-    const specifier =
+/** The literal module specifier one `require(...)` or `import(...)` call names, if any. */
+function calledSpecifier(node: Node): Node | undefined {
+  if (!isCallExpression(node) || node.arguments.length !== 1) {
+    return undefined;
+  }
+  const callee = node.expression;
+  const loads =
+    callee.kind === SyntaxKind.ImportKeyword || (isIdentifier(callee) && callee.text === "require");
+  return loads ? node.arguments[0] : undefined;
+}
+
+/**
+ * The relative specifiers one file's imports and re-exports name, and those its
+ * `require(...)` and `import(...)` calls name by a literal.
+ */
+export function relativeSpecifiers(file: SourceFile): readonly string[] {
+  const known = specifiersOf.get(file);
+  if (known !== undefined) {
+    return known;
+  }
+  const found: string[] = [];
+  const named = (specifier: Node | undefined): void => {
+    if (
+      specifier !== undefined &&
+      (isStringLiteral(specifier) || isNoSubstitutionTemplateLiteral(specifier)) &&
+      RELATIVE_PREFIXES.some((prefix) => specifier.text.startsWith(prefix))
+    ) {
+      found.push(specifier.text);
+    }
+  };
+  const visit = (node: Node): void => {
+    named(calledSpecifier(node));
+    node.forEachChild(visit);
+  };
+  for (const statement of file.statements) {
+    named(
       isImportDeclaration(statement) || isExportDeclaration(statement)
         ? statement.moduleSpecifier
-        : undefined;
-    return specifier !== undefined &&
-      isStringLiteral(specifier) &&
-      RELATIVE_PREFIXES.some((prefix) => specifier.text.startsWith(prefix))
-      ? [specifier.text]
-      : [];
-  });
+        : undefined,
+    );
+    visit(statement);
+  }
+  specifiersOf.set(file, found);
+  return found;
+}
+
+/** What {@link relativeSpecifiers} found in each file, which every project of a run reads alike. */
+const specifiersOf = new WeakMap<SourceFile, readonly string[]>();
+
+/**
+ * The files no program holds that a chain from `seeds` reads: each seed, and each file
+ * below the target root one imports, re-exports or loads by a relative specifier that no
+ * program holds either, until no further file joins, each read against the manifest
+ * directory its seed names. A file that cannot be read is skipped.
+ */
+export function outsideChain(
+  host: Host,
+  targetRoot: string,
+  files: SourceFiles,
+  parse: ParseFile,
+  seeds: readonly { readonly path: string; readonly manifestDir: string }[],
+): readonly OutsideModule[] {
+  const root = resolvePath(host.workingDirectory(), targetRoot);
+  return outsideModules(host, root, [], files, () => false, parse, seeds);
 }
 
 /**

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: "5.2.0",
+    corpusVersion: "6.0.0",
     result: "pass",
-    digest: "sha256:012872542679539ec105f49b5ee502b0a9fa35c6bbd9ef3983b5f6e53af83d8e",
+    digest: "sha256:d65daae4b7c95050c07896b166d0250d233cca71f97de75a6086c1d80fe76232",
   },
   gaps: [],
 } as const;

package/src/convention-rows.ts

@@ -31,6 +31,22 @@ export interface ShortNameReading extends MoveReading {
   readonly package: string;
 }
 
+/**
+ * One configuration property whose values name packages by the tool's prefix convention:
+ * `x` stands for `<prefix>-x`, `@s` for `@s/<prefix>` and `@s/x` for `@s/<prefix>-x`, and
+ * a name already holding the prefix for itself.
+ */
+export interface PrefixedNameReading extends MoveReading {
+  /** The prefix the convention puts before a short name. */
+  readonly prefix: string;
+  /**
+   * The text a value starts with to name a package, the name ending at its last `/`.
+   * Absent, every value without a `:` names one, the name ending at its first `/` past
+   * a scope.
+   */
+  readonly marker?: string;
+}
+
 /**
  * One configuration property whose value makes the tool's output import a runtime helper
  * package, so the package is used where the property holds that value.
@@ -63,6 +79,14 @@ export interface TestFileReading extends MoveReading {
   readonly roots: readonly string[];
 }
 
+/** One member of the declaring `package.json` whose strings name the tool's entries. */
+export interface ManifestEntryKey {
+  /** The member's path through nested objects, its keys joined by `.`, a `*` key standing for every member. */
+  readonly key: string;
+  /** Whether each string names a directory of entries, or one entry, its extension optional. */
+  readonly directory: boolean;
+}
+
 /** 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>`. */
@@ -96,6 +120,8 @@ 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 that name a package the configuration uses by its prefix convention. */
+  readonly prefixedNames?: readonly PrefixedNameReading[];
   /**
    * 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.
@@ -110,6 +136,8 @@ export interface ConventionRow {
   readonly packageKeys?: readonly PackageKey[];
   /** The members of a `package.json` the tool reads its configuration from. */
   readonly manifestKeys?: readonly string[];
+  /** The members of the declaring `package.json` whose strings name entries, as an entry glob does. */
+  readonly manifestEntries?: readonly ManifestEntryKey[];
   /** The settings that make the tool's output import a runtime helper package. */
   readonly helpers?: readonly HelperReading[];
 }
@@ -118,6 +146,8 @@ const SCRIPT = "{js,jsx,ts,tsx}";
 const MODULE = "{js,mjs,ts,mts}";
 const ANY_MODULE = "{js,mjs,cjs,ts,mts,cts}";
 const VITE_CONFIG = `vite.config.${ANY_MODULE}`;
+/** The legacy configuration files of ESLint that hold JSON or a CommonJS module. */
+const ESLINTRC = [".eslintrc", ".eslintrc.json", ".eslintrc.{js,cjs}"];
 
 const SVELTEKIT_ROUTE_FILES = "+{page,layout,server,page.server,layout.server,error}";
 
@@ -179,6 +209,31 @@ const ANGULAR_PACKAGE_KEYS: readonly PackageKey[] = [
   "scripts",
 ].map((key) => ({ key, files: ["angular.json"] }));
 
+/**
+ * The test runners and the assertion, mock and runner libraries whose import is test
+ * evidence beside each runner a row reads test files for. Each applies whether or not a
+ * manifest declares it, so none is a row.
+ */
+export const TEST_LIBRARIES: readonly string[] = [
+  "@jest/globals",
+  "@playwright/test",
+  "ava",
+  "chai",
+  "expect",
+  "jasmine",
+  "jest",
+  "mocha",
+  "msw",
+  "nock",
+  "node:test",
+  "sinon",
+  "tap",
+  "uvu",
+];
+
+/** The scopes every package of which is a test library. */
+export const TEST_LIBRARY_SCOPES: readonly string[] = ["@testing-library/"];
+
 /** Every row, ordered by name and then by range. */
 export const CONVENTION_ROWS: readonly ConventionRow[] = [
   {
@@ -231,6 +286,25 @@ export const CONVENTION_ROWS: readonly ConventionRow[] = [
       package: "@babel/runtime",
     })),
   },
+  {
+    name: "docusaurus",
+    package: "@docusaurus/core",
+    range: ">=2.0.0 <4.0.0",
+    entries: [`src/pages/**/*.${SCRIPT}`, `src/theme/**/*.${SCRIPT}`],
+    moves: [],
+  },
+  {
+    name: "eslint",
+    package: "eslint",
+    range: ">=4.0.0 <10.0.0",
+    entries: [],
+    moves: [],
+    prefixedNames: [
+      { property: "plugins", files: ESLINTRC, prefix: "eslint-plugin" },
+      { property: "extends", files: ESLINTRC, prefix: "eslint-plugin", marker: "plugin:" },
+      { property: "extends", files: ESLINTRC, prefix: "eslint-config" },
+    ],
+  },
   {
     name: "eslint",
     package: "eslint",
@@ -238,6 +312,13 @@ export const CONVENTION_ROWS: readonly ConventionRow[] = [
     entries: [`**/eslint.config.${ANY_MODULE}`],
     moves: [],
   },
+  {
+    name: "expo",
+    package: "expo",
+    range: ">=44.0.0 <60.0.0",
+    entries: [`{index,App}.${SCRIPT}`],
+    moves: [],
+  },
   {
     name: "expo-router",
     package: "expo-router",
@@ -322,6 +403,28 @@ export const CONVENTION_ROWS: readonly ConventionRow[] = [
       },
     ],
   },
+  {
+    name: "oclif",
+    package: "@oclif/core",
+    range: ">=1.0.0 <5.0.0",
+    entries: [`src/{commands,hooks}/**/*.${SCRIPT}`],
+    moves: [],
+    manifestEntries: [
+      { key: "oclif.commands", directory: true },
+      { key: "oclif.hooks", directory: false },
+    ],
+  },
+  {
+    name: "parcel",
+    package: "parcel",
+    range: ">=2.0.0 <3.0.0",
+    entries: [],
+    moves: [],
+    manifestEntries: [
+      { key: "source", directory: false },
+      { key: "targets.*.source", directory: false },
+    ],
+  },
   {
     name: "prettier",
     package: "prettier",
@@ -613,6 +716,31 @@ export const CONVENTION_ROWS: readonly ConventionRow[] = [
       },
     ],
   },
+  {
+    name: "tanstack-router",
+    package: "@tanstack/router-plugin",
+    range: ">=1.0.0 <2.0.0",
+    entries: [`<routes>/**/*.${SCRIPT}`],
+    moves: [
+      {
+        id: "routes",
+        defaults: ["src/routes"],
+        readings: [
+          { property: "routesDirectory", files: ["tsr.config.json"] },
+          {
+            property: "routesDirectory",
+            files: [VITE_CONFIG],
+            call: { module: "@tanstack/router-plugin/vite", export: "tanstackRouter" },
+          },
+          {
+            property: "routesDirectory",
+            files: [VITE_CONFIG],
+            call: { module: "@tanstack/router-plugin/vite", export: "TanStackRouterVite" },
+          },
+        ],
+      },
+    ],
+  },
   {
     name: "vite",
     package: "vite",

package/src/conventions.ts

@@ -51,9 +51,11 @@ import {
   type ConventionRow,
   type DirectoryMove,
   type HelperReading,
+  type ManifestEntryKey,
   type MoveReading,
   type OptionsCall,
   type PackageKey,
+  type PrefixedNameReading,
   type ShortNameReading,
   type TestFileReading,
 } from "./convention-rows.ts";
@@ -692,6 +694,47 @@ function manifestKeyUses(manifest: unknown, keys: readonly string[]): readonly s
   );
 }
 
+/** The extensions an entry a manifest entry key names without one may carry. */
+const ENTRY_EXTENSIONS = "{js,jsx,mjs,cjs,ts,tsx,mts,cts}";
+
+/** The characters that make a manifest string a pattern rather than a directory's name. */
+const PATTERN = /[*?{}[\]]/u;
+
+/**
+ * The entry globs one applied row's manifest entry keys write, below the manifest's
+ * directory: a directory's every module, or a file with or without an extension. A string
+ * that leaves the directory names nothing.
+ */
+function manifestEntryGlobs(manifest: unknown, keys: readonly ManifestEntryKey[]): string[] {
+  const at = (value: unknown, path: readonly string[]): unknown[] => {
+    const [key, ...rest] = path;
+    if (key === undefined) {
+      return [value];
+    }
+    if (!isRecord(value)) {
+      return [];
+    }
+    const next = key === "*" ? Object.values(value) : Object.hasOwn(value, key) ? [value[key]] : [];
+    return next.flatMap((one) => at(one, rest));
+  };
+  return keys.flatMap(({ key, directory }) =>
+    at(manifest, key.split(".")).flatMap((value) =>
+      documentStrings(value).flatMap((text) => {
+        const path = normalizePath(text)
+          .replace(/^(?:\.\/)+/u, "")
+          .replace(/\/+$/u, "");
+        if (path === "" || path === ".." || path.startsWith("../") || path.startsWith("/")) {
+          return [];
+        }
+        if (!directory) {
+          return [path, `${path}.${ENTRY_EXTENSIONS}`];
+        }
+        return PATTERN.test(path) ? [] : [`${path}/**/*.${ENTRY_EXTENSIONS}`];
+      }),
+    ),
+  );
+}
+
 /** What one configuration file states about one property. */
 interface PropertyReading {
   /** The literal values the file sets the property to. */
@@ -892,6 +935,66 @@ function shortNameUses(
   return [...used].filter((name) => declared.has(name)).sort(compare);
 }
 
+/**
+ * The package one value of a prefixed-name reading names, or none: ESLint's own naming,
+ * https://github.com/eslint/eslintrc/blob/main/lib/shared/naming.js
+ */
+function prefixedPackage(value: string, reading: PrefixedNameReading): string | undefined {
+  const { prefix, marker } = reading;
+  let name: string;
+  if (marker === undefined) {
+    if (value.includes(":") || value.startsWith(".") || value.startsWith("/")) {
+      return undefined;
+    }
+    const parts = value.split("/");
+    name = (value.startsWith("@") ? parts.slice(0, 2) : parts.slice(0, 1)).join("/");
+  } else {
+    if (!value.startsWith(marker) || !value.includes("/", marker.length)) {
+      return undefined;
+    }
+    name = value.slice(marker.length, value.lastIndexOf("/"));
+  }
+  if (name === "") {
+    return undefined;
+  }
+  if (!name.startsWith("@")) {
+    return name.startsWith(`${prefix}-`) ? name : `${prefix}-${name}`;
+  }
+  const [scope, rest] = name.split("/");
+  if (rest === undefined || rest === "" || rest === prefix) {
+    return `${scope ?? name}/${prefix}`;
+  }
+  return rest.startsWith(`${prefix}-`) ? name : `${scope ?? name}/${prefix}-${rest}`;
+}
+
+/** The declared dependencies an applied row's prefixed names use. */
+function prefixedNameUses(
+  host: Host,
+  parse: ParseSource,
+  dir: string,
+  manifest: unknown,
+  readings: readonly PrefixedNameReading[],
+): 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) {
+    for (const { file } of readingFiles(host, parse, dir, reading.files)) {
+      for (const value of readProperty(file, reading.property, reading.call, true).values) {
+        const named = prefixedPackage(value, reading);
+        if (named !== undefined && declared.has(named)) {
+          used.add(named);
+        }
+      }
+    }
+  }
+  return [...used].sort(compare);
+}
+
 /** The declared dependencies an applied row's helper settings use. */
 function helperUses(
   host: Host,
@@ -1064,6 +1167,10 @@ export function readConventions(
       for (const name of shortNameUses(host, parse, manifest.dir, declared, row.shortNames ?? [])) {
         uses.add(name);
       }
+      const prefixed = row.prefixedNames ?? [];
+      for (const name of prefixedNameUses(host, parse, manifest.dir, declared, prefixed)) {
+        uses.add(name);
+      }
       const keys = row.packageKeys ?? [];
       for (const name of packageKeyUses(host, parse, manifest.dir, declared, keys)) {
         uses.add(name);
@@ -1082,7 +1189,11 @@ export function readConventions(
       for (const below of new Set((row.generated ?? []).flatMap((one) => expand(one, resolved)))) {
         generated.push({ dir: manifest.dir, row: row.name, below });
       }
-      for (const glob of new Set(row.entries.flatMap((entry) => expand(entry, resolved)))) {
+      const written = [
+        ...row.entries.flatMap((entry) => expand(entry, resolved)),
+        ...manifestEntryGlobs(declared, row.manifestEntries ?? []),
+      ];
+      for (const glob of new Set(written)) {
         globs.push({
           dir: manifest.dir,
           row: row.name,
@@ -1138,12 +1249,15 @@ export function conventionEntries(
   const found = new Map<string, ConventionEntry>();
   for (const glob of conventions.globs) {
     for (const file of files.byName.values()) {
-      const path = relativePath(glob.dir, file.fileName);
-      if (
-        path !== undefined &&
-        glob.expression.test(path) &&
-        !glob.excludes.some((one) => one.test(path))
-      ) {
+      const matched = [file.fileName, ...files.writtenAs(file)].some((name) => {
+        const path = relativePath(glob.dir, name);
+        return (
+          path !== undefined &&
+          glob.expression.test(path) &&
+          !glob.excludes.some((one) => one.test(path))
+        );
+      });
+      if (matched) {
         found.set(`${file.fileName}\u0000${glob.row}`, { file, row: glob.row });
       }
     }

package/src/decorator.ts

@@ -1,14 +1,10 @@
 /**
- * The decorator class: a member a decorator expression is attached to, and every
- * member of a class a decorator expression is attached to, is held back, because the
- * decorator receives the member or the class when the class is defined and may reach
- * the member by its name.
- *
- * The rule is read from the tree alone: a decorator is attached where it is written.
- * The use the decorator itself makes of what it decorates is the reference pass's,
- * which records it as a `decorator` reference; this class records only that the
- * declaration is held back, and the member set of a decorated class is every member
- * the inventory holds for the class, static members included.
+ * The decorator class: a member a decorator expression is attached to, and every member
+ * of a class one is attached to but the member a parameter property declares, is held
+ * back, because the decorator may reach the member by its name. The rule is read from
+ * the tree alone. The decorator's own use of what it decorates is the reference pass's
+ * `decorator` reference; this class records only that the declaration is held back,
+ * static members of a decorated class included.
  */
 
 import type { Node } from "@typescript/native/ast";
@@ -44,25 +40,39 @@ export function decorator<Brand>(input: DetectorInput<Brand>): readonly Evidence
     }
   }
 
-  const found: Evidence[] = [];
+  const decorated: {
+    readonly symbol: InventorySymbol;
+    readonly detail: string;
+    readonly site: Evidence["site"];
+  }[] = [];
+  // A decorated class's container passes each constructor argument, which keeps the
+  // parameter, not the member a parameter property stores it in.
+  const parameterMembers = new Set<string>();
   for (const file of project.ownSourceFiles()) {
     const visit = (node: Node): void => {
       const id = held.declarations.get(nodeKey(file, node));
       const symbol = id === undefined ? undefined : byId.get(id);
+      if (id !== undefined && isParameterProperty(node)) {
+        parameterMembers.add(id);
+      }
       // A parameter property's decorator is attached to its parameter, and to no member.
       if (symbol !== undefined && DECORATED.has(symbol.kind) && !isParameterProperty(node)) {
         for (const attached of decoratorsOf(node)) {
-          const detail = `decorated by ${spelledDecorator(attached)}`;
-          const site = renderPosition(file, targetRoot, attached.getStart());
-          const reached = symbol.kind === "class" ? (membersOf.get(symbol.id) ?? []) : [symbol];
-          for (const member of reached) {
-            found.push({ id: member.id, detail, site });
-          }
+          decorated.push({
+            symbol,
+            detail: `decorated by ${spelledDecorator(attached)}`,
+            site: renderPosition(file, targetRoot, attached.getStart()),
+          });
         }
       }
       node.forEachChild(visit);
     };
     file.forEachChild(visit);
   }
-  return found;
+  return decorated.flatMap(({ symbol, detail, site }) =>
+    (symbol.kind === "class"
+      ? (membersOf.get(symbol.id) ?? []).filter((member) => !parameterMembers.has(member.id))
+      : [symbol]
+    ).map((member) => ({ id: member.id, detail, site })),
+  );
 }