@cplieger/deadset-ts 3.2.0 → 3.3.1

package/README.md

@@ -8,7 +8,7 @@ deadset-ts is a command-line analyzer for TypeScript and JavaScript projects. It
 
 deadset-ts is report-only. It never edits source, and it refuses any `--fix` flag.
 
-**Status: pre-release.** This version implements contract 3.0.0 and ships the analyzer's foundation: one compiler session per run over the projects `analysis.configurations` declares, in the order it lists them, each a compiler configuration file below the target, or, where it declares none, every `tsconfig` project discovered under the target (the explicit scope, every `tsconfig*.json`, each project's `references`), a fail-closed read of every project's diagnostics, configuration decoding against the contract's closed key list with `print-config` and its provenance, `print-projects`, the report-only guard, the symbol inventory of every declaration a project's own files hold down to its class and type members, the one-pass reference resolution over that inventory, which resolves each file's identifiers in batches ([batch-cap calibration](docs/batch-cap-calibration.md) is the measurement behind the batch size), and the root set `print-roots` prints. A root is a declaration the analysis keeps live without a reference: what a file exports when the manifest names it through `main`, `module`, `types`, `bin` or `exports`, or when `ts.entry_files` matches it; a library target's published API; the configuration, setup and test files of Vitest, Stryker and Playwright, the flat configuration of ESLint, and a worker or service worker a call addresses by a string literal; and every declaration a `roots.patterns` entry names. An entry that names nothing is reported as `DS1704` and fails the run. The entry-point conventions of other tools are not read, and `DECLINED_CONVENTIONS` lists each one with the reason. The analysis is reached through the command, and through `run()` for a caller that runs the command in-process; no other verb reports findings yet, so `analyze`, `explain` and `describe` exit with a usage message. The one runtime dependency is the `typescript` package at exactly 7.0.2, installed under the `@typescript/native` name until TypeScript 7.1 ships a compiler API the tooling can share.
+**Status: pre-release.** This version implements contract 3.0.0 and ships the analyzer's foundation: one compiler session per run over the projects `analysis.configurations` declares, in the order it lists them, each a compiler configuration file below the target, or, where it declares none, every `tsconfig` project discovered under the target (the explicit scope, every `tsconfig*.json`, each project's `references`), a fail-closed read of every project's diagnostics, configuration decoding against the contract's closed key list with `print-config` and its provenance, `print-projects`, the report-only guard, the symbol inventory of every declaration a project's own files hold down to its class and type members, the one-pass reference resolution over that inventory, which resolves each file's identifiers in batches ([batch-cap calibration](docs/batch-cap-calibration.md) is the measurement behind the batch size), and the root set `print-roots` prints. A root is a declaration the analysis keeps live without a reference: what a file exports when the manifest names it through `main`, `module`, `types`, `bin` or `exports`, or when `ts.entry_files` matches it; a library target's published API; the configuration, setup and test files of Vitest, Stryker and Playwright, the flat configuration of ESLint, and a worker or service worker a call addresses by a string literal; and every declaration a `roots.patterns` entry names. An entry that names nothing is reported as `DS1704` and fails the run. The entry-point conventions of other tools are not read, and `DECLINED_CONVENTIONS` lists each one with the reason. Four exemption classes hold a declaration back from the sweep, and `print-retained` lists what each one held back: `interface-satisfaction`, a member an interface requires of a class whose value reaches that interface; `decorator`, a decorated member and every member of a decorated class; and, at the lowest confidence, `template-field`, a member an action of a template under `analysis.template_dirs` names, and `reflective-lookup`, a member a literal key of an element access or of `Reflect.get`, `Reflect.set` or `Reflect.has` names. None of them holds back a `#private` member. The analysis is reached through the command, and through `run()` for a caller that runs the command in-process; no other verb reports findings yet, so `analyze`, `explain` and `describe` exit with a usage message. The one runtime dependency is the `typescript` package at exactly 7.0.2, installed under the `@typescript/native` name until TypeScript 7.1 ships a compiler API the tooling can share.
 
 ## Install
 
@@ -28,7 +28,7 @@ The npm package carries the command and the library as JavaScript that the compi
 npx deadset-ts version
 ```
 
-`version` prints the analyzer version and the Contract version it implements, and exits 0. `print-config`, `print-projects`, `print-roots` and `print-retained` print what their row of the table says and exit 0, or 1 when `print-roots` reports a `DS1704`, and `print-retained` exits 2 when an `exemptions.disabled` entry is not an exemption class. `analyze`, `explain`, `describe`, any other invocation and no arguments print the usage line and exit 2.
+`version` prints the analyzer version and the Contract version it implements, and exits 0. `print-config`, `print-projects`, `print-roots` and `print-retained` print what their row of the table says and exit 0, or 1 when `print-roots` reports a `DS1704`, and `print-retained` exits 2 when an `exemptions.disabled` entry is not an exemption class or an `analysis.template_dirs` entry is not a directory below the target root. `analyze`, `explain`, `describe`, any other invocation and no arguments print the usage line and exit 2.
 
 | Verb             | Job                                                                             |
 | ---------------- | ------------------------------------------------------------------------------- |

package/dist/src/analysis.js

@@ -7,16 +7,20 @@
  * carries a project's identity in its type so a handle cannot cross to another
  * project's checker, and that holds only for views the session itself hands out.
  */
+import { decorator } from "./decorator.js";
 import { diagnosticErrors, discoverProjects, DiscoveryError } from "./discover.js";
 import { computeExemptions, disabledClasses, exemptionsOf, retainedIn, } from "./exempt.js";
+import { interfaceSatisfaction } from "./interface-satisfaction.js";
 import { inventory } from "./inventory.js";
 import { readManifest } from "./manifest.js";
 import { matrixOf, sweepMatrix } from "./matrix.js";
 import { relativePath, resolvePath } from "./paths.js";
 import { byPosition } from "./position.js";
+import { reflectiveLookup } from "./reflective-lookup.js";
 import { references } from "./references.js";
 import { roots, unmatchedEverywhere, unmatchedRoots } from "./roots.js";
 import { diagnosticsOf, runSession } from "./session.js";
+import { readTemplates, templateField } from "./template-field.js";
 /** The setting whose source decides where a finding about a configured root sits. */
 const ROOTS_SETTING = "roots.patterns";
 /**
@@ -119,7 +123,12 @@ export function runRoots(engine, host, scope, config, provenance) {
     };
 }
 /** The exemption classes this analyzer detects, each by its detector; any other retains nothing. */
-const DETECTORS = new Map();
+const DETECTORS = new Map([
+    ["interface-satisfaction", interfaceSatisfaction],
+    ["template-field", templateField],
+    ["reflective-lookup", reflectiveLookup],
+    ["decorator", decorator],
+]);
 /**
  * Sweeps the run the scope and the configuration describe. Each project's references
  * and exemptions are read against its own inventory while its view is open; the
@@ -133,6 +142,9 @@ const DETECTORS = new Map();
 export function runSweep(engine, host, scope, config, input, detectors = DETECTORS) {
     const targetRoot = scope.target.path;
     const disabled = disabledClasses(config);
+    const templates = disabled.has("template-field")
+        ? { delimiters: config.analysis.templateDelimiters, files: [] }
+        : readTemplates(host, targetRoot, config.analysis);
     const read = readProjects(engine, host, scope, config, (project, projectRead) => {
         const resolved = references(project, projectRead.held, targetRoot, {
             testFiles: config.ts.testFiles,
@@ -144,7 +156,7 @@ export function runSweep(engine, host, scope, config, input, detectors = DETECTO
             roots: projectRead.rooted.liveUnderReachability,
             testFiles: resolved.testFilePaths,
         };
-        const exempt = computeExemptions({ project, held: projectRead.held, targetRoot }, detectors, {
+        const exempt = computeExemptions({ project, held: projectRead.held, targetRoot, templates }, detectors, {
             disabled,
             mode: input.mode,
             testFiles: new Set(resolved.testFilePaths),

package/dist/src/decorator.js

@@ -0,0 +1,64 @@
+/**
+ * The decorator class: a member a decorator expression is attached to, and every
+ * member of a class a decorator expression is attached to, is held back, because the
+ * decorator receives the member or the class when the class is defined and may reach
+ * the member by its name.
+ *
+ * The rule is read from the tree alone: a decorator is attached where it is written.
+ * The use the decorator itself makes of what it decorates is the reference pass's,
+ * which records it as a `decorator` reference; this class records only that the
+ * declaration is held back, and the member set of a decorated class is every member
+ * the inventory holds for the class, static members included.
+ */
+import { isCallExpression, isDecorator, } from "@typescript/native/unstable/ast";
+import { nodeKey } from "./inventory.js";
+import { renderPosition } from "./position.js";
+/** The kinds of declaration a decorator is attached to and holds back. */
+const DECORATED = new Set(["class", "method", "class-member"]);
+/** How one decorator is spelled in a record: its expression, without a call's arguments. */
+function spelled(decorator) {
+    const expression = decorator.expression;
+    const named = isCallExpression(expression) ? expression.expression : expression;
+    return `@${named.getText().replace(/\s+/gu, "")}`;
+}
+/**
+ * The decorator detector: each decorated member, and each member of a decorated
+ * class, recorded at the decorator.
+ */
+export function decorator(input) {
+    const { project, held, targetRoot } = input;
+    const byId = new Map(held.symbols.map((symbol) => [symbol.id, symbol]));
+    const membersOf = new Map();
+    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);
+            }
+        }
+    }
+    const found = [];
+    for (const file of project.ownSourceFiles()) {
+        const visit = (node) => {
+            const id = held.declarations.get(nodeKey(file, node));
+            const symbol = id === undefined ? undefined : byId.get(id);
+            if (symbol !== undefined && DECORATED.has(symbol.kind)) {
+                const modifiers = node.modifiers ?? [];
+                for (const attached of modifiers.filter(isDecorator)) {
+                    const detail = `decorated by ${spelled(attached)}`;
+                    const site = renderPosition(file, targetRoot, attached.getStart());
+                    const reached = symbol.kind === "class" ? (membersOf.get(symbol.id) ?? []) : [symbol];
+                    for (const member of reached) {
+                        found.push({ id: member.id, detail, site });
+                    }
+                }
+            }
+            node.forEachChild(visit);
+        };
+        file.forEachChild(visit);
+    }
+    return found;
+}

package/dist/src/exempt-classes.js

@@ -1,6 +1,7 @@
 /**
  * The exemption classes of the Contract's vocabulary, in its order: each class's name,
- * the languages it runs on and the confidence it is recorded at.
+ * the languages it runs on, the confidence it is recorded at and, for a class that runs
+ * on TypeScript, which private members it may retain.
  *
  * The rows are written out rather than read from the Contract at run time, for the
  * reason the fixed severity codes are, and a test holds them equal to the Contract
@@ -10,26 +11,72 @@
  */
 /** Every class of the vocabulary, in the order the Contract lists them. */
 export const EXEMPTION_CLASSES = [
-    { class: "interface-satisfaction", languages: ["go", "ts"], confidence: "certain" },
+    {
+        class: "interface-satisfaction",
+        languages: ["go", "ts"],
+        confidence: "certain",
+        typescriptVisibility: { private: false, privateName: false },
+    },
     { class: "encoding-reflection", languages: ["go"], confidence: "certain" },
     { class: "format-verb-contract", languages: ["go"], confidence: "certain" },
     { class: "errors-duck-typing", languages: ["go"], confidence: "certain" },
-    { class: "enum-group", languages: ["go", "ts"], confidence: "certain" },
+    {
+        class: "enum-group",
+        languages: ["go", "ts"],
+        confidence: "certain",
+        typescriptVisibility: { private: false, privateName: false },
+    },
     { class: "generated-file", languages: ["go"], confidence: "certain" },
     { class: "linkname-cgo-asm-plugin", languages: ["go"], confidence: "certain" },
-    { class: "template-field", languages: ["go", "ts"], confidence: "possible" },
-    { class: "reflective-lookup", languages: ["go", "ts"], confidence: "possible" },
-    { class: "decorator", languages: ["ts"], confidence: "certain" },
-    { class: "injection-container", languages: ["ts"], confidence: "certain" },
-    { class: "framework-lifecycle", languages: ["ts"], confidence: "certain" },
-    { class: "serialization-contract", languages: ["ts"], confidence: "certain" },
+    {
+        class: "template-field",
+        languages: ["go", "ts"],
+        confidence: "possible",
+        typescriptVisibility: { private: true, privateName: false },
+    },
+    {
+        class: "reflective-lookup",
+        languages: ["go", "ts"],
+        confidence: "possible",
+        typescriptVisibility: { private: true, privateName: false },
+    },
+    {
+        class: "decorator",
+        languages: ["ts"],
+        confidence: "certain",
+        typescriptVisibility: { private: true, privateName: false },
+    },
+    {
+        class: "injection-container",
+        languages: ["ts"],
+        confidence: "certain",
+        typescriptVisibility: { private: true, privateName: false },
+    },
+    {
+        class: "framework-lifecycle",
+        languages: ["ts"],
+        confidence: "certain",
+        typescriptVisibility: { private: true, privateName: false },
+    },
+    {
+        class: "serialization-contract",
+        languages: ["ts"],
+        confidence: "certain",
+        typescriptVisibility: { private: true, privateName: false },
+    },
 ];
 function runsOnTS(row) {
     const languages = row.languages;
     return languages.includes("ts");
 }
+const TS_ROWS = EXEMPTION_CLASSES.filter(runsOnTS);
 /** The classes that run on TypeScript, in the vocabulary's order. */
-export const TS_EXEMPTION_CLASSES = EXEMPTION_CLASSES.filter(runsOnTS).map((row) => row.class);
+export const TS_EXEMPTION_CLASSES = TS_ROWS.map((row) => row.class);
+const VISIBILITY = new Map(TS_ROWS.map((row) => [row.class, row.typescriptVisibility]));
+/** Which private members one class that runs on TypeScript may retain. */
+export function typescriptVisibilityOf(exemptionClass) {
+    return VISIBILITY.get(exemptionClass) ?? { private: false, privateName: false };
+}
 /** Whether one name is a class of the vocabulary, whichever language it runs on. */
 export function isExemptionClass(name) {
     return EXEMPTION_CLASSES.some((row) => row.class === name);

package/dist/src/exempt.js

@@ -7,7 +7,7 @@
  * hands it the table of the classes it has.
  */
 import { ConfigError } from "./config.js";
-import { EXEMPTION_CLASSES, isExemptionClass, TS_EXEMPTION_CLASSES, } from "./exempt-classes.js";
+import { EXEMPTION_CLASSES, isExemptionClass, TS_EXEMPTION_CLASSES, typescriptVisibilityOf, } from "./exempt-classes.js";
 import { byPosition, positionKey } from "./position.js";
 import { sweep } from "./sweep.js";
 /**
@@ -26,19 +26,39 @@ export function disabledClasses(config) {
     }
     return disabled;
 }
+/**
+ * Whether a class whose row states `allowed` may retain a member of one visibility. A
+ * declaration the inventory does not hold has no visibility to refuse it by.
+ */
+function retainable(allowed, visibility) {
+    if (visibility === "private") {
+        return allowed.private;
+    }
+    if (visibility === "private-name") {
+        return allowed.privateName;
+    }
+    return true;
+}
 /**
  * The records one project's detectors found, each class in the vocabulary's order and
- * none of a switched-off class. Under a production mode a record whose evidence is
- * written in a test file holds nothing, as a reference a test file makes is none there.
+ * none of a switched-off class. Evidence on a private member the class's row says it
+ * cannot retain is dropped first, whatever the detector found. Under a production mode
+ * a record whose evidence is written in a test file holds nothing, as a reference a
+ * test file makes is none there.
  */
 export function computeExemptions(input, detectors, holding) {
+    const visibility = new Map(input.held.symbols.map((symbol) => [symbol.id, symbol.visibility]));
     const found = [];
     for (const exemptionClass of TS_EXEMPTION_CLASSES) {
         const detect = detectors.get(exemptionClass);
         if (detect === undefined || holding.disabled.has(exemptionClass)) {
             continue;
         }
+        const allowed = typescriptVisibilityOf(exemptionClass);
         for (const evidence of detect(input)) {
+            if (!retainable(allowed, visibility.get(evidence.id))) {
+                continue;
+            }
             if (holding.mode.production && holding.testFiles.has(evidence.site.path)) {
                 continue;
             }

package/dist/src/findings/dependencies-and-module-machinery.js

@@ -0,0 +1,2 @@
+/** The findings of the dependencies-and-module-machinery family, `DS1600` to `DS1699`. */
+export const dependenciesAndModuleMachinery = () => [];

package/dist/src/findings/emitter.js

@@ -0,0 +1 @@
+export {};

package/dist/src/findings/emitters.js

@@ -0,0 +1,19 @@
+import { dependenciesAndModuleMachinery } from "./dependencies-and-module-machinery.js";
+import { interfaces } from "./interfaces.js";
+import { intraFunction } from "./intra-function.js";
+import { nonCodeArtifacts } from "./non-code-artifacts.js";
+import { readsAndWrites } from "./reads-and-writes.js";
+import { selfCheck } from "./self-check.js";
+import { unusedDeclarations } from "./unused-declarations.js";
+import { visibilityNarrowing } from "./visibility-narrowing.js";
+/** Every kind family this analyzer reports, each by its emitter, in code order. */
+export const EMITTERS = new Map([
+    ["unused-declarations", unusedDeclarations],
+    ["visibility-narrowing", visibilityNarrowing],
+    ["interfaces", interfaces],
+    ["reads-and-writes", readsAndWrites],
+    ["non-code-artifacts", nonCodeArtifacts],
+    ["dependencies-and-module-machinery", dependenciesAndModuleMachinery],
+    ["self-check", selfCheck],
+    ["intra-function", intraFunction],
+]);

package/dist/src/findings/interfaces.js

@@ -0,0 +1,2 @@
+/** The findings of the interfaces family, `DS1200` to `DS1299`. */
+export const interfaces = () => [];

package/dist/src/findings/intra-function.js

@@ -0,0 +1,2 @@
+/** The findings of the intra-function family, `DS1800` to `DS1899`. */
+export const intraFunction = () => [];

package/dist/src/findings/non-code-artifacts.js

@@ -0,0 +1,2 @@
+/** The findings of the non-code-artifacts family, `DS1500` to `DS1599`. */
+export const nonCodeArtifacts = () => [];

package/dist/src/findings/reads-and-writes.js

@@ -0,0 +1,2 @@
+/** The findings of the reads-and-writes family, `DS1300` to `DS1399`. */
+export const readsAndWrites = () => [];

package/dist/src/findings/self-check.js

@@ -0,0 +1,2 @@
+/** The findings of the self-check family, `DS1700` to `DS1799`. */
+export const selfCheck = () => [];

package/dist/src/findings/unused-declarations.js

@@ -0,0 +1,2 @@
+/** The findings of the unused-declarations family, `DS1000` to `DS1099`. */
+export const unusedDeclarations = () => [];

package/dist/src/findings/visibility-narrowing.js

@@ -0,0 +1,2 @@
+/** The findings of the visibility-narrowing family, `DS1100` to `DS1199`. */
+export const visibilityNarrowing = () => [];

package/dist/src/interface-satisfaction.js

@@ -0,0 +1,310 @@
+/**
+ * The interface-satisfaction class: a class member is held back when a value of the
+ * class reaches a position the checker types as an interface requiring a member of
+ * that name, so a caller reaches the member through the interface while no name in
+ * the program resolves to it.
+ *
+ * A value reaches such a position as an `implements` entry, the initializer of a
+ * declaration whose type is written, an assignment, an argument, a returned value, an
+ * array element, an object property, or the operand of `as` or `satisfies`, read
+ * through parentheses, conditionals and the operators whose result is an operand.
+ * `this` in an instance member is a value of its class. Types are asked in batches;
+ * the contextual lookup has none, so it is asked only of a value whose type is a class
+ * of the target, and each distinct pair, interface and class is asked once.
+ */
+import { isArrayLiteralExpression, isArrowFunction, isAsExpression, isBinaryExpression, isCallExpression, isClassDeclaration, isClassExpression, isClassStaticBlockDeclaration, isConditionalExpression, isFunctionDeclaration, isFunctionExpression, isGetAccessorDeclaration, isHeritageClause, isIdentifier, isMethodDeclaration, isNewExpression, isObjectLiteralExpression, isParameterDeclaration, isParenthesizedExpression, isPropertyAssignment, isPropertyDeclaration, isReturnStatement, isSatisfiesExpression, isSetAccessorDeclaration, isShorthandPropertyAssignment, isSpreadElement, isVariableDeclaration, ModifierFlags, SyntaxKind, } from "@typescript/native/unstable/ast";
+import { SymbolFlags } from "@typescript/native/unstable/sync";
+import { aliasChains } from "./alias-chain.js";
+import { nodeKey } from "./inventory.js";
+import { renderPosition } from "./position.js";
+import { DEFAULT_BATCH_CAP } from "./references.js";
+/** The operators of an assignment whose right side is stored into the left side's type. */
+const STORES = new Set([
+    SyntaxKind.EqualsToken,
+    SyntaxKind.QuestionQuestionEqualsToken,
+    SyntaxKind.BarBarEqualsToken,
+    SyntaxKind.AmpersandAmpersandEqualsToken,
+]);
+/** Whether one node declares a static member, whose `this` is the class itself. */
+function isStatic(node) {
+    const flags = node.modifierFlags ?? 0;
+    return (flags & ModifierFlags.Static) !== 0;
+}
+/** Whether one node is a method or an accessor of an object literal, whose `this` is the literal. */
+function isObjectLiteralMethod(node) {
+    return ((isMethodDeclaration(node) ||
+        isGetAccessorDeclaration(node) ||
+        isSetAccessorDeclaration(node)) &&
+        isObjectLiteralExpression(node.parent));
+}
+/** Whether a declaration writes its type, so its initializer is read in that type's context. */
+function writesType(node) {
+    return node.type !== undefined;
+}
+/**
+ * The values one written expression hands on: the expression itself, or what it
+ * evaluates to through parentheses, a conditional and the operators whose result is
+ * one of their operands.
+ */
+function valuesOf(expression) {
+    if (isParenthesizedExpression(expression)) {
+        return valuesOf(expression.expression);
+    }
+    if (isConditionalExpression(expression)) {
+        return [...valuesOf(expression.whenTrue), ...valuesOf(expression.whenFalse)];
+    }
+    if (isBinaryExpression(expression)) {
+        const operator = expression.operatorToken.kind;
+        if (operator === SyntaxKind.QuestionQuestionToken || operator === SyntaxKind.BarBarToken) {
+            return [...valuesOf(expression.left), ...valuesOf(expression.right)];
+        }
+        if (operator === SyntaxKind.AmpersandAmpersandToken || operator === SyntaxKind.CommaToken) {
+            return valuesOf(expression.right);
+        }
+    }
+    return [expression];
+}
+/** The expressions one node hands to a position typed by its context. */
+function handedOn(node) {
+    if ((isVariableDeclaration(node) || isPropertyDeclaration(node) || isParameterDeclaration(node)) &&
+        node.initializer !== undefined &&
+        writesType(node)) {
+        return [node.initializer];
+    }
+    if (isBinaryExpression(node) && STORES.has(node.operatorToken.kind)) {
+        return [node.right];
+    }
+    if (isCallExpression(node) || isNewExpression(node)) {
+        return (node.arguments ?? []).filter((argument) => !isSpreadElement(argument));
+    }
+    if (isReturnStatement(node)) {
+        return node.expression === undefined ? [] : [node.expression];
+    }
+    if (isArrowFunction(node)) {
+        return node.body.kind === SyntaxKind.Block ? [] : [node.body];
+    }
+    if (isArrayLiteralExpression(node)) {
+        return node.elements.filter((element) => !isSpreadElement(element) && element.kind !== SyntaxKind.OmittedExpression);
+    }
+    if (isPropertyAssignment(node)) {
+        return [node.initializer];
+    }
+    if (isShorthandPropertyAssignment(node)) {
+        return isIdentifier(node.name) ? [node.name] : [];
+    }
+    if (isAsExpression(node) || isSatisfiesExpression(node)) {
+        return [node.expression];
+    }
+    return [];
+}
+/**
+ * The classes, the `implements` entries and the flowing values of one project's own
+ * files. `this` is the class an instance member belongs to, so a function that is not
+ * an arrow, a static member and a static block each stop it.
+ */
+function walk(files, declarations) {
+    const classes = [];
+    const clauses = [];
+    const flows = [];
+    for (const file of files) {
+        const visit = (node, self) => {
+            let inner = self;
+            if (isClassDeclaration(node) || isClassExpression(node)) {
+                const id = declarations.get(nodeKey(file, node));
+                const name = node.name;
+                const owner = id === undefined || name === undefined
+                    ? undefined
+                    : { id, name, generic: node.typeParameters !== undefined };
+                if (owner !== undefined) {
+                    classes.push(owner);
+                    for (const clause of node.heritageClauses ?? []) {
+                        if (isHeritageClause(clause) && clause.token === SyntaxKind.ImplementsKeyword) {
+                            clauses.push(...clause.types.map((entry) => ({ owner, entry })));
+                        }
+                    }
+                }
+                inner = owner;
+            }
+            else if (isFunctionDeclaration(node) ||
+                isFunctionExpression(node) ||
+                isClassStaticBlockDeclaration(node) ||
+                isStatic(node) ||
+                isObjectLiteralMethod(node)) {
+                inner = undefined;
+            }
+            for (const written of handedOn(node)) {
+                for (const value of valuesOf(written)) {
+                    flows.push({
+                        value,
+                        self: value.kind === SyntaxKind.ThisKeyword ? inner : undefined,
+                    });
+                }
+            }
+            node.forEachChild((child) => {
+                visit(child, inner);
+            });
+        };
+        file.forEachChild((child) => {
+            visit(child, undefined);
+        });
+    }
+    return { classes, clauses, flows };
+}
+/**
+ * The interface-satisfaction detector: for each class type that reaches an interface
+ * type it is assignable to, the class's members whose names the interface's members
+ * carry, each recorded at the place the value flows.
+ */
+export function interfaceSatisfaction(input) {
+    const { project, held, targetRoot } = input;
+    const checker = project.checker;
+    const files = project.ownSourceFiles();
+    const { classes, clauses, flows } = walk(files, held.declarations);
+    if (classes.length === 0) {
+        return [];
+    }
+    // One list, so the batches are capped runs of the whole project rather than of a
+    // file: a class's name, an `implements` entry and a value are each one question.
+    const asked = [
+        ...classes.map((owner) => owner.name),
+        ...clauses.map((clause) => clause.entry),
+        ...flows.filter((flow) => flow.self === undefined).map((flow) => flow.value),
+    ];
+    const typeAt = new Map();
+    for (let from = 0; from < asked.length; from += DEFAULT_BATCH_CAP) {
+        const run = asked.slice(from, from + DEFAULT_BATCH_CAP);
+        checker.getTypeAtLocation(run).forEach((type, index) => {
+            const node = run[index];
+            if (type !== undefined && node !== undefined) {
+                typeAt.set(node, type);
+            }
+        });
+    }
+    const classOfType = new Map();
+    const instanceOf = new Map();
+    for (const owner of classes) {
+        const type = typeAt.get(owner.name);
+        if (type !== undefined) {
+            classOfType.set(type.id, owner);
+            instanceOf.set(owner.id, type);
+        }
+    }
+    const instantiates = classes.some((owner) => owner.generic);
+    const constituents = new Map();
+    const partsOf = (type) => {
+        if (!type.isUnionType() && !type.isIntersectionType()) {
+            return [type];
+        }
+        let parts = constituents.get(type.id);
+        if (parts === undefined) {
+            parts = type.getTypes();
+            constituents.set(type.id, parts);
+        }
+        return parts;
+    };
+    const targets = new Map();
+    /** The classes of the target one value's type is an instance of, with the instance type. */
+    const classesOf = (type) => partsOf(type).flatMap((part) => {
+        const direct = classOfType.get(part.id);
+        if (direct !== undefined) {
+            return [{ owner: direct, type: part }];
+        }
+        if (!instantiates || !part.isTypeReference()) {
+            return [];
+        }
+        if (!targets.has(part.id)) {
+            targets.set(part.id, classOfType.get(part.getTarget().id));
+        }
+        const generic = targets.get(part.id);
+        return generic === undefined ? [] : [{ owner: generic, type: part }];
+    });
+    const interfaceNames = new Map();
+    /** The interface types one position's type is or holds, each with the interface's name. */
+    const interfacesOf = (type) => partsOf(type).flatMap((part) => {
+        if (!interfaceNames.has(part.id)) {
+            const symbol = part.isObjectType() ? part.getSymbol() : undefined;
+            interfaceNames.set(part.id, symbol !== undefined && (symbol.flags & SymbolFlags.Interface) !== 0
+                ? symbol.name
+                : undefined);
+        }
+        const name = interfaceNames.get(part.id);
+        return name === undefined ? [] : [{ type: part, name }];
+    });
+    const pairs = new Map();
+    const reach = (owner, source, target, name, site) => {
+        const key = `${String(source.id)}:${String(target.id)}`;
+        const pair = pairs.get(key);
+        if (pair === undefined) {
+            pairs.set(key, { owner, source, target, name, sites: [site] });
+        }
+        else {
+            pair.sites.push(site);
+        }
+    };
+    for (const clause of clauses) {
+        const source = instanceOf.get(clause.owner.id);
+        const target = typeAt.get(clause.entry);
+        if (source === undefined || target === undefined) {
+            continue;
+        }
+        for (const reached of interfacesOf(target)) {
+            reach(clause.owner, source, reached.type, reached.name, clause.entry);
+        }
+    }
+    for (const flow of flows) {
+        const self = flow.self === undefined ? undefined : instanceOf.get(flow.self.id);
+        const valueType = typeAt.get(flow.value);
+        const sources = flow.self !== undefined && self !== undefined
+            ? [{ owner: flow.self, type: self }]
+            : valueType === undefined
+                ? []
+                : classesOf(valueType);
+        if (sources.length === 0) {
+            continue;
+        }
+        const position = checker.getContextualType(flow.value);
+        if (position === undefined) {
+            continue;
+        }
+        for (const reached of interfacesOf(position)) {
+            for (const source of sources) {
+                reach(source.owner, source.type, reached.type, reached.name, flow.value);
+            }
+        }
+    }
+    const chains = aliasChains(project, held);
+    const required = new Map();
+    const members = new Map();
+    const found = [];
+    for (const pair of pairs.values()) {
+        if (!checker.isTypeAssignableTo(pair.source, pair.target)) {
+            continue;
+        }
+        let names = required.get(pair.target.id);
+        if (names === undefined) {
+            names = new Set(checker.getPropertiesOfType(pair.target).map((property) => property.escapedName));
+            required.set(pair.target.id, names);
+        }
+        let answering = members.get(pair.owner.id);
+        if (answering === undefined) {
+            const instance = instanceOf.get(pair.owner.id) ?? pair.source;
+            answering = new Map(checker
+                .getPropertiesOfType(instance)
+                .map((property) => [property.escapedName, chains.declarationsOf(property)]));
+            members.set(pair.owner.id, answering);
+        }
+        const detail = `satisfies ${pair.name}`;
+        for (const name of names) {
+            for (const id of answering.get(name) ?? []) {
+                for (const site of pair.sites) {
+                    found.push({
+                        id,
+                        detail,
+                        site: renderPosition(site.getSourceFile(), targetRoot, site.getStart()),
+                    });
+                }
+            }
+        }
+    }
+    return found;
+}