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

package/dist/src/analysis.js

@@ -531,7 +531,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,6 +544,7 @@ 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,
@@ -551,6 +552,7 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
             roots: projectRead.rooted.liveUnderReachability,
             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
                 ? {}

package/dist/src/augmentations.js

@@ -15,45 +15,76 @@ 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 [];
+        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);
+}
+/**
+ * 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)) {

package/dist/src/conformance-record.js

@@ -4,7 +4,7 @@ export const RECORD = {
     conformance: {
         corpusVersion: "6.0.0",
         result: "pass",
-        digest: "sha256:76c07ac14bda6e302444918d832b01844bac6f29b6f22a742d538804480c0769",
+        digest: "sha256:d65daae4b7c95050c07896b166d0250d233cca71f97de75a6086c1d80fe76232",
     },
     gaps: [],
 };

package/dist/src/convention-rows.js

@@ -61,6 +61,29 @@ const ANGULAR_PACKAGE_KEYS = [
     "styles",
     "scripts",
 ].map((key) => ({ key, files: ["angular.json"] }));
+/**
+ * The test runners and the assertion, mock and runner libraries whose import is test
+ * evidence beside each runner a row reads test files for. Each applies whether or not a
+ * manifest declares it, so none is a row.
+ */
+export const TEST_LIBRARIES = [
+    "@jest/globals",
+    "@playwright/test",
+    "ava",
+    "chai",
+    "expect",
+    "jasmine",
+    "jest",
+    "mocha",
+    "msw",
+    "nock",
+    "node:test",
+    "sinon",
+    "tap",
+    "uvu",
+];
+/** The scopes every package of which is a test library. */
+export const TEST_LIBRARY_SCOPES = ["@testing-library/"];
 /** Every row, ordered by name and then by range. */
 export const CONVENTION_ROWS = [
     {

package/dist/src/findings/completion.js

@@ -105,6 +105,19 @@ function reachabilityClasses(input) {
         return published.has(id) ? outside : "certain";
     };
 }
+/** The target symbols one test of dead code references, by id: production declarations the sweep judges. */
+function testTargets(union, id) {
+    return (union.out[union.at(id)] ?? []).flatMap((edge) => {
+        const target = union.symbols[edge.to];
+        const testCode = union.test[edge.to] === true || union.support[edge.to] === true;
+        return target !== undefined &&
+            !testCode &&
+            union.ambient[edge.to] !== true &&
+            union.subject[edge.to] === true
+            ? [target.id]
+            : [];
+    });
+}
 /**
  * The confidence ceiling of a test of dead code: the lowest reachability class among the
  * target symbols it references, because its deadness is theirs, whether or not they share
@@ -113,23 +126,28 @@ function reachabilityClasses(input) {
 function testCeilings(input, classOf) {
     const union = input.swept.matrix.union;
     const tests = new Set(input.swept.sweep.candidates.filter((one) => one.testOfDeadCode).map((one) => one.id));
-    return (id) => {
-        let lowest = "certain";
-        if (!tests.has(id)) {
-            return lowest;
-        }
-        for (const edge of union.out[union.at(id)] ?? []) {
-            const target = union.symbols[edge.to];
-            const testCode = union.test[edge.to] === true || union.support[edge.to] === true;
-            if (target !== undefined &&
-                !testCode &&
-                union.ambient[edge.to] !== true &&
-                union.subject[edge.to] === true) {
-                lowest = capped(lowest, classOf(target.id));
-            }
+    return (id) => tests.has(id)
+        ? testTargets(union, id).reduce((lowest, target) => capped(lowest, classOf(target)), "certain")
+        : "certain";
+}
+/**
+ * The subjects dead only because production code only tests use is: each declaration the
+ * sweep marks test-used, each `DS1502` file of such code, and each test of dead code every
+ * target of which is one. Nothing they hold references a dead declaration outside them, so
+ * the rest of a component they share is reported without them.
+ */
+function testUsedSubjects(input) {
+    const { matrix, sweep } = input.swept;
+    const union = matrix.union;
+    const used = new Set(sweep.candidates.filter((one) => one.testUsed).map((one) => one.id));
+    for (const test of sweep.candidates.filter((one) => one.testOfDeadCode)) {
+        const targets = testTargets(union, test.id);
+        if (targets.length > 0 && targets.every((target) => used.has(target))) {
+            used.add(test.id);
         }
-        return lowest;
-    };
+    }
+    const files = new Set(union.symbols.flatMap((symbol, at) => matrix.testUsed[at] === true ? [symbol.position.path] : []));
+    return { declarations: used, files };
 }
 /**
  * The ceiling the roots the run found put on one dead subject: a subject other declarations
@@ -251,6 +269,7 @@ export function completed(input, findings, kinds = KINDS) {
     const candidates = new Map(swept.sweep.candidates.map((candidate) => [candidate.id, candidate]));
     const classOf = reachabilityClasses(input);
     const ceilingOf = testCeilings(input, classOf);
+    const testUsed = testUsedSubjects(input);
     const { components, computed, files } = runComponents(swept, findings);
     const componentOf = findingComponents(swept, components, input.config.reporters.cascade);
     const held = new Set(components.filter((one) => one.held).flatMap((one) => one.members));
@@ -317,7 +336,12 @@ export function completed(input, findings, kinds = KINDS) {
         const counts = candidate === undefined
             ? union.made[at]
             : { production: candidate.productionRefs, test: candidate.testRefs };
-        const reachabilityClass = judged === undefined ? (finding.reachabilityClass ?? "certain") : classOf(judged.id);
+        const ownClass = judged === undefined ? (finding.reachabilityClass ?? "certain") : classOf(judged.id);
+        const used = judged !== undefined
+            ? candidate !== undefined && testUsed.declarations.has(judged.id)
+            : finding.code === FILE_NEVER_IMPORTED && testUsed.files.has(finding.position.path);
+        const reachabilityClass = used && candidate?.testOfDeadCode !== true ? "possible" : ownClass;
+        const untested = capped(capped(capped(ownClass, row.maxClass), rootsCeiling(input, finding, candidate)), judged === undefined ? "certain" : ceilingOf(judged.id));
         const generated = input.files.generated?.has(finding.position.path) === true;
         const fixability = generated
             ? "none"
@@ -341,7 +365,8 @@ export function completed(input, findings, kinds = KINDS) {
             position: finding.position,
             symbol: finding.symbol,
             reachabilityClass,
-            confidence: capped(capped(capped(reachabilityClass, row.maxClass), rootsCeiling(input, finding, candidate)), judged === undefined ? "certain" : ceilingOf(judged.id)),
+            confidence: used ? "possible" : untested,
+            ...(used ? { componentConfidence: untested } : {}),
             ...(candidate === undefined ? {} : { livenessRelation: candidate.relation }),
             testOnly: judged !== undefined && counts?.production === 0 && counts.test > 0,
             generated,
@@ -365,7 +390,7 @@ export function completed(input, findings, kinds = KINDS) {
 /**
  * The findings with every finding of a dead component capped by the lowest confidence
  * among the component's root members, so the minimum confidence reports or withholds a
- * component whole.
+ * component whole but for the findings test-used code lowers on their own.
  */
 function componentCapped(findings, dead) {
     const lowest = new Map();
@@ -373,16 +398,27 @@ function componentCapped(findings, dead) {
         const { id, root } = finding.component;
         if (root && dead.has(id)) {
             const held = lowest.get(id);
-            lowest.set(id, held === undefined ? finding.confidence : capped(held, finding.confidence));
+            const own = componentConfidenceOf(finding);
+            lowest.set(id, held === undefined ? own : capped(held, own));
         }
     }
     return findings.map((finding) => {
         const cap = lowest.get(finding.component.id);
-        return cap === undefined || RANK[cap] >= RANK[finding.confidence]
-            ? finding
-            : { ...finding, confidence: cap };
+        if (cap === undefined) {
+            return finding;
+        }
+        const own = finding.componentConfidence;
+        return {
+            ...finding,
+            confidence: capped(finding.confidence, cap),
+            ...(own === undefined ? {} : { componentConfidence: capped(own, cap) }),
+        };
     });
 }
+/** The confidence a finding gives its component's cap and the dials. */
+function componentConfidenceOf(finding) {
+    return finding.componentConfidence ?? finding.confidence;
+}
 /** Whether the dials withhold a finding by its own severity or confidence. */
 function dialed(finding, minConfidence) {
     return finding.severity === "allow" || RANK[finding.confidence] < RANK[minConfidence];
@@ -397,7 +433,8 @@ function dialed(finding, minConfidence) {
 export function dialsOf(input, findings) {
     const minConfidence = input.config.analysis.minConfidence;
     const components = new Set(findings
-        .filter((finding) => finding.component.root && dialed(finding, minConfidence))
+        .filter((finding) => finding.component.root &&
+        dialed({ ...finding, confidence: componentConfidenceOf(finding) }, minConfidence))
         .map((finding) => finding.component.id));
     return {
         allows: (code) => {

package/dist/src/findings/unused-declarations.js

@@ -41,8 +41,9 @@ const TEST_OF_DEAD_CODE = "every target symbol this test references is reported
  * The code one candidate is reported under, or none, each symbol once under the most
  * specific code: a test of dead code first; no other test-file declaration or enum
  * member nothing names; a test-support declaration test code references as test-only
- * use; then deprecation, a test reference, and the unreferenced codes, an unimportable
- * unused export being the unreachable kind's.
+ * use; then deprecation, a test reference, or only dead production references beside a
+ * test that stays, and the unreferenced codes, an unimportable unused export being the
+ * unreachable kind's.
  */
 function codeOf(judged) {
     const { candidate, symbol } = judged;
@@ -65,7 +66,9 @@ function codeOf(judged) {
     if (candidate.productionRefs === 0 && judged.deprecated) {
         return "DS1006";
     }
-    if (candidate.productionRefs === 0 && candidate.testRefs > 0) {
+    if (candidate.testRefs > 0 &&
+        (candidate.productionRefs === 0 ||
+            (candidate.relation === "reachability" && candidate.keptByTests))) {
         return "DS1004";
     }
     if (MEMBERS.has(symbol.kind)) {
@@ -109,7 +112,9 @@ function messageOf(code, judged) {
         case "DS1006":
             return `deprecated ${word} has no production reference`;
         case "DS1004":
-            return `${word} is referenced only from test files and never from production code`;
+            return candidate.productionRefs === 0
+                ? `${word} is referenced only from test files and never from production code`
+                : `${word} is referenced only from test files and from declarations that are themselves dead`;
     }
     const subject = code === "DS1003"
         ? `${visibilityWord(symbol)}${word}`

package/dist/src/findings/visibility-narrowing.js

@@ -34,12 +34,17 @@ const RUN_ONLY = new Set(["configuration-string", "script"]);
 function entersByName(kinds) {
     return [...(kinds ?? [])].some((kind) => !PUBLISHING.has(kind) && !RUN_ONLY.has(kind));
 }
+/**
+ * The root kinds whose root of a file enters no export by name: a document's import roots
+ * each export it imports, so an export it does not import is judged as in any file.
+ */
+const PER_NAME = new Set(["document-import"]);
 /**
  * Whether the roots of a declaration's file enter it by name: a test runner's root
  * enters only an export the runner calls, so another export of a test file is judged.
  */
 function fileEntersByName(kinds, symbol) {
-    const entering = [...(kinds ?? [])].filter((kind) => !PUBLISHING.has(kind) && !RUN_ONLY.has(kind));
+    const entering = [...(kinds ?? [])].filter((kind) => !PUBLISHING.has(kind) && !RUN_ONLY.has(kind) && !PER_NAME.has(kind));
     return (entering.some((kind) => kind !== "test-runner") || (entering.length > 0 && runnerCalls(symbol)));
 }
 /**
@@ -163,7 +168,7 @@ function narrowing(facts, at, symbol, world) {
  * export no code outside the target can import, because the manifest declares
  * `exports` and no root reaches it. Each arm yields to a more specific kind, so one
  * declaration is reported once: a test whose every subject is dead, an interface, a
- * declaration only a test file references, and a deprecated one.
+ * declaration only a test file references or a test that stays keeps, and a deprecated one.
  */
 function unreachable(facts, at, symbol, candidate, input) {
     if (!input.boundary.encapsulated ||
@@ -171,7 +176,7 @@ function unreachable(facts, at, symbol, candidate, input) {
         (facts.rootedBy[at]?.size ?? 0) > 0 ||
         candidate.testOfDeadCode ||
         symbol.kind === "interface" ||
-        (candidate.productionRefs === 0 && candidate.testRefs > 0) ||
+        (candidate.testRefs > 0 && (candidate.productionRefs === 0 || candidate.keptByTests)) ||
         (candidate.productionRefs === 0 && input.deprecated.has(symbol.id))) {
         return undefined;
     }

package/dist/src/kinds.js

@@ -43,7 +43,7 @@ const ROWS = [
         code: "DS1004",
         name: "test-only-use",
         languages: ["go", "ts"],
-        rule: "A symbol with zero production references and at least one test reference: an unused-exported, unused-unexported or unused-member candidate whose test reference count is not zero, reported once under this code. A reference from a consumer's test files is a test reference unless the configuration counts consumer tests as production. A reference from test-support code, a package or file that only tests reach and that carries test evidence of its own language, is a test reference. A declaration of test-support code is test code and is no subject of this code, as grammar/analysis.md states. An interface method whose only calls and selections through the interface are in test code, and that DS1203's precondition does not exempt, is reported under this code. The methods implementing it are not reported with it, because the test reaches them through it.",
+        rule: "A symbol with zero production references and at least one test reference: an unused-exported, unused-unexported or unused-member candidate whose test reference count is not zero, reported once under this code. A reference from a consumer's test files is a test reference unless the configuration counts consumer tests as production. A reference from test-support code, a package or file that only tests reach and that carries test evidence of its own language, is a test reference. A declaration of test-support code is test code and is no subject of this code, as grammar/analysis.md states. An interface method whose only calls and selections through the interface are in test code, and that DS1203's precondition does not exempt, is reported under this code. The methods implementing it are not reported with it, because the test reaches them through it. A candidate found dead under reachability, every production reference to which is made by a declaration itself dead, is reported under this code as well where test code that is no test of dead code, and that the run counting test references reaches, references it, because that test keeps it, and the finding's message names both kinds of reference.",
         defaultSeverity: "deny",
         maxClass: "certain",
         fixability: "deletable",
@@ -110,7 +110,7 @@ const ROWS = [
         name: "redundant-export-keyword",
         languages: ["ts"],
         rule: "An exported declaration used only inside its own file, reported as a candidate for removing the export keyword. The finding names the narrower visibility the references support.",
-        precondition: 'Closed world only. Reported in a file that is not an entry file, a file only a configuration string or a script token names being none, because each runs the file and reads no name it exports, and a test file being one only for the exports its test runner calls, as grammar/analysis.md "Test code" states, and that either belongs to a project whose consumer set the configuration declares complete or is reached by no manifest export. A declared cross-language edge counts as a reference from outside the file. Where the edge\'s other side is unknown to the analyzer, the finding is emitted pending. A symbol the rule of DS1301 holds for is not reported under this code, whatever severity the configuration gives DS1301, because the write-only finding names the defect to fix first.',
+        precondition: 'Closed world only. Reported in a file that is not an entry file, a file only a configuration string or a script token names being none, because each runs the file and reads no name it exports, and a test file being one only for the exports its test runner calls, as grammar/analysis.md "Test code" states, and a file a Markdown or MDX document imports one only for the exports the import reads, as grammar/analysis.md "Markdown and MDX documents" states, and that either belongs to a project whose consumer set the configuration declares complete or is reached by no manifest export. A declared cross-language edge counts as a reference from outside the file. Where the edge\'s other side is unknown to the analyzer, the finding is emitted pending. A symbol the rule of DS1301 holds for is not reported under this code, whatever severity the configuration gives DS1301, because the write-only finding names the defect to fix first.',
         defaultSeverity: "warn",
         maxClass: "certain",
         fixability: "narrowable",

package/dist/src/matrix.js

@@ -70,11 +70,13 @@ export function matrixOf(per) {
         }
     });
     symbols.sort((a, b) => byPosition(a.position, b.position));
+    const testUsed = new Set(per.flatMap((one) => one.testUsedFiles ?? []));
     return {
         configurations: per.map((one) => one.configuration),
         graphs: per.map((one) => graphOf(one.symbols, one.references, one.roots, one.testFiles, one.supportFiles, one.ambient)),
         union: graphOf(symbols, references, per.flatMap((one) => one.roots), [...new Set(per.flatMap((one) => one.testFiles))], [...new Set(per.flatMap((one) => one.supportFiles ?? []))], new Set(per.flatMap((one) => [...(one.ambient ?? [])]))),
         heldIn: symbols.map((symbol) => holders.get(symbol.id) ?? []),
+        testUsed: symbols.map((symbol) => testUsed.has(symbol.position.path)),
         dependents,
     };
 }
@@ -121,6 +123,9 @@ export function sweepMatrix(matrix, input) {
         union.ambient[edge.to] === true ||
         union.subject[edge.to] !== true ||
         judged[edge.to] !== undefined);
+    const admittedAt = (at) => judged[at]?.every((candidate) => candidate.testOfDeadCode) === true && subjectsDead(at);
+    const kept = keptByTests(union, testReached, admittedAt);
+    const testUsed = testUsedReach(union, union.symbols.map((_symbol, at) => matrix.testUsed[at] === true && testReached[at] === true), judged.map((one) => one !== undefined));
     const candidates = [];
     union.symbols.forEach((symbol, at) => {
         const all = judged[at];
@@ -128,7 +133,7 @@ export function sweepMatrix(matrix, input) {
             return;
         }
         const held = matrix.heldIn[at] ?? [];
-        const admitted = all.every((candidate) => candidate.testOfDeadCode) && subjectsDead(at);
+        const admitted = admittedAt(at);
         const testRefs = union.made[at]?.test ?? 0;
         const heldByTests = heldBy[union.parent[at] ?? OUTSIDE] ??
             (union.support[at] === true && testRefs > 0 && !admitted ? symbol.id : undefined);
@@ -148,6 +153,8 @@ export function sweepMatrix(matrix, input) {
             configurations: held,
             heldByTests,
             unreferencedTest: unreferenced,
+            testUsed: testUsed[at] === true,
+            keptByTests: kept[at] === true,
         });
     });
     const liveUnder = liveAnywhere(union.symbols, per);
@@ -157,6 +164,37 @@ export function sweepMatrix(matrix, input) {
         components: deadComponents(matrix, { liveUnder, candidates }, new Set()),
     };
 }
+/** Per declaration of the union, whether one of `seeds` is it or reaches it through `dead` declarations. */
+function testUsedReach(union, seeds, dead) {
+    // A file is no candidate, and its top level is what reaches what it alone calls.
+    const reached = seeds.map((seed, at) => seed && dead[at] === true);
+    const queue = seeds.flatMap((one, at) => (one ? [at] : []));
+    for (let at = queue.pop(); at !== undefined; at = queue.pop()) {
+        for (const edge of union.out[at] ?? []) {
+            if (dead[edge.to] === true && reached[edge.to] !== true) {
+                reached[edge.to] = true;
+                queue.push(edge.to);
+            }
+        }
+    }
+    return reached;
+}
+/** Per declaration of the union, whether test code `reached` holds and `admitted` rejects references it. */
+function keptByTests(union, reached, admitted) {
+    const kept = union.symbols.map(() => false);
+    union.out.forEach((edges, from) => {
+        const testCode = union.test[from] === true || union.support[from] === true;
+        if (!testCode || reached[from] !== true || admitted(from)) {
+            return;
+        }
+        for (const edge of edges) {
+            if (edge.test) {
+                kept[edge.to] = true;
+            }
+        }
+    });
+    return kept;
+}
 /**
  * The dead components of one sweep over the union, with the file declarations at `files`
  * dead as well: a file that is deleted whole takes the declarations it holds and every

package/dist/src/references.js

@@ -1,4 +1,4 @@
-import { isArrayLiteralExpression, isAsExpression, isBinaryExpression, isCallExpression, isDecorator, isDeleteExpression, isElementAccessExpression, isExportDeclaration, isExpressionStatement, isExternalModuleReference, isForInStatement, isForOfStatement, isForStatement, isIdentifier, isImportDeclaration, isImportEqualsDeclaration, isMetaProperty, isNewExpression, isNamespaceExport, isNoSubstitutionTemplateLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPostfixUnaryExpression, isPrefixUnaryExpression, isPropertyAccessExpression, isPropertyAssignment, isShorthandPropertyAssignment, isSpreadAssignment, isSpreadElement, isStringLiteral, isVoidExpression, SyntaxKind, } from "@typescript/native/ast";
+import { isArrayLiteralExpression, isAsExpression, isBinaryExpression, isCallExpression, isDecorator, isDeleteExpression, isElementAccessExpression, isExportDeclaration, isExpressionStatement, isExternalModuleReference, isForInStatement, isForOfStatement, isForStatement, isIdentifier, isImportDeclaration, isImportEqualsDeclaration, isInterfaceDeclaration, isMetaProperty, isModuleBlock, isModuleDeclaration, isNewExpression, isNamespaceExport, isNoSubstitutionTemplateLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPostfixUnaryExpression, isPrefixUnaryExpression, isPropertyAccessExpression, isPropertyAssignment, isShorthandPropertyAssignment, isSpreadAssignment, isSpreadElement, isStringLiteral, isVoidExpression, SyntaxKind, } from "@typescript/native/ast";
 import { aliasChains } from "./alias-chain.js";
 import { contextualUses } from "./contextual-uses.js";
 import { destructuring, propertyReadsOf } from "./destructuring.js";
@@ -6,7 +6,7 @@ import { specifierCandidates } from "./configuration-files.js";
 import { namespaceUses } from "./namespace-objects.js";
 import { globExpression } from "./glob.js";
 import { declarationsByName, isParameterProperty, nodeKey, } from "./inventory.js";
-import { augmentationReferences } from "./augmentations.js";
+import { ambientGlobalInterfaces, augmentationReferences } from "./augmentations.js";
 import { elementAccessReferences } from "./element-access.js";
 import { indexedAccessReferences } from "./indexed-access.js";
 import { keyofComparisonReferences } from "./keyof-comparisons.js";
@@ -1135,6 +1135,37 @@ export function references(project, held, targetRoot, options) {
             }
         }
     }
+    /** The ambient global interfaces of the walked files that merge into a declaration outside the project's own files. */
+    const libraryMerged = (scripts) => {
+        const names = new Map();
+        const visit = (node) => {
+            if (isInterfaceDeclaration(node)) {
+                const id = declaredAt(node);
+                if (id !== undefined) {
+                    names.set(id, node.name);
+                }
+            }
+            else if (isModuleDeclaration(node) || isModuleBlock(node)) {
+                node.forEachChild(visit);
+            }
+        };
+        for (const { file } of walked) {
+            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 new Set();
+        }
+        const answers = project.symbolsAt(asked.map(([, name]) => project.handle(name)));
+        return new Set(asked.flatMap(([id], at) => {
+            const symbol = answers[at];
+            return typeof symbol === "object" &&
+                symbol.declarations.some((handle) => !ownPaths.has(handle.path))
+                ? [id]
+                : [];
+        }));
+    };
     const usesOf = new Map(walked.map((one) => [one.file, one.uses]));
     for (const [file, writes] of valued) {
         const uses = usesOf.get(file) ?? [];
@@ -1159,7 +1190,7 @@ export function references(project, held, targetRoot, options) {
         typedLookups = (options.requestCount?.() ?? 0) - before;
     }
     const scripts = new Set(walked.filter((one) => one.file.externalModuleIndicator === undefined).map((one) => one.fileId));
-    found.push(...augmentationReferences(held, found, scripts));
+    found.push(...augmentationReferences(held, found, scripts, libraryMerged(scripts)));
     found.sort((a, b) => byPosition(a.position, b.position) ||
         compare(a.to, b.to) ||
         compare(a.from, b.from) ||

package/dist/src/suppress.js

@@ -57,6 +57,7 @@ export const GO_REF_EXPRESSIONS = [
     `^go://${GO_PATH}#${GO_IDENT}$`,
     `^go://${GO_PATH}#${GO_IDENT}(?:\\.${GO_IDENT})+$`,
     `^go://${GO_PATH}#${GO_IDENT}(?:\\.${GO_IDENT})?\\[${GO_IDENT}\\]$`,
+    `^go://${GO_PATH}#(?:${GO_IDENT}(?:\\.${GO_IDENT})?)?\\(${GO_IDENT}\\)$`,
     `^go://${GO_PATH}#${GO_FILE}:file$`,
     `^go://${GO_PATH}#${GO_PATH}(?:@${GO_VERSION})?:require$`,
     `^go://${GO_PATH}#${GO_PATH}(?:@${GO_VERSION})?:replace$`,

package/dist/src/test-support.js

@@ -5,21 +5,18 @@
  * another such file, so it is judged with the tests: what it references is referenced by
  * test code.
  */
-import { CONVENTION_ROWS } from "./convention-rows.js";
+import { CONVENTION_ROWS, TEST_LIBRARIES, TEST_LIBRARY_SCOPES } from "./convention-rows.js";
 import { packageOfSpecifier } from "./dependencies.js";
 /** The root kind that never takes a file out of test-support code: the skip only withholds. */
 const SKIP_ROOT = "type-error";
 /**
  * The test runners and test libraries an import of which is test evidence: each runner a
- * convention row reads test files for, the platform's own runner, and the libraries below.
+ * convention row reads test files for, and the convention table's test libraries.
  */
 const TEST_PACKAGES = new Set([
     ...CONVENTION_ROWS.filter((row) => row.testFiles !== undefined).map((row) => row.package),
-    "node:test",
-    "@playwright/test",
+    ...TEST_LIBRARIES,
 ]);
-/** The scopes every package of which is a test library. */
-const TEST_SCOPES = ["@testing-library/"];
 /**
  * The Node.js built-in modules a bare specifier names, which are no package. The set is
  * closed: Node.js adds a new built-in under the `node:` scheme alone
@@ -73,7 +70,7 @@ const NODE_BUILTINS = new Set([
 function namesTestPackage(specifier) {
     const name = specifier.startsWith("node:") ? specifier : packageOfSpecifier(specifier);
     return (name !== undefined &&
-        (TEST_PACKAGES.has(name) || TEST_SCOPES.some((scope) => name.startsWith(scope))));
+        (TEST_PACKAGES.has(name) || TEST_LIBRARY_SCOPES.some((scope) => name.startsWith(scope))));
 }
 /**
  * Whether a file carries test evidence: an import of a test runner or a test library, or
@@ -106,9 +103,9 @@ function evidenceReader(tests, evidence) {
  * The files of one project that are test-support code, below the target root: the
  * largest set of files a test file reaches, none of them a test file or holding a root,
  * each carrying test evidence of its own, whose every user outside the set is a test
- * file. A root has a caller outside the reference graph: a runtime, a tool, a
- * configuration, or a consumer of a library's published API. `testFiles` are the files
- * the test-file rules classified.
+ * file; and the files only tests reach that are not among them. A root has a caller
+ * outside the reference graph: a runtime, a tool, a configuration, or a consumer of a
+ * library's published API. `testFiles` are the files the test-file rules classified.
  */
 export function testSupportFiles(symbols, references, roots, testFiles, evidence) {
     const fileOf = new Map(symbols.map((symbol) => [symbol.id, symbol.position.path]));
@@ -162,7 +159,7 @@ export function testSupportFiles(symbols, references, roots, testFiles, evidence
     const onlyTests = withoutOutsideUsers(new Set([...reached].filter((path) => !rooted.has(path))));
     const carries = evidenceReader(tests, evidence);
     const support = withoutOutsideUsers(new Set([...onlyTests].filter((path) => carries(onlyTests, path))));
-    return support;
+    return { support, testUsed: new Set([...onlyTests].filter((path) => !support.has(path))) };
 }
 /** The references with every one a test-support file makes counted as a test reference. */
 export function supportReferences(references, support) {

package/jsr.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "8.0.0-dev.1",
+  "version": "8.0.0-dev.2",
   "license": "GPL-3.0-or-later",
   "exports": {
     ".": "./src/index.ts"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "8.0.0-dev.1",
+  "version": "8.0.0-dev.2",
   "type": "module",
   "sideEffects": false,
   "description": "Deterministic dead-code analysis for TypeScript, class and type members included",