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

package/src/findings/completion.ts

@@ -110,12 +110,13 @@ function testedByIn(input: EmitterInput): ReadonlySet<string> {
  * published API, a public member of a published type included, is `certain` where the
  * run loaded every consumer the scope declared and declared one, `probable` where one did
  * not load, and `possible` where it declared none, whatever the configuration says of the
- * consumer set. A member an `in` expression tests by name, and one a function outside the
- * analysis fills, is `possible`.
+ * consumer set. A member an `in` expression tests by name, one a function outside the
+ * analysis fills, and one {@link possiblyLoaded} names, is `possible`.
  */
 function reachabilityClasses(input: EmitterInput): (id: string) => Confidence {
   const tested = testedByIn(input);
   const filled = input.boundary.filledOutside ?? new Set<string>();
+  const possible = possiblyLoaded(input);
   const published = publishedIds(input.swept.matrix.union);
   const { declared } = input.boundary.consumers;
   const outside: Confidence =
@@ -125,7 +126,7 @@ function reachabilityClasses(input: EmitterInput): (id: string) => Confidence {
         ? "certain"
         : "probable";
   return (id) => {
-    if (tested.has(id) || filled.has(id)) {
+    if (tested.has(id) || filled.has(id) || possible.has(id)) {
       return "possible";
     }
     return published.has(id) ? outside : "certain";
@@ -182,6 +183,36 @@ function testCeilings(
       : "certain";
 }
 
+/**
+ * What only a bundler's retry of an import Node leaves unresolved names (program.38), and each
+ * dead declaration that reaches through dead declarations, as confidence.20 reads what only
+ * tests reach: each is dead only while no loader the analysis does not see loads the file.
+ */
+function possiblyLoaded(input: EmitterInput): ReadonlySet<string> {
+  const seeds = input.boundary.possiblyLoaded ?? new Set<string>();
+  if (seeds.size === 0) {
+    return seeds;
+  }
+  const union = input.swept.matrix.union;
+  const dead = new Set(input.swept.sweep.candidates.map((one) => one.id));
+  const reached = new Set<string>();
+  const pending = union.symbols.flatMap((symbol, at) => (seeds.has(symbol.id) ? [at] : []));
+  for (let at = pending.pop(); at !== undefined; at = pending.pop()) {
+    const symbol = union.symbols[at];
+    if (symbol === undefined || reached.has(symbol.id)) {
+      continue;
+    }
+    reached.add(symbol.id);
+    for (const edge of union.out[at] ?? []) {
+      const to = union.symbols[edge.to];
+      if (to !== undefined && dead.has(to.id)) {
+        pending.push(edge.to);
+      }
+    }
+  }
+  return reached;
+}
+
 /**
  * The subjects dead only because production code only tests use is: each declaration the
  * sweep marks test-used, each `DS1602` file of such code, and each test of dead code every
@@ -373,6 +404,9 @@ export function completed(
     union.symbols.map((symbol, at) => [declarationKey(symbol.ref, symbol.position.path), at]),
   );
   const candidates = new Map(swept.sweep.candidates.map((candidate) => [candidate.id, candidate]));
+  const fileIds = new Map(
+    union.symbols.flatMap((one) => (one.kind === "file" ? [[one.position.path, one.id]] : [])),
+  );
   const classOf = reachabilityClasses(input);
   const ceilingOf = testCeilings(input, classOf);
   const testUsed = testUsedSubjects(input);
@@ -465,7 +499,12 @@ export function completed(
         ? union.made[at]
         : { production: candidate.productionRefs, test: candidate.testRefs };
     const ownClass =
-      judged === undefined ? (finding.reachabilityClass ?? "certain") : classOf(judged.id);
+      judged !== undefined
+        ? classOf(judged.id)
+        : (finding.reachabilityClass ??
+          (finding.code === CODE.fileNeverImported
+            ? classOf(fileIds.get(finding.position.path) ?? "")
+            : "certain"));
     const used =
       judged !== undefined
         ? candidate !== undefined && testUsed.declarations.has(judged.id)

package/src/findings/emitter.ts

@@ -3,7 +3,7 @@ import type { ResolvedConfig } from "../config.ts";
 import type { Dependencies } from "../dependencies.ts";
 import type { FileFacts } from "../file-facts.ts";
 import type { Finding } from "../finding.ts";
-import type { Implementations } from "../implementations.ts";
+import type { Implementations } from "./implementations.ts";
 import type { IntraFunctionFacts } from "../intra-function-parts.ts";
 import type { Stores } from "../stores.ts";
 import type { Boundary } from "./boundary.ts";

package/src/{implementations.ts → findings/implementations.ts}

@@ -15,10 +15,10 @@ import {
   type Node,
 } from "@typescript/native/ast";
 import { SymbolFlags, type Symbol as TSSymbol, type Type } from "@typescript/native/sync";
-import { aliasChains } from "./alias-chain.ts";
-import { nodeKey, type Inventory } from "./inventory.ts";
-import { must, Unanswerable } from "./query.ts";
-import type { ProjectView } from "./session.ts";
+import { aliasChains } from "../alias-chain.ts";
+import { nodeKey, type Inventory } from "../inventory.ts";
+import { must, Unanswerable } from "../query.ts";
+import type { ProjectView } from "../session.ts";
 
 /** What one run knows about how its interfaces are implemented. */
 export interface Implementations {

package/src/{in-operands.ts → findings/in-operands.ts}

@@ -11,9 +11,9 @@ import {
   SyntaxKind,
   type Node,
 } from "@typescript/native/ast";
-import type { ProjectView } from "./session.ts";
-import { sourceFilesOf } from "./source-files.ts";
-import { bytewise } from "./text/compare.ts";
+import type { ProjectView } from "../session.ts";
+import { sourceFilesOf } from "../source-files.ts";
+import { bytewise } from "../text/compare.ts";
 
 /**
  * The text of each string literal, or template literal with no substitution, written as

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/graph.ts

@@ -7,6 +7,7 @@
 
 import type { InventorySymbol, SymbolKind } from "./inventory.ts";
 import type { Reference } from "./references.ts";
+import { madeByTestCode } from "./tests/file-class.ts";
 import type { Root, RootKind } from "./roots/root-set.ts";
 
 /** The position of a declaration the inventory does not hold. */
@@ -85,12 +86,22 @@ export interface Edge {
    * module's top level and none of what it exports.
    */
   readonly evaluation: boolean;
+  /**
+   * Whether a loaded consumer made it, whose test references a mode may class as
+   * production. Only a consumed edge can be one.
+   */
+  readonly consumer: boolean;
 }
 
-/** How many references one declaration carries, split by the classification of the file that made each. */
-interface Counts {
+/**
+ * How many references one declaration carries, split by the classification of the file that
+ * made each; `consumerTest` counts the test references a loaded consumer's test files made,
+ * which a mode may class as production (`sweep.ts` `countedRefs`).
+ */
+export interface Counts {
   readonly production: number;
   readonly test: number;
+  readonly consumerTest: number;
 }
 
 /** One root the inventory holds, at the position of the declaration it names. */
@@ -156,23 +167,30 @@ export function graphOf(
   const tests = new Set(testFiles);
 
   const out: Edge[][] = symbols.map(() => []);
-  const made = symbols.map(() => ({ production: 0, test: 0 }));
+  const made = symbols.map(() => ({ production: 0, test: 0, consumerTest: 0 }));
   const consumed: Edge[] = [];
   for (const reference of references) {
     const to = at(reference.to);
     if (to === OUTSIDE) {
       continue;
     }
+    const test = madeByTestCode(reference, supports);
     const counts = made[to];
     if (counts !== undefined) {
-      if (reference.test) {
+      if (test) {
         counts.test += 1;
+        counts.consumerTest += reference.consumer === undefined ? 0 : 1;
       } else {
         counts.production += 1;
       }
     }
-    const edge = { to, test: reference.test, evaluation: reference.use === "evaluation" };
-    if (reference.consumer !== undefined || reference.unheld === true) {
+    const edge = {
+      to,
+      test,
+      evaluation: reference.use === "evaluation",
+      consumer: reference.consumer !== undefined,
+    };
+    if (edge.consumer || reference.unheld === true) {
       consumed.push(edge);
       continue;
     }

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);