@cplieger/deadset-ts 4.0.1 → 5.1.0

package/dist/src/findings/completion.js

@@ -15,50 +15,40 @@ const RANK = { certain: 3, probable: 2, possible: 1 };
 function capped(found, ceiling) {
     return RANK[found] <= RANK[ceiling] ? found : ceiling;
 }
-/** The kind whose default turns on what the run knows about the target's consumers. */
-const UNUSED_EXPORTED = "DS1001";
 /** Whether the run loaded every consumer the scope declared, which holds of a scope declaring none. */
 function everyDeclaredLoaded(boundary) {
     const { declared, loaded } = boundary.consumers;
     return declared.every((id) => loaded.includes(id));
 }
-/**
- * Whether a library's published API may have a caller the run cannot see: the target is
- * a library, and the run either holds no consumer information or did not load a consumer
- * the scope declared. A configuration declaring the consumer set complete holds consumer
- * information whether or not it declares a consumer, because it says no other exists.
- */
-function openWorld(input) {
-    const known = input.config.consumersComplete || input.boundary.consumers.declared.length > 0;
-    return input.config.targetKind === "library" && !(known && everyDeclaredLoaded(input.boundary));
-}
 /**
  * The severity the configuration gives one code: the key naming the code, else the key
- * naming its family, else the code's default. The unused-exported kind defaults to
- * `allow` while a library's published API is open to callers the run cannot see.
+ * naming its family, else the code's default.
  */
 function severityOf(input, code, fallback) {
     const { config } = input;
-    const named = config.severity.get(code) ?? config.severity.get(code.slice(0, FAMILY_KEY_LENGTH));
-    if (named !== undefined) {
-        return named;
-    }
-    return code === UNUSED_EXPORTED && openWorld(input) ? "allow" : fallback;
+    return (config.severity.get(code) ?? config.severity.get(code.slice(0, FAMILY_KEY_LENGTH)) ?? fallback);
+}
+/**
+ * The declarations the roots name as a library's published API, each public member of a
+ * published type included.
+ */
+function publishedIds(union) {
+    return new Set(union.rooted
+        .filter((root) => root.kind === "published-api")
+        .flatMap((root) => union.symbols[root.at]?.id ?? []));
 }
 /**
  * The reachability class of one declaration of the run. A declaration of a library's
- * published API 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, 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`.
  */
 function reachabilityClasses(input) {
-    const union = input.swept.matrix.union;
-    const published = new Set(union.rooted
-        .filter((root) => root.kind === "published-api")
-        .map((root) => union.symbols[root.at]?.id));
+    const published = publishedIds(input.swept.matrix.union);
     const { declared } = input.boundary.consumers;
     const outside = declared.length === 0
         ? "possible"
@@ -126,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`);
@@ -161,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,
@@ -171,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 ??
@@ -179,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/emitters.js

@@ -1,5 +1,7 @@
 import { evaluateEdges } from "../edges.js";
+import { liveFilesAt } from "../matrix.js";
 import { ledgerOf } from "../suppress.js";
+import { insideSkipped } from "../type-errors.js";
 import { completed, dialsOf, reportable } from "./completion.js";
 import { dependenciesAndModuleMachinery } from "./dependencies-and-module-machinery.js";
 import { interfaces } from "./interfaces.js";
@@ -33,6 +35,21 @@ function heldRefs(input) {
         .filter((symbol) => held.has(symbol.id))
         .map((symbol) => symbol.ref));
 }
+/**
+ * The references of every top-level declaration of a live component file. The file's
+ * markup may use each of them, which no analysis of the markup can rule out, so the run
+ * reports nothing about one while the file is live.
+ */
+function markupRefs(input) {
+    const { swept } = input;
+    if (swept.componentFiles.length === 0) {
+        return new Set();
+    }
+    const live = new Set(liveFilesAt(swept.matrix, swept.sweep, new Set(swept.componentFiles)).map((symbol) => symbol.id));
+    return new Set(swept.matrix.union.symbols
+        .filter((symbol) => live.has(symbol.parent))
+        .map((symbol) => symbol.ref));
+}
 /** Every family's findings over one sweep, and those of any further emitter, completed by one step. */
 function completedOver(input, ...more) {
     return completed(input, [...EMITTERS.values(), ...more].flatMap((emit) => emit(input)));
@@ -64,7 +81,11 @@ export function decidedFindings(input, suppressed = { unmarked: input, records:
     const would = [...unmarked, ...found];
     const ledger = ledgerOf(suppressed.records, would, dialsOver(input, found, suppressed, unmarked));
     const unanswered = heldRefs(input);
-    const kept = reportable(input, found.filter((finding) => !ledger.withheld(finding) && !unanswered.has(finding.symbol.ref)));
+    const markup = markupRefs(input);
+    const kept = reportable(input, found.filter((finding) => !ledger.withheld(finding) &&
+        !unanswered.has(finding.symbol.ref) &&
+        !markup.has(finding.symbol.ref) &&
+        !insideSkipped(input.swept.skipped, finding.position)));
     const evaluated = evaluateEdges(kept, input.boundary.edges, input.swept.matrix.union.symbols);
     return {
         findings: evaluated.findings,

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

@@ -40,8 +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; 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, 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.
  */
 function codeOf(judged) {
     const { candidate, symbol } = judged;
@@ -55,6 +56,9 @@ function codeOf(judged) {
     if (symbol.kind === "enum-member" && !referenced) {
         return undefined;
     }
+    if (judged.support && candidate.testRefs > 0) {
+        return undefined;
+    }
     if (candidate.productionRefs === 0 && judged.deprecated) {
         return "DS1006";
     }
@@ -110,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);
 /**
@@ -123,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);
@@ -138,12 +180,14 @@ 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),
         };
         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

@@ -32,20 +32,26 @@ const SWEPT = {
 };
 /**
  * Whether a root of each kind names a caller, which holds it live under both relations: a
- * tool reads the configuration it loads, a runtime runs a test file, a setup file, a
- * worker and a command, the manifest names what enters the package, and an entry file, a
- * configured root and a pattern assert a caller. A library's published API only supposes
+ * tool reads the configuration it loads and the files its strings name, a runtime runs a
+ * test file, a setup file, a worker, a command and a script, the manifest names what
+ * enters the package, an alias global stands for the export it names, and an entry file,
+ * a configured root and a pattern assert a caller. A library's published API only supposes
  * a consumer the run may not see, so it is live under reachability alone.
  */
 const NAMES_A_CALLER = {
     "entry-file": true,
+    convention: true,
     "manifest-entry": true,
     "manifest-binary": true,
+    script: true,
     "published-api": false,
     configured: true,
     pattern: true,
+    "type-error": true,
+    "type-query-alias": true,
+    "configuration-file": true,
+    "configuration-string": true,
     "test-runner": true,
-    "lint-configuration": true,
     "mutation-testing": true,
     "browser-tests": true,
     worker: true,
@@ -65,7 +71,8 @@ export function namesACaller(kind) {
  * from such a declaration still counts toward its target, because reference counting
  * asks whether any declaration names the target. A root naming nothing is dropped.
  */
-export function graphOf(symbols, references, roots, testFiles) {
+export function graphOf(symbols, references, roots, testFiles, supportFiles = []) {
+    const supports = new Set(supportFiles);
     const index = new Map(symbols.map((symbol, at) => [symbol.id, at]));
     const at = (id) => index.get(id) ?? OUTSIDE;
     const tests = new Set(testFiles);
@@ -114,6 +121,7 @@ export function graphOf(symbols, references, roots, testFiles) {
         made,
         parent,
         test: symbols.map((symbol) => tests.has(symbol.position.path)),
+        support: symbols.map((symbol) => supports.has(symbol.position.path)),
         subject: symbols.map((symbol) => swept(symbol.kind)),
         exportsOf,
         rooted,

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

@@ -1,6 +1,6 @@
 import { isClassDeclaration, isComputedPropertyName, isEnumDeclaration, isEnumMember, isExportAssignment, isExportDeclaration, isFunctionDeclaration, isGetAccessorDeclaration, isIdentifier, isInterfaceDeclaration, isIntersectionTypeNode, isMethodDeclaration, isMethodSignatureDeclaration, isModuleBlock, isModuleDeclaration, isNamespaceExport, isParenthesizedTypeNode, isPrivateIdentifier, isPropertyDeclaration, isPropertySignatureDeclaration, isSetAccessorDeclaration, isTypeAliasDeclaration, isTypeLiteralNode, isUnionTypeNode, isVariableStatement, ModifierFlags, } from "@typescript/native/unstable/ast";
 import { dirnamePath, joinPath, relativePath } from "./paths.js";
-import { byPosition, positionKey, renderPosition } from "./position.js";
+import { byPosition, positionKey, renderPosition, writtenLength, } from "./position.js";
 import { computedComponent, nameComponent, renderRef } from "./ref.js";
 import { isAnswered, UNANSWERED } from "./query.js";
 const MANIFEST = "package.json";
@@ -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 [];
@@ -273,7 +276,9 @@ export function inventory(project, host, targetRoot) {
             typeParameter: undefined,
         });
         exportScopes.push({ owner: fileRecord, nameNode: file });
-        walkStatements(file.statements, fileRecord);
+        // A statement a component file's module appends is not written in the file.
+        const written = writtenLength(file);
+        walkStatements(file.statements.filter((statement) => statement.end <= written), fileRecord);
     }
     /** One declaration of a module, a namespace or a container body. */
     function walkStatements(statements, owner) {