@cplieger/deadset-ts 8.0.0-dev.2 → 8.0.0-dev.21

package/src/load/synthesize.ts

@@ -0,0 +1,230 @@
+/**
+ * The programs a run forms for the JavaScript files no compiler configuration lists: one per
+ * package, over the files git would track that are no build output, each written as a
+ * configuration only the snapshot holds, with the module system of the runtime its package
+ * is written for.
+ */
+
+import { readCommands } from "../commands/read.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, minifiedBy, minifiedByName } from "../javascript-file.ts";
+import { isRecord } from "../json-document.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";
+import type { Configuration, Origin } from "./discover.ts";
+import { writtenPath } from "./workspace-programs.ts";
+
+/** The name a package's program is written beside, made free by {@link writtenPath}. */
+const GROUP_CONFIGURATION = "jsconfig.json";
+
+/**
+ * The options of a formed program before its runtime is chosen: unchecked JavaScript, no
+ * emit, no installed package's JavaScript, which is not the target's code and grows the
+ * program with the depth of `node_modules`, and every type package visible.
+ */
+const FORMED_OPTIONS = {
+  allowJs: true,
+  checkJs: false,
+  noEmit: true,
+  skipLibCheck: true,
+  maxNodeModuleJsDepth: 0,
+  target: "esnext",
+  jsx: "preserve",
+  resolveJsonModule: true,
+} as const;
+
+interface CandidateContext {
+  /** The files a configuration of the run lists or a test file joins it with, absolute. */
+  readonly covered: ReadonlySet<string>;
+  /** The output and declaration directories of every configuration of the run, absolute. */
+  readonly outputs: readonly string[];
+  /** Whether git ignores one absolute path. */
+  readonly ignored: (path: string) => boolean;
+}
+
+/** 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) !== undefined) {
+    return true;
+  }
+  try {
+    return minifiedBy(file, host.readFile(file)) !== undefined;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * The JavaScript files below `root` a program may be formed over: none in a skipped
+ * directory, none git ignores, none minified, none `context` covers and none below one of
+ * its output directories. A convention row's generated directory leaves out more, once the
+ * rows are read: {@link formedGroups}.
+ */
+export function candidateFiles(
+  host: Host,
+  root: string,
+  { covered, outputs, ignored }: CandidateContext,
+): readonly string[] {
+  return filesBelow(host, root, (name) => JAVASCRIPT_FILE.test(name))
+    .map((path) => joinPath(root, path))
+    .filter(
+      (file) =>
+        !covered.has(file) &&
+        !outputs.some((dir) => relativePath(dir, file) !== undefined) &&
+        !ignored(file) &&
+        !minifiedFile(host, file),
+    );
+}
+
+interface Group {
+  /** The package's directory, absolute. */
+  readonly dir: string;
+  readonly manifest: ManifestRead;
+  /** Its files, absolute, in ascending order. */
+  readonly files: readonly string[];
+}
+
+/**
+ * The candidates below `root` grouped by package, in directory order, less every file below a
+ * directory an applied row of `conventions` names as generated: each file belongs to the
+ * nearest directory at or above it, up to `root`, that holds a `package.json`, a manifest that
+ * does not parse included, and to `root` where none does.
+ */
+export function formedGroups(
+  host: Host,
+  root: string,
+  candidates: readonly string[],
+  conventions: Conventions,
+): readonly Group[] {
+  const generated = conventions.generated.map(({ dir, below }) => joinPath(dir, below));
+  const groups = new Map<string, string[]>();
+  for (const file of candidates) {
+    if (generated.some((dir) => relativePath(dir, file) !== undefined)) {
+      continue;
+    }
+    const dir = packageOf(host, root, file);
+    groups.set(dir, [...(groups.get(dir) ?? []), file]);
+  }
+  return [...groups]
+    .sort(([a], [b]) => bytewise(a, b))
+    .map(([dir, files]) => ({
+      dir,
+      manifest: readManifestAt(host, dir),
+      files: files.sort(bytewise),
+    }));
+}
+
+/** The directory whose `package.json` groups one file: the nearest at or above it, up to `root`. */
+export function packageOf(host: Host, root: string, file: string): string {
+  return ancestors(dirnamePath(file), root).find((at) => holdsManifest(host, at)) ?? root;
+}
+
+type Runtime = "bundler" | "node";
+
+const RUNTIME_OPTIONS = {
+  bundler: { module: "preserve", moduleResolution: "bundler" },
+  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;
+
+/**
+ * Whether one manifest says its package runs under Node: a Node member, `engines.node`
+ * included, or a command string of it that runs a file with `node`, as `commands/read.ts` reads it.
+ */
+function writtenForNode(
+  host: Host,
+  dir: string,
+  manifest: Readonly<Record<string, unknown>>,
+): boolean {
+  const { engines } = manifest;
+  return (
+    NODE_MEMBERS.some((member) => manifest[member] !== undefined) ||
+    (isRecord(engines) && engines["node"] !== undefined) ||
+    manifestCommands(host, dir, manifest).some(({ command }) =>
+      readCommands(command, dir).runs.some((run) => run.runtime === "node"),
+    )
+  );
+}
+
+/**
+ * The manifests, by path as `conventions` names them, an applied row of a tool that bundles
+ * applies through.
+ */
+export function bundlingManifests(conventions: Conventions): ReadonlySet<string> {
+  return new Set(
+    conventions.applied
+      .filter((one) => CONVENTION_ROWS.some((row) => row.name === one.name && row.bundles === true))
+      .map((one) => one.manifest),
+  );
+}
+
+interface FormedProgram {
+  readonly configuration: Configuration;
+  readonly group: Group;
+}
+
+interface Forming {
+  /** The tree's root, absolute, which the manifest paths of `bundling` are read below. */
+  readonly root: string;
+  readonly origin: Origin;
+  /** The manifests a bundling row applies through, as {@link bundlingManifests} names them. */
+  readonly bundling: ReadonlySet<string>;
+  /** The name one group's program is given, by the group's manifest path, `undefined` for none. */
+  readonly idOf: (manifest: string | undefined) => string;
+}
+
+/**
+ * Each group's program, given the module system of the runtime its package is written for: a
+ * bundler's where a row of a tool that bundles applies through the group's manifest or the
+ * root's, else Node's where its manifest says the package runs under Node or a command string of
+ * it runs a file with `node`, under which a file's
+ * extension and its package's `type` decide its module format, else a bundler's, which reads a
+ * file with no module syntax as a classic script, as a browser loads it.
+ */
+export function formedPrograms(
+  engine: Engine,
+  host: Host,
+  groups: readonly Group[],
+  { root, origin, bundling, idOf }: Forming,
+): readonly FormedProgram[] {
+  return groups.map((group) => {
+    const manifest = group.manifest.kind === "absent" ? undefined : joinPath(group.dir, MANIFEST);
+    const below = manifest === undefined ? undefined : relativePath(root, manifest);
+    const runtime: Runtime =
+      !bundling.has(MANIFEST) &&
+      (below === undefined || !bundling.has(below)) &&
+      group.manifest.kind === "read" &&
+      writtenForNode(host, group.dir, group.manifest.manifest)
+        ? "node"
+        : "bundler";
+    const configFile = writtenPath(host, joinPath(group.dir, GROUP_CONFIGURATION));
+    const written = {
+      compilerOptions: { ...FORMED_OPTIONS, ...RUNTIME_OPTIONS[runtime] },
+      files: group.files,
+    };
+    return {
+      group,
+      configuration: {
+        id: idOf(manifest),
+        configFile,
+        origin,
+        parsed: engine.parseConfigJson(written, configFile),
+        written,
+      },
+    };
+  });
+}

package/src/load/test-globals.ts

@@ -0,0 +1,251 @@
+/**
+ * The globals a test runner injects into every file it runs, which no import names: a
+ * Vitest configuration whose `test.globals` is `true` gives each test and each file it
+ * loads `describe`, `it`, `expect` and `vi` (https://vitest.dev/config/globals). A program
+ * analyzed without the runner's declarations of them reads every use as an error, so a
+ * configuration under such a runner is read with them; and a file that calls one is
+ * written for the runner, as one that imports it is.
+ */
+
+import {
+  isAsExpression,
+  isBinaryExpression,
+  isCallExpression,
+  isExportAssignment,
+  isExpressionStatement,
+  isIdentifier,
+  isObjectLiteralExpression,
+  isParenthesizedExpression,
+  isPropertyAccessExpression,
+  isPropertyAssignment,
+  isSatisfiesExpression,
+  SyntaxKind,
+  type Node,
+  type SourceFile,
+} from "@typescript/native/ast";
+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";
+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";
+const GLOBALS_TYPES = "vitest/globals";
+
+/** The configuration files the runner reads its settings from, by name. */
+const RUNNER_CONFIG = /^(?:vitest|vite)\.config\.(?:js|mjs|cjs|ts|mts|cts)$/u;
+
+/** The globals `vitest/globals` declares that a test or a helper calls or reads a member of. */
+const GLOBAL_NAMES: ReadonlySet<string> = new Set([
+  "afterAll",
+  "afterEach",
+  "assert",
+  "assertType",
+  "beforeAll",
+  "beforeEach",
+  "bench",
+  "describe",
+  "expect",
+  "expectTypeOf",
+  "it",
+  "onTestFailed",
+  "onTestFinished",
+  "suite",
+  "test",
+  "vi",
+  "vitest",
+]);
+
+/** The expression one wrapper that changes no value holds, and a call's first argument. */
+function configObject(node: Node): Node | undefined {
+  let at: Node | undefined = node;
+  while (at !== undefined) {
+    if (isParenthesizedExpression(at) || isAsExpression(at) || isSatisfiesExpression(at)) {
+      at = at.expression;
+    } else if (isCallExpression(at)) {
+      at = at.arguments[0];
+    } else {
+      return at;
+    }
+  }
+  return undefined;
+}
+
+/** The value one object literal writes for one member as `name: value`. */
+function member(object: Node | undefined, name: string): Node | undefined {
+  if (object === undefined || !isObjectLiteralExpression(object)) {
+    return undefined;
+  }
+  for (const property of object.properties) {
+    if (
+      isPropertyAssignment(property) &&
+      isIdentifier(property.name) &&
+      property.name.text === name
+    ) {
+      return configObject(property.initializer);
+    }
+  }
+  return undefined;
+}
+
+/** Whether one runner configuration's default export sets `test.globals` to `true`. */
+function setsGlobals(file: SourceFile): boolean {
+  for (const statement of file.statements) {
+    let exported: Node | undefined;
+    if (isExportAssignment(statement)) {
+      exported = statement.expression;
+    } else if (isExpressionStatement(statement) && isBinaryExpression(statement.expression)) {
+      const { left, operatorToken, right } = statement.expression;
+      if (
+        operatorToken.kind === SyntaxKind.EqualsToken &&
+        isPropertyAccessExpression(left) &&
+        isIdentifier(left.expression) &&
+        left.expression.text === "module" &&
+        isIdentifier(left.name) &&
+        left.name.text === "exports"
+      ) {
+        exported = right;
+      }
+    }
+    const object = exported === undefined ? undefined : configObject(exported);
+    const globals = member(member(object, "test"), "globals");
+    if (globals?.kind === SyntaxKind.TrueKeyword) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/** Whether the runner's configuration in one manifest's directory injects the globals. */
+function injectsGlobals(host: Host, parse: ParseFile, dir: string): boolean {
+  return filesIn(host, dir, (name) => RUNNER_CONFIG.test(name)).some((name) => {
+    const path = joinPath(dir, name);
+    try {
+      return setsGlobals(parse(path, host.readFile(path)));
+    } catch {
+      return false;
+    }
+  });
+}
+
+/** Whether a file declaring the globals is installed where the configuration resolves packages from. */
+function globalsInstalled(host: Host, configFile: string): boolean {
+  return ancestors(dirnamePath(configFile)).some(
+    (dir) =>
+      host.kindOf(joinPath(dir, INSTALLED_PACKAGES, GLOBALS_RUNNER, "globals.d.ts")) === "file",
+  );
+}
+
+/** The directory of the manifest nearest one configuration file, at or above its own. */
+function manifestDir(host: Host, configFile: string): string | undefined {
+  return ancestors(dirnamePath(configFile)).find((dir) => holdsManifest(host, dir));
+}
+
+function typesOf(value: unknown): readonly string[] | undefined {
+  return Array.isArray(value) && value.every((one) => typeof one === "string") ? value : undefined;
+}
+
+/**
+ * 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 testGlobals(
+  host: Host,
+  parse: ParseFile,
+  plans: readonly ProgramPlan[],
+): readonly ProgramPlan[] {
+  const injects = new Map<string, boolean>();
+  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) {
+      return plan;
+    }
+    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],
+                },
+              },
+            },
+          };
+    }
+    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;
+    return listed.includes(GLOBALS_TYPES)
+      ? plan
+      : {
+          ...plan,
+          build: {
+            kind: "configuration",
+            value: {
+              ...written,
+              compilerOptions: { ...options, types: [...listed, GLOBALS_TYPES] },
+            },
+          },
+        };
+  });
+}
+
+/**
+ * Whether one file names a global the runner injects, which is how a file written for the
+ * runner's globals reads: a call of one of the names or a read of a member of it that
+ * resolves to a declaration outside the project's own files, the runner's declaration
+ * file. A name the file binds, imported, declared or a parameter, resolves to its own.
+ */
+export function namesTestGlobals<Brand>(project: ProjectView<Brand>, file: SourceFile): boolean {
+  const named: Node[] = [];
+  const visit = (node: Node): void => {
+    const callee = isCallExpression(node)
+      ? node.expression
+      : isPropertyAccessExpression(node)
+        ? node.expression
+        : undefined;
+    if (callee !== undefined && isIdentifier(callee) && GLOBAL_NAMES.has(callee.text)) {
+      named.push(callee);
+    }
+    node.forEachChild(visit);
+  };
+  file.forEachChild(visit);
+  if (named.length === 0) {
+    return false;
+  }
+  const own = project.ownPaths();
+  return project
+    .symbolsAt(named.map((node) => project.handle(node)))
+    .some(
+      (symbol) =>
+        symbol === UNANSWERED ||
+        (symbol !== undefined &&
+          symbol.declarations.length > 0 &&
+          symbol.declarations.every((handle) => !own.has(handle.path))),
+    );
+}

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 "../roots/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) {