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

package/src/suppress-inline.ts

@@ -10,8 +10,10 @@ import {
   type Node,
   type SourceFile,
 } from "@typescript/native/ast";
+import { importBindings } from "./import-bindings.ts";
 import { isParameterProperty, nodeKey, type Inventory } from "./inventory.ts";
 import { byPosition, positionKey, renderPosition, type Position } from "./position.ts";
+import { importRef } from "./ref.ts";
 import type { ProjectView } from "./session.ts";
 import { signatureOf } from "./signatures.ts";
 import {
@@ -200,6 +202,7 @@ function declarationLines(
   file: SourceFile,
   held: Inventory,
   symbols: ReadonlyMap<string, Declared>,
+  targetRoot: string,
 ): ReadonlyMap<number, readonly Binding[]> {
   const below = new Map<number, Binding[]>();
   const add = (offset: number, one: Binding): void => {
@@ -245,6 +248,20 @@ function declarationLines(
     node.forEachChild(visit);
   };
   file.forEachChild(visit);
+  // An import binding is a subject of its own, bound on its line as a declaration is.
+  const fileId = held.declarations.get(nodeKey(file, file));
+  const moduleRef = held.symbols.find((symbol) => symbol.id === fileId)?.ref ?? "";
+  for (const name of moduleRef === "" ? [] : importBindings(file)) {
+    const position = renderPosition(file, targetRoot, name.getStart());
+    const one = { id: positionKey(position), ref: importRef(moduleRef, name.text), position };
+    let statement: Node = name;
+    while (statement.parent.kind !== SyntaxKind.SourceFile) {
+      statement = statement.parent;
+    }
+    for (const at of [statement.pos, name.getStart()]) {
+      add(at, { declared: one, part: one });
+    }
+  }
   return below;
 }
 
@@ -285,7 +302,7 @@ export function inlineDirectives<Brand>(
     if (comments.length === 0) {
       continue;
     }
-    const below = declarationLines(file, held, symbols);
+    const below = declarationLines(file, held, symbols, targetRoot);
     for (const comment of comments) {
       const site = renderPosition(file, targetRoot, comment.offset);
       const target = trails(file, comment.offset) ? site.line : site.line + 1;

package/src/suppress.ts

@@ -115,6 +115,7 @@ export const GO_REF_EXPRESSIONS: readonly string[] = [
   `^go://${GO_PATH}#${GO_IDENT}$`,
   `^go://${GO_PATH}#${GO_IDENT}(?:\\.${GO_IDENT})+$`,
   `^go://${GO_PATH}#${GO_IDENT}(?:\\.${GO_IDENT})?\\[${GO_IDENT}\\]$`,
+  `^go://${GO_PATH}#(?:${GO_IDENT}(?:\\.${GO_IDENT})?)?\\(${GO_IDENT}\\)$`,
   `^go://${GO_PATH}#${GO_FILE}:file$`,
   `^go://${GO_PATH}#${GO_PATH}(?:@${GO_VERSION})?:require$`,
   `^go://${GO_PATH}#${GO_PATH}(?:@${GO_VERSION})?:replace$`,
@@ -243,10 +244,11 @@ function claimKey(finding: Finding): string {
 
 /**
  * Whether one record names one finding. A record reaches a finding in two ways: it bound
- * the declaration at the finding's position, or it names the finding's reference and the
- * file the finding is reported in, each exactly. The second is how an entry copied from a
- * finding about a part of a declaration reaches the part, and the only way any record
- * reaches a dependency row.
+ * the declaration at the finding's position, or it names the finding's reference, or the
+ * reference of the declaration holding a part that has one of its own, and the file the
+ * finding is reported in, each exactly. The second is how an entry copied from a finding
+ * about a part of a declaration reaches the part, and the only way any record reaches a
+ * dependency row.
  */
 export function pairs(record: SuppressionRecord, finding: Finding): boolean {
   if (record.code !== finding.code) {
@@ -265,7 +267,10 @@ export function pairs(record: SuppressionRecord, finding: Finding): boolean {
   if (record.bound !== "" && record.bound === positionKey(finding.position)) {
     return true;
   }
-  return record.symbol === finding.symbol.ref && record.path === finding.position.path;
+  return (
+    (record.symbol === finding.symbol.ref || record.symbol === finding.symbol.holder) &&
+    record.path === finding.position.path
+  );
 }
 
 /**

package/src/sweep.ts

@@ -8,6 +8,7 @@
 
 import type { TSExemptionClass } from "./exempt-classes.ts";
 import { namesACaller, OUTSIDE, type Edge, type Graph } from "./graph.ts";
+import type { InventorySymbol } from "./inventory.ts";
 import type { Position } from "./position.ts";
 
 /** The liveness relation that decided a declaration, as a finding spells it. */
@@ -178,17 +179,32 @@ export function sweep(graph: Graph, input: SweepInput): Liveness {
   return { liveUnder: live, candidates };
 }
 
+/**
+ * The directory a test runner reads a manual mock from, whose exports it puts in place of
+ * the module's: https://jestjs.io/docs/manual-mocks
+ */
+const MANUAL_MOCKS = "__mocks__";
+
+/** Whether a test runner calls or reads one export of a test file: a function, or any export of a manual mock. */
+export function runnerCalls(symbol: InventorySymbol): boolean {
+  return symbol.kind === "function" || symbol.position.path.split("/").includes(MANUAL_MOCKS);
+}
+
 /**
  * Per declaration of the graph, whether the run that counts test references reaches it.
- * That run's roots are the graph's own and each test file, being the file's top level
- * and every declaration it exports, which a test runner may call; `held` seeds it as a
- * mark or an exemption seeds a sweep.
+ * That run's roots are the graph's own and, of each test file, its top level and every
+ * function it exports, which a test runner may call, and every export of a manual mock,
+ * which the runner reads; any other export of a test file, and test-support code, which
+ * runs where a test imports it, are judged as any file's are.
+ * `held` seeds it as a mark or an exemption seeds a sweep.
  */
 export function reachedWithTheTests(graph: Graph, held: readonly string[]): readonly boolean[] {
   const tests = graph.symbols.flatMap((symbol, at) => {
-    const top =
-      symbol.kind === "file" || graph.symbols[graph.parent[at] ?? OUTSIDE]?.kind === "file";
-    return graph.test[at] === true && top && (symbol.kind === "file" || symbol.exported)
+    const exported = symbol.exported && graph.symbols[graph.parent[at] ?? OUTSIDE]?.kind === "file";
+    const called = exported && runnerCalls(symbol);
+    return graph.test[at] === true &&
+      graph.support[at] !== true &&
+      (symbol.kind === "file" || called)
       ? [{ at, kind: "test-runner" as const }]
       : [];
   });
@@ -277,10 +293,11 @@ function reachable(graph: Graph, held: readonly boolean[], mode: Mode): readonly
 
 /**
  * Admits every test declaration whose set of referenced production declarations is
- * non-empty and wholly dead, and returns which it admitted. The set is read from every
- * reference the test makes, which a production sweep does not count. A test-support
- * declaration that a test referencing a live target also references is a live target of
- * every test referencing it. A marked or exempt test is never admitted.
+ * non-empty and wholly dead, and returns which it admitted. An ambient declaration describes
+ * code the target does not implement, so it is no production declaration here. The set is
+ * read from every reference the test makes, which a production sweep does not count. A
+ * test-support declaration a test referencing a live target also references is a live
+ * target of every test referencing it. A marked or exempt test is never admitted.
  */
 function admitTestsOfDeadCode(
   graph: Graph,
@@ -293,7 +310,11 @@ function admitTestsOfDeadCode(
     let live = 0;
     if (testCode(at) && graph.subject[at] === true && held[at] !== true) {
       for (const edge of graph.out[at] ?? []) {
-        if (testCode(edge.to) || graph.subject[edge.to] !== true) {
+        if (
+          testCode(edge.to) ||
+          graph.subject[edge.to] !== true ||
+          graph.ambient[edge.to] === true
+        ) {
           continue;
         }
         targets += 1;

package/src/symbol-keys.ts

@@ -2,24 +2,31 @@
  * The members a unique symbol keys, used through element accesses. `value[key]`, where
  * `key` is a constant of a `unique symbol` type, reads the member of the receiver's type
  * whose computed name is that same constant, and a store through the access writes it.
- * No name node resolves to such a member: the key's name resolves to the constant.
+ * No name node resolves to such a member: the key's name resolves to the constant. An
+ * iteration reads the member its well-known iteration symbol keys.
  */
 
 import {
   isComputedPropertyName,
+  isForOfStatement,
   isIdentifier,
   isNoSubstitutionTemplateLiteral,
   isNumericLiteral,
   isParenthesizedExpression,
   isPropertyAccessExpression,
+  isSpreadElement,
   isStringLiteral,
   type ElementAccessExpression,
+  type Expression,
   type Node,
+  type SourceFile,
 } from "@typescript/native/ast";
 import type { Symbol as TSSymbol, Type } from "@typescript/native/sync";
 import type { AliasChains } from "./alias-chain.ts";
-import type { InventorySymbol } from "./inventory.ts";
+import { nodeKey, type Inventory, type InventorySymbol } from "./inventory.ts";
+import { renderPosition } from "./position.ts";
 import { isAnswered, type PropertyTables } from "./query.ts";
+import type { Reference } from "./references.ts";
 import type { ProjectView } from "./session.ts";
 
 /** One element access whose key is a name, and how the access uses the member it selects. */
@@ -170,3 +177,123 @@ export function keyedUses<Brand>(
     return ids.length === 0 ? [] : [{ access: one.access, ids: [...new Set(ids)] }];
   });
 }
+
+/** The well-known symbol a value's iteration calls, by the construct that iterates it. */
+type Protocol = "iterator" | "asyncIterator";
+
+/** The member name `[Symbol.<name>]` spells, where a computed name spells one. */
+function wellKnownName(name: Node | undefined): string | undefined {
+  if (name === undefined || !isComputedPropertyName(name)) {
+    return undefined;
+  }
+  const key = name.expression;
+  return isPropertyAccessExpression(key) &&
+    isIdentifier(key.expression) &&
+    key.expression.text === "Symbol" &&
+    isIdentifier(key.name)
+    ? key.name.text
+    : undefined;
+}
+
+/**
+ * The references the iterations of one project's own files make to the iteration members
+ * of the values they iterate: a `for…of` statement and a spread element read
+ * `[Symbol.iterator]`, and a `for await…of` statement reads `[Symbol.asyncIterator]` and,
+ * which it falls back to, `[Symbol.iterator]`. Each is made by the declaration holding it.
+ */
+export function iterationReferences<Brand>(
+  project: ProjectView<Brand>,
+  held: Inventory,
+  chains: AliasChains,
+  root: string,
+  testFiles: ReadonlySet<string>,
+): readonly Reference[] {
+  const queries = project.queries;
+  const ownPaths = project.ownPaths();
+  const iterated: {
+    readonly file: SourceFile;
+    readonly from: string;
+    readonly operand: Expression;
+    readonly protocols: readonly Protocol[];
+  }[] = [];
+  for (const file of project.ownSourceFiles()) {
+    const fileId = held.declarations.get(nodeKey(file, file));
+    if (fileId === undefined) {
+      continue;
+    }
+    const visit = (node: Node, from: string): void => {
+      const holder = held.declarations.get(nodeKey(file, node)) ?? from;
+      if (isForOfStatement(node)) {
+        const protocols: readonly Protocol[] =
+          node.awaitModifier === undefined ? ["iterator"] : ["asyncIterator", "iterator"];
+        iterated.push({ file, from: holder, operand: node.expression, protocols });
+      } else if (isSpreadElement(node)) {
+        iterated.push({ file, from: holder, operand: node.expression, protocols: ["iterator"] });
+      }
+      node.forEachChild((child) => {
+        visit(child, holder);
+      });
+    };
+    file.forEachChild((child) => {
+      visit(child, fileId);
+    });
+  }
+  if (iterated.length === 0) {
+    return [];
+  }
+  const types = queries.typesAt(iterated.map((one) => one.operand));
+  const members = new Map<
+    number,
+    readonly { readonly name: string; readonly ids: readonly string[] }[]
+  >();
+  const membersOf = (
+    type: Type,
+  ): readonly { readonly name: string; readonly ids: readonly string[] }[] => {
+    const known = members.get(type.id);
+    if (known !== undefined) {
+      return known;
+    }
+    const keyed: { name: string; ids: readonly string[] }[] = [];
+    const properties = queries.propertiesOf(type);
+    for (const property of isAnswered(properties) ? properties : []) {
+      for (const handle of property.declarations) {
+        const node = ownPaths.has(handle.path) ? project.declarationAt(handle)?.node : undefined;
+        const name = wellKnownName((node as { readonly name?: Node } | undefined)?.name);
+        if (name !== undefined) {
+          keyed.push({ name, ids: chains.declarationsOf(property) });
+          break;
+        }
+      }
+    }
+    members.set(type.id, keyed);
+    return keyed;
+  };
+  const found: Reference[] = [];
+  iterated.forEach((one, index) => {
+    const type = types[index];
+    if (type === undefined || !isAnswered(type)) {
+      return;
+    }
+    const parts =
+      type.isUnionType() || type.isIntersectionType() ? queries.constituents(type) : [type];
+    const position = renderPosition(one.file, root, one.operand.getStart());
+    for (const part of isAnswered(parts) ? parts : []) {
+      for (const member of membersOf(part)) {
+        if (!(one.protocols as readonly string[]).includes(member.name)) {
+          continue;
+        }
+        for (const to of member.ids) {
+          found.push({
+            from: one.from,
+            to,
+            position,
+            use: "read",
+            resolution: "keyed",
+            test: testFiles.has(position.path),
+          });
+        }
+      }
+    }
+  });
+  return found;
+}

package/src/test-support.ts

@@ -1,10 +1,13 @@
 /**
- * Test-support code: the files only tests reach. A test reaches each one through a chain
- * of references, and every reference to a declaration of one, an import for its effects
- * included, is written in a test file or in another such file, so it is judged with the
- * tests: what it references is referenced by test code.
+ * Test-support code: the files only tests reach that carry test evidence of their own. A
+ * test reaches each one through a chain of references, and every reference to a
+ * declaration of one, an import for its effects included, is written in a test file or in
+ * another such file, so it is judged with the tests: what it references is referenced by
+ * test code.
  */
 
+import { CONVENTION_ROWS, TEST_LIBRARIES, TEST_LIBRARY_SCOPES } from "./convention-rows.ts";
+import { packageOfSpecifier } from "./dependencies.ts";
 import type { InventorySymbol } from "./inventory.ts";
 import type { Reference } from "./references.ts";
 import type { Root } from "./roots.ts";
@@ -12,19 +15,144 @@ import type { Root } from "./roots.ts";
 /** The root kind that never takes a file out of test-support code: the skip only withholds. */
 const SKIP_ROOT = "type-error";
 
+/**
+ * The test runners and test libraries an import of which is test evidence: each runner a
+ * convention row reads test files for, and the convention table's test libraries.
+ */
+const TEST_PACKAGES: ReadonlySet<string> = new Set([
+  ...CONVENTION_ROWS.filter((row) => row.testFiles !== undefined).map((row) => row.package),
+  ...TEST_LIBRARIES,
+]);
+
+/**
+ * The Node.js built-in modules a bare specifier names, which are no package. The set is
+ * closed: Node.js adds a new built-in under the `node:` scheme alone
+ * (https://nodejs.org/api/modules.html#built-in-modules-with-mandatory-node-prefix).
+ */
+const NODE_BUILTINS: ReadonlySet<string> = new Set([
+  "assert",
+  "async_hooks",
+  "buffer",
+  "child_process",
+  "cluster",
+  "console",
+  "constants",
+  "crypto",
+  "dgram",
+  "diagnostics_channel",
+  "dns",
+  "domain",
+  "events",
+  "fs",
+  "http",
+  "http2",
+  "https",
+  "inspector",
+  "module",
+  "net",
+  "os",
+  "path",
+  "perf_hooks",
+  "process",
+  "punycode",
+  "querystring",
+  "readline",
+  "repl",
+  "stream",
+  "string_decoder",
+  "sys",
+  "timers",
+  "tls",
+  "trace_events",
+  "tty",
+  "url",
+  "util",
+  "v8",
+  "vm",
+  "wasi",
+  "worker_threads",
+  "zlib",
+]);
+
+/** What a file imports, read for test evidence. */
+export interface TestEvidence {
+  /** Per file below the target root, the module specifiers its imports write. */
+  readonly imports: ReadonlyMap<string, readonly string[]>;
+  /**
+   * Whether the manifest nearest the file, below the target root, that declares the
+   * package declares it under `devDependencies`.
+   */
+  readonly devDependency: (path: string, name: string) => boolean;
+}
+
+/** Whether a specifier names a test runner or a test library. */
+function namesTestPackage(specifier: string): boolean {
+  const name = specifier.startsWith("node:") ? specifier : packageOfSpecifier(specifier);
+  return (
+    name !== undefined &&
+    (TEST_PACKAGES.has(name) || TEST_LIBRARY_SCOPES.some((scope) => name.startsWith(scope)))
+  );
+}
+
+/**
+ * Whether a file carries test evidence: an import of a test runner or a test library, or
+ * package imports, Node built-ins aside, that are all devDependencies no file imports
+ * outside the test files and `onlyTests`, the files only tests reach.
+ */
+function evidenceReader(
+  tests: ReadonlySet<string>,
+  evidence: TestEvidence,
+): (onlyTests: ReadonlySet<string>, path: string) => boolean {
+  const importers = new Map<string, string[]>();
+  for (const [path, specifiers] of evidence.imports) {
+    for (const specifier of specifiers) {
+      const name = packageOfSpecifier(specifier);
+      if (name !== undefined) {
+        importers.set(name, [...(importers.get(name) ?? []), path]);
+      }
+    }
+  }
+  return (onlyTests, path) => {
+    const specifiers = evidence.imports.get(path) ?? [];
+    if (specifiers.some(namesTestPackage)) {
+      return true;
+    }
+    const names = specifiers.flatMap((one) => packageOfSpecifier(one) ?? []);
+    const packages = names.filter((name) => !NODE_BUILTINS.has(name));
+    return (
+      packages.length > 0 &&
+      packages.every(
+        (name) =>
+          evidence.devDependency(path, name) &&
+          (importers.get(name) ?? []).every((one) => tests.has(one) || onlyTests.has(one)),
+      )
+    );
+  };
+}
+
+/** The files only tests reach, split by whether each carries test evidence of its own. */
+interface TestReached {
+  /** The test-support files: test code. */
+  readonly support: ReadonlySet<string>;
+  /** The files only tests reach that are no test-support file: production code only tests use. */
+  readonly testUsed: ReadonlySet<string>;
+}
+
 /**
  * The files of one project that are test-support code, below the target root: the
  * largest set of files a test file reaches, none of them a test file or holding a root,
- * whose every user outside the set is a test file. A root has a caller outside the
- * reference graph: a runtime, a tool, a configuration, or a consumer of a library's
- * published API. `testFiles` are the files the test-file rules classified.
+ * each carrying test evidence of its own, whose every user outside the set is a test
+ * file; and the files only tests reach that are not among them. A root has a caller
+ * outside the reference graph: a runtime, a tool, a configuration, or a consumer of a
+ * library's published API. `testFiles` are the files the test-file rules classified.
  */
 export function testSupportFiles(
   symbols: readonly InventorySymbol[],
   references: readonly Reference[],
   roots: readonly Root[],
   testFiles: readonly string[],
-): ReadonlySet<string> {
+  evidence: TestEvidence,
+): TestReached {
   const fileOf = new Map(symbols.map((symbol) => [symbol.id, symbol.position.path]));
   const users = new Map<string, Set<string>>();
   const uses = new Map<string, Set<string>>();
@@ -59,18 +187,27 @@ export function testSupportFiles(
       }
     }
   }
-  const support = new Set([...reached].filter((path) => !rooted.has(path)));
-  for (let changed = true; changed;) {
-    changed = false;
-    for (const path of support) {
-      const from = users.get(path) ?? new Set<string>();
-      if (![...from].every((one) => tests.has(one) || support.has(one))) {
-        support.delete(path);
-        changed = true;
+  const withoutOutsideUsers = (files: Set<string>): Set<string> => {
+    for (let changed = true; changed;) {
+      changed = false;
+      for (const path of files) {
+        const from = users.get(path) ?? new Set<string>();
+        if (![...from].every((one) => tests.has(one) || files.has(one))) {
+          files.delete(path);
+          changed = true;
+        }
       }
     }
-  }
-  return support;
+    return files;
+  };
+  // Evidence reads the files only tests reach, evidence or none, so it is fixed before the
+  // files without evidence leave the set.
+  const onlyTests = withoutOutsideUsers(new Set([...reached].filter((path) => !rooted.has(path))));
+  const carries = evidenceReader(tests, evidence);
+  const support = withoutOutsideUsers(
+    new Set([...onlyTests].filter((path) => carries(onlyTests, path))),
+  );
+  return { support, testUsed: new Set([...onlyTests].filter((path) => !support.has(path))) };
 }
 
 /** The references with every one a test-support file makes counted as a test reference. */

package/src/type-errors.ts

@@ -8,6 +8,7 @@
 
 import {
   isClassDeclaration,
+  isFunctionLikeDeclaration,
   isNoSubstitutionTemplateLiteral,
   isPropertyAccessExpression,
   isStringLiteral,
@@ -25,6 +26,7 @@ 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]);
@@ -78,6 +80,8 @@ interface ErrorContext {
   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`. */
@@ -241,7 +245,11 @@ function expectedModule(
     name === undefined
       ? undefined
       : declaringManifest(host, dirnamePath(importer), targetRoot, name);
-  if (manifest === undefined) {
+  // 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;
@@ -249,13 +257,27 @@ function expectedModule(
 }
 
 /**
- * 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.
+ * 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 || !isClassDeclaration(statement)) {
-    return statement;
+  if (statement === undefined) {
+    return undefined;
+  }
+  let innermost: Node | undefined;
+  const visit = (node: Node): void => {
+    if (offset < node.getStart() || offset >= node.end) {
+      return;
+    }
+    if (isFunctionLikeDeclaration(node)) {
+      innermost = node;
+    }
+    node.forEachChild(visit);
+  };
+  visit(statement);
+  if (innermost !== undefined || !isClassDeclaration(statement)) {
+    return innermost ?? statement;
   }
   return statement.members.find((one) => one.pos <= offset && offset < one.end) ?? statement;
 }
@@ -274,8 +296,18 @@ function messageOf(text: string, targetRoot: string): string {
 export function readErrors<Brand>(
   project: ProjectView<Brand>,
   errors: readonly LocatedDiagnostic[],
-  context: ErrorContext,
+  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[] = [];