@cplieger/deadset-ts 3.13.0 → 4.0.0

package/src/implementations.ts

@@ -17,7 +17,7 @@ import {
 import { SymbolFlags, type Symbol as TSSymbol, type Type } from "@typescript/native/unstable/sync";
 import { aliasChains } from "./alias-chain.ts";
 import { nodeKey, type Inventory } from "./inventory.ts";
-import { DEFAULT_BATCH_CAP } from "./references.ts";
+import { must, Unanswerable } from "./query.ts";
 import type { ProjectView } from "./session.ts";
 
 /** What one run knows about how its interfaces are implemented. */
@@ -29,6 +29,13 @@ export interface Implementations {
    * class's implementation is a method whose body holds no statement.
    */
   readonly bodies: ReadonlyMap<string, ReadonlyMap<string, boolean>>;
+  /**
+   * The interface methods whose implementations a project could not read in full,
+   * because the checker left a question about them unanswered. Each is treated as a
+   * marker, whose every implementation is empty, so none is reported for want of an
+   * answer.
+   */
+  readonly unknown: ReadonlySet<string>;
 }
 
 /** One interface or class the inventory holds, by its declaration. */
@@ -97,24 +104,22 @@ function walk<Brand>(
   return { interfaces, classes, clauses };
 }
 
-/** The type at each node, asked in capped batches. */
+/** The type at each node. */
 function typesAt<Brand>(project: ProjectView<Brand>, nodes: readonly Node[]): Map<Node, Type> {
   const typeAt = new Map<Node, Type>();
-  for (let from = 0; from < nodes.length; from += DEFAULT_BATCH_CAP) {
-    const run = nodes.slice(from, from + DEFAULT_BATCH_CAP);
-    project.checker.getTypeAtLocation(run).forEach((type, index) => {
-      const node = run[index];
-      if (type !== undefined && node !== undefined) {
-        typeAt.set(node, type);
-      }
-    });
-  }
+  project.queries.typesAt(nodes).forEach((answer, index) => {
+    const type = must(answer);
+    const node = nodes[index];
+    if (type !== undefined && node !== undefined) {
+      typeAt.set(node, type);
+    }
+  });
   return typeAt;
 }
 
 /** Whether one class member is a method whose every written body holds no statement. */
 function emptyImplementation<Brand>(project: ProjectView<Brand>, member: TSSymbol): boolean {
-  const own = new Set(project.ownSourceFiles().map((file) => file.fileName));
+  const own = project.ownPaths();
   let bodies = 0;
   for (const handle of member.declarations) {
     // A body outside the target is one this analysis cannot read, so it is not empty.
@@ -135,19 +140,41 @@ function emptyImplementation<Brand>(project: ProjectView<Brand>, member: TSSymbo
   return bodies > 0;
 }
 
-/** How one project's interfaces are implemented by its classes. */
+/**
+ * How one project's interfaces are implemented by its classes. Where the checker leaves
+ * a question unanswered, what was read stands and every interface method of the project
+ * is named in {@link Implementations.unknown}.
+ */
 export function implementations<Brand>(
   project: ProjectView<Brand>,
   held: Inventory,
 ): Implementations {
   const classes = new Map<string, Set<string>>();
   const bodies = new Map<string, Map<string, boolean>>();
+  try {
+    implementedIn(project, held, classes, bodies);
+    return { classes, bodies, unknown: new Set() };
+  } catch (error: unknown) {
+    if (!(error instanceof Unanswerable)) {
+      throw error;
+    }
+    const methods = held.symbols.filter((symbol) => symbol.kind === "interface-method");
+    return { classes, bodies, unknown: new Set(methods.map((symbol) => symbol.id)) };
+  }
+}
+
+function implementedIn<Brand>(
+  project: ProjectView<Brand>,
+  held: Inventory,
+  classes: Map<string, Set<string>>,
+  bodies: Map<string, Map<string, boolean>>,
+): void {
   const walked = walk(project, held);
   if (walked.interfaces.length === 0 || walked.classes.length === 0) {
-    return { classes, bodies };
+    return;
   }
 
-  const checker = project.checker;
+  const queries = project.queries;
   const typeAt = typesAt(project, [
     ...walked.interfaces.map((one) => one.nameNode),
     ...walked.classes.map((one) => one.nameNode),
@@ -178,10 +205,10 @@ export function implementations<Brand>(
   }
 
   const membersOf = (at: InterfaceAt): readonly TSSymbol[] =>
-    (at.members ??= checker.getPropertiesOfType(at.type));
+    (at.members ??= must(queries.propertiesOf(at.type)));
   const classMembers = (at: ClassAt): ReadonlyMap<string, TSSymbol> =>
     (at.members ??= new Map(
-      checker.getPropertiesOfType(at.type).map((member) => [member.escapedName, member]),
+      must(queries.propertiesOf(at.type)).map((member) => [member.escapedName, member]),
     ));
 
   const methodIds = new Set(
@@ -233,12 +260,14 @@ export function implementations<Brand>(
     if (entry === undefined || implementer === undefined) {
       continue;
     }
-    const at = byType.get(entry.isTypeReference() ? entry.getTarget().id : entry.id);
+    const at = byType.get(must(queries.targetOf(entry)).id);
     if (at !== undefined) {
       pair(at, implementer);
     }
   }
 
+  // Every pair whose names line up is asked about at once.
+  const candidates: { readonly at: InterfaceAt; readonly implementer: ClassAt }[] = [];
   for (const at of byType.values()) {
     const members = at.generic ? [] : membersOf(at);
     if (members.length === 0) {
@@ -252,18 +281,25 @@ export function implementations<Brand>(
       const written = classMembers(implementer);
       if (
         required.every((member) => written.has(member.escapedName)) &&
-        members.some((member) => written.has(member.escapedName)) &&
-        checker.isTypeAssignableTo(implementer.type, at.type)
+        members.some((member) => written.has(member.escapedName))
       ) {
-        pair(at, implementer);
+        candidates.push({ at, implementer });
       }
     }
   }
-  return { classes, bodies };
+  const assignable = queries.assignableEach(
+    candidates.map((one) => ({ source: one.implementer.type, target: one.at.type })),
+  );
+  candidates.forEach((one, index) => {
+    if (must(assignable[index] ?? false)) {
+      pair(one.at, one.implementer);
+    }
+  });
 }
 
 /** Every project's answers as one run's, each implementation once. */
 export function mergeImplementations(per: readonly Implementations[]): Implementations {
+  const unknown = new Set(per.flatMap((one) => [...one.unknown]));
   const classes = new Map<string, Set<string>>();
   const bodies = new Map<string, Map<string, boolean>>();
   for (const one of per) {
@@ -282,5 +318,5 @@ export function mergeImplementations(per: readonly Implementations[]): Implement
       }
     }
   }
-  return { classes, bodies };
+  return { classes, bodies, unknown };
 }

package/src/interface-satisfaction.ts

@@ -52,7 +52,7 @@ import { aliasChains } from "./alias-chain.ts";
 import type { DetectorInput, Evidence } from "./exempt.ts";
 import { nodeKey } from "./inventory.ts";
 import { renderPosition } from "./position.ts";
-import { DEFAULT_BATCH_CAP } from "./references.ts";
+import { must } from "./query.ts";
 
 /** One class the inventory holds, by its declaration. */
 interface ClassAt {
@@ -246,7 +246,7 @@ function walk(files: readonly SourceFile[], declarations: ReadonlyMap<string, st
  */
 export function interfaceSatisfaction<Brand>(input: DetectorInput<Brand>): readonly Evidence[] {
   const { project, held, targetRoot } = input;
-  const checker = project.checker;
+  const queries = project.queries;
   const files = project.ownSourceFiles();
   const { classes, clauses, flows } = walk(files, held.declarations);
   if (classes.length === 0) {
@@ -261,15 +261,13 @@ export function interfaceSatisfaction<Brand>(input: DetectorInput<Brand>): reado
     ...flows.filter((flow) => flow.self === undefined).map((flow) => flow.value),
   ];
   const typeAt = new Map<Node, Type>();
-  for (let from = 0; from < asked.length; from += DEFAULT_BATCH_CAP) {
-    const run = asked.slice(from, from + DEFAULT_BATCH_CAP);
-    checker.getTypeAtLocation(run).forEach((type, index) => {
-      const node = run[index];
-      if (type !== undefined && node !== undefined) {
-        typeAt.set(node, type);
-      }
-    });
-  }
+  queries.typesAt(asked).forEach((answer, index) => {
+    const type = must(answer);
+    const node = asked[index];
+    if (type !== undefined && node !== undefined) {
+      typeAt.set(node, type);
+    }
+  });
 
   const classOfType = new Map<number, ClassAt>();
   const instanceOf = new Map<string, Type>();
@@ -289,7 +287,7 @@ export function interfaceSatisfaction<Brand>(input: DetectorInput<Brand>): reado
     }
     let parts = constituents.get(type.id);
     if (parts === undefined) {
-      parts = type.getTypes();
+      parts = must(queries.constituents(type));
       constituents.set(type.id, parts);
     }
     return parts;
@@ -307,7 +305,7 @@ export function interfaceSatisfaction<Brand>(input: DetectorInput<Brand>): reado
         return [];
       }
       if (!targets.has(part.id)) {
-        targets.set(part.id, classOfType.get(part.getTarget().id));
+        targets.set(part.id, classOfType.get(must(queries.targetOf(part)).id));
       }
       const generic = targets.get(part.id);
       return generic === undefined ? [] : [{ owner: generic, type: part }];
@@ -318,7 +316,7 @@ export function interfaceSatisfaction<Brand>(input: DetectorInput<Brand>): reado
   const interfacesOf = (type: Type): readonly { type: Type; name: string }[] =>
     partsOf(type).flatMap((part) => {
       if (!interfaceNames.has(part.id)) {
-        const symbol = part.isObjectType() ? part.getSymbol() : undefined;
+        const symbol = part.isObjectType() ? must(queries.symbolOfType(part)) : undefined;
         interfaceNames.set(
           part.id,
           symbol !== undefined && (symbol.flags & SymbolFlags.Interface) !== 0
@@ -352,7 +350,8 @@ export function interfaceSatisfaction<Brand>(input: DetectorInput<Brand>): reado
     }
   }
 
-  for (const flow of flows) {
+  // The positions of every flow carrying a class are asked for at once.
+  const carrying = flows.flatMap((flow) => {
     const self = flow.self === undefined ? undefined : instanceOf.get(flow.self.id);
     const valueType = typeAt.get(flow.value);
     const sources =
@@ -361,32 +360,35 @@ export function interfaceSatisfaction<Brand>(input: DetectorInput<Brand>): reado
         : valueType === undefined
           ? []
           : classesOf(valueType);
-    if (sources.length === 0) {
-      continue;
-    }
-    const position = checker.getContextualType(flow.value);
+    return sources.length === 0 ? [] : [{ flow, sources }];
+  });
+  const positions = queries.contextualTypes(carrying.map((one) => one.flow.value));
+  carrying.forEach(({ flow, sources }, index) => {
+    const position = must(positions[index]);
     if (position === undefined) {
-      continue;
+      return;
     }
     for (const reached of interfacesOf(position)) {
       for (const source of sources) {
         reach(source.owner, source.type, reached.type, reached.name, flow.value);
       }
     }
-  }
+  });
 
   const chains = aliasChains(project, held);
   const required = new Map<number, ReadonlySet<string>>();
   const members = new Map<string, ReadonlyMap<string, readonly string[]>>();
   const found: Evidence[] = [];
-  for (const pair of pairs.values()) {
-    if (!checker.isTypeAssignableTo(pair.source, pair.target)) {
+  const asking = [...pairs.values()];
+  const assignable = queries.assignableEach(asking);
+  for (const [index, pair] of asking.entries()) {
+    if (!must(assignable[index] ?? false)) {
       continue;
     }
     let names = required.get(pair.target.id);
     if (names === undefined) {
       names = new Set(
-        checker.getPropertiesOfType(pair.target).map((property) => property.escapedName),
+        must(queries.propertiesOf(pair.target)).map((property) => property.escapedName),
       );
       required.set(pair.target.id, names);
     }
@@ -394,9 +396,10 @@ export function interfaceSatisfaction<Brand>(input: DetectorInput<Brand>): reado
     if (answering === undefined) {
       const instance = instanceOf.get(pair.owner.id) ?? pair.source;
       answering = new Map(
-        checker
-          .getPropertiesOfType(instance)
-          .map((property) => [property.escapedName, chains.declarationsOf(property)]),
+        must(queries.propertiesOf(instance)).map((property) => [
+          property.escapedName,
+          chains.declarationsOf(property),
+        ]),
       );
       members.set(pair.owner.id, answering);
     }

package/src/intra-function-parts.ts

@@ -38,12 +38,14 @@ import {
   isParenthesizedExpression,
   isPrefixUnaryExpression,
   isPropertyAccessExpression,
+  isQualifiedName,
   isReturnStatement,
   isShorthandPropertyAssignment,
   isStringLiteral,
   isSwitchStatement,
   isThrowStatement,
   isTypeAliasDeclaration,
+  isTypeReferenceNode,
   isVariableStatement,
   isVoidExpression,
   NodeFlags,
@@ -58,7 +60,8 @@ import {
 import type { FindingPosition } from "./finding.ts";
 import { nodeKey, type Inventory } from "./inventory.ts";
 import { positionKey, renderPosition } from "./position.ts";
-import { DEFAULT_BATCH_CAP, type Reference } from "./references.ts";
+import { isAnswered, UNANSWERED, type Answer } from "./query.ts";
+import type { Reference } from "./references.ts";
 import type { ProjectView } from "./session.ts";
 import { signatureOf, type SignatureNode } from "./signatures.ts";
 
@@ -318,8 +321,14 @@ function extendedNames(files: readonly SourceFile[]): ReadonlySet<string> {
   const visit = (node: Node): void => {
     if (isHeritageClause(node) && node.token === SyntaxKind.ExtendsKeyword) {
       for (const type of node.types) {
-        const expression = unwrapped(type.expression);
-        const named = isPropertyAccessExpression(expression) ? expression.name : expression;
+        // A class's clause holds expressions; an interface's holds type references.
+        let named: Node;
+        if (isTypeReferenceNode(type)) {
+          named = isQualifiedName(type.typeName) ? type.typeName.right : type.typeName;
+        } else {
+          const expression = unwrapped(type.expression);
+          named = isPropertyAccessExpression(expression) ? expression.name : expression;
+        }
         if (isIdentifier(named)) {
           names.add(named.text);
         }
@@ -364,39 +373,41 @@ interface Declared {
   readonly signature: SignatureNode;
 }
 
-/** The symbol identifier each of a batch of identifiers resolves to, where the batch answers. */
+/**
+ * The symbol identifier each of a batch of identifiers resolves to, where the batch
+ * resolves it, and {@link UNANSWERED} where the checker did not answer.
+ */
 function resolvedIds<Brand>(
   project: ProjectView<Brand>,
   nodes: readonly Identifier[],
-): ReadonlyMap<Node, number> {
-  const ids = new Map<Node, number>();
-  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];
-      if (symbol !== undefined && node !== undefined) {
-        ids.set(node, symbol.id);
-      }
-    });
-  }
+): ReadonlyMap<Node, Answer<number>> {
+  const ids = new Map<Node, Answer<number>>();
+  project.symbolsAt(nodes.map((node) => project.handle(node))).forEach((symbol, index) => {
+    const node = nodes[index];
+    if (node !== undefined && symbol !== undefined) {
+      ids.set(node, symbol === UNANSWERED ? UNANSWERED : symbol.id);
+    }
+  });
   return ids;
 }
 
 /**
  * Whether one identifier reads the binding a name node declares: it resolves to the
- * same symbol, or the checker resolves it to nothing, which is read as a use rather than
- * risk a finding; a shorthand property reads the binding of its own name.
+ * same symbol, or the checker resolves it to nothing or does not answer for either
+ * name, which is read as a use rather than risk a finding; a shorthand property reads
+ * the binding of its own name.
  */
 function readsBinding(
   use: Identifier,
   declared: Identifier,
-  ids: ReadonlyMap<Node, number>,
+  ids: ReadonlyMap<Node, Answer<number>>,
 ): boolean {
   if (isShorthandPropertyAssignment(use.parent)) {
     return true;
   }
   const at = ids.get(use);
-  return at === undefined || at === ids.get(declared);
+  const own = ids.get(declared);
+  return at === undefined || at === UNANSWERED || own === UNANSWERED || at === own;
 }
 
 /** What one file's walk collects before the batch that resolves its names. */
@@ -587,7 +598,7 @@ function parameterParts(
   root: string,
   one: Declared,
   uses: readonly Identifier[],
-  ids: ReadonlyMap<Node, number>,
+  ids: ReadonlyMap<Node, Answer<number>>,
 ): PartFact[] {
   const signature = one.signature;
   // A function that reads `arguments` reads every parameter by position.
@@ -676,7 +687,7 @@ function deadStores(
   block: Block,
   holder: string,
   locals: readonly Local[],
-  ids: ReadonlyMap<Node, number>,
+  ids: ReadonlyMap<Node, Answer<number>>,
 ): PartFact[] {
   const found: PartFact[] = [];
   for (const local of locals) {
@@ -779,10 +790,17 @@ function resultParts<Brand>(
     if (!discardedAt.has(id) || generator || !returnsAValue(signature)) {
       continue;
     }
-    const typed = project.checker.getSignatureFromDeclaration(signature);
-    const result =
-      typed === undefined ? undefined : project.checker.getReturnTypeOfSignature(typed);
-    if (result === undefined || NO_VALUE.has(project.checker.typeToString(result))) {
+    // A question the checker leaves unanswered withholds the finding.
+    const typed = project.queries.signatureOf(signature);
+    if (typed === undefined || !isAnswered(typed)) {
+      continue;
+    }
+    const result = project.queries.returnTypeOf(typed);
+    if (result === undefined || !isAnswered(result)) {
+      continue;
+    }
+    const spelled = project.queries.typeToString(result);
+    if (!isAnswered(spelled) || NO_VALUE.has(spelled)) {
       continue;
     }
     const at = signature.type ?? (node as { readonly name?: Node }).name ?? node;

package/src/inventory.ts

@@ -33,6 +33,7 @@ import type { Host } from "./host.ts";
 import { dirnamePath, joinPath, relativePath } from "./paths.ts";
 import { byPosition, positionKey, renderPosition, type Position } from "./position.ts";
 import { computedComponent, nameComponent, renderRef, type Component, type Module } from "./ref.ts";
+import { isAnswered, UNANSWERED } from "./query.ts";
 import type { Handle, ProjectView } from "./session.ts";
 
 /**
@@ -160,6 +161,17 @@ export interface Inventory {
    * that the omission is a number rather than a silence.
    */
   readonly outsideOwnFiles: number;
+  /**
+   * The declarations whose module, namespace or container table the checker did not
+   * answer, in position order: whether each is exported, and which members a table
+   * would have added, are unknown.
+   */
+  readonly unanswered: readonly string[];
+  /**
+   * Every declaration other than a file by each name a use may spell it with: its
+   * component, its declared name where that differs, and a type parameter's own name.
+   */
+  readonly byName: ReadonlyMap<string, readonly string[]>;
 }
 
 /** A declaration under construction, before its reference is rendered. */
@@ -758,12 +770,28 @@ export function inventory<Brand>(
   const handles: Handle<Brand>[] = batched.map((node) => project.handle(node));
   const resolved = project.symbolsAt(handles);
   const symbolOf = new Map<Node, TSSymbol>();
+  // A scope or a container whose symbol or table went unanswered keeps what its syntax
+  // declares, and everything under it is recorded unanswered.
+  const unansweredOwners = new Set<Building>();
   batched.forEach((node, index) => {
     const symbol = resolved[index];
-    if (symbol !== undefined) {
+    if (typeof symbol === "object") {
       symbolOf.set(node, symbol);
     }
   });
+  resolved.slice(0, exportScopes.length).forEach((symbol, index) => {
+    const scope = exportScopes[index];
+    if (symbol === UNANSWERED && scope !== undefined) {
+      unansweredOwners.add(scope.owner);
+    }
+  });
+  containers
+    .filter((container) => container.nameNode !== undefined)
+    .forEach((container, index) => {
+      if (resolved[exportScopes.length + index] === UNANSWERED) {
+        unansweredOwners.add(container.owner);
+      }
+    });
 
   let exportTables = 0;
   for (const scope of exportScopes) {
@@ -772,7 +800,11 @@ export function inventory<Brand>(
       continue;
     }
     exportTables += 1;
-    for (const [, exported] of symbol.getExports()) {
+    const table = project.queries.exportsOf(symbol);
+    if (!isAnswered(table)) {
+      unansweredOwners.add(scope.owner);
+    }
+    for (const [, exported] of isAnswered(table) ? table : []) {
       for (const declaration of exported.declarations) {
         const held = project.declarationAt(declaration);
         if (held === undefined) {
@@ -794,11 +826,21 @@ export function inventory<Brand>(
     if (symbol !== undefined) {
       if (!container.membersAreExports) {
         memberTables += 1;
-        outsideOwnFiles += readTable(container, symbol.getMembers(), seen, false);
+        const table = project.queries.membersOf(symbol);
+        if (isAnswered(table)) {
+          outsideOwnFiles += readTable(container, table, seen, false);
+        } else {
+          unansweredOwners.add(container.owner);
+        }
       }
       if (container.membersAreExports || container.isClass) {
         memberTables += 1;
-        outsideOwnFiles += readTable(container, symbol.getExports(), seen, container.isClass);
+        const table = project.queries.exportsOf(symbol);
+        if (isAnswered(table)) {
+          outsideOwnFiles += readTable(container, table, seen, container.isClass);
+        } else {
+          unansweredOwners.add(container.owner);
+        }
       }
     }
     completeFromTree(container, seen);
@@ -919,6 +961,7 @@ export function inventory<Brand>(
     return undefined;
   }
 
+  const byId = new Map(building.map((record) => [positionKey(record.position), record]));
   const symbols = building
     .map(render)
     .sort((a, b) => byPosition(a.position, b.position) || (a.ref < b.ref ? -1 : 1));
@@ -932,9 +975,50 @@ export function inventory<Brand>(
     cost: { batches: 1, exportTables, memberTables },
     starReExports,
     outsideOwnFiles,
+    unanswered: symbols
+      .filter((symbol) => underUnanswered(byId.get(symbol.id), unansweredOwners))
+      .map((symbol) => symbol.id),
+    byName: namesOf(building),
   };
 }
 
+/** Whether one declaration is, or is declared under, a scope or container left unanswered. */
+function underUnanswered(record: Building | undefined, owners: ReadonlySet<Building>): boolean {
+  for (let at = record; at !== undefined; at = at.parent) {
+    if (owners.has(at)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/** Every declaration but a file, by each name a use may spell it with. */
+function namesOf(building: readonly Building[]): ReadonlyMap<string, readonly string[]> {
+  const byName = new Map<string, string[]>();
+  for (const record of building) {
+    if (record.kind === "file") {
+      continue;
+    }
+    const id = positionKey(record.position);
+    const names =
+      record.typeParameter === undefined
+        ? [record.component.text, record.localName]
+        : [record.typeParameter];
+    for (const name of new Set(names)) {
+      if (name === undefined) {
+        continue;
+      }
+      const ids = byName.get(name);
+      if (ids === undefined) {
+        byName.set(name, [id]);
+      } else if (!ids.includes(id)) {
+        ids.push(id);
+      }
+    }
+  }
+  return byName;
+}
+
 /** The chain of components that names one declaration, read from the module inward. */
 function chainOf(record: Building): readonly Component[] {
   return [...record.parentChain, record.component];
@@ -984,3 +1068,12 @@ function refOf(record: Building, chain: readonly Component[]): string {
     ...(record.typeParameter === undefined ? {} : { typeParameter: record.typeParameter }),
   });
 }
+
+/**
+ * Every declaration of an inventory other than a file, by each name a use may spell it
+ * with. It is how a reference the checker could not resolve is still counted, as a
+ * reference to every declaration that bears the name it spells.
+ */
+export function declarationsByName(held: Inventory): ReadonlyMap<string, readonly string[]> {
+  return held.byName;
+}