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

package/dist/src/analysis.js

@@ -43,7 +43,10 @@ import { references, testFileRulesOf } from "./references.js";
 import { roots, unmatchedEverywhere, } from "./roots.js";
 import { serializationContract } from "./serialization-contract.js";
 import { outsideTestReferences, testFilesAt } from "./outside-tests.js";
+import { mergedGlobalInterfaces } from "./augmentations.js";
+import { unseenLoadsOf } from "./unseen-loads.js";
 import { joinedTestFiles, withJoinedTests } from "./test-joins.js";
+import { GLOBALS_RUNNER, namesTestGlobals, withTestGlobals } from "./test-globals.js";
 import { supportReferences, testSupportFiles } from "./test-support.js";
 import { diagnosticsOf, ownedAs, runSession, } from "./session.js";
 import { accessorsOf, storesOf } from "./stores.js";
@@ -195,7 +198,7 @@ function readProjects(engine, host, scope, config, stage) {
     const joins = discovered.derived
         ? joinedTestFiles(engine, host, absoluteRoot, discovered.configFiles, testPatterns)
         : new Map();
-    const programs = withBaseUrlPaths(engine, host, [...discovered.configFiles, ...consumerOf.keys()], workspace?.programs ?? new Map());
+    const programs = withTestGlobals(engine, host, parse, discovered.configFiles, withBaseUrlPaths(engine, host, [...discovered.configFiles, ...consumerOf.keys()], workspace?.programs ?? new Map()));
     const session = runSession(engine, [...discovered.configFiles, ...consumerOf.keys()], (opened) => {
         const consumer = consumerOf.get(opened.configFile);
         const setup = consumer === undefined ? workspace?.unbuildable(opened.configFile) : undefined;
@@ -499,6 +502,9 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
                 : { generated: projectRead.generated }),
         }, detectors, 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) => relativePath(targetRoot, file.fileName) ?? file.fileName;
         return {
             projectRead,
@@ -506,11 +512,22 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
             testFiles: resolved.testFilePaths,
             evidence,
             componentFiles: components.map(pathOf),
+            augmented: mergedGlobalInterfaces(project, projectRead.held, sourceFilesOf(project, targetRoot)).map((id) => ({ 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) => readComponent(file.originalText, extensionOf(file.fileName)).warnings.map((warning) => ({
                 path: pathOf(file),
@@ -531,7 +548,7 @@ function readRun(engine, host, scope, config, mode, detectors, 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(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 { 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 })), [...withOutside.flatMap((one) => one.references), ...read.consumers.references]);
     const answers = withOutside.map((one, index) => {
         const { projectRead } = one;
@@ -544,13 +561,17 @@ function readRun(engine, host, scope, config, mode, detectors, 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 = {
             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
                 ? {}
@@ -759,6 +780,7 @@ export function readEmitterRun(engine, host, scope, config, mode, detectors) {
         directives: inlineDirectives(project, read.held, targetRoot).filter((directive) => !read.referenceOnly.includes(directive.site.path)),
         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
     // unread is reported by nothing.
@@ -834,6 +856,7 @@ export function emitterInputOver(host, scope, config, read, input, selfCheck) {
             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: {
@@ -884,6 +907,7 @@ function readAnalysis(engine, host, scope, config, provenance, mode, detectors)
             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,

package/dist/src/augmentations.js

@@ -6,6 +6,8 @@
  * name, which the language or a library types values by where the target never names it,
  * as `import.meta` or `process.env`, so a use of its member is a use of it.
  */
+import { isInterfaceDeclaration, isModuleBlock, isModuleDeclaration, } from "@typescript/native/ast";
+import { nodeKey } from "./inventory.js";
 import { referenceKey } from "./matrix.js";
 /** Whether one declaration is a `declare global` block: a module-level namespace named `global`. */
 function isGlobalBlock(symbol, held, files) {
@@ -15,45 +17,136 @@ function isGlobalBlock(symbol, held, files) {
         !held.modules.has(symbol.id));
 }
 /**
- * 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(held, found, scripts = new Set()) {
+function holdersOf(held, scripts) {
     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) => {
+    return (id) => {
         const ids = [];
         for (let at = byId.get(byId.get(id)?.parent ?? ""); at !== undefined; 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, interfaces, scripts) {
+    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(project, held, files) {
+    const scripts = new Set();
+    const names = new Map();
+    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) => {
+            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) => {
+        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, found, scripts = new Set(), merged = new Set()) {
+    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();
     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 = {
-                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)) {