@cplieger/deadset-ts 3.3.1 → 3.5.0

package/src/calls.ts

@@ -0,0 +1,224 @@
+/**
+ * The calls and decorators of one project that the configured classes read: what each
+ * callee resolves to, and which of the target's classes a call passes or a decorator
+ * is attached to. A class is passed as an argument, or as an element of an array
+ * literal or a property value of an object literal written as one, at any depth, and a
+ * decorator written as a call is a call.
+ */
+
+import {
+  isArrayLiteralExpression,
+  isCallExpression,
+  isClassDeclaration,
+  isDecorator,
+  isIdentifier,
+  isObjectLiteralExpression,
+  isParenthesizedExpression,
+  isPropertyAccessExpression,
+  isPropertyAssignment,
+  isShorthandPropertyAssignment,
+  isSpreadElement,
+  type CallExpression,
+  type Decorator,
+  type Expression,
+  type Node,
+} from "@typescript/native/unstable/ast";
+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 type { ProjectView } from "./session.ts";
+
+/** One value written where a call passes it, and the node its declaration is resolved from. */
+export interface PassedValue {
+  /** Where the value is written, which is where a record of it sits. */
+  readonly site: Node;
+  /** The name the value is resolved through, or the shorthand assignment that holds it. */
+  readonly name: Node;
+  readonly shorthand: boolean;
+}
+
+/** One class of the target a call passes or a decorator is attached to, and where. */
+export interface ClassUse {
+  /** The inventory's identifier of the class. */
+  readonly id: string;
+  readonly site: Node;
+}
+
+/** The name node a callee or a decorator expression resolves through, where it has one. */
+export function calleeName(expression: Expression): Node | undefined {
+  if (isParenthesizedExpression(expression)) {
+    return calleeName(expression.expression);
+  }
+  if (isPropertyAccessExpression(expression)) {
+    return expression.name;
+  }
+  return isIdentifier(expression) ? expression : undefined;
+}
+
+/** The callee one decorator names: its expression, or the callee of the call it writes. */
+export function decoratorCallee(decorator: Decorator): Node | undefined {
+  const expression = decorator.expression;
+  return calleeName(isCallExpression(expression) ? expression.expression : expression);
+}
+
+/** How one decorator is spelled in a record: its expression, without a call's arguments. */
+export function spelledDecorator(decorator: Decorator): string {
+  const expression = decorator.expression;
+  const named = isCallExpression(expression) ? expression.expression : expression;
+  return `@${named.getText().replace(/\s+/gu, "")}`;
+}
+
+/** The decorators written on one declaration. */
+export function decoratorsOf(node: Node): readonly Decorator[] {
+  return ((node as { readonly modifiers?: readonly Node[] }).modifiers ?? []).filter(isDecorator);
+}
+
+/**
+ * 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.
+ */
+export function resolvedTargets<Brand>(
+  project: ProjectView<Brand>,
+  nodes: readonly Node[],
+): 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];
+      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);
+          followed.set(symbol.id, aliased.declarations.length === 0 ? undefined : aliased);
+        }
+        target = followed.get(symbol.id);
+      }
+      if (target !== undefined) {
+        targets.set(node, target);
+      }
+    });
+  }
+  return targets;
+}
+
+/** The values one expression passes: itself, or what an array or object literal holds. */
+function passedIn(expression: Expression, found: PassedValue[]): void {
+  if (isParenthesizedExpression(expression)) {
+    passedIn(expression.expression, found);
+    return;
+  }
+  if (isArrayLiteralExpression(expression)) {
+    for (const element of expression.elements) {
+      passedIn(isSpreadElement(element) ? element.expression : element, found);
+    }
+    return;
+  }
+  if (isObjectLiteralExpression(expression)) {
+    for (const property of expression.properties) {
+      if (isPropertyAssignment(property)) {
+        passedIn(property.initializer, found);
+      } else if (isShorthandPropertyAssignment(property)) {
+        found.push({ site: property.name, name: property, shorthand: true });
+      }
+    }
+    return;
+  }
+  const name = calleeName(expression);
+  if (name !== undefined) {
+    found.push({ site: expression, name, shorthand: false });
+  }
+}
+
+/** The values one argument passes, a spread argument's included. */
+export function valuesPassed(argument: Expression): readonly PassedValue[] {
+  const found: PassedValue[] = [];
+  passedIn(isSpreadElement(argument) ? argument.expression : argument, found);
+  return found;
+}
+
+/**
+ * The classes of the target each call passes, by the call. A value that names no
+ * class of the target, a class of another program included, passes nothing here.
+ */
+export function classesPassed<Brand>(
+  project: ProjectView<Brand>,
+  held: Inventory,
+  chains: AliasChains,
+  calls: readonly CallExpression[],
+): ReadonlyMap<CallExpression, readonly ClassUse[]> {
+  const passed = new Map(
+    calls.map((call) => [call, call.arguments.flatMap((argument) => valuesPassed(argument))]),
+  );
+  const all = [...passed.values()].flat();
+  const targets = resolvedTargets(
+    project,
+    all.filter((value) => !value.shorthand).map((value) => value.name),
+  );
+  const classes = new Set(
+    held.symbols.filter((symbol) => symbol.kind === "class").map((symbol) => symbol.id),
+  );
+  const classesOf = (value: PassedValue): readonly string[] => {
+    const symbol = value.shorthand
+      ? project.shorthandValueAt(project.handle(value.name))
+      : targets.get(value.name);
+    return symbol === undefined
+      ? []
+      : chains.declarationsOf(symbol).filter((id) => classes.has(id));
+  };
+  return new Map(
+    [...passed].map(([call, values]) => [
+      call,
+      values.flatMap((value) => classesOf(value).map((id) => ({ id, site: value.site }))),
+    ]),
+  );
+}
+
+/** One class declaration of the target and the decorators written on it. */
+export interface DecoratedClass {
+  readonly id: string;
+  readonly decorators: readonly Decorator[];
+}
+
+/** Every class declaration of the target that carries a decorator. */
+export function decoratedClasses<Brand>(
+  project: ProjectView<Brand>,
+  held: Inventory,
+): readonly DecoratedClass[] {
+  const found: DecoratedClass[] = [];
+  for (const file of project.ownSourceFiles()) {
+    const visit = (node: Node): void => {
+      if (isClassDeclaration(node)) {
+        const id = held.declarations.get(nodeKey(file, node));
+        const decorators = decoratorsOf(node);
+        if (id !== undefined && decorators.length > 0) {
+          found.push({ id, decorators });
+        }
+      }
+      node.forEachChild(visit);
+    };
+    file.forEachChild(visit);
+  }
+  return found;
+}
+
+/** Every call expression of the project's own files, decorators written as calls included. */
+export function callsOf<Brand>(project: ProjectView<Brand>): readonly CallExpression[] {
+  const found: CallExpression[] = [];
+  for (const file of project.ownSourceFiles()) {
+    const visit = (node: Node): void => {
+      if (isCallExpression(node)) {
+        found.push(node);
+      }
+      node.forEachChild(visit);
+    };
+    file.forEachChild(visit);
+  }
+  return found;
+}

package/src/class-members.ts

@@ -0,0 +1,136 @@
+/**
+ * The members a value of one of the target's classes carries, as the checker answers
+ * for the class's type, so a member a base class declares is a member of every class
+ * that extends it and a member a subclass overrides is the subclass's own.
+ */
+
+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 type { ProjectView } from "./session.ts";
+
+/** One member of a class's value that the target declares. */
+export interface ClassMember {
+  /** The inventory's identifier of the declaration. */
+  readonly id: string;
+  /** The declaring node, whose syntax says whether it is a property, an accessor or a method. */
+  readonly node: Node;
+  /** The member's symbol flags, as the checker reads it on this class. */
+  readonly flags: SymbolFlags;
+}
+
+/** Which side of a class a reading asks for: its instances, or the class itself. */
+export type ClassSide = "instance" | "static";
+
+/** The name node of each class declaration of the target, by the class's identifier. */
+export function classNames<Brand>(
+  project: ProjectView<Brand>,
+  held: Inventory,
+): ReadonlyMap<string, Node> {
+  const names = new Map<string, Node>();
+  for (const file of project.ownSourceFiles()) {
+    const visit = (node: Node): void => {
+      if ((isClassDeclaration(node) || isClassExpression(node)) && node.name !== undefined) {
+        const id = held.declarations.get(nodeKey(file, node));
+        if (id !== undefined) {
+          names.set(id, node.name);
+        }
+      }
+      node.forEachChild(visit);
+    };
+    file.forEachChild(visit);
+  }
+  return names;
+}
+
+/** The types of a batch of nodes, asked in capped batches. */
+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;
+}
+
+/**
+ * The type one side of each class is: the instance type at the class's name, or the
+ * type of the class's own symbol, which is its constructor's.
+ */
+function sideTypes<Brand>(
+  project: ProjectView<Brand>,
+  nodes: readonly Node[],
+  side: ClassSide,
+): (Type | undefined)[] {
+  if (side === "instance") {
+    return typesAt(project, nodes);
+  }
+  const symbols = project.symbolsAt(nodes.map((node) => project.handle(node)));
+  const present = symbols.filter((symbol): symbol is TSSymbol => symbol !== undefined);
+  const types = present.length === 0 ? [] : project.checker.getTypeOfSymbol(present);
+  let next = 0;
+  return symbols.map((symbol) => (symbol === undefined ? undefined : types[next++]));
+}
+
+/**
+ * The members one side of each class carries that the target declares, by the class.
+ * A member declared in a file outside the project's own, and the `prototype` a class
+ * carries on its static side, are not declarations of the target and are left out.
+ */
+export function classMembers<Brand>(
+  project: ProjectView<Brand>,
+  held: Inventory,
+  classIds: ReadonlySet<string>,
+  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 types = sideTypes(
+    project,
+    named.map(([, node]) => node),
+    side,
+  );
+  const members = new Map<string, readonly ClassMember[]>();
+  named.forEach(([id], index) => {
+    const type = types[index];
+    if (type === undefined) {
+      return;
+    }
+    const found: ClassMember[] = [];
+    for (const property of project.checker.getPropertiesOfType(type)) {
+      for (const handle of property.declarations) {
+        if (!own.has(handle.path)) {
+          continue;
+        }
+        const node = project.declarationAt(handle)?.node;
+        const declared =
+          node === undefined
+            ? undefined
+            : held.declarations.get(nodeKey(node.getSourceFile(), node));
+        if (node !== undefined && declared !== undefined) {
+          found.push({ id: declared, node, flags: property.flags });
+        }
+      }
+    }
+    members.set(id, found);
+  });
+  return members;
+}
+
+/**
+ * The last component of one member's stable reference, `:static` included, which is
+ * how a configuration names a member; undefined for a declaration that is no member.
+ */
+export function memberComponent(
+  symbol: InventorySymbol,
+  byId: ReadonlyMap<string, InventorySymbol>,
+): string | undefined {
+  const parent = byId.get(symbol.parent);
+  if (parent === undefined || !symbol.ref.startsWith(`${parent.ref}.`)) {
+    return undefined;
+  }
+  return symbol.ref.slice(parent.ref.length + 1);
+}

package/src/components.ts

@@ -1,7 +1,7 @@
 /**
- * The dead components of one graph: the strongly connected components of the subgraph
- * the dead declarations induce, ordered so a report is worked from the top down, each
- * with the root members a deletion starts at and what falls with it.
+ * The dead components of one graph. A component is a set of dead declarations one
+ * deletion removes together: its root members, which are where the deletion starts,
+ * and every dead declaration that falls with them, being dead only through them.
  */
 
 import type { Cascade } from "./config.ts";
@@ -17,25 +17,22 @@ const ID_DIGITS = 4;
 /** The index of a declaration the component walk has not reached. */
 const UNVISITED = -1;
 
-/** One dead component and its place in the acyclic graph over the components. */
+/** One dead component. */
 export interface Component {
   /** The analyzer's name, a solidus, and `c-` followed by the component's place in the order. */
   readonly id: string;
-  /** The component's declarations, by site. A dead member of a dead container is one of them. */
-  readonly members: readonly string[];
   /**
-   * The members no other dead component references and whose container is not dead,
-   * which are where a deletion starts. A cycle has as many as it has members no dead
-   * component outside it references.
+   * The component's declarations by site: its root members and every dead declaration
+   * that falls with them. A dead member of a dead container is one of them.
    */
-  readonly roots: readonly string[];
+  readonly members: readonly string[];
   /**
-   * What one deletion of the component removes: its members, and every dead declaration
-   * only this component reaches. A dead declaration two components both reach falls with
-   * neither and is counted by its own component.
+   * The root members, by site. A root member is a member of a cycle no dead declaration
+   * outside the cycle references, whose container is not dead; every member of such a
+   * cycle with a live container is one, so a component has at least one.
    */
-  readonly falls: readonly string[];
-  /** The source lines the deletion removes: the distinct lines {@link Component.falls} spans. */
+  readonly roots: readonly string[];
+  /** The source lines one deletion of the component removes: the distinct lines its members span. */
   readonly deletableLines: number;
 }
 
@@ -48,22 +45,22 @@ export interface Listing {
   readonly deletableLines: number;
 }
 
-/** What a report carries for one component: its roots and what falls, and its members in full. */
+/** What a report carries for one component: its roots and counts, and its members in full. */
 export function listing(component: Component, cascade: Cascade): Listing {
   return {
     roots: component.roots,
     members: cascade === "full" ? component.members : [],
-    symbolCount: component.falls.length,
+    symbolCount: component.members.length,
     deletableLines: component.deletableLines,
   };
 }
 
 /**
- * Groups the declarations `dead` marks into components and orders them so each precedes
- * every component it reaches, two that neither reaches ordered by their first member's
- * site. `dead` and `testOfDeadCode` hold one flag per declaration of the graph; the dead
- * set arrives rather than being read from a sweep, so a set several sweeps intersect is
- * grouped over this graph's edges the same way.
+ * Groups the declarations `dead` marks into components, ordered by their first member's
+ * site; `dead` and `testOfDeadCode` hold one flag per declaration of the graph. Root
+ * members sit on the cycles no other cycle references. A cycle two roots both reach is
+ * dead only through both, so a component is a weakly connected part of the dead
+ * subgraph: no dead declaration of one references a declaration of another.
  */
 export function componentsOf(
   graph: Graph,
@@ -75,26 +72,22 @@ export function componentsOf(
     return [];
   }
   const { componentOf, members } = connected(adjacent);
-  const { edges, into } = condense(adjacent, componentOf, members.length);
-  const falls = fallSets(edges, members, into);
-  const outsideReference = externallyReferenced(adjacent, componentOf);
+  const referenced = referencedCycles(adjacent, componentOf, members.length);
+  const groups = joined(adjacent);
   const idOf = (position: number): string => graph.symbols[at[position] ?? 0]?.id ?? "";
 
-  return order(edges, members).map((group, place) => {
-    const own = members[group] ?? [];
-    const roots = own.filter((position) => {
-      // A dead member of a dead container is never a root: the container is where the
-      // deletion starts and the member falls with it.
+  return groups.map((group, place) => {
+    const roots = group.filter((position) => {
+      // A dead member's dead container is on the member's own cycle, and the container
+      // is where the deletion starts.
       const container = graph.parent[at[position] ?? 0] ?? OUTSIDE;
-      return outsideReference[position] !== true && dead[container] !== true;
+      return referenced[componentOf[position] ?? 0] !== true && dead[container] !== true;
     });
-    const fallen = falls[group] ?? [];
     return {
       id: `${ANALYZER}/c-${String(place + 1).padStart(ID_DIGITS, "0")}`,
-      members: own.map(idOf),
+      members: group.map(idOf),
       roots: roots.map(idOf),
-      falls: fallen.map(idOf),
-      deletableLines: linesSpanned(fallen.map((position) => graph.symbols[at[position] ?? 0])),
+      deletableLines: linesSpanned(group.map((position) => graph.symbols[at[position] ?? 0])),
     };
   });
 }
@@ -185,10 +178,9 @@ interface Frame {
 }
 
 /**
- * Each declaration's component and each component's members by site, by Tarjan's
+ * Each declaration's cycle and each cycle's members by site, by Tarjan's
  * algorithm in one pass. The walk keeps its own stack of frames, so a chain of any length
- * is walked without growing the call stack. Components are closed in an order in which
- * each follows every component it reaches.
+ * is walked without growing the call stack.
  */
 function connected(adjacent: readonly (readonly number[])[]): {
   readonly componentOf: readonly number[];
@@ -257,45 +249,18 @@ function connected(adjacent: readonly (readonly number[])[]): {
   return { componentOf, members };
 }
 
-/**
- * Per component, the components it reaches in one step, and how many components reach
- * it, each pair counted once. An edge inside a component is not an edge between two, so
- * the result is acyclic.
- */
-function condense(
+/** Per cycle, whether a dead declaration outside it references one of its members. */
+function referencedCycles(
   adjacent: readonly (readonly number[])[],
   componentOf: readonly number[],
   count: number,
-): { readonly edges: readonly (readonly number[])[]; readonly into: readonly number[] } {
-  const edges: number[][] = Array.from({ length: count }, () => []);
-  const into = Array.from({ length: count }, () => 0);
-  const seen = new Set<string>();
-  adjacent.forEach((targets, from) => {
-    for (const to of targets) {
-      const a = componentOf[from] ?? 0;
-      const b = componentOf[to] ?? 0;
-      const pair = `${String(a)}>${String(b)}`;
-      if (a === b || seen.has(pair)) {
-        continue;
-      }
-      seen.add(pair);
-      edges[a]?.push(b);
-      into[b] = (into[b] ?? 0) + 1;
-    }
-  });
-  return { edges, into };
-}
-
-/** Per dead declaration, whether a dead component other than its own references it. */
-function externallyReferenced(
-  adjacent: readonly (readonly number[])[],
-  componentOf: readonly number[],
 ): readonly boolean[] {
-  const referenced = adjacent.map(() => false);
+  const referenced = Array.from({ length: count }, () => false);
   adjacent.forEach((targets, from) => {
     for (const to of targets) {
-      if (componentOf[from] !== componentOf[to]) {
-        referenced[to] = true;
+      const cycle = componentOf[to] ?? 0;
+      if (componentOf[from] !== cycle) {
+        referenced[cycle] = true;
       }
     }
   });
@@ -303,70 +268,42 @@ function externallyReferenced(
 }
 
 /**
- * The components in the order a report is worked in. Tarjan closes each component after
- * every one it reaches, so reading the closing order backwards is a topological order,
- * and one pass over it gives each component its depth below the roots.
+ * The weakly connected parts of the dead subgraph, each its positions in ascending
+ * order, ordered by their first position. Positions follow the graph's declaration
+ * order, so a part's first position is its first member's site.
  */
-function order(
-  edges: readonly (readonly number[])[],
-  members: readonly (readonly number[])[],
-): readonly number[] {
-  const sequence = edges.map((_targets, component) => component).reverse();
-  const depth = edges.map(() => 0);
-  for (const from of sequence) {
-    for (const to of edges[from] ?? []) {
-      depth[to] = Math.max(depth[to] ?? 0, (depth[from] ?? 0) + 1);
+function joined(adjacent: readonly (readonly number[])[]): readonly (readonly number[])[] {
+  const leader = adjacent.map((_edges, position) => position);
+  const find = (position: number): number => {
+    let top = position;
+    while ((leader[top] ?? top) !== top) {
+      top = leader[top] ?? top;
     }
-  }
-  return sequence.sort(
-    (a, b) => (depth[a] ?? 0) - (depth[b] ?? 0) || (members[a]?.[0] ?? 0) - (members[b]?.[0] ?? 0),
-  );
-}
-
-/**
- * Per component, the dead declarations one deletion of it removes. A root of the
- * condensation carries its members and every component only it reaches; any other
- * component carries its own members alone, because what it reaches is reached through a
- * root above it as well.
- */
-function fallSets(
-  edges: readonly (readonly number[])[],
-  members: readonly (readonly number[])[],
-  into: readonly number[],
-): readonly (readonly number[])[] {
-  // Each root's walk stamps what it reaches with the root's own number, so the walks
-  // share one array rather than allocating one per root.
-  const stamp = edges.map(() => UNVISITED);
-  const reach = new Map<number, readonly number[]>();
-  const owners = edges.map(() => 0);
-  edges.forEach((_targets, root) => {
-    if (into[root] !== 0) {
-      return;
+    // Every position on the walk points at the top afterwards, so a later find is short.
+    for (let step = position; step !== top;) {
+      const next = leader[step] ?? top;
+      leader[step] = top;
+      step = next;
     }
-    const reached = [root];
-    stamp[root] = root;
-    // An array's iterator reads its length at every step, so what a step pushes is
-    // walked in the same loop.
-    for (const at of reached) {
-      for (const to of edges[at] ?? []) {
-        if (stamp[to] !== root) {
-          stamp[to] = root;
-          reached.push(to);
-        }
-      }
-    }
-    reach.set(root, reached);
-    for (const component of reached) {
-      owners[component] = (owners[component] ?? 0) + 1;
+    return top;
+  };
+  adjacent.forEach((targets, from) => {
+    for (const to of targets) {
+      const a = find(from);
+      const b = find(to);
+      // The smaller position leads, so a part's leader is its first position.
+      leader[Math.max(a, b)] = Math.min(a, b);
     }
   });
-  return members.map((own, component) => {
-    const set = [...own];
-    for (const other of reach.get(component) ?? []) {
-      if (other !== component && owners[other] === 1) {
-        set.push(...(members[other] ?? []));
-      }
+  const parts = new Map<number, number[]>();
+  adjacent.forEach((_edges, position) => {
+    const top = find(position);
+    const part = parts.get(top);
+    if (part === undefined) {
+      parts.set(top, [position]);
+    } else {
+      part.push(position);
     }
-    return set.sort((a, b) => a - b);
   });
+  return [...parts.values()];
 }