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

package/src/findings/visibility-narrowing.ts

@@ -1,11 +1,12 @@
 import { CODE } from "../contract/contract.generated.ts";
 import type { Finding } from "../finding.ts";
-import { OUTSIDE, type Graph } from "../graph.ts";
-import type { InventorySymbol, SymbolKind } from "../inventory.ts";
-import type { MatrixCandidate } from "../matrix.ts";
+import { OUTSIDE, type Graph } from "../liveness/graph.ts";
+import { WORDS, type InventorySymbol } from "../inventory.ts";
+import type { Candidate } from "../liveness/sweep.ts";
 import { declarationKey } from "../ref.ts";
 import type { RootKind } from "../roots/root-set.ts";
-import { runnerCalls } from "../sweep.ts";
+import { runnerCalls } from "../liveness/sweep.ts";
+import { exposedTypes, exposes } from "../exposure.ts";
 import type { Emitter, EmitterInput } from "./emitter.ts";
 import { writeOnlyDeclarations } from "./reads-and-writes.ts";
 
@@ -19,18 +20,6 @@ type Reach = "file" | "package" | "outside";
  */
 const PUBLISHING: ReadonlySet<RootKind> = new Set<RootKind>(["manifest-entry", "published-api"]);
 
-/** The reader's word for each kind of declaration this emitter reports. */
-const WORDS: Partial<Readonly<Record<SymbolKind, string>>> = {
-  function: "function",
-  class: "class",
-  interface: "interface",
-  type: "type alias",
-  enum: "enum",
-  namespace: "namespace",
-  variable: "variable",
-  "export-alias": "re-export",
-};
-
 /** Per declaration of the run, the facts both rules read. */
 interface Facts {
   readonly graph: Graph;
@@ -142,10 +131,6 @@ function topLevelExport(facts: Facts, at: number, symbol: InventorySymbol): bool
   return symbol.exported && parent !== OUTSIDE && facts.graph.symbols[parent]?.kind === "file";
 }
 
-function wordOf(symbol: InventorySymbol): string {
-  return WORDS[symbol.kind] ?? symbol.kind;
-}
-
 /** The visibility each narrowing code names, which only the narrowing codes carry. */
 const NARROWER: Readonly<Record<string, "file" | "package">> = {
   [CODE.redundantExportKeyword]: "file",
@@ -181,7 +166,11 @@ function narrowing(
   facts: Facts,
   at: number,
   symbol: InventorySymbol,
-  world: { readonly closed: boolean; readonly writeOnly: ReadonlySet<string> },
+  world: {
+    readonly closed: boolean;
+    readonly writeOnly: ReadonlySet<string>;
+    readonly exposed: ReadonlySet<string> | "every";
+  },
 ): Finding | undefined {
   const { closed } = world;
   const file = facts.fileOf[at] ?? OUTSIDE;
@@ -195,7 +184,7 @@ function narrowing(
   ) {
     return undefined;
   }
-  const word = wordOf(symbol);
+  const word = WORDS[symbol.kind];
   switch (facts.reach[at]) {
     case "file":
       if (facts.published[file] === true && !closed) {
@@ -207,7 +196,7 @@ function narrowing(
         `exported ${word} is referenced only inside the file that declares it`,
       );
     case "package":
-      if (!closed || !publishes(facts.rootedBy[at])) {
+      if (!closed || !publishes(facts.rootedBy[at]) || exposes(world.exposed, symbol)) {
         return undefined;
       }
       return findingOf(
@@ -231,7 +220,7 @@ function unreachable(
   facts: Facts,
   at: number,
   symbol: InventorySymbol,
-  candidate: MatrixCandidate,
+  candidate: Candidate,
   input: EmitterInput,
 ): Finding | undefined {
   if (
@@ -252,7 +241,7 @@ function unreachable(
   return findingOf(
     symbol,
     CODE.unreachableExport,
-    `exported ${wordOf(symbol)} ${found}, and nothing outside can import the file that declares it`,
+    `exported ${WORDS[symbol.kind]} ${found}, and nothing outside can import the file that declares it`,
   );
 }
 
@@ -267,7 +256,17 @@ export function narrowings(input: EmitterInput): readonly Finding[] {
   const facts = factsOf(input.swept.matrix.union);
   const { declared, loaded } = input.boundary.consumers;
   const closed = input.config.consumers.complete && declared.every((id) => loaded.includes(id));
-  const world = { closed, writeOnly: writeOnlyDeclarations(input) };
+  const world = {
+    closed,
+    writeOnly: writeOnlyDeclarations(input),
+    exposed: closed
+      ? exposedTypes(
+          facts.graph,
+          facts.reach.map((reach) => reach === "outside"),
+          input.boundary.carriers,
+        )
+      : new Set<string>(),
+  };
   const candidates = new Map(
     input.swept.sweep.candidates.map((candidate) => [candidate.id, candidate]),
   );

package/src/framework-lifecycle.ts

@@ -1,9 +1,10 @@
 /**
- * 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 {
@@ -33,6 +34,30 @@ import { renderPosition } from "./position.ts";
 import { must } from "./query.ts";
 import type { ProjectView } from "./session.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 {
   readonly contract: LifecycleContract;
@@ -238,16 +263,17 @@ 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.lifecycle_contracts.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.lifecycle_contracts);
   const components = [
     ...byComponents(project, held, chains, contracts),
     ...byBases(project, held, chains, contracts),
@@ -256,7 +282,7 @@ export function frameworkLifecycle<Brand>(input: DetectorInput<Brand>): readonly
     return [];
   }
   const ids = new Set(components.map((one) => one.id));
-  const sides: readonly ClassSide[] = input.ts.lifecycle_contracts.some((contract) =>
+  const sides: readonly ClassSide[] = declared.some((contract) =>
     contract.members.some((name) => name.endsWith(":static")),
   )
     ? ["instance", "static"]
@@ -264,7 +290,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 +301,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()];
 }

package/src/import-bindings.ts

@@ -4,17 +4,20 @@
  */
 
 import {
+  isExportDeclaration,
   isExportSpecifier,
   isExternalModuleReference,
-  isIdentifier,
   isImportDeclaration,
   isImportEqualsDeclaration,
   isJsxElement,
   isJsxFragment,
   isJsxSelfClosingElement,
+  isNamedExports,
   isNamespaceImport,
   SyntaxKind,
   type Identifier,
+  type ImportDeclaration,
+  type ImportEqualsDeclaration,
   type Node,
   type SourceFile,
 } from "@typescript/native/ast";
@@ -41,42 +44,108 @@ export interface JsxOptions {
   readonly jsxFragmentFactory?: unknown;
 }
 
+/** One name a file's top-level import declaration binds. */
+interface ImportBinding {
+  readonly name: Identifier;
+  /** The export name it binds, `default` for a default import; absent where it binds a whole module. */
+  readonly imported?: string;
+  /** An `import x = …` declaration: whether it is exported, and whether it names an external module. */
+  readonly equals?: { readonly exported: boolean; readonly external: boolean };
+}
+
+const bindingsCache = new WeakMap<SourceFile, readonly ImportBinding[]>();
+
 /**
- * The names one file's import declarations bind: the default, named and namespace names of
- * an `import` declaration, and the name of an `import x = require()` declaration that is
- * not exported. None is judged in a declaration file or a component file.
+ * Every name one import declaration binds, in source order: the default, named and
+ * namespace names of an `import` declaration and the name of an `import x = …` declaration.
+ * A namespace import and an import assignment bind a whole module.
  */
-export function importBindings(file: SourceFile): readonly Identifier[] {
-  if (file.isDeclarationFile || !JUDGED.test(file.fileName)) {
-    return [];
+export function declarationBindings(
+  declaration: ImportDeclaration | ImportEqualsDeclaration,
+): readonly ImportBinding[] {
+  if (isImportEqualsDeclaration(declaration)) {
+    return [
+      {
+        name: declaration.name,
+        equals: {
+          exported: (declaration.modifiers ?? []).some(
+            (modifier) => modifier.kind === SyntaxKind.ExportKeyword,
+          ),
+          external: isExternalModuleReference(declaration.moduleReference),
+        },
+      },
+    ];
   }
-  const found: Identifier[] = [];
-  for (const statement of file.statements) {
-    if (isImportDeclaration(statement)) {
-      const clause = statement.importClause;
-      if (clause?.name !== undefined) {
-        found.push(clause.name);
-      }
-      const named = clause?.namedBindings;
-      if (named !== undefined && isNamespaceImport(named)) {
-        found.push(named.name);
-      } else if (named !== undefined) {
-        for (const element of named.elements) {
-          found.push(element.name);
-        }
-      }
-    } else if (
-      isImportEqualsDeclaration(statement) &&
-      isExternalModuleReference(statement.moduleReference) &&
-      isIdentifier(statement.name) &&
-      !(statement.modifiers ?? []).some((modifier) => modifier.kind === SyntaxKind.ExportKeyword)
-    ) {
-      found.push(statement.name);
+  const clause = declaration.importClause;
+  const found: ImportBinding[] = [];
+  if (clause?.name !== undefined) {
+    found.push({ name: clause.name, imported: "default" });
+  }
+  const named = clause?.namedBindings;
+  if (named !== undefined && isNamespaceImport(named)) {
+    found.push({ name: named.name });
+  } else if (named !== undefined) {
+    for (const element of named.elements) {
+      found.push({ name: element.name, imported: element.propertyName?.text ?? element.name.text });
     }
   }
   return found;
 }
 
+/** Every name one file's top-level import declarations bind, in source order. */
+export function bindingsOf(file: SourceFile): readonly ImportBinding[] {
+  const known = bindingsCache.get(file);
+  if (known !== undefined) {
+    return known;
+  }
+  const found = file.statements.flatMap((statement) =>
+    isImportDeclaration(statement) || isImportEqualsDeclaration(statement)
+      ? declarationBindings(statement)
+      : [],
+  );
+  bindingsCache.set(file, found);
+  return found;
+}
+
+/**
+ * The export names an import or a re-export declaration reads from the module it names,
+ * `undefined` standing for the whole module where a namespace or a star reads it; none for
+ * any other node.
+ */
+export function importedNames(node: Node): readonly (string | undefined)[] {
+  if (isImportDeclaration(node)) {
+    return declarationBindings(node).map((binding) => binding.imported);
+  }
+  if (!isExportDeclaration(node)) {
+    return [];
+  }
+  const clause = node.exportClause;
+  return clause === undefined || !isNamedExports(clause)
+    ? [undefined]
+    : clause.elements.map((one) => (one.propertyName ?? one.name).text);
+}
+
+/** The export names {@link importedNames} gives one node, without the whole module. */
+export function namesImported(node: Node): readonly string[] {
+  return importedNames(node).flatMap((name) => name ?? []);
+}
+
+/**
+ * The bindings of one file that are judged as imports: those of {@link bindingsOf} but an
+ * `import x = …` that is exported or names no external module. None is judged in a
+ * declaration file or a component file.
+ */
+export function importBindings(file: SourceFile): readonly Identifier[] {
+  if (file.isDeclarationFile || !JUDGED.test(file.fileName)) {
+    return [];
+  }
+  return bindingsOf(file).flatMap((binding) =>
+    binding.equals !== undefined && (binding.equals.exported || !binding.equals.external)
+      ? []
+      : [binding.name],
+  );
+}
+
 /** Whether one identifier names a binding in a local export, which reads it whatever it resolves to. */
 export function exportsLocally(use: Identifier): boolean {
   return isExportSpecifier(use.parent);