@cplieger/deadset-ts 8.0.0-dev.1 → 8.0.0-dev.10

package/src/load/specifiers.ts

@@ -0,0 +1,168 @@
+/**
+ * The module specifiers of the JavaScript files a configuration does not check, read for what
+ * the compiler leaves unresolved. Unchecked JavaScript reports no unfound module, and a
+ * JavaScript file may name a file that is absent on purpose, so an unresolved one is no failure
+ * of the program: a relative one is noted, and only a configuration whose imported dependencies
+ * are none of them installed fails, because its program is not the one the project runs.
+ */
+
+import {
+  isBinaryExpression,
+  isCallExpression,
+  isParenthesizedExpression,
+  isStringLiteralLikeNode,
+  isTryStatement,
+  SyntaxKind,
+  type Node,
+  type SourceFile,
+  type StringLiteralLikeNode,
+} from "@typescript/native/ast";
+import type { Program } from "@typescript/native/sync";
+import { packageOfSpecifier } from "../dependencies.ts";
+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 { 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;
+  readonly position: Position;
+}
+
+/** What the specifiers of one project's unchecked JavaScript files say. */
+interface SpecifierReading {
+  readonly unresolved: readonly UnresolvedSpecifier[];
+  /** The failure of a project whose imported dependencies are none of them installed. */
+  readonly uninstalled: Failure | undefined;
+}
+
+/**
+ * Whether one specifier is loaded optionally: written inside a `try` block, or as a call whose
+ * result an `||` or a `??` falls back from, so the program is written for its absence.
+ */
+function optional(node: StringLiteralLikeNode): boolean {
+  const call = node.parent;
+  let operand: Node = call;
+  let parent = call.parent as Node | undefined;
+  while (parent !== undefined && isParenthesizedExpression(parent)) {
+    operand = parent;
+    parent = parent.parent;
+  }
+  if (
+    isCallExpression(call) &&
+    parent !== undefined &&
+    isBinaryExpression(parent) &&
+    parent.left === operand &&
+    (parent.operatorToken.kind === SyntaxKind.BarBarToken ||
+      parent.operatorToken.kind === SyntaxKind.QuestionQuestionToken)
+  ) {
+    return true;
+  }
+  for (let at: Node | undefined = node; at !== undefined; at = at.parent as Node | undefined) {
+    const above = at.parent as Node | undefined;
+    if (above !== undefined && isTryStatement(above) && above.tryBlock === at) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Whether a manifest at or above `dir`, no higher than `root`, declares the package `name`. A
+ * manifest that does not parse or cannot be read ends the search, because what it declares is
+ * unanswered and a manifest above it is another package's.
+ */
+function declared(host: Host, dir: string, root: string, name: string): boolean {
+  for (const at of ancestors(dir, root)) {
+    const read = readManifestAt(host, at);
+    if (read.kind === "malformed" || read.kind === "unread") {
+      return false;
+    }
+    if (read.kind === "read" && dependencySpecifiers(read.manifest, name).length > 0) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/** What a project's specifiers are read against. */
+interface SpecifierContext {
+  /** Whether the project's options check its JavaScript files, which then report their own. */
+  readonly checked: boolean;
+  /** The target root, absolute. */
+  readonly root: string;
+  /** The directories a configuration of the run emits into, whose paths name build output. */
+  readonly outputs: readonly string[];
+}
+
+/**
+ * The specifiers of every JavaScript file of `project`, where its options do not check
+ * JavaScript, each asked of the compiler in batched round trips. A relative one naming a path
+ * below one of the run's output directories names build output, which a build writes later.
+ */
+export function readSpecifiers<Brand>(
+  engine: Engine,
+  host: Host,
+  project: ProjectView<Brand>,
+  { checked, root, outputs }: SpecifierContext,
+): SpecifierReading {
+  if (checked) {
+    return { unresolved: [], uninstalled: undefined };
+  }
+  const usages: { readonly file: SourceFile; readonly node: StringLiteralLikeNode }[] = [];
+  for (const file of project.ownSourceFiles()) {
+    if (JAVASCRIPT_FILE.test(file.fileName)) {
+      for (const node of file.imports) {
+        if (isStringLiteralLikeNode(node) && !optional(node)) {
+          usages.push({ file, node });
+        }
+      }
+    }
+  }
+  const answers = batched<
+    (typeof usages)[number],
+    ReturnType<Program["getResolvedModuleFromModuleSpecifier"]>
+  >(engine, usages, ({ file, node }) =>
+    project.program.getResolvedModuleFromModuleSpecifier.gen(node, file.fileName),
+  );
+
+  const unresolved: UnresolvedSpecifier[] = [];
+  let missing: { readonly file: SourceFile; readonly node: StringLiteralLikeNode } | undefined;
+  let installed = false;
+  for (const [at, usage] of usages.entries()) {
+    const resolved = (answers[at]?.resolvedFileName ?? "") !== "";
+    const specifier = usage.node.text;
+    const name = packageOfSpecifier(specifier);
+    if (RELATIVE.test(specifier)) {
+      const named = resolvePath(dirnamePath(usage.file.fileName), specifier);
+      if (!resolved && !outputs.some((dir) => relativePath(dir, named) !== undefined)) {
+        unresolved.push({
+          specifier,
+          position: renderPosition(usage.file, root, usage.node.getStart()),
+        });
+      }
+    } else if (name !== undefined && declared(host, dirnamePath(usage.file.fileName), root, name)) {
+      installed ||= resolved;
+      missing ??= resolved ? undefined : usage;
+    }
+  }
+  if (installed || missing === undefined) {
+    return { unresolved, uninstalled: undefined };
+  }
+  const { path, line } = renderPosition(missing.file, root, missing.node.getStart());
+  return {
+    unresolved,
+    uninstalled: {
+      failureClass: "missing-module",
+      detail: `${path}:${String(line)}: ${path} imports ${JSON.stringify(missing.node.text)}, a declared dependency, and no dependency the configuration's JavaScript files import is installed: run the package manager's install`,
+    },
+  };
+}

package/src/load/synthesize.ts

@@ -0,0 +1,211 @@
+/**
+ * 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 { CONVENTION_ROWS } from "../convention-rows.ts";
+import type { Conventions } from "../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 { isRecord } from "../json-document.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)) {
+    return true;
+  }
+  try {
+    return minified(file, host.readFile(file));
+  } 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>>>;
+
+/** 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, `engines.node` included; its scripts are not read. */
+function writtenForNode(manifest: Readonly<Record<string, unknown>>): boolean {
+  const { engines } = manifest;
+  return (
+    NODE_MEMBERS.some((member) => manifest[member] !== undefined) ||
+    (isRecord(engines) && engines["node"] !== undefined)
+  );
+}
+
+/**
+ * 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, 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(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 "../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))),
+    );
+}