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

package/src/type-errors.ts

@@ -1,41 +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,
-  isNoSubstitutionTemplateLiteral,
+  isFunctionLikeDeclaration,
   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";
-
-/** 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 {
@@ -57,205 +38,34 @@ 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;
-}
-
-/** 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;
+/**
+ * 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.
+ */
+function unitAt(file: SourceFile, offset: number): Node | undefined {
+  const statement = file.statements.find((one) => one.pos <= offset && offset < one.end);
+  if (statement === undefined) {
+    return undefined;
+  }
+  let innermost: Node | undefined;
   const visit = (node: Node): void => {
-    if (offset < node.pos || offset >= node.end) {
+    if (offset < node.getStart() || 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);
+    if (isFunctionLikeDeclaration(node)) {
+      innermost = node;
     }
     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);
-  if (manifest === undefined) {
-    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 class member holding it where a
- * top-level class does, else the top-level statement.
- */
-function unitAt(file: SourceFile, offset: number): Node | undefined {
-  const statement = file.statements.find((one) => one.pos <= offset && offset < one.end);
-  if (statement === undefined || !isClassDeclaration(statement)) {
-    return statement;
+  visit(statement);
+  if (innermost !== undefined || !isClassDeclaration(statement)) {
+    return innermost ?? statement;
   }
   return statement.members.find((one) => one.pos <= offset && offset < one.end) ?? statement;
 }
@@ -266,48 +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[],
-  context: ErrorContext,
-): ProjectErrorReading {
-  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. */
@@ -379,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/type-parameter-reads.ts

@@ -0,0 +1,227 @@
+/**
+ * The members a read through a value typed by a type parameter reaches: `value.kind`,
+ * where `value` is of a type parameter `T` of a generic function, reads `kind` on each
+ * object type no class declares that a call of the function passes for `T`, because the
+ * call's value is what the read reads, whatever member of the constraint the name resolves
+ * to. A class's members a constraint requires are interface satisfaction's.
+ */
+
+import {
+  isBinaryExpression,
+  isCallExpression,
+  isIdentifier,
+  isNewExpression,
+  isPropertyAccessExpression,
+  isTypeParameterDeclaration,
+  SyntaxKind,
+  type CallExpression,
+  type NewExpression,
+  type Node,
+  type PropertyAccessExpression,
+  type SourceFile,
+} from "@typescript/native/ast";
+import { SymbolFlags, type Type } from "@typescript/native/sync";
+import type { AliasChains } from "./alias-chain.ts";
+import { nodeKey, type Inventory } from "./inventory.ts";
+import { renderPosition } from "./position.ts";
+import { isAnswered } from "./query.ts";
+import type { Reference } from "./references.ts";
+import type { ProjectView } from "./session.ts";
+
+/** How deep a parameter's type is matched against the type a call passes: `readonly T[]` is one level. */
+const MATCH_DEPTH = 3;
+
+/** One read of a member through a value whose type is a type parameter. */
+interface Read {
+  readonly file: SourceFile;
+  readonly from: string;
+  readonly access: PropertyAccessExpression;
+}
+
+/** A node that declares parameters, as a generic function does. */
+type Generic = Node & {
+  readonly parameters?: readonly Node[];
+};
+
+/** The name a call reaches one generic by: its own, or that of what holds it. */
+function nameOf(generic: Generic): string | undefined {
+  const own = (generic as { readonly name?: Node }).name;
+  const holder = (generic.parent as { readonly name?: Node } | undefined)?.name;
+  const name = own ?? holder;
+  return name !== undefined && isIdentifier(name) ? name.text : undefined;
+}
+
+/** Whether a property access is the target of a plain assignment, which writes the member. */
+function assignedTo(access: PropertyAccessExpression): boolean {
+  const parent = access.parent;
+  return (
+    isBinaryExpression(parent) &&
+    parent.operatorToken.kind === SyntaxKind.EqualsToken &&
+    parent.left === access
+  );
+}
+
+/**
+ * The references the reads through type-parameter-typed values of one project's own files
+ * make to the members of the types its calls pass, each made by the declaration holding
+ * the read.
+ */
+export function typeParameterReads<Brand>(
+  project: ProjectView<Brand>,
+  held: Inventory,
+  chains: AliasChains,
+  root: string,
+  testFiles: ReadonlySet<string>,
+): readonly Reference[] {
+  const queries = project.queries;
+  const reads: Read[] = [];
+  const calls: (CallExpression | NewExpression)[] = [];
+  for (const file of project.ownSourceFiles()) {
+    const fileId = held.declarations.get(nodeKey(file, file));
+    if (fileId === undefined) {
+      continue;
+    }
+    const visit = (node: Node, from: string, generic: boolean): void => {
+      const holder = held.declarations.get(nodeKey(file, node)) ?? from;
+      const inside =
+        generic ||
+        (node as { readonly typeParameters?: readonly Node[] }).typeParameters !== undefined;
+      if (
+        inside &&
+        isPropertyAccessExpression(node) &&
+        isIdentifier(node.name) &&
+        !assignedTo(node)
+      ) {
+        reads.push({ file, from: holder, access: node });
+      }
+      if (isCallExpression(node) || isNewExpression(node)) {
+        calls.push(node);
+      }
+      node.forEachChild((child) => {
+        visit(child, holder, inside);
+      });
+    };
+    file.forEachChild((child) => {
+      visit(child, fileId, false);
+    });
+  }
+  if (reads.length === 0) {
+    return [];
+  }
+
+  // The reads whose receiver the checker types as a type parameter, by the generic declaring it.
+  const receivers = queries.typesAt(reads.map((read) => read.access.expression));
+  const byGeneric = new Map<Generic, { read: Read; parameter: Type }[]>();
+  reads.forEach((read, at) => {
+    const type = receivers[at];
+    if (type === undefined || !isAnswered(type) || !type.isTypeParameter()) {
+      return;
+    }
+    const symbol = queries.symbolOfType(type);
+    const declaration =
+      symbol === undefined || !isAnswered(symbol)
+        ? undefined
+        : symbol.declarations
+            .map((handle) => project.declarationAt(handle)?.node)
+            .find((node) => node !== undefined && isTypeParameterDeclaration(node));
+    const generic = declaration?.parent as Generic | undefined;
+    if (generic !== undefined) {
+      byGeneric.set(generic, [...(byGeneric.get(generic) ?? []), { read, parameter: type }]);
+    }
+  });
+  if (byGeneric.size === 0) {
+    return [];
+  }
+
+  /** The types `instantiated` holds where `declared` holds `parameter`, matched part for part. */
+  const passedFor = (
+    parameter: Type,
+    declared: Type,
+    instantiated: Type,
+    depth: number,
+  ): readonly Type[] => {
+    if (declared.id === parameter.id) {
+      return [instantiated];
+    }
+    if (depth >= MATCH_DEPTH) {
+      return [];
+    }
+    const a = queries.typeArguments(declared);
+    const b = queries.typeArguments(instantiated);
+    if (!isAnswered(a) || !isAnswered(b) || a.length !== b.length) {
+      return [];
+    }
+    return a.flatMap((one, at) => {
+      const other = b[at];
+      return other === undefined ? [] : passedFor(parameter, one, other, depth + 1);
+    });
+  };
+
+  // Only a call spelling a generic's name is resolved: one request each.
+  const spelled = new Set([...byGeneric.keys()].flatMap((generic) => nameOf(generic) ?? []));
+  const found = new Map<string, Reference>();
+  for (const call of calls) {
+    const callee = call.expression;
+    const written = isIdentifier(callee)
+      ? callee.text
+      : isPropertyAccessExpression(callee) && isIdentifier(callee.name)
+        ? callee.name.text
+        : undefined;
+    if (written === undefined || !spelled.has(written)) {
+      continue;
+    }
+    const resolved = queries.resolvedSignature(call);
+    if (resolved === undefined || !isAnswered(resolved) || resolved.declaration === undefined) {
+      continue;
+    }
+    const generic = project.declarationAt(resolved.declaration)?.node as Generic | undefined;
+    const pending = generic === undefined ? undefined : byGeneric.get(generic);
+    const declared = pending === undefined ? undefined : queries.genericOf(resolved);
+    if (pending === undefined || declared === undefined || !isAnswered(declared)) {
+      continue;
+    }
+    const count = (generic?.parameters ?? []).length;
+    for (const { read, parameter } of pending) {
+      const passed: Type[] = [];
+      for (let at = 0; at < count; at += 1) {
+        const own = queries.parameterType(declared, at);
+        const given = queries.typeAtPosition(resolved, at);
+        if (own !== undefined && isAnswered(own) && isAnswered(given)) {
+          passed.push(...passedFor(parameter, own, given, 0));
+        }
+      }
+      const name = read.access.name.text;
+      const position = renderPosition(read.file, root, read.access.name.getStart());
+      for (const type of passed) {
+        const parts = type.isUnionType() ? queries.constituents(type) : [type];
+        for (const part of isAnswered(parts) ? parts : []) {
+          const owner = queries.symbolOfType(part);
+          if (
+            !isAnswered(owner) ||
+            owner === undefined ||
+            (owner.flags & SymbolFlags.Class) !== 0
+          ) {
+            continue;
+          }
+          const properties = queries.propertiesOf(part);
+          for (const property of isAnswered(properties) ? properties : []) {
+            if (property.name !== name) {
+              continue;
+            }
+            for (const to of chains.declarationsOf(property)) {
+              found.set(`${read.from}\u0000${to}\u0000${String(read.access.name.pos)}`, {
+                from: read.from,
+                to,
+                position,
+                use: "read",
+                resolution: "batch",
+                test: testFiles.has(position.path),
+              });
+            }
+          }
+        }
+      }
+    }
+  }
+  return [...found.values()];
+}