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

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,
@@ -80,7 +83,14 @@ import {
   type Matrix,
   type SweepResult,
 } from "./matrix.ts";
-import { dirnamePath, joinPath, normalizePath, relativePath, resolvePath } from "./paths.ts";
+import {
+  dirnamePath,
+  extensionOf,
+  joinPath,
+  normalizePath,
+  relativePath,
+  resolvePath,
+} from "./paths.ts";
 import type { UnansweredQuestion } from "./query.ts";
 import { byPosition, isComponentFile, type Position } from "./position.ts";
 import { LANGUAGE, type TypeErrorSkip, type UnansweredCount } from "./report.ts";
@@ -105,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,
@@ -232,6 +242,8 @@ interface ReadProjects<Answer> {
   readonly unanswered: readonly UnansweredQuestion[];
   /** Per configuration whose component files the run cannot read, the reason. */
   readonly componentsUnread: readonly ComponentsUnread[];
+  /** Per analyzed configuration, each library it names that the compiler cannot find. */
+  readonly librariesUnfound: readonly LibraryUnfound[];
   /** The convention rows the run applied. */
   readonly conventionsApplied: readonly AppliedConvention[];
   /** The dependencies the applied rows' short names use. */
@@ -381,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];
@@ -394,6 +411,7 @@ function readProjects<Answer>(
   const failures: LocatedDiagnostic[] = [];
   const unbuildable: SetupFailure[] = [];
   const setupDropped: SetupFailure[] = [];
+  const librariesUnfound: LibraryUnfound[] = [];
   const consumed = new Map<string, Reference>();
   const heldFiles = new Set<string>();
   let outsideTests: readonly OutsideTest[] = [];
@@ -410,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()],
@@ -458,10 +482,6 @@ function readProjects<Answer>(
             : resolvePath(host.workingDirectory(), consumer.path),
         paths: pathsOf(engine, project.configFile),
       });
-      if (reading.failing.length > 0) {
-        failures.push(...reading.failing);
-        return undefined;
-      }
       if (consumer !== undefined && reading.missing.length > 0) {
         unbuildable.push(
           ...reading.missing.map((one) => ({
@@ -502,11 +522,35 @@ function readProjects<Answer>(
         }
         return undefined;
       }
+      librariesUnfound.push(
+        ...raw.unfound.map((one) => ({
+          configFile: project.configFile,
+          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
@@ -523,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))
@@ -539,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,
@@ -589,6 +631,7 @@ function readProjects<Answer>(
     notBuilt,
     unanswered: session.unanswered,
     componentsUnread: workspace?.componentsUnread ?? [],
+    librariesUnfound,
     conventionsApplied: conventions.applied,
     conventionUses: conventions.uses,
     memberDirs,
@@ -746,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;
 }
 
@@ -757,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;
 }
 
@@ -775,6 +822,8 @@ interface ReadRun<Extra> {
   readonly unanswered: readonly UnansweredQuestion[];
   /** Per configuration whose component files the run cannot read, the reason. */
   readonly componentsUnread: readonly ComponentsUnread[];
+  /** Per analyzed configuration, each library it names that the compiler cannot find. */
+  readonly librariesUnfound: readonly LibraryUnfound[];
   /** The convention rows the run applied. */
   readonly conventionsApplied: readonly AppliedConvention[];
   /** The dependencies the applied rows' short names use. */
@@ -785,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
@@ -841,8 +948,16 @@ 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).warnings.map((warning) => ({
+        readComponent(file.originalText, extensionOf(file.fileName)).warnings.map((warning) => ({
           path: pathOf(file),
           line: lineOf(file.originalText, warning.offset),
           reason: warning.reason,
@@ -867,6 +982,7 @@ function readRun<Extra>(
     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 })),
@@ -888,8 +1004,9 @@ function readRun<Extra>(
       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 }),
+      ...(projectRead.held.ambient.size === 0 ? {} : { ambient: projectRead.held.ambient }),
       ...(projectRead.referenceOnly.length === 0
         ? {}
         : { referenceOnly: projectRead.referenceOnly }),
@@ -910,6 +1027,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,
@@ -942,6 +1060,7 @@ function readRun<Extra>(
     notBuilt: read.notBuilt,
     unanswered: read.unanswered,
     componentsUnread: read.componentsUnread,
+    librariesUnfound: read.librariesUnfound,
     conventionsApplied: read.conventionsApplied,
     conventionUses: read.conventionUses,
     memberDirs: read.memberDirs,
@@ -1174,7 +1293,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,
@@ -1198,6 +1318,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;
 }
 
@@ -1341,7 +1471,9 @@ function readAnalysis(
       notBuilt: read.notBuilt,
       unanswered: read.unanswered,
       componentsUnread: read.componentsUnread,
+      librariesUnfound: read.librariesUnfound,
       conventionsApplied: read.conventionsApplied,
+      unmappedEntries: unmappedEverywhere(read.projects),
     },
     configured: read.projects.map((one) => one.configured),
     symbols,
@@ -1393,6 +1525,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;
@@ -1418,8 +1566,12 @@ interface RunFacts {
   readonly componentWarnings: readonly ComponentWarning[];
   /** Per configuration whose component files the run cannot read, the reason. */
   readonly componentsUnread: readonly ComponentsUnread[];
+  /** Per analyzed configuration, each library it names that the compiler cannot find. */
+  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. */
@@ -1428,6 +1580,13 @@ interface ComponentsUnread {
   readonly reason: string;
 }
 
+/** One library an analyzed configuration names that the compiler cannot find. */
+interface LibraryUnfound {
+  readonly configFile: string;
+  /** The compiler's error, rendered as a dropped configuration's is. */
+  readonly error: string;
+}
+
 /** The findings of one run, beside what a report states about the run itself. */
 export interface RunAnalysis {
   readonly result: PassResult;

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;
+    }
+  }
+}