@cplieger/deadset-ts 3.13.0 → 4.0.1

package/dist/src/verbs/explain.js

@@ -3,6 +3,7 @@ import { listing } from "../components.js";
 import { ConfigError } from "../config.js";
 import { OUTSIDE, swept as judged } from "../graph.js";
 import { referenceKey } from "../matrix.js";
+import { partialNotes } from "../partial.js";
 import { positionKey } from "../position.js";
 import { resolve } from "../resolve.js";
 import { EXIT_CLEAN, EXIT_USAGE } from "./verb.js";
@@ -282,18 +283,22 @@ function explanation(analysis, subject, cascade) {
             text += `  class: ${one.class}\t${positionKey(one.site)}\t${one.detail}\n`;
         }
     }
+    else if (analysis.swept.heldByUnanswered.includes(subject.id)) {
+        text +=
+            "answer: held\n  held by: a question the checker did not answer, which could have kept it live, so no finding names it\n";
+    }
     else {
         text += liveness(analysis, subject, cascade);
     }
     return text + namedElsewhere(analysis.result.findings, subject);
 }
 /**
- * Explains one symbol from the analysis the report is built from, so an explanation cannot
- * disagree with a finding: why a reported symbol is reported, which exemption classes held a
- * retained one back, and for any other declaration the relations that hold it live and the
- * shortest path of references from a root or a loaded consumer, or the references it has where
- * no path reaches it. A request naming no one declaration exits with the usage code and names
- * what partially matches it.
+ * Explains one symbol from the analysis the report is built from: why a reported symbol is
+ * reported, which exemption classes held a retained one back, that an unanswered question held
+ * a held one, and for any other declaration the relations that hold it live and the shortest
+ * path from a root or a loaded consumer, or the references it has where no path reaches it. A
+ * request naming no one declaration exits with the usage code and names what partially
+ * matches it. Where the analysis was partial, the error stream says so.
  */
 export const explainVerb = ({ out, err, host, inputs, scope, openClient, option }) => {
     const named = namedSymbol(option);
@@ -302,6 +307,10 @@ export const explainVerb = ({ out, err, host, inputs, scope, openClient, option
         production: true,
     });
     const { subject, candidates } = subjectOf(analysis.swept.matrix.union.symbols, named);
+    const notes = partialNotes({
+        notBuilt: analysis.run.notBuilt,
+        unanswered: analysis.run.unanswered,
+    });
     if (subject === undefined) {
         err.write(`deadset-ts: ${JSON.stringify(named)} names no one symbol of the target\n`);
         for (const candidate of candidates) {
@@ -310,8 +319,12 @@ export const explainVerb = ({ out, err, host, inputs, scope, openClient, option
         if (candidates.length === 0) {
             err.write("  no symbol of the target partially matches it either\n");
         }
-        return EXIT_USAGE;
     }
-    out.write(explanation(analysis, subject, config.reporters.cascade));
-    return EXIT_CLEAN;
+    else {
+        out.write(explanation(analysis, subject, config.reporters.cascade));
+    }
+    for (const note of notes) {
+        err.write(`deadset-ts: ${note}\n`);
+    }
+    return subject === undefined ? EXIT_USAGE : EXIT_CLEAN;
 };

package/dist/src/verbs/print-projects.js

@@ -1,4 +1,6 @@
-import { diagnosticErrors, discoverProjects, renderDiagnostic } from "../discover.js";
+import { discoverProjects, DiscoveryError, isGuess, projectErrors, renderDiagnostic, targetRelative, } from "../discover.js";
+import { partialNotes } from "../partial.js";
+import { relativePath, resolvePath } from "../paths.js";
 import { resolveMatrix } from "../resolve.js";
 import { diagnosticsOf, runSession } from "../session.js";
 import { EXIT_CLEAN, EXIT_FAILURE } from "./verb.js";
@@ -6,7 +8,8 @@ import { EXIT_CLEAN, EXIT_FAILURE } from "./verb.js";
  * Writes the name of every project one run analyzes, one per line, having read each
  * project's diagnostics first: the identifier the build matrix declares for it, or,
  * where discovery derived the project, its configuration file's path below the
- * target root.
+ * target root. A derived project that does not load is not one the run analyzes, so it
+ * is named on the error stream instead, as the analysis drops it.
  */
 export const printProjectsVerb = ({ out, err, host, inputs, scope, openClient }) => {
     const matrix = resolveMatrix(inputs());
@@ -14,21 +17,51 @@ export const printProjectsVerb = ({ out, err, host, inputs, scope, openClient })
     const engine = openClient(false);
     const discovered = discoverProjects(engine, host, scoped, matrix);
     const ids = new Map(discovered.projects.map((project) => [project.configFile, project.id]));
+    const root = resolvePath(host.workingDirectory(), scoped.target.path);
+    const notBuilt = [...discovered.notBuilt];
     const failures = [];
-    const { projects } = runSession(engine, discovered.configFiles, (project) => {
-        const errors = diagnosticErrors(diagnosticsOf(project));
-        failures.push(...errors.map(renderDiagnostic));
-        return ids.get(project.configFile) ?? project.configFile;
-    });
+    const session = runSession(engine, discovered.configFiles, (project) => {
+        const id = ids.get(project.configFile) ?? project.configFile;
+        const errors = projectErrors(diagnosticsOf(project));
+        const [unloaded] = errors.load;
+        if (unloaded !== undefined && isGuess(discovered, project.configFile)) {
+            const error = renderDiagnostic(unloaded, (path) => relativePath(root, path) ?? path);
+            notBuilt.push({ id, configFile: project.configFile, error: targetRelative(error, root) });
+            return undefined;
+        }
+        failures.push(...[...errors.load, ...errors.check].map((one) => renderDiagnostic(one)));
+        return id;
+    }, discovered.derived ? "record" : "refuse");
+    for (const configFile of session.unopened) {
+        if (!isGuess(discovered, configFile)) {
+            throw new DiscoveryError(`${configFile} opened no project`, []);
+        }
+        notBuilt.push({
+            id: ids.get(configFile) ?? configFile,
+            configFile,
+            error: "the compiler opened no project for the configuration",
+        });
+    }
     if (failures.length > 0) {
         for (const line of failures) {
             err.write(`${line}\n`);
         }
-        err.write(`deadset-ts: ${String(failures.length)} error(s); no answer was produced\n`);
+        err.write(`deadset-ts: ${String(failures.length)} error(s), so no answer was produced\n`);
+        return EXIT_FAILURE;
+    }
+    const projects = session.projects.filter((id) => id !== undefined);
+    if (projects.length === 0 && notBuilt.length > 0) {
+        for (const note of partialNotes({ notBuilt, unanswered: [] })) {
+            err.write(`deadset-ts: ${note}\n`);
+        }
+        err.write("deadset-ts: no configuration discovery derived could be built\n");
         return EXIT_FAILURE;
     }
     for (const id of projects) {
         out.write(`${id}\n`);
     }
+    for (const note of partialNotes({ notBuilt, unanswered: [] })) {
+        err.write(`deadset-ts: ${note}\n`);
+    }
     return EXIT_CLEAN;
 };

package/dist/src/verbs/print-retained.js

@@ -1,5 +1,6 @@
 import { runSweep } from "../analysis.js";
 import { retainedLines } from "../exempt.js";
+import { partialNotes } from "../partial.js";
 import { resolve } from "../resolve.js";
 import { EXIT_CLEAN } from "./verb.js";
 /**
@@ -7,9 +8,9 @@ import { EXIT_CLEAN } from "./verb.js";
  * built from, one per line, and nothing where no exemption held one back. One fact
  * several configurations found is one record, so the line names no configuration. The
  * line shape is this command's own rather than a Contract format, so that sort and cut
- * read it.
+ * read it. Where the analysis was partial, the error stream says so.
  */
-export const printRetainedVerb = ({ out, host, inputs, scope, openClient }) => {
+export const printRetainedVerb = ({ out, err, host, inputs, scope, openClient }) => {
     const { config } = resolve(inputs());
     const scoped = scope();
     const swept = runSweep(openClient(false), host, scoped, config, {
@@ -19,5 +20,8 @@ export const printRetainedVerb = ({ out, host, inputs, scope, openClient }) => {
     for (const line of retainedLines(swept.matrix.union.symbols, swept.retained)) {
         out.write(`${line}\n`);
     }
+    for (const note of partialNotes({ notBuilt: swept.notBuilt, unanswered: swept.unanswered })) {
+        err.write(`deadset-ts: ${note}\n`);
+    }
     return EXIT_CLEAN;
 };

package/dist/src/verbs/print-roots.js

@@ -1,4 +1,5 @@
 import { runRoots } from "../analysis.js";
+import { partialNotes } from "../partial.js";
 import { resolve } from "../resolve.js";
 import { EXIT_CLEAN, EXIT_FINDINGS } from "./verb.js";
 /**
@@ -18,7 +19,7 @@ function rootLine(root, several) {
 /**
  * Writes the root set of the run, one root per line, and then names on the error
  * stream, by its issue kind, every configured root or pattern that named nothing;
- * one such string fails the run. The line shape is this command's own rather than a
+ * one such string fails the run, and then where the analysis was partial. The line shape is this command's own rather than a
  * Contract format, so that sort and cut read it.
  */
 export const printRootsVerb = ({ out, err, host, inputs, scope, openClient }) => {
@@ -32,5 +33,8 @@ export const printRootsVerb = ({ out, err, host, inputs, scope, openClient }) =>
     for (const finding of answer.findings) {
         err.write(`${finding.code}: roots.patterns names nothing: ${finding.symbol.ref}\n`);
     }
+    for (const note of partialNotes({ notBuilt: answer.notBuilt, unanswered: answer.unanswered })) {
+        err.write(`deadset-ts: ${note}\n`);
+    }
     return answer.findings.length > 0 ? EXIT_FINDINGS : EXIT_CLEAN;
 };

package/jsr.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "3.13.0",
+  "version": "4.0.1",
   "type": "module",
   "sideEffects": false,
   "description": "Deterministic dead-code analysis for TypeScript, class and type members included",
@@ -28,7 +28,7 @@
     "lint:fix": "eslint . --fix && prettier --write ."
   },
   "dependencies": {
-    "@typescript/native": "npm:typescript@7.0.2"
+    "@typescript/native": "npm:typescript@7.1.0-dev.20261003.1"
   },
   "devDependencies": {
     "@eslint/js": "10.0.1",
@@ -38,7 +38,7 @@
     "prettier": "3.9.9",
     "typescript": "npm:@typescript/typescript6@6.0.2",
     "typescript-eslint": "8.71.0",
-    "vitest": "5.0.2"
+    "vitest": "5.0.3"
   },
   "publishConfig": {
     "access": "public"

package/src/alias-chain.ts

@@ -4,8 +4,18 @@
  * declaration every link of that chain is.
  */
 
+import {
+  isExportAssignment,
+  isExportSpecifier,
+  isIdentifier,
+  isImportClause,
+  isImportSpecifier,
+  isNamespaceExport,
+  isNamespaceImport,
+} from "@typescript/native/unstable/ast";
 import { SymbolFlags, type Symbol as TSSymbol } from "@typescript/native/unstable/sync";
-import { nodeKey, type Inventory } from "./inventory.ts";
+import { declarationsByName, nodeKey, type Inventory } from "./inventory.ts";
+import { UNANSWERED, type Answer } from "./query.ts";
 import type { ProjectView } from "./session.ts";
 
 /** One declaration a chain reaches, and whether a step along an alias reached it. */
@@ -13,6 +23,11 @@ export interface ChainTarget {
   readonly id: string;
   /** False for a declaration the head symbol itself is, true for one a link stands for. */
   readonly stepped: boolean;
+  /**
+   * True where the compiler did not answer a step and the declaration is one the link
+   * may stand for by the name it carries.
+   */
+  readonly guessed: boolean;
 }
 
 /** The chain walks over one project's aliases, each step asked of the compiler once. */
@@ -33,7 +48,7 @@ export interface AliasChains {
    * inventory declares, stepping over the links it does not, or none where no later
    * link is declared.
    */
-  nextDeclared(symbol: TSSymbol): readonly string[];
+  nextDeclared(symbol: TSSymbol): readonly ChainTarget[];
   /** How many steps the compiler was asked for: one per alias, whatever the chains it heads. */
   readonly steps: number;
 }
@@ -47,8 +62,8 @@ export interface AliasChains {
  * library file is never fetched to find out that the inventory does not hold it.
  */
 export function aliasChains<Brand>(project: ProjectView<Brand>, held: Inventory): AliasChains {
-  const ownFiles = new Set(project.ownSourceFiles().map((file) => file.fileName));
-  const steps = new Map<number, TSSymbol | undefined>();
+  const ownFiles = project.ownPaths();
+  const steps = new Map<number, Answer<TSSymbol | undefined>>();
   const chains = new Map<number, readonly ChainTarget[]>();
   let asked = 0;
 
@@ -74,7 +89,7 @@ export function aliasChains<Brand>(project: ProjectView<Brand>, held: Inventory)
    * expression is written in an alias form and names nothing declared elsewhere, so its
    * chain ends at itself.
    */
-  const stepOf = (symbol: TSSymbol): TSSymbol | undefined => {
+  const stepOf = (symbol: TSSymbol): Answer<TSSymbol | undefined> => {
     if ((symbol.flags & SymbolFlags.Alias) === 0) {
       return undefined;
     }
@@ -87,38 +102,87 @@ export function aliasChains<Brand>(project: ProjectView<Brand>, held: Inventory)
     return next;
   };
 
+  const files = held.symbols.filter((one) => one.kind === "file").map((one) => one.id);
+
+  /**
+   * The declarations an alias whose step went unanswered may stand for: every one the
+   * inventory holds under its own name or the name it carries forward, and every file
+   * where it carries a module, so a use through it still counts for what it reaches.
+   */
+  const sameNamed = (alias: TSSymbol): readonly ChainTarget[] => {
+    const names = new Set([alias.name]);
+    let module = false;
+    for (const handle of alias.declarations) {
+      const node = ownFiles.has(handle.path) ? project.declarationAt(handle)?.node : undefined;
+      if (node === undefined) {
+        continue;
+      }
+      if ((isImportSpecifier(node) || isExportSpecifier(node)) && node.propertyName !== undefined) {
+        names.add(node.propertyName.text);
+      } else if (isImportClause(node)) {
+        names.add("default");
+      } else if (isNamespaceImport(node) || isNamespaceExport(node)) {
+        module = true;
+      } else if (isExportAssignment(node) && isIdentifier(node.expression)) {
+        names.add(node.expression.text);
+      }
+    }
+    const byName = declarationsByName(held);
+    const ids = [...names].flatMap((name) => byName.get(name) ?? []);
+    return [...new Set([...ids, ...(module ? files : [])])].map((id) => ({
+      id,
+      stepped: true,
+      guessed: true,
+    }));
+  };
+
   const chainOf = (symbol: TSSymbol): readonly ChainTarget[] => {
     const cached = chains.get(symbol.id);
     if (cached !== undefined) {
       return cached;
     }
     const targets: ChainTarget[] = [];
+    const add = (id: string, stepped: boolean, guessed = false): void => {
+      if (!targets.some((target) => target.id === id)) {
+        targets.push({ id, stepped, guessed });
+      }
+    };
     const walked = new Set<number>();
     let at: TSSymbol | undefined = symbol;
     let stepped = false;
     while (at !== undefined && !walked.has(at.id)) {
       walked.add(at.id);
       for (const id of declarationsOf(at)) {
-        if (!targets.some((target) => target.id === id)) {
-          targets.push({ id, stepped });
+        add(id, stepped);
+      }
+      const next = stepOf(at);
+      if (next === UNANSWERED) {
+        for (const target of sameNamed(at)) {
+          add(target.id, true, true);
         }
+        break;
       }
-      at = stepOf(at);
+      at = next;
       stepped = true;
     }
     chains.set(symbol.id, targets);
     return targets;
   };
 
-  const nextDeclared = (symbol: TSSymbol): readonly string[] => {
+  const nextDeclared = (symbol: TSSymbol): readonly ChainTarget[] => {
     const walked = new Set<number>([symbol.id]);
+    let from = symbol;
     let at = stepOf(symbol);
-    while (at !== undefined && !walked.has(at.id)) {
+    while (at !== undefined && (at === UNANSWERED || !walked.has(at.id))) {
+      if (at === UNANSWERED) {
+        return sameNamed(from);
+      }
       walked.add(at.id);
       const ids = declarationsOf(at);
       if (ids.length > 0) {
-        return ids;
+        return ids.map((id) => ({ id, stepped: true, guessed: false }));
       }
+      from = at;
       at = stepOf(at);
     }
     return [];