@cplieger/deadset-ts 5.0.0 → 5.1.0

package/dist/src/conventions.js

@@ -5,15 +5,16 @@
  * 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, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAccessExpression, isPropertyAssignment, isSatisfiesExpression, isShorthandPropertyAssignment, isSpreadAssignment, isStringLiteral, isVariableStatement, SyntaxKind, } from "@typescript/native/unstable/ast";
+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 { lineOf } from "./component-files.js";
 import { CONVENTION_ROWS, } from "./convention-rows.js";
 import { globExpression } from "./glob.js";
 import { dirnamePath, joinPath, normalizePath, relativePath, resolvePath } from "./paths.js";
 import { satisfies } from "./version-range.js";
+/** The sections an installed package is required by, so its absence fails the run. */
+const REQUIRED_SECTIONS = ["dependencies", "devDependencies"];
 const DEPENDENCY_SECTIONS = [
-    "dependencies",
-    "devDependencies",
+    ...REQUIRED_SECTIONS,
     "peerDependencies",
     "optionalDependencies",
 ];
@@ -28,11 +29,11 @@ function readJSON(host, path) {
         return undefined;
     }
 }
-function declares(manifest, name) {
+function declares(manifest, name, sections = DEPENDENCY_SECTIONS) {
     if (!isRecord(manifest)) {
         return false;
     }
-    return DEPENDENCY_SECTIONS.some((section) => {
+    return sections.some((section) => {
         const held = manifest[section];
         return isRecord(held) && Object.hasOwn(held, name);
     });
@@ -70,20 +71,29 @@ function unwrapped(node) {
     }
     return at;
 }
-/** The key one property is written with, where it is written as a name or a literal. */
+/** The key one property is written with, where it is written as a name or as literal text. */
 function keyOf(property) {
     if (!isPropertyAssignment(property) && !isShorthandPropertyAssignment(property)) {
         return undefined;
     }
     const { name } = property;
-    if (isComputedPropertyName(name)) {
-        return undefined;
-    }
-    if (isIdentifier(name) || isStringLiteral(name) || isNoSubstitutionTemplateLiteral(name)) {
-        return name.text;
+    const key = isComputedPropertyName(name) ? name.expression : name;
+    if ((isIdentifier(key) && key === name) ||
+        isStringLiteral(key) ||
+        isNoSubstitutionTemplateLiteral(key)) {
+        return key.text;
     }
     return undefined;
 }
+/** Whether one member's computed name is no literal, so it may set any key. */
+function computesKey(member) {
+    const name = member.name;
+    if (name === undefined || !isComputedPropertyName(name)) {
+        return false;
+    }
+    const key = name.expression;
+    return !(isStringLiteral(key) || isNumericLiteral(key) || isNoSubstitutionTemplateLiteral(key));
+}
 /** The values one file's top-level variable declarations bind, by name. */
 function declaredValues(file) {
     const values = new Map();
@@ -134,6 +144,67 @@ function defaultExports(file) {
     }
     return found;
 }
+/** The declarations whose name is a binding of the scope they are written in. */
+const BINDING_KINDS = new Set([
+    SyntaxKind.VariableDeclaration,
+    SyntaxKind.Parameter,
+    SyntaxKind.BindingElement,
+    SyntaxKind.FunctionDeclaration,
+    SyntaxKind.ClassDeclaration,
+    SyntaxKind.ImportClause,
+    SyntaxKind.ImportSpecifier,
+    SyntaxKind.NamespaceImport,
+    SyntaxKind.ImportEqualsDeclaration,
+]);
+/** Whether one file declares a binding named `require` at any depth, which shadows the global. */
+function declaresRequire(file) {
+    let found = false;
+    const visit = (node) => {
+        const name = node.name;
+        if (name !== undefined &&
+            isIdentifier(name) &&
+            name.text === "require" &&
+            BINDING_KINDS.has(node.kind)) {
+            found = true;
+        }
+        if (!found) {
+            node.forEachChild(visit);
+        }
+    };
+    file.forEachChild(visit);
+    return found;
+}
+/**
+ * The top-level `const`, `let` and `var` declarations that bind a `require` of one module,
+ * written with the module's name as its one string-literal argument, in a file that
+ * declares no binding named `require`: each binds as an import of the module does.
+ */
+function requireBindings(file, module) {
+    const found = [];
+    for (const statement of file.statements) {
+        if (!isVariableStatement(statement)) {
+            continue;
+        }
+        for (const declaration of statement.declarationList.declarations) {
+            const value = declaration.initializer === undefined ? undefined : unwrapped(declaration.initializer);
+            const [argument, ...rest] = value !== undefined && isCallExpression(value) ? value.arguments : [];
+            if (value === undefined ||
+                !isCallExpression(value) ||
+                !isIdentifier(value.expression) ||
+                value.expression.text !== "require" ||
+                argument === undefined ||
+                rest.length > 0 ||
+                !isStringLiteral(argument) ||
+                argument.text !== module) {
+                continue;
+            }
+            if (isIdentifier(declaration.name) || isObjectBindingPattern(declaration.name)) {
+                found.push(declaration.name);
+            }
+        }
+    }
+    return found.length > 0 && declaresRequire(file) ? [] : found;
+}
 /**
  * The first argument of every call one file makes to one module's export, through a
  * named or a namespace import; `undefined` for a call with no argument.
@@ -141,6 +212,24 @@ function defaultExports(file) {
 function optionsArguments(file, call) {
     const names = new Set();
     const namespaces = new Set();
+    for (const name of requireBindings(file, call.module)) {
+        if (isIdentifier(name)) {
+            namespaces.add(name.text);
+            continue;
+        }
+        for (const element of name.elements) {
+            const local = element.name;
+            const exported = element.propertyName ?? local;
+            if (element.dotDotDotToken === undefined &&
+                local !== undefined &&
+                isIdentifier(local) &&
+                exported !== undefined &&
+                (isIdentifier(exported) || isStringLiteral(exported)) &&
+                exported.text === call.export) {
+                names.add(local.text);
+            }
+        }
+    }
     for (const statement of file.statements) {
         const bindings = isImportDeclaration(statement)
             ? statement.importClause?.namedBindings
@@ -207,7 +296,7 @@ function objectOf(node, declared, throughCalls, seen = new Set()) {
 function readPath(object, keys, values) {
     const [key, ...rest] = keys;
     for (const member of object.properties) {
-        if (isSpreadAssignment(member)) {
+        if (isSpreadAssignment(member) || computesKey(member)) {
             return member;
         }
         if (keyOf(member) !== key) {
@@ -352,6 +441,7 @@ function compare(a, b) {
 export function readConventions(host, parse, manifests, disabled, rows = CONVENTION_ROWS) {
     const applied = [];
     const globs = [];
+    const generated = [];
     const failures = [];
     for (const manifest of manifests) {
         const declared = readJSON(host, joinPath(manifest.dir, "package.json"));
@@ -366,7 +456,7 @@ export function readConventions(host, parse, manifests, disabled, rows = CONVENT
             }
             const version = versions.get(row.package);
             if (version === undefined) {
-                if (missing.has(row.package)) {
+                if (missing.has(row.package) || !declares(declared, row.package, REQUIRED_SECTIONS)) {
                     continue;
                 }
                 missing.add(row.package);
@@ -413,6 +503,9 @@ export function readConventions(host, parse, manifests, disabled, rows = CONVENT
             const excludes = [
                 ...new Set((row.excludes ?? []).flatMap((one) => expand(one, resolved))),
             ].map(globExpression);
+            for (const below of new Set((row.generated ?? []).flatMap((one) => expand(one, resolved)))) {
+                generated.push({ dir: manifest.dir, row: row.name, below });
+            }
             for (const glob of new Set(row.entries.flatMap((entry) => expand(entry, resolved)))) {
                 globs.push({
                     dir: manifest.dir,
@@ -427,7 +520,23 @@ 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, failures };
+    return { applied: unique, globs, generated, failures };
+}
+/**
+ * Every own file of one project below a directory an applied row names as generated, by
+ * its path below the target root, with the name of the first such row.
+ */
+export function generatedFiles(conventions, files) {
+    const found = new Map();
+    for (const { dir, row, below } of conventions.generated) {
+        const root = joinPath(dir, below);
+        for (const [path, file] of files.byPath) {
+            if (!found.has(path) && relativePath(root, file.fileName) !== undefined) {
+                found.set(path, row);
+            }
+        }
+    }
+    return found;
 }
 /** Every own file of one project an applied row's globs match, once per row. */
 export function conventionEntries(conventions, files) {

package/dist/src/dependencies.js

@@ -187,7 +187,7 @@ function bindingsOf(node) {
  * shadows the name is not one. A string of a configuration file uses each dependency
  * the manifest beside the file declares that it spells.
  */
-export function projectNeeds(project, held, host, targetRoot) {
+export function projectNeeds(project, held, host, targetRoot, parse) {
     const programPackages = new Set();
     for (const name of project.program.getSourceFileNames()) {
         const named = packageOfPath(name);
@@ -225,7 +225,7 @@ export function projectNeeds(project, held, host, targetRoot) {
         }
         return names;
     };
-    const configuration = configurationFiles(host, targetRoot, sourceFilesOf(project, targetRoot));
+    const configuration = configurationFiles(host, targetRoot, sourceFilesOf(project, targetRoot), parse);
     for (const { file } of configuration.modules) {
         const names = declaredAt(file.fileName);
         for (const { node, text } of moduleStrings(file)) {
@@ -238,6 +238,12 @@ export function projectNeeds(project, held, host, targetRoot) {
             use([PROJECT_OWNER], dependenciesNamed(text, names));
         }
     }
+    for (const { file, manifestDir } of configuration.outside) {
+        const names = declaredAt(joinPath(manifestDir, "package.json"));
+        for (const { text } of moduleStrings(file)) {
+            use([PROJECT_OWNER], dependenciesNamed(text, names));
+        }
+    }
     return { packages, uses, unanswered };
 }
 /** The declarations of the inventory a use written at one node belongs to. */

package/dist/src/destructuring.js

@@ -7,7 +7,7 @@
  */
 import { isArrayLiteralExpression, isBinaryExpression, isForOfStatement, isIdentifier, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectBindingPattern, isObjectLiteralExpression, isParameterDeclaration, isParenthesizedExpression, isPropertyAssignment, isShorthandPropertyAssignment, isStringLiteral, SyntaxKind, } from "@typescript/native/unstable/ast";
 import { TypeFlags } from "@typescript/native/unstable/sync";
-import { isAnswered, UNANSWERED } from "./query.js";
+import { isAnswered, propertyTables, UNANSWERED, } from "./query.js";
 /** The text a property name spells, or `undefined` for a computed name. */
 function nameText(node) {
     if (node === undefined) {
@@ -151,7 +151,7 @@ function sourceOf(target) {
  * read once per type for the whole project, since one type is destructured in many
  * places and a table answers every name of it.
  */
-export function destructuring(project, cap) {
+export function destructuring(project, cap, properties = propertyTables(project.queries)) {
     const queries = project.queries;
     const tables = new Map();
     let patternBatches = 0;
@@ -163,10 +163,10 @@ export function destructuring(project, cap) {
         }
         let table = new Map();
         if ((type.flags & TypeFlags.AnyOrUnknown) === 0) {
-            patternLookups += 1;
-            const properties = queries.propertiesOf(type);
-            table = isAnswered(properties)
-                ? new Map(properties.map((property) => [property.name, property]))
+            const read = properties.of(type);
+            patternLookups += read.asked ? 1 : 0;
+            table = isAnswered(read.properties)
+                ? new Map(read.properties.map((property) => [property.name, property]))
                 : UNANSWERED;
         }
         tables.set(type.id, table);

package/dist/src/entry-points.js

@@ -12,7 +12,7 @@
  */
 import { isArrayLiteralExpression, isAsExpression, isCallExpression, isExportAssignment, isIdentifier, isMetaProperty, isNewExpression, isNoSubstitutionTemplateLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAccessExpression, isPropertyAssignment, isSatisfiesExpression, isStringLiteral, } from "@typescript/native/unstable/ast";
 import { SymbolFlags } from "@typescript/native/unstable/sync";
-import { configurationFiles, filesNamedBy, moduleStrings } from "./configuration-files.js";
+import { configurationFiles, filesNamedBy, moduleStrings, } from "./configuration-files.js";
 import { globExpression } from "./glob.js";
 import { dirnamePath, relativePath, resolvePath } from "./paths.js";
 import { UNANSWERED } from "./query.js";
@@ -169,8 +169,8 @@ function isBrowserTestConfig(name) {
  * with what it exports, and each own file a relative string of a configuration module
  * or a JSON configuration file names, read against that file's directory.
  */
-function configurationEntries(host, targetRoot, files) {
-    const { modules, documents } = configurationFiles(host, targetRoot, files);
+function configurationEntries(host, targetRoot, files, parse) {
+    const { modules, documents, outside } = configurationFiles(host, targetRoot, files, parse);
     const found = [];
     const strings = (dir, texts) => {
         for (const text of texts) {
@@ -186,6 +186,9 @@ function configurationEntries(host, targetRoot, files) {
     for (const document of documents) {
         strings(dirnamePath(document.path), document.strings);
     }
+    for (const { file } of outside) {
+        strings(dirnamePath(file.fileName), moduleStrings(file).map((one) => one.text));
+    }
     return found;
 }
 /**
@@ -381,8 +384,8 @@ function workersOf(project, file, files) {
  * file's path below the target root; a file one of them matches is a test file the
  * runner executes.
  */
-export function entryPoints(project, files, testFiles, host, targetRoot) {
-    const found = [...configurationEntries(host, targetRoot, files)];
+export function entryPoints(project, files, testFiles, host, targetRoot, parse) {
+    const found = [...configurationEntries(host, targetRoot, files, parse)];
     const tests = testFiles.map((pattern) => ({ pattern, expression: globExpression(pattern) }));
     for (const [path, file] of files.byPath) {
         const name = basename(path);

package/dist/src/exempt-classes.js

@@ -26,7 +26,12 @@ export const EXEMPTION_CLASSES = [
         confidence: "certain",
         typescriptVisibility: { private: false, privateName: false },
     },
-    { class: "generated-file", languages: ["go"], confidence: "certain" },
+    {
+        class: "generated-file",
+        languages: ["go", "ts"],
+        confidence: "certain",
+        typescriptVisibility: { private: true, privateName: false },
+    },
     { class: "linkname-cgo-asm-plugin", languages: ["go"], confidence: "certain" },
     {
         class: "template-field",

package/dist/src/exempt.js

@@ -88,8 +88,13 @@ function detected(exemptionClass, detect, input) {
  * test file makes is none there.
  */
 export function computeExemptions(input, detectors, holding) {
+    return detectExemptions(input, detectors, holding).records;
+}
+/** The records of {@link computeExemptions}, beside the test-file evidence it set aside. */
+export function detectExemptions(input, detectors, holding) {
     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)) {
@@ -100,19 +105,21 @@ export function computeExemptions(input, detectors, holding) {
             if (!retainable(allowed, visibility.get(evidence.id))) {
                 continue;
             }
-            if (holding.mode.production && holding.testFiles.has(evidence.site.path)) {
-                continue;
-            }
-            found.push({
+            const record = {
                 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;
+            }
+            found.push(record);
         }
     }
-    return exemptionsOf(found);
+    return { records: exemptionsOf(found), inTestFiles };
 }
 /** Two strings ordered bytewise. */
 function compare(a, b) {
@@ -160,24 +167,21 @@ function byDeclaration(records) {
     return grouped;
 }
 /**
- * The records that held back a declaration some configuration of the run would
- * otherwise judge dead: each configuration's graph is swept once more with no
- * exemption and the marks it was given, and a record is retained when one of those
- * sweeps judged its declaration a candidate. A record that holds a declaration back in
- * one configuration is retained whatever another configuration answers about it, as a
- * run of that configuration alone would report the declaration without it. A record
- * on a declaration that a relation or a mark holds live in every configuration held
- * nothing back. The order is the declarations' site order, and for one declaration
- * the input's.
+ * The records that held back a declaration: one some configuration's graph, swept
+ * again with no exemption and its marks, judges a candidate, whatever another
+ * configuration answers, or one in `writeOnly`, which the run would report as written
+ * and never read without the record's read. A declaration a relation or a mark holds
+ * live in every configuration is held back by no record. The order is the
+ * declarations' site order, and for one declaration the input's.
  */
-export function retainedIn(matrix, input) {
+export function retainedIn(matrix, input, writeOnly = new Set()) {
     const exempt = input.exempt ?? [];
     if (exempt.length === 0) {
         return [];
     }
     const bare = { marked: input.marked, mode: input.mode };
     const dead = new Set(matrix.graphs.flatMap((graph) => sweep(graph, bare).candidates.map((candidate) => candidate.id)));
-    const held = byDeclaration(exempt.filter((record) => dead.has(record.id)));
+    const held = byDeclaration(exempt.filter((record) => dead.has(record.id) || writeOnly.has(record.id)));
     return matrix.union.symbols.flatMap((symbol) => held.get(symbol.id) ?? []);
 }
 /**

package/dist/src/findings/completion.js

@@ -116,7 +116,8 @@ export function completed(input, findings, kinds = KINDS) {
     const classOf = reachabilityClasses(input);
     const componentOf = findingComponents(swept, input.config.reporters.cascade);
     let minted = swept.sweep.components.length;
-    return findings.map((finding) => {
+    const dead = new Set(swept.sweep.components.map((component) => component.id));
+    const done = findings.map((finding) => {
         const row = kinds.get(finding.code);
         if (row === undefined) {
             throw new Error(`${finding.code} names no live row of the issue-kind vocabulary`);
@@ -151,6 +152,7 @@ export function completed(input, findings, kinds = KINDS) {
             ? union.made[at]
             : { production: candidate.productionRefs, test: candidate.testRefs };
         const reachabilityClass = judged === undefined ? "certain" : classOf(judged.id);
+        const generated = input.files.generated?.has(finding.position.path) === true;
         return {
             code: finding.code,
             kind: row.name,
@@ -161,7 +163,7 @@ export function completed(input, findings, kinds = KINDS) {
             confidence: capped(reachabilityClass, row.maxClass),
             ...(candidate === undefined ? {} : { livenessRelation: candidate.relation }),
             testOnly: judged !== undefined && counts?.production === 0 && counts.test > 0,
-            generated: false,
+            generated,
             component,
             retainedBy: [],
             configurations: candidate?.configurations ??
@@ -169,12 +171,34 @@ export function completed(input, findings, kinds = KINDS) {
                     ? swept.matrix.configurations
                     : (swept.matrix.heldIn[at] ?? swept.matrix.configurations)),
             consumersLoaded: input.boundary.consumers.loaded,
-            fixability: row.fixability,
+            fixability: generated ? "none" : row.fixability,
             severity: severityOf(input, finding.code, row.defaultSeverity),
             message: finding.message,
             details: finding.details ?? {},
         };
     });
+    return componentCapped(done, dead);
+}
+/**
+ * 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.
+ */
+function componentCapped(findings, dead) {
+    const lowest = new Map();
+    for (const finding of findings) {
+        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));
+        }
+    }
+    return findings.map((finding) => {
+        const cap = lowest.get(finding.component.id);
+        return cap === undefined || RANK[cap] >= RANK[finding.confidence]
+            ? finding
+            : { ...finding, confidence: cap };
+    });
 }
 /** Whether the dials withhold a finding by its own severity or confidence. */
 function dialed(finding, minConfidence) {

package/dist/src/findings/interfaces.js

@@ -26,6 +26,7 @@ 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)
@@ -55,14 +56,17 @@ 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.
+ * 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.
  */
 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)) {
+        if (symbol === undefined ||
+            run.inTest(candidate.id) ||
+            (run.inSupport(candidate.id) && candidate.testRefs > 0)) {
             continue;
         }
         if (symbol.kind === "interface") {

package/dist/src/findings/reads-and-writes.js

@@ -36,18 +36,55 @@ function findingAbout(symbol, code, message, details) {
 }
 /**
  * Whether one declaration is a subject of the write-only kind: a module-level variable,
- * or a class member that is state rather than code. A getter or a setter is code, so a
- * store into one runs it.
+ * a member of an object type, or a class member that is state rather than code. A getter
+ * or a setter is code, so a store into one runs it.
  */
 function writable(run, symbol) {
-    if (symbol.kind === "variable") {
+    if (symbol.kind === "variable" || symbol.kind === "type-member") {
         return true;
     }
     return symbol.kind === "class-member" && !run.input.stores.accessors.has(symbol.id);
 }
+/** The reader's word for each kind of the write-only kind's subject. */
+const SUBJECT_WORDS = {
+    variable: "variable",
+    "class-member": "member",
+    "type-member": "type member",
+};
+/**
+ * The type parameters of one member's declaring type that only the member names, which
+ * deleting the member leaves unused.
+ */
+function parametersOnlyNamedBy(run, namedBy, member) {
+    return [...run.symbols.values()]
+        .filter((symbol) => {
+        const from = namedBy.get(symbol.id);
+        return (symbol.kind === "type-parameter" &&
+            symbol.parent === member.parent &&
+            from?.size === 1 &&
+            from.has(member.id));
+    })
+        .map((symbol) => symbol.name);
+}
+/** What one write-only finding says, the declarations its deletion takes with it included. */
+function writeOnlyMessage(run, namedBy, symbol, held) {
+    const writes = held.writes.length === 1 ? "once" : `at ${String(held.writes.length)} positions`;
+    const read = run.input.stores.readInTests.has(symbol.id)
+        ? "read only from test files"
+        : "never read";
+    const cascade = [
+        ...parametersOnlyNamedBy(run, namedBy, symbol).map((name) => `type parameter ${name}`),
+        ...[...held.alone].sort().map((name) => `import ${name}`),
+    ];
+    const word = SUBJECT_WORDS[symbol.kind] ?? "member";
+    const message = `${word} ${symbol.name} is written ${writes} and ${read}`;
+    return cascade.length === 0
+        ? message
+        : `${message}, and deleting it with its writes deletes ${cascade.join(" and ")} too`;
+}
 /**
- * `DS1301`: a module-level variable or a class member the counted references store into
- * and never read, named with every position written.
+ * `DS1301`: a module-level variable, a type member or a class member the counted
+ * references store into and never read, named with every position written.
  *
  * The subject is a live declaration: a store is a reference, so the sweep holds a
  * written one live and its candidates are never this kind's. Every reference that is
@@ -60,7 +97,7 @@ function writeOnlySymbols(run) {
     for (const reference of stores.references) {
         let held = uses.get(reference.to);
         if (held === undefined) {
-            held = { writes: [], reads: 0 };
+            held = { writes: [], reads: 0, alone: new Set() };
             uses.set(reference.to, held);
         }
         // A consumer's store is written at a position no report of the target can name, so
@@ -69,12 +106,21 @@ function writeOnlySymbols(run) {
             held.reads += 1;
             continue;
         }
+        for (const name of reference.alone ?? []) {
+            held.alone.add(name);
+        }
         const at = reference.position;
         const key = positionKey(at);
         if (!held.writes.some((written) => positionKey(written) === key)) {
             held.writes.push({ path: at.path, line: at.line, column: at.column, endLine: at.line });
         }
     }
+    const namedBy = new Map();
+    for (const reference of stores.references) {
+        if (run.symbols.get(reference.to)?.kind === "type-parameter") {
+            namedBy.set(reference.to, (namedBy.get(reference.to) ?? new Set()).add(reference.from));
+        }
+    }
     const found = [];
     for (const symbol of matrix.union.symbols) {
         const held = uses.get(symbol.id);
@@ -86,9 +132,7 @@ function writeOnlySymbols(run) {
             run.candidates.has(symbol.id)) {
             continue;
         }
-        const writes = held.writes.length === 1 ? "once" : `at ${String(held.writes.length)} positions`;
-        const word = symbol.kind === "variable" ? "variable" : "member";
-        found.push(findingAbout(symbol, "DS1301", `${word} ${symbol.name} is written ${writes} and never read`, {
+        found.push(findingAbout(symbol, "DS1301", writeOnlyMessage(run, namedBy, symbol, held), {
             writePositions: held.writes,
         }));
     }