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

package/src/type-errors.ts

@@ -1,43 +1,22 @@
 /**
- * What the errors a project's own files carry do to the run. An import of a module the
- * project expects and nothing provides is a setup failure. Any other error in an own file
- * is a type error: the function, method or file-level statement holding it is skipped,
- * which only ever withholds a finding. `projectErrors` decides, before any of these, which
- * errors the compiler places in no file leave the project unloaded.
+ * What a type error in a project's own file does: the function, method or file-level statement
+ * holding it is skipped, which only ever withholds a finding.
  */
 
 import {
   isClassDeclaration,
   isFunctionLikeDeclaration,
-  isNoSubstitutionTemplateLiteral,
   isPropertyAccessExpression,
-  isStringLiteral,
   type Node,
   type PropertyAccessExpression,
   type SourceFile,
 } from "@typescript/native/ast";
 import type { Symbol as TSSymbol, Type } from "@typescript/native/sync";
-import { packageOfSpecifier } from "./dependencies.ts";
-import type { LocatedDiagnostic } from "./discover.ts";
-import type { Host } from "./host.ts";
 import { nodeKey, type Inventory } from "./inventory.ts";
-import { dirnamePath, isAbsolutePath, joinPath, relativePath, resolvePath } from "./paths.ts";
+import { relativePath } from "./paths.ts";
 import { isAnswered } from "./query.ts";
 import type { TypeErrorSkip } from "./report.ts";
-import type { Engine, ProjectView } from "./session.ts";
-import type { SetupFailure } from "./setup-failure.ts";
-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]);
-
-const MANIFEST = "package.json";
-const MANIFEST_SECTIONS = [
-  "dependencies",
-  "devDependencies",
-  "peerDependencies",
-  "optionalDependencies",
-] as const;
+import type { ProjectView } from "./session.ts";
 
 /** The lines of one file a skip withholds every finding on. */
 export interface SkippedUnit {
@@ -59,203 +38,12 @@ export function insideSkipped(
 }
 
 /** One type error of an own file, with the unit it skips. */
-interface Skip {
+export interface Skip {
   readonly record: TypeErrorSkip;
   readonly file: SourceFile;
   readonly unit: Node;
 }
 
-/** What the errors of one project's own files are. */
-interface ProjectErrorReading {
-  /** The imports of a module the project expects that nothing provides, one failure each. */
-  readonly missing: readonly SetupFailure[];
-  /** The type errors, each with the unit it skips. */
-  readonly skips: readonly Skip[];
-}
-
-/** Where one project reads what its imports may name. */
-interface ErrorContext {
-  readonly host: Host;
-  /** The target root, absolute. */
-  readonly targetRoot: string;
-  /** The project configuration's `paths` mapping. */
-  readonly paths: PathsMapping;
-  /** Whether one manifest is a workspace member's, whose dependencies the workspace installs. */
-  readonly member: (manifest: string) => boolean;
-}
-
-/** One configuration's `paths` mapping, its targets read against `base`. */
-interface PathsMapping {
-  readonly base: string;
-  readonly entries: readonly { readonly key: string; readonly targets: readonly string[] }[];
-}
-
-/** The string literal holding one offset, innermost first, a doc comment's included. */
-function literalAt(file: SourceFile, offset: number): string | undefined {
-  let found: string | undefined;
-  const visit = (node: Node): void => {
-    if (offset < node.pos || offset >= node.end) {
-      return;
-    }
-    if (isStringLiteral(node) || isNoSubstitutionTemplateLiteral(node)) {
-      found = node.text;
-    }
-    // `forEachChild` does not enter a doc comment, where a JavaScript file imports types.
-    for (const doc of (node as { readonly jsDoc?: readonly Node[] }).jsDoc ?? []) {
-      visit(doc);
-    }
-    node.forEachChild(visit);
-  };
-  file.forEachChild(visit);
-  return found;
-}
-
-/**
- * What one `paths` key's `*` matches in one specifier, `""` for a key with no `*` that
- * is the specifier, or `undefined` where the key does not match it.
- */
-function mappedBy(key: string, specifier: string): string | undefined {
-  const star = key.indexOf("*");
-  if (star < 0) {
-    return key === specifier ? "" : undefined;
-  }
-  const prefix = key.slice(0, star);
-  const suffix = key.slice(star + 1);
-  return specifier.length >= prefix.length + suffix.length &&
-    specifier.startsWith(prefix) &&
-    specifier.endsWith(suffix)
-    ? specifier.slice(prefix.length, specifier.length - suffix.length)
-    : undefined;
-}
-
-/**
- * One `paths` target, its first `*` replaced by `star` taken literally, as the compiler does:
- * https://github.com/microsoft/typescript-go/blob/89d5d5b2849a0db0957065889ca58536fa6d2e4a/internal/module/resolver.go#L1282
- */
-function substituted(target: string, star: string): string {
-  const at = target.indexOf("*");
-  return at < 0 ? target : target.slice(0, at) + star + target.slice(at + 1);
-}
-
-/**
- * Whether a path names something on disk, as written or with any extension; under
- * `fileOnly`, only a file counts.
- */
-function provided(host: Host, path: string, fileOnly: boolean): boolean {
-  const counts = (at: string): boolean =>
-    fileOnly ? host.kindOf(at) === "file" : host.kindOf(at) !== "absent";
-  if (counts(path)) {
-    return true;
-  }
-  const dir = dirnamePath(path);
-  const stem = `${path.slice(dir.length + 1)}.`;
-  try {
-    return host
-      .readDirectory(dir)
-      .some((entry) => entry.name.startsWith(stem) && counts(joinPath(dir, entry.name)));
-  } catch {
-    return false;
-  }
-}
-
-/** The manifest at or above `dir`, no higher than the target root, that declares `name`. */
-function declaringManifest(
-  host: Host,
-  dir: string,
-  targetRoot: string,
-  name: string,
-): string | undefined {
-  for (let at = dir; ; at = dirnamePath(at)) {
-    const path = joinPath(at, MANIFEST);
-    let manifest: unknown;
-    try {
-      manifest = JSON.parse(host.readFile(path)) as unknown;
-    } catch {
-      manifest = undefined;
-    }
-    if (typeof manifest === "object" && manifest !== null) {
-      const sections = manifest as Record<string, unknown>;
-      for (const section of MANIFEST_SECTIONS) {
-        const declared = sections[section];
-        if (typeof declared === "object" && declared !== null && Object.hasOwn(declared, name)) {
-          return path;
-        }
-      }
-    }
-    // The target root is not below itself, so the walk stops after reading its manifest.
-    if (relativePath(targetRoot, at) === undefined) {
-      return undefined;
-    }
-  }
-}
-
-/**
- * Whether a package is installed for an importer in `dir`: in the `node_modules` of
- * `dir` or of any ancestor, above the target root too, as Node and the compiler look.
- */
-function installed(host: Host, dir: string, name: string): boolean {
-  for (let at = dir; ; at = dirnamePath(at)) {
-    if (host.kindOf(joinPath(at, "node_modules", name)) === "directory") {
-      return true;
-    }
-    if (dirnamePath(at) === at) {
-      return false;
-    }
-  }
-}
-
-/**
- * Why one import that the compiler cannot resolve names a module the project expects,
- * with the fix, or undefined where the module is one the project does not expect.
- */
-function expectedModule(
-  context: ErrorContext,
-  importer: string,
-  specifier: string,
-): string | undefined {
-  const { host, targetRoot } = context;
-  const fix = "run the generator or the build that writes it";
-  if (specifier.startsWith(".") || isAbsolutePath(specifier)) {
-    return provided(host, resolvePath(dirnamePath(importer), specifier), false)
-      ? undefined
-      : `which names no file of the target: ${fix}`;
-  }
-  if (specifier.startsWith("#")) {
-    return `which the manifest's imports map to no file: ${fix}`;
-  }
-  const mapped = context.paths.entries.flatMap(({ key, targets }) => {
-    const star = mappedBy(key, specifier);
-    return star === undefined
-      ? []
-      : targets.map((target) => resolvePath(context.paths.base, substituted(target, star)));
-  });
-  const name = packageOfSpecifier(specifier);
-  // The compiler looks up in `node_modules` what `paths` does not resolve, so the error
-  // of an installed package's import is the import's own, a subpath its exports omit:
-  // https://github.com/microsoft/typescript-go/blob/89d5d5b2849a0db0957065889ca58536fa6d2e4a/internal/module/resolver.go#L548-L575
-  if (name !== undefined && installed(host, dirnamePath(importer), name)) {
-    return undefined;
-  }
-  if (mapped.length > 0) {
-    return mapped.some((path) => provided(host, path, true))
-      ? undefined
-      : `which the compiler configuration's paths map to no file: ${fix}`;
-  }
-  const manifest =
-    name === undefined
-      ? undefined
-      : declaringManifest(host, dirnamePath(importer), targetRoot, name);
-  // No run requires a nested package that is no workspace member to be installed.
-  if (
-    manifest === undefined ||
-    (dirnamePath(manifest) !== targetRoot && !context.member(manifest))
-  ) {
-    return undefined;
-  }
-  const where = relativePath(targetRoot, manifest) ?? manifest;
-  return `a dependency ${where} declares that is not installed: run the package manager's install`;
-}
-
 /**
  * The unit a type error at one offset skips: the innermost function holding it, else the
  * class member holding it where a top-level class does, else the top-level statement.
@@ -288,58 +76,19 @@ function messageOf(text: string, targetRoot: string): string {
   return line === "" ? "a type error" : line;
 }
 
-/**
- * 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.
- */
-export function readErrors<Brand>(
-  project: ProjectView<Brand>,
-  errors: readonly LocatedDiagnostic[],
-  where: Omit<ErrorContext, "member">,
-): ProjectErrorReading {
-  let workspace: Workspace | undefined | null = null;
-  const context: ErrorContext = {
-    ...where,
-    member: (manifest) => {
-      if (workspace === null) {
-        workspace = findWorkspace(where.host, where.targetRoot, () => undefined);
-      }
-      return workspace?.memberOf(manifest) !== undefined;
-    },
-  };
-  const files = new Map(project.ownSourceFiles().map((file) => [file.fileName, file]));
-  const missing: SetupFailure[] = [];
-  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) {
-      continue;
-    }
-    const path = relativePath(context.targetRoot, file.fileName) ?? file.fileName;
-    const line = at?.line ?? 1;
-    const specifier = MODULE_NOT_FOUND.has(diagnostic.code)
-      ? literalAt(file, diagnostic.pos)
-      : undefined;
-    const expected =
-      specifier === undefined ? undefined : expectedModule(context, file.fileName, specifier);
-    if (specifier !== undefined && expected !== undefined) {
-      missing.push({
-        setupClass: "missing-module",
-        detail: `${path}:${String(line)}: ${path} imports ${JSON.stringify(specifier)}, ${expected}`,
-      });
-      continue;
-    }
-    const unit = unitAt(file, diagnostic.pos);
-    if (unit !== undefined) {
-      skips.push({
-        record: { path, line, message: messageOf(diagnostic.text, context.targetRoot) },
-        file,
-        unit,
-      });
-    }
-  }
-  return { missing, skips };
+/** The skip one type error at `offset` of an own file makes, the root spelled relative to itself. */
+export function skipAt(
+  file: SourceFile,
+  offset: number,
+  line: number,
+  text: string,
+  targetRoot: string,
+): Skip | undefined {
+  const unit = unitAt(file, offset);
+  const path = relativePath(targetRoot, file.fileName) ?? file.fileName;
+  return unit === undefined
+    ? undefined
+    : { record: { path, line, message: messageOf(text, targetRoot) }, file, unit };
 }
 
 /** The lines each skip withholds, below the target root. */
@@ -411,22 +160,3 @@ export function skippedRoots<Brand>(
   }
   return [...kept];
 }
-
-/** One compiler configuration's `paths` mapping, empty where it cannot be read. */
-export function pathsOf(engine: Engine, configFile: string): PathsMapping {
-  const base = dirnamePath(configFile);
-  try {
-    const { options } = engine.parseConfigFile(configFile);
-    const { paths } = options;
-    // The parse answers `pathsBasePath`, the directory of the configuration that writes
-    // `paths` (an extended one included), though the client's option type omits it:
-    // https://github.com/microsoft/typescript-go/blob/89d5d5b2849a0db0957065889ca58536fa6d2e4a/internal/tsoptions/tsconfigparsing.go#L1120
-    const declaredAt = (options as { readonly pathsBasePath?: unknown }).pathsBasePath;
-    return {
-      base: typeof declaredAt === "string" ? declaredAt : base,
-      entries: Object.entries(paths ?? {}).map(([key, targets]) => ({ key, targets })),
-    };
-  } catch {
-    return { base, entries: [] };
-  }
-}

package/src/unseen-loads.ts

@@ -0,0 +1,134 @@
+/**
+ * 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 {
+  isBinaryExpression,
+  isCallExpression,
+  isIdentifier,
+  isNoSubstitutionTemplateLiteral,
+  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";
+import { unwrapped } from "./unwrap.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 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/unwrap.ts

@@ -0,0 +1,34 @@
+import {
+  isAsExpression,
+  isNonNullExpression,
+  isParenthesizedExpression,
+  isSatisfiesExpression,
+  type Expression,
+  type Node,
+} from "@typescript/native/ast";
+
+/** The expression inside every pair of parentheses around `node`. */
+export function parenthesesRemoved<T extends Node>(node: T): T | Expression {
+  let at: T | Expression = node;
+  while (isParenthesizedExpression(at)) {
+    at = at.expression;
+  }
+  return at;
+}
+
+/**
+ * The expression inside every wrapper around `node` that changes no value it evaluates to:
+ * parentheses, `as` and `satisfies` assertions and the non-null assertion.
+ */
+export function unwrapped<T extends Node>(node: T): T | Expression {
+  let at: T | Expression = node;
+  while (
+    isParenthesizedExpression(at) ||
+    isAsExpression(at) ||
+    isSatisfiesExpression(at) ||
+    isNonNullExpression(at)
+  ) {
+    at = at.expression;
+  }
+  return at;
+}

package/src/usage.ts

@@ -0,0 +1,10 @@
+/**
+ * A refusal of the invocation: the fix is to the command line or to a document it
+ * names, so the run ends with the usage code before any analysis.
+ */
+export class UsageError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "UsageError";
+  }
+}