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

package/src/test-globals.ts

@@ -0,0 +1,275 @@
+/**
+ * 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 { 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";
+
+/** 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 {
+  let names: readonly string[];
+  try {
+    names = host
+      .readDirectory(dir)
+      .filter((entry) => !entry.directory && RUNNER_CONFIG.test(entry.name))
+      .map((entry) => entry.name);
+  } catch {
+    return false;
+  }
+  return names.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 {
+  for (let dir = dirnamePath(configFile); ; dir = dirnamePath(dir)) {
+    if (host.kindOf(joinPath(dir, "node_modules", GLOBALS_RUNNER, "globals.d.ts")) === "file") {
+      return true;
+    }
+    if (dirnamePath(dir) === dir) {
+      return false;
+    }
+  }
+}
+
+/** The directory of the manifest nearest one configuration file, at or above its own. */
+function manifestDir(host: Host, configFile: string): string | undefined {
+  for (let dir = dirnamePath(configFile); ; dir = dirnamePath(dir)) {
+    if (host.kindOf(joinPath(dir, "package.json")) === "file") {
+      return dir;
+    }
+    if (dirnamePath(dir) === dir) {
+      return undefined;
+    }
+  }
+}
+
+function typesOf(value: unknown): readonly string[] | undefined {
+  return Array.isArray(value) && value.every((one) => typeof one === "string") ? value : 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.
+ */
+export function withTestGlobals(
+  engine: Engine,
+  host: Host,
+  parse: ParseFile,
+  configFiles: readonly string[],
+  programs: ReadonlyMap<string, WorkspaceProgram>,
+): ReadonlyMap<string, WorkspaceProgram> {
+  const found = new Map(programs);
+  const injects = new Map<string, boolean>();
+  for (const configFile of configFiles) {
+    const dir = manifestDir(host, configFile);
+    if (dir === undefined || !globalsInstalled(host, configFile)) {
+      continue;
+    }
+    if (!injects.has(dir)) {
+      injects.set(dir, injectsGlobals(host, parse, dir));
+    }
+    if (injects.get(dir) !== true) {
+      continue;
+    }
+    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;
+    }
+    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 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;
+}
+
+/**
+ * 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/type-errors.ts

@@ -31,6 +31,13 @@ import { findWorkspace, type Workspace } from "./workspace.ts";
 /** The compiler's codes for an import whose module it cannot find. */
 const MODULE_NOT_FOUND: ReadonlySet<number> = new Set([2307, 2792]);
 
+/**
+ * The compiler's codes for where the configuration places a file, which leave every type
+ * the file's statements carry as it is: an output that would overwrite an input (5055,
+ * 5056), a file outside `rootDir` (6059), one a composite project does not list (6307).
+ */
+const CONFIGURATION_LEVEL: ReadonlySet<number> = new Set([5055, 5056, 6059, 6307]);
+
 const MANIFEST = "package.json";
 const MANIFEST_SECTIONS = [
   "dependencies",
@@ -290,8 +297,8 @@ function messageOf(text: string, targetRoot: string): string {
 
 /**
  * Reads the errors one project's own files carry. A diagnostic marking unnecessary code
- * is no error here, and one in a file that is not the project's own is that file's
- * package's to answer for.
+ * or about where the configuration places a file is no error here, and one in a file that
+ * is not the project's own is that file's package's to answer for.
  */
 export function readErrors<Brand>(
   project: ProjectView<Brand>,
@@ -313,7 +320,11 @@ export function readErrors<Brand>(
   const skips: Skip[] = [];
   for (const { diagnostic, at } of errors) {
     const file = diagnostic.fileName === undefined ? undefined : files.get(diagnostic.fileName);
-    if (file === undefined || diagnostic.reportsUnnecessary === true) {
+    if (
+      file === undefined ||
+      diagnostic.reportsUnnecessary === true ||
+      CONFIGURATION_LEVEL.has(diagnostic.code)
+    ) {
       continue;
     }
     const path = relativePath(context.targetRoot, file.fileName) ?? file.fileName;

package/src/unseen-loads.ts

@@ -0,0 +1,145 @@
+/**
+ * The loads of a project's production files whose target the analysis cannot resolve: an
+ * `import()` or `require()` call whose path is computed and starts with no relative literal
+ * naming a directory below the calling file's. The files such a load runs are roots the
+ * analysis does not see, so the configuration's roots are never complete.
+ */
+
+import {
+  isAsExpression,
+  isBinaryExpression,
+  isCallExpression,
+  isIdentifier,
+  isNoSubstitutionTemplateLiteral,
+  isParenthesizedExpression,
+  isSatisfiesExpression,
+  isStringLiteral,
+  isTemplateExpression,
+  SyntaxKind,
+  type Node,
+} from "@typescript/native/ast";
+import { dirnamePath, relativePath, resolvePath } from "./paths.ts";
+import { renderPosition, type Position } from "./position.ts";
+import { UNANSWERED } from "./query.ts";
+import type { ProjectView } from "./session.ts";
+import { sourceFilesOf } from "./source-files.ts";
+
+/** One load the analysis cannot resolve, in the configuration whose production file writes it. */
+export interface UnseenLoad {
+  readonly configuration: string;
+  /** The position of the call. */
+  readonly position: Position;
+}
+
+/** The expression a wrapper that changes no value holds: parentheses and type assertions. */
+function unwrapped(node: Node): Node {
+  let at = node;
+  while (isParenthesizedExpression(at) || isAsExpression(at) || isSatisfiesExpression(at)) {
+    at = at.expression;
+  }
+  return at;
+}
+
+/** The literal text a computed path starts with: a template's head, or a concatenation's first literal. */
+export function leadingLiteral(node: Node): string | undefined {
+  const at = unwrapped(node);
+  if (isTemplateExpression(at)) {
+    return at.head.text;
+  }
+  if (isBinaryExpression(at) && at.operatorToken.kind === SyntaxKind.PlusToken) {
+    const left = unwrapped(at.left);
+    return isStringLiteral(left) || isNoSubstitutionTemplateLiteral(left)
+      ? left.text
+      : leadingLiteral(at.left);
+  }
+  return undefined;
+}
+
+/**
+ * The directory below `dir` a computed load's leading literal names, which the entry
+ * rules root every file of, or none where it names a package, `dir` itself or a
+ * directory holding it, each of which would name files no rule roots.
+ */
+export function computedLoadDirectory(dir: string, prefix: string): string | undefined {
+  if (!(prefix.startsWith("./") || prefix.startsWith("../")) || !prefix.endsWith("/")) {
+    return undefined;
+  }
+  const target = resolvePath(dir, prefix);
+  return target === dir || relativePath(target, dir) !== undefined ? undefined : target;
+}
+
+/** Whether a computed path's leading literal names a package, whose files are none of the target's. */
+function namesPackage(prefix: string | undefined): boolean {
+  return (
+    prefix !== undefined &&
+    prefix !== "" &&
+    !prefix.startsWith(".") &&
+    !prefix.startsWith("/") &&
+    !/^[A-Za-z][A-Za-z\d+.-]*:/u.test(prefix)
+  );
+}
+
+/**
+ * Every unresolved load the project's production files write, in file then source order.
+ * `testFiles` holds the test files by their path below the target root. A `require` call
+ * loads a module only where the name resolves to no declaration of the project's own
+ * files: one the project declares is its own function.
+ */
+export function unseenLoadsOf<Brand>(
+  project: ProjectView<Brand>,
+  configuration: string,
+  targetRoot: string,
+  testFiles: readonly string[],
+): readonly UnseenLoad[] {
+  const tests = new Set(testFiles);
+  const sites: { readonly position: Position; readonly require: Node | undefined }[] = [];
+  for (const [path, file] of sourceFilesOf(project, targetRoot).byPath) {
+    if (tests.has(path) || file.isDeclarationFile) {
+      continue;
+    }
+    const dir = dirnamePath(file.fileName);
+    const visit = (node: Node): void => {
+      if (isCallExpression(node)) {
+        const callee = node.expression;
+        const required = isIdentifier(callee) && callee.text === "require";
+        const [first] = node.arguments;
+        const argument = first === undefined ? undefined : unwrapped(first);
+        if (
+          (callee.kind === SyntaxKind.ImportKeyword || required) &&
+          argument !== undefined &&
+          !isStringLiteral(argument) &&
+          !isNoSubstitutionTemplateLiteral(argument)
+        ) {
+          const prefix = leadingLiteral(argument);
+          const seen =
+            namesPackage(prefix) ||
+            (prefix !== undefined && computedLoadDirectory(dir, prefix) !== undefined);
+          if (!seen) {
+            sites.push({
+              position: renderPosition(file, targetRoot, node.getStart()),
+              require: required ? callee : undefined,
+            });
+          }
+        }
+      }
+      node.forEachChild(visit);
+    };
+    file.forEachChild(visit);
+  }
+  const requires = sites.flatMap((site) => (site.require === undefined ? [] : [site.require]));
+  const own = project.ownPaths();
+  const local = new Set<Node>();
+  project.symbolsAt(requires.map((node) => project.handle(node))).forEach((symbol, at) => {
+    const node = requires[at];
+    if (
+      node !== undefined &&
+      symbol !== UNANSWERED &&
+      symbol?.declarations.some((handle) => own.has(handle.path)) === true
+    ) {
+      local.add(node);
+    }
+  });
+  return sites
+    .filter((site) => site.require === undefined || !local.has(site.require))
+    .map((site) => ({ configuration, position: site.position }));
+}

package/src/verbs/analyze.ts

@@ -10,7 +10,7 @@ import { ConfigError, kindOf, type Format } from "../config.ts";
 import { CONFORMANCE, DECLARED_GAPS } from "../conformance.ts";
 import { moduleIdentity } from "../consumers.ts";
 import { analyzerProvenance, verdictOf } from "../findings-pass.ts";
-import { joinPath, normalizePath, relativePath, resolvePath } from "../paths.ts";
+import { dirnamePath, joinPath, normalizePath, relativePath, resolvePath } from "../paths.ts";
 import type { Host } from "../host.ts";
 import type { ManifestEntry } from "../manifest.ts";
 import type { NotBuilt } from "../discover.ts";
@@ -30,6 +30,7 @@ import { RENDERINGS } from "../reporters/reporters.ts";
 import { parseTemplate, TemplateError, type Template } from "../reporters/template.ts";
 import { resolve } from "../resolve.ts";
 import { otherSchemeRows, rowReason, writeBaseline, type Recorded } from "../suppress-file.ts";
+import type { UnseenLoad } from "../unseen-loads.ts";
 import { CONTRACT_VERSION } from "../version.ts";
 import { EXIT_CLEAN, EXIT_FAILURE, type Verb, type VerbOptions } from "./verb.ts";
 
@@ -113,6 +114,27 @@ function unmappedNotes(
   });
 }
 
+/**
+ * One note per load of a production file the run cannot resolve, each site once: a file
+ * it loads is a root the run does not see, so `ts.roots_complete` lifts no cap there.
+ */
+function unseenLoadNotes(loads: readonly UnseenLoad[]): readonly ReportNote[] {
+  return [
+    ...new Map(
+      loads.map((load) => {
+        const { path, line, column } = load.position;
+        const site = `${path}:${String(line)}:${String(column)}`;
+        const note: ReportNote = {
+          kind: "computed-load",
+          path: dirnamePath(path),
+          message: `${site} loads a module by a computed path the analysis cannot resolve, so the configurations compiling it report what no root reaches at probable at most, whatever ts.roots_complete says`,
+        };
+        return [site, note] as const;
+      }),
+    ).values(),
+  ];
+}
+
 /** Each project the run dropped as a report names it, by its configuration file below the target. */
 function notBuiltOf(dropped: readonly NotBuilt[], targetRoot: string): readonly ReportNotBuilt[] {
   return dropped.map((one) => {
@@ -309,7 +331,11 @@ export const analyzeVerb: Verb = ({ err, host, inputs, scope, openClient, option
       typeErrorSkips: run.typeErrorSkips,
       unanswered: unansweredCounts(analysis),
       conventionsApplied: run.conventionsApplied,
-      notes: unmappedNotes(run.unmappedEntries, resolvePath(invoked, targetRoot)),
+      listsComponents: config.reporters.cascade === "full",
+      notes: [
+        ...unmappedNotes(run.unmappedEntries, resolvePath(invoked, targetRoot)),
+        ...unseenLoadNotes(run.unseenLoads),
+      ],
     });
     report = capFindings(sortFindings(built, config.reporters.sort), config.reporters.maxFindings);
     verdict = verdictOf(result, config);