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

package/src/analysis.ts

@@ -107,6 +107,7 @@ import { references, testFileRulesOf, type Reference, type TestFileRule } from "
 import {
   roots,
   unmatchedEverywhere,
+  type Root,
   type RootKind,
   type RootOptions,
   type Roots,
@@ -114,7 +115,10 @@ import {
 import type { Scope } from "./scope.ts";
 import { serializationContract } from "./serialization-contract.ts";
 import { outsideTestReferences, testFilesAt, type OutsideTest } from "./outside-tests.ts";
+import { mergedGlobalInterfaces } from "./augmentations.ts";
+import { unseenLoadsOf, type UnseenLoad } from "./unseen-loads.ts";
 import { joinedTestFiles, withJoinedTests } from "./test-joins.ts";
+import { GLOBALS_RUNNER, namesTestGlobals, withTestGlobals } from "./test-globals.ts";
 import { supportReferences, testSupportFiles, type TestEvidence } from "./test-support.ts";
 import {
   diagnosticsOf,
@@ -428,11 +432,17 @@ function readProjects<Answer>(
   const joins = discovered.derived
     ? joinedTestFiles(engine, host, absoluteRoot, discovered.configFiles, testPatterns)
     : new Map<string, readonly string[]>();
-  const programs = withBaseUrlPaths(
+  const programs = withTestGlobals(
     engine,
     host,
-    [...discovered.configFiles, ...consumerOf.keys()],
-    workspace?.programs ?? new Map(),
+    parse,
+    discovered.configFiles,
+    withBaseUrlPaths(
+      engine,
+      host,
+      [...discovered.configFiles, ...consumerOf.keys()],
+      workspace?.programs ?? new Map(),
+    ),
   );
   const session = runSession(
     engine,
@@ -804,6 +814,8 @@ interface ReadProject<Extra> {
   readonly componentWarnings: readonly ComponentWarning[];
   /** Per own file below the target root, the module specifiers its imports write. */
   readonly imports: ReadonlyMap<string, readonly string[]>;
+  /** The global augmentations a declaration outside the project names. */
+  readonly augmented: readonly Root[];
   readonly extra: Extra;
 }
 
@@ -940,6 +952,9 @@ function readRun<Extra>(
       disabled,
     );
     const components = project.ownSourceFiles().filter(isComponentFile);
+    const injected = project.program
+      .getSourceFileNames()
+      .some((name) => name.endsWith(`/node_modules/${GLOBALS_RUNNER}/globals.d.ts`));
     const pathOf = (file: (typeof components)[number]): string =>
       relativePath(targetRoot, file.fileName) ?? file.fileName;
     return {
@@ -948,12 +963,27 @@ function readRun<Extra>(
       testFiles: resolved.testFilePaths,
       evidence,
       componentFiles: components.map(pathOf),
+      augmented: mergedGlobalInterfaces(
+        project,
+        projectRead.held,
+        sourceFilesOf(project, targetRoot),
+      ).map((id): Root => ({ id, kind: "global-augmentation", source: "" })),
       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)]];
+          if (path === undefined) {
+            return [];
+          }
+          const specifiers = file.imports.filter(isStringLiteralLikeNode).map((one) => one.text);
+          // A file calling the globals a program declares is written for their runner.
+          return [
+            [
+              path,
+              injected && namesTestGlobals(project, file)
+                ? [...specifiers, GLOBALS_RUNNER]
+                : specifiers,
+            ],
+          ];
         }),
       ),
       componentWarnings: components.flatMap((file) =>
@@ -977,7 +1007,7 @@ 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),
@@ -999,13 +1029,17 @@ 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,
+      // The augmentations are rooted after test support is read: an outside declaration
+      // naming one calls nothing of its file.
+      roots: [...projectRead.rooted.liveUnderReachability, ...one.augmented],
       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
         ? {}
@@ -1244,6 +1278,7 @@ interface EmitterExtra {
   readonly directives: readonly InlineDirective[];
   readonly declarationsNamed: readonly boolean[];
   readonly parts: ProjectParts;
+  readonly unseenLoads: readonly UnseenLoad[];
 }
 
 /** Reads a run's projects with every per-project fact an emitter reads. */
@@ -1279,6 +1314,7 @@ export function readEmitterRun(
       ),
       declarationsNamed: declarationsNamed(project, read.held, configuredDeclarations(config)),
       parts: projectParts(project, read.held, references, targetRoot),
+      unseenLoads: unseenLoadsOf(project, read.configuration, targetRoot, testFiles),
     }),
   );
   // Whether a declaration carries the marker decides its code, so one whose marker went
@@ -1384,6 +1420,7 @@ export function emitterInputOver(
       heldByInclusion: new Set(projects.flatMap((one) => one.extra.heldByInclusion)),
       generated: new Set(projects.flatMap((one) => one.extra.generated)),
       inOperands: new Set(projects.flatMap((one) => one.extra.inOperands)),
+      unseenLoads: projects.flatMap((one) => one.extra.unseenLoads),
     },
     boundary: {
       consumers: {
@@ -1474,6 +1511,7 @@ function readAnalysis(
       librariesUnfound: read.librariesUnfound,
       conventionsApplied: read.conventionsApplied,
       unmappedEntries: unmappedEverywhere(read.projects),
+      unseenLoads: read.projects.flatMap((one) => one.extra.unseenLoads),
     },
     configured: read.projects.map((one) => one.configured),
     symbols,
@@ -1572,6 +1610,8 @@ interface RunFacts {
   readonly conventionsApplied: readonly AppliedConvention[];
   /** The manifest entries no project of the run reads back to a file, each once. */
   readonly unmappedEntries: readonly ManifestEntry[];
+  /** The loads of production files whose target the run cannot resolve, per configuration. */
+  readonly unseenLoads: readonly UnseenLoad[];
 }
 
 /** One configuration whose component files a run cannot read. */

package/src/augmentations.ts

@@ -7,9 +7,18 @@
  * as `import.meta` or `process.env`, so a use of its member is a use of it.
  */
 
-import type { Inventory, InventorySymbol } from "./inventory.ts";
+import {
+  isInterfaceDeclaration,
+  isModuleBlock,
+  isModuleDeclaration,
+  type Node,
+} from "@typescript/native/ast";
+import { nodeKey, type Inventory, type InventorySymbol } from "./inventory.ts";
 import { referenceKey } from "./matrix.ts";
 import type { Reference } from "./references.ts";
+import type { ProjectView } from "./session.ts";
+import type { SourceFiles } from "./source-files.ts";
+import type { NodeHandle } from "@typescript/native/sync";
 
 /** Whether one declaration is a `declare global` block: a module-level namespace named `global`. */
 function isGlobalBlock(
@@ -26,25 +35,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 ?? "");
@@ -52,29 +60,139 @@ 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 { ids: [], global: false };
+  };
+}
+
+/**
+ * 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);
+}
+
+/**
+ * Each ambient global interface of the project's own files that merges into an interface
+ * declared outside them, with every interface, namespace and block between it and the
+ * global scope: the outside declaration names it wherever a value is typed by it. Where
+ * every outside declaration is a package's, not the compiler's library, and declares no
+ * member, each member it declares as well: such an interface is a slot the package reads
+ * by type, as `keyof` does, in declarations the analysis does not walk.
+ */
+export function mergedGlobalInterfaces<Brand>(
+  project: ProjectView<Brand>,
+  held: Inventory,
+  files: SourceFiles,
+): readonly string[] {
+  const scripts = new Set<string>();
+  const names = new Map<string, Node>();
+  for (const file of files.byName.values()) {
+    const fileId = held.declarations.get(nodeKey(file, file));
+    if (fileId !== undefined && file.externalModuleIndicator === undefined) {
+      scripts.add(fileId);
+    }
+    const visit = (node: Node): void => {
+      if (isInterfaceDeclaration(node)) {
+        const id = held.declarations.get(nodeKey(file, node));
+        if (id !== undefined) {
+          names.set(id, node.name);
+        }
+      } else if (isModuleDeclaration(node) || isModuleBlock(node)) {
+        node.forEachChild(visit);
+      }
+    };
+    file.forEachChild(visit);
+  }
+  const global = new Set(ambientGlobalInterfaces(held, [...names.keys()], scripts));
+  const asked = [...names].filter(([id]) => global.has(id));
+  if (asked.length === 0) {
     return [];
+  }
+  const answers = project.symbolsAt(asked.map(([, name]) => project.handle(name)));
+  const holders = holdersOf(held, scripts);
+  const empty = (handle: NodeHandle): boolean => {
+    if (project.program.getSourceFileMetadata(handle.path)?.isDefaultLibrary === true) {
+      return false;
+    }
+    const node = project.declarationAt(handle)?.node;
+    return node !== undefined && isInterfaceDeclaration(node) && node.members.length === 0;
   };
+  return [
+    ...new Set(
+      asked.flatMap(([id], at) => {
+        const symbol = answers[at];
+        if (typeof symbol !== "object") {
+          return [];
+        }
+        const outside = symbol.declarations.filter((handle) => !files.byName.has(handle.path));
+        if (outside.length === 0) {
+          return [];
+        }
+        const members = outside.every(empty)
+          ? held.symbols.filter((one) => one.parent === id).map((one) => one.id)
+          : [];
+        return [id, ...(holders?.(id).ids ?? []), ...members];
+      }),
+    ),
+  ];
+}
+
+/**
+ * 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) {
-    for (const to of holders(reference.to)) {
+    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: reference.from,
+        from,
         to,
         position: reference.position,
         use: "read",
         resolution: reference.resolution,
-        test: reference.test,
+        test: reference.test && !typed,
       };
       const key = referenceKey(read);
       if (!made.has(key) && !reads.has(key)) {