@cplieger/deadset-ts 7.0.0-dev.1 → 7.0.0-dev.3

package/src/intra-function-parts.ts

@@ -93,8 +93,17 @@ export interface PartFact {
   readonly used: boolean;
   /** Where the part is a parameter's name, what a function used as a value decides it by. */
   readonly parameter?: ParameterPlace;
+  /** Where the part is a result, whether its type has a `then` member, as a promise does. */
+  readonly thenable?: boolean;
 }
 
+/**
+ * What a call does with its value: uses it, discards it as a statement of its own or the
+ * operand of `void`, or awaits it as a statement, which sequences on a thenable value and
+ * discards any other.
+ */
+type CallUse = "used" | "discarded" | "awaited";
+
 /** What decides a parameter of a function used as a value: a caller may pass it more arguments. */
 interface ParameterPlace {
   /** Whether a parameter after this one, which is no binding-pattern name, is read. */
@@ -116,8 +125,8 @@ interface SignatureFact {
 export interface ProjectParts {
   readonly parts: readonly PartFact[];
   readonly signatures: readonly SignatureFact[];
-  /** Each name written as the callee of a call, by position, and whether the call's value is discarded. */
-  readonly calls: ReadonlyMap<string, boolean>;
+  /** Each name written as the callee of a call, by position, and what the call does with its value. */
+  readonly calls: ReadonlyMap<string, CallUse>;
   /** Each name an import or an export specifier writes, by position, which uses no value. */
   readonly specifiers: ReadonlySet<string>;
 }
@@ -165,16 +174,15 @@ function calleeName(call: CallExpression): Identifier | undefined {
   return isPropertyAccessExpression(callee) && isIdentifier(callee.name) ? callee.name : undefined;
 }
 
-/**
- * Whether a call's value is discarded: the call is a statement of its own, awaited as a
- * statement, or the operand of `void`.
- */
-function discarded(call: CallExpression): boolean {
+/** What a call does with its value. */
+function callUse(call: CallExpression): CallUse {
   const parent = outerParent(call);
   if (isExpressionStatement(parent) || isVoidExpression(parent)) {
-    return true;
+    return "discarded";
   }
-  return isAwaitExpression(parent) && isExpressionStatement(outerParent(parent));
+  return isAwaitExpression(parent) && isExpressionStatement(outerParent(parent))
+    ? "awaited"
+    : "used";
 }
 
 /** Whether one statement leaves its statement list on every path: the rest of the list never runs. */
@@ -473,7 +481,7 @@ export function projectParts<Brand>(
   const kinds = new Map(held.symbols.map((symbol) => [symbol.id, symbol.kind]));
   const parts: PartFact[] = [];
   const signatures: SignatureFact[] = [];
-  const calls = new Map<string, boolean>();
+  const calls = new Map<string, CallUse>();
   const specifiers = new Set<string>();
   const sites: { readonly file: SourceFile; readonly declared: Declared }[] = [];
   const contextual: ContextualParameter[] = [];
@@ -550,7 +558,7 @@ export function projectParts<Brand>(
       if (isCallExpression(node)) {
         const name = calleeName(node);
         if (name !== undefined) {
-          calls.set(position(name), discarded(node));
+          calls.set(position(name), callUse(node));
         }
       }
       if (isImportSpecifier(node) || isExportSpecifier(node)) {
@@ -1004,10 +1012,12 @@ function resultParts<Brand>(
   root: string,
   sites: readonly { readonly file: SourceFile; readonly declared: Declared }[],
   references: readonly Reference[],
-  calls: ReadonlyMap<string, boolean>,
+  calls: ReadonlyMap<string, CallUse>,
 ): PartFact[] {
   const discardedAt = new Set(
-    references.filter((one) => calls.get(positionKey(one.position)) === true).map((one) => one.to),
+    references
+      .filter((one) => (calls.get(positionKey(one.position)) ?? "used") !== "used")
+      .map((one) => one.to),
   );
   const found: PartFact[] = [];
   for (const { file, declared } of sites) {
@@ -1030,6 +1040,8 @@ function resultParts<Brand>(
       continue;
     }
     const at = signature.type ?? (node as { readonly name?: Node }).name ?? node;
+    const valued = project.queries.nonNullable(result);
+    const members = isAnswered(valued) ? project.queries.propertiesOf(valued) : UNANSWERED;
     found.push({
       code: UNUSED_RESULT,
       declaration: id,
@@ -1038,6 +1050,7 @@ function resultParts<Brand>(
       position: spanOf(file, root, at),
       message: "result is discarded at every call site",
       used: false,
+      thenable: !isAnswered(members) || members.some((member) => member.name === "then"),
     });
   }
   return found;
@@ -1077,7 +1090,7 @@ export function intraFunctionFacts(
     const known = parts.get(key);
     parts.set(key, known === undefined ? part : { ...known, used: known.used || part.used });
   }
-  const calls = new Map<string, boolean>();
+  const calls = new Map<string, CallUse>();
   const specifiers = new Set<string>();
   for (const one of projects) {
     for (const [at, value] of one.calls) {
@@ -1089,6 +1102,7 @@ export function intraFunctionFacts(
   }
   const valued = new Set<string>();
   const called = new Map<string, boolean>();
+  const awaited = new Set<string>();
   for (const reference of references) {
     if (reference.use === "decorator" || reference.use === "evaluation") {
       continue;
@@ -1096,7 +1110,10 @@ export function intraFunctionFacts(
     const at = positionKey(reference.position);
     const call = reference.consumer === undefined ? calls.get(at) : undefined;
     if (call !== undefined) {
-      called.set(reference.to, (called.get(reference.to) ?? true) && call);
+      called.set(reference.to, (called.get(reference.to) ?? true) && call !== "used");
+      if (call === "awaited") {
+        awaited.add(reference.to);
+      }
     } else if (reference.consumer !== undefined || !specifiers.has(at)) {
       valued.add(reference.to);
     }
@@ -1115,8 +1132,16 @@ export function intraFunctionFacts(
       .map((one) => one.declaration)
       .filter((id) => !fixed.has(id) && !exempted.has(id) && valued.has(id)),
   );
+  // Awaiting a thenable result sequences on it, so a call that awaits one uses it.
+  const sequenced = new Set(
+    [...parts.values()]
+      .filter((part) => part.thenable === true && awaited.has(part.declaration))
+      .map((part) => part.declaration),
+  );
   const discardedEverywhere = new Set(
-    [...called].filter(([id, all]) => all && !valued.has(id)).map(([id]) => id),
+    [...called]
+      .filter(([id, all]) => all && !valued.has(id) && !sequenced.has(id))
+      .map(([id]) => id),
   );
   return { parts: [...parts.values()], free, freeButValued, discardedEverywhere };
 }

package/src/inventory.ts

@@ -139,8 +139,6 @@ export interface InventoryCost {
 
 /** One project's declarations, in position order, and what reading them cost. */
 export interface Inventory {
-  /** The compiler configuration the project was opened from. */
-  readonly configFile: string;
   readonly symbols: readonly InventorySymbol[];
   /**
    * Each declaring node's {@link nodeKey} mapped to the identifier of the declaration
@@ -154,20 +152,6 @@ export interface Inventory {
    */
   readonly declarations: ReadonlyMap<string, string>;
   readonly cost: InventoryCost;
-  /**
-   * The module specifiers of the bare star re-exports the project's files carry, in
-   * the order they were read. A bare star re-export declares nothing here: the names
-   * it carries forward are the declarations of the module it names, so it is a
-   * reference to that module and not a declaration of this one.
-   */
-  readonly starReExports: readonly string[];
-  /**
-   * The number of member declarations that were left out because the file declaring
-   * them is not one of the target's own files. Such a declaration belongs to another
-   * program, so the target's inventory does not name it, and the count is reported so
-   * 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
@@ -181,6 +165,12 @@ export interface Inventory {
   readonly byName: ReadonlyMap<string, readonly string[]>;
   /** Each `declare module` declaration whose name is a string literal, by id, to that name. */
   readonly modules: ReadonlyMap<string, string>;
+  /**
+   * Each enum member's dependents, by id: the later members of its declaration with no
+   * initializer, up to the first one with an initializer, whose values its deletion moves.
+   * A member with none has no entry.
+   */
+  readonly dependents: ReadonlyMap<string, readonly string[]>;
 }
 
 /** A declaration under construction, before its reference is rendered. */
@@ -534,9 +524,7 @@ export function inventory<Brand>(
   const byNode = new Map<string, Building>();
   const exportScopes: ExportScope[] = [];
   const containers: Container[] = [];
-  const starReExports: string[] = [];
   const modules: (readonly [Building, string])[] = [];
-  let outsideOwnFiles = 0;
 
   const keep = (record: Building): Building => {
     building.push(record);
@@ -782,14 +770,10 @@ export function inventory<Brand>(
     }
   }
 
-  function walkExportDeclaration(
-    node: { readonly exportClause?: Node; readonly moduleSpecifier?: Node },
-    owner: Building,
-  ): void {
+  function walkExportDeclaration(node: { readonly exportClause?: Node }, owner: Building): void {
     const clause = node.exportClause;
+    // A bare star re-export declares nothing: the names it carries are the named module's.
     if (clause === undefined) {
-      const specifier = node.moduleSpecifier;
-      starReExports.push(specifier === undefined ? "" : literalTextOf(specifier));
       return;
     }
     if (isNamespaceExport(clause)) {
@@ -876,7 +860,7 @@ export function inventory<Brand>(
         memberTables += 1;
         const table = project.queries.membersOf(symbol);
         if (isAnswered(table)) {
-          outsideOwnFiles += readTable(container, table, seen, false);
+          readTable(container, table, seen, false);
         } else {
           unansweredOwners.add(container.owner);
         }
@@ -885,7 +869,7 @@ export function inventory<Brand>(
         memberTables += 1;
         const table = project.queries.exportsOf(symbol);
         if (isAnswered(table)) {
-          outsideOwnFiles += readTable(container, table, seen, container.isClass);
+          readTable(container, table, seen, container.isClass);
         } else {
           unansweredOwners.add(container.owner);
         }
@@ -905,8 +889,7 @@ export function inventory<Brand>(
     table: ReadonlyMap<string, TSSymbol>,
     seen: Map<string, Building>,
     areStatic: boolean,
-  ): number {
-    let outside = 0;
+  ): void {
     for (const [, member] of table) {
       const declarations = member.declarations
         .map((handle) => project.declarationAt(handle))
@@ -916,7 +899,6 @@ export function inventory<Brand>(
       }
       const own = declarations.filter((held) => ownFiles.has(held.node.getSourceFile().fileName));
       if (own.length === 0) {
-        outside += declarations.length;
         continue;
       }
       // A merged symbol's table holds the members every one of its declarations writes,
@@ -925,7 +907,6 @@ export function inventory<Brand>(
         keepMember(container, held.node, seen, areStatic);
       }
     }
-    return outside;
   }
 
   /**
@@ -1011,25 +992,48 @@ export function inventory<Brand>(
     return undefined;
   }
 
+  const dependents = new Map<string, readonly string[]>();
+  for (const container of containers.filter((one) => one.memberKind === "enum-member")) {
+    const ids = container.members.map((member) => {
+      const record = byNode.get(nodeKey(member.getSourceFile(), member));
+      return record === undefined ? undefined : positionKey(record.position);
+    });
+    container.members.forEach((_member, index) => {
+      const after: string[] = [];
+      for (let next = index + 1; next < container.members.length; next += 1) {
+        const member = container.members[next];
+        if (member === undefined || !isEnumMember(member) || member.initializer !== undefined) {
+          break;
+        }
+        const id = ids[next];
+        if (id !== undefined) {
+          after.push(id);
+        }
+      }
+      const id = ids[index];
+      if (id !== undefined && after.length > 0) {
+        dependents.set(id, after);
+      }
+    });
+  }
+
   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));
 
   return {
-    configFile: project.configFile,
     symbols,
     declarations: new Map(
       [...byNode].map(([key, record]) => [key, positionKey(record.position)] as const),
     ),
     cost: { batches: 1, exportTables, memberTables },
-    starReExports,
-    outsideOwnFiles,
     unanswered: symbols
       .filter((symbol) => underUnanswered(byId.get(symbol.id), unansweredOwners))
       .map((symbol) => symbol.id),
     byName: namesOf(building),
     modules: new Map(modules.map(([record, name]) => [positionKey(record.position), name])),
+    dependents,
   };
 }
 

package/src/json-document.ts

@@ -100,7 +100,7 @@ class Walk {
 }
 
 /** What a walk of one document found. */
-export interface DocumentWalk {
+interface DocumentWalk {
   /** The offset of the brace opening each object of the document's array member, in order. */
   readonly opened: readonly number[];
   /** The first member one object writes twice, at any depth, as the offset of its name. */

package/src/keyof-comparisons.ts

@@ -0,0 +1,211 @@
+/**
+ * The members a comparison with a key reads: where one operand of `===`, `!==`, `==` or
+ * `!=`, or a `switch` expression a `case` label is compared with, is declared with a type
+ * that holds `keyof X`, the literal the other side has names the member of `X` under that
+ * key, because deleting the member makes the comparison a type error.
+ */
+
+import {
+  isBinaryExpression,
+  isCaseClause,
+  isElementAccessExpression,
+  isIdentifier,
+  isParenthesizedExpression,
+  isPropertyAccessExpression,
+  isSwitchStatement,
+  isTypeOperatorNode,
+  SyntaxKind,
+  type Expression,
+  type Node,
+  type SourceFile,
+  type TypeNode,
+} from "@typescript/native/unstable/ast";
+import { SymbolFlags, type Type } from "@typescript/native/unstable/sync";
+import type { AliasChains } from "./alias-chain.ts";
+import { nodeKey, type Inventory } from "./inventory.ts";
+import { renderPosition } from "./position.ts";
+import { UNANSWERED } from "./query.ts";
+import type { Reference } from "./references.ts";
+import type { ProjectView } from "./session.ts";
+
+/** The operators that compare their operands for equality. */
+const EQUALITIES: ReadonlySet<SyntaxKind> = new Set([
+  SyntaxKind.EqualsEqualsEqualsToken,
+  SyntaxKind.ExclamationEqualsEqualsToken,
+  SyntaxKind.EqualsEqualsToken,
+  SyntaxKind.ExclamationEqualsToken,
+]);
+
+/** One comparison of a keyed operand with another, and the declaration that writes it. */
+interface Comparison {
+  readonly file: SourceFile;
+  readonly from: string;
+  readonly keyed: Expression;
+  readonly other: Expression;
+}
+
+function unwrapped(node: Expression): Expression {
+  return isParenthesizedExpression(node) ? unwrapped(node.expression) : node;
+}
+
+/** The name node an operand's symbol is read at: an identifier, or a property access's name. */
+function nameOf(node: Expression): Node | undefined {
+  const at = unwrapped(node);
+  if (isIdentifier(at)) {
+    return at;
+  }
+  return isPropertyAccessExpression(at) ? at.name : undefined;
+}
+
+/** The operand of each `keyof` one type node holds, through every type node it is built of. */
+function keyofOperands(node: TypeNode): readonly TypeNode[] {
+  const found: TypeNode[] = [];
+  const visit = (at: Node): void => {
+    if (isTypeOperatorNode(at) && at.operator === SyntaxKind.KeyOfKeyword) {
+      found.push(at.type);
+      return;
+    }
+    at.forEachChild(visit);
+  };
+  visit(node);
+  return found;
+}
+
+/** The names a literal type or a union of them spells, or none. */
+function literalNames(parts: readonly Type[]): readonly string[] {
+  const names: string[] = [];
+  for (const part of parts) {
+    if (part.isStringLiteralType()) {
+      names.push(part.value);
+    } else if (part.isNumberLiteralType()) {
+      names.push(String(part.value));
+    } else {
+      return [];
+    }
+  }
+  return names;
+}
+
+/**
+ * The references the key comparisons of one project's own files make to the members their
+ * literal side names, each made by the declaration holding the comparison.
+ */
+export function keyofComparisonReferences<Brand>(
+  project: ProjectView<Brand>,
+  held: Inventory,
+  chains: AliasChains,
+  root: string,
+  testFiles: ReadonlySet<string>,
+): readonly Reference[] {
+  const queries = project.queries;
+  const comparisons: Comparison[] = [];
+  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 (isBinaryExpression(node) && EQUALITIES.has(node.operatorToken.kind)) {
+        comparisons.push({ file, from: holder, keyed: node.left, other: node.right });
+        comparisons.push({ file, from: holder, keyed: node.right, other: node.left });
+      }
+      if (isSwitchStatement(node)) {
+        for (const clause of node.caseBlock.clauses) {
+          if (isCaseClause(clause)) {
+            comparisons.push({
+              file,
+              from: holder,
+              keyed: node.expression,
+              other: clause.expression,
+            });
+          }
+        }
+      }
+      node.forEachChild((child) => {
+        visit(child, holder);
+      });
+    };
+    file.forEachChild((child) => {
+      visit(child, fileId);
+    });
+  }
+  const named = comparisons.flatMap((one) => {
+    const name = nameOf(one.keyed);
+    return name === undefined || isElementAccessExpression(unwrapped(one.other))
+      ? []
+      : [{ ...one, name }];
+  });
+  if (named.length === 0) {
+    return [];
+  }
+
+  // The operand's own declaration states the key type, which the checker resolves to
+  // the literals it admits and so no longer names the type the key indexes.
+  const symbols = queries.symbolsAt(named.map((one) => one.name));
+  const keyed = named.flatMap((one, at) => {
+    const asked = symbols[at];
+    const symbol =
+      asked === UNANSWERED || asked === undefined || (asked.flags & SymbolFlags.Alias) === 0
+        ? asked
+        : queries.aliased(asked);
+    if (symbol === UNANSWERED || symbol === undefined) {
+      return [];
+    }
+    const operands = symbol.declarations.flatMap((handle) => {
+      const declared = (
+        project.declarationAt(handle)?.node as { readonly type?: TypeNode } | undefined
+      )?.type;
+      return declared === undefined ? [] : keyofOperands(declared);
+    });
+    return operands.length === 0 ? [] : [{ ...one, operands }];
+  });
+  if (keyed.length === 0) {
+    return [];
+  }
+  const nodes = keyed.flatMap((one) => [one.other, ...one.operands]);
+  const types = queries.typesAt(nodes);
+  const typeOf = new Map<Node, Type>();
+  nodes.forEach((node, at) => {
+    const type = types[at];
+    if (type !== UNANSWERED && type !== undefined) {
+      typeOf.set(node, type);
+    }
+  });
+  const partsOf = (type: Type): readonly Type[] => {
+    const parts = queries.constituents(type);
+    return parts === UNANSWERED ? [type] : parts;
+  };
+
+  const found: Reference[] = [];
+  for (const one of keyed) {
+    const literal = typeOf.get(one.other);
+    const names = literal === undefined ? [] : literalNames(partsOf(literal));
+    if (names.length === 0) {
+      continue;
+    }
+    const position = renderPosition(one.file, root, one.other.getStart());
+    for (const operand of one.operands) {
+      const object = typeOf.get(operand);
+      for (const part of object === undefined ? [] : partsOf(object)) {
+        const properties = queries.propertiesOf(part);
+        for (const property of properties === UNANSWERED ? [] : properties) {
+          if (!names.includes(property.name)) {
+            continue;
+          }
+          for (const to of chains.declarationsOf(property)) {
+            found.push({
+              from: one.from,
+              to,
+              position,
+              use: "read",
+              resolution: "keyed",
+              test: testFiles.has(position.path),
+            });
+          }
+        }
+      }
+    }
+  }
+  return found;
+}