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

package/src/augmentations.ts

@@ -8,6 +8,7 @@
  */
 
 import type { Inventory, InventorySymbol } from "./inventory.ts";
+import { referenceKey } from "./matrix.ts";
 import type { Reference } from "./references.ts";
 
 /** Whether one declaration is a `declare global` block: a module-level namespace named `global`. */
@@ -62,14 +63,24 @@ export function augmentationReferences(
     }
     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,
-    })),
-  );
+  // Two uses at one place of declarations one block holds read the block once there.
+  const made = new Set(found.map(referenceKey));
+  const reads = new Map<string, Reference>();
+  for (const reference of found) {
+    for (const to of holders(reference.to)) {
+      const read: Reference = {
+        from: reference.from,
+        to,
+        position: reference.position,
+        use: "read",
+        resolution: reference.resolution,
+        test: reference.test,
+      };
+      const key = referenceKey(read);
+      if (!made.has(key) && !reads.has(key)) {
+        reads.set(key, read);
+      }
+    }
+  }
+  return [...reads.values()];
 }

package/src/automatic-types.ts

@@ -0,0 +1,246 @@
+/**
+ * The global names and ambient modules of the `@types` packages a compiler before version 6
+ * includes automatically: every package of each type root when the configuration lists no
+ * `types`. Version 6 and later include none, so the analysis program holds none of their
+ * declarations, and a use of one resolves to nothing; each such use is a use of the package.
+ */
+
+import {
+  isClassDeclaration,
+  isEnumDeclaration,
+  isExportAssignment,
+  isExportDeclaration,
+  isFunctionDeclaration,
+  isIdentifier,
+  isImportDeclaration,
+  isImportEqualsDeclaration,
+  isInterfaceDeclaration,
+  isModuleBlock,
+  isModuleDeclaration,
+  isStringLiteral,
+  isTypeAliasDeclaration,
+  isVariableStatement,
+  SyntaxKind,
+  type Node,
+  type SourceFile,
+  type Statement,
+} from "@typescript/native/ast";
+import type { ParseFile } from "./configuration-files.ts";
+import type { DirectoryEntry, Host } from "./host.ts";
+import { dirnamePath, joinPath, resolvePath } from "./paths.ts";
+
+const TYPE_ROOT = "node_modules/@types";
+
+/** What the automatically included `@types` packages of one configuration declare. */
+export interface AutomaticTypes {
+  /** Per global name, the packages that declare it. */
+  readonly globals: ReadonlyMap<string, readonly string[]>;
+  /** Per ambient module name, the packages that declare it. */
+  readonly modules: ReadonlyMap<string, readonly string[]>;
+}
+
+const NONE: AutomaticTypes = { globals: new Map(), modules: new Map() };
+
+/** What one installed type package declares, by its directory. */
+interface PackageDeclarations {
+  readonly globals: readonly string[];
+  readonly modules: readonly string[];
+}
+
+/**
+ * The packages each host has read, so a run's configurations share one reading of a type
+ * root; a host reads one unchanging tree for its whole life.
+ */
+const READ = new WeakMap<Host, Map<string, PackageDeclarations>>();
+
+/** Whether one file is a module: it imports, exports or assigns an export at its top level. */
+function isModuleFile(file: SourceFile): boolean {
+  return file.statements.some(
+    (statement) =>
+      isImportDeclaration(statement) ||
+      isImportEqualsDeclaration(statement) ||
+      isExportDeclaration(statement) ||
+      isExportAssignment(statement) ||
+      ((statement as { readonly modifiers?: readonly Node[] }).modifiers ?? []).some(
+        (modifier) => modifier.kind === SyntaxKind.ExportKeyword,
+      ),
+  );
+}
+
+/** The names one statement of a global scope declares, and the ambient modules it declares. */
+function declared(statement: Statement, globals: string[], modules: string[]): void {
+  if (isVariableStatement(statement)) {
+    for (const declaration of statement.declarationList.declarations) {
+      if (isIdentifier(declaration.name)) {
+        globals.push(declaration.name.text);
+      }
+    }
+  } else if (
+    isFunctionDeclaration(statement) ||
+    isClassDeclaration(statement) ||
+    isInterfaceDeclaration(statement) ||
+    isTypeAliasDeclaration(statement) ||
+    isEnumDeclaration(statement)
+  ) {
+    if (statement.name !== undefined) {
+      globals.push(statement.name.text);
+    }
+  } else if (isModuleDeclaration(statement)) {
+    if (isStringLiteral(statement.name)) {
+      modules.push(statement.name.text);
+    } else {
+      globals.push(statement.name.text);
+    }
+  }
+}
+
+/**
+ * What one declaration file declares in the global scope: its top level where it is no
+ * module, and the body of each `declare global` block where it is one.
+ */
+function fileDeclarations(file: SourceFile, globals: string[], modules: string[]): void {
+  if (!isModuleFile(file)) {
+    file.statements.forEach((statement) => {
+      declared(statement, globals, modules);
+    });
+    return;
+  }
+  for (const statement of file.statements) {
+    if (
+      isModuleDeclaration(statement) &&
+      isIdentifier(statement.name) &&
+      statement.name.text === "global" &&
+      statement.body !== undefined &&
+      isModuleBlock(statement.body)
+    ) {
+      statement.body.statements.forEach((inner) => {
+        declared(inner, globals, modules);
+      });
+    }
+  }
+}
+
+/** The entry declaration file of one installed type package's directory. */
+function entryOf(host: Host, dir: string): string {
+  try {
+    const manifest: unknown = JSON.parse(host.readFile(joinPath(dir, "package.json")));
+    const named =
+      typeof manifest === "object" && manifest !== null
+        ? ((manifest as Record<string, unknown>)["types"] ??
+          (manifest as Record<string, unknown>)["typings"])
+        : undefined;
+    if (typeof named === "string" && named !== "") {
+      const path = resolvePath(dir, named);
+      return path.endsWith(".ts") ? path : `${path}.d.ts`;
+    }
+  } catch {
+    // A package with no readable manifest is read from its index, as the compiler reads it.
+  }
+  return joinPath(dir, "index.d.ts");
+}
+
+/**
+ * Every global name and ambient module one installed type package declares: in its entry
+ * file and each file a `/// <reference path>` of a file read reaches, inside the package.
+ */
+function packageDeclarations(host: Host, dir: string, parse: ParseFile): PackageDeclarations {
+  const known = READ.get(host) ?? new Map<string, PackageDeclarations>();
+  READ.set(host, known);
+  const held = known.get(dir);
+  if (held !== undefined) {
+    return held;
+  }
+  const globals: string[] = [];
+  const modules: string[] = [];
+  const seen = new Set<string>();
+  const pending = [entryOf(host, dir)];
+  for (let path = pending.pop(); path !== undefined; path = pending.pop()) {
+    if (seen.has(path) || !path.startsWith(`${dir}/`)) {
+      continue;
+    }
+    seen.add(path);
+    let text: string;
+    try {
+      text = host.readFile(path);
+    } catch {
+      continue;
+    }
+    const file = parse(path, text);
+    fileDeclarations(file, globals, modules);
+    for (const reference of file.referencedFiles) {
+      pending.push(resolvePath(dirnamePath(path), reference.fileName));
+    }
+  }
+  const found = { globals, modules };
+  known.set(dir, found);
+  return found;
+}
+
+/**
+ * What the `@types` packages a compiler before version 6 would include for one
+ * configuration declare: none where its options list `types`, else every package of each
+ * `node_modules/@types` directory at or above the configuration's directory, the nearest
+ * holding a name winning.
+ */
+export function automaticTypes(
+  host: Host,
+  configFile: string,
+  options: Readonly<Record<string, unknown>>,
+  parse: ParseFile,
+): AutomaticTypes {
+  if (options["types"] !== undefined) {
+    return NONE;
+  }
+  const globals = new Map<string, string[]>();
+  const modules = new Map<string, string[]>();
+  const add = (into: Map<string, string[]>, name: string, named: string): void => {
+    const held = into.get(name) ?? [];
+    if (!held.includes(named)) {
+      into.set(name, [...held, named]);
+    }
+  };
+  const read = new Set<string>();
+  for (const root of typeRoots(configFile, options)) {
+    let entries: readonly DirectoryEntry[];
+    try {
+      entries = host.readDirectory(root);
+    } catch {
+      entries = [];
+    }
+    for (const entry of entries) {
+      if (read.has(entry.name) || host.kindOf(joinPath(root, entry.name)) !== "directory") {
+        continue;
+      }
+      read.add(entry.name);
+      const named = `@types/${entry.name}`;
+      const found = packageDeclarations(host, joinPath(root, entry.name), parse);
+      found.globals.forEach((name) => {
+        add(globals, name, named);
+      });
+      found.modules.forEach((name) => {
+        add(modules, name, named);
+      });
+    }
+  }
+  return { globals, modules };
+}
+
+/**
+ * The type roots of one configuration that a package manager installs into: those its
+ * `typeRoots` lists, else each `node_modules/@types` directory at or above its directory.
+ */
+function typeRoots(configFile: string, options: Readonly<Record<string, unknown>>): string[] {
+  const listed = options["typeRoots"];
+  if (Array.isArray(listed)) {
+    return listed.filter(
+      (root): root is string => typeof root === "string" && root.endsWith(`/${TYPE_ROOT}`),
+    );
+  }
+  const roots: string[] = [];
+  for (let dir = dirnamePath(configFile); ; dir = dirnamePath(dir)) {
+    roots.push(joinPath(dir, TYPE_ROOT));
+    if (dirnamePath(dir) === dir) {
+      return roots;
+    }
+  }
+}

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:76c07ac14bda6e302444918d832b01844bac6f29b6f22a742d538804480c0769",
   },
   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}";
 
@@ -231,6 +261,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 +287,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 +378,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 +691,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",