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

package/README.md

@@ -4,7 +4,7 @@
 
 deadset-ts finds dead code in TypeScript projects, down to class members, type members and dead stores inside functions, and writes a report your CI can fail on.
 
-It reads your `tsconfig.json` projects, `allowJs` JavaScript and Vue, Svelte and Astro scripts included, with the type information of TypeScript 7.1.0-dev.20261010.1, its one dependency. Your project keeps its own TypeScript version. A type error under that version skips the function or statement that holds it. deadset-ts reports and never edits your code. It is pre-release, tested only on Linux, needs Node.js 24 or later and is licensed under GPL-3.0-or-later.
+It reads your `tsconfig.json` projects, `allowJs` JavaScript and Vue, Svelte and Astro scripts included, with the type information of TypeScript 7.1.0-dev.20261014.1, its one dependency. Your project keeps its own TypeScript version. A type error under that version skips the function or statement that holds it. deadset-ts reports and never edits your code. It is pre-release, tested only on Linux, needs Node.js 24 or later and is licensed under GPL-3.0-or-later.
 
 ## Why use it
 

package/dist/src/analysis.js

@@ -20,7 +20,7 @@ import { enumGroup } from "./enum-group.js";
 import { generatedFile, generatedFilesOf } from "./generated-file.js";
 import { inOperandNames } from "./in-operands.js";
 import { sourceFilesOf } from "./source-files.js";
-import { evidenceRecords, heldRecords, disabledClasses, exemptionsOf, holdingWhile, isUnansweredRecord, retainedIn, } from "./exempt.js";
+import { evidenceRecords, heldRecords, disabledClasses, exemptionsOf, holdingWhile, isUnansweredRecord, retainedIn, writtenRecords, } from "./exempt.js";
 import { heldByInclusion, sourcePaths, sourceTree } from "./file-facts.js";
 import { globExpression } from "./glob.js";
 import { findingsPass, recordedFindings, rowKey } from "./findings-pass.js";
@@ -41,9 +41,12 @@ import { pathsOf, readErrors, skippedRoots, skippedUnits, } from "./type-errors.
 import { reflectiveLookup } from "./reflective-lookup.js";
 import { references, testFileRulesOf } from "./references.js";
 import { roots, unmatchedEverywhere, } from "./roots.js";
-import { serializationContract } from "./serialization-contract.js";
+import { decodedMembers, 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,17 +512,29 @@ 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),
                 line: lineOf(file.originalText, warning.offset),
                 reason: warning.reason,
             }))),
+            decoded: decodedMembers(project, projectRead.held, productionFiles(project, targetRoot, resolved.testFilePaths), consumers),
             extra: extra(project, projectRead, resolved.references, resolved.testFilePaths),
         };
     });
@@ -532,11 +550,24 @@ 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, 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]);
+    // A member a decode fills or a copy carries is written: a value decoded and sent again carries it on.
+    const written = new Set([
+        ...countedWrites([...withOutside.flatMap((one) => one.references), ...read.consumers.references], support, mode),
+        ...withOutside.flatMap((one) => [
+            ...one.decoded.filled,
+            ...one.decoded.parsed,
+            ...one.decoded.copied,
+        ]),
+    ]);
+    const evidence = withOutside.map((one) => writtenRecords(one.evidence, written));
+    const settled = settledSatisfaction(withOutside.map((one, index) => ({
+        evidence: evidence[index] ?? [],
+        held: one.projectRead.held,
+    })), [...withOutside.flatMap((one) => one.references), ...read.consumers.references]);
     const answers = withOutside.map((one, index) => {
         const { projectRead } = one;
         const satisfied = settled[index];
-        const detected = heldRecords(satisfied?.evidence ?? one.evidence, {
+        const detected = heldRecords(satisfied?.evidence ?? evidence[index] ?? [], {
             mode,
             testFiles: new Set([...one.testFiles, ...support]),
         });
@@ -549,7 +580,9 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
             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 }),
@@ -572,7 +605,9 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
                     .filter((reference) => reference.resolution === "by-name")
                     .map((reference) => reference.to),
                 ...exempt.filter(isUnansweredRecord).map((record) => record.id),
+                ...one.decoded.unanswered,
             ],
+            filledOutside: one.decoded.filled,
             typeErrorSkips: projectRead.typeErrorSkips,
             unmappedEntries: projectRead.rooted.unmappedEntries,
             skipped: projectRead.skipped,
@@ -662,6 +697,13 @@ function evidenceReferences(symbols, inTestFiles) {
             ];
     });
 }
+/**
+ * The declarations a write the mode counts stores into, a write a test-support file
+ * makes being a test's.
+ */
+function countedWrites(references, support, mode) {
+    return new Set(supportReferences(references, support).flatMap((reference) => reference.use === "write" && !(mode.production && reference.test) ? [reference.to] : []));
+}
 /**
  * The declarations every reference the mode counts stores into, a loaded consumer's
  * reference counting as a read: what the write-only kind would report but for a record.
@@ -746,6 +788,11 @@ function sweptOf(read, input) {
 export function runSweep(engine, host, scope, config, input, detectors = DETECTORS) {
     return sweptOf(readRun(engine, host, scope, config, input.mode, detectors, () => undefined), input);
 }
+/** The project's own files below the target root that are no test file. */
+function productionFiles(project, targetRoot, testFiles) {
+    const tests = new Set(testFiles);
+    return [...sourceFilesOf(project, targetRoot).byPath].flatMap(([path, file]) => tests.has(path) ? [] : [file]);
+}
 /** Reads a run's projects with every per-project fact an emitter reads. */
 export function readEmitterRun(engine, host, scope, config, mode, detectors) {
     const targetRoot = scope.target.path;
@@ -761,8 +808,9 @@ 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
+    // Whether a declaration carries the marker decides its code, so one whose answer went
     // unread is reported by nothing.
     const unread = run.projects.flatMap((one) => one.extra.deprecation.unanswered);
     return unread.length === 0
@@ -836,6 +884,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: {
@@ -844,6 +893,7 @@ export function emitterInputOver(host, scope, config, read, input, selfCheck) {
             },
             encapsulated: readManifest(host, targetRoot).declaresExports,
             edges: readEdgeSides(host, targetRoot),
+            filledOutside: new Set(projects.flatMap((one) => one.filledOutside)),
         },
         selfCheck,
         intraFunction: intraFunctionFacts(projects.map((one) => one.extra.parts), projects.flatMap((one) => one.configured.references), new Set([...swept.exempt.map((one) => one.id), ...swept.heldByUnanswered])),
@@ -886,6 +936,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,9 +6,11 @@
  * 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) {
+export function isGlobalBlock(symbol, held, files) {
     return (symbol.kind === "namespace" &&
         files.has(symbol.parent) &&
         symbol.ref.endsWith("#global") &&
@@ -54,6 +56,66 @@ export function ambientGlobalInterfaces(held, interfaces, scripts) {
         ? []
         : 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