@cplieger/deadset-ts 5.0.0 → 5.1.1

package/dist/src/exempt.js

@@ -88,11 +88,22 @@ 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) {
+    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 = [];
     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);
@@ -100,9 +111,6 @@ 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({
                 id: evidence.id,
                 class: exemptionClass,
@@ -112,7 +120,21 @@ export function computeExemptions(input, detectors, holding) {
             });
         }
     }
-    return exemptionsOf(found);
+    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);
+        }
+    }
+    return { records: exemptionsOf(found), inTestFiles };
 }
 /** Two strings ordered bytewise. */
 function compare(a, b) {
@@ -160,24 +182,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/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

@@ -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,
         }));
     }

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

@@ -114,6 +114,43 @@ function messageOf(code, judged) {
     }
     return `${subject} has no reference in the target`;
 }
+/**
+ * The members nothing writes or reads that are brands: each names a type parameter of
+ * its declaring type that no other part of the declaration names, other than another
+ * such member. They are what make two instantiations of the type distinct types, so
+ * deleting them would let one instantiation stand for another.
+ */
+function brandMembers(input) {
+    const union = input.swept.matrix.union;
+    const unreferenced = new Map(input.swept.sweep.candidates
+        .filter((candidate) => candidate.productionRefs + candidate.testRefs === 0)
+        .map((candidate) => [candidate.id, candidate]));
+    const namedBy = new Map();
+    for (const reference of input.stores.references) {
+        const to = union.symbols[union.at(reference.to)];
+        if (to?.kind === "type-parameter") {
+            namedBy.set(to.id, (namedBy.get(to.id) ?? new Set()).add(reference.from));
+        }
+    }
+    const brands = new Set();
+    for (const [parameter, from] of namedBy) {
+        const owner = union.symbols[union.at(parameter)]?.parent;
+        const members = [...from].map((id) => union.symbols[union.at(id)]);
+        if (members.every((member) => member !== undefined &&
+            member.parent === owner &&
+            BRANDS.has(member.kind) &&
+            unreferenced.has(member.id))) {
+            for (const member of members) {
+                if (member !== undefined) {
+                    brands.add(member.id);
+                }
+            }
+        }
+    }
+    return brands;
+}
+/** The kinds of member a brand is: a data member of a type or of a class. */
+const BRANDS = new Set(["type-member", "class-member"]);
 /** The findings of the unused-declarations family, `DS1000` to `DS1099`. */
 export const unusedDeclarations = (input) => familyFindings(input, false);
 /**
@@ -127,6 +164,7 @@ function familyFindings(input, fallen) {
     const union = input.swept.matrix.union;
     const dead = new Set(input.swept.sweep.candidates.map((candidate) => candidate.id));
     const unreachable = unreachableExports(input);
+    let brands;
     const found = [];
     for (const candidate of input.swept.sweep.candidates) {
         const at = union.at(candidate.id);
@@ -148,7 +186,8 @@ function familyFindings(input, fallen) {
             unreachable: unreachable.has(symbol.id),
         };
         const code = codeOf(judged);
-        if (code === undefined) {
+        if (code === undefined ||
+            (code === "DS1003" && (brands ??= brandMembers(input)).has(symbol.id))) {
             continue;
         }
         const endLine = Math.max(symbol.position.line, symbol.endLine);

package/dist/src/generated-file.js

@@ -0,0 +1,24 @@
+/**
+ * The generated-file class on TypeScript: every declaration in a file below a directory
+ * an applied convention row names as generated is retained, because the framework owns
+ * the file and a deletion there is undone at the next generation.
+ */
+/** The generated-file detector, recording each file's first line. */
+export function generatedFile(input) {
+    const generated = input.generated;
+    if (generated === undefined || generated.size === 0) {
+        return [];
+    }
+    return input.held.symbols.flatMap((symbol) => {
+        const row = generated.get(symbol.position.path);
+        return symbol.kind === "file" || row === undefined
+            ? []
+            : [
+                {
+                    id: symbol.id,
+                    detail: `generated below a directory the convention row ${row} names`,
+                    site: { path: symbol.position.path, line: 1, column: 1 },
+                },
+            ];
+    });
+}

package/dist/src/graph.js

@@ -94,7 +94,7 @@ export function graphOf(symbols, references, roots, testFiles, supportFiles = []
             }
         }
         const edge = { to, test: reference.test, evaluation: reference.use === "evaluation" };
-        if (reference.consumer !== undefined) {
+        if (reference.consumer !== undefined || reference.unheld === true) {
             consumed.push(edge);
             continue;
         }

package/dist/src/interface-satisfaction.js

@@ -12,19 +12,13 @@
  * the contextual lookup has none, so it is asked only of a value whose type is a class
  * of the target, and each distinct pair, interface and class is asked once.
  */
-import { isArrayLiteralExpression, isArrowFunction, isAsExpression, isBinaryExpression, isCallExpression, isClassDeclaration, isClassExpression, isClassStaticBlockDeclaration, isConditionalExpression, isFunctionDeclaration, isFunctionExpression, isGetAccessorDeclaration, isHeritageClause, isIdentifier, isMethodDeclaration, isNewExpression, isObjectLiteralExpression, isParameterDeclaration, isParenthesizedExpression, isPropertyAssignment, isPropertyDeclaration, isReturnStatement, isSatisfiesExpression, isSetAccessorDeclaration, isShorthandPropertyAssignment, isSpreadElement, isVariableDeclaration, ModifierFlags, SyntaxKind, } from "@typescript/native/unstable/ast";
+import { isClassDeclaration, isClassExpression, isClassStaticBlockDeclaration, isFunctionDeclaration, isFunctionExpression, isGetAccessorDeclaration, isHeritageClause, isMethodDeclaration, isObjectLiteralExpression, isSetAccessorDeclaration, ModifierFlags, SyntaxKind, } from "@typescript/native/unstable/ast";
 import { SymbolFlags } from "@typescript/native/unstable/sync";
 import { aliasChains } from "./alias-chain.js";
 import { nodeKey } from "./inventory.js";
 import { renderPosition } from "./position.js";
 import { must } from "./query.js";
-/** The operators of an assignment whose right side is stored into the left side's type. */
-const STORES = new Set([
-    SyntaxKind.EqualsToken,
-    SyntaxKind.QuestionQuestionEqualsToken,
-    SyntaxKind.BarBarEqualsToken,
-    SyntaxKind.AmpersandAmpersandEqualsToken,
-]);
+import { handedOn, valuesOf } from "./value-flow.js";
 /** Whether one node declares a static member, whose `this` is the class itself. */
 function isStatic(node) {
     const flags = node.modifierFlags ?? 0;
@@ -37,66 +31,6 @@ function isObjectLiteralMethod(node) {
         isSetAccessorDeclaration(node)) &&
         isObjectLiteralExpression(node.parent));
 }
-/** Whether a declaration writes its type, so its initializer is read in that type's context. */
-function writesType(node) {
-    return node.type !== undefined;
-}
-/**
- * The values one written expression hands on: the expression itself, or what it
- * evaluates to through parentheses, a conditional and the operators whose result is
- * one of their operands.
- */
-function valuesOf(expression) {
-    if (isParenthesizedExpression(expression)) {
-        return valuesOf(expression.expression);
-    }
-    if (isConditionalExpression(expression)) {
-        return [...valuesOf(expression.whenTrue), ...valuesOf(expression.whenFalse)];
-    }
-    if (isBinaryExpression(expression)) {
-        const operator = expression.operatorToken.kind;
-        if (operator === SyntaxKind.QuestionQuestionToken || operator === SyntaxKind.BarBarToken) {
-            return [...valuesOf(expression.left), ...valuesOf(expression.right)];
-        }
-        if (operator === SyntaxKind.AmpersandAmpersandToken || operator === SyntaxKind.CommaToken) {
-            return valuesOf(expression.right);
-        }
-    }
-    return [expression];
-}
-/** The expressions one node hands to a position typed by its context. */
-function handedOn(node) {
-    if ((isVariableDeclaration(node) || isPropertyDeclaration(node) || isParameterDeclaration(node)) &&
-        node.initializer !== undefined &&
-        writesType(node)) {
-        return [node.initializer];
-    }
-    if (isBinaryExpression(node) && STORES.has(node.operatorToken.kind)) {
-        return [node.right];
-    }
-    if (isCallExpression(node) || isNewExpression(node)) {
-        return (node.arguments ?? []).filter((argument) => !isSpreadElement(argument));
-    }
-    if (isReturnStatement(node)) {
-        return node.expression === undefined ? [] : [node.expression];
-    }
-    if (isArrowFunction(node)) {
-        return node.body.kind === SyntaxKind.Block ? [] : [node.body];
-    }
-    if (isArrayLiteralExpression(node)) {
-        return node.elements.filter((element) => !isSpreadElement(element) && element.kind !== SyntaxKind.OmittedExpression);
-    }
-    if (isPropertyAssignment(node)) {
-        return [node.initializer];
-    }
-    if (isShorthandPropertyAssignment(node)) {
-        return isIdentifier(node.name) ? [node.name] : [];
-    }
-    if (isAsExpression(node) || isSatisfiesExpression(node)) {
-        return [node.expression];
-    }
-    return [];
-}
 /**
  * The classes, the `implements` entries and the flowing values of one project's own
  * files. `this` is the class an instance member belongs to, so a function that is not

package/dist/src/inventory.js

@@ -69,7 +69,10 @@ function modifiersOf(node) {
 function typeParametersOf(node) {
     if (isFunctionDeclaration(node) ||
         isMethodDeclaration(node) ||
-        isMethodSignatureDeclaration(node)) {
+        isMethodSignatureDeclaration(node) ||
+        isClassDeclaration(node) ||
+        isInterfaceDeclaration(node) ||
+        isTypeAliasDeclaration(node)) {
         return node.typeParameters ?? [];
     }
     return [];
@@ -210,7 +213,18 @@ function nameNodeOf(node) {
  * needs the declaration this enumeration made for it.
  */
 export function nodeKey(file, node) {
-    return `${file.fileName}:${String(node.pos)}:${String(node.end)}`;
+    return `${file.fileName}:${String(node.pos)}:${String(node.end)}:${String(node.kind)}`;
+}
+/** `export default`, up to the keyword that stands where an unnamed default export's name would. */
+const DEFAULT_EXPORT = /^export\s+(?=default\b)/u;
+/**
+ * Where an unnamed declaration is placed: at `default` when it is the default export, so it
+ * never shares the file's own position, else at its first token.
+ */
+function unnamedStart(node) {
+    const start = node.getStart();
+    const prefix = DEFAULT_EXPORT.exec(node.getText());
+    return prefix === null ? start : start + prefix[0].length;
 }
 /** The kind a class element takes: a method, or a property or accessor. */
 function classMemberKind(node) {
@@ -284,12 +298,11 @@ export function inventory(project, host, targetRoot) {
         }
     }
     function declare(node, owner, kind, name, named) {
-        const at = name ?? node;
         const record = keep({
             file: owner.file,
             node,
             module: owner.module,
-            position: renderPosition(owner.file, targetRoot, at.getStart()),
+            position: renderPosition(owner.file, targetRoot, name?.getStart() ?? unnamedStart(node)),
             endLine: renderPosition(owner.file, targetRoot, Math.max(node.end - 1, 0)).line,
             kind,
             parentChain: owner.kind === "file" ? [] : chainOf(owner),

package/dist/src/kinds.js

@@ -30,6 +30,7 @@ const ROWS = [
         name: "unused-member",
         languages: ["go", "ts"],
         rule: "A struct field, class member or type member with no reference, a private member included. A member referenced only from its own declaration site counts as unreferenced.",
+        precondition: "A TypeScript member that no value writes and nothing reads, whose type names a type parameter of its declaring interface, class or type alias, is not reported when every part of that declaration that names the type parameter is a member no value writes and nothing reads. TypeScript compares object types by their members, so such members are what make two instantiations of their type distinct types, and deleting them leaves the type parameter phantom and lets one instantiation stand for another. A member a value writes is decided by the rule of DS1301 instead, whatever its type names.",
         defaultSeverity: "deny",
         maxClass: "certain",
         fixability: "deletable",
@@ -70,7 +71,7 @@ const ROWS = [
         name: "unnecessary-export",
         languages: ["go", "ts"],
         rule: "An exported symbol whose every reference is inside the symbol's own package or module, reported as a candidate for unexporting. The subject is a package-level declaration or a method, and three subjects are excluded: an interface method, whose exportedness is the contract of the interface that declares it; a struct field, which an encoder reads by name; and a method that satisfies an interface some symbol uses as a type, which cannot be unexported without its type ceasing to satisfy that interface. The finding names the narrower visibility the references support. A declared cross-language edge counts as an out-of-package reference; where the edge's other side is unknown to the analyzer the finding is emitted pending.",
-        precondition: "Closed world only. Reported always for a main package and an internal/ directory tree, and for a published package only when the configuration declares the consumer set complete and every declared consumer loads. A library with no consumer loaded and no complete consumer set declared gets this finding on its internal/ tree and its main packages and never on its published API. 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 always for a main package and an internal/ directory tree, and for a published package only when the configuration declares the consumer set complete and every declared consumer loads. A library with no consumer loaded and no complete consumer set declared gets this finding on its internal/ tree and its main packages and never on its published API. 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. A type that a parameter or a result of an exported function or method of its own package names is not reported when a reference from outside the package references that function or method, because the caller holds values of the type, and unexporting it would leave an exported signature naming a type its callers cannot name.",
         defaultSeverity: "warn",
         maxClass: "certain",
         fixability: "narrowable",
@@ -81,7 +82,7 @@ const ROWS = [
         name: "unnecessary-exposure",
         languages: ["go"],
         rule: "An exported symbol of a non-internal package whose every reference is inside the target module, reported as a candidate for relocation behind an internal boundary. The subject is a package-level declaration or a method, and three subjects are excluded: an interface method, whose exportedness is the contract of the interface that declares it; a struct field, which an encoder reads by name; and a method that satisfies an interface some symbol uses as a type, which cannot be unexported without its type ceasing to satisfy that interface. The finding names the narrower visibility the references support. A declared cross-language edge counts as an out-of-package reference; where the edge's other side is unknown to the analyzer the finding is emitted pending.",
-        precondition: "Closed world only. Reported always for a main package and an internal/ directory tree, and for a published package only when the configuration declares the consumer set complete and every declared consumer loads. A library with no consumer loaded and no complete consumer set declared gets this finding on its internal/ tree and its main packages and never on its published API. 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 always for a main package and an internal/ directory tree, and for a published package only when the configuration declares the consumer set complete and every declared consumer loads. A library with no consumer loaded and no complete consumer set declared gets this finding on its internal/ tree and its main packages and never on its published API. 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. A type that a parameter or a result of an exported function or method of its own package names is not reported when a reference from outside the target module references that function or method, because the caller holds values of the type, and moving it behind an internal boundary would leave an exported signature naming a type its callers cannot name.",
         defaultSeverity: "warn",
         maxClass: "certain",
         fixability: "narrowable",
@@ -143,7 +144,7 @@ const ROWS = [
         code: "DS1301",
         name: "write-only-symbol",
         languages: ["go", "ts"],
-        rule: "A package-level or module-level variable, struct field, class member or collection that production code writes and never reads. In production mode a read from a test file counts as no read. A comparison of struct values reads every field of the type: in Go, a value of a struct type used as an operand of `==` or `!=`, as a map key, or as a `switch` tag or `case` expression is a read of every field of that type, transitively through the fields of every struct type it holds, recorded at the comparison, because equality reads every field and a field that decides equality carries information. In TypeScript a comparison of two object references reads no member, because `===` compares identity and never a member. The finding names each write position, so the deletion set is visible.",
+        rule: "A package-level or module-level variable, struct field, class member, type member or collection that production code writes and never reads. In production mode a read from a test file counts as no read. A comparison of struct values reads every field of the type: in Go, a value of a struct type used as an operand of `==` or `!=`, as a map key, or as a `switch` tag or `case` expression is a read of every field of that type, transitively through the fields of every struct type it holds, recorded at the comparison, because equality reads every field and a field that decides equality carries information. In TypeScript a comparison of two object references reads no member, because `===` compares identity and never a member. In TypeScript a property of an object literal writes the member of the same name that the literal's contextual type declares, whether or not the compiler checks the literal for excess properties. Where that contextual type is a union or an intersection, the property writes the member of that name on each constituent that declares one. So a literal that a declaration annotates, a function returns, a call passes or a `satisfies` expression checks writes the members of the type it is given. A store through the value a field or a member holds reads that field or member rather than writing it, because the store lands in storage every other holder of the value reads. In Go that store is an assignment, an increment, a compound assignment or a `delete` whose target is reached through a struct field holding a map, a slice or a pointer. Examples are `s.f[k] = v`, `s.f.x = v` and `delete(s.f, k)`. The same store through a field holding an array or a struct is a store into the field itself. TypeScript holds every object by reference, so an element or property store through a member's value reads the member. The finding names each write position, so the deletion set is visible. Deleting the subject and its writes also deletes every declaration whose only uses they hold. Such a declaration is a type parameter of the subject's declaring type that the subject's type alone names, or an import binding the writes alone use. The finding's message names each such declaration.",
         defaultSeverity: "deny",
         maxClass: "certain",
         fixability: "deletable",