@cplieger/deadset-ts 8.0.0-dev.16 → 8.0.0-dev.18

package/src/interface-satisfaction.ts

@@ -29,10 +29,10 @@ import {
 } from "@typescript/native/ast";
 import { SymbolFlags, type Type } from "@typescript/native/sync";
 import { aliasChains } from "./alias-chain.ts";
-import { emptyImplementation } from "./implementations.ts";
+import { emptyImplementation } from "./findings/implementations.ts";
 import type { DetectorInput, Evidence } from "./exempt.ts";
 import type { Reference } from "./references.ts";
-import type { Exemption } from "./sweep.ts";
+import type { Exemption } from "./exempt.ts";
 import { nodeKey, type Inventory } from "./inventory.ts";
 import { renderPosition } from "./position.ts";
 import { must } from "./query.ts";

package/src/inventory.ts

@@ -50,6 +50,25 @@ export type SymbolKind =
   | "enum-member"
   | "type-parameter";
 
+/** The reader's word for each kind of declaration, as a finding names it. */
+export const WORDS: Readonly<Record<SymbolKind, string>> = {
+  file: "file",
+  function: "function",
+  class: "class",
+  interface: "interface",
+  type: "type alias",
+  enum: "enum",
+  namespace: "namespace",
+  variable: "variable",
+  "export-alias": "re-export",
+  method: "method",
+  "class-member": "class member",
+  "interface-method": "interface method",
+  "type-member": "type member",
+  "enum-member": "enum member",
+  "type-parameter": "type parameter",
+};
+
 /**
  * How a member may be named from outside its container. A `private` member is still
  * reachable at run time by its name; a private name does not exist outside the class body.

package/src/keyof-comparisons.ts

@@ -10,7 +10,10 @@ import {
   isCaseClause,
   isElementAccessExpression,
   isIdentifier,
+  isNoSubstitutionTemplateLiteral,
+  isNumericLiteral,
   isPropertyAccessExpression,
+  isStringLiteral,
   isSwitchStatement,
   isTypeOperatorNode,
   SyntaxKind,
@@ -20,12 +23,8 @@ import {
   type TypeNode,
 } from "@typescript/native/ast";
 import { SymbolFlags, type Type } from "@typescript/native/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";
+import type { Read, ReadRule } from "./references/read-rule.ts";
 import { parenthesesRemoved } from "./unwrap.ts";
 
 /** The operators that compare their operands for equality. */
@@ -83,125 +82,141 @@ function literalNames(parts: readonly Type[]): readonly string[] {
 }
 
 /**
- * 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.
+ * The reads the key comparisons of a side's files make of the members their literal side
+ * names, each made by the declaration holding the comparison. A question the checker leaves
+ * unanswered holds what its answer could have read.
  */
-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,
+export const keyofComparisons: ReadRule = {
+  start() {
+    const comparisons: Comparison[] = [];
+    return {
+      visit(node, { file, from }) {
+        if (isBinaryExpression(node) && EQUALITIES.has(node.operatorToken.kind)) {
+          comparisons.push({ file, from, keyed: node.left, other: node.right });
+          comparisons.push({ file, from, keyed: node.right, other: node.left });
+        }
+        if (isSwitchStatement(node)) {
+          for (const clause of node.caseBlock.clauses) {
+            if (isCaseClause(clause)) {
+              comparisons.push({ file, from, keyed: node.expression, other: clause.expression });
+            }
+          }
+        }
+      },
+      reads({ project, chains }) {
+        const queries = project.queries;
+        const found: Read[] = [];
+        const named = comparisons.flatMap((one) => {
+          const name = nameOf(one.keyed);
+          return name === undefined || isElementAccessExpression(parenthesesRemoved(one.other))
+            ? []
+            : [{ ...one, name }];
+        });
+        if (named.length === 0) {
+          return found;
+        }
+        // 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) {
+            const text = literalText(one.other);
+            found.push({
+              kind: "held",
+              from: one.from,
+              ...(text === undefined ? {} : { names: [text] }),
             });
+            return [];
+          }
+          if (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 found;
         }
-      }
-      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(parenthesesRemoved(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;
+        const nodes = keyed.flatMap((one) => [one.other, ...one.operands]);
+        const types = queries.typesAt(nodes);
+        const typeOf = new Map<Node, Type | typeof UNANSWERED>();
+        nodes.forEach((node, at) => {
+          const type = types[at];
+          if (type !== undefined) {
+            typeOf.set(node, type);
           }
-          for (const to of chains.declarationsOf(property)) {
+        });
+        const partsOf = (type: Type): readonly Type[] => {
+          const parts = queries.constituents(type);
+          return parts === UNANSWERED ? [type] : parts;
+        };
+        for (const one of keyed) {
+          const literal = typeOf.get(one.other);
+          const objects = one.operands.map((operand) => typeOf.get(operand));
+          if (literal === UNANSWERED) {
+            const known = objects.filter((type) => type !== undefined && type !== UNANSWERED);
             found.push({
+              kind: "held",
               from: one.from,
-              to,
-              position,
-              use: "read",
-              resolution: "keyed",
-              test: testFiles.has(position.path),
+              types: known.flatMap(partsOf),
+              ...(known.length < objects.length ? { members: true as const } : {}),
             });
+            continue;
+          }
+          const names = literal === undefined ? [] : literalNames(partsOf(literal));
+          if (names.length === 0) {
+            continue;
+          }
+          for (const object of objects) {
+            if (object === UNANSWERED) {
+              found.push({ kind: "held", from: one.from, names });
+              continue;
+            }
+            for (const part of object === undefined ? [] : partsOf(object)) {
+              const properties = queries.propertiesOf(part);
+              if (properties === UNANSWERED) {
+                found.push({ kind: "held", from: one.from, names });
+                continue;
+              }
+              for (const property of properties) {
+                if (!names.includes(property.name)) {
+                  continue;
+                }
+                for (const to of chains.declarationsOf(property)) {
+                  found.push({
+                    kind: "named",
+                    from: one.from,
+                    to,
+                    file: one.file,
+                    at: one.other,
+                    use: "read",
+                    via: "keyed",
+                  });
+                }
+              }
+            }
           }
         }
-      }
-    }
-  }
-  return found;
+        return found;
+      },
+    };
+  },
+};
+
+/** The text a string or number literal operand spells, where it is one. */
+function literalText(node: Expression): string | undefined {
+  const at = parenthesesRemoved(node);
+  return isStringLiteral(at) || isNumericLiteral(at) || isNoSubstitutionTemplateLiteral(at)
+    ? at.text
+    : undefined;
 }

package/src/{components.ts → liveness/components.ts}

@@ -4,10 +4,10 @@
  * and every dead declaration that falls with them, being dead only through them.
  */
 
-import type { Cascade } from "./config.ts";
+import type { Cascade } from "../config.ts";
 import { OUTSIDE, type Graph } from "./graph.ts";
-import type { InventorySymbol } from "./inventory.ts";
-import { PRODUCT } from "./product.ts";
+import type { InventorySymbol } from "../inventory.ts";
+import { PRODUCT } from "../product.ts";
 
 /** The fewest digits a component identifier's number is written with. */
 const ID_DIGITS = 4;

package/src/{graph.ts → liveness/graph.ts}

@@ -1,13 +1,14 @@
 /**
- * One project's declarations, the references between them and the roots that seed
- * reachability, indexed for the sweep. The graph reads no file and asks the compiler
- * nothing, so a sweep over it is a function of the values it was built from, and the
- * inventory's order is the order every set a sweep answers reads in.
+ * The run's declarations, the references every configuration makes between them and the
+ * roots that seed reachability, indexed for the sweep. The graph reads no file and asks the
+ * compiler nothing, so a sweep over it is a function of the values it was built from, and
+ * the inventory's order is the order every set a sweep answers reads in.
  */
 
-import type { InventorySymbol, SymbolKind } from "./inventory.ts";
-import type { Reference } from "./references.ts";
-import type { Root, RootKind } from "./roots/root-set.ts";
+import type { InventorySymbol, SymbolKind } from "../inventory.ts";
+import type { Reference } from "../references.ts";
+import { madeByTestCode } from "../tests/file-class.ts";
+import type { Root, RootKind } from "../roots/root-set.ts";
 
 /** The position of a declaration the inventory does not hold. */
 export const OUTSIDE = -1;
@@ -79,24 +80,40 @@ export function namesACaller(kind: RootKind): boolean {
 /** One reference as the sweep reads it: the declaration named, and whether a test file made it. */
 export interface Edge {
   readonly to: number;
+  /** The reference's place in {@link Graph.references}. */
+  readonly reference: number;
   readonly test: boolean;
+  /** Whether only the name answered, which counts at the sweep's guessed tier alone. */
+  readonly guessed: boolean;
   /**
    * Whether the reference evaluates the module whose file it names, which reaches the
    * module's top level and none of what it exports.
    */
   readonly evaluation: boolean;
+  /**
+   * Whether a loaded consumer made it, whose test references a mode may class as
+   * production. Only a consumed edge can be one.
+   */
+  readonly consumer: boolean;
 }
 
-/** How many references one declaration carries, split by the classification of the file that made each. */
-interface Counts {
+/**
+ * How many references one declaration carries, split by the classification of the file that
+ * made each; `consumerTest` counts the test references a loaded consumer's test files made,
+ * which a mode may class as production (`sweep.ts` `countedRefs`).
+ */
+export interface Counts {
   readonly production: number;
   readonly test: number;
+  readonly consumerTest: number;
 }
 
 /** One root the inventory holds, at the position of the declaration it names. */
-interface Rooted {
+export interface Rooted {
   readonly at: number;
   readonly kind: RootKind;
+  /** What names the root, as the root set spells it. */
+  readonly source: string;
 }
 
 /** The index the sweep and the component pass read. */
@@ -107,6 +124,12 @@ export interface Graph {
   readonly out: readonly (readonly Edge[])[];
   /** Per declaration, the references made to it, whoever made them. */
   readonly made: readonly Counts[];
+  /** Per declaration, those of {@link Graph.made} only a name answered. */
+  readonly guessedMade: readonly Counts[];
+  /** The references the graph was built from, in the order given. */
+  readonly references: readonly Reference[];
+  /** Per reference, the configurations that make it, in the run's order. */
+  readonly configurations: readonly (readonly string[])[];
   /** Per declaration, the position of its container, or {@link OUTSIDE} for a file. */
   readonly parent: readonly number[];
   /** Per declaration, whether a test file holds it. */
@@ -126,17 +149,44 @@ export interface Graph {
   /** Every root naming a declaration the inventory holds, in the order the root set gives them. */
   readonly rooted: readonly Rooted[];
   /**
-   * Every reference a loaded consumer or an unheld file makes to a declaration the
-   * inventory holds, in the order given. Such a file is a caller the analysis read, so the
-   * sweep holds what it names live under both relations and reaches on from there.
+   * Every reference a loaded consumer, an unheld file or a declaration no configuration
+   * judges makes to a declaration the inventory holds, in the order given. Such code is a
+   * caller the analysis read, so the sweep holds what it names live under both relations
+   * and reaches on from there.
    */
   readonly consumed: readonly Edge[];
   /** The position of the declaration one identifier names, or {@link OUTSIDE}. */
   at(id: string): number;
 }
 
+/** What the run says of a graph's references beyond the references themselves. */
+interface Sources {
+  /**
+   * The declarations a configuration holds only for their references, judged by none: each
+   * reference one makes enters as a consumer's does, since deleting what it names breaks
+   * that configuration's compile (matrix.5).
+   */
+  readonly unjudged?: ReadonlySet<string>;
+  /** Per reference, in the order given, the configurations that make it. */
+  readonly configurations?: readonly (readonly string[])[];
+}
+
+/** Adds one reference's count to the counts of the declaration it names. */
+function count(
+  counts: { production: number; test: number; consumerTest: number },
+  test: boolean,
+  consumer: boolean,
+): void {
+  if (test) {
+    counts.test += 1;
+    counts.consumerTest += consumer ? 1 : 0;
+  } else {
+    counts.production += 1;
+  }
+}
+
 /**
- * Indexes one project's inventory, references and roots. `testFiles` are the paths the
+ * Indexes the run's inventory, references and roots. `testFiles` are the paths the
  * reference pass classified as test files, so a declaration one holds is a test
  * declaration. A reference to a declaration the inventory does not hold is dropped; one
  * from such a declaration still counts toward its target, because reference counting
@@ -149,35 +199,48 @@ export function graphOf(
   testFiles: readonly string[],
   supportFiles: readonly string[] = [],
   ambient: ReadonlySet<string> = new Set(),
+  sources: Sources = {},
 ): Graph {
   const supports = new Set(supportFiles);
   const index = new Map(symbols.map((symbol, at) => [symbol.id, at]));
   const at = (id: string): number => index.get(id) ?? OUTSIDE;
   const tests = new Set(testFiles);
+  const unjudged = sources.unjudged ?? new Set<string>();
 
   const out: Edge[][] = symbols.map(() => []);
-  const made = symbols.map(() => ({ production: 0, test: 0 }));
+  const made = symbols.map(() => ({ production: 0, test: 0, consumerTest: 0 }));
+  const guessedMade = symbols.map(() => ({ production: 0, test: 0, consumerTest: 0 }));
   const consumed: Edge[] = [];
-  for (const reference of references) {
+  references.forEach((reference, place) => {
     const to = at(reference.to);
     if (to === OUTSIDE) {
-      continue;
+      return;
     }
+    const test = madeByTestCode(reference, supports);
+    const consumer = reference.consumer !== undefined;
+    const guessed = reference.guessed === true;
     const counts = made[to];
     if (counts !== undefined) {
-      if (reference.test) {
-        counts.test += 1;
-      } else {
-        counts.production += 1;
-      }
+      count(counts, test, consumer);
     }
-    const edge = { to, test: reference.test, evaluation: reference.use === "evaluation" };
-    if (reference.consumer !== undefined || reference.unheld === true) {
+    const guesses = guessedMade[to];
+    if (guessed && guesses !== undefined) {
+      count(guesses, test, consumer);
+    }
+    const edge = {
+      to,
+      reference: place,
+      test,
+      guessed,
+      evaluation: reference.use === "evaluation",
+      consumer,
+    };
+    if (consumer || reference.unheld === true || unjudged.has(reference.from)) {
       consumed.push(edge);
-      continue;
+      return;
     }
     out[at(reference.from)]?.push(edge);
-  }
+  });
 
   const parent = symbols.map((symbol) => at(symbol.parent));
   const exportsOf: number[][] = symbols.map(() => []);
@@ -192,7 +255,7 @@ export function graphOf(
   for (const root of roots) {
     const position = at(root.id);
     if (position !== OUTSIDE) {
-      rooted.push({ at: position, kind: root.kind });
+      rooted.push({ at: position, kind: root.kind, source: root.source });
     }
   }
 
@@ -200,6 +263,9 @@ export function graphOf(
     symbols,
     out,
     made,
+    guessedMade,
+    references,
+    configurations: sources.configurations ?? references.map(() => []),
     parent,
     test: symbols.map((symbol) => tests.has(symbol.position.path)),
     support: symbols.map((symbol) => supports.has(symbol.position.path)),