@cplieger/deadset-ts 7.2.0-dev.3 → 8.0.0-dev.1

package/src/discover.ts

@@ -1,11 +1,13 @@
 import { DiagnosticCategory } from "@typescript/native/sync";
 import type { Diagnostic } from "@typescript/native/sync";
+import { baseUrlPaths } from "./base-url.ts";
 import type { BuildConfiguration, ProjectConfiguration } from "./config.ts";
 import type { Host } from "./host.ts";
 import { dirnamePath, isAbsolutePath, joinPath, relativePath, resolvePath } from "./paths.ts";
 import type { Scope } from "./scope.ts";
 import { SetupError } from "./setup-failure.ts";
 import type { Engine, ProjectDiagnostics } from "./session.ts";
+import { writtenPath, type WorkspaceProgram } from "./workspace-programs.ts";
 
 /** Directory names discovery does not descend into. */
 export const IGNORED_DIRECTORIES: ReadonlySet<string> = new Set(["node_modules", ".git"]);
@@ -95,20 +97,54 @@ export function diagnosticErrors(sets: {
 /** Why one open project cannot be analyzed, split by whether it loaded at all. */
 interface ProjectErrors {
   /**
-   * The errors in the configuration itself: no input matched, an option that does not
-   * parse. A project carrying one did not load, whatever its files say.
+   * The errors in the configuration itself, and the errors the compiler places in no file
+   * that leave its checker without a type it needs: no input matched, an option that
+   * does not parse, a missing global type. A project carrying one did not load, whatever
+   * its files say.
    */
   readonly load: readonly LocatedDiagnostic[];
   /** The errors in the files of a project that loaded: their syntax and their types. */
   readonly check: readonly LocatedDiagnostic[];
+  /**
+   * The libraries the configuration names that the compiler cannot find, which leave it
+   * loaded: a use of a name only such a library declares is an error in its file.
+   */
+  readonly unfound: readonly LocatedDiagnostic[];
 }
 
+/**
+ * The codes of a type library and a lib the configuration names that the compiler
+ * cannot find, which it reports while it gathers the program's files,
+ * https://github.com/microsoft/typescript-go/blob/89d5d5b2849a0db0957065889ca58536fa6d2e4a/internal/compiler/processingDiagnostic.go,
+ * and {@link MISSING_GLOBAL_TYPE}, which the checker reports.
+ */
+const UNFOUND_LIBRARY: ReadonlySet<number> = new Set([2318, 2688, 2726, 2727]);
+
+/**
+ * The code of a global type the checker finds in no library the program holds. The checker
+ * types every use of one against nothing and places no error in the file, so the analysis
+ * skips each file of such a project whole.
+ */
+export const MISSING_GLOBAL_TYPE = 2318;
+
 /** The errors one open project carries, each located in the file it names. */
 export function projectErrors(sets: ProjectDiagnostics): ProjectErrors {
-  const load = sets.configParsing.filter(isError);
+  // The compiler numbers its semantic messages from 2000 and its option messages from
+  // 5000. A file-less option error, a removed option or an output layout, leaves the
+  // program whole, and the compiler checks it all the same:
+  // https://github.com/microsoft/TypeScript/wiki/Coding-guidelines#diagnostic-message-codes
+  const semantic = sets.unplaced.filter(
+    (diagnostic) => isError(diagnostic) && diagnostic.code >= 2000 && diagnostic.code < 3000,
+  );
+  const unfound = semantic.filter(({ code }) => UNFOUND_LIBRARY.has(code));
+  const load = [
+    ...sets.configParsing.filter(isError),
+    ...semantic.filter(({ code }) => !UNFOUND_LIBRARY.has(code)),
+  ];
   return {
     load: locatedIn(load, sets.locate),
     check: load.length > 0 ? [] : locatedIn(diagnosticErrors(sets), sets.locate),
+    unfound: load.length > 0 ? [] : locatedIn(unfound, sets.locate),
   };
 }
 
@@ -182,10 +218,6 @@ interface Discovery {
   readonly fromScope: readonly string[];
 }
 
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
 /**
  * The configuration files below `root`, in ascending path order, skipping an
  * ignored directory. A directory that cannot be read is skipped: a tree the
@@ -221,45 +253,6 @@ function configFilesUnder(host: Host, root: string): string[] {
   return found.sort();
 }
 
-/**
- * The configuration files one configuration's `references` name, resolved against
- * that configuration's own directory. A reference naming a directory names the
- * `tsconfig.json` in it, which is the compiler's own rule.
- */
-function referencesOf(host: Host, configFile: string): string[] {
-  let text: string;
-  try {
-    text = host.readFile(configFile);
-  } catch {
-    return [];
-  }
-  let value: unknown;
-  try {
-    value = JSON.parse(text);
-  } catch {
-    // What a configuration's contents say is refused by the compiler's own
-    // diagnostics, which name the position; nothing is inferred from it here.
-    return [];
-  }
-  if (!isRecord(value) || !Array.isArray(value["references"])) {
-    return [];
-  }
-  const dir = dirnamePath(configFile);
-  const found: string[] = [];
-  for (const entry of value["references"] as unknown[]) {
-    if (!isRecord(entry)) {
-      continue;
-    }
-    const path = entry["path"];
-    if (typeof path !== "string" || path === "") {
-      continue;
-    }
-    const resolved = isAbsolutePath(path) ? path : joinPath(dir, path);
-    found.push(resolved.endsWith(".json") ? resolved : joinPath(resolved, "tsconfig.json"));
-  }
-  return found;
-}
-
 /**
  * The configuration file the scope names for the target directly, where its path
  * names one rather than a directory. A target naming a directory is reached by the
@@ -274,15 +267,16 @@ function scopeConfigFiles(host: Host, scope: Scope): string[] {
 
 /**
  * Every configuration file reached from `pending`, in the order discovery reads them:
- * each once, each followed by the configurations it references, transitively. A
- * configuration the compiler cannot read ends the run naming it, unless `unreadable`
- * is given, which is then told the configuration and why, and the walk goes on
- * without it.
+ * each once, each followed by the configurations it references that `follows` admits,
+ * transitively. A configuration the compiler cannot read ends the run naming it, unless
+ * `unreadable` is given, which is then told the configuration and why, and the walk
+ * goes on without it.
  */
 function derivedFrom(
   engine: Engine,
   host: Host,
   pending: string[],
+  follows: (reference: string) => boolean,
   unreadable?: (configFile: string, reason: string) => void,
 ): string[] {
   const seen = new Set<string>();
@@ -297,19 +291,19 @@ function derivedFrom(
       continue;
     }
     seen.add(path);
-    const reason = unreadableReason(engine, path);
-    if (reason !== undefined) {
+    const read = readConfiguration(engine, path);
+    if ("reason" in read) {
       if (unreadable === undefined) {
         throw new DiscoveryError(
-          `${path} cannot be read as a compiler configuration: ${reason}`,
+          `${path} cannot be read as a compiler configuration: ${read.reason}`,
           [],
         );
       }
-      unreadable(path, reason);
+      unreadable(path, read.reason);
       continue;
     }
     found.push(path);
-    pending.push(...referencesOf(host, path));
+    pending.push(...read.references.filter(follows));
   }
   return found;
 }
@@ -335,7 +329,7 @@ export function consumerProjects(engine: Engine, host: Host, root: string): read
   if (kind !== "directory") {
     throw new DiscoveryError(`the consumer ${root} is not a directory`, []);
   }
-  const found = derivedFrom(engine, host, configFilesUnder(host, root));
+  const found = derivedFrom(engine, host, configFilesUnder(host, root), () => true);
   if (found.length === 0) {
     throw new DiscoveryError(
       `the consumer ${root} holds no compiler configuration, so none of its references can be read`,
@@ -353,39 +347,150 @@ function derivedId(targetRoot: string, configFile: string): string {
   return relativePath(targetRoot, configFile) ?? configFile;
 }
 
-/** Why the compiler cannot read one configuration file, or undefined where it can. */
-function unreadableReason(engine: Engine, configFile: string): string | undefined {
-  try {
-    engine.parseConfigFile(configFile);
+/**
+ * The code of a configuration whose `extends` chain returns to a configuration it already
+ * passed. The parse reports it and returns, and a snapshot opened from it never answers:
+ * https://github.com/microsoft/TypeScript/issues/64754
+ */
+const CIRCULAR_EXTENDS = 18000;
+
+type Parsed = ReturnType<Engine["parseConfigFile"]>;
+
+/** The configuration files one parsed configuration's own `extends` names by path. */
+function extendedPaths(parsed: Parsed, configFile: string): readonly string[] {
+  const { raw } = parsed as { readonly raw?: unknown };
+  const named: unknown = typeof raw === "object" && raw !== null ? Reflect.get(raw, "extends") : [];
+  return (Array.isArray(named) ? named : [named])
+    .filter((one): one is string => typeof one === "string")
+    .filter((one) => one.startsWith("./") || one.startsWith("../") || isAbsolutePath(one))
+    .map((one) => resolvePath(dirnamePath(configFile), one));
+}
+
+/**
+ * The `extends` chain from `configFile` to the first configuration it reaches twice, each
+ * link by path, or undefined where no chain written by path returns.
+ */
+function extendsCycle(
+  engine: Engine,
+  configFile: string,
+  parsed: Parsed,
+): readonly string[] | undefined {
+  const walk = (chain: readonly string[], at: Parsed): readonly string[] | undefined => {
+    for (const next of extendedPaths(at, chain.at(-1) ?? configFile)) {
+      if (chain.includes(next)) {
+        return [...chain, next];
+      }
+      let read: Parsed;
+      try {
+        read = engine.parseConfigFile(next);
+      } catch {
+        continue;
+      }
+      const cycle = walk([...chain, next], read);
+      if (cycle !== undefined) {
+        return cycle;
+      }
+    }
+    return undefined;
+  };
+  return walk([configFile], parsed);
+}
+
+/** The configuration files one parsed configuration's `references` name. */
+function referencesOf(parsed: Parsed): readonly string[] {
+  // The parse answers a directory reference as the directory; the compiler reads a
+  // path not ending `.json` as its `tsconfig.json`:
+  // https://github.com/microsoft/typescript-go/blob/89d5d5b2849a0db0957065889ca58536fa6d2e4a/internal/core/projectreference.go#L18
+  return (parsed.projectReferences ?? []).map(({ path }) =>
+    path.endsWith(".json") ? path : joinPath(path, "tsconfig.json"),
+  );
+}
+
+/** Why one parsed configuration's own `extends` chain cannot be opened, where it is circular. */
+function circularity(engine: Engine, configFile: string, parsed: Parsed): string | undefined {
+  const chain = extendsCycle(engine, configFile, parsed);
+  if (chain === undefined && !parsed.errors.some(({ code }) => code === CIRCULAR_EXTENDS)) {
     return undefined;
+  }
+  return `TS${String(CIRCULAR_EXTENDS)}: Circularity detected while resolving configuration: ${(chain ?? [configFile]).join(" -> ")}`;
+}
+
+/**
+ * Why a configuration the `references` reach, transitively, cannot be opened, where one's
+ * `extends` chain is circular: the compiler opens every referenced project with the one
+ * that references it.
+ */
+function referencedCircularity(
+  engine: Engine,
+  references: readonly string[],
+  visited: Set<string>,
+): string | undefined {
+  for (const reference of references) {
+    if (visited.has(reference)) {
+      continue;
+    }
+    visited.add(reference);
+    let parsed: Parsed;
+    try {
+      parsed = engine.parseConfigFile(reference);
+    } catch {
+      continue;
+    }
+    const reason =
+      circularity(engine, reference, parsed) ??
+      referencedCircularity(engine, referencesOf(parsed), visited);
+    if (reason !== undefined) {
+      return reason;
+    }
+  }
+  return undefined;
+}
+
+/**
+ * The configuration files one configuration's `references` name, or why the compiler
+ * cannot read the configuration: it throws, or its `extends` chain or that of a
+ * configuration it references is circular, which the analysis refuses before any
+ * snapshot is asked to open it.
+ */
+function readConfiguration(
+  engine: Engine,
+  configFile: string,
+): { readonly references: readonly string[] } | { readonly reason: string } {
+  try {
+    const parsed = engine.parseConfigFile(configFile);
+    const references = referencesOf(parsed);
+    const reason =
+      circularity(engine, configFile, parsed) ??
+      referencedCircularity(engine, references, new Set([configFile]));
+    return reason === undefined ? { references } : { reason };
   } catch (error: unknown) {
-    return error instanceof Error ? error.message : String(error);
+    return { reason: error instanceof Error ? error.message : String(error) };
   }
 }
 
 /**
- * Resolves one compiler configuration file, or ends the run naming it: a project
- * opened from a configuration the compiler cannot read would be analyzed with no
- * type information.
+ * The references of one compiler configuration file, or ends the run naming it: a
+ * project opened from a configuration the compiler cannot read would be analyzed with
+ * no type information.
  */
-function parseOrRefuse(engine: Engine, configFile: string, named: string): void {
-  const reason = unreadableReason(engine, configFile);
-  if (reason !== undefined) {
-    throw new DiscoveryError(`${named} cannot be read as a compiler configuration: ${reason}`, []);
+function parseOrRefuse(engine: Engine, configFile: string, named: string): readonly string[] {
+  const read = readConfiguration(engine, configFile);
+  if ("reason" in read) {
+    throw new DiscoveryError(
+      `${named} cannot be read as a compiler configuration: ${read.reason}`,
+      [],
+    );
   }
+  return read.references;
 }
 
 /**
- * The projects a build matrix declares, in the order it lists them. Each entry
- * names a file below the target root, and an entry naming a file that is absent,
- * that is a directory, or that the compiler cannot read ends the run naming it.
- *
- * A declared project's `references` are not followed, because the entries are the
- * matrix, and a reference to a configuration the matrix does not name ends the run
- * naming both: the compiler builds a referenced project's sources into the program
- * that references it without reporting their diagnostics, so the project the matrix
- * left out would be analyzed with its errors unread. An entry naming a file an
- * earlier entry named adds nothing, so the earlier identifier stands.
+ * The projects a build matrix declares, in its order, each entry a file below the target
+ * root: an entry naming an absent file, a directory or a file the compiler cannot read
+ * ends the run naming it, and one naming an earlier entry's file adds nothing. A
+ * reference below the root the matrix does not name ends the run naming both, because the
+ * compiler builds a referenced project's sources into the referencing program without
+ * reporting their diagnostics. A reference outside the root is an outside project.
  */
 function declaredProjects(
   engine: Engine,
@@ -395,6 +500,7 @@ function declaredProjects(
 ): Discovery {
   const seen = new Set<string>();
   const projects: DiscoveredProject[] = [];
+  const references = new Map<string, readonly string[]>();
   for (const entry of entries) {
     const configFile = joinPath(targetRoot, entry.project);
     const named = `the project ${JSON.stringify(entry.id)} (${configFile})`;
@@ -411,11 +517,13 @@ function declaredProjects(
       continue;
     }
     seen.add(configFile);
-    parseOrRefuse(engine, configFile, named);
+    references.set(configFile, parseOrRefuse(engine, configFile, named));
     projects.push({ id: entry.id, configFile });
   }
   for (const project of projects) {
-    const unnamed = referencesOf(host, project.configFile).find((path) => !seen.has(path));
+    const unnamed = references
+      .get(project.configFile)
+      ?.find((path) => !seen.has(path) && relativePath(targetRoot, path) !== undefined);
     if (unnamed !== undefined) {
       throw new DiscoveryError(
         `the project ${JSON.stringify(project.id)} (${project.configFile}) references ` +
@@ -435,21 +543,26 @@ function declaredProjects(
 }
 
 /**
- * The projects a run derives where the matrix declares none, in the order discovery
- * reads them: the paths the scope names, then every compiler configuration under
- * the target root that is not inside an ignored directory, then the configurations
- * each of those references, transitively. Each configuration appears once. A
- * configuration the scope names directly is the caller's own and ends the run where
- * it cannot be read; one the walk found is dropped and named.
+ * The projects a run derives where the matrix declares none, in discovery order: the
+ * paths the scope names, every compiler configuration under the target root outside an
+ * ignored directory, then each configuration below the root those reference,
+ * transitively, each once. A reference outside the root is an outside project, whose
+ * sources the compiler builds into the referencing program. A configuration the scope
+ * names ends the run where it cannot be read; one the walk found is dropped and named.
  */
 function derivedProjects(engine: Engine, host: Host, scope: Scope): Discovery {
   const targetRoot = scope.target.path;
   const fromScope = scopeConfigFiles(host, scope);
   const notBuilt: NotBuilt[] = [];
+  const rootDir = resolvePath(
+    host.workingDirectory(),
+    fromScope.length > 0 ? dirnamePath(targetRoot) : targetRoot,
+  );
   const configFiles = derivedFrom(
     engine,
     host,
     [...fromScope, ...configFilesUnder(host, targetRoot)],
+    (reference) => relativePath(rootDir, reference) !== undefined,
     (configFile, reason) => {
       if (fromScope.includes(configFile)) {
         throw new DiscoveryError(
@@ -503,3 +616,38 @@ export function discoverProjects(
   }
   return derivedProjects(engine, host, scope);
 }
+
+/**
+ * How the snapshot reads each configuration of `configFiles` that sets `baseUrl` and
+ * `programs` does not already describe: a configuration only the snapshot holds, which
+ * extends it and states the `paths` {@link baseUrlPaths} gives, so its imports resolve as
+ * the compilers before version 7 resolve them. A configuration the compiler cannot read is
+ * left for its project to refuse.
+ */
+export function withBaseUrlPaths(
+  engine: Engine,
+  host: Host,
+  configFiles: readonly string[],
+  programs: ReadonlyMap<string, WorkspaceProgram>,
+): ReadonlyMap<string, WorkspaceProgram> {
+  const found = new Map(programs);
+  for (const configFile of configFiles) {
+    if (found.has(configFile)) {
+      continue;
+    }
+    let paths: Record<string, string[]> | undefined;
+    try {
+      paths = baseUrlPaths(engine.parseConfigFile(configFile).options);
+    } catch {
+      continue;
+    }
+    if (paths !== undefined) {
+      found.set(configFile, {
+        kind: "configuration",
+        file: writtenPath(host, configFile),
+        text: `${JSON.stringify({ extends: configFile, compilerOptions: { paths } }, null, 2)}\n`,
+      });
+    }
+  }
+  return found;
+}

package/src/edges.ts

@@ -156,7 +156,7 @@ export function readEdgeSides(host: Host, targetRoot: string): readonly EdgeSide
 
   const sides: EdgeSide[] = [];
   (edges as readonly unknown[]).forEach((value, index) => {
-    const offset = walk.opened[index];
+    const offset = walk.starts[index];
     const at =
       offset === undefined ? EDGES_FILE : positionKey(positionAt(text, EDGES_FILE, offset));
     const edge = readEdge(value, at);

package/src/entry-point-gaps.ts

@@ -58,7 +58,6 @@ const UNREAD_TOOLS: readonly string[] = [
   "cypress",
   "danger",
   "dependency-cruiser",
-  "docusaurus",
   "dotenv",
   "drizzle",
   "electron-vite",
@@ -112,14 +111,12 @@ const UNREAD_TOOLS: readonly string[] = [
   "nuxtjs-i18n",
   "nx",
   "nyc",
-  "oclif",
   "openapi-ts",
   "openclaw",
   "orval",
   "oxfmt",
   "oxlint",
   "panda-css",
-  "parcel",
   "payload",
   "pino",
   "playwright-ct",
@@ -164,7 +161,6 @@ const UNREAD_TOOLS: readonly string[] = [
   "swc",
   "syncpack",
   "tailwind",
-  "tanstack-router",
   "taskfile",
   "tauri",
   "temporal",
@@ -210,18 +206,19 @@ const UNREAD_TOOLS: readonly string[] = [
 /** The conventions declined for a tool some of whose conventions are entered. */
 const PARTLY_ENTERED: readonly DeclinedConvention[] = [
   {
-    tool: "eslint",
-    convention: "a legacy configuration written in YAML or in JSON with comments",
+    tool: "docusaurus",
+    convention: "a page or theme directory a plugin's configuration moves, and the docs",
     reason:
-      "Only a configuration module and a strict JSON configuration file are read, so a " +
-      "dependency only such a file names is reported as unused.",
+      "The convention row reads src/pages and src/theme only, and a document's imports are " +
+      "read from every Markdown and MDX file, so a module only a moved directory holds is " +
+      "reported as never imported unless ts.entry_files names it.",
   },
   {
     tool: "eslint",
-    convention: "a plugin or shareable configuration named without its package's prefix",
+    convention: "a legacy configuration written in YAML or in JSON with comments",
     reason:
-      "A string uses a dependency only where it spells the dependency's name, so a " +
-      "dependency only a shortened name loads is reported as unused.",
+      "Only a configuration module and a strict JSON configuration file are read, so a " +
+      "dependency only such a file names is reported as unused.",
   },
   {
     tool: "playwright",