@cplieger/deadset-ts 8.0.0-dev.20 → 8.0.0-dev.22

package/src/{calls.ts → exemptions/calls.ts}

@@ -1,33 +1,26 @@
 /**
  * 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 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.
+ * call invokes, a call through a method of `Function.prototype` included, and which of the
+ * target's classes a call passes or a decorator is attached to. A class is passed by each
+ * value an argument can carry ({@link carriedValues}), 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,
@@ -35,7 +28,6 @@ import {
   type Expression,
   type Node,
   type ParameterDeclaration,
-  SyntaxKind,
 } from "@typescript/native/ast";
 import {
   ObjectFlags,
@@ -43,23 +35,13 @@ import {
   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";
-import type { ProjectView } from "./session.ts";
-import { unwrapped } from "./unwrap.ts";
-
-/** One value written where a call passes it, and the node its declaration is resolved from. */
-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, 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 };
+import { resolvedTargets, type AliasChains } from "../alias-chain.ts";
+import { carriedValues, nameOf, type CarriedValue } from "../index/values.ts";
+import type { Inventory } from "../inventory.ts";
+import { must } from "../query.ts";
+import type { ProjectView } from "../session.ts";
+import { parenthesesRemoved, unwrapped } from "../unwrap.ts";
+import type { ProjectSites } from "./sites.ts";
 
 /** One class of the target a call passes or a decorator is attached to, and where. */
 interface ClassUse {
@@ -68,21 +50,10 @@ interface ClassUse {
   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);
+  return nameOf(isCallExpression(expression) ? expression.expression : expression);
 }
 
 /** How one decorator is spelled in a record: its expression, without a call's arguments. */
@@ -97,127 +68,146 @@ export function decoratorsOf(node: Node): readonly Decorator[] {
   return ((node as { readonly modifiers?: readonly Node[] }).modifiers ?? []).filter(isDecorator);
 }
 
+/** The methods of `Function.prototype` that invoke a function with arguments of their own. */
+const FUNCTION_METHODS: ReadonlySet<string> = new Set(["call", "apply", "bind"]);
+
+/** The interfaces of the standard library that declare those methods for a function value. */
+const FUNCTION_INTERFACES: ReadonlySet<string> = new Set([
+  "Function",
+  "CallableFunction",
+  "NewableFunction",
+]);
+
 /**
- * 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. A question the
- * checker does not answer stops the pass, as {@link must} stops.
+ * One call as the function it invokes sees it: the expression naming that function,
+ * and the argument each of its parameters binds, in order.
  */
-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>();
-  project
-    .symbolsAt(nodes.map((node) => project.handle(node)))
-    .map(must)
-    .forEach((symbol, index) => {
-      const node = nodes[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 = must(project.queries.aliased(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;
+export interface Invocation {
+  readonly callee: Expression;
+  readonly arguments: readonly Expression[];
+  /** Whether the call reaches the callee through a method of `Function.prototype`. */
+  readonly indirect: boolean;
+  /** Whether the last argument is a list the parameters bind the elements of, as `apply` takes. */
+  readonly listed: boolean;
 }
 
-/** 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;
-  }
-  const aliased = must(project.queries.aliased(value));
-  return aliased.declarations.length === 0 ? undefined : aliased;
+/** A call through a method of `Function.prototype`: the method's name and the invocation. */
+interface MethodForm {
+  readonly method: Node;
+  readonly invocation: Invocation;
 }
 
 /**
- * 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.
+ * The invocation a call writes through a method of `Function.prototype`, read from
+ * the syntax alone: `f.call(self, a)`, `f.apply(self, [a])`, `f.bind(self, a)`, which
+ * passes `a` though nothing calls the bound function there, because the bound function
+ * carries `a` to wherever it is called and that call is not followed, and
+ * `f.bind(self, a)(b)`, which passes `b` after it. An `apply` argument
+ * that is no array literal is the value of the first parameter, whose elements it
+ * carries. Whether the method is the prototype's is resolution's to say.
  */
-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 });
+function throughMethod(call: CallExpression): MethodForm | undefined {
+  const expression = parenthesesRemoved(call.expression);
+  if (isPropertyAccessExpression(expression) && FUNCTION_METHODS.has(expression.name.text)) {
+    const [, ...rest] = call.arguments;
+    let passed: readonly Expression[] = rest;
+    let listed = false;
+    if (expression.name.text === "apply") {
+      const list = rest[0] === undefined ? undefined : parenthesesRemoved(rest[0]);
+      listed = list !== undefined && !isArrayLiteralExpression(list);
+      passed = list === undefined ? [] : isArrayLiteralExpression(list) ? list.elements : [list];
     }
+    return {
+      method: expression.name,
+      invocation: { callee: expression.expression, arguments: passed, indirect: true, listed },
+    };
   }
+  if (isCallExpression(expression)) {
+    const bound = parenthesesRemoved(expression.expression);
+    if (isPropertyAccessExpression(bound) && bound.name.text === "bind") {
+      return {
+        method: bound.name,
+        invocation: {
+          callee: bound.expression,
+          arguments: [...expression.arguments.slice(1), ...call.arguments],
+          indirect: true,
+          listed: false,
+        },
+      };
+    }
+  }
+  return undefined;
 }
 
-/** The operators whose value is one of their operands. */
-const CHOOSING: ReadonlySet<SyntaxKind> = new Set([
-  SyntaxKind.QuestionQuestionToken,
-  SyntaxKind.BarBarToken,
-  SyntaxKind.AmpersandAmpersandToken,
-]);
+/** What each call of one project invokes. */
+export interface Invocations {
+  /** The function one call invokes and the arguments its parameters bind. */
+  readonly of: (call: CallExpression) => Invocation;
+  /** The declaration the invoked function's name resolves to, every alias followed. */
+  readonly callee: (call: CallExpression) => TSSymbol | undefined;
+}
 
 /**
- * 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.
+ * What each of a project's calls invokes. A call through `call`, `apply` or `bind`
+ * invokes the function the method is read from only where the method is the standard
+ * library's: the program's own `call` and `Reflect.apply` pass nothing on.
  */
-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);
+export function invocations<Brand>(
+  project: ProjectView<Brand>,
+  calls: readonly CallExpression[],
+): Invocations {
+  const forms = new Map<CallExpression, MethodForm>();
+  for (const call of calls) {
+    const form = throughMethod(call);
+    if (form !== undefined) {
+      forms.set(call, form);
     }
   }
-  return [expression];
-}
-
-/** The values one argument passes, a spread argument's included. */
-function leavesPassed(argument: Expression): readonly PassedValue[] {
-  const found: PassedValue[] = [];
-  passedIn(argument, found);
-  return found;
+  const callees = resolvedTargets(project, [
+    ...calls.flatMap((call) => nameOf(call.expression) ?? []),
+    ...[...forms.values()].flatMap((form) => {
+      const name = nameOf(form.invocation.callee);
+      return name === undefined ? [form.method] : [form.method, name];
+    }),
+  ]);
+  const standard = (method: TSSymbol): boolean =>
+    method.declarations.some(
+      (handle) => project.program.getSourceFileMetadata(handle.path)?.isDefaultLibrary === true,
+    ) && FUNCTION_INTERFACES.has(must(project.queries.parentOf(method))?.name ?? "");
+  const of = (call: CallExpression): Invocation => {
+    const form = forms.get(call);
+    const method = form === undefined ? undefined : callees.get(form.method);
+    return form !== undefined && method !== undefined && standard(method)
+      ? form.invocation
+      : { callee: call.expression, arguments: call.arguments, indirect: false, listed: false };
+  };
+  return {
+    of,
+    callee: (call) => {
+      const name = nameOf(of(call).callee);
+      return name === undefined ? undefined : callees.get(name);
+    },
+  };
 }
 
-/** 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);
+/** 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;
+  }
+  const aliased = must(project.queries.aliased(value));
+  return aliased.declarations.length === 0 ? undefined : aliased;
 }
 
 /**
- * What one passed value holds: the declaration its name resolves to, and the classes and
+ * What one carried 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,
+  value: CarriedValue,
   known?: ReadonlyMap<Node, TSSymbol>,
 ): { readonly named: TSSymbol | undefined; readonly typed: readonly TSSymbol[] } {
   const { name } = value;
@@ -233,34 +223,58 @@ function heldBy<Brand>(
   };
 }
 
-/**
- * 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.
- */
+/** The classes of the target each call passes, by the call, as {@link classesCarried} reads its invocation's arguments. */
 export function classesPassed<Brand>(
   project: ProjectView<Brand>,
   held: Inventory,
   chains: AliasChains,
+  sites: Pick<ProjectSites, "calls" | "invocations">,
   calls: readonly CallExpression[],
 ): ReadonlyMap<CallExpression, readonly ClassUse[]> {
-  const passed = new Map(calls.map((call) => [call, call.arguments.flatMap(leavesPassed)]));
+  const carried = classesCarried(
+    project,
+    held,
+    chains,
+    sites,
+    calls.map((call) => sites.invocations.of(call).arguments),
+  );
+  return new Map(calls.map((call, at) => [call, carried[at] ?? []]));
+}
+
+/**
+ * The classes of the target each group of written values carries: each class a value
+ * can carry 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 carries it. A class
+ * of another program is carried by nothing.
+ */
+export function classesCarried<Brand>(
+  project: ProjectView<Brand>,
+  held: Inventory,
+  chains: AliasChains,
+  sites: Pick<ProjectSites, "calls" | "invocations">,
+  groups: readonly (readonly Expression[])[],
+): readonly (readonly ClassUse[])[] {
+  const { invocations: invoked } = sites;
+  const passed = groups.map((written) => written.flatMap(carriedValues));
   const targets = resolvedTargets(
     project,
-    [...passed.values()].flat().flatMap((value) => (value.shorthand ? [] : (value.name ?? []))),
+    passed.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);
+    calling ??= callsByDeclaration(
+      project,
+      sites.calls.map((one) => one.call),
+      invoked,
+    );
     return symbol.declarations.flatMap((handle) => calling?.get(keyOf(handle)) ?? []);
   };
-  const classesOf = (value: PassedValue, seen: Set<number>): readonly string[] => {
+  const classesOf = (value: CarriedValue, seen: Set<number>): readonly string[] => {
     const { named, typed } = heldBy(project, value, targets);
     return [
       ...typed.flatMap((symbol) => chains.declarationsOf(symbol).filter((id) => classes.has(id))),
@@ -274,14 +288,14 @@ export function classesPassed<Brand>(
     }
     seen.add(symbol.id);
     const through = (written: Expression): readonly string[] =>
-      leavesPassed(written).flatMap((value) => classesOf(value, seen));
+      carriedValues(written).flatMap((value) => classesOf(value, seen));
     return symbol.declarations.flatMap((handle) => {
       const node = project.declarationAt(handle)?.node;
       if (node === undefined) {
         return [];
       }
       if (isParameterDeclaration(node)) {
-        return argumentsAt(project, node, callsOfFunction).flatMap(through);
+        return argumentsAt(project, node, callsOfFunction, invoked).flatMap(through);
       }
       const bound = boundTo(project, node);
       return [
@@ -290,17 +304,15 @@ export function classesPassed<Brand>(
       ];
     });
   };
-  return new Map(
-    [...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 passed.map((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()]];
-    }),
-  );
+    }
+    return [...uses.values()];
+  });
 }
 
 /**
@@ -371,19 +383,18 @@ function keyOf(handle: { readonly path: string; readonly index: number }): strin
 }
 
 /**
- * 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
+ * Every call of the project by the declarations its invoked function 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);
+function callsByDeclaration<Brand>(
+  project: ProjectView<Brand>,
+  calls: readonly CallExpression[],
+  invoked: Invocations,
+): CallsOf {
   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);
@@ -398,7 +409,7 @@ function callsByDeclaration<Brand>(project: ProjectView<Brand>): CallsOf {
         const bound = node === undefined ? { symbols: [] } : boundTo(project, node);
         const copied = [
           ...bound.symbols,
-          ...(bound.written === undefined ? [] : leavesPassed(bound.written)).flatMap((value) => {
+          ...(bound.written === undefined ? [] : carriedValues(bound.written)).flatMap((value) => {
             const { named: next, typed } = heldBy(project, value);
             return [...typed, ...(next === undefined ? [] : [next])];
           }),
@@ -408,21 +419,17 @@ function callsByDeclaration<Brand>(project: ProjectView<Brand>): CallsOf {
     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;
+    ((invoked.callee(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)))
+      .typesAt(typed.map((call) => unwrapped(invoked.of(call).callee)))
       .map((type, index) => [typed[index], must(type)]),
   );
   const found = new Map<string, CallExpression[]>();
   for (const call of calls) {
-    const callee = calleeOf(call);
+    const callee = invoked.callee(call);
     const held = [
       ...(callee === undefined ? [] : [callee]),
       ...(types.has(call) ? heldIn(project, types.get(call)) : []),
@@ -436,15 +443,17 @@ function callsByDeclaration<Brand>(project: ProjectView<Brand>): CallsOf {
 
 /**
  * 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.
+ * every argument from there on for a rest parameter, as the call's invocation binds them.
+ * 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[],
+  invoked: Invocations,
 ): readonly Expression[] {
   const owner = parameter.parent;
   if (
@@ -462,7 +471,7 @@ function argumentsAt<Brand>(
   const rest = parameter.dotDotDotToken !== undefined;
   return [...calls].flatMap((call) => {
     let spreads = 0;
-    return call.arguments.flatMap((argument, index) => {
+    return invoked.of(call).arguments.flatMap((argument, index) => {
       const spread = isSpreadElement(argument);
       const earliest = index - spreads;
       spreads += spread ? 1 : 0;
@@ -472,46 +481,3 @@ function argumentsAt<Brand>(
     });
   });
 }
-
-/** One class declaration of the target and the decorators written on it. */
-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/{exempt-classes.ts → exemptions/classes.ts}

@@ -1,4 +1,4 @@
-import { EXEMPTION_CLASSES, type Language } from "./contract/contract.generated.ts";
+import { EXEMPTION_CLASSES, type Language } from "../contract/contract.generated.ts";
 
 /**
  * Whether a class may retain a member declared with the `private` modifier, and one

package/src/exemptions/decorator.ts

@@ -0,0 +1,56 @@
+/**
+ * The decorator class: a member a decorator expression is attached to, and every member
+ * of a class one is attached to but the member a parameter property declares, is held
+ * back, because the decorator may reach the member by its name. The rule is read from
+ * the tree alone. The decorator's own use of what it decorates is the reference pass's
+ * `decorator` reference; this class records only that the declaration is held back,
+ * static members of a decorated class included.
+ */
+
+import { decoratorsOf, spelledDecorator } from "./calls.ts";
+import type { DetectorInput, Evidence } from "./lifecycle.ts";
+import { isParameterProperty, type InventorySymbol, type SymbolKind } from "../inventory.ts";
+import { renderPosition } from "../position.ts";
+
+/** The kinds of declaration a decorator is attached to and holds back. */
+const DECORATED: ReadonlySet<SymbolKind> = new Set(["class", "method", "class-member"]);
+
+/**
+ * The decorator detector: each decorated member, and each member of a decorated
+ * class, recorded at the decorator.
+ */
+export function decorator<Brand>(input: DetectorInput<Brand>): readonly Evidence[] {
+  const { held, sites, targetRoot } = input;
+  const byId = new Map(held.symbols.map((symbol) => [symbol.id, symbol]));
+  const membersOf = new Map<string, InventorySymbol[]>();
+  for (const symbol of held.symbols) {
+    if (symbol.kind === "method" || symbol.kind === "class-member") {
+      const members = membersOf.get(symbol.parent);
+      if (members === undefined) {
+        membersOf.set(symbol.parent, [symbol]);
+      } else {
+        members.push(symbol);
+      }
+    }
+  }
+  // A decorated class's container passes each constructor argument, which keeps the
+  // parameter, not the member a parameter property stores it in. A parameter property's
+  // decorator is attached to its parameter, and to no member.
+  return sites.decorated.flatMap(({ id, node }) => {
+    const symbol = byId.get(id);
+    if (symbol === undefined || !DECORATED.has(symbol.kind) || isParameterProperty(node)) {
+      return [];
+    }
+    const members =
+      symbol.kind === "class"
+        ? (membersOf.get(symbol.id) ?? []).filter(
+            (member) => !sites.parameterProperties.has(member.id),
+          )
+        : [symbol];
+    return decoratorsOf(node).flatMap((attached) => {
+      const detail = `decorated by ${spelledDecorator(attached)}`;
+      const site = renderPosition(node.getSourceFile(), targetRoot, attached.getStart());
+      return members.map((member) => ({ id: member.id, detail, site }));
+    });
+  });
+}