@cplieger/deadset-ts 8.0.0-dev.14 → 8.0.0-dev.16

package/dist/src/serialization-contract.js

@@ -12,7 +12,7 @@ import { SignatureKind, SymbolFlags, TypeFlags, } from "@typescript/native/sync"
 import { aliasChains } from "./alias-chain.js";
 import { calleeName, resolvedTargets, valuesPassed } from "./calls.js";
 import { classMembers, memberComponent, typesAt } from "./class-members.js";
-import { names, namesADeclaration, resolveEntries, spelledEntry, } from "./configured-declarations.js";
+import { names, namesADeclaration, resolveEntries, spelledEntry, } from "./roots/configured-declarations.js";
 import { nodeKey } from "./inventory.js";
 import { renderPosition } from "./position.js";
 import { must, Unanswerable } from "./query.js";

package/dist/src/session.js

@@ -138,6 +138,9 @@ function viewOf(project, configFile, engine, log) {
             ownKeys ??= new Set(ownSourceFiles().map((file) => file.path));
             return ownKeys;
         },
+        resolvedFileNames: (specifiers) => batched(engine, specifiers, (node) => project.program.getResolvedModuleFromModuleSpecifier.gen(node, node.getSourceFile().fileName)).map((resolved) => resolved === undefined || resolved.resolvedFileName === ""
+            ? undefined
+            : resolved.resolvedFileName),
         handle: (node) => ({ node }),
         symbolsAt: (handles, cap) => queries.symbolsAt(handles.map(({ node }) => node), cap),
         resolvedSymbolAt: ({ node }) => queries.resolvedSymbol(node),

package/dist/src/source-files.js

@@ -5,12 +5,11 @@
  */
 import { commonDirectory, emittedFrom } from "./load/emit-map.js";
 import { dirnamePath, joinPath, relativePath, resolvePath } from "./paths.js";
+import { OUTPUT_EXTENSIONS } from "./extensions.js";
 /** The one character a subpath pattern of a manifest's `exports` holds. */
 const SUBPATH_WILDCARD = "*";
 /** The extension a source file's name drops when the project writes it out. */
 const SOURCE_EXTENSION = /\.[cm]?[jt]sx?$/u;
-/** The extensions the project may write a source file's output under. */
-const OUTPUT_EXTENSIONS = [".js", ".mjs", ".cjs", ".jsx", ".d.ts", ".d.mts", ".d.cts"];
 /**
  * Whether one path is what a subpath pattern stands for: the text before the
  * wildcard, any run of characters including the solidus, then the text after it.
@@ -43,13 +42,10 @@ function layoutOf(project, fileNames) {
     };
 }
 /**
- * The lookups over one project's own files.
- *
- * A path that names an emitted file is read back to the source the project would
- * emit it from through the project's own emit mapping and nothing else: the
- * extension is one the compiler emits from a source extension, and a path below the
- * output directory is read below the directory the compiler emits from, which the
- * configuration declares or which is the directory every input file shares.
+ * The lookups over one project's own files. A path naming an emitted file is read back to its
+ * source through the project's own emit mapping alone: the extension is one the compiler emits
+ * from a source extension, and a path below the output directory is read below the directory
+ * the compiler emits from, which the configuration declares or every input file shares.
  */
 export function sourceFilesOf(project, targetRoot) {
     const byName = new Map();

package/dist/src/suppress-inline.js

@@ -4,12 +4,12 @@
  * below it, or on its own line where it trails a token there.
  */
 import { CODE } from "./contract/contract.generated.js";
-import { isConstructorDeclaration, SyntaxKind, } from "@typescript/native/ast";
+import { SyntaxKind } from "@typescript/native/ast";
 import { importBindings } from "./import-bindings.js";
-import { isParameterProperty, nodeKey } from "./inventory.js";
-import { byPosition, positionKey, renderPosition } from "./position.js";
+import { nodeKey } from "./inventory.js";
+import { relativePath } from "./paths.js";
+import { byPosition, lineEnd, positionKey, renderPosition, startLine, tokenStart, } from "./position.js";
 import { importRef } from "./ref.js";
-import { signatureOf } from "./signatures.js";
 import { isPartKind, SuppressionError, siteText, } from "./suppress.js";
 /**
  * The three expressions the grammar applies to the text of each line comment, in this
@@ -55,43 +55,6 @@ const LITERALS = new Set([
     SyntaxKind.RegularExpressionLiteral,
     SyntaxKind.JsxText,
 ]);
-/** Whether one character ends a line, under the language's line terminators. */
-function endsLine(char) {
-    return char === "\n" || char === "\r" || char === "\u2028" || char === "\u2029";
-}
-/** The offset where the line holding `from` ends. */
-function lineEnd(text, from) {
-    let at = from;
-    while (at < text.length && !endsLine(text[at])) {
-        at += 1;
-    }
-    return at;
-}
-/**
- * The offset of the first token at or after `from`: whitespace, comments and a leading
- * hashbang are trivia.
- */
-export function tokenStart(text, from) {
-    let at = from;
-    if (at === 0 && text.startsWith("#!")) {
-        at = lineEnd(text, 0);
-    }
-    for (;;) {
-        if (/\s/u.test(text[at] ?? "")) {
-            at += 1;
-        }
-        else if (text.startsWith("//", at)) {
-            at = lineEnd(text, at);
-        }
-        else if (text.startsWith("/*", at)) {
-            const close = text.indexOf("*/", at + 2);
-            at = close < 0 ? text.length : close + 2;
-        }
-        else {
-            return at;
-        }
-    }
-}
 /**
  * Every `//` line comment of one file, in file order. The text between tokens is read as
  * the language reads it: a block comment holds no line comment, and the literal tokens the
@@ -140,55 +103,42 @@ function lineComments(file) {
 function bindingKey(one) {
     return `${one.declared?.id ?? ""}\u0000${one.part.id}`;
 }
+/** The placed declarations of a project by the path of the file each is in. */
+function placedByPath(held, symbols) {
+    const byPath = new Map();
+    for (const [id, placed] of held.placement) {
+        const one = symbols.get(id);
+        const holder = symbols.get(placed.holder);
+        if (one === undefined || holder === undefined) {
+            continue;
+        }
+        const at = byPath.get(one.position.path) ?? [];
+        at.push({ one, holder, startLines: placed.startLines, partLines: placed.partLines });
+        byPath.set(one.position.path, at);
+    }
+    return byPath;
+}
 /**
- * The declarations of one file by the line each begins on, the line of its first token: a
- * decorator, a modifier or the keyword. A variable's first token is its statement's
- * keyword, and a variable written on a later line of the statement also begins there. A
- * function also begins, for a directive, on the line of each of its parameters, and a
- * class, for a part kind, on the lines of its constructor and its constructor's parameters.
+ * The declarations of one file by the line a directive binds each on, as the inventory
+ * places them, and each import binding of the file on its statement's lines.
  */
-function declarationLines(file, held, symbols, targetRoot) {
+function declarationLines(file, placed, held, targetRoot) {
     const below = new Map();
-    const add = (offset, one) => {
-        const line = file.getLineAndCharacterOfPosition(tokenStart(file.text, offset)).line + 1;
+    const add = (line, one) => {
         const at = below.get(line) ?? [];
         if (!at.some((known) => bindingKey(known) === bindingKey(one))) {
             at.push(one);
         }
         below.set(line, at);
     };
-    const declaredAt = (node) => {
-        const id = held.declarations.get(nodeKey(file, node));
-        return id === undefined ? undefined : symbols.get(id);
-    };
-    const visit = (node) => {
-        const one = declaredAt(node);
-        const owner = isConstructorDeclaration(node) ? declaredAt(node.parent) : undefined;
-        if (owner !== undefined && isConstructorDeclaration(node)) {
-            for (const at of [node, ...node.parameters.filter((one) => !isParameterProperty(one))]) {
-                add(at.pos, { declared: undefined, part: owner });
-            }
-        }
-        const holder = one !== undefined && isParameterProperty(node) ? declaredAt(node.parent.parent) : one;
-        if (one !== undefined && holder !== undefined) {
-            add(node.pos, { declared: one, part: holder });
+    for (const { one, holder, startLines, partLines } of placed) {
+        for (const line of startLines) {
+            add(line, { declared: one, part: holder });
         }
-        if (one !== undefined) {
-            // A parameter on a later line of a wrapped signature takes its directive on the
-            // line above it, inside the parameter list, and the directive binds the function.
-            for (const parameter of signatureOf(node)?.parameters ?? []) {
-                add(parameter.pos, { declared: one, part: one });
-            }
-            const list = node.parent;
-            if (node.kind === SyntaxKind.VariableDeclaration &&
-                list.kind === SyntaxKind.VariableDeclarationList &&
-                list.parent.kind === SyntaxKind.VariableStatement) {
-                add(list.parent.pos, { declared: one, part: one });
-            }
+        for (const line of partLines) {
+            add(line, { declared: undefined, part: one });
         }
-        node.forEachChild(visit);
-    };
-    file.forEachChild(visit);
+    }
     // An import binding is a subject of its own, bound on its line as a declaration is.
     const fileId = held.declarations.get(nodeKey(file, file));
     const moduleRef = held.symbols.find((symbol) => symbol.id === fileId)?.ref ?? "";
@@ -200,7 +150,7 @@ function declarationLines(file, held, symbols, targetRoot) {
             statement = statement.parent;
         }
         for (const at of [statement.pos, name.getStart()]) {
-            add(at, { declared: one, part: one });
+            add(startLine(file, at), { declared: one, part: one });
         }
     }
     return below;
@@ -221,13 +171,15 @@ export function inlineDirectives(project, held, targetRoot) {
     const symbols = new Map(held.symbols
         .filter((symbol) => symbol.kind !== "file")
         .map((symbol) => [symbol.id, { id: symbol.id, ref: symbol.ref, position: symbol.position }]));
+    const placed = placedByPath(held, symbols);
     const found = [];
     for (const file of project.ownSourceFiles()) {
         const comments = lineComments(file).filter((comment) => CANDIDATE.test(comment.text));
         if (comments.length === 0) {
             continue;
         }
-        const below = declarationLines(file, held, symbols, targetRoot);
+        const path = relativePath(targetRoot, file.fileName) ?? "";
+        const below = declarationLines(file, placed.get(path) ?? [], held, targetRoot);
         for (const comment of comments) {
             const site = renderPosition(file, targetRoot, comment.offset);
             const target = trails(file, comment.offset) ? site.line : site.line + 1;

package/dist/src/suppress.js

@@ -4,9 +4,9 @@
  * ignore entry or a baseline row. A bound record marks its declaration live before the
  * sweep, unless its code reports a part or a dependency row, and is in effect when it
  * withholds a finding its code would have produced there, dormant when the configuration
- * withholds every such finding anyway, and stale otherwise.
+ * or a hold withholds every such finding anyway, and stale otherwise.
  */
-import { KIND_ROWS, SYMBOL_SUBJECTS, } from "./contract/contract.generated.js";
+import { KIND_ROWS, REMEDIES, SYMBOL_SUBJECTS, } from "./contract/contract.generated.js";
 import { UsageError } from "./usage.js";
 import { positionKey } from "./position.js";
 import { isRef } from "./ref.js";
@@ -66,6 +66,8 @@ export function isSymbolRef(value) {
 export function blankReason(reason) {
     return reason === undefined || /^[ \t\r\n]*$/u.test(reason);
 }
+/** No hold. */
+const NO_HOLDS = { withholds: () => false, holdsRecord: () => false };
 /** The subject of the kind each live code names. */
 const SUBJECT_OF_CODE = new Map(KIND_ROWS.map((row) => [row.code, row.subject]));
 /** The subject a finding about one symbol kind is about. */
@@ -78,32 +80,25 @@ function subjectOf(kind) {
 function rowOf(subject) {
     return subject === "file" || subject === "dependency" || subject === "record";
 }
-/**
- * Whether a finding's subject is a row of a document rather than a declaration. Apart
- * from a dependency row, nothing withholds a finding about one.
- */
+/** Whether a finding's subject is a row of a document rather than a declaration. */
 export function isRowSubject(kind) {
     return rowOf(subjectOf(kind));
 }
-/** Whether a code reports a row of a document. */
-export function isRowCode(code) {
-    return rowOf(SUBJECT_OF_CODE.get(code));
+/** The subject a code reports, which kinds.json's remedies table answers for. */
+export function subjectOfCode(code) {
+    return SUBJECT_OF_CODE.get(code);
 }
 /**
- * Whether a finding's subject is a dependency row. An ignore entry or a baseline row
- * naming the row's reference and file withholds its finding and marks nothing, and an
- * inline directive never binds one.
+ * Whether a record of `mechanism` can name a finding about `subject`, as kinds.json's
+ * remedies table lists the suppressions of each subject. A subject the table does not
+ * know is a declaration's.
  */
-export function isDependencySubject(kind) {
-    return subjectOf(kind) === "dependency";
-}
-/** Whether a code reports a dependency row, which only an ignore entry or a baseline row names. */
-export function isDependencyCode(code) {
-    return SUBJECT_OF_CODE.get(code) === "dependency";
+export function names(subject, mechanism) {
+    return REMEDIES[subject ?? "declaration"].suppressions.includes(mechanism);
 }
-/** Whether a code reports a row of a document that no record of any mechanism can name. */
-export function isUnsuppressibleCode(code) {
-    return isRowCode(code) && !isDependencyCode(code);
+/** Whether a finding about a symbol of `kind` is one a record of `mechanism` can name. */
+export function namesKind(kind, mechanism) {
+    return names(subjectOf(kind), mechanism);
 }
 /**
  * Whether a finding's subject is a part of the declaration its reference names: a part
@@ -136,14 +131,13 @@ export function pairs(record, finding) {
     if (record.code !== finding.code) {
         return false;
     }
-    if (isDependencySubject(finding.symbol.kind)) {
-        return (record.mechanism !== "inline" &&
-            record.symbol === finding.symbol.ref &&
-            record.path === finding.position.path);
-    }
-    if (isRowSubject(finding.symbol.kind)) {
+    const subject = subjectOf(finding.symbol.kind);
+    if (!names(subject, record.mechanism)) {
         return false;
     }
+    if (subject === "dependency") {
+        return record.symbol === finding.symbol.ref && record.path === finding.position.path;
+    }
     if (record.bound !== "" && record.bound === positionKey(finding.position)) {
         return true;
     }
@@ -155,10 +149,10 @@ export function pairs(record, finding) {
  * there: swept with no mark for a liveness kind, and as swept otherwise. The first record
  * in reading order claims a finding, so a second naming it is stale; a part-kind record
  * claims every finding of its code about a part of its declaration. A record is dormant
- * when the dials withhold every finding it claims, read from those findings alone, or when
- * it claims none and its code's severity is `allow`.
+ * when the dials or `holds` withhold every finding it claims, or when it claims none and
+ * its code is at `allow` or a hold keeps its declaration live.
  */
-export function ledgerOf(records, would, dials) {
+export function ledgerOf(records, would, dials, holds = NO_HOLDS) {
     const taken = new Set();
     const verdicts = [];
     for (const record of records) {
@@ -166,13 +160,17 @@ export function ledgerOf(records, would, dials) {
         const first = would.find(open);
         const claimed = first === undefined ? [] : isPartKind(record.code) ? would.filter(open) : [first];
         if (claimed.length === 0) {
-            verdicts.push(record.bound !== "" && dials.allows(record.code) ? "dormant" : "stale");
+            verdicts.push(record.bound !== "" && (dials.allows(record.code) || holds.holdsRecord(record))
+                ? "dormant"
+                : "stale");
             continue;
         }
         for (const finding of claimed) {
             taken.add(claimKey(finding));
         }
-        verdicts.push(claimed.every((finding) => dials.withholds(finding)) ? "dormant" : "in-effect");
+        verdicts.push(claimed.every((finding) => dials.withholds(finding) || holds.withholds(finding))
+            ? "dormant"
+            : "in-effect");
     }
     return {
         verdicts,

package/dist/src/test-support.js

@@ -5,7 +5,7 @@
  * another such file, so it is judged with the tests: what it references is referenced by
  * test code.
  */
-import { CONVENTION_ROWS, TEST_LIBRARIES, TEST_LIBRARY_SCOPES } from "./convention-rows.js";
+import { CONVENTION_ROWS, TEST_LIBRARIES, TEST_LIBRARY_SCOPES } from "./entries/convention-rows.js";
 import { packageOfSpecifier } from "./dependencies.js";
 /** The root kind that never takes a file out of test-support code: the skip only withholds. */
 const SKIP_ROOT = "type-error";
@@ -14,7 +14,9 @@ const SKIP_ROOT = "type-error";
  * convention row reads test files for, and the convention table's test libraries.
  */
 const TEST_PACKAGES = new Set([
-    ...CONVENTION_ROWS.filter((row) => row.testFiles !== undefined).map((row) => row.package),
+    ...CONVENTION_ROWS.filter((row) => row.testFiles !== undefined ||
+        row.testDirectories !== undefined ||
+        row.testRunner !== undefined).map((row) => row.package),
     ...TEST_LIBRARIES,
 ]);
 /**

package/dist/src/verbs/analyze.js

@@ -3,6 +3,7 @@ import { runAnalysis, runBaselineWrite, unansweredCounts, } from "../analysis.js
 import { kindOf } from "../config.js";
 import { CONFORMANCE, DECLARED_GAPS } from "../conformance.js";
 import { analyzerProvenance, verdictOf } from "../findings-pass.js";
+import { factsDocument } from "../facts.js";
 import { dirnamePath, joinPath, normalizePath, relativePath, resolvePath } from "../paths.js";
 import { moduleIdentity } from "../load/discover.js";
 import { partialNotes } from "../partial.js";
@@ -21,7 +22,7 @@ import { diagnose, message } from "../product.js";
 import { ownVersion } from "./version.js";
 /** The options `analyze` takes beside the ones every verb takes. */
 export const ANALYZE_OPTIONS = {
-    plain: ["report", "baseline-write", "exit-code", "template"],
+    plain: ["report", "facts", "baseline-write", "exit-code", "template"],
     repeatable: ["format"],
 };
 /** The two values `--exit-code` takes; on, the default, puts the run's verdict in the exit code. */
@@ -211,8 +212,13 @@ export const analyzeVerb = ({ err, host, inputs, scope, openClient, option, repe
     const { config, provenance } = resolve(inputs());
     const invoked = host.workingDirectory();
     const baseline = option("baseline-write");
+    const facts = option("facts");
+    if (facts === "") {
+        throw new UsageError("--facts names the path the facts document is written to, and named none");
+    }
     const documents = {
         report: resolvePath(invoked, reportPath),
+        facts: facts === undefined ? undefined : resolvePath(invoked, facts),
         formats: formatsOf(repeated("format"), config.reporters.formats),
         baseline: baseline === undefined ? undefined : resolvePath(invoked, baseline),
     };
@@ -281,6 +287,12 @@ export const analyzeVerb = ({ err, host, inputs, scope, openClient, option, repe
         throw productFault(`built a report that breaks the report schema at ${refused.pointer || "the document"}: ${refused.keyword}: ${refused.reason}`);
     }
     writeDocument(host, documents.report, "name a path the run can write", () => json(report));
+    const factsPath = documents.facts;
+    if (factsPath !== undefined) {
+        writeDocument(host, factsPath, "name a path the run can write", () => [
+            factsDocument(version, run.generated),
+        ]);
+    }
     const options = {
         readSource: (path) => host.readFile(joinPath(targetRoot, path)),
         template,

package/dist/src/verbs/describe.js

@@ -1,12 +1,13 @@
-import { CONTRACT_VERSION, EXIT_CLEAN, EXIT_USAGE, SCHEMA_VERSIONS, } from "../contract/contract.generated.js";
+import { CONTRACT_VERSION, EXIT_CLEAN, EXIT_USAGE, FACTS_VERSION, SCHEMA_VERSIONS, } from "../contract/contract.generated.js";
 import { CONFORMANCE } from "../conformance.js";
 import {} from "./verb.js";
 import { diagnose, LANGUAGE, PRODUCT } from "../product.js";
 import { ownVersion } from "./version.js";
 /**
  * The document `describe` writes: the analyzer, the Contract version it implements, the
- * report schema versions it reads, the languages it claims, and its recorded result over
- * the conformance corpus, a member the document omits where no run is recorded.
+ * report schema versions it reads, the languages it claims, the facts version it writes,
+ * and its recorded result over the conformance corpus, a member the document omits where
+ * no run is recorded.
  */
 export function describeDocument(version, recorded) {
     const document = {
@@ -15,6 +16,7 @@ export function describeDocument(version, recorded) {
         contract_version: CONTRACT_VERSION,
         schema_versions_accepted: SCHEMA_VERSIONS,
         languages: [LANGUAGE],
+        facts_version_written: FACTS_VERSION,
         ...(recorded === undefined
             ? {}
             : {

package/jsr.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "8.0.0-dev.14",
+  "version": "8.0.0-dev.16",
   "type": "module",
   "sideEffects": false,
   "description": "Deterministic dead-code analysis for TypeScript, class and type members included",
@@ -32,7 +32,7 @@
     "lint:fix": "eslint . --fix && prettier --write ."
   },
   "dependencies": {
-    "@typescript/native": "npm:typescript@7.1.0-dev.20261029.1"
+    "@typescript/native": "npm:typescript@7.1.0-dev.20261103.1"
   },
   "overrides": {
     "qs": "^6.15.2"
@@ -43,7 +43,7 @@
     "@stryker-mutator/typescript-checker": "10.1.1",
     "@stryker-mutator/vitest-runner": "10.1.1",
     "@types/node": "24.19.2",
-    "eslint": "10.13.0",
+    "eslint": "10.14.0",
     "fast-check": "4.10.2",
     "prettier": "3.9.10",
     "typescript": "npm:@typescript/typescript6@6.0.2",

package/src/alias-chain.ts

@@ -14,7 +14,7 @@ import {
   isNamespaceImport,
 } from "@typescript/native/ast";
 import { SymbolFlags, type Symbol as TSSymbol } from "@typescript/native/sync";
-import { declarationsByName, isParameterProperty, nodeKey, type Inventory } from "./inventory.ts";
+import { isParameterProperty, nodeKey, type Inventory } from "./inventory.ts";
 import { UNANSWERED, type Answer } from "./query.ts";
 import type { ProjectView } from "./session.ts";
 
@@ -132,7 +132,7 @@ export function aliasChains<Brand>(project: ProjectView<Brand>, held: Inventory)
         names.add(node.expression.text);
       }
     }
-    const byName = declarationsByName(held);
+    const byName = held.byName;
     const ids = [...names].flatMap((name) => byName.get(name) ?? []);
     return [...new Set([...ids, ...(module ? files : [])])].map((id) => ({
       id,