@cplieger/deadset-ts 5.1.0 → 5.2.0

package/dist/src/roots.js

@@ -7,11 +7,13 @@
  * decides; the published API only supposes a consumer, so a published export is live
  * under reachability and still a candidate under reference counting.
  */
+import { isExpressionWithTypeArguments, isFunctionLikeDeclaration, isPropertyAccessExpression, isQualifiedName, isTypeQueryNode, isTypeReferenceNode, } from "@typescript/native/unstable/ast";
 import { aliasChains } from "./alias-chain.js";
 import { conventionEntries } from "./conventions.js";
 import { entryPoints } from "./entry-points.js";
 import { globExpression } from "./glob.js";
 import { nodeKey } from "./inventory.js";
+import { relativePath, resolvePath } from "./paths.js";
 import { byPosition } from "./position.js";
 import { UNANSWERED } from "./query.js";
 import { sourceFilesOf } from "./source-files.js";
@@ -22,6 +24,42 @@ const ENTRY_KINDS = {
     run: "manifest-binary",
     script: "script",
 };
+/** The rules whose rooted files a manifest target is read back to by name. */
+const READ_BACK_RULES = new Set([
+    "configuration-file",
+    "configuration-string",
+    "html-entry",
+]);
+/** The extensions a manifest target's name drops: the ones a build writes. */
+const OUTPUT_EXTENSION = /\.(?:d\.ts|d\.mts|d\.cts|js|mjs|cjs|jsx)$/u;
+/** The extension a source file's name drops. */
+const SOURCE_EXTENSION = /\.(?:d\.)?[cm]?[jt]sx?$/u;
+/**
+ * The rooted files one manifest target reads back to by name: its path below the
+ * manifest's directory, past its first directory where it names one, without its output
+ * extension, is the name, and a rooted file is one whose path below the same directory,
+ * without its source extension, ends with that name at a directory boundary.
+ */
+function readBackByName(host, entry, rooted) {
+    const dir = resolvePath(host.workingDirectory(), entry.dir);
+    const below = relativePath(dir, resolvePath(host.workingDirectory(), entry.path));
+    if (below === undefined || below === "") {
+        return [];
+    }
+    const cut = below.indexOf("/");
+    const name = (cut === -1 ? below : below.slice(cut + 1)).replace(OUTPUT_EXTENSION, "");
+    if (name === "") {
+        return [];
+    }
+    const found = new Map();
+    for (const file of rooted) {
+        const path = relativePath(dir, file.fileName)?.replace(SOURCE_EXTENSION, "");
+        if (path !== undefined && (path === name || path.endsWith(`/${name}`))) {
+            found.set(file.fileName, file);
+        }
+    }
+    return [...found.values()];
+}
 /** Whether a configured string carries either special character. */
 function isPattern(text) {
     return text.includes("*") || text.includes("?");
@@ -124,6 +162,7 @@ export function roots(project, held, targetRoot, options) {
     const enter = (file, kind, source, exports) => {
         entered.push({ file, kind, source, exports });
     };
+    const points = entryPoints(project, files, options.testFiles, options.host, targetRoot, options.parse);
     const published = [];
     const entries = [
         ...options.manifest.entries.map((entry) => ({
@@ -131,16 +170,27 @@ export function roots(project, held, targetRoot, options) {
             publishes: entry.published &&
                 (options.manifest.declaresExports ? entry.member.startsWith("exports") : true),
         })),
-        ...(options.workspaceEntries ?? []).map((entry) => ({ entry, publishes: entry.published })),
+        ...(options.otherPackages ?? []).map((entry) => ({ entry, publishes: entry.published })),
     ];
+    const scripted = entries.flatMap(({ entry }) => entry.role === "script" ? files.named(entry.path) : []);
+    const readBackTo = [
+        ...scripted,
+        ...points.filter((point) => READ_BACK_RULES.has(point.rule)).map((point) => point.file),
+    ];
+    const entryFiles = (entry) => {
+        const named = files.named(entry.path);
+        return named.length > 0 || entry.role === "script"
+            ? named
+            : readBackByName(options.host, entry, readBackTo);
+    };
     for (const { entry, publishes } of entries) {
         if (options.publishedAPI && publishes) {
-            published.push(...files.named(entry.path));
+            published.push(...entryFiles(entry));
         }
     }
     const publishedNames = new Set(published.map((file) => file.fileName));
     for (const { entry } of entries) {
-        for (const file of files.named(entry.path)) {
+        for (const file of entryFiles(entry)) {
             const kind = ENTRY_KINDS[entry.role];
             enter(file, kind, entry.member, !publishedNames.has(file.fileName));
         }
@@ -158,7 +208,7 @@ export function roots(project, held, targetRoot, options) {
         : conventionEntries(options.conventions, files)) {
         enter(file, "convention", row, true);
     }
-    for (const point of entryPoints(project, files, options.testFiles, options.host, targetRoot, options.parse)) {
+    for (const point of points) {
         enter(point.file, point.rule, point.source, point.exports);
     }
     for (const file of files.byPath.values()) {
@@ -188,10 +238,11 @@ export function roots(project, held, targetRoot, options) {
             }
         }
     }
-    if (options.publishedAPI) {
-        for (const id of publishedAPI(published, exportsOf, held)) {
-            add(id, "published-api", "");
-        }
+    const api = options.publishedAPI
+        ? publishedAPI(project, published, exportsOf, held, files.byPath)
+        : { ids: [], guessed: [] };
+    for (const id of api.ids) {
+        add(id, "published-api", "");
     }
     const unmatched = configured(held, options.patterns, add);
     const sites = new Map(held.symbols.map((symbol) => [symbol.id, symbol.position]));
@@ -205,7 +256,7 @@ export function roots(project, held, targetRoot, options) {
         configFile: project.configFile,
         liveUnderReachability: ordered,
         unmatched,
-        unanswered: answered ? [] : held.symbols.map((symbol) => symbol.id),
+        unanswered: answered ? api.guessed : held.symbols.map((symbol) => symbol.id),
     };
 }
 /**
@@ -255,52 +306,134 @@ function exportTables(project, held, wanted) {
 /** The kinds of container whose export table, not its members' visibility, says what it publishes. */
 const EXPORTING_CONTAINERS = new Set(["file", "namespace"]);
 /**
- * Every declaration a consumer of the library can name: what the published files
- * export, and below each, the members a consumer reaches through it.
- *
- * The published files are the ones `exports` reaches where the manifest declares
- * one, because a package that declares `exports` has said exactly what a consumer may
- * import; where it declares none, they are the ones the members that preceded it
- * name. Below a published module or namespace the walk follows what its export table
- * names; below any other published declaration it follows every member a consumer
- * can write: a public one, and a protected one, which a consumer's subclass names. A
- * private member is not published, nor is anything below one, and a type parameter
- * is not published either, because a consumer supplies a type argument by position.
- *
- * A published file is not itself published. A consumer imports a module and names
- * what it exports; the file is a root because the manifest names it, which is a
- * different reason.
+ * Every declaration a consumer of the library can name: what the published files export
+ * and, below each, the members a consumer writes: a namespace's exported ones, any other
+ * declaration's public and protected ones, never a private one or a type parameter. A
+ * declaration a published one's type names is published too, exported or not. A type name
+ * the checker leaves unanswered publishes every declaration spelled as it is, and those are
+ * `guessed`. A published file is not itself published.
  */
-function publishedAPI(published, exportsOf, held) {
+function publishedAPI(project, published, exportsOf, held, byPath) {
     const byId = new Map(held.symbols.map((symbol) => [symbol.id, symbol]));
     const children = childrenOf(held);
+    const nodes = declarationNodes(held, byPath);
+    const chains = aliasChains(project, held);
     const reached = new Set();
+    const guessed = new Set();
     const pending = [];
+    const reach = (id) => {
+        if (!reached.has(id) && byId.get(id)?.kind !== "file") {
+            reached.add(id);
+            pending.push(id);
+        }
+    };
     for (const file of published) {
         for (const id of exportsOf.get(file.fileName) ?? []) {
             if (byId.get(id)?.kind === "file") {
                 pending.push(id);
             }
-            else if (!reached.has(id)) {
-                reached.add(id);
-                pending.push(id);
+            else {
+                reach(id);
             }
         }
     }
-    for (let next = pending.shift(); next !== undefined; next = pending.shift()) {
-        const exporting = EXPORTING_CONTAINERS.has(byId.get(next)?.kind ?? "");
-        for (const member of children.get(next) ?? []) {
-            const reachable = exporting
-                ? member.exported
-                : member.visibility !== "private" && member.visibility !== "private-name";
-            if (member.kind === "type-parameter" || reached.has(member.id) || !reachable) {
-                continue;
+    while (pending.length > 0) {
+        const round = [];
+        for (let next = pending.shift(); next !== undefined; next = pending.shift()) {
+            round.push(next);
+            const exporting = EXPORTING_CONTAINERS.has(byId.get(next)?.kind ?? "");
+            for (const member of children.get(next) ?? []) {
+                const reachable = exporting
+                    ? member.exported
+                    : member.visibility !== "private" && member.visibility !== "private-name";
+                if (member.kind !== "type-parameter" && reachable) {
+                    reach(member.id);
+                }
             }
-            reached.add(member.id);
-            pending.push(member.id);
         }
+        const named = round.flatMap((id) => {
+            const symbol = byId.get(id);
+            return symbol === undefined || symbol.kind === "file" ? [] : nodes.typeNamesOf(symbol);
+        });
+        project.symbolsAt(named.map((node) => project.handle(node))).forEach((symbol, index) => {
+            if (symbol === UNANSWERED) {
+                for (const id of held.byName.get(named[index]?.getText() ?? "") ?? []) {
+                    guessed.add(id);
+                    reach(id);
+                }
+            }
+            else if (symbol !== undefined) {
+                for (const target of chains.chainOf(symbol)) {
+                    reach(target.id);
+                }
+            }
+        });
     }
-    return [...reached];
+    return { ids: [...reached], guessed: [...guessed] };
+}
+/** The type names declarations of the inventory write, each file walked once, when first asked. */
+function declarationNodes(held, byPath) {
+    const walked = new Map();
+    const nodesIn = (path) => {
+        const known = walked.get(path);
+        if (known !== undefined) {
+            return known;
+        }
+        const found = { byId: new Map(), nodes: new Set() };
+        const file = byPath.get(path);
+        if (file !== undefined) {
+            const visit = (node) => {
+                const id = held.declarations.get(nodeKey(file, node));
+                if (id !== undefined) {
+                    found.nodes.add(node);
+                    if (!found.byId.has(id)) {
+                        found.byId.set(id, node);
+                    }
+                }
+                node.forEachChild(visit);
+            };
+            visit(file);
+        }
+        walked.set(path, found);
+        return found;
+    };
+    return {
+        typeNamesOf: (symbol) => {
+            const { byId, nodes } = nodesIn(symbol.position.path);
+            const declaration = byId.get(symbol.id);
+            return declaration === undefined ? [] : typeNamesOf(declaration, nodes);
+        },
+    };
+}
+/**
+ * The names of types one declaration's own syntax writes: in a type reference, a
+ * heritage clause or a type query. A function body is not read, and neither is a
+ * declaration nested in this one, which `nested` holds and which is read on its own.
+ */
+function typeNamesOf(declaration, nested) {
+    const found = [];
+    const visit = (node) => {
+        if (node !== declaration && nested.has(node)) {
+            return;
+        }
+        if (isTypeReferenceNode(node)) {
+            found.push(isQualifiedName(node.typeName) ? node.typeName.right : node.typeName);
+        }
+        else if (isExpressionWithTypeArguments(node)) {
+            found.push(isPropertyAccessExpression(node.expression) ? node.expression.name : node.expression);
+        }
+        else if (isTypeQueryNode(node)) {
+            found.push(isQualifiedName(node.exprName) ? node.exprName.right : node.exprName);
+        }
+        const body = isFunctionLikeDeclaration(node) ? node.body : undefined;
+        node.forEachChild((child) => {
+            if (child !== body) {
+                visit(child);
+            }
+        });
+    };
+    visit(declaration);
+    return found;
 }
 /**
  * Keeps every declaration the configuration names and returns every string that

package/dist/src/session.js

@@ -225,10 +225,10 @@ function projectsOf(snapshot, built, written) {
  * snapshot of one client, and answers in their order. A configuration `programs` describes is
  * built as that program, or opened from the configuration it writes, instead of as a project.
  * One the snapshot holds nothing for ends the run under `"refuse"` and is named in the result
- * under `"record"`. The snapshot is disposed after the last visit and the client released
- * after it, whether the visit completed or threw.
+ * under `"record"`. `last` runs after the last visit while the client still answers; the
+ * snapshot is disposed and the client released after it, whether the visit completed or threw.
  */
-export function runSession(engine, configFiles, visit, unopened = "refuse", programs = new Map()) {
+export function runSession(engine, configFiles, visit, unopened = "refuse", programs = new Map(), last = () => undefined) {
     try {
         const built = [];
         const params = [];
@@ -262,6 +262,7 @@ export function runSession(engine, configFiles, visit, unopened = "refuse", prog
                 }
                 projects.push(visit(viewOf(project, configFile, engine, log)));
             }
+            last();
             return {
                 projects,
                 unopened: missing,

package/dist/src/sweep.js

@@ -70,6 +70,23 @@ export function sweep(graph, input) {
     });
     return { liveUnder: live, candidates };
 }
+/**
+ * Per declaration of the graph, whether the run that counts test references reaches it.
+ * That run's roots are the graph's own and each test file, being the file's top level
+ * and every declaration it exports, which a test runner may call; `held` seeds it as a
+ * mark or an exemption seeds a sweep.
+ */
+export function reachedWithTheTests(graph, held) {
+    const tests = graph.symbols.flatMap((symbol, at) => {
+        const top = symbol.kind === "file" || graph.symbols[graph.parent[at] ?? OUTSIDE]?.kind === "file";
+        return graph.test[at] === true && top && (symbol.kind === "file" || symbol.exported)
+            ? [{ at, kind: "test-runner" }]
+            : [];
+    });
+    return reachable({ ...graph, rooted: [...graph.rooted, ...tests] }, flagged(graph, held), {
+        production: false,
+    });
+}
 /**
  * The references a loaded consumer makes that the mode counts. A production mode counts
  * none a consumer's test file made, as it counts none of the target's.

package/dist/src/template-field.js

@@ -87,12 +87,69 @@ function stringEnd(text, from) {
     }
     return at + 1;
 }
-/** The identifiers one action's inner text writes outside a quoted string, with their offsets in it. */
-function identifiersOf(inner) {
+/** The end of the `${` substitution whose expression starts at `from`, past its closing brace. */
+function substitutionEnd(text, from) {
+    let depth = 1;
+    let at = from;
+    while (at < text.length) {
+        const char = text[at];
+        if (char === '"' || char === "'") {
+            at = stringEnd(text, at);
+            continue;
+        }
+        if (char === "`") {
+            at = templateEnd(text, at, () => undefined);
+            continue;
+        }
+        if (char === "{") {
+            depth += 1;
+        }
+        else if (char === "}") {
+            depth -= 1;
+            if (depth === 0) {
+                return at + 1;
+            }
+        }
+        at += 1;
+    }
+    return at;
+}
+/** The end of the template literal at `from`; each `${…}` expression goes to `substitution`. */
+function templateEnd(text, from, substitution) {
+    let at = from + 1;
+    while (at < text.length && text[at] !== "`") {
+        if (text[at] === "\\") {
+            at += 2;
+            continue;
+        }
+        if (text[at] === "$" && text[at + 1] === "{") {
+            const start = at + 2;
+            const end = substitutionEnd(text, start);
+            substitution(text.slice(start, end - 1), start);
+            at = end;
+            continue;
+        }
+        at += 1;
+    }
+    return at + 1;
+}
+/**
+ * The identifiers one action's inner text writes outside a quoted string, with their offsets
+ * in it. In `script` text, a component's markup, a template literal's substitutions are code.
+ */
+function identifiersOf(inner, script = false) {
     const found = [];
     let at = 0;
     while (at < inner.length) {
         const char = inner[at] ?? "";
+        if (char === "`" && script) {
+            at = templateEnd(inner, at, (expression, offset) => {
+                for (const one of identifiersOf(expression, true)) {
+                    found.push({ name: one.name, offset: offset + one.offset });
+                }
+            });
+            continue;
+        }
         if (char === '"' || char === "'" || char === "`") {
             at = stringEnd(inner, at);
             continue;
@@ -142,7 +199,7 @@ function namesOf(text, delimiters) {
 }
 /** Every identifier the markup of one component file writes in an action. */
 function markupNamesOf(text) {
-    return readComponent(text).markup.flatMap((one) => identifiersOf(one.text).map(({ name, offset }) => ({
+    return readComponent(text).markup.flatMap((one) => identifiersOf(one.text, true).map(({ name, offset }) => ({
         name,
         offset: one.start + offset,
         action: one.action,

package/dist/src/test-support.js

@@ -1,47 +1,59 @@
 /**
- * Test-support code: a file that is not a test file by name and that only test code
- * imports. At least one test file reaches it, directly or through other such files, and
- * nothing else does, so it is judged with the tests: what it references is referenced by
- * test code, and a declaration of it is live while test code references it.
+ * Test-support code: the files only tests reach. A test reaches each one through a chain
+ * of references, and every reference to a declaration of one, an import for its effects
+ * included, is written in a test file or in another such file, so it is judged with the
+ * tests: what it references is referenced by test code.
  */
 /** The root kind that never takes a file out of test-support code: the skip only withholds. */
 const SKIP_ROOT = "type-error";
 /**
- * The files of one project that are test-support code, below the target root. A file
- * holding a root is not one, because a root has a caller outside the import graph: a
- * runtime, a tool, a configuration, or a consumer of a library's published API.
- * `testFiles` are the files the test-file rules classified.
+ * The files of one project that are test-support code, below the target root: the
+ * largest set of files a test file reaches, none of them a test file or holding a root,
+ * whose every user outside the set is a test file. A root has a caller outside the
+ * reference graph: a runtime, a tool, a configuration, or a consumer of a library's
+ * published API. `testFiles` are the files the test-file rules classified.
  */
 export function testSupportFiles(symbols, references, roots, testFiles) {
     const fileOf = new Map(symbols.map((symbol) => [symbol.id, symbol.position.path]));
     const users = new Map();
+    const uses = new Map();
+    const add = (map, key, value) => {
+        const held = map.get(key);
+        if (held === undefined) {
+            map.set(key, new Set([value]));
+        }
+        else {
+            held.add(value);
+        }
+    };
     for (const reference of references) {
         const used = fileOf.get(reference.to);
         const from = reference.position.path;
         if (reference.consumer !== undefined || used === undefined || used === from) {
             continue;
         }
-        const held = users.get(used);
-        if (held === undefined) {
-            users.set(used, new Set([from]));
-        }
-        else {
-            held.add(from);
-        }
+        add(users, used, from);
+        add(uses, from, used);
     }
     const tests = new Set(testFiles);
     const rooted = new Set(roots.filter((root) => root.kind !== SKIP_ROOT).flatMap((root) => fileOf.get(root.id) ?? []));
-    const candidates = [...users.keys()].filter((path) => !tests.has(path) && !rooted.has(path));
-    const support = new Set();
+    const reached = new Set();
+    const queue = [...tests];
+    for (let path = queue.pop(); path !== undefined; path = queue.pop()) {
+        for (const next of uses.get(path) ?? []) {
+            if (!reached.has(next) && !tests.has(next)) {
+                reached.add(next);
+                queue.push(next);
+            }
+        }
+    }
+    const support = new Set([...reached].filter((path) => !rooted.has(path)));
     for (let changed = true; changed;) {
         changed = false;
-        for (const path of candidates) {
-            if (support.has(path)) {
-                continue;
-            }
+        for (const path of support) {
             const from = users.get(path) ?? new Set();
-            if ([...from].every((one) => tests.has(one) || support.has(one))) {
-                support.add(path);
+            if (![...from].every((one) => tests.has(one) || support.has(one))) {
+                support.delete(path);
                 changed = true;
             }
         }

package/dist/src/version.js

@@ -4,4 +4,4 @@
  * independently of the analyzer's own version, which is the one the host answers
  * from the package the analyzer was installed from.
  */
-export const CONTRACT_VERSION = "5.2.0";
+export const CONTRACT_VERSION = "5.3.0";

package/jsr.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "5.1.0",
+  "version": "5.2.0",
   "type": "module",
   "sideEffects": false,
   "description": "Deterministic dead-code analysis for TypeScript, class and type members included",