@cplieger/deadset-ts 8.0.0-dev.15 → 8.0.0-dev.17

package/src/load/classify.ts

@@ -1,5 +1,5 @@
 import type { SourceFile } from "@typescript/native/ast";
-import { conventionFailuresFor } from "../conventions.ts";
+import { conventionFailuresFor } from "../entries/conventions.ts";
 import type { Host } from "../host.ts";
 import { relativePath, resolvePath } from "../paths.ts";
 import { diagnosticsOf, ownedAs, type Engine, type ProjectView } from "../session.ts";
@@ -11,7 +11,13 @@ import {
   renderDiagnostic,
   type LocatedDiagnostic,
 } from "./diagnostics.ts";
-import { targetRelative, type LoadedConsumer, type NotBuilt, type Origin } from "./discover.ts";
+import {
+  targetRelative,
+  unreadableDetail,
+  type LoadedConsumer,
+  type NotBuilt,
+  type Origin,
+} from "./discover.ts";
 import { missingModule, pathsOf, type ModuleContext } from "./expected-module.ts";
 import { FailureExit, failureLine, type Failure } from "../failure.ts";
 import type { ProgramPlan, RunPlan } from "./plan.ts";
@@ -21,8 +27,12 @@ import { ownErrors } from "./workspace-run.ts";
 
 /** What keeps one configuration from being analyzed. */
 type Failed =
-  /** Its project carries an error that leaves it unloaded. */
-  | { readonly kind: "load"; readonly errors: readonly [LocatedDiagnostic, ...LocatedDiagnostic[]] }
+  /** Its project carries an error that leaves it unloaded, its configuration unreadable or not. */
+  | {
+      readonly kind: "load";
+      readonly errors: readonly [LocatedDiagnostic, ...LocatedDiagnostic[]];
+      readonly unreadable: boolean;
+    }
   | { readonly kind: "setup"; readonly failures: readonly [Failure, ...Failure[]] }
   /** The snapshot opened no project for it. */
   | { readonly kind: "unopened" };
@@ -162,7 +172,7 @@ function classifyTarget<Brand>(
   const raw = projectErrors(diagnosticsOf(project));
   const load = nonEmpty(raw.load);
   if (load !== undefined) {
-    return { kind: "load", errors: load };
+    return { kind: "load", errors: load, unreadable: raw.unreadable };
   }
   const reading = readErrors(project, plan, ownErrors(raw.check, referenceOnly), {
     host,
@@ -236,7 +246,7 @@ function classifyConsumer<Brand>(
   const raw = projectErrors(diagnosticsOf(project));
   const load = nonEmpty(raw.load);
   if (load !== undefined) {
-    return { kind: "load", errors: load };
+    return { kind: "load", errors: load, unreadable: raw.unreadable };
   }
   let faulted: string | undefined;
   const reading = readErrors(project, plan, raw.check, {
@@ -283,7 +293,8 @@ function ending(plan: ProgramPlan, failed: Failed, root: string): readonly Failu
   return plan.consumer === undefined
     ? [
         {
-          failureClass: "no-program",
+          failureClass:
+            failed.kind === "load" && failed.unreadable ? "unreadable-configuration" : "no-program",
           detail: `${what}: correct the configuration, or name the configurations to analyze`,
         },
       ]
@@ -295,6 +306,30 @@ function ending(plan: ProgramPlan, failed: Failed, root: string): readonly Failu
       ];
 }
 
+/** The setup failures a dropped derived configuration counts as, where it counts as any. */
+function droppedFailures(
+  failed: Failed,
+  plan: ProgramPlan,
+  root: string,
+): { readonly failures?: readonly [Failure, ...Failure[]] } {
+  if (failed.kind === "setup") {
+    return { failures: failed.failures };
+  }
+  return failed.kind === "load" && failed.unreadable
+    ? {
+        failures: [
+          {
+            failureClass: "unreadable-configuration",
+            detail: unreadableDetail(
+              plan.id,
+              `cannot be read as a compiler configuration: ${droppedBy(failed, root)}`,
+            ),
+          },
+        ],
+      }
+    : {};
+}
+
 /** The first line of the error that drops one derived configuration. */
 function droppedBy(failed: Failed, root: string): string {
   return failed.kind === "load"
@@ -326,7 +361,6 @@ export function classify(
   const analyzed: Analyzed<unknown>[] = [];
   const consumed: Consumed<unknown>[] = [];
   const ended = new Map<Failed["kind"], { plan: ProgramPlan; failed: Failed }[]>();
-  const dropped: Failed[] = [];
   const unopened = run.plans.filter((plan) => !views.has(plan.configFile));
   const outcomes = [
     ...run.plans.flatMap((plan) => {
@@ -355,8 +389,12 @@ export function classify(
     } else if (POLICY[plan.origin][outcome.kind] === "end") {
       ended.set(outcome.kind, [...(ended.get(outcome.kind) ?? []), { plan, failed: outcome }]);
     } else {
-      dropped.push(outcome);
-      notBuilt.push({ id: plan.id, configFile: plan.configFile, error: droppedBy(outcome, root) });
+      notBuilt.push({
+        id: plan.id,
+        configFile: plan.configFile,
+        error: droppedBy(outcome, root),
+        ...droppedFailures(outcome, plan, root),
+      });
     }
   }
   for (const kind of ["unopened", "setup", "load"] as const) {
@@ -369,9 +407,7 @@ export function classify(
       );
     }
   }
-  const setupDropped = nonEmpty(
-    dropped.flatMap((one) => (one.kind === "setup" ? one.failures : [])),
-  );
+  const setupDropped = nonEmpty(notBuilt.flatMap((one) => one.failures ?? []));
   const [first] = notBuilt;
   if (analyzed.length === 0 && first !== undefined) {
     throw new FailureExit(

package/src/load/diagnostics.ts

@@ -121,10 +121,18 @@ export function diagnosticErrors(sets: {
   return [...sets.configParsing, ...sets.syntactic, ...sets.semantic].filter(isError);
 }
 
+/**
+ * The code of a configuration whose only parse error is that its inputs name no file: it reads
+ * as written and holds no program.
+ */
+const NO_INPUTS = 18003;
+
 /** Why one open project cannot be analyzed as it stands, split by whether it loaded at all. */
 interface ProjectErrors {
   /** The configuration's own errors and the errors in no file the table reads as a load failure. */
   readonly load: readonly LocatedDiagnostic[];
+  /** Whether the compiler cannot read the configuration: a parse error other than {@link NO_INPUTS}. */
+  readonly unreadable: boolean;
   /** The errors in the files of a project that loaded. */
   readonly check: readonly LocatedDiagnostic[];
   /** The libraries the configuration names that the compiler cannot find, of a project that loaded. */
@@ -135,9 +143,11 @@ interface ProjectErrors {
 export function projectErrors(sets: ProjectDiagnostics): ProjectErrors {
   const unplaced = (kind: DiagnosticClass): readonly Diagnostic[] =>
     sets.unplaced.filter((diagnostic) => classOf(diagnostic, false) === kind);
-  const load = [...sets.configParsing.filter(isError), ...unplaced("load")];
+  const parsing = sets.configParsing.filter(isError);
+  const load = [...parsing, ...unplaced("load")];
   return {
     load: locatedIn(load, sets.locate),
+    unreadable: parsing.some(({ code }) => code !== NO_INPUTS),
     check: load.length > 0 ? [] : locatedIn(diagnosticErrors(sets), sets.locate),
     unfound: load.length > 0 ? [] : locatedIn(unplaced("unfound-library"), sets.locate),
   };

package/src/load/discover.ts

@@ -8,7 +8,7 @@ import { LANGUAGE, message } from "../product.ts";
 import type { Module, Scope } from "../scope.ts";
 import type { Engine } from "../session.ts";
 import { globExpression } from "../text/glob.ts";
-import { failureExit, type FailureExit } from "../failure.ts";
+import { failureExit, type Failure, type FailureExit } from "../failure.ts";
 import { MANIFEST } from "../fs/manifest.ts";
 
 /** The names of the files a program of the language is read from. */
@@ -72,6 +72,8 @@ export interface NotBuilt {
   readonly configFile: string;
   /** The error's first line, every path below the target root spelled relative to it. */
   readonly error: string;
+  /** The setup failures that dropped it, where one did. */
+  readonly failures?: readonly [Failure, ...Failure[]];
 }
 
 /**
@@ -165,11 +167,9 @@ function readConfiguration(
   try {
     const parsed = engine.parseConfigFile(configFile);
     const circular = parsed.errors.find(({ code }) => code === CIRCULAR_EXTENDS);
-    // The compiler leaves the message's `{0}` unfilled:
-    // https://github.com/microsoft/TypeScript/pull/64755
     return circular === undefined
       ? { parsed }
-      : { reason: `TS${String(circular.code)}: ${circular.text.replace("{0}", () => configFile)}` };
+      : { reason: `TS${String(circular.code)}: ${circular.text}` };
   } catch (error: unknown) {
     return { reason: message(error) };
   }
@@ -274,11 +274,17 @@ export function targetWithoutSources(target: string): FailureExit {
 }
 
 /** A target configuration a matrix or the invocation names that cannot be built, ending the run. */
-function unbuilt(named: string, reason: string): never {
-  throw failureExit(
-    "no-program",
-    `${named} ${reason}: correct the configuration, or name the configurations to analyze`,
-  );
+function unbuilt(
+  named: string,
+  reason: string,
+  failureClass: Failure["failureClass"] = "no-program",
+): never {
+  throw failureExit(failureClass, unreadableDetail(named, reason));
+}
+
+/** What fails and the fix, for a configuration `named` that `reason` keeps from being built. */
+export function unreadableDetail(named: string, reason: string): string {
+  return `${named} ${reason}: correct the configuration, or name the configurations to analyze`;
 }
 
 /**
@@ -321,7 +327,11 @@ function declaredProjects(
     }
     const read = readConfiguration(engine, configFile);
     if ("reason" in read) {
-      unbuilt(named, `cannot be read as a compiler configuration: ${read.reason}`);
+      unbuilt(
+        named,
+        `cannot be read as a compiler configuration: ${read.reason}`,
+        "unreadable-configuration",
+      );
     }
     references.set(configFile, referencesOf(read.parsed));
     const configuration: Configuration = {
@@ -377,13 +387,19 @@ function derivedProjects(
     [...fromScope, ...configFilesUnder(host, targetRoot)],
     (reference) => relativePath(rootDir, reference) !== undefined,
     (configFile, reason) => {
+      const why = `cannot be read as a compiler configuration: ${reason}`;
       if (fromScope.includes(configFile)) {
-        unbuilt(configFile, `cannot be read as a compiler configuration: ${reason}`);
+        unbuilt(configFile, why, "unreadable-configuration");
       }
+      const failure: Failure = {
+        failureClass: "unreadable-configuration",
+        detail: targetRelative(unreadableDetail(idOf(configFile), why), absoluteRoot),
+      };
       notBuilt.push({
         id: idOf(configFile),
         configFile,
         error: targetRelative(reason, absoluteRoot),
+        failures: [failure],
       });
     },
   );

package/src/load/expected-module.ts

@@ -8,7 +8,13 @@ import { packageOfSpecifier } from "../dependencies.ts";
 import { MANIFEST } from "../fs/manifest.ts";
 import { entriesOf } from "../fs/tree.ts";
 import type { Host } from "../host.ts";
-import { dirnamePath, isAbsolutePath, joinPath, relativePath, resolvePath } from "../paths.ts";
+import {
+  cannotStartPackageName,
+  dirnamePath,
+  joinPath,
+  relativePath,
+  resolvePath,
+} from "../paths.ts";
 import { dependencySpecifiers, installedPackage, manifestsAbove } from "./module-lookup.ts";
 import type { CompilerOptions } from "./plan.ts";
 
@@ -119,7 +125,7 @@ function expectedModule(
 ): string | undefined {
   const { host, targetRoot } = context;
   const fix = "run the generator or the build that writes it";
-  if (specifier.startsWith(".") || isAbsolutePath(specifier)) {
+  if (cannotStartPackageName(specifier)) {
     return provided(host, resolvePath(dirnamePath(importer), specifier), false)
       ? undefined
       : `which names no file of the target: ${fix}`;

package/src/load/plan.ts

@@ -1,10 +1,19 @@
 import type { CreateSnapshotProgramParams } from "@typescript/native/sync";
 import type { PartialConfig } from "../config.ts";
-import { readConventions, type ConventionManifest, type Conventions } from "../conventions.ts";
+import {
+  readConventions,
+  type ConventionManifest,
+  type Conventions,
+} from "../entries/conventions.ts";
 import { holdsManifest, inInstalledPackages, MANIFEST, readManifestAt } from "../fs/manifest.ts";
 import { gitIgnored } from "../git-ignore.ts";
 import type { Host } from "../host.ts";
-import { packageEntries, readManifest, type Manifest, type ManifestEntry } from "../manifest.ts";
+import {
+  packageEntries,
+  readManifest,
+  type Manifest,
+  type ManifestEntry,
+} from "../roots/manifest.ts";
 import {
   ancestors,
   dirnamePath,

package/src/load/specifiers.ts

@@ -23,14 +23,17 @@ import type { Failure } from "../failure.ts";
 import { readManifestAt } from "../fs/manifest.ts";
 import type { Host } from "../host.ts";
 import { JAVASCRIPT_FILE } from "../javascript-file.ts";
-import { ancestors, dirnamePath, relativePath, resolvePath } from "../paths.ts";
+import {
+  ancestors,
+  dirnamePath,
+  isRelativeSpecifier,
+  relativePath,
+  resolvePath,
+} from "../paths.ts";
 import { renderPosition, type Position } from "../position.ts";
 import { batched, type Engine, type ProjectView } from "../session.ts";
 import { dependencySpecifiers } from "./module-lookup.ts";
 
-/** A relative specifier: `.`, `..`, or one starting `./` or `../`. */
-const RELATIVE = /^\.\.?(?:\/|$)/u;
-
 /** One relative specifier of a JavaScript file that resolves to no file. */
 export interface UnresolvedSpecifier {
   readonly specifier: string;
@@ -141,7 +144,7 @@ export function readSpecifiers<Brand>(
     const resolved = (answers[at]?.resolvedFileName ?? "") !== "";
     const specifier = usage.node.text;
     const name = packageOfSpecifier(specifier);
-    if (RELATIVE.test(specifier)) {
+    if (isRelativeSpecifier(specifier)) {
       const named = resolvePath(dirnamePath(usage.file.fileName), specifier);
       if (!resolved && !outputs.some((dir) => relativePath(dir, named) !== undefined)) {
         unresolved.push({

package/src/load/synthesize.ts

@@ -6,14 +6,14 @@
  */
 
 import { readCommands } from "../commands/read.ts";
-import { CONVENTION_ROWS } from "../convention-rows.ts";
-import type { Conventions } from "../conventions.ts";
+import { CONVENTION_ROWS } from "../entries/convention-rows.ts";
+import type { Conventions } from "../entries/conventions.ts";
 import { holdsManifest, MANIFEST, readManifestAt, type ManifestRead } from "../fs/manifest.ts";
 import { filesBelow } from "../fs/tree.ts";
 import type { Host } from "../host.ts";
-import { JAVASCRIPT_FILE, minified, minifiedByName } from "../javascript-file.ts";
+import { JAVASCRIPT_FILE, minifiedBy, minifiedByName } from "../javascript-file.ts";
 import { isRecord } from "../json-document.ts";
-import { manifestCommands } from "../manifest.ts";
+import { manifestCommands } from "../roots/manifest.ts";
 import { ancestors, dirnamePath, joinPath, relativePath } from "../paths.ts";
 import type { Engine } from "../session.ts";
 import { bytewise } from "../text/compare.ts";
@@ -50,11 +50,11 @@ interface CandidateContext {
 
 /** Whether one file is minified build output; one that cannot be read is left to the compiler. */
 function minifiedFile(host: Host, file: string): boolean {
-  if (minifiedByName(file)) {
+  if (minifiedByName(file) !== undefined) {
     return true;
   }
   try {
-    return minified(file, host.readFile(file));
+    return minifiedBy(file, host.readFile(file)) !== undefined;
   } catch {
     return false;
   }
@@ -132,6 +132,12 @@ const RUNTIME_OPTIONS = {
   node: { module: "nodenext", moduleResolution: "nodenext" },
 } as const satisfies Record<Runtime, Readonly<Record<string, string>>>;
 
+/** Whether one configuration is a program the run formed to resolve its modules as Node does. */
+export function formedForNode(configuration: Configuration): boolean {
+  const options = configuration.written?.["compilerOptions"];
+  return isRecord(options) && options["moduleResolution"] === RUNTIME_OPTIONS.node.moduleResolution;
+}
+
 /** The manifest members that say a package is written for Node. */
 const NODE_MEMBERS = ["main", "exports", "bin", "type"] as const;
 

package/src/load/test-globals.ts

@@ -23,7 +23,7 @@ import {
   type Node,
   type SourceFile,
 } from "@typescript/native/ast";
-import type { ParseFile } from "../configuration-files.ts";
+import type { ParseFile } from "../entries/configuration-files.ts";
 import type { Host } from "../host.ts";
 import { isRecord } from "../json-document.ts";
 import { ancestors, dirnamePath, joinPath } from "../paths.ts";

package/src/load/workspace-manifests.ts

@@ -8,7 +8,7 @@
 
 import { emittedFrom } from "./emit-map.ts";
 import type { Host } from "../host.ts";
-import { readManifest, type Manifest, type ManifestEntry } from "../manifest.ts";
+import { readManifest, type Manifest, type ManifestEntry } from "../roots/manifest.ts";
 import { joinPath, relativePath } from "../paths.ts";
 import type { WorkspaceMember } from "./workspace.ts";
 import type { WorkspaceResolver } from "./workspace-resolution.ts";

package/src/load/workspace-resolution.ts

@@ -10,7 +10,14 @@ import { emittedFrom } from "./emit-map.ts";
 import { packageOfSpecifier } from "../dependencies.ts";
 import { gitIgnored } from "../git-ignore.ts";
 import type { Host } from "../host.ts";
-import { ancestors, dirnamePath, joinPath, relativePath, resolvePath } from "../paths.ts";
+import {
+  ancestors,
+  cannotStartPackageName,
+  dirnamePath,
+  joinPath,
+  relativePath,
+  resolvePath,
+} from "../paths.ts";
 import { satisfies } from "../version-range.ts";
 import type { Workspace, WorkspaceMember } from "./workspace.ts";
 import { isRecord } from "../json-document.ts";
@@ -140,7 +147,7 @@ function dependsOn(specifier: string, member: WorkspaceMember, fromDir: string):
     member.version !== undefined && satisfies(member.version, range);
   if (specifier.startsWith("workspace:")) {
     const rest = specifier.slice("workspace:".length);
-    if (rest.startsWith(".") || rest.startsWith("/")) {
+    if (cannotStartPackageName(rest)) {
       return atPath(rest);
     }
     const alias = /^((?:@[^/@]+\/)?[^/@]+)@(.*)$/u.exec(rest);

package/src/load/workspace-run.ts

@@ -6,7 +6,7 @@
  */
 
 import type { Host } from "../host.ts";
-import type { Manifest, ManifestEntry } from "../manifest.ts";
+import type { Manifest, ManifestEntry } from "../roots/manifest.ts";
 import { relativePath } from "../paths.ts";
 import type { Engine } from "../session.ts";
 import type { LocatedDiagnostic } from "./diagnostics.ts";

package/src/matrix.ts

@@ -9,9 +9,11 @@ import { graphOf, OUTSIDE, type Graph } from "./graph.ts";
 import type { InventorySymbol } from "./inventory.ts";
 import { byPosition } from "./position.ts";
 import type { Reference } from "./references.ts";
-import type { Root } from "./roots.ts";
+import type { Root } from "./roots/root-set.ts";
+import { edgeWithheldBy } from "./tests/file-class.ts";
 import {
   reachedWithTheTests,
+  splitRefs,
   sweep,
   type Candidate,
   type Liveness,
@@ -198,19 +200,12 @@ export function matrixOf(per: readonly Configured[]): Matrix {
 }
 
 /**
- * Answers which declarations of the run are dead in every configuration that holds them.
- *
- * Liveness is a question about one configuration, because a file another configuration
- * does not compile makes no reference there and a root it does not hold seeds nothing
- * there, so each configuration is swept on its own graph under the run's input. A
- * declaration is a candidate when every configuration holding it judged it one: a
- * reference under one configuration is a reference, so what one project uses is never
- * reported, and a configuration that does not hold a declaration says nothing about it.
- * The candidate's relation is reference counting where every configuration found it so,
- * and reachability otherwise; its counts are the union's, one per reference.
- *
- * The components are computed once, over the union and the intersected dead set, so one
- * dead component is one entry of the run with one identifier.
+ * Which declarations of the run are dead in every configuration that holds them. Each
+ * configuration is swept on its own graph, since a file it does not compile references nothing
+ * there and a root it does not hold seeds nothing. A declaration is a candidate when every
+ * configuration holding it judged it one; its relation is reference counting where every one
+ * found it so, else reachability, and its counts are the union's. Components are computed once,
+ * over the union and the intersected dead set, so one dead component has one identifier.
  */
 export function sweepMatrix(matrix: Matrix, input: SweepInput): SweepResult {
   const per = matrix.graphs.map((graph) => sweep(graph, input));
@@ -277,13 +272,14 @@ export function sweepMatrix(matrix: Matrix, input: SweepInput): SweepResult {
     }
     const held = matrix.heldIn[at] ?? [];
     const admitted = admittedAt(at);
-    const testRefs = union.made[at]?.test ?? 0;
+    const split = splitRefs(union.made[at], input.mode);
+    const testRefs = split.test;
     const heldByTests =
       heldBy[union.parent[at] ?? OUTSIDE] ??
       (union.support[at] === true && testRefs > 0 && !admitted ? symbol.id : undefined);
     const unreferenced = union.test[at] === true && !admitted && testReached[at] !== true;
     heldBy[at] = heldByTests;
-    const productionRefs = union.made[at]?.production ?? 0;
+    const productionRefs = split.production;
     const counted = all.every((candidate) => candidate.relation === "reference-counting");
     candidates.push({
       id: symbol.id,
@@ -332,7 +328,7 @@ function compiledReferences(
         }
         for (const edge of edges) {
           const to = graph.symbols[edge.to]?.id ?? "";
-          if ((!mode.production || !edge.test) && dead.has(to) && !kept.has(to)) {
+          if (!edgeWithheldBy(mode, edge) && dead.has(to) && !kept.has(to)) {
             kept.add(to);
             changed = true;
           }