@cplieger/deadset-ts 8.0.0-dev.2 → 8.0.0-dev.21

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

@@ -18,7 +18,6 @@ import {
   isIdentifier,
   isMethodDeclaration,
   isNoSubstitutionTemplateLiteral,
-  isParenthesizedExpression,
   isParenthesizedTypeNode,
   isPropertyAccessExpression,
   isReturnStatement,
@@ -28,18 +27,19 @@ import {
   type Node,
   type SourceFile,
 } from "@typescript/native/ast";
+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";
@@ -55,15 +55,6 @@ interface Site {
   readonly at: Node;
 }
 
-/** The expression one node is, through however many parentheses are written around it. */
-function unparenthesized(node: Node): Node {
-  let held = node;
-  while (isParenthesizedExpression(held)) {
-    held = held.expression;
-  }
-  return held;
-}
-
 /**
  * The name node a type node names its declaration by: the identifier of a type
  * reference, the right side of a qualified one, through parentheses. A type that is no
@@ -86,7 +77,7 @@ function typeName(type: Node | undefined): Node | undefined {
 
 /** The name node an expression names an object by: an identifier, or a property access's name. */
 function objectName(expression: Node): Node | undefined {
-  const held = unparenthesized(expression);
+  const held = parenthesesRemoved(expression);
   if (isIdentifier(held)) {
     return held;
   }
@@ -185,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}

@@ -16,7 +16,6 @@ import {
   isNoSubstitutionTemplateLiteral,
   isNumericLiteral,
   isObjectLiteralExpression,
-  isParenthesizedExpression,
   isPropertyAccessExpression,
   isPropertyAssignment,
   isShorthandPropertyAssignment,
@@ -27,13 +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";
-
-/** 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"]);
@@ -81,10 +78,6 @@ function literalKey(node: Expression): string | undefined {
     : undefined;
 }
 
-function unwrapped(node: Expression): Expression {
-  return isParenthesizedExpression(node) ? unwrapped(node.expression) : node;
-}
-
 /**
  * Whether a variable declaration's type can differ from what is stored in it: it carries an
  * annotation, or it has neither an annotation nor an initializer, so its type evolves.
@@ -150,8 +143,8 @@ function propertyAt(source: Expression, name: string): Expression | undefined {
  * here, and a default value is stored in its target too.
  */
 function patternTargets(pattern: Expression, from: Stored, out: Target[]): void {
-  const target = unwrapped(pattern);
-  const source = from.path.length === 0 ? unwrapped(from.value) : from.value;
+  const target = parenthesesRemoved(pattern);
+  const source = from.path.length === 0 ? parenthesesRemoved(from.value) : from.value;
   const into = (element: Expression, step: Step, literal: Expression | undefined): void => {
     patternTargets(
       element,

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

@@ -1,24 +1,24 @@
 /**
- * The framework-lifecycle class: a member a `ts.lifecycle_contracts` entry lists is held
- * back on each class that is the entry's component, being a class a decorator or a call
- * the entry's `components` name is attached to or passes, or one extending, directly or
- * through a chain, a class its `bases` name. A component's members are its type's, so a
- * member a base class declares answers for every subclass.
+ * The framework-lifecycle class: a member a lifecycle contract lists is held back on each
+ * class that is the contract's component, being a class a decorator or a call the
+ * contract's `components` name is attached to or passes, or one extending, directly or
+ * through a chain, a class its `bases` name. The contracts are the platform's custom
+ * elements and each `ts.lifecycle_contracts` entry. A component's members are its type's,
+ * so a member a base class declares answers for every subclass.
  */
 
 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,
@@ -26,12 +26,37 @@ import {
   resolveEntries,
   spelledEntry,
   type ResolvedEntry,
-} from "./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
+ * these members off the class it registers, its constructor's and its prototype's
+ * (https://html.spec.whatwg.org/multipage/custom-elements.html#dom-customelementregistry-define),
+ * and calls each callback as a custom element reaction.
+ */
+const CUSTOM_ELEMENTS: LifecycleContract = {
+  components: [{ global: "CustomElementRegistry.define" }],
+  members: [
+    "observedAttributes:static",
+    "disabledFeatures:static",
+    "formAssociated:static",
+    "connectedCallback",
+    "disconnectedCallback",
+    "connectedMoveCallback",
+    "adoptedCallback",
+    "attributeChangedCallback",
+    "formAssociatedCallback",
+    "formResetCallback",
+    "formDisabledCallback",
+    "formStateRestoreCallback",
+  ],
+};
 
 /** One class that is a component of one contract, and what says it is. */
 interface Component {
@@ -55,8 +80,8 @@ function resolveContracts<Brand>(
   contracts: readonly LifecycleContract[],
 ): readonly ResolvedContract[] {
   const entries: DeclarationEntry[] = contracts.flatMap((contract) => [
-    ...contract.components,
-    ...contract.bases,
+    ...(contract.components ?? []),
+    ...(contract.bases ?? []),
   ]);
   const resolved = resolveEntries(project, held, entries);
   let next = 0;
@@ -67,8 +92,8 @@ function resolveContracts<Brand>(
   };
   return contracts.map((contract) => ({
     contract,
-    components: take(contract.components.length),
-    bases: take(contract.bases.length),
+    components: take(contract.components?.length ?? 0),
+    bases: take(contract.bases?.length ?? 0),
   }));
 }
 
@@ -76,6 +101,7 @@ function resolveContracts<Brand>(
 function byComponents<Brand>(
   project: ProjectView<Brand>,
   held: Inventory,
+  sites: ProjectSites,
   chains: AliasChains,
   contracts: readonly ResolvedContract[],
 ): readonly Component[] {
@@ -86,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) ?? []),
       ),
@@ -115,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({
@@ -135,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[] {
@@ -179,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 [];
   }
@@ -238,25 +254,26 @@ function byBases<Brand>(
 
 /**
  * The framework-lifecycle detector: each member a contract lists, on each class that
- * is a component of that contract's framework, recorded where the class was found to
- * be one.
+ * is a component of that contract's framework, recorded once per place where the class
+ * was found to be one.
  */
 export function frameworkLifecycle<Brand>(input: DetectorInput<Brand>): readonly Evidence[] {
   const { project, held, targetRoot } = input;
-  if (input.ts.lifecycleContracts.length === 0) {
+  const declared = [CUSTOM_ELEMENTS, ...input.ts.lifecycle_contracts];
+  const contracts = resolveContracts(project, held, declared);
+  if (contracts.every((one) => one.components.length === 0 && one.bases.length === 0)) {
     return [];
   }
   const chains = aliasChains(project, held);
-  const contracts = resolveContracts(project, held, input.ts.lifecycleContracts);
   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 [];
   }
   const ids = new Set(components.map((one) => one.id));
-  const sides: readonly ClassSide[] = input.ts.lifecycleContracts.some((contract) =>
+  const sides: readonly ClassSide[] = declared.some((contract) =>
     contract.members.some((name) => name.endsWith(":static")),
   )
     ? ["instance", "static"]
@@ -264,7 +281,7 @@ export function frameworkLifecycle<Brand>(input: DetectorInput<Brand>): readonly
   const members = sides.map((side) => classMembers(project, held, ids, side));
   const byId = new Map(held.symbols.map((symbol) => [symbol.id, symbol]));
 
-  const found: Evidence[] = [];
+  const found = new Map<string, Evidence>();
   for (const component of components) {
     const listed = new Set(component.contract.members);
     const site = renderPosition(
@@ -275,10 +292,12 @@ export function frameworkLifecycle<Brand>(input: DetectorInput<Brand>): readonly
     for (const member of members.flatMap((side) => side.get(component.id) ?? [])) {
       const symbol = byId.get(member.id);
       const spelled = symbol === undefined ? undefined : memberComponent(symbol, byId);
-      if (spelled !== undefined && listed.has(spelled)) {
-        found.push({ id: member.id, detail: component.detail, site });
+      // A configured contract may name the platform's registry too; one record answers both.
+      const key = `${member.id}\0${component.detail}\0${site.path}:${String(site.line)}:${String(site.column)}`;
+      if (spelled !== undefined && listed.has(spelled) && !found.has(key)) {
+        found.set(key, { id: member.id, detail: component.detail, site });
       }
     }
   }
-  return found;
+  return [...found.values()];
 }