@cplieger/deadset-ts 5.1.0 → 5.2.0

package/dist/src/conventions.js

@@ -5,7 +5,7 @@
  * directory a configuration property moves read from the property's literal value.
  * No configuration file is run.
  */
-import { isAsExpression, isBinaryExpression, isCallExpression, isClassDeclaration, isComputedPropertyName, isExportAssignment, isExportDeclaration, isExpressionStatement, isFunctionDeclaration, isIdentifier, isImportDeclaration, isNamedExports, isNamespaceImport, isNoSubstitutionTemplateLiteral, isNonNullExpression, isNumericLiteral, isObjectBindingPattern, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAccessExpression, isPropertyAssignment, isSatisfiesExpression, isShorthandPropertyAssignment, isSpreadAssignment, isStringLiteral, isVariableStatement, SyntaxKind, } from "@typescript/native/unstable/ast";
+import { isArrayLiteralExpression, isAsExpression, isBinaryExpression, isCallExpression, isClassDeclaration, isComputedPropertyName, isExportAssignment, isExportDeclaration, isExpressionStatement, isFunctionDeclaration, isIdentifier, isImportDeclaration, isNamedExports, isNamespaceImport, isNoSubstitutionTemplateLiteral, isNonNullExpression, isNumericLiteral, isObjectBindingPattern, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAccessExpression, isPropertyAssignment, isSatisfiesExpression, isShorthandPropertyAssignment, isSpreadAssignment, isStringLiteral, isVariableStatement, SyntaxKind, } from "@typescript/native/unstable/ast";
 import { lineOf } from "./component-files.js";
 import { CONVENTION_ROWS, } from "./convention-rows.js";
 import { globExpression } from "./glob.js";
@@ -288,12 +288,32 @@ function objectOf(node, declared, throughCalls, seen = new Set()) {
     }
     return at;
 }
+/** The text of a string literal or a template literal with no substitution, or undefined. */
+function literalText(node) {
+    const at = unwrapped(node);
+    return isStringLiteral(at) || isNoSubstitutionTemplateLiteral(at) ? at.text : undefined;
+}
+/**
+ * The literal texts one value at a path's end writes: the literal itself, or, where
+ * `elements`, each element of an array literal of literals. Undefined for any other value.
+ */
+function literalTexts(held, elements) {
+    const one = literalText(held);
+    if (one !== undefined) {
+        return [one];
+    }
+    if (!elements || !isArrayLiteralExpression(held)) {
+        return undefined;
+    }
+    const texts = held.elements.map(literalText);
+    return texts.every((text) => text !== undefined) ? texts : undefined;
+}
 /**
  * Reads the values at one path of keys below one object literal into `values`, and
  * answers the first member that does not write its value out: a spread, a value that is
  * not a literal at the path's end, or one that is not an object literal before it.
  */
-function readPath(object, keys, values) {
+function readPath(object, keys, values, elements) {
     const [key, ...rest] = keys;
     for (const member of object.properties) {
         if (isSpreadAssignment(member) || computesKey(member)) {
@@ -304,16 +324,17 @@ function readPath(object, keys, values) {
         }
         const held = isPropertyAssignment(member) ? unwrapped(member.initializer) : undefined;
         if (rest.length === 0) {
-            if (held === undefined || !(isStringLiteral(held) || isNoSubstitutionTemplateLiteral(held))) {
+            const texts = held === undefined ? undefined : literalTexts(held, elements);
+            if (texts === undefined) {
                 return member;
             }
-            values.push(held.text);
+            values.push(...texts);
         }
         else {
             if (held === undefined || !isObjectLiteralExpression(held)) {
                 return member;
             }
-            const failed = readPath(held, rest, values);
+            const failed = readPath(held, rest, values, elements);
             if (failed !== undefined) {
                 return failed;
             }
@@ -324,11 +345,12 @@ function readPath(object, keys, values) {
 /**
  * Every value one file writes at one property's path inside the object it is read from:
  * the options argument of every call `call` names, or the file's default export. A string
- * literal or a template literal with no substitution is the value. A read object, or an
- * object along the path, that is not written out as an object literal, or that spreads
- * another object into itself, is not a literal, and neither is any other value at the path.
+ * literal or a template literal with no substitution is the value, and so is each element
+ * of an array literal of them where `elements`. A read object, or an object along the
+ * path, that is not written out as an object literal, or that spreads another object into
+ * itself, is not a literal, and neither is any other value at the path.
  */
-export function readProperty(file, property, call) {
+export function readProperty(file, property, call, elements = false) {
     const declared = declaredValues(file);
     const objects = call === undefined
         ? defaultExports(file).map((one) => objectOf(one, declared, true))
@@ -339,7 +361,7 @@ export function readProperty(file, property, call) {
             continue;
         }
         const notLiteral = isObjectLiteralExpression(object)
-            ? readPath(object, property.split("."), values)
+            ? readPath(object, property.split("."), values, elements)
             : object;
         if (notLiteral !== undefined) {
             return { values, notLiteral };
@@ -392,29 +414,18 @@ function configurationFiles(host, dir, glob) {
 function resolveMove(host, parse, dir, row, move, resolved) {
     const set = [];
     for (const reading of move.readings) {
-        for (const glob of reading.files) {
-            for (const name of configurationFiles(host, dir, glob)) {
-                const path = joinPath(dir, name);
-                let text;
-                try {
-                    text = host.readFile(path);
-                }
-                catch {
-                    continue;
-                }
-                const file = parse(path, text);
-                const read = readProperty(file, reading.property, reading.call);
-                if (read.notLiteral !== undefined) {
-                    const line = lineOf(text, read.notLiteral.getStart());
-                    return {
-                        failure: `${name}:${String(line)} sets ${reading.property}, which moves a directory ` +
-                            `the convention row ${row.name} reads, to a value that is not a string literal: ` +
-                            `write it as a literal, or name ${row.name} in ts.disabled_conventions and its ` +
-                            `files in ts.entry_files`,
-                    };
-                }
-                set.push(...read.values);
+        for (const { name, text, file } of readingFiles(host, parse, dir, reading.files)) {
+            const read = readProperty(file, reading.property, reading.call);
+            if (read.notLiteral !== undefined) {
+                const line = lineOf(text, read.notLiteral.getStart());
+                return {
+                    failure: `${name}:${String(line)} sets ${reading.property}, which moves a directory ` +
+                        `the convention row ${row.name} reads, to a value that is not a string literal: ` +
+                        `write it as a literal, or name ${row.name} in ts.disabled_conventions and its ` +
+                        `files in ts.entry_files`,
+                };
             }
+            set.push(...read.values);
         }
     }
     const dirs = [];
@@ -427,6 +438,55 @@ function resolveMove(host, parse, dir, row, move, resolved) {
     }
     return { dirs: [...new Set(dirs)] };
 }
+/** The texts each configuration file a reading names holds, parsed, in name order. */
+function readingFiles(host, parse, dir, files) {
+    const found = [];
+    for (const glob of files) {
+        for (const name of configurationFiles(host, dir, glob)) {
+            const path = joinPath(dir, name);
+            let text;
+            try {
+                text = host.readFile(path);
+            }
+            catch {
+                continue;
+            }
+            found.push({ name, text, file: parse(path, text) });
+        }
+    }
+    return found;
+}
+/**
+ * The dependencies one manifest declares that an applied row's short names use: the
+ * package each literal value stands for, and, for a value that is not a literal, every
+ * declared dependency the row's package name stands for with some value.
+ */
+function shortNameUses(host, parse, dir, manifest, readings) {
+    const declared = new Set(DEPENDENCY_SECTIONS.flatMap((section) => {
+        const held = isRecord(manifest) ? manifest[section] : undefined;
+        return isRecord(held) ? Object.keys(held) : [];
+    }));
+    const used = new Set();
+    for (const reading of readings) {
+        const [before = "", after = ""] = reading.package.split("{}");
+        for (const { file } of readingFiles(host, parse, dir, reading.files)) {
+            const read = readProperty(file, reading.property, reading.call, true);
+            for (const value of read.values) {
+                used.add(`${before}${value}${after}`);
+            }
+            if (read.notLiteral !== undefined) {
+                for (const name of declared) {
+                    if (name.length >= before.length + after.length &&
+                        name.startsWith(before) &&
+                        name.endsWith(after)) {
+                        used.add(name);
+                    }
+                }
+            }
+        }
+    }
+    return [...used].filter((name) => declared.has(name)).sort(compare);
+}
 /** Two strings ordered bytewise. */
 function compare(a, b) {
     if (a === b) {
@@ -443,6 +503,7 @@ export function readConventions(host, parse, manifests, disabled, rows = CONVENT
     const globs = [];
     const generated = [];
     const failures = [];
+    const uses = new Set();
     for (const manifest of manifests) {
         const declared = readJSON(host, joinPath(manifest.dir, "package.json"));
         const versions = new Map();
@@ -500,6 +561,9 @@ export function readConventions(host, parse, manifests, disabled, rows = CONVENT
                 version,
                 manifest: manifest.path,
             });
+            for (const name of shortNameUses(host, parse, manifest.dir, declared, row.shortNames ?? [])) {
+                uses.add(name);
+            }
             const excludes = [
                 ...new Set((row.excludes ?? []).flatMap((one) => expand(one, resolved))),
             ].map(globExpression);
@@ -520,7 +584,7 @@ export function readConventions(host, parse, manifests, disabled, rows = CONVENT
     unique.sort((a, b) => compare(a.name, b.name) ||
         compare(a.manifest, b.manifest) ||
         compare(JSON.stringify(a), JSON.stringify(b)));
-    return { applied: unique, globs, generated, failures };
+    return { applied: unique, globs, generated, failures, uses: [...uses].sort(compare) };
 }
 /**
  * Every own file of one project below a directory an applied row names as generated, by

package/dist/src/dependencies.js

@@ -24,6 +24,14 @@ const SECTIONS = [
 ];
 /** The owner of a use no declaration of the inventory holds: a configuration's. */
 const PROJECT_OWNER = "";
+/** What a configuration's own reading needs: packages no deletion of a declaration removes. */
+export function configurationNeeds(packages) {
+    return {
+        packages: new Set(packages),
+        uses: new Map([[PROJECT_OWNER, new Set(packages)]]),
+        unanswered: false,
+    };
+}
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }

package/dist/src/entry-point-gaps.js

@@ -13,9 +13,9 @@ const EVERY_CONVENTION = "every file it loads by its own convention beyond its c
 const UNREAD = "No rule reads it beyond a configuration file the file-name form or a string enters, so a " +
     "file only it loads is reported as never imported unless ts.entry_files or roots.patterns " +
     "names it.";
-/** Why a configuration's file names that are not relative literals are declined. */
-const NOT_RELATIVE = "A string of a configuration file names a file only where it is a literal starting with ./ " +
-    "or ../, so a file named otherwise is reported as never imported.";
+/** Why a configuration's file names that are not literals are declined. */
+const NOT_LITERAL = "A string of a configuration file names a file only where it is a literal, so a file a " +
+    "computed value names is reported as never imported.";
 /** The tools whose own conventions are not read. */
 const UNREAD_TOOLS = [
     "angular",
@@ -211,11 +211,6 @@ const PARTLY_ENTERED = [
         reason: "A testMatch that is not a string literal leaves the test-file set unknown, and an " +
             "unknown set enters nothing.",
     },
-    {
-        tool: "playwright",
-        convention: "a globalSetup or globalTeardown file named without a leading ./ or ../",
-        reason: NOT_RELATIVE,
-    },
     {
         tool: "playwright",
         convention: "the testDir and testMatch of an entry in projects",
@@ -272,20 +267,14 @@ const PARTLY_ENTERED = [
     },
     {
         tool: "vite",
-        convention: "an entry point its configuration names without a leading ./ or ../, or computes",
-        reason: NOT_RELATIVE,
-    },
-    {
-        tool: "vite",
-        convention: "the module scripts an index.html loads",
-        reason: "No rule reads an HTML file, so a script only index.html loads is reported as never " +
-            "imported unless ts.entry_files names it.",
+        convention: "an entry point its configuration computes",
+        reason: NOT_LITERAL,
     },
     {
         tool: "vitest",
-        convention: "the benchmark and type-test files",
-        reason: "A test file is one ts.test_files classifies, so a *.bench.* or *.test-d.* file is " +
-            "entered only where a configured pattern names it.",
+        convention: "the benchmark files",
+        reason: "A test file is one ts.test_files classifies, so a *.bench.* file is entered only " +
+            "where a configured pattern names it.",
     },
     {
         tool: "vitest",
@@ -293,11 +282,6 @@ const PARTLY_ENTERED = [
         reason: "A string is read against the configuration file's directory, so a setup file named " +
             "against a root the configuration moves is not entered.",
     },
-    {
-        tool: "vitest",
-        convention: "a setup file named without a leading ./ or ../",
-        reason: NOT_RELATIVE,
-    },
     {
         tool: "vitest",
         convention: "the test files a configuration's include member names",
@@ -306,8 +290,8 @@ const PARTLY_ENTERED = [
     },
     {
         tool: "webpack",
-        convention: "an entry point its configuration names without a leading ./ or ../, or computes",
-        reason: NOT_RELATIVE,
+        convention: "an entry point its configuration computes",
+        reason: NOT_LITERAL,
     },
 ];
 /** Two strings ordered bytewise. */

package/dist/src/entry-points.js

@@ -14,6 +14,7 @@ import { isArrayLiteralExpression, isAsExpression, isCallExpression, isExportAss
 import { SymbolFlags } from "@typescript/native/unstable/sync";
 import { configurationFiles, filesNamedBy, moduleStrings, } from "./configuration-files.js";
 import { globExpression } from "./glob.js";
+import { htmlEntries } from "./html-entries.js";
 import { dirnamePath, relativePath, resolvePath } from "./paths.js";
 import { UNANSWERED } from "./query.js";
 /** The extensions the test runner and the browser-test runner load a configuration from. */
@@ -406,5 +407,8 @@ export function entryPoints(project, files, testFiles, host, targetRoot, parse)
         }
         found.push(...workersOf(project, file, files));
     }
+    for (const { file, source } of htmlEntries(host, targetRoot, files, parse)) {
+        found.push({ file, rule: "html-entry", source, exports: true });
+    }
     return found;
 }

package/dist/src/exempt.js

@@ -92,12 +92,18 @@ export function computeExemptions(input, detectors, holding) {
 }
 /** The records of {@link computeExemptions}, beside the test-file evidence it set aside. */
 export function detectExemptions(input, detectors, holding) {
+    return heldRecords(evidenceRecords(input, detectors, holding.disabled), holding);
+}
+/**
+ * Every record one project's detectors found, one per piece of evidence, before the
+ * mode decides which of them hold: what {@link heldRecords} reads.
+ */
+export function evidenceRecords(input, detectors, disabled) {
     const visibility = new Map(input.held.symbols.map((symbol) => [symbol.id, symbol.visibility]));
     const found = [];
-    const inTestFiles = [];
     for (const exemptionClass of TS_EXEMPTION_CLASSES) {
         const detect = detectors.get(exemptionClass);
-        if (detect === undefined || holding.disabled.has(exemptionClass)) {
+        if (detect === undefined || disabled.has(exemptionClass)) {
             continue;
         }
         const allowed = typescriptVisibilityOf(exemptionClass);
@@ -105,17 +111,26 @@ export function detectExemptions(input, detectors, holding) {
             if (!retainable(allowed, visibility.get(evidence.id))) {
                 continue;
             }
-            const record = {
+            found.push({
                 id: evidence.id,
                 class: exemptionClass,
                 detail: evidence.detail,
                 site: evidence.site,
                 ...(evidence.whileLive === undefined ? {} : { whileLive: evidence.whileLive }),
-            };
-            if (holding.mode.production && holding.testFiles.has(evidence.site.path)) {
-                inTestFiles.push(record);
-                continue;
-            }
+            });
+        }
+    }
+    return found;
+}
+/** The records that hold under one mode, beside the evidence a production mode found in a test file. */
+export function heldRecords(records, holding) {
+    const found = [];
+    const inTestFiles = [];
+    for (const record of records) {
+        if (holding.mode.production && holding.testFiles.has(record.site.path)) {
+            inTestFiles.push(record);
+        }
+        else {
             found.push(record);
         }
     }

package/dist/src/file-facts.js

@@ -26,12 +26,10 @@ function lastLine(text) {
     return line;
 }
 /**
- * Every source file below the target root, in path order. A directory that cannot be
- * read is skipped, as discovery skips it, and a file that cannot be read is skipped
- * with it: a tree the analysis may not enter holds no file it can report.
+ * The path below the target root of every source file there, in path order. A directory
+ * that cannot be read is skipped, as discovery skips it.
  */
-export function sourceTree(host, targetRoot) {
-    const scopeOf = packageScope(host, targetRoot);
+export function sourcePaths(host, targetRoot) {
     const found = [];
     const pending = [""];
     for (let dir = pending.pop(); dir !== undefined; dir = pending.pop()) {
@@ -50,24 +48,29 @@ export function sourceTree(host, targetRoot) {
                 }
                 continue;
             }
-            if (!SOURCE_FILE.test(entry.name) || DECLARATION_FILE.test(entry.name)) {
-                continue;
-            }
-            let text;
-            try {
-                text = host.readFile(joinPath(targetRoot, path));
+            if (SOURCE_FILE.test(entry.name) && !DECLARATION_FILE.test(entry.name)) {
+                found.push(path);
             }
-            catch {
-                continue;
-            }
-            found.push({
-                path,
-                ref: renderRef(scopeOf(path), { of: "module" }),
-                endLine: lastLine(text),
-            });
         }
     }
-    return found.sort((a, b) => (a.path < b.path ? -1 : 1));
+    return found.sort((a, b) => (a < b ? -1 : 1));
+}
+/**
+ * Every source file below the target root, in path order. A file that cannot be read is
+ * skipped: a tree the analysis may not enter holds no file it can report.
+ */
+export function sourceTree(host, targetRoot) {
+    const scopeOf = packageScope(host, targetRoot);
+    return sourcePaths(host, targetRoot).flatMap((path) => {
+        let text;
+        try {
+            text = host.readFile(joinPath(targetRoot, path));
+        }
+        catch {
+            return [];
+        }
+        return [{ path, ref: renderRef(scopeOf(path), { of: "module" }), endLine: lastLine(text) }];
+    });
 }
 /** Whether one file changes what the program sees by being included in it. */
 function actsByInclusion(file) {

package/dist/src/findings/completion.js

@@ -39,23 +39,29 @@ function publishedIds(union) {
 }
 /**
  * The reachability class of one declaration of the run. A declaration of a library's
- * published API, a public member of a published type included, has callers outside the
- * target: it is `certain` where the run loaded every consumer the scope declared and
- * declared at least one, `probable` where it declared consumers and did not load them
- * all, and `possible` where it declared none. Whether the configuration declares the
- * consumer set complete decides nothing here. Every other declaration has every reference
- * in the loaded program, a private member and a `#private` name among them, and is
- * `certain`.
+ * published API, a public member of a published type included, is `certain` where the
+ * run loaded every consumer the scope declared and declared one, `probable` where one did
+ * not load, and `possible` where it declared none, whatever the configuration says of the
+ * consumer set. A declaration of test-support code that test code references, outside the
+ * test-of-dead-code rule, is `possible`. Every other declaration is `certain`.
  */
 function reachabilityClasses(input) {
     const published = publishedIds(input.swept.matrix.union);
+    const usedByTests = new Set(input.swept.sweep.candidates
+        .filter((candidate) => candidate.heldByTests === candidate.id)
+        .map((candidate) => candidate.id));
     const { declared } = input.boundary.consumers;
     const outside = declared.length === 0
         ? "possible"
         : everyDeclaredLoaded(input.boundary)
             ? "certain"
             : "probable";
-    return (id) => (published.has(id) ? outside : "certain");
+    return (id) => {
+        if (usedByTests.has(id)) {
+            return "possible";
+        }
+        return published.has(id) ? outside : "certain";
+    };
 }
 /**
  * The component each dead declaration of the run falls in, and none for a live one, with
@@ -117,6 +123,12 @@ export function completed(input, findings, kinds = KINDS) {
     const componentOf = findingComponents(swept, input.config.reporters.cascade);
     let minted = swept.sweep.components.length;
     const dead = new Set(swept.sweep.components.map((component) => component.id));
+    const fallingWith = new Map();
+    for (const { heldByTests } of swept.sweep.candidates) {
+        if (heldByTests !== undefined) {
+            fallingWith.set(heldByTests, (fallingWith.get(heldByTests) ?? 0) + 1);
+        }
+    }
     const done = findings.map((finding) => {
         const row = kinds.get(finding.code);
         if (row === undefined) {
@@ -134,8 +146,12 @@ export function completed(input, findings, kinds = KINDS) {
         const judged = !part && union.subject[at] === true ? symbol : undefined;
         const candidate = judged === undefined ? undefined : candidates.get(judged.id);
         const found = symbol === undefined || part ? undefined : componentOf(symbol.id);
-        // A test file's declaration is a component member only as a test of dead code.
-        if (candidate !== undefined && found === undefined && union.test[at] !== true) {
+        // A test file's declaration is a component member only as a test of dead code, and
+        // test code keeps the test-support code it references out of every component.
+        if (candidate !== undefined &&
+            found === undefined &&
+            union.test[at] !== true &&
+            candidate.heldByTests === undefined) {
             throw new Error(`${candidate.id} is judged dead and falls in no dead component`);
         }
         let component = found;
@@ -144,7 +160,7 @@ export function completed(input, findings, kinds = KINDS) {
             component = {
                 id: componentId(minted),
                 root: true,
-                symbolCount: 1,
+                symbolCount: symbol?.kind === "interface" ? (fallingWith.get(symbol.id) ?? 1) : 1,
                 deletableLines: 0,
             };
         }

package/dist/src/findings/interfaces.js

@@ -26,7 +26,6 @@ function indexed(input) {
     return {
         symbolOf,
         inTest: (id) => union.test[union.at(id)] === true,
-        inSupport: (id) => union.support[union.at(id)] === true,
         candidateOf: (id) => candidates.get(id),
         implementationsOf: (id) => [...(input.implementations.classes.get(id) ?? [])]
             .map(symbolOf)
@@ -56,17 +55,14 @@ function findingOf(code, symbol, message, implementations) {
  * interface, whose members fall with it unreported; and `DS1203`, a method of a live
  * interface no reference names, unless it is a marker, a method whose every
  * implementation has an empty body. A test file's declaration is neither kind's
- * subject, because a production sweep counts none of the references it can have, and
- * neither is a test-support declaration test code references, which that code keeps live.
+ * subject, because a production sweep counts none of the references it can have.
  */
 export const interfaces = (input) => {
     const run = indexed(input);
     const found = [];
     for (const candidate of input.swept.sweep.candidates) {
         const symbol = run.symbolOf(candidate.id);
-        if (symbol === undefined ||
-            run.inTest(candidate.id) ||
-            (run.inSupport(candidate.id) && candidate.testRefs > 0)) {
+        if (symbol === undefined || run.inTest(candidate.id)) {
             continue;
         }
         if (symbol.kind === "interface") {

package/dist/src/findings/intra-function.js

@@ -1,5 +1,6 @@
 import { KINDS } from "../kinds.js";
 import { UNUSED_PARAMETER, UNUSED_RESULT } from "../intra-function-parts.js";
+import { reachedWithTheTests } from "../sweep.js";
 /** A list of rules as a sentence names them. */
 function spelled(rules) {
     if (rules.length < 2) {
@@ -39,12 +40,23 @@ function reported(input, part, callersUnknown) {
 /**
  * The findings of the intra-function family, `DS1800` to `DS1899`, each about a part of
  * the declaration its reference names, at the part's own position, whatever the sweep
- * decided about that declaration. Each message names the other rules that report the
- * kind, as the vocabulary lists them, and so does the finding's details.
+ * decided about a production declaration. A part of test code is reported only where the
+ * run that counts test references reaches its declaration and that is no test of dead
+ * code. Each message and the finding's details name the other rules that report the kind.
  */
 export const intraFunction = (input) => {
     const union = input.swept.matrix.union;
     const byId = new Map(union.symbols.map((symbol) => [symbol.id, symbol]));
+    const reached = reachedWithTheTests(union, [
+        ...input.swept.exempt.map((record) => record.id),
+        ...input.swept.heldByUnanswered,
+    ]);
+    const testsOfDeadCode = new Set(input.swept.sweep.candidates.filter((one) => one.testOfDeadCode).map((one) => one.id));
+    const judged = (id) => {
+        const at = union.at(id);
+        const testCode = union.test[at] === true || union.support[at] === true;
+        return !testCode || (reached[at] === true && !testsOfDeadCode.has(id));
+    };
     const unknown = new Set(union.rooted.flatMap((root) => {
         const symbol = union.symbols[root.at];
         return symbol === undefined ? [] : [symbol.id];
@@ -68,7 +80,7 @@ export const intraFunction = (input) => {
     for (const part of input.intraFunction.parts) {
         const declaration = byId.get(part.declaration);
         const overlap = KINDS.get(part.code)?.overlap ?? [];
-        if (declaration === undefined || !reported(input, part, unknown)) {
+        if (declaration === undefined || !judged(declaration.id) || !reported(input, part, unknown)) {
             continue;
         }
         found.push({

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

@@ -40,9 +40,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, member of a
- * dead container or enum member nothing names, nor a test-support declaration test code
- * references; then deprecation, a test reference, and the unreferenced codes, an
- * unimportable unused export being the unreachable kind's.
+ * dead container 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.
  */
 function codeOf(judged) {
     const { candidate, symbol } = judged;
@@ -56,8 +56,8 @@ function codeOf(judged) {
     if (symbol.kind === "enum-member" && !referenced) {
         return undefined;
     }
-    if (judged.support && candidate.testRefs > 0) {
-        return undefined;
+    if (candidate.heldByTests === candidate.id) {
+        return "DS1004";
     }
     if (candidate.productionRefs === 0 && judged.deprecated) {
         return "DS1006";
@@ -180,7 +180,6 @@ function familyFindings(input, fallen) {
             candidate,
             symbol,
             test: union.test[at] === true,
-            support: union.support[at] === true,
             containerDead: containerDead && !fallen,
             deprecated: input.deprecated.has(symbol.id),
             unreachable: unreachable.has(symbol.id),

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

@@ -168,7 +168,8 @@ function unreachable(facts, at, symbol, candidate, input) {
  * The visibility-narrowing family over one run: `DS1101`, `DS1103` and `DS1104`. A finding
  * about a symbol a declared cross-language edge names is reported here like any other, and
  * the edge's evaluation then holds it pending, because the edge stands for a reference from
- * outside the file and the package whose use is decided in the other language.
+ * outside the file and the package whose use is decided in the other language. A
+ * declaration of a generated file is reported only where generated files are included.
  */
 export function narrowings(input) {
     const facts = factsOf(input.swept.matrix.union);
@@ -176,8 +177,12 @@ export function narrowings(input) {
     const closed = input.config.consumersComplete && declared.every((id) => loaded.includes(id));
     const world = { closed, writeOnly: writeOnlyDeclarations(input) };
     const candidates = new Map(input.swept.sweep.candidates.map((candidate) => [candidate.id, candidate]));
+    const generated = input.config.analysis.generatedFiles === "include" ? undefined : input.files.generated;
     const findings = [];
     facts.graph.symbols.forEach((symbol, at) => {
+        if (generated?.has(symbol.position.path) === true) {
+            return;
+        }
         const candidate = candidates.get(symbol.id);
         const found = candidate === undefined
             ? narrowing(facts, at, symbol, world)