@cplieger/deadset-ts 3.13.0 → 4.0.1

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) };
 }

package/src/destructuring.ts

@@ -25,6 +25,7 @@ import {
   type Node,
 } from "@typescript/native/unstable/ast";
 import { TypeFlags, type Symbol as TSSymbol, type Type } from "@typescript/native/unstable/sync";
+import { isAnswered, UNANSWERED, type Answer } from "./query.ts";
 import type { ProjectView } from "./session.ts";
 
 /** One property one object pattern reads. */
@@ -212,97 +213,102 @@ interface DestructuringCost {
 interface Destructuring {
   /**
    * The property symbol each read names, in the order given, `undefined` where the
-   * destructured value's type declares no property of that name or is not known.
+   * destructured value's type declares no property of that name or is not known, and
+   * {@link UNANSWERED} where a question about the value's type went unanswered.
    */
-  resolve(reads: readonly PropertyRead[]): readonly (TSSymbol | undefined)[];
+  resolve(reads: readonly PropertyRead[]): readonly Answer<TSSymbol | undefined>[];
   readonly cost: DestructuringCost;
 }
 
+/** A type along a destructuring, or the mark that a question about it went unanswered. */
+type Found = Answer<Type | undefined>;
+
 /**
  * The resolution over one project, its batches capped at `cap`. Property tables are
  * read once per type for the whole project, since one type is destructured in many
  * places and a table answers every name of it.
  */
 export function destructuring<Brand>(project: ProjectView<Brand>, cap: number): Destructuring {
-  const checker = project.checker;
-  const tables = new Map<number, ReadonlyMap<string, TSSymbol>>();
+  const queries = project.queries;
+  const tables = new Map<number, Answer<ReadonlyMap<string, TSSymbol>>>();
   let patternBatches = 0;
   let patternLookups = 0;
 
-  const typesAt = (nodes: readonly Node[]): (Type | undefined)[] => {
-    const types: (Type | undefined)[] = [];
-    for (let from = 0; from < nodes.length; from += cap) {
-      types.push(...checker.getTypeAtLocation(nodes.slice(from, from + cap)));
-      patternBatches += 1;
-    }
-    return types;
-  };
-
-  const tableOf = (type: Type): ReadonlyMap<string, TSSymbol> => {
+  const tableOf = (type: Type): Answer<ReadonlyMap<string, TSSymbol>> => {
     const known = tables.get(type.id);
     if (known !== undefined) {
       return known;
     }
-    const table = new Map<string, TSSymbol>();
+    let table: Answer<ReadonlyMap<string, TSSymbol>> = new Map<string, TSSymbol>();
     if ((type.flags & TypeFlags.AnyOrUnknown) === 0) {
       patternLookups += 1;
-      for (const property of checker.getPropertiesOfType(type)) {
-        table.set(property.name, property);
-      }
+      const properties = queries.propertiesOf(type);
+      table = isAnswered(properties)
+        ? new Map(properties.map((property) => [property.name, property]))
+        : UNANSWERED;
     }
     tables.set(type.id, table);
     return table;
   };
 
-  const definedOf = (type: Type): Type | undefined => {
+  const definedOf = (type: Type): Found => {
     if ((type.flags & TypeFlags.Union) === 0) {
       return type;
     }
     patternLookups += 1;
-    return checker.getNonNullableType(type);
+    return queries.nonNullable(type);
   };
 
   /**
    * The type one element of an array or tuple value has: a tuple's element at `index`,
    * an array's element type at any index, and `undefined` for a tuple iterated whole.
    */
-  const elementOf = (type: Type, index: number | undefined): Type | undefined => {
+  const elementOf = (type: Type, index: number | undefined): Found => {
     if (!type.isTypeReference()) {
       return undefined;
     }
-    patternLookups += 1;
-    if (checker.isTupleType(type)) {
+    if (type.isTupleType()) {
       if (index === undefined) {
         return undefined;
       }
       patternLookups += 1;
-      return checker.getTypeArguments(type)[index];
+      const elements = queries.typeArguments(type);
+      return isAnswered(elements) ? elements[index] : UNANSWERED;
     }
     patternLookups += 1;
-    if (!checker.isArrayType(type)) {
+    const array = queries.isArray(type);
+    if (!isAnswered(array)) {
+      return UNANSWERED;
+    }
+    if (!array) {
       return undefined;
     }
     patternLookups += 1;
-    return checker.getTypeArguments(type)[0];
+    const elements = queries.typeArguments(type);
+    return isAnswered(elements) ? elements[0] : UNANSWERED;
   };
 
-  const step = (type: Type, next: Step): Type | undefined => {
+  const step = (type: Type, next: Step): Found => {
     const defined = definedOf(type);
-    if (defined === undefined) {
-      return undefined;
+    if (defined === undefined || defined === UNANSWERED) {
+      return defined;
     }
     if (next.kind === "property") {
-      const property = tableOf(defined).get(next.name);
+      const table = tableOf(defined);
+      if (!isAnswered(table)) {
+        return UNANSWERED;
+      }
+      const property = table.get(next.name);
       if (property === undefined) {
         return undefined;
       }
       patternLookups += 1;
-      return checker.getTypeOfSymbol(property);
+      return queries.typeOfSymbol(property);
     }
     return elementOf(defined, next.kind === "element" ? next.index : undefined);
   };
 
-  const resolve = (reads: readonly PropertyRead[]): readonly (TSSymbol | undefined)[] => {
+  const resolve = (reads: readonly PropertyRead[]): readonly Answer<TSSymbol | undefined>[] => {
     const patterns = [...new Set(reads.map((read) => read.pattern))];
     const sources = new Map<Node, Source | undefined>();
     const asking = new Set<Node>();
@@ -317,15 +323,16 @@ export function destructuring<Brand>(project: ProjectView<Brand>, cap: number):
         asking.add(source.expression);
       }
     }
-    const answered = new Map<Node, Type>();
     const asked = [...asking];
-    typesAt(asked).forEach((type, index) => {
+    patternBatches += Math.ceil(asked.length / cap);
+    const answered = new Map<Node, Found>();
+    queries.typesAt(asked, cap).forEach((type, index) => {
       const node = asked[index];
-      if (type !== undefined && node !== undefined) {
+      if (node !== undefined) {
         answered.set(node, type);
       }
     });
-    const patternTypes = new Map<Node, Type | undefined>();
+    const patternTypes = new Map<Node, Found>();
     for (const pattern of patterns) {
       const source = sources.get(pattern);
       if (source === undefined) {
@@ -334,13 +341,17 @@ export function destructuring<Brand>(project: ProjectView<Brand>, cap: number):
       }
       let type = answered.get(source.expression);
       for (const next of source.steps) {
-        type = type === undefined ? undefined : step(type, next);
+        type = type === undefined || type === UNANSWERED ? type : step(type, next);
       }
-      patternTypes.set(pattern, type === undefined ? undefined : definedOf(type));
+      patternTypes.set(pattern, type === undefined || type === UNANSWERED ? type : definedOf(type));
     }
     return reads.map((read) => {
       const type = patternTypes.get(read.pattern);
-      return type === undefined ? undefined : tableOf(type).get(read.name);
+      if (type === undefined || type === UNANSWERED) {
+        return type;
+      }
+      const table = tableOf(type);
+      return isAnswered(table) ? table.get(read.name) : UNANSWERED;
     });
   };