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

package/src/analysis.ts

@@ -6,6 +6,7 @@
  * another project's checker, which holds only for views the session hands out.
  */
 
+import { isStringLiteralLikeNode } from "@typescript/native/ast";
 import { lineOf, readComponent } from "./component-files.ts";
 import { kindOf, type Config, type Provenance } from "./config.ts";
 import {
@@ -26,9 +27,11 @@ import {
   discoverProjects,
   DiscoveryError,
   isGuess,
+  MISSING_GLOBAL_TYPE,
   projectErrors,
   renderDiagnostic,
   targetRelative,
+  withBaseUrlPaths,
   type LocatedDiagnostic,
   type NotBuilt,
 } from "./discover.ts";
@@ -70,7 +73,7 @@ import { injectionContainer } from "./injection-container.ts";
 import { interfaceSatisfaction, settledSatisfaction } from "./interface-satisfaction.ts";
 import { intraFunctionFacts, projectParts, type ProjectParts } from "./intra-function-parts.ts";
 import { inventory, type Inventory, type InventorySymbol } from "./inventory.ts";
-import { packageEntries, readManifest } from "./manifest.ts";
+import { packageEntries, readManifest, type ManifestEntry } from "./manifest.ts";
 import {
   liveFilesAt,
   matrixOf,
@@ -112,7 +115,7 @@ import type { Scope } from "./scope.ts";
 import { serializationContract } from "./serialization-contract.ts";
 import { outsideTestReferences, testFilesAt, type OutsideTest } from "./outside-tests.ts";
 import { joinedTestFiles, withJoinedTests } from "./test-joins.ts";
-import { supportReferences, testSupportFiles } from "./test-support.ts";
+import { supportReferences, testSupportFiles, type TestEvidence } from "./test-support.ts";
 import {
   diagnosticsOf,
   ownedAs,
@@ -390,6 +393,11 @@ function readProjects<Answer>(
       publishedMembers: new Set(
         (workspace?.entries ?? []).filter((entry) => entry.published).map((entry) => entry.dir),
       ),
+      runFiles: new Set(
+        opened.flatMap((one) =>
+          one.fileNames().map((name) => resolvePath(host.workingDirectory(), name)),
+        ),
+      ),
     };
   };
   const notBuilt: NotBuilt[] = [...discovered.notBuilt];
@@ -420,6 +428,12 @@ function readProjects<Answer>(
   const joins = discovered.derived
     ? joinedTestFiles(engine, host, absoluteRoot, discovered.configFiles, testPatterns)
     : new Map<string, readonly string[]>();
+  const programs = withBaseUrlPaths(
+    engine,
+    host,
+    [...discovered.configFiles, ...consumerOf.keys()],
+    workspace?.programs ?? new Map(),
+  );
   const session = runSession(
     engine,
     [...discovered.configFiles, ...consumerOf.keys()],
@@ -514,11 +528,29 @@ function readProjects<Answer>(
           error: renderDiagnostic(one, (path) => relativePath(absoluteRoot, path) ?? path),
         })),
       );
+      const missingGlobal = raw.unfound.find(
+        ({ diagnostic }) => diagnostic.code === MISSING_GLOBAL_TYPE,
+      );
+      const skips =
+        missingGlobal === undefined
+          ? reading.skips
+          : [
+              ...reading.skips,
+              ...project.ownSourceFiles().map((file) => ({
+                record: {
+                  path: relativePath(absoluteRoot, file.fileName) ?? file.fileName,
+                  line: 1,
+                  message: missingGlobal.diagnostic.text,
+                },
+                file,
+                unit: file,
+              })),
+            ];
       const configuration = ids.get(project.configFile) ?? project.configFile;
       const read = (): ProjectRead => {
         const held = inventory(project, host, targetRoot);
         const found = roots(project, held, targetRoot, options);
-        const kept = skippedRoots(project, held, reading.skips);
+        const kept = skippedRoots(project, held, skips);
         const rooted =
           kept.length === 0
             ? found
@@ -535,8 +567,8 @@ function readProjects<Answer>(
           configFile: project.configFile,
           held,
           rooted,
-          typeErrorSkips: reading.skips.map((one) => one.record),
-          skipped: skippedUnits(reading.skips, absoluteRoot),
+          typeErrorSkips: skips.map((one) => one.record),
+          skipped: skippedUnits(skips, absoluteRoot),
           referenceOnly: project
             .ownSourceFiles()
             .filter((file) => referenceOnly(file.fileName))
@@ -551,9 +583,7 @@ function readProjects<Answer>(
       return stage(project, { configuration, read });
     },
     discovered.derived ? "record" : "refuse",
-    joins.size === 0
-      ? workspace?.programs
-      : withJoinedTests(engine, host, workspace?.programs ?? new Map(), joins),
+    joins.size === 0 ? programs : withJoinedTests(engine, host, programs, joins),
     () => {
       outsideTests = testFilesAt(
         host,
@@ -759,6 +789,8 @@ interface SweptProject<Extra> {
   /** The component files the project holds of its own, by path below the target root. */
   readonly componentFiles: readonly string[];
   readonly componentWarnings: readonly ComponentWarning[];
+  /** The manifest entries the project reads back to no file of its own. */
+  readonly unmappedEntries: readonly ManifestEntry[];
   readonly extra: Extra;
 }
 
@@ -770,6 +802,8 @@ interface ReadProject<Extra> {
   readonly evidence: readonly Exemption[];
   readonly componentFiles: readonly string[];
   readonly componentWarnings: readonly ComponentWarning[];
+  /** Per own file below the target root, the module specifiers its imports write. */
+  readonly imports: ReadonlyMap<string, readonly string[]>;
   readonly extra: Extra;
 }
 
@@ -800,6 +834,64 @@ interface ReadRun<Extra> {
   readonly nestedDirs: readonly string[];
 }
 
+/** The manifest section of a package test evidence counts, and the sections that keep one out of it. */
+const DEV_SECTION = "devDependencies";
+const OTHER_SECTIONS = ["dependencies", "peerDependencies", "optionalDependencies"] as const;
+
+/**
+ * The imports of a run's own files and the manifests below the target root that test
+ * evidence reads: a package is a devDependency of a file where the nearest manifest at or
+ * above it that declares the package declares it under `devDependencies` alone.
+ */
+function testEvidence(
+  host: Host,
+  targetRoot: string,
+  projects: readonly { readonly imports: ReadonlyMap<string, readonly string[]> }[],
+): TestEvidence {
+  const imports = new Map<string, readonly string[]>();
+  for (const one of projects) {
+    for (const [path, specifiers] of one.imports) {
+      imports.set(path, specifiers);
+    }
+  }
+  const manifests = new Map<string, Readonly<Record<string, unknown>> | undefined>();
+  const manifestAt = (dir: string): Readonly<Record<string, unknown>> | undefined => {
+    if (!manifests.has(dir)) {
+      let value: unknown;
+      try {
+        value = JSON.parse(host.readFile(joinPath(dir, "package.json")));
+      } catch {
+        value = undefined;
+      }
+      manifests.set(
+        dir,
+        typeof value === "object" && value !== null && !Array.isArray(value)
+          ? (value as Record<string, unknown>)
+          : undefined,
+      );
+    }
+    return manifests.get(dir);
+  };
+  const declares = (section: unknown, name: string): boolean =>
+    typeof section === "object" && section !== null && Object.hasOwn(section, name);
+  const root = resolvePath(host.workingDirectory(), targetRoot);
+  return {
+    imports,
+    devDependency: (path, name) => {
+      for (let dir = dirnamePath(joinPath(root, path)); ; dir = dirnamePath(dir)) {
+        const manifest = manifestAt(dir);
+        const other = OTHER_SECTIONS.some((one) => declares(manifest?.[one], name));
+        if (declares(manifest?.[DEV_SECTION], name) || other) {
+          return !other;
+        }
+        if (normalizePath(dir) === normalizePath(root) || dirnamePath(dir) === dir) {
+          return false;
+        }
+      }
+    },
+  };
+}
+
 /**
  * Reads every project of the run, its references and exemptions, and `extra`'s answer,
  * while the project's view is open, and merges the projects into one matrix in the run's
@@ -856,6 +948,14 @@ function readRun<Extra>(
       testFiles: resolved.testFilePaths,
       evidence,
       componentFiles: components.map(pathOf),
+      imports: new Map(
+        project.ownSourceFiles().flatMap((file) => {
+          const path = relativePath(targetRoot, file.fileName);
+          return path === undefined
+            ? []
+            : [[path, file.imports.filter(isStringLiteralLikeNode).map((one) => one.text)]];
+        }),
+      ),
       componentWarnings: components.flatMap((file) =>
         readComponent(file.originalText, extensionOf(file.fileName)).warnings.map((warning) => ({
           path: pathOf(file),
@@ -877,11 +977,12 @@ function readRun<Extra>(
   }));
   // Test-support code is code only test code imports in any configuration of the run: a
   // configuration that holds no test file says nothing about what the tests import.
-  const support = testSupportFiles(
+  const { support, testUsed } = testSupportFiles(
     withOutside.flatMap((one) => one.projectRead.held.symbols),
     withOutside.flatMap((one) => one.references),
     withOutside.flatMap((one) => one.projectRead.rooted.liveUnderReachability),
     withOutside.flatMap((one) => one.testFiles),
+    testEvidence(host, targetRoot, withOutside),
   );
   const settled = settledSatisfaction(
     withOutside.map((one) => ({ evidence: one.evidence, held: one.projectRead.held })),
@@ -898,13 +999,16 @@ function readRun<Extra>(
     const made = supportReferences([...one.references, ...(satisfied?.references ?? [])], support);
     const held = new Set(projectRead.held.symbols.map((symbol) => symbol.position.path));
     const supportFiles = [...support].filter((path) => held.has(path)).sort();
+    const testUsedFiles = [...testUsed].filter((path) => held.has(path)).sort();
     const configured: Configured = {
       configuration: projectRead.configuration,
       symbols: projectRead.held.symbols,
       references: [...made, ...evidenceReferences(projectRead.held.symbols, detected.inTestFiles)],
       roots: projectRead.rooted.liveUnderReachability,
-      testFiles: one.testFiles,
+      testFiles: [...one.testFiles, ...supportFiles],
       ...(supportFiles.length === 0 ? {} : { supportFiles }),
+      ...(testUsedFiles.length === 0 ? {} : { testUsedFiles }),
+      ...(projectRead.held.ambient.size === 0 ? {} : { ambient: projectRead.held.ambient }),
       ...(projectRead.referenceOnly.length === 0
         ? {}
         : { referenceOnly: projectRead.referenceOnly }),
@@ -925,6 +1029,7 @@ function readRun<Extra>(
         ...exempt.filter(isUnansweredRecord).map((record) => record.id),
       ],
       typeErrorSkips: projectRead.typeErrorSkips,
+      unmappedEntries: projectRead.rooted.unmappedEntries,
       skipped: projectRead.skipped,
       componentFiles: one.componentFiles,
       componentWarnings: one.componentWarnings,
@@ -1190,7 +1295,8 @@ export function readEmitterRun(
  * The workspace members whose dependencies the run judges: `read` holds those a built
  * project holds a file below, `unbuilt` the others whose own directory, the nearest
  * manifest's above the configuration, holds a configuration the run could not build. A
- * member no configuration holds a file of is in neither.
+ * member no configuration holds a file of is in neither. A nested package no built project
+ * holds a file below joins `unbuilt` the same way.
  */
 function judgedMembers(
   host: Host,
@@ -1214,6 +1320,16 @@ function judgedMembers(
       judged.unbuilt.push(dir);
     }
   }
+  for (const dir of read.nestedDirs) {
+    const below = relativePath(root, dir);
+    if (
+      below !== undefined &&
+      owners.has(dir) &&
+      ![...held].some((path) => path.startsWith(`${below}/`))
+    ) {
+      judged.unbuilt.push(dir);
+    }
+  }
   return judged;
 }
 
@@ -1359,6 +1475,7 @@ function readAnalysis(
       componentsUnread: read.componentsUnread,
       librariesUnfound: read.librariesUnfound,
       conventionsApplied: read.conventionsApplied,
+      unmappedEntries: unmappedEverywhere(read.projects),
     },
     configured: read.projects.map((one) => one.configured),
     symbols,
@@ -1410,6 +1527,22 @@ function inputsOver(
   };
 }
 
+/** The manifest entries every project of the run reads back to no file, in the first project's order. */
+function unmappedEverywhere(
+  projects: readonly { readonly unmappedEntries: readonly ManifestEntry[] }[],
+): readonly ManifestEntry[] {
+  const key = (entry: ManifestEntry): string => `${entry.dir}\u0000${entry.member}`;
+  const [first, ...rest] = projects;
+  const others = rest.map((one) => new Set(one.unmappedEntries.map(key)));
+  const found = new Map<string, ManifestEntry>();
+  for (const entry of first?.unmappedEntries ?? []) {
+    if (others.every((one) => one.has(key(entry)))) {
+      found.set(key(entry), entry);
+    }
+  }
+  return [...found.values()];
+}
+
 /** One project of a run: the name the run gives it and the file it was opened from. */
 export interface RunProject {
   readonly id: string;
@@ -1439,6 +1572,8 @@ interface RunFacts {
   readonly librariesUnfound: readonly LibraryUnfound[];
   /** The convention rows the run applied. */
   readonly conventionsApplied: readonly AppliedConvention[];
+  /** The manifest entries no project of the run reads back to a file, each once. */
+  readonly unmappedEntries: readonly ManifestEntry[];
 }
 
 /** One configuration whose component files a run cannot read. */

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`. */
@@ -25,25 +26,24 @@ function isGlobalBlock(
 }
 
 /**
- * For each reference to a declaration an augmentation block, or the global scope of a
- * file in `scripts`, holds, a read at the same place of every interface and namespace
- * between it and the block or the file, and of the block itself. `scripts` holds the
- * files that are no module, by identifier.
+ * Per declaration, the interfaces and namespaces between it and the augmentation block or
+ * the file in `scripts` that holds it, with the block itself, or none where no such block
+ * or file holds it; and whether that holder is the global scope rather than a module
+ * declaration. `scripts` holds the files that are no module, by identifier.
  */
-export function augmentationReferences(
+function holdersOf(
   held: Inventory,
-  found: readonly Reference[],
-  scripts: ReadonlySet<string> = new Set(),
-): readonly Reference[] {
+  scripts: ReadonlySet<string>,
+): ((id: string) => { readonly ids: readonly string[]; readonly global: boolean }) | undefined {
   const files = new Set(held.symbols.filter((one) => one.kind === "file").map((one) => one.id));
   const globals = new Set(
     held.symbols.filter((one) => isGlobalBlock(one, held, files)).map((one) => one.id),
   );
   if (globals.size === 0 && held.modules.size === 0 && scripts.size === 0) {
-    return [];
+    return undefined;
   }
   const byId = new Map(held.symbols.map((one) => [one.id, one]));
-  const holders = (id: string): string[] => {
+  return (id) => {
     const ids: string[] = [];
     for (
       let at = byId.get(byId.get(id)?.parent ?? "");
@@ -51,25 +51,79 @@ export function augmentationReferences(
       at = byId.get(at.parent)
     ) {
       if (globals.has(at.id) || held.modules.has(at.id)) {
-        return [...ids, at.id];
+        return { ids: [...ids, at.id], global: globals.has(at.id) };
       }
       if (scripts.has(at.id)) {
-        return ids;
+        return { ids, global: true };
       }
       if (at.kind === "interface" || at.kind === "namespace") {
         ids.push(at.id);
       }
     }
-    return [];
+    return { ids: [], global: false };
   };
-  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,
-    })),
+}
+
+/**
+ * The ambient interfaces of the global scope among `interfaces`: each one a declaration
+ * file or a `declare` holds that a `declare global` block, or the top level of a file in
+ * `scripts`, declares, directly or inside a namespace there.
+ */
+export function ambientGlobalInterfaces(
+  held: Inventory,
+  interfaces: readonly string[],
+  scripts: ReadonlySet<string>,
+): readonly string[] {
+  const holders = holdersOf(held, scripts);
+  return holders === undefined
+    ? []
+    : interfaces.filter((id) => held.ambient.has(id) && holders(id).global);
+}
+
+/**
+ * For each reference to a declaration an augmentation block, or the global scope of a
+ * file in `scripts` (the files that are no module), holds, a read at the same place of
+ * every interface and namespace between it and the block or the file, and of the block
+ * itself. A read through an interface of `merged`, an ambient global interface merging
+ * into a language or library one, is a production read whoever writes it: it types a
+ * value the runtime provides, so a test reading a member needs it as code does.
+ */
+export function augmentationReferences(
+  held: Inventory,
+  found: readonly Reference[],
+  scripts: ReadonlySet<string> = new Set(),
+  merged: ReadonlySet<string> = new Set(),
+): readonly Reference[] {
+  const holders = holdersOf(held, scripts);
+  if (holders === undefined) {
+    return [];
+  }
+  const fileOf = new Map(
+    held.symbols.filter((one) => one.kind === "file").map((one) => [one.position.path, one.id]),
   );
+  // 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) {
+    const { ids } = holders(reference.to);
+    // A test's read through such an interface is held by the test file, which the test
+    // runner loads whichever of its declarations runs.
+    const typed = reference.test && ids.some((id) => merged.has(id));
+    const from = typed ? (fileOf.get(reference.position.path) ?? reference.from) : reference.from;
+    for (const to of ids) {
+      const read: Reference = {
+        from,
+        to,
+        position: reference.position,
+        use: "read",
+        resolution: reference.resolution,
+        test: reference.test && !typed,
+      };
+      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;
+    }
+  }
+}