@cplieger/deadset-ts 8.0.0-dev.7 → 8.0.0-dev.9

package/src/load/plan.ts

@@ -0,0 +1,258 @@
+import type { CreateSnapshotProgramParams } from "@typescript/native/sync";
+import type { PartialConfig } from "../config.ts";
+import { readConventions, type ConventionManifest, type Conventions } from "../conventions.ts";
+import { holdsManifest, inInstalledPackages, MANIFEST } from "../fs/manifest.ts";
+import type { Host } from "../host.ts";
+import { packageEntries, readManifest, type Manifest, type ManifestEntry } from "../manifest.ts";
+import { ancestors, dirnamePath, normalizePath, relativePath, resolvePath } from "../paths.ts";
+import type { Scope } from "../scope.ts";
+import type { Engine, ProgramBuild } from "../session.ts";
+import { bytewise } from "../text/compare.ts";
+import { globExpression } from "../text/glob.ts";
+import {
+  discoverProjects,
+  isTargetConfiguration,
+  type Configuration,
+  type Discovery,
+  type LoadedConsumer,
+  type Parsed,
+} from "./discover.ts";
+import { FailureExit } from "../failure.ts";
+import { joinedTestFiles, joinedTests } from "./test-joins.ts";
+import { testGlobals } from "./test-globals.ts";
+import { findWorkspace, type Workspace } from "./workspace.ts";
+import { writtenConfiguration } from "./workspace-programs.ts";
+import { workspaceRun, type WorkspaceRun } from "./workspace-run.ts";
+
+export type CompilerOptions = Parsed["options"];
+
+/** How the snapshot builds one configuration. */
+export type Build =
+  /** The project the compiler opens for the configuration as it stands. */
+  | { readonly kind: "project" }
+  | { readonly kind: "program"; readonly params: CreateSnapshotProgramParams }
+  /** A configuration only the snapshot holds, which extends the one it stands for. */
+  | { readonly kind: "configuration"; readonly value: Readonly<Record<string, unknown>> };
+
+/** One configuration of the run and how the snapshot builds it. */
+export interface ProgramPlan extends Configuration {
+  /** The options the program is built with, the parse's own with `paths` read as {@link baseUrlPaths} states. */
+  readonly options: CompilerOptions;
+  readonly build: Build;
+}
+
+/** The manifests the run reads, each once, and what they decide before any project opens. */
+interface PackageSet {
+  /** The target's own manifest, its targets read back to source where the target is a member. */
+  readonly manifest: Manifest;
+  /** The directory of every workspace member, absolute, in the workspace's order. */
+  readonly members: readonly string[];
+  /** The directory of every nested package, absolute, in path order. */
+  readonly nested: readonly string[];
+  /** The entry points the other members' and the nested packages' manifests name. */
+  readonly entries: readonly ManifestEntry[];
+  /** The directories of the members whose manifest is not private. */
+  readonly published: ReadonlySet<string>;
+}
+
+/**
+ * The workspace one consumer sits in, or the fault of a declaration that cannot be read,
+ * which ends the run only where an import's membership depends on it.
+ */
+export type ConsumerWorkspace =
+  { readonly workspace: Workspace | undefined } | { readonly fault: string };
+
+/** What a run opens and how it builds each program, decided before the snapshot. */
+export interface RunPlan {
+  readonly discovery: Discovery;
+  readonly plans: readonly ProgramPlan[];
+  readonly packages: PackageSet;
+  /** The convention rows applied per package of {@link PackageSet}. */
+  readonly conventions: Conventions;
+  readonly workspace: WorkspaceRun | undefined;
+  /** The workspace each consumer sits in, by its directory, read from its own root. */
+  readonly consumerWorkspaces: ReadonlyMap<string, ConsumerWorkspace>;
+  /** The target root, absolute. */
+  readonly root: string;
+}
+
+/**
+ * The `paths` one configuration's resolved options map under the compilers before version
+ * 7, each target absolute: a target is read against the effective `baseUrl`, and a specifier
+ * no other pattern maps is looked up below it. Undefined where no `baseUrl` is set, so the
+ * options' own `paths` stand. Version 7 reads no `baseUrl`:
+ * https://github.com/microsoft/TypeScript/issues/62207
+ */
+export function baseUrlPaths(options: CompilerOptions): Record<string, string[]> | undefined {
+  const baseUrl: unknown = Reflect.get(options, "baseUrl");
+  if (typeof baseUrl !== "string") {
+    return undefined;
+  }
+  return Object.fromEntries(
+    Object.entries({ "*": ["*"], ...options.paths }).map(([key, targets]) => [
+      key,
+      targets.map((target) => resolvePath(baseUrl, target)),
+    ]),
+  );
+}
+
+/** One configuration, read through the `paths` its `baseUrl` gives. */
+function planned(configuration: Configuration): ProgramPlan {
+  const { options } = configuration.parsed;
+  const paths = baseUrlPaths(options);
+  return {
+    ...configuration,
+    options: paths === undefined ? options : { ...options, paths },
+    build:
+      paths === undefined
+        ? { kind: "project" }
+        : {
+            kind: "configuration",
+            value: { extends: configuration.configFile, compilerOptions: { paths } },
+          },
+  };
+}
+
+/**
+ * The nested packages of a run: each directory below the target root, in no `node_modules`
+ * directory and none of `known`, that holds a `package.json` and lies at or above one of
+ * `files`, in path order.
+ */
+function nestedPackageDirs(
+  host: Host,
+  targetRoot: string,
+  files: Iterable<string>,
+  known: ReadonlySet<string>,
+): readonly string[] {
+  const seen = new Set<string>();
+  const found: string[] = [];
+  for (const file of files) {
+    for (const dir of ancestors(dirnamePath(file), targetRoot)) {
+      if (seen.has(dir) || relativePath(targetRoot, dir) === undefined) {
+        break;
+      }
+      seen.add(dir);
+      const below = relativePath(targetRoot, dir) ?? "";
+      if (!inInstalledPackages(below) && !known.has(dir) && holdsManifest(host, dir)) {
+        found.push(dir);
+      }
+    }
+  }
+  return found.sort(bytewise);
+}
+
+/** The manifests conventions are applied from: the target's, then each member's and nested package's. */
+function conventionManifests(
+  host: Host,
+  root: string,
+  packages: PackageSet,
+): readonly ConventionManifest[] {
+  const found = new Map<string, ConventionManifest>();
+  if (holdsManifest(host, root)) {
+    found.set(root, { dir: root, path: MANIFEST });
+  }
+  for (const [dirs, nested] of [
+    [packages.members, false],
+    [packages.nested, true],
+  ] as const) {
+    for (const dir of dirs) {
+      const below = relativePath(root, dir);
+      if (below !== undefined && !found.has(dir)) {
+        found.set(dir, { dir, path: `${below}/${MANIFEST}`, nested });
+      }
+    }
+  }
+  return [...found.values()];
+}
+
+/** The workspace one consumer sits in, read from its own root, the target's reused. */
+function consumerWorkspace(
+  host: Host,
+  consumer: LoadedConsumer,
+  target: Workspace | undefined,
+): ConsumerWorkspace {
+  try {
+    return { workspace: findWorkspace(host, consumer.path, () => undefined, target) };
+  } catch (error: unknown) {
+    if (!(error instanceof FailureExit)) {
+      throw error;
+    }
+    return { fault: error.failures[0].detail };
+  }
+}
+
+/**
+ * The plan of one run: the configurations discovery names, each built through the steps in
+ * order (the `baseUrl` paths, the workspace members read from source, the test runner's
+ * globals, the joined test files of a derived matrix), the package set and the convention
+ * rows applied per package. A nested package is one at or above a file a target
+ * configuration lists or a test file that joins it.
+ */
+export function planRun(engine: Engine, host: Host, scope: Scope, config: PartialConfig): RunPlan {
+  const discovery = discoverProjects(engine, host, scope, config.analysis.configurations);
+  const root = resolvePath(host.workingDirectory(), scope.target.path);
+  const parse = (fileName: string, text: string) => engine.parseSourceFile(fileName, text);
+  let plans: readonly ProgramPlan[] = discovery.configurations.map(planned);
+  const targets = plans.filter(isTargetConfiguration);
+  const manifest = readManifest(host, scope.target.path);
+  const workspace = workspaceRun(engine, host, root, targets, manifest);
+  const consumerWorkspaces = new Map(
+    discovery.consumers.map((consumer) => [
+      consumer.path,
+      consumerWorkspace(host, consumer, workspace?.workspace),
+    ]),
+  );
+  plans = plans.map((plan) => {
+    const build = workspace?.programs.get(plan.configFile);
+    return build === undefined ? plan : { ...plan, build };
+  });
+  plans = testGlobals(host, parse, plans);
+  const joins =
+    discovery.mode === "derived"
+      ? joinedTestFiles(host, root, targets, config.ts.test_files.map(globExpression))
+      : new Map<string, readonly string[]>();
+  plans = joinedTests(plans, joins);
+  const members = workspace?.memberDirs ?? [];
+  const nested = nestedPackageDirs(
+    host,
+    normalizePath(root),
+    targets.flatMap((plan) => [
+      plan.configFile,
+      ...plan.parsed.fileNames,
+      ...(joins.get(plan.configFile) ?? []),
+    ]),
+    new Set(members),
+  );
+  const packages: PackageSet = {
+    manifest: workspace?.manifest ?? manifest,
+    members,
+    nested,
+    entries: [...(workspace?.entries ?? []), ...packageEntries(host, normalizePath(root), nested)],
+    published: new Set(
+      (workspace?.entries ?? []).filter((entry) => entry.published).map((entry) => entry.dir),
+    ),
+  };
+  const conventions = readConventions(
+    host,
+    parse,
+    conventionManifests(host, root, packages),
+    config.ts.disabled_conventions,
+  );
+  return { discovery, plans, packages, conventions, workspace, consumerWorkspaces, root };
+}
+
+/** How the snapshot builds each planned configuration other than by opening its project. */
+export function programBuilds(
+  host: Host,
+  plans: readonly ProgramPlan[],
+): ReadonlyMap<string, ProgramBuild> {
+  const builds = new Map<string, ProgramBuild>();
+  for (const { configFile, build } of plans) {
+    if (build.kind === "program") {
+      builds.set(configFile, build);
+    } else if (build.kind === "configuration") {
+      builds.set(configFile, writtenConfiguration(host, configFile, build.value));
+    }
+  }
+  return builds;
+}

package/src/{test-globals.ts → load/test-globals.ts}

@@ -23,14 +23,16 @@ import {
   type Node,
   type SourceFile,
 } from "@typescript/native/ast";
-import type { ParseFile } from "./configuration-files.ts";
-import type { Host } from "./host.ts";
-import { ancestors, dirnamePath, joinPath } from "./paths.ts";
-import { UNANSWERED } from "./query.ts";
-import type { Engine, ProjectView } from "./session.ts";
-import { writtenPath, type WorkspaceProgram } from "./workspace-programs.ts";
-import { filesIn } from "./fs/tree.ts";
-import { holdsManifest, INSTALLED_PACKAGES } from "./fs/manifest.ts";
+import type { ParseFile } from "../configuration-files.ts";
+import type { Host } from "../host.ts";
+import { isRecord } from "../json-document.ts";
+import { ancestors, dirnamePath, joinPath } from "../paths.ts";
+import { UNANSWERED } from "../query.ts";
+import type { ProjectView } from "../session.ts";
+import { filesIn } from "../fs/tree.ts";
+import { holdsManifest, INSTALLED_PACKAGES } from "../fs/manifest.ts";
+import { isTargetConfiguration } from "./discover.ts";
+import type { ProgramPlan } from "./plan.ts";
 
 /** The test runner whose configuration injects the globals, and the `types` entry declaring them. */
 export const GLOBALS_RUNNER = "vitest";
@@ -150,75 +152,67 @@ function typesOf(value: unknown): readonly string[] | undefined {
 }
 
 /**
- * How the snapshot reads each configuration of `configFiles` whose nearest manifest's
- * runner configuration injects the globals and that can resolve their declarations: as
- * `programs` reads it, else as itself, with the globals' declarations added to its `types`.
- * A configuration the compiler cannot read is left for its project to refuse.
+ * The plans with the globals' declarations added to the `types` of each target configuration
+ * whose nearest manifest's runner configuration injects them and that can resolve them.
  */
-export function withTestGlobals(
-  engine: Engine,
+export function testGlobals(
   host: Host,
   parse: ParseFile,
-  configFiles: readonly string[],
-  programs: ReadonlyMap<string, WorkspaceProgram>,
-): ReadonlyMap<string, WorkspaceProgram> {
-  const found = new Map(programs);
+  plans: readonly ProgramPlan[],
+): readonly ProgramPlan[] {
   const injects = new Map<string, boolean>();
-  for (const configFile of configFiles) {
-    const dir = manifestDir(host, configFile);
-    if (dir === undefined || !globalsInstalled(host, configFile)) {
-      continue;
+  return plans.map((plan): ProgramPlan => {
+    const dir = manifestDir(host, plan.configFile);
+    if (
+      !isTargetConfiguration(plan) ||
+      dir === undefined ||
+      !globalsInstalled(host, plan.configFile)
+    ) {
+      return plan;
     }
     if (!injects.has(dir)) {
       injects.set(dir, injectsGlobals(host, parse, dir));
     }
+    const base = typesOf(plan.options.types) ?? [];
+    const { build } = plan;
     if (injects.get(dir) !== true) {
-      continue;
+      return plan;
     }
-    let base: readonly string[];
-    try {
-      base = typesOf(engine.parseConfigFile(configFile).options.types) ?? [];
-    } catch {
-      continue;
-    }
-    const held = found.get(configFile);
-    if (held?.kind === "program") {
-      const listed = typesOf(held.params.compilerOptions.types) ?? base;
-      if (!listed.includes(GLOBALS_TYPES)) {
-        found.set(configFile, {
-          kind: "program",
-          params: {
-            ...held.params,
-            compilerOptions: { ...held.params.compilerOptions, types: [...listed, GLOBALS_TYPES] },
-          },
-        });
-      }
-      continue;
+    if (build.kind === "program") {
+      const listed = typesOf(build.params.compilerOptions.types) ?? base;
+      return listed.includes(GLOBALS_TYPES)
+        ? plan
+        : {
+            ...plan,
+            build: {
+              kind: "program",
+              params: {
+                ...build.params,
+                compilerOptions: {
+                  ...build.params.compilerOptions,
+                  types: [...listed, GLOBALS_TYPES],
+                },
+              },
+            },
+          };
     }
-    let written: Record<string, unknown> = { extends: configFile };
-    if (held !== undefined) {
-      try {
-        written = JSON.parse(held.text) as Record<string, unknown>;
-      } catch {
-        continue;
-      }
-    }
-    const options = (written["compilerOptions"] ?? {}) as Record<string, unknown>;
+    const written = build.kind === "configuration" ? build.value : { extends: plan.configFile };
+    const held = written["compilerOptions"];
+    const options = isRecord(held) ? held : {};
     const listed = typesOf(options["types"]) ?? base;
-    if (listed.includes(GLOBALS_TYPES)) {
-      continue;
-    }
-    found.set(configFile, {
-      kind: "configuration",
-      file: held?.file ?? writtenPath(host, configFile),
-      text: `${JSON.stringify(
-        { ...written, compilerOptions: { ...options, types: [...listed, GLOBALS_TYPES] } },
-        null,
-        2,
-      )}\n`,
-    });
-  }
-  return found;
+    return listed.includes(GLOBALS_TYPES)
+      ? plan
+      : {
+          ...plan,
+          build: {
+            kind: "configuration",
+            value: {
+              ...written,
+              compilerOptions: { ...options, types: [...listed, GLOBALS_TYPES] },
+            },
+          },
+        };
+  });
 }
 
 /**

package/src/load/test-joins.ts

@@ -0,0 +1,98 @@
+/**
+ * The test files a derived matrix holds although no configuration's file list names them.
+ * The test runner compiles such a file with the options of the nearest compiler
+ * configuration at or above it, so the file joins that configuration's program as a file
+ * its list names, unless a `package.json` below that configuration's directory makes the
+ * file another package's, which its own test runner compiles.
+ */
+
+import { sourcePaths } from "../file-facts.ts";
+import type { Host } from "../host.ts";
+import { ancestors, dirnamePath, joinPath } from "../paths.ts";
+import { bytewise } from "../text/compare.ts";
+import { holdsManifest } from "../fs/manifest.ts";
+import type { Configuration } from "./discover.ts";
+import type { ProgramPlan } from "./plan.ts";
+
+const PREFERRED = "/tsconfig.json";
+
+/** The configurations of one directory in the order a file joins them: `tsconfig.json` first. */
+function byPreference(a: string, b: string): number {
+  const first = a.endsWith(PREFERRED) ? 0 : 1;
+  const second = b.endsWith(PREFERRED) ? 0 : 1;
+  return first - second || bytewise(a, b);
+}
+
+/**
+ * Per configuration of `configurations`, the absolute paths of the test files that join it:
+ * each file below `root` a pattern of `patterns` names, that no configuration's file list
+ * holds, joins the configuration nearest at or above its directory when no `package.json`
+ * sits between them.
+ */
+export function joinedTestFiles(
+  host: Host,
+  root: string,
+  configurations: readonly Configuration[],
+  patterns: readonly RegExp[],
+): ReadonlyMap<string, readonly string[]> {
+  const listed = new Set<string>();
+  const byDir = new Map<string, string[]>();
+  for (const { configFile, parsed } of configurations) {
+    parsed.fileNames.forEach((name) => listed.add(name));
+    const dir = dirnamePath(configFile);
+    byDir.set(dir, [...(byDir.get(dir) ?? []), configFile].sort(byPreference));
+  }
+  const joins = new Map<string, string[]>();
+  for (const path of sourcePaths(host, root)) {
+    const file = joinPath(root, path);
+    if (listed.has(file) || !patterns.some((pattern) => pattern.test(path))) {
+      continue;
+    }
+    for (const dir of ancestors(dirnamePath(file), root)) {
+      const [nearest] = byDir.get(dir) ?? [];
+      if (nearest !== undefined) {
+        joins.set(nearest, [...(joins.get(nearest) ?? []), file]);
+        break;
+      }
+      if (holdsManifest(host, dir)) {
+        break;
+      }
+    }
+  }
+  return joins;
+}
+
+/**
+ * The plans with each joined test file added to the configuration it joins: to a described
+ * program's root files, or to the file list of a configuration only the snapshot holds, which
+ * lists every file the configuration lists and the joined ones.
+ */
+export function joinedTests(
+  plans: readonly ProgramPlan[],
+  joins: ReadonlyMap<string, readonly string[]>,
+): readonly ProgramPlan[] {
+  return plans.map((plan): ProgramPlan => {
+    const files = joins.get(plan.configFile);
+    const { build } = plan;
+    if (files === undefined) {
+      return plan;
+    }
+    if (build.kind === "program") {
+      return {
+        ...plan,
+        build: {
+          kind: "program",
+          params: { ...build.params, rootFiles: [...(build.params.rootFiles ?? []), ...files] },
+        },
+      };
+    }
+    const written = build.kind === "configuration" ? build.value : { extends: plan.configFile };
+    return {
+      ...plan,
+      build: {
+        kind: "configuration",
+        value: { ...written, files: [...plan.parsed.fileNames, ...files], include: [] },
+      },
+    };
+  });
+}

package/src/{workspace-manifests.ts → load/workspace-manifests.ts}

@@ -7,12 +7,12 @@
  */
 
 import { emittedFrom } from "./emit-map.ts";
-import type { Host } from "./host.ts";
-import { readManifest, type Manifest, type ManifestEntry } from "./manifest.ts";
-import { joinPath, relativePath } from "./paths.ts";
+import type { Host } from "../host.ts";
+import { readManifest, type Manifest, type ManifestEntry } from "../manifest.ts";
+import { joinPath, relativePath } from "../paths.ts";
 import type { WorkspaceMember } from "./workspace.ts";
 import type { WorkspaceResolver } from "./workspace-resolution.ts";
-import { MANIFEST } from "./fs/manifest.ts";
+import { MANIFEST } from "../fs/manifest.ts";
 
 /** The one character a subpath pattern of a manifest's `exports` holds. */
 const SUBPATH_WILDCARD = "*";