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

package/src/exemptions/detectors.ts

@@ -0,0 +1,75 @@
+/**
+ * The exemption classes this analyzer detects, each by its detector, and what their
+ * detection reads of the run once for every project. A class without a detector here
+ * retains nothing.
+ */
+
+import type { ResolvedConfig } from "../config.ts";
+import type { Host } from "../host.ts";
+import type { Inventory } from "../inventory.ts";
+import type { ProjectView } from "../session.ts";
+import type { TSExemptionClass } from "./classes.ts";
+import { decorator } from "./decorator.ts";
+import { enumGroup } from "./enum-group.ts";
+import { frameworkLifecycle } from "./framework-lifecycle.ts";
+import { generatedFile, type GeneratedFact } from "./generated-file.ts";
+import { injectionContainer } from "./injection-container.ts";
+import { interfaceSatisfaction } from "./interface-satisfaction.ts";
+import { detect, type Detector, type Detectors, type Exemption } from "./lifecycle.ts";
+import { reflectiveLookup } from "./reflective-lookup.ts";
+import { serializationContract } from "./serialization-contract.ts";
+import { readTemplates, templateField } from "./template-field.ts";
+
+export const DETECTORS: Detectors = new Map<TSExemptionClass, Detector>([
+  ["interface-satisfaction", interfaceSatisfaction],
+  ["enum-group", enumGroup],
+  ["generated-file", generatedFile],
+  ["template-field", templateField],
+  ["reflective-lookup", reflectiveLookup],
+  ["decorator", decorator],
+  ["injection-container", injectionContainer],
+  ["framework-lifecycle", frameworkLifecycle],
+  ["serialization-contract", serializationContract],
+]);
+
+/** One project, while its view is open, as detection reads it. */
+interface DetectedProject<Brand> {
+  readonly project: ProjectView<Brand>;
+  readonly held: Inventory;
+  /** The project's generated files, by path below the target root, each with what decided it. */
+  readonly generated: ReadonlyMap<string, GeneratedFact>;
+}
+
+/**
+ * The detection of one run: what every project's detectors read of the run, read once,
+ * and a function that runs them over one project. A switched-off class reads nothing,
+ * its templates included, and generated files are held only where the configuration
+ * leaves them out of the analysis.
+ */
+export function detection(
+  host: Host,
+  targetRoot: string,
+  config: ResolvedConfig,
+  consumers: readonly string[],
+  detectors: Detectors,
+): <Brand>(one: DetectedProject<Brand>) => readonly Exemption[] {
+  const disabled = new Set(config.exemptions.disabled);
+  const templates = disabled.has("template-field")
+    ? { delimiters: config.analysis.template_delimiters, files: [] }
+    : readTemplates(host, targetRoot, config.analysis);
+  const included = config.analysis.generated_files === "include";
+  return ({ project, held, generated }) =>
+    detect(
+      {
+        project,
+        held,
+        targetRoot,
+        templates,
+        ts: config.ts,
+        consumers,
+        ...(included ? {} : { generated }),
+      },
+      detectors,
+      disabled,
+    );
+}

package/src/{enum-group.ts → exemptions/enum-group.ts}

@@ -27,19 +27,19 @@ import {
   type Node,
   type SourceFile,
 } from "@typescript/native/ast";
-import { parenthesesRemoved } from "./unwrap.ts";
+import { parenthesesRemoved } from "../unwrap.ts";
 import { TypeFlags, type Type } from "@typescript/native/sync";
-import { aliasChains } from "./alias-chain.ts";
-import type { DetectorInput, Evidence } from "./exempt.ts";
-import { nodeKey } from "./inventory.ts";
-import { renderPosition } from "./position.ts";
-import { isAnswered, UNANSWERED, type Answer } from "./query.ts";
-import type { ProjectView } from "./session.ts";
+import { aliasChains } from "../alias-chain.ts";
+import type { DetectorInput, Evidence } from "./lifecycle.ts";
+import { nodeKey } from "../inventory.ts";
+import { renderPosition } from "../position.ts";
+import { isAnswered, UNANSWERED, type Answer } from "../query.ts";
+import type { ProjectView } from "../session.ts";
+import { ERASED } from "./value-reach.ts";
 
 /** The operand types a conversion produces an enum value from. */
 const NUMBER = TypeFlags.NumberLike;
 const STRING = TypeFlags.StringLike;
-const DECODED = TypeFlags.Any | TypeFlags.Unknown;
 
 /** How one site produces a value of the type it names. */
 type Form = "assertion" | "lookup" | "annotation";
@@ -176,7 +176,7 @@ function detailOf<Brand>(
   if (parts.some((part) => (part.flags & STRING) !== 0)) {
     return site.form === "assertion" ? "converted from string" : undefined;
   }
-  if (parts.some((part) => (part.flags & DECODED) !== 0)) {
+  if (parts.some((part) => (part.flags & ERASED) !== 0)) {
     return `decoded as ${enumName}`;
   }
   return undefined;

package/src/{erased-stores.ts → exemptions/erased-stores.ts}

@@ -26,14 +26,11 @@ import {
   type Expression,
   type Node,
 } from "@typescript/native/ast";
-import { SymbolFlags, TypeFlags, type Type } from "@typescript/native/sync";
-import { must } from "./query.ts";
-import type { ProjectView } from "./session.ts";
-import { checkedTypes } from "./value-reach.ts";
-import { parenthesesRemoved } from "./unwrap.ts";
-
-/** The types that keep nothing of the value they are given. */
-const ERASED = TypeFlags.Any | TypeFlags.Unknown;
+import { SymbolFlags, type Type } from "@typescript/native/sync";
+import { must } from "../query.ts";
+import type { ProjectView } from "../session.ts";
+import { checkedTypes, ERASED } from "./value-reach.ts";
+import { parenthesesRemoved } from "../unwrap.ts";
 
 /** The array methods whose arguments become elements of the array they are called on. */
 const ELEMENT_STORES: ReadonlySet<string> = new Set(["push", "unshift"]);

package/src/{framework-lifecycle.ts → exemptions/framework-lifecycle.ts}

@@ -8,18 +8,17 @@
  */
 
 import {
-  isClassDeclaration,
-  isClassExpression,
   isHeritageClause,
   SyntaxKind,
   type CallExpression,
   type Node,
 } from "@typescript/native/ast";
 import type { Type } from "@typescript/native/sync";
-import { aliasChains, type AliasChains } from "./alias-chain.ts";
-import { calleeName, callsOf, classesPassed, decoratedClasses, decoratorCallee } from "./calls.ts";
-import { classMembers, memberComponent, typesAt, type ClassSide } from "./class-members.ts";
-import type { DeclarationEntry, LifecycleContract } from "./config.ts";
+import { aliasChains, type AliasChains } from "../alias-chain.ts";
+import { nameOf } from "../index/values.ts";
+import { classesPassed, decoratorCallee, decoratorsOf } from "./calls.ts";
+import { classMembers, memberComponent, typesAt, type ClassSide } from "../class-members.ts";
+import type { DeclarationEntry, LifecycleContract } from "../config.ts";
 import {
   entriesAt,
   names,
@@ -27,12 +26,13 @@ import {
   resolveEntries,
   spelledEntry,
   type ResolvedEntry,
-} from "./roots/configured-declarations.ts";
-import type { DetectorInput, Evidence } from "./exempt.ts";
-import { nodeKey, type Inventory } from "./inventory.ts";
-import { renderPosition } from "./position.ts";
-import { must } from "./query.ts";
-import type { ProjectView } from "./session.ts";
+} from "../roots/configured-declarations.ts";
+import type { DetectorInput, Evidence } from "./lifecycle.ts";
+import type { Inventory } from "../inventory.ts";
+import { renderPosition } from "../position.ts";
+import { must } from "../query.ts";
+import type { ProjectView } from "../session.ts";
+import type { ProjectSites } from "./sites.ts";
 
 /**
  * The platform's own contract (references-ts.38): `CustomElementRegistry.define` reads
@@ -101,6 +101,7 @@ function resolveContracts<Brand>(
 function byComponents<Brand>(
   project: ProjectView<Brand>,
   held: Inventory,
+  sites: ProjectSites,
   chains: AliasChains,
   contracts: readonly ResolvedContract[],
 ): readonly Component[] {
@@ -111,13 +112,18 @@ function byComponents<Brand>(
   const contractOf = new Map(
     routed.flatMap((one) => one.components.map((entry) => [entry, one.contract] as const)),
   );
-  const calls = callsOf(project);
-  const decorated = decoratedClasses(project, held);
+  const calls = sites.calls.map((one) => one.call);
+  const invoked = (call: CallExpression): Node | undefined =>
+    nameOf(sites.invocations.of(call).callee);
+  const decorated = sites.classes.flatMap(({ id, node }) => {
+    const decorators = decoratorsOf(node);
+    return decorators.length === 0 ? [] : [{ id, decorators }];
+  });
   const named = entriesAt(
     project,
     chains,
     [
-      ...calls.flatMap((call) => calleeName(call.expression) ?? []),
+      ...calls.flatMap((call) => invoked(call) ?? []),
       ...decorated.flatMap((one) =>
         one.decorators.flatMap((decorator) => decoratorCallee(decorator) ?? []),
       ),
@@ -140,12 +146,12 @@ function byComponents<Brand>(
   }
   const matched = new Map<CallExpression, { contract: LifecycleContract; detail: string }[]>();
   for (const call of calls) {
-    const routes = naming(calleeName(call.expression));
+    const routes = naming(invoked(call));
     if (routes.length > 0) {
       matched.set(call, routes);
     }
   }
-  for (const [call, uses] of classesPassed(project, held, chains, [...matched.keys()])) {
+  for (const [call, uses] of classesPassed(project, held, chains, sites, [...matched.keys()])) {
     for (const route of matched.get(call) ?? []) {
       for (const use of uses) {
         found.push({
@@ -160,43 +166,28 @@ function byComponents<Brand>(
   return found;
 }
 
-/** Each class declaration of the target, with its name and the class its `extends` names. */
-interface Declared {
+/** Each named class of the target that extends another, with its name and the class its `extends` names. */
+function extendingClasses(sites: ProjectSites): readonly {
   readonly id: string;
   readonly name: Node;
   readonly extended: Node;
-}
-
-/** The class declarations of the target that extend another class. */
-function extendingClasses<Brand>(
-  project: ProjectView<Brand>,
-  held: Inventory,
-): readonly Declared[] {
-  const found: Declared[] = [];
-  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));
-        const clause = (node.heritageClauses ?? []).find(
-          (one) => isHeritageClause(one) && one.token === SyntaxKind.ExtendsKeyword,
-        );
-        const extended =
-          clause !== undefined && isHeritageClause(clause) ? clause.types[0] : undefined;
-        if (id !== undefined && extended !== undefined) {
-          found.push({ id, name: node.name, extended });
-        }
-      }
-      node.forEachChild(visit);
-    };
-    file.forEachChild(visit);
-  }
-  return found;
+}[] {
+  return sites.classes.flatMap(({ id, node }) => {
+    const clause = (node.heritageClauses ?? []).find(
+      (one) => isHeritageClause(one) && one.token === SyntaxKind.ExtendsKeyword,
+    );
+    const extended = clause !== undefined && isHeritageClause(clause) ? clause.types[0] : undefined;
+    return node.name === undefined || extended === undefined
+      ? []
+      : [{ id, name: node.name, extended }];
+  });
 }
 
 /** The classes that extend, directly or through a chain, a class the contracts' bases name. */
 function byBases<Brand>(
   project: ProjectView<Brand>,
   held: Inventory,
+  sites: ProjectSites,
   chains: AliasChains,
   contracts: readonly ResolvedContract[],
 ): readonly Component[] {
@@ -204,7 +195,7 @@ function byBases<Brand>(
   if (based.length === 0) {
     return [];
   }
-  const classes = extendingClasses(project, held);
+  const classes = extendingClasses(sites);
   if (classes.length === 0) {
     return [];
   }
@@ -275,8 +266,8 @@ export function frameworkLifecycle<Brand>(input: DetectorInput<Brand>): readonly
   }
   const chains = aliasChains(project, held);
   const components = [
-    ...byComponents(project, held, chains, contracts),
-    ...byBases(project, held, chains, contracts),
+    ...byComponents(project, held, input.sites, chains, contracts),
+    ...byBases(project, held, input.sites, chains, contracts),
   ];
   if (components.length === 0) {
     return [];

package/src/{generated-file.ts → exemptions/generated-file.ts}

@@ -15,12 +15,12 @@ import {
   type Node,
   type SourceFile,
 } from "@typescript/native/ast";
-import { GENERATORS } from "./contract/contract.generated.ts";
-import type { DetectorInput, Evidence } from "./exempt.ts";
-import { minifiedBy } from "./javascript-file.ts";
-import type { SourceFiles } from "./source-files.ts";
-import { bytewise } from "./text/compare.ts";
-import { satisfies } from "./version-range.ts";
+import { GENERATORS } from "../contract/contract.generated.ts";
+import type { DetectorInput, Evidence } from "./lifecycle.ts";
+import { minifiedBy } from "../javascript-file.ts";
+import type { SourceFiles } from "../source-files.ts";
+import { bytewise } from "../text/compare.ts";
+import { satisfies } from "../version-range.ts";
 
 /** The generated-code header, matched against each line of a leading comment. */
 const HEADER_LINE = /^\/\/ Code generated .* DO NOT EDIT\.$/u;

package/src/{injection-container.ts → exemptions/injection-container.ts}

@@ -8,8 +8,6 @@
  */
 
 import {
-  isClassDeclaration,
-  isClassExpression,
   isConstructorDeclaration,
   isGetAccessorDeclaration,
   isPropertyDeclaration,
@@ -18,19 +16,20 @@ import {
   type Decorator,
   type Node,
 } from "@typescript/native/ast";
-import { aliasChains } from "./alias-chain.ts";
-import { calleeName, callsOf, classesPassed, decoratorsOf, spelledDecorator } from "./calls.ts";
-import { classMembers, type ClassMember } from "./class-members.ts";
+import { aliasChains } from "../alias-chain.ts";
+import { nameOf } from "../index/values.ts";
+import { classesPassed, decoratorsOf, spelledDecorator } from "./calls.ts";
+import { classMembers, type ClassMember } from "../class-members.ts";
 import {
   entriesAt,
   namesADeclaration,
   resolveEntries,
   spelledEntry,
   type ResolvedEntry,
-} from "./roots/configured-declarations.ts";
-import type { DetectorInput, Evidence } from "./exempt.ts";
-import { isParameterProperty, nodeKey } from "./inventory.ts";
-import { renderPosition } from "./position.ts";
+} from "../roots/configured-declarations.ts";
+import type { DetectorInput, Evidence } from "./lifecycle.ts";
+import { isParameterProperty } from "../inventory.ts";
+import { renderPosition } from "../position.ts";
 
 /** One class a container constructs, by the registration that says so. */
 interface Registration {
@@ -52,32 +51,36 @@ function isInjected(node: Node): boolean {
 
 /** The classes of the target a call whose callee an entry names passes, with that call's entry. */
 function registrations<Brand>(input: DetectorInput<Brand>): readonly Registration[] {
-  const { project, held } = input;
+  const { project, held, sites } = input;
   const resolved = resolveEntries(project, held, input.ts.injection_registrations);
   if (!resolved.some(namesADeclaration)) {
     return [];
   }
   const chains = aliasChains(project, held);
-  const calls = callsOf(project);
+  const calls = sites.calls.map((one) => one.call);
+  const invoked = (call: CallExpression): Node | undefined =>
+    nameOf(sites.invocations.of(call).callee);
   const named = entriesAt(
     project,
     chains,
-    calls.flatMap((call) => calleeName(call.expression) ?? []),
+    calls.flatMap((call) => invoked(call) ?? []),
     resolved,
   );
   const matched = new Map<CallExpression, ResolvedEntry>();
   for (const call of calls) {
-    const name = calleeName(call.expression);
+    const name = invoked(call);
     const [entry] = name === undefined ? [] : (named.get(name) ?? []);
     if (entry !== undefined) {
       matched.set(call, entry);
     }
   }
-  return [...classesPassed(project, held, chains, [...matched.keys()])].flatMap(([call, uses]) => {
-    const entry = matched.get(call);
-    const detail = entry === undefined ? "" : `registered by ${spelledEntry(entry.entry, held)}`;
-    return uses.map((use) => ({ id: use.id, site: use.site, detail }));
-  });
+  return [...classesPassed(project, held, chains, sites, [...matched.keys()])].flatMap(
+    ([call, uses]) => {
+      const entry = matched.get(call);
+      const detail = entry === undefined ? "" : `registered by ${spelledEntry(entry.entry, held)}`;
+      return uses.map((use) => ({ id: use.id, site: use.site, detail }));
+    },
+  );
 }
 
 /**
@@ -87,22 +90,14 @@ function registrations<Brand>(input: DetectorInput<Brand>): readonly Registratio
 function constructedForParameters<Brand>(
   input: DetectorInput<Brand>,
 ): ReadonlyMap<string, Decorator> {
-  const { project, held } = input;
   const found = new Map<string, Decorator>();
-  for (const file of project.ownSourceFiles()) {
-    const visit = (node: Node): void => {
-      if (isClassDeclaration(node) || isClassExpression(node)) {
-        const id = held.declarations.get(nodeKey(file, node));
-        const [asks] = node.members.flatMap((member) =>
-          isConstructorDeclaration(member) ? member.parameters.flatMap(decoratorsOf) : [],
-        );
-        if (id !== undefined && asks !== undefined) {
-          found.set(id, asks);
-        }
-      }
-      node.forEachChild(visit);
-    };
-    file.forEachChild(visit);
+  for (const { id, node } of input.sites.classes) {
+    const [asks] = node.members.flatMap((member) =>
+      isConstructorDeclaration(member) ? member.parameters.flatMap(decoratorsOf) : [],
+    );
+    if (asks !== undefined) {
+      found.set(id, asks);
+    }
   }
   return found;
 }