@cplieger/deadset-ts 3.12.1 → 4.0.0

package/src/calls.ts

@@ -26,7 +26,7 @@ import {
 import { SymbolFlags, type Symbol as TSSymbol } from "@typescript/native/unstable/sync";
 import type { AliasChains } from "./alias-chain.ts";
 import { nodeKey, type Inventory } from "./inventory.ts";
-import { DEFAULT_BATCH_CAP } from "./references.ts";
+import { must } from "./query.ts";
 import type { ProjectView } from "./session.ts";
 
 /** One value written where a call passes it, and the node its declaration is resolved from. */
@@ -77,7 +77,8 @@ export function decoratorsOf(node: Node): readonly Decorator[] {
 /**
  * What each of a batch of nodes resolves to, every alias followed to the declaration
  * it stands for. A node the checker resolves to nothing, and an alias that resolves
- * to nothing, are absent from the answer. Each alias is followed once.
+ * to nothing, are absent from the answer. Each alias is followed once. A question the
+ * checker does not answer stops the pass, as {@link must} stops.
  */
 export function resolvedTargets<Brand>(
   project: ProjectView<Brand>,
@@ -85,17 +86,18 @@ export function resolvedTargets<Brand>(
 ): ReadonlyMap<Node, TSSymbol> {
   const followed = new Map<number, TSSymbol | undefined>();
   const targets = new Map<Node, TSSymbol>();
-  for (let from = 0; from < nodes.length; from += DEFAULT_BATCH_CAP) {
-    const run = nodes.slice(from, from + DEFAULT_BATCH_CAP);
-    project.symbolsAt(run.map((node) => project.handle(node))).forEach((symbol, index) => {
-      const node = run[index];
+  project
+    .symbolsAt(nodes.map((node) => project.handle(node)))
+    .map(must)
+    .forEach((symbol, index) => {
+      const node = nodes[index];
       if (symbol === undefined || node === undefined) {
         return;
       }
       let target: TSSymbol | undefined = symbol;
       if ((symbol.flags & SymbolFlags.Alias) !== 0) {
         if (!followed.has(symbol.id)) {
-          const aliased = project.checker.getAliasedSymbol(symbol);
+          const aliased = must(project.queries.aliased(symbol));
           followed.set(symbol.id, aliased.declarations.length === 0 ? undefined : aliased);
         }
         target = followed.get(symbol.id);
@@ -104,7 +106,6 @@ export function resolvedTargets<Brand>(
         targets.set(node, target);
       }
     });
-  }
   return targets;
 }
 
@@ -166,7 +167,7 @@ export function classesPassed<Brand>(
   );
   const classesOf = (value: PassedValue): readonly string[] => {
     const symbol = value.shorthand
-      ? project.shorthandValueAt(project.handle(value.name))
+      ? must(project.shorthandValueAt(project.handle(value.name)))
       : targets.get(value.name);
     return symbol === undefined
       ? []

package/src/class-members.ts

@@ -7,7 +7,7 @@
 import { isClassDeclaration, isClassExpression, type Node } from "@typescript/native/unstable/ast";
 import type { Symbol as TSSymbol, SymbolFlags, Type } from "@typescript/native/unstable/sync";
 import { nodeKey, type Inventory, type InventorySymbol } from "./inventory.ts";
-import { DEFAULT_BATCH_CAP } from "./references.ts";
+import { must } from "./query.ts";
 import type { ProjectView } from "./session.ts";
 
 /** One member of a class's value that the target declares. */
@@ -44,16 +44,15 @@ export function classNames<Brand>(
   return names;
 }
 
-/** The types of a batch of nodes, asked in capped batches. */
+/**
+ * The types of a batch of nodes, for a pass that cannot go on past a type the checker
+ * did not answer: it stops there, as {@link must} stops.
+ */
 export function typesAt<Brand>(
   project: ProjectView<Brand>,
   nodes: readonly Node[],
 ): (Type | undefined)[] {
-  const types: (Type | undefined)[] = [];
-  for (let from = 0; from < nodes.length; from += DEFAULT_BATCH_CAP) {
-    types.push(...project.checker.getTypeAtLocation(nodes.slice(from, from + DEFAULT_BATCH_CAP)));
-  }
-  return types;
+  return project.queries.typesAt(nodes).map(must);
 }
 
 /**
@@ -68,9 +67,9 @@ function sideTypes<Brand>(
   if (side === "instance") {
     return typesAt(project, nodes);
   }
-  const symbols = project.symbolsAt(nodes.map((node) => project.handle(node)));
+  const symbols = project.symbolsAt(nodes.map((node) => project.handle(node))).map(must);
   const present = symbols.filter((symbol): symbol is TSSymbol => symbol !== undefined);
-  const types = present.length === 0 ? [] : project.checker.getTypeOfSymbol(present);
+  const types = project.queries.typesOfSymbols(present).map(must);
   let next = 0;
   return symbols.map((symbol) => (symbol === undefined ? undefined : types[next++]));
 }
@@ -87,7 +86,7 @@ export function classMembers<Brand>(
   side: ClassSide,
 ): ReadonlyMap<string, readonly ClassMember[]> {
   const named = [...classNames(project, held)].filter(([id]) => classIds.has(id));
-  const own = new Set(project.ownSourceFiles().map((file) => file.fileName));
+  const own = project.ownPaths();
   const types = sideTypes(
     project,
     named.map(([, node]) => node),
@@ -100,7 +99,7 @@ export function classMembers<Brand>(
       return;
     }
     const found: ClassMember[] = [];
-    for (const property of project.checker.getPropertiesOfType(type)) {
+    for (const property of must(project.queries.propertiesOf(type))) {
       for (const handle of property.declarations) {
         if (!own.has(handle.path)) {
           continue;

package/src/components.ts

@@ -132,7 +132,8 @@ function linesSpanned(symbols: readonly (InventorySymbol | undefined)[]): number
 }
 
 /**
- * The dead declarations by their place in the subgraph, and the edges between them: each
+ * The dead declarations by their place in the subgraph, a test file's declaration only
+ * where it is a test of dead code, and the edges between them: each
  * reference one makes to another, an edge each way between a dead member and its dead
  * container (one direction alone leaves the member a component the container reaches),
  * and an edge back from each production target of an admitted test, which puts the test in
@@ -145,7 +146,8 @@ function deadSubgraph(
 ): { readonly at: readonly number[]; readonly adjacent: readonly (readonly number[])[] } {
   const at: number[] = [];
   const position = graph.symbols.map((_symbol, index) => {
-    if (dead[index] !== true) {
+    // A test file's declaration belongs to a component only as a test of dead code.
+    if (dead[index] !== true || (graph.test[index] === true && testOfDeadCode[index] !== true)) {
       return UNVISITED;
     }
     at.push(index);

package/src/configured-declarations.ts

@@ -23,8 +23,9 @@ import {
 } from "@typescript/native/unstable/sync";
 import type { AliasChains } from "./alias-chain.ts";
 import { resolvedTargets } from "./calls.ts";
-import type { DeclarationEntry } from "./config.ts";
+import type { Config, DeclarationEntry } from "./config.ts";
 import type { Inventory } from "./inventory.ts";
+import { must, Unanswerable } from "./query.ts";
 import { nameComponent } from "./ref.ts";
 import type { ProjectView } from "./session.ts";
 
@@ -90,7 +91,7 @@ function unaliased<Brand>(project: ProjectView<Brand>, symbol: TSSymbol): TSSymb
   if ((symbol.flags & SymbolFlags.Alias) === 0) {
     return symbol;
   }
-  const target = project.checker.getAliasedSymbol(symbol);
+  const target = must(project.queries.aliased(symbol));
   return target.declarations.length === 0 ? undefined : target;
 }
 
@@ -105,14 +106,18 @@ function isClassMember(symbol: TSSymbol): boolean {
  * with the static suffix names one of the first and a component without it names an
  * instance member or one of the second.
  */
-function candidatesOf(container: TSSymbol, isStatic: boolean): readonly TSSymbol[] {
-  const exported = [...container.getExports().values()];
+function candidatesOf<Brand>(
+  project: ProjectView<Brand>,
+  container: TSSymbol,
+  isStatic: boolean,
+): readonly TSSymbol[] {
+  const exported = [...must(project.queries.exportsOf(container)).values()];
   if (isStatic) {
     return exported.filter(isClassMember);
   }
   const isClass = (container.flags & SymbolFlags.Class) !== 0;
   return [
-    ...container.getMembers().values(),
+    ...must(project.queries.membersOf(container)).values(),
     ...exported.filter((member) => !isClass || !isClassMember(member)),
   ];
 }
@@ -124,7 +129,7 @@ function memberOf<Brand>(
   component: string,
   isStatic: boolean,
 ): TSSymbol | undefined {
-  const member = candidatesOf(container, isStatic).find(
+  const member = candidatesOf(project, container, isStatic).find(
     (candidate) => nameComponent(candidate.name) === component,
   );
   return member === undefined ? undefined : unaliased(project, member);
@@ -190,7 +195,7 @@ function modulesNamed<Brand>(
     file.forEachChild(visit);
   }
   const specified = [...written];
-  const symbols = project.symbolsAt(specified.map(([, node]) => project.handle(node)));
+  const symbols = project.symbolsAt(specified.map(([, node]) => project.handle(node))).map(must);
   const modules = new Map<string, TSSymbol>();
   specified.forEach(([name], index) => {
     const symbol = symbols[index];
@@ -238,7 +243,7 @@ export function resolveEntries<Brand>(
       const module = modules.get(entry.module);
       start = module === undefined ? undefined : memberOf(project, module, first, false);
     } else if (nameComponent(first) === first) {
-      const global = project.checker.resolveName(first, ANY_MEANING, undefined, false);
+      const global = must(project.queries.resolveName(first, ANY_MEANING, undefined, false));
       start = global === undefined ? undefined : unaliased(project, global);
     }
     const declared = walkPath(project, start, rest, isStatic);
@@ -306,3 +311,70 @@ export function spelledEntry(entry: DeclarationEntry, held: Inventory): string {
       return entry.global;
   }
 }
+
+/** One entry of a configuration key that names a declaration, and the key's dotted path. */
+interface ConfiguredDeclaration {
+  readonly key: string;
+  readonly entry: DeclarationEntry;
+}
+
+/** The key under which a lifecycle contract's declarations are configured. */
+const LIFECYCLE_KEY = "ts.lifecycle_contracts";
+
+/**
+ * Every entry of the three keys that name declarations, in the configuration's order:
+ * the injection registrations, each lifecycle contract's components and then its bases,
+ * and the serializers.
+ */
+export function configuredDeclarations(config: Config): readonly ConfiguredDeclaration[] {
+  return [
+    ...config.ts.injectionRegistrations.map((entry) => ({
+      key: "ts.injection_registrations",
+      entry,
+    })),
+    ...config.ts.lifecycleContracts.flatMap((contract) =>
+      [...contract.components, ...contract.bases].map((entry) => ({ key: LIFECYCLE_KEY, entry })),
+    ),
+    ...config.ts.serializers.map((entry) => ({ key: "ts.serializers", entry })),
+  ];
+}
+
+/**
+ * Whether each configured entry names a declaration in one project, in the entries'
+ * order. Where the checker leaves a question of the resolution unanswered, every entry
+ * counts as naming one, so no entry is reported as naming nothing on a gap.
+ */
+export function declarationsNamed<Brand>(
+  project: ProjectView<Brand>,
+  held: Inventory,
+  configured: readonly ConfiguredDeclaration[],
+): readonly boolean[] {
+  try {
+    return resolveEntries(
+      project,
+      held,
+      configured.map((one) => one.entry),
+    ).map(namesADeclaration);
+  } catch (error: unknown) {
+    if (!(error instanceof Unanswerable)) {
+      throw error;
+    }
+    return configured.map(() => true);
+  }
+}
+
+/**
+ * The reference a finding about a configured entry names it by, the entry as the
+ * configuration spells it: a symbol entry's reference, a module entry's module, a number
+ * sign and its name, and a global entry's path after a number sign.
+ */
+export function configuredRef(entry: DeclarationEntry): string {
+  switch (entry.shape) {
+    case "symbol":
+      return entry.symbol;
+    case "module":
+      return `${entry.module}#${entry.name}`;
+    case "global":
+      return `#${entry.global}`;
+  }
+}

package/src/conformance-record.ts

@@ -2,9 +2,9 @@
 // Regenerate it with `UPDATE_GOLDEN=1 npx vitest --run src/conformance.corpus.test.ts`.
 export const RECORD = {
   conformance: {
-    corpusVersion: "1.9.0",
+    corpusVersion: "2.0.0",
     result: "pass",
-    digest: "sha256:3e9e40876551faa2c196311bf06d47d220ab5127a9fb8921969aae552c42e824",
+    digest: "sha256:1274315595d7b944d22eb0126081e24cf293c9fe53a236f4d263c714644f32ee",
   },
   gaps: [
     {

package/src/dependencies.ts

@@ -17,16 +17,16 @@ import {
   isStringLiteral,
   isNoSubstitutionTemplateLiteral,
   SyntaxKind,
+  type Identifier,
   type Node,
   type SourceFile,
 } from "@typescript/native/unstable/ast";
-import type { Symbol as TSSymbol } from "@typescript/native/unstable/sync";
 import type { FindingPosition } from "./finding.ts";
 import type { Host } from "./host.ts";
 import { nodeKey, packageScope, type Inventory } from "./inventory.ts";
 import { dirnamePath, isAbsolutePath, joinPath, resolvePath } from "./paths.ts";
 import type { DependencySection, Module } from "./ref.ts";
-import { DEFAULT_BATCH_CAP } from "./references.ts";
+import { UNANSWERED } from "./query.ts";
 import type { Handle, ProjectView } from "./session.ts";
 
 const MANIFEST = "package.json";
@@ -70,6 +70,11 @@ export interface ProjectNeeds {
    * compiler configuration names, which no deletion removes.
    */
   readonly uses: ReadonlyMap<string, ReadonlySet<string>>;
+  /**
+   * Whether the checker left a module specifier unanswered, so the project may use any
+   * dependency the manifest declares.
+   */
+  readonly unanswered: boolean;
 }
 
 /** The run's dependency evidence. */
@@ -299,10 +304,11 @@ export function projectNeeds<Brand>(
   };
   use([PROJECT_OWNER], packages);
 
+  let unanswered = false;
   for (const file of project.ownSourceFiles()) {
-    fileNeeds(project, held, file, programPackages, use);
+    unanswered = fileNeeds(project, held, file, programPackages, use) || unanswered;
   }
-  return { packages, uses };
+  return { packages, uses, unanswered };
 }
 
 /** The declarations of the inventory a use written at one node belongs to. */
@@ -329,13 +335,14 @@ function ownersOf(file: SourceFile, held: Inventory, node: Node): readonly strin
   return [PROJECT_OWNER];
 }
 
+/** Records the needs of one file, and answers whether a specifier of it went unanswered. */
 function fileNeeds<Brand>(
   project: ProjectView<Brand>,
   held: Inventory,
   file: SourceFile,
   programPackages: ReadonlySet<string>,
   use: (owners: readonly string[], named: Iterable<string>) => void,
-): void {
+): boolean {
   const specifiers = [...file.imports, ...file.moduleAugmentations].filter(isLiteralText);
   const bindings: { readonly node: Texted; readonly specifier: Texted }[] = [];
   const bound = new Set<Node>();
@@ -351,7 +358,7 @@ function fileNeeds<Brand>(
     }
   }
   const names = new Set(bindings.map(({ node }) => node.text));
-  const candidates: Node[] = [];
+  const candidates: Identifier[] = [];
   const visit = (node: Node): void => {
     if (isIdentifier(node) && names.has(node.text) && !bound.has(node)) {
       candidates.push(node);
@@ -363,13 +370,8 @@ function fileNeeds<Brand>(
   }
 
   const asked = [...specifiers, ...bindings.map(({ node }) => node), ...candidates];
-  const resolved: (TSSymbol | undefined)[] = [];
-  for (let at = 0; at < asked.length; at += DEFAULT_BATCH_CAP) {
-    const handles: Handle<Brand>[] = asked
-      .slice(at, at + DEFAULT_BATCH_CAP)
-      .map((node) => project.handle(node));
-    resolved.push(...project.symbolsAt(handles));
-  }
+  const handles: Handle<Brand>[] = asked.map((node) => project.handle(node));
+  const resolved = project.symbolsAt(handles);
 
   const packagesOf = new Map<Node, readonly string[]>();
   specifiers.forEach((specifier, index) => {
@@ -378,7 +380,8 @@ function fileNeeds<Brand>(
     if (byName !== undefined) {
       named.add(byName);
     }
-    for (const declaration of resolved[index]?.declarations ?? []) {
+    const symbol = resolved[index];
+    for (const declaration of typeof symbol === "object" ? symbol.declarations : []) {
       const byPath = packageOfPath(declaration.path);
       if (byPath !== undefined) {
         named.add(byPath);
@@ -387,11 +390,19 @@ function fileNeeds<Brand>(
     packagesOf.set(specifier, [...named]);
   });
 
+  // A name the checker could not resolve counts as a use of every package a binding of
+  // that name brings in, so a gap never makes a dependency read as unused.
   const bySymbol = new Map<number, readonly string[]>();
-  bindings.forEach(({ specifier }, index) => {
+  const byName = new Map<string, string[]>();
+  const unresolvedNames = new Set<string>();
+  bindings.forEach(({ node, specifier }, index) => {
+    const packages = packagesOf.get(specifier) ?? [];
+    byName.set(node.text, [...(byName.get(node.text) ?? []), ...packages]);
     const symbol = resolved[specifiers.length + index];
-    if (symbol !== undefined) {
-      bySymbol.set(symbol.id, packagesOf.get(specifier) ?? []);
+    if (symbol === UNANSWERED) {
+      unresolvedNames.add(node.text);
+    } else if (symbol !== undefined) {
+      bySymbol.set(symbol.id, packages);
     }
   });
 
@@ -409,7 +420,13 @@ function fileNeeds<Brand>(
     if (parent !== undefined && isShorthandPropertyAssignment(parent) && parent.name === node) {
       symbol = project.shorthandValueAt(project.handle(node));
     }
-    const named = symbol === undefined ? undefined : bySymbol.get(symbol.id);
+    const named =
+      symbol === UNANSWERED || (unresolvedNames.has(node.text) && symbol === undefined)
+        ? byName.get(node.text)
+        : symbol === undefined
+          ? undefined
+          : (bySymbol.get(symbol.id) ??
+            (unresolvedNames.has(node.text) ? byName.get(node.text) : undefined));
     if (named !== undefined) {
       use(ownersOf(file, held, node), named);
     }
@@ -418,6 +435,7 @@ function fileNeeds<Brand>(
   for (const reference of file.typeReferenceDirectives) {
     use(ownersOf(file, held, file), typePackages(reference.fileName, programPackages));
   }
+  return resolved.slice(0, specifiers.length).includes(UNANSWERED);
 }
 
 /** The offset just past the JSON value that starts at `at` in text the parser has accepted. */
@@ -591,12 +609,16 @@ export function dependenciesOf(
   const needed = new Set<string>();
   const uses = new Map<string, Set<string>>();
   for (const project of perProject) {
-    project.packages.forEach((one) => needed.add(one));
-    for (const [id, used] of project.uses) {
+    // A specifier the checker left unanswered may resolve to any declared dependency,
+    // and what the configuration needs is never deleted, so it is needed there.
+    const unknown = project.unanswered ? declared.map((dependency) => dependency.name) : [];
+    const held = unknown.length === 0 ? [] : [[PROJECT_OWNER, new Set(unknown)] as const];
+    for (const [id, used] of [...project.uses, ...held]) {
       const merged = uses.get(id) ?? new Set<string>();
       used.forEach((one) => merged.add(one));
       uses.set(id, merged);
     }
+    [...project.packages, ...unknown].forEach((one) => needed.add(one));
   }
   const users = new Map<string, number>();
   for (const used of uses.values()) {

package/src/deprecation.ts

@@ -8,9 +8,8 @@
  */
 
 import { isVariableStatement, SyntaxKind, type Node } from "@typescript/native/unstable/ast";
-import type { Symbol as TSSymbol } from "@typescript/native/unstable/sync";
 import { nodeKey, type Inventory } from "./inventory.ts";
-import { DEFAULT_BATCH_CAP } from "./references.ts";
+import { isAnswered, UNANSWERED } from "./query.ts";
 import type { Handle, ProjectView } from "./session.ts";
 
 /** The tag the TypeScript tools recognize as marking a declaration deprecated. */
@@ -31,19 +30,31 @@ function nameNode(node: Node): Node {
   return (node as { readonly name?: Node }).name ?? node;
 }
 
+/** Which declarations of one project carry the deprecation marker. */
+export interface Deprecation {
+  /** Every declaration that carries it, in the inventory's order. */
+  readonly deprecated: readonly string[];
+  /**
+   * Every declaration whose symbol or tags the checker left unanswered where the
+   * project's files hold the tag, in the inventory's order: whether it carries the
+   * marker is unknown.
+   */
+  readonly unanswered: readonly string[];
+}
+
 /**
- * The identifiers of every declaration of one project that carries the deprecation
- * marker, in the inventory's order.
+ * The declarations of one project that carry the deprecation marker.
  *
  * The checker is asked only for a symbol with a declaration in a file whose tree holds
  * the tag, so a project whose files hold none costs no round trip, and one that does
- * costs one batch per file and one request per symbol that could carry the tag.
+ * costs one batch per file and one for the tags of the symbols that could carry it.
  */
 export function deprecatedDeclarations<Brand>(
   project: ProjectView<Brand>,
   held: Inventory,
-): readonly string[] {
+): Deprecation {
   const marked = new Set<string>();
+  const unknown = new Set<string>();
   const markedPaths = new Set<string>();
   const declared: { readonly id: string; readonly handle: Handle<Brand> }[][] = [];
 
@@ -72,30 +83,45 @@ export function deprecatedDeclarations<Brand>(
   }
 
   if (markedPaths.size > 0) {
-    const asked = new Map<number, boolean>();
-    const carriesTag = (symbol: TSSymbol): boolean => {
-      const known = asked.get(symbol.id);
-      if (known !== undefined) {
-        return known;
+    const pairs = declared.flatMap((named) => {
+      const symbols = project.symbolsAt(named.map((one) => one.handle));
+      return named.flatMap((one, at) => {
+        const symbol = symbols[at];
+        if (symbol === UNANSWERED) {
+          unknown.add(one.id);
+        }
+        return typeof symbol === "object" &&
+          symbol.declarations.some((declaration) => markedPaths.has(declaration.path))
+          ? [{ id: one.id, symbol }]
+          : [];
+      });
+    });
+    const distinct = [...new Map(pairs.map((one) => [one.symbol.id, one.symbol])).values()];
+    const tags = project.queries.jsDocTags(distinct);
+    const unread = new Set(
+      distinct.filter((_, at) => tags[at] === UNANSWERED).map((one) => one.id),
+    );
+    const carries = new Set(
+      distinct.flatMap((symbol, at) => {
+        const read = tags[at];
+        return read !== undefined &&
+          isAnswered(read) &&
+          read.some((tag) => tag.name === DEPRECATED_TAG)
+          ? [symbol.id]
+          : [];
+      }),
+    );
+    for (const one of pairs) {
+      if (carries.has(one.symbol.id)) {
+        marked.add(one.id);
       }
-      const carries =
-        symbol.declarations.some((declaration) => markedPaths.has(declaration.path)) &&
-        symbol.getJsDocTags(project.checker).some((tag) => tag.name === DEPRECATED_TAG);
-      asked.set(symbol.id, carries);
-      return carries;
-    };
-    for (const named of declared) {
-      for (let start = 0; start < named.length; start += DEFAULT_BATCH_CAP) {
-        const batch = named.slice(start, start + DEFAULT_BATCH_CAP);
-        project.symbolsAt(batch.map((one) => one.handle)).forEach((symbol, at) => {
-          const one = batch[at];
-          if (symbol !== undefined && one !== undefined && carriesTag(symbol)) {
-            marked.add(one.id);
-          }
-        });
+      if (unread.has(one.symbol.id)) {
+        unknown.add(one.id);
       }
     }
   }
 
-  return held.symbols.filter((symbol) => marked.has(symbol.id)).map((symbol) => symbol.id);
+  const inOrder = (ids: ReadonlySet<string>): readonly string[] =>
+    held.symbols.filter((symbol) => ids.has(symbol.id)).map((symbol) => symbol.id);
+  return { deprecated: inOrder(marked), unanswered: inOrder(unknown) };
 }