@cplieger/deadset-ts 7.2.0-dev.4 → 8.0.0-dev.10

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,11 +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";
 
 /** The one character a subpath pattern of a manifest's `exports` holds. */
 const SUBPATH_WILDCARD = "*";
@@ -84,8 +85,7 @@ export function memberEntries(
     }
     const manifest = readManifest(host, member.dir);
     const where =
-      relativePath(targetRoot, joinPath(member.dir, "package.json")) ??
-      joinPath(member.dir, "package.json");
+      relativePath(targetRoot, joinPath(member.dir, MANIFEST)) ?? joinPath(member.dir, MANIFEST);
     const kept = manifest.entries.flatMap((entry): ManifestEntry[] => {
       const exported = entry.member.startsWith("exports");
       if (member.private && exported) {

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

@@ -16,10 +16,16 @@ import type {
 } from "@typescript/native/sync";
 import { isStringLiteralLikeNode } from "@typescript/native/ast";
 import type { StringLiteralLikeNode } from "@typescript/native/ast";
-import type { Host } from "./host.ts";
-import { dirnamePath, resolvePath } from "./paths.ts";
-import type { Engine } from "./session.ts";
+import type { Host } from "../host.ts";
+import { JAVASCRIPT_FILE } from "../javascript-file.ts";
+import { isRecord } from "../json-document.ts";
+import { dirnamePath, resolvePath } from "../paths.ts";
+import { batched, type Engine, type ProgramBuild } from "../session.ts";
 import type { WorkspaceResolver } from "./workspace-resolution.ts";
+import { bytewise } from "../text/compare.ts";
+import { PRODUCT } from "../product.ts";
+import type { Parsed } from "./discover.ts";
+import type { Build, CompilerOptions } from "./plan.ts";
 
 /** One member import no member source answers for. */
 interface UnresolvedImport {
@@ -42,31 +48,35 @@ export interface MemberReading {
   readonly componentsUnread: string | undefined;
 }
 
-/** How a snapshot reads one configuration that imports a member. */
-export type WorkspaceProgram =
-  | { readonly kind: "program"; readonly params: CreateSnapshotProgramParams }
-  /** A configuration only the snapshot holds, at a path no file has. */
-  | { readonly kind: "configuration"; readonly file: string; readonly text: string };
+/** One configuration as a written configuration or a described program. */
+type Written = Exclude<Build, { readonly kind: "project" }>;
 
 /** The programs one run builds instead of opening projects, with what reading them did. */
 interface WorkspacePrograms {
   /** Per configuration that imports a member, how the snapshot reads it. */
-  readonly programs: ReadonlyMap<string, WorkspaceProgram>;
+  readonly programs: ReadonlyMap<string, Written>;
   readonly readings: readonly MemberReading[];
 }
 
-type Parsed = ReturnType<Engine["parseConfigFile"]>;
-
-/** The most questions one round trip carries. */
-const BATCH = 2048;
+/** One configuration the rounds read: its parse and the options the plan builds it with. */
+export interface PlannedConfiguration {
+  readonly configFile: string;
+  readonly parsed: Parsed;
+  readonly options: CompilerOptions;
+  /** The configuration of a program the run forms, which only the snapshot holds, at `configFile`. */
+  readonly written?: Readonly<Record<string, unknown>> | undefined;
+}
 
 /**
- * The options a configuration's program is built with: its own, less the ones that
- * lay out an emitted program's inputs and outputs. The analysis emits nothing, and a
- * member's source is outside the importer's root directory by construction, which
- * the compiler refuses under such a layout.
+ * The options a configuration's program is built with: the plan's, less the ones that lay
+ * out an emitted program's inputs and outputs. The analysis emits nothing, and a member's
+ * source is outside the importer's root directory by construction, which the compiler
+ * refuses under such a layout.
  */
-function analysisOptions(parsed: Parsed): CreateSnapshotProgramParams["compilerOptions"] {
+function analysisOptions(
+  options: CompilerOptions,
+  readsJavaScript: boolean,
+): CreateSnapshotProgramParams["compilerOptions"] {
   const {
     composite,
     rootDir: _rootDir,
@@ -74,8 +84,24 @@ function analysisOptions(parsed: Parsed): CreateSnapshotProgramParams["compilerO
     declarationDir: _declarationDir,
     tsBuildInfoFile: _tsBuildInfoFile,
     ...kept
-  } = parsed.options;
-  return composite === true ? { ...kept, declaration: true } : kept;
+  } = options;
+  const read = readsJavaScript ? { ...kept, allowJs: true } : kept;
+  return composite === true ? { ...read, declaration: true } : read;
+}
+
+/**
+ * Whether one reading answers a member import with a JavaScript file, which its program reads
+ * as source only where it allows JavaScript, a program formed for a JavaScript member being the
+ * member's source.
+ */
+function readsJavaScript(reading: Reading): boolean {
+  return (
+    reading.options.allowJs !== true &&
+    reading.entries.some((entry) => {
+      const file = entry.result.resolvedFileName;
+      return typeof file === "string" && JAVASCRIPT_FILE.test(file);
+    })
+  );
 }
 
 /** The conditions an `exports` lookup under one configuration and one resolution mode reads. */
@@ -97,9 +123,7 @@ function resolutionMode(kind: ModuleKind): ResolutionMode | undefined {
 }
 
 /** One configuration's state across the rounds. */
-interface Reading {
-  readonly configFile: string;
-  readonly parsed: Parsed;
+interface Reading extends PlannedConfiguration {
   readonly entries: ModuleResolutionEntry[];
   readonly seen: Set<string>;
   /** Per member specifier, every file an import of it is read as. */
@@ -121,34 +145,56 @@ function unstatable(reading: Reading): string | undefined {
   return undefined;
 }
 
-/** The path beside `configFile` its written configuration takes, which no file has. */
-export function writtenPath(host: Host, configFile: string): string {
+/** The path beside `configFile` its written configuration takes, which no file and none of `taken` has. */
+export function writtenPath(
+  host: Host,
+  configFile: string,
+  taken: ReadonlySet<string> = new Set(),
+): string {
   const stem = configFile.replace(/\.json$/u, "");
   for (let counter = 0; ; counter += 1) {
-    const path = `${stem}.deadset-ts${counter === 0 ? "" : `-${String(counter)}`}.json`;
-    if (host.kindOf(path) === "absent") {
+    const path = `${stem}.${PRODUCT}${counter === 0 ? "" : `-${String(counter)}`}.json`;
+    if (host.kindOf(path) === "absent" && !taken.has(path)) {
       return path;
     }
   }
 }
 
 /**
- * The configuration that reads as one configuration's program: it extends it, lays out
- * no output for the reason {@link analysisOptions} gives, maps each answered specifier
- * to its file, and carries the references the program does. The compiler's default
- * `exclude` names the output directories this drops, so where the file list moves it is
- * restated; a list that still differs, or answers `paths` cannot state, are a reason.
+ * The path the snapshot holds one configuration's written form at: a formed configuration's
+ * own path, else a free one beside it that no configuration of `formed` holds, because a formed
+ * program in a directory with a `jsconfig.json` takes the name that file's written form would.
+ */
+export function writtenFileOf(
+  host: Host,
+  configuration: Pick<PlannedConfiguration, "configFile" | "written">,
+  formed: ReadonlySet<string>,
+): string {
+  return configuration.written === undefined
+    ? writtenPath(host, configuration.configFile, formed)
+    : configuration.configFile;
+}
+
+/**
+ * The configuration that reads as one configuration's program: it extends it, lays out no output
+ * ({@link analysisOptions}), maps each answered specifier to its file and keeps its references.
+ * Where the file list moves, the default `exclude` the dropped output directories are named in is
+ * restated, and one that {@link readsJavaScript} lists its files outright, as `allowJs` widens its
+ * `include` to JavaScript; a list that still differs, or answers `paths` cannot state, are a
+ * reason. A formed configuration, which no file holds to extend, is its own value with `paths`.
  */
 function configurationOf(
   engine: Engine,
   host: Host,
   reading: Reading,
-): WorkspaceProgram | { readonly kind: "unread"; readonly reason: string } {
+  formed: ReadonlySet<string>,
+): Written | { readonly kind: "unread"; readonly reason: string } {
   const reason = unstatable(reading);
   if (reason !== undefined) {
     return { kind: "unread", reason };
   }
-  const { options, projectReferences: references = [] } = reading.parsed;
+  const { options } = reading;
+  const references = reading.parsed.projectReferences ?? [];
   const raw: unknown = (options as Record<string, unknown>)["pathsBasePath"];
   const base = typeof raw === "string" ? raw : dirnamePath(reading.configFile);
   const paths: Record<string, string[]> = {};
@@ -161,6 +207,17 @@ function configurationOf(
       paths[entry.moduleName] = [file];
     }
   }
+  if (reading.written !== undefined) {
+    const held = reading.written["compilerOptions"];
+    return {
+      kind: "configuration",
+      value: {
+        ...reading.written,
+        compilerOptions: { ...(isRecord(held) ? held : {}), paths },
+      },
+    };
+  }
+  const javascript = readsJavaScript(reading);
   const json = (exclude: readonly string[] | undefined): Record<string, unknown> => ({
     extends: reading.configFile,
     compilerOptions: {
@@ -169,18 +226,20 @@ function configurationOf(
       declarationDir: null,
       tsBuildInfoFile: null,
       ...(options.composite === true ? { composite: false, declaration: true } : {}),
+      ...(javascript ? { allowJs: true } : {}),
       paths,
     },
     ...(references.length > 0
       ? { references: references.map((reference) => ({ path: reference.path })) }
       : {}),
+    ...(javascript ? { files: [...reading.parsed.fileNames], include: [] } : {}),
     ...(exclude === undefined ? {} : { exclude }),
   });
-  const file = writtenPath(host, reading.configFile);
-  const expected = [...reading.parsed.fileNames].sort().join("\u0000");
+  const file = writtenFileOf(host, reading, formed);
+  const expected = [...reading.parsed.fileNames].sort(bytewise).join("\u0000");
   const listed = (value: Record<string, unknown>): string | undefined => {
     try {
-      return [...engine.parseConfigJson(value, file).fileNames].sort().join("\u0000");
+      return [...engine.parseConfigJson(value, file).fileNames].sort(bytewise).join("\u0000");
     } catch {
       return undefined;
     }
@@ -198,7 +257,7 @@ function configurationOf(
       };
     }
   }
-  return { kind: "configuration", file, text: `${JSON.stringify(value, null, 2)}\n` };
+  return { kind: "configuration", value };
 }
 
 /** The program one configuration is built as, under the answers it holds so far. */
@@ -206,7 +265,7 @@ function programOf(
   engine: Engine,
   reading: Reading,
 ): { readonly params: CreateSnapshotProgramParams; readonly resolver: ModuleResolver } {
-  const compilerOptions = analysisOptions(reading.parsed);
+  const compilerOptions = analysisOptions(reading.options, readsJavaScript(reading));
   const references = reading.parsed.projectReferences ?? [];
   const resolver = engine.createModuleResolver(compilerOptions, reading.entries);
   return {
@@ -223,23 +282,6 @@ function programOf(
   };
 }
 
-function chunks<T>(items: readonly T[]): readonly (readonly T[])[] {
-  const found: T[][] = [];
-  for (let at = 0; at < items.length; at += BATCH) {
-    found.push(items.slice(at, at + BATCH));
-  }
-  return found;
-}
-
-/** Asks one question of every item, in round trips of at most {@link BATCH}. */
-function batched<T, A>(
-  engine: Engine,
-  items: readonly T[],
-  question: (item: T) => Parameters<Engine["batch"]>[0][number],
-): A[] {
-  return chunks(items).flatMap((run) => engine.batch(run.map(question)) as A[]);
-}
-
 /** One round over one program: answers the member imports no earlier round asked about. */
 function scan(
   engine: Engine,
@@ -332,6 +374,18 @@ type Built =
     }
   | { readonly kind: "configuration"; readonly file: string; readonly text: string };
 
+function configurationText(value: Readonly<Record<string, unknown>>): string {
+  return `${JSON.stringify(value, null, 2)}\n`;
+}
+
+/** One configuration value as the snapshot holds it, at `file`, which no file on disk holds. */
+export function writtenConfiguration(
+  file: string,
+  value: Readonly<Record<string, unknown>>,
+): Extract<ProgramBuild, { readonly kind: "configuration" }> {
+  return { kind: "configuration", file, text: configurationText(value) };
+}
+
 /**
  * Answers the member imports of every reading `build` describes, round by round, all
  * the readings still adding answers built in one snapshot per round. A reading `build`
@@ -387,45 +441,38 @@ function readRounds(
 export function workspacePrograms(
   engine: Engine,
   host: Host,
-  configFiles: readonly string[],
+  configurations: readonly PlannedConfiguration[],
   resolver: WorkspaceResolver,
 ): WorkspacePrograms {
-  const readings: Reading[] = configFiles.flatMap((configFile) => {
-    let parsed: Parsed;
-    try {
-      parsed = engine.parseConfigFile(configFile);
-    } catch {
-      // A configuration that does not read is opened as a project, which states why.
-      return [];
-    }
-    return [
-      {
-        configFile,
-        parsed,
-        entries: [],
-        seen: new Set<string>(),
-        bound: new Map<string, Set<string>>(),
-        unresolved: [],
-      },
-    ];
-  });
+  const readings: Reading[] = configurations.map((configuration) => ({
+    ...configuration,
+    entries: [],
+    seen: new Set<string>(),
+    bound: new Map<string, Set<string>>(),
+    unresolved: [],
+  }));
+  const formed = new Set(
+    configurations.filter((one) => one.written !== undefined).map((one) => one.configFile),
+  );
   readRounds(engine, readings, resolver, (reading) => ({
     kind: "program",
     ...programOf(engine, reading),
   }));
   if (engine.readsComponents) {
     readRounds(engine, readings, resolver, (reading) => {
-      const one = configurationOf(engine, host, reading);
-      return one.kind === "configuration" ? one : undefined;
+      const one = configurationOf(engine, host, reading, formed);
+      return one.kind === "configuration"
+        ? writtenConfiguration(writtenFileOf(host, reading, formed), one.value)
+        : undefined;
     });
   }
-  const programs = new Map<string, WorkspaceProgram>();
+  const programs = new Map<string, Written>();
   const unread = new Map<string, string>();
   for (const reading of readings) {
     if (reading.entries.length === 0) {
       continue;
     }
-    const one = engine.readsComponents ? configurationOf(engine, host, reading) : undefined;
+    const one = engine.readsComponents ? configurationOf(engine, host, reading, formed) : undefined;
     if (one !== undefined && one.kind !== "unread") {
       programs.set(reading.configFile, one);
       continue;