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

package/src/calls.ts

@@ -1,30 +1,48 @@
 /**
  * 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, named
- * directly or through variables, and a decorator written as a call is a call.
+ * is attached to. A class is passed by each value an argument can be, at any depth inside
+ * the array and object literals it writes, named directly or through variables, and a
+ * decorator written as a call is a call.
  */
 
 import {
   isArrayLiteralExpression,
+  isArrowFunction,
+  isBinaryExpression,
+  isBindingElement,
   isCallExpression,
   isClassDeclaration,
+  isConditionalExpression,
   isDecorator,
+  isFunctionDeclaration,
+  isFunctionExpression,
   isIdentifier,
+  isMethodDeclaration,
   isObjectLiteralExpression,
+  isParameterDeclaration,
   isParenthesizedExpression,
   isPropertyAccessExpression,
   isPropertyAssignment,
+  isPropertyDeclaration,
   isShorthandPropertyAssignment,
+  isOmittedExpression,
+  isSpreadAssignment,
   isSpreadElement,
   isVariableDeclaration,
   type CallExpression,
   type Decorator,
   type Expression,
   type Node,
+  type ParameterDeclaration,
+  SyntaxKind,
 } from "@typescript/native/ast";
-import { SymbolFlags, type Symbol as TSSymbol } from "@typescript/native/sync";
+import {
+  ObjectFlags,
+  SymbolFlags,
+  type Symbol as TSSymbol,
+  type Type,
+} from "@typescript/native/sync";
 import type { AliasChains } from "./alias-chain.ts";
 import { nodeKey, type Inventory } from "./inventory.ts";
 import { must } from "./query.ts";
@@ -35,11 +53,14 @@ import { unwrapped } from "./unwrap.ts";
 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;
+  /** The name the value is resolved through, the shorthand assignment that holds it, or none. */
+  readonly name: Node | undefined;
   readonly shorthand: boolean;
 }
 
+/** A passed value that names its declaration. */
+type NamedValue = PassedValue & { readonly name: Node };
+
 /** One class of the target a call passes or a decorator is attached to, and where. */
 interface ClassUse {
   /** The inventory's identifier of the class. */
@@ -111,46 +132,114 @@ export function resolvedTargets<Brand>(
   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;
+/** The declaration a shorthand property's value resolves to, an import followed to what it names. */
+function shorthandTarget<Brand>(project: ProjectView<Brand>, node: Node): TSSymbol | undefined {
+  const value = must(project.shorthandValueAt(project.handle(node)));
+  if (value === undefined || (value.flags & SymbolFlags.Alias) === 0) {
+    return value;
   }
-  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 });
+  const aliased = must(project.queries.aliased(value));
+  return aliased.declarations.length === 0 ? undefined : aliased;
+}
+
+/**
+ * The values one expression passes: each value it can be ({@link leavesOf}), or what an
+ * array or object literal it can be holds, at any depth.
+ */
+function passedIn(written: Expression, found: PassedValue[]): void {
+  for (const expression of leavesOf(written)) {
+    if (isArrayLiteralExpression(expression)) {
+      for (const element of expression.elements) {
+        passedIn(element, found);
+      }
+    } else if (isObjectLiteralExpression(expression)) {
+      for (const property of expression.properties) {
+        if (isPropertyAssignment(property)) {
+          passedIn(property.initializer, found);
+        } else if (isSpreadAssignment(property)) {
+          passedIn(property.expression, found);
+        } else if (isShorthandPropertyAssignment(property)) {
+          found.push({ site: property.name, name: property, shorthand: true });
+        }
       }
+    } else if (!isOmittedExpression(expression)) {
+      found.push({ site: expression, name: calleeName(expression), shorthand: false });
     }
-    return;
   }
-  const name = calleeName(expression);
-  if (name !== undefined) {
-    found.push({ site: expression, name, shorthand: false });
+}
+
+/** The operators whose value is one of their operands. */
+const CHOOSING: ReadonlySet<SyntaxKind> = new Set([
+  SyntaxKind.QuestionQuestionToken,
+  SyntaxKind.BarBarToken,
+  SyntaxKind.AmpersandAmpersandToken,
+]);
+
+/**
+ * The expressions one value can be: itself, or each branch of a conditional, each operand
+ * of `??`, `||` and `&&` and the last of a comma, inside any wrapper that changes no value.
+ * Each is read alone because the checker reduces a union by subtype, so the type at the
+ * whole drops a class structurally equal to, or a subtype of, another branch's.
+ */
+function leavesOf(written: Expression): readonly Expression[] {
+  const expression = unwrapped(isSpreadElement(written) ? written.expression : written);
+  if (isConditionalExpression(expression)) {
+    return [...leavesOf(expression.whenTrue), ...leavesOf(expression.whenFalse)];
+  }
+  if (isBinaryExpression(expression)) {
+    const operator = expression.operatorToken.kind;
+    if (CHOOSING.has(operator)) {
+      return [...leavesOf(expression.left), ...leavesOf(expression.right)];
+    }
+    if (operator === SyntaxKind.CommaToken) {
+      return leavesOf(expression.right);
+    }
   }
+  return [expression];
 }
 
 /** The values one argument passes, a spread argument's included. */
-export function valuesPassed(argument: Expression): readonly PassedValue[] {
+function leavesPassed(argument: Expression): readonly PassedValue[] {
   const found: PassedValue[] = [];
-  passedIn(isSpreadElement(argument) ? argument.expression : argument, found);
+  passedIn(argument, found);
   return found;
 }
 
+/** The values one argument passes that name their declaration. */
+export function valuesPassed(argument: Expression): readonly NamedValue[] {
+  return leavesPassed(argument).filter((value): value is NamedValue => value.name !== undefined);
+}
+
+/**
+ * What one passed value holds: the declaration its name resolves to, and the classes and
+ * functions the checker's type at it holds ({@link constructedAt}). `known` holds names
+ * already resolved in a batch.
+ */
+function heldBy<Brand>(
+  project: ProjectView<Brand>,
+  value: PassedValue,
+  known?: ReadonlyMap<Node, TSSymbol>,
+): { readonly named: TSSymbol | undefined; readonly typed: readonly TSSymbol[] } {
+  const { name } = value;
+  if (name === undefined) {
+    return { named: undefined, typed: constructedAt(project, value.site) };
+  }
+  if (value.shorthand) {
+    return { named: shorthandTarget(project, name), typed: [] };
+  }
+  return {
+    named: known?.get(name) ?? resolvedTargets(project, [name]).get(name),
+    typed: constructedAt(project, value.site),
+  };
+}
+
 /**
- * The classes of the target each call passes, by the call. A name that is no class is
- * followed through the initializer of each variable it declares, so a class bound to a
- * variable first is passed. A value that names no class of the target, a class of
- * another program included, passes nothing here.
+ * The classes of the target each call passes, by the call: each class a value an argument
+ * can be holds as a constructor, as the checker types it. A name whose type erases the
+ * class is followed through what its declaration binds ({@link boundTo}) and, for a
+ * parameter, through what each call of its function passes at its place, so a class handed
+ * to a wrapper is passed. A class is used at each value that passes it. A class of another
+ * program passes nothing.
  */
 export function classesPassed<Brand>(
   project: ProjectView<Brand>,
@@ -158,45 +247,230 @@ export function classesPassed<Brand>(
   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 passed = new Map(calls.map((call) => [call, call.arguments.flatMap(leavesPassed)]));
   const targets = resolvedTargets(
     project,
-    all.filter((value) => !value.shorthand).map((value) => value.name),
+    [...passed.values()].flat().flatMap((value) => (value.shorthand ? [] : (value.name ?? []))),
   );
   const classes = new Set(
     held.symbols.filter((symbol) => symbol.kind === "class").map((symbol) => symbol.id),
   );
+  let calling: CallsOf | undefined;
+  const callsOfFunction = (symbol: TSSymbol): readonly CallExpression[] => {
+    calling ??= callsByDeclaration(project);
+    return symbol.declarations.flatMap((handle) => calling?.get(keyOf(handle)) ?? []);
+  };
+  const classesOf = (value: PassedValue, seen: Set<number>): readonly string[] => {
+    const { named, typed } = heldBy(project, value, targets);
+    return [
+      ...typed.flatMap((symbol) => chains.declarationsOf(symbol).filter((id) => classes.has(id))),
+      ...(named === undefined ? [] : reached(named, seen)),
+    ];
+  };
   const reached = (symbol: TSSymbol, seen: Set<number>): readonly string[] => {
     const ids = chains.declarationsOf(symbol).filter((id) => classes.has(id));
     if (ids.length > 0 || seen.has(symbol.id)) {
       return ids;
     }
     seen.add(symbol.id);
+    const through = (written: Expression): readonly string[] =>
+      leavesPassed(written).flatMap((value) => classesOf(value, seen));
     return symbol.declarations.flatMap((handle) => {
       const node = project.declarationAt(handle)?.node;
-      if (node === undefined || !isVariableDeclaration(node) || node.initializer === undefined) {
+      if (node === undefined) {
         return [];
       }
-      const name = calleeName(unwrapped(node.initializer));
-      const next = name === undefined ? undefined : resolvedTargets(project, [name]).get(name);
-      return next === undefined ? [] : reached(next, seen);
+      if (isParameterDeclaration(node)) {
+        return argumentsAt(project, node, callsOfFunction).flatMap(through);
+      }
+      const bound = boundTo(project, node);
+      return [
+        ...(bound.written === undefined ? [] : through(bound.written)),
+        ...bound.symbols.flatMap((next) => reached(next, seen)),
+      ];
     });
   };
-  const classesOf = (value: PassedValue): readonly string[] => {
-    const symbol = value.shorthand
-      ? must(project.shorthandValueAt(project.handle(value.name)))
-      : targets.get(value.name);
-    return symbol === undefined ? [] : reached(symbol, new Set());
-  };
   return new Map(
-    [...passed].map(([call, values]) => [
-      call,
-      values.flatMap((value) => classesOf(value).map((id) => ({ id, site: value.site }))),
-    ]),
+    [...passed].map(([call, values]) => {
+      const uses = new Map<string, ClassUse>();
+      for (const value of values) {
+        for (const id of classesOf(value, new Set())) {
+          uses.set(`${id}\u0000${String(value.site.pos)}`, { id, site: value.site });
+        }
+      }
+      return [call, [...uses.values()]];
+    }),
+  );
+}
+
+/**
+ * The symbols of the classes and functions the checker's type at one expression holds as
+ * values, each member of a union: the static side of a class or a function is an
+ * anonymous type its declaration's symbol names, which an instance's type is not.
+ */
+function constructedAt<Brand>(project: ProjectView<Brand>, written: Node): readonly TSSymbol[] {
+  return heldIn(project, must(project.queries.typeAt(unwrapped(written))));
+}
+
+/** The classes and functions one type holds as values, as {@link constructedAt} reads them. */
+function heldIn<Brand>(project: ProjectView<Brand>, type: Type | undefined): readonly TSSymbol[] {
+  const { queries } = project;
+  return (type === undefined ? [] : must(queries.constituents(type))).flatMap((part) => {
+    if (!part.isObjectType() || (part.objectFlags & ObjectFlags.Anonymous) === 0) {
+      return [];
+    }
+    return must(queries.symbolOfType(part)) ?? [];
+  });
+}
+
+/** What one declaration binds its name to: the value it writes, or the symbols it copies. */
+interface Bound {
+  readonly written?: Expression;
+  readonly symbols: readonly TSSymbol[];
+}
+
+/**
+ * What a variable, a property or a destructured binding binds its name to: a variable's
+ * or a property's initializer, the value a shorthand property names, or the property of
+ * the destructured value a binding element reads.
+ */
+function boundTo<Brand>(project: ProjectView<Brand>, node: Node): Bound {
+  if (isShorthandPropertyAssignment(node)) {
+    const value = shorthandTarget(project, node);
+    return { symbols: value === undefined ? [] : [value] };
+  }
+  if (isBindingElement(node)) {
+    const key = node.propertyName ?? node.name;
+    if (key === undefined || !isIdentifier(key)) {
+      return { symbols: [] };
+    }
+    const source = must(project.queries.typeAt(node.parent));
+    const property =
+      source === undefined
+        ? undefined
+        : must(project.queries.propertiesOf(source)).find((one) => one.name === key.text);
+    return { symbols: property === undefined ? [] : [property] };
+  }
+  const written = initializerOf(node);
+  return written === undefined ? { symbols: [] } : { written, symbols: [] };
+}
+
+/** The value a variable or a property declaration binds its name to, where it writes one. */
+function initializerOf(node: Node): Expression | undefined {
+  return isVariableDeclaration(node) || isPropertyAssignment(node) || isPropertyDeclaration(node)
+    ? node.initializer
+    : undefined;
+}
+
+/** The project's calls, by each declaration their callee resolves to. */
+type CallsOf = ReadonlyMap<string, readonly CallExpression[]>;
+
+/** The key of one declaration a symbol names, the same for each symbol the checker makes of it. */
+function keyOf(handle: { readonly path: string; readonly index: number }): string {
+  return `${handle.path}#${String(handle.index)}`;
+}
+
+/**
+ * Every call of the project by the declarations its callee can be: the function or the
+ * method it names, or else each function the checker's type at it holds, wherever that
+ * value came from. A name is also followed through what its binding copies
+ * ({@link boundTo}), which is how a call reaches a function an annotation erases.
+ * Only the target's own declarations are keys, as only its own functions are asked for.
+ */
+function callsByDeclaration<Brand>(project: ProjectView<Brand>): CallsOf {
+  const calls = callsOf(project);
+  const own = project.ownPaths();
+  const callees = resolvedTargets(
+    project,
+    calls.flatMap((call) => calleeName(call.expression) ?? []),
+  );
+  const named = new Map<number, readonly string[]>();
+  const keysOf = (symbol: TSSymbol, seen: Set<number>): readonly string[] => {
+    const known = named.get(symbol.id);
+    if (known !== undefined || seen.has(symbol.id)) {
+      return known ?? [];
+    }
+    seen.add(symbol.id);
+    const keys = symbol.declarations
+      .filter((handle) => own.has(handle.path))
+      .flatMap((handle) => {
+        const node = project.declarationAt(handle)?.node;
+        const bound = node === undefined ? { symbols: [] } : boundTo(project, node);
+        const copied = [
+          ...bound.symbols,
+          ...(bound.written === undefined ? [] : leavesPassed(bound.written)).flatMap((value) => {
+            const { named: next, typed } = heldBy(project, value);
+            return [...typed, ...(next === undefined ? [] : [next])];
+          }),
+        ];
+        return [keyOf(handle), ...copied.flatMap((next) => keysOf(next, seen))];
+      });
+    named.set(symbol.id, keys);
+    return keys;
+  };
+  const calleeOf = (call: CallExpression): TSSymbol | undefined => {
+    const name = calleeName(call.expression);
+    return name === undefined ? undefined : callees.get(name);
+  };
+  const declared = (call: CallExpression): boolean =>
+    ((calleeOf(call)?.flags ?? 0) & (SymbolFlags.Function | SymbolFlags.Method)) !== 0;
+  const typed = calls.filter((call) => !declared(call));
+  const types = new Map(
+    project.queries
+      .typesAt(typed.map((call) => unwrapped(call.expression)))
+      .map((type, index) => [typed[index], must(type)]),
   );
+  const found = new Map<string, CallExpression[]>();
+  for (const call of calls) {
+    const callee = calleeOf(call);
+    const held = [
+      ...(callee === undefined ? [] : [callee]),
+      ...(types.has(call) ? heldIn(project, types.get(call)) : []),
+    ];
+    for (const key of new Set(held.flatMap((symbol) => keysOf(symbol, new Set())))) {
+      found.set(key, [...(found.get(key) ?? []), call]);
+    }
+  }
+  return found;
+}
+
+/**
+ * What each call of the function a parameter belongs to passes at the parameter's place,
+ * every argument from there on for a rest parameter. The function is the one the checker's
+ * type at its own declaration names, so a function with no name of its own is called too.
+ * A `this` parameter takes no place, and an argument at or after a spread argument passes
+ * at every place the spread's length can move it to.
+ */
+function argumentsAt<Brand>(
+  project: ProjectView<Brand>,
+  parameter: ParameterDeclaration,
+  callsOfFunction: (symbol: TSSymbol) => readonly CallExpression[],
+): readonly Expression[] {
+  const owner = parameter.parent;
+  if (
+    !isFunctionDeclaration(owner) &&
+    !isMethodDeclaration(owner) &&
+    !isArrowFunction(owner) &&
+    !isFunctionExpression(owner)
+  ) {
+    return [];
+  }
+  const calls = new Set(constructedAt(project, owner).flatMap(callsOfFunction));
+  const [first] = owner.parameters;
+  const erased = first !== undefined && isIdentifier(first.name) && first.name.text === "this";
+  const place = owner.parameters.indexOf(parameter) - (erased ? 1 : 0);
+  const rest = parameter.dotDotDotToken !== undefined;
+  return [...calls].flatMap((call) => {
+    let spreads = 0;
+    return call.arguments.flatMap((argument, index) => {
+      const spread = isSpreadElement(argument);
+      const earliest = index - spreads;
+      spreads += spread ? 1 : 0;
+      const open = spread || earliest < index;
+      const lands = open ? rest || earliest <= place : rest ? index >= place : index === place;
+      return lands ? [spread ? argument.expression : argument] : [];
+    });
+  });
 }
 
 /** One class declaration of the target and the decorators written on it. */

package/src/conformance-record.ts

@@ -4,7 +4,7 @@ export const RECORD = {
   conformance: {
     corpusVersion: "6.0.0",
     result: "pass",
-    digest: "sha256:a4ffbc1c2d9dc7903ccbf52af0e1a22094e0b50363f59365f6aa37b9437d3427",
+    digest: "sha256:140f095d52fa8140de070f46d13a132b723c634ecf24a8b96e6a92c410c4b848",
   },
   gaps: [],
 } as const;

package/src/contract/contract.generated.ts

@@ -423,7 +423,7 @@ export const KIND_ROWS = [
     holdsLive: true,
     rule: "An exported symbol whose every reference is inside the symbol's own package or module, reported as a candidate for unexporting. The subject is a package-level declaration or a method. Three subjects are excluded. An interface method is excluded because its exportedness is the contract of the interface that declares it. A struct field is excluded because an encoder reads it by name. A method that satisfies an interface some symbol uses as a type is excluded because it cannot be unexported without its type ceasing to satisfy that interface, and so is a method whose name and signature are those of a method of an exported interface type declared by a package outside the target that the import closure holds, because that interface fixes them whether or not the program converts the method's type to it. The finding names the narrower visibility the references support. A declared cross-language edge counts as an out-of-package reference. Where the edge's other side is unknown to the analyzer, the finding is emitted pending. A reference from a Go external test package, a test file whose package clause names its directory's package with the suffix _test, is a reference from outside the package, because that test builds as another package and needs the export.",
     precondition:
-      "Closed world only. A Go main package, and an internal/ directory tree for importers outside its parent, are closed worlds whatever the configuration declares, because no other program can import them, so this finding is reported there always. A published package is a closed world only when the configuration declares the consumer set complete and every declared consumer loads. A library with no consumer loaded and no complete consumer set declared gets this finding on its internal/ tree and its main packages and never on its published API. A symbol the rule of DS1301 holds for is not reported under this code, whatever severity the configuration gives DS1301, because the write-only finding names the defect to fix first. A type that a parameter or a result of an exported function or method of its own package names is not reported when a reference from outside the package references that function or method, because the caller holds values of the type, and unexporting it would leave an exported signature naming a type its callers cannot name. A package-level declaration whose name a string literal spells carries the class grammar/analysis/confidence.md gives it.",
+      "Closed world only. A Go main package, and an internal/ directory tree for importers outside its parent, are closed worlds whatever the configuration declares, because no other program can import them, so this finding is reported there always. A published package is a closed world only when the configuration declares the consumer set complete and every declared consumer loads. A library with no consumer loaded and no complete consumer set declared gets this finding on its internal/ tree and its main packages and never on its published API. A symbol the rule of DS1301 holds for is not reported under this code, whatever severity the configuration gives DS1301, because the write-only finding names the defect to fix first. A type is not reported when a reference from outside the package reaches its values through its own package's exported declarations: a reference to an exported function or method whose parameters or results name the type, to an exported variable or constant whose type names it, to an exported field or property whose type names it, an embedded field included, or to an exported member of the type itself, a field promoted through an embedding included. A type a reference from outside the package names, or whose values such a reference reaches, passes the reach on to each type its definition names other than through an unexported member, whether it is exported or not, so an unexported type an exported function returns passes it to the types its exported fields name. A type names another through every composite that spells it: a pointer, an array, a slice, a map key or value, a channel, a function signature and a type argument. The referencing code holds values of the type, so unexporting it would leave an exported declaration naming a type its users cannot name. A package-level declaration whose name a string literal spells carries the class grammar/analysis/confidence.md gives it.",
     details: { narrower_visibility: "required", name_literal: "optional" },
     defaultEnabled: true,
     defaultSeverity: "warn",
@@ -439,7 +439,7 @@ export const KIND_ROWS = [
     holdsLive: true,
     rule: "An exported symbol of a non-internal package whose every reference is inside the target module, reported as a candidate for relocation behind an internal boundary. The subject is a package-level declaration or a method. Three subjects are excluded. An interface method is excluded because its exportedness is the contract of the interface that declares it. A struct field is excluded because an encoder reads it by name. A method that satisfies an interface some symbol uses as a type is excluded because it cannot be unexported without its type ceasing to satisfy that interface, and so is a method whose name and signature are those of a method of an exported interface type declared by a package outside the target that the import closure holds, because that interface fixes them whether or not the program converts the method's type to it. The finding names the narrower visibility the references support. A declared cross-language edge counts as an out-of-package reference. Where the edge's other side is unknown to the analyzer, the finding is emitted pending. A reference from a Go external test package, a test file whose package clause names its directory's package with the suffix _test, is a reference from outside the package, because that test builds as another package and needs the export.",
     precondition:
-      "Closed world only. Reported always for a main package and an internal/ directory tree, and for a published package only when the configuration declares the consumer set complete and every declared consumer loads. A library with no consumer loaded and no complete consumer set declared gets this finding on its internal/ tree and its main packages and never on its published API. A symbol the rule of DS1301 holds for is not reported under this code, whatever severity the configuration gives DS1301, because the write-only finding names the defect to fix first. A type that a parameter or a result of an exported function or method of its own package names is not reported when a reference from outside the target module references that function or method, because the caller holds values of the type, and moving it behind an internal boundary would leave an exported signature naming a type its callers cannot name.",
+      "Closed world only. Reported always for a main package and an internal/ directory tree, and for a published package only when the configuration declares the consumer set complete and every declared consumer loads. A library with no consumer loaded and no complete consumer set declared gets this finding on its internal/ tree and its main packages and never on its published API. A symbol the rule of DS1301 holds for is not reported under this code, whatever severity the configuration gives DS1301, because the write-only finding names the defect to fix first. A type is not reported when a reference from outside the target module reaches its values through its own package's exported declarations, as DS1501 defines that reach, because the referencing code holds values of the type, and moving it behind an internal boundary would leave an exported declaration naming a type its users cannot name.",
     details: { narrower_visibility: "required", name_literal: "optional" },
     defaultEnabled: true,
     defaultSeverity: "warn",

package/src/exempt.ts

@@ -18,14 +18,43 @@ import {
   type TypeScriptVisibility,
 } from "./exempt-classes.ts";
 import type { Inventory, InventorySymbol, Visibility } from "./inventory.ts";
-import type { Matrix } from "./matrix.ts";
 import { byPosition, positionKey, type Position } from "./position.ts";
 import { Unanswerable } from "./query.ts";
 import type { ProjectView } from "./session.ts";
 import type { Templates } from "./template-field.ts";
-import { sweep, type Exemption, type Implementing, type Mode, type SweepInput } from "./sweep.ts";
+import type { Mode } from "./tests/file-class.ts";
 import { bytewise } from "./text/compare.ts";
 
+/** One declaration an exemption class holds back, and the evidence it was found by. */
+export interface Exemption {
+  /** The identifier of the declaration held back. */
+  readonly id: string;
+  readonly class: TSExemptionClass;
+  /** One clause naming the relation, then the thing it relates to: `passed to JSON.stringify`. */
+  readonly detail: string;
+  /** Where the evidence is written. */
+  readonly site: Position;
+  /**
+   * The component file, below the target root, whose markup holds the evidence. The
+   * record holds only while that file is live.
+   */
+  readonly whileLive?: string;
+  /**
+   * The interface methods the retained member implements, and whether its body is empty.
+   * The record holds only while one of them is called through its interface.
+   */
+  readonly implementing?: Implementing;
+  /** Whether the record holds only where a write the mode counts stores into the declaration. */
+  readonly whileWritten?: true;
+}
+
+/** The interface methods one retained class member implements, and whether its body is empty. */
+interface Implementing {
+  /** The declarations of the interface's methods the member answers, by identifier. */
+  readonly methods: readonly string[];
+  readonly empty: boolean;
+}
+
 /** One declaration a detector holds back, and where and why. */
 export interface Evidence {
   /** The identifier of the declaration held back. */
@@ -228,21 +257,6 @@ export function exemptionsOf(found: readonly Exemption[]): readonly Exemption[]
   });
 }
 
-/**
- * The records that hold while the component files at `live` are live: every record that
- * holds whatever is live, and each one a live file's markup holds, as a record of the run.
- */
-export function holdingWhile(
-  records: readonly Exemption[],
-  live: ReadonlySet<string>,
-): readonly Exemption[] {
-  return exemptionsOf(
-    records.flatMap(({ whileLive, ...record }) =>
-      whileLive === undefined || live.has(whileLive) ? [record] : [],
-    ),
-  );
-}
-
 /** The records per declaration, each declaration's in the order given. */
 function byDeclaration(records: readonly Exemption[]): ReadonlyMap<string, readonly Exemption[]> {
   const grouped = new Map<string, Exemption[]>();
@@ -257,35 +271,6 @@ function byDeclaration(records: readonly Exemption[]): ReadonlyMap<string, reado
   return grouped;
 }
 
-/**
- * The records that held back a declaration: one some configuration's graph, swept
- * again with no exemption and its marks, judges a candidate, whatever another
- * configuration answers, or one in `writeOnly`, which the run would report as written
- * and never read without the record's read. A declaration a relation or a mark holds
- * live in every configuration is held back by no record. The order is the
- * declarations' site order, and for one declaration the input's.
- */
-export function retainedIn(
-  matrix: Matrix,
-  input: SweepInput,
-  writeOnly: ReadonlySet<string> = new Set(),
-): readonly Exemption[] {
-  const exempt = input.exempt ?? [];
-  if (exempt.length === 0) {
-    return [];
-  }
-  const bare: SweepInput = { marked: input.marked, mode: input.mode };
-  const dead = new Set(
-    matrix.graphs.flatMap((graph) =>
-      sweep(graph, bare).candidates.map((candidate) => candidate.id),
-    ),
-  );
-  const held = byDeclaration(
-    exempt.filter((record) => dead.has(record.id) || writeOnly.has(record.id)),
-  );
-  return matrix.union.symbols.flatMap((symbol) => held.get(symbol.id) ?? []);
-}
-
 /**
  * One line per held-back declaration, in site order: its reference and position, then
  * each record's class, site and detail, all separated by tabs.