@cplieger/deadset-ts 3.3.0 → 3.4.0

package/dist/src/run.js

@@ -1,29 +1,30 @@
-import { runRoots, runSweep } from "./analysis.js";
 import { ConfigError, REPOSITORY_DOCUMENT } from "./config.js";
-import { diagnosticErrors, discoverProjects, DiscoveryError, renderDiagnostic, } from "./discover.js";
-import { retainedLines } from "./exempt.js";
+import { DiscoveryError, renderDiagnostic } from "./discover.js";
+import { EMITTERS } from "./findings/emitters.js";
 import { joinPath, resolvePath } from "./paths.js";
-import { printConfig } from "./print.js";
-import { resolve, resolveMatrix } from "./resolve.js";
 import { readScope, ScopeError, scopeForDir } from "./scope.js";
-import { diagnosticsOf, openEngine, runSession } from "./session.js";
-import { CONTRACT_VERSION } from "./version.js";
-/** The exit codes the Contract's exit-code table names. */
-const EXIT_CLEAN = 0;
-const EXIT_FINDINGS = 1;
-const EXIT_USAGE = 2;
-const EXIT_FAILURE = 3;
+import { openEngine } from "./session.js";
+import { printConfigVerb } from "./verbs/print-config.js";
+import { printProjectsVerb } from "./verbs/print-projects.js";
+import { printRetainedVerb } from "./verbs/print-retained.js";
+import { printRootsVerb } from "./verbs/print-roots.js";
+import { EXIT_FAILURE, EXIT_USAGE } from "./verbs/verb.js";
+import { versionVerb } from "./verbs/version.js";
+/**
+ * Every verb this command answers, in the order the usage text lists them. A verb
+ * with no `run` is listed, and invoking it is a usage error.
+ */
 const VERBS = [
-    "analyze",
-    "explain",
-    "print-config",
-    "print-projects",
-    "print-roots",
-    "print-retained",
-    "describe",
-    "version",
+    { name: "analyze" },
+    { name: "explain" },
+    { name: "print-config", run: printConfigVerb },
+    { name: "print-projects", run: printProjectsVerb },
+    { name: "print-roots", run: printRootsVerb },
+    { name: "print-retained", run: printRetainedVerb },
+    { name: "describe" },
+    { name: "version", run: versionVerb },
 ];
-const USAGE = `usage: deadset-ts <verb> [options]\nverbs: ${VERBS.join(", ")}\n`;
+const USAGE = `usage: deadset-ts <verb> [options]\nverbs: ${VERBS.map((verb) => verb.name).join(", ")}\n`;
 /**
  * The tokens whose presence in an option's name makes that option a request to
  * edit a source file. The set is closed, and a token is matched in any position of
@@ -31,15 +32,11 @@ const USAGE = `usage: deadset-ts <verb> [options]\nverbs: ${VERBS.join(", ")}\n`
  */
 const SOURCE_EDIT_TOKENS = ["fix", "edit", "delete", "rewrite"];
 /**
- * Maps an option name to the setting it supplies, so one entry registers the
- * option, supplies the document resolution reads, and gives the spelling the
- * setting's provenance names.
- *
- * An option's name is this command's own vocabulary, chosen for how it reads on a
- * command line, and its path is the setting of the Contract's configuration schema
- * that option supplies. The two are mapped here and never derived from one
- * another, so this table is the authority for both: a setting reaches the command
- * line only by an entry, and a path names a key the schema declares.
+ * Maps an option name to the setting of the Contract's configuration schema it supplies,
+ * so one entry registers the option, supplies the document resolution reads, and gives
+ * the spelling the setting's provenance names. The name is this command's vocabulary and
+ * is never derived from the path: a setting reaches the command line only by an entry,
+ * and a path names a key the schema declares.
  */
 export const SETTING_OPTIONS = new Map([
     ["min-confidence", "analysis.min_confidence"],
@@ -139,20 +136,13 @@ function scopeOf(host, options) {
     return scopeForDir(host, options.named.get("target") ?? ".");
 }
 /**
- * Runs the deadset-ts command line over `args` (the arguments after the program
- * name) and returns the process exit code: 0 for a completed verb, 2 for a usage
- * error or a configuration this analyzer refuses, 3 for a failure that produced no
- * answer. It writes nothing outside `out` and `err` and never exits the process,
- * so a caller decides what the code means.
- *
- * An option asking for a source edit is refused before the verb is read: this
- * analyzer reports and never edits a source file.
- *
- * `host` is the platform the run reads, the version it reports included;
- * `openClient` opens the compiler client a verb that reads projects needs.
- * Both are parameters because both are the platform, which no module below this one
- * names: the command entry binds them, and a caller that wants to watch what a run
- * reads supplies its own.
+ * Runs the command line over `args`, the arguments after the program name, and returns
+ * the exit code: 0 for a completed verb, 1 for a finding that fails the run, 2 for a
+ * usage error, a requested source edit or a refused configuration, 3 for a failure that
+ * produced no answer. It writes nothing outside `out` and `err` and never exits the
+ * process. `host` is the platform the run reads, the version it reports included, and
+ * `openClient` opens the compiler client; a caller that watches what a run reads
+ * supplies its own of either.
  */
 export function run(args, out, err, host, openClient = (collectTiming) => openEngine({ collectTiming })) {
     const editing = sourceEditOption(args);
@@ -161,151 +151,45 @@ export function run(args, out, err, host, openClient = (collectTiming) => openEn
         err.write(USAGE);
         return EXIT_USAGE;
     }
-    const verb = args[0];
-    if (verb === "version") {
-        out.write(`deadset-ts ${host.analyzerVersion()}\ncontract ${CONTRACT_VERSION}\n`);
-        return EXIT_CLEAN;
-    }
-    if (verb === "print-config") {
-        return printConfigVerb(args.slice(1), out, err, host);
-    }
-    if (verb === "print-projects") {
-        return printProjectsVerb(args.slice(1), out, err, host, openClient);
-    }
-    if (verb === "print-roots") {
-        return printRootsVerb(args.slice(1), out, err, host, openClient);
+    const name = args[0];
+    const verb = VERBS.find((listed) => listed.name === name);
+    if (verb?.run !== undefined) {
+        return invoke(verb.run, args.slice(1), { out, err, host }, openClient);
     }
-    if (verb === "print-retained") {
-        return printRetainedVerb(args.slice(1), out, err, host, openClient);
-    }
-    if (verb !== undefined && VERBS.includes(verb)) {
-        err.write(`deadset-ts: ${verb} is not implemented\n`);
+    if (verb !== undefined) {
+        err.write(`deadset-ts: ${verb.name} is not implemented\n`);
         return EXIT_USAGE;
     }
-    if (verb !== undefined) {
-        err.write(`deadset-ts: unknown verb ${JSON.stringify(verb)}\n`);
+    if (name !== undefined) {
+        err.write(`deadset-ts: unknown verb ${JSON.stringify(name)}\n`);
     }
     err.write(USAGE);
     return EXIT_USAGE;
 }
-/** Writes the resolved configuration with the source of every setting. */
-function printConfigVerb(args, out, err, host) {
-    try {
-        const options = readOptions(args);
-        const { config, provenance } = resolve(inputsOf(host, options));
-        out.write(printConfig(config, provenance));
-        return EXIT_CLEAN;
-    }
-    catch (error) {
-        return refuse(error, err);
-    }
-}
 /**
- * Writes the name of every project one run analyzes, one per line, having read each
- * project's diagnostics first: the identifier the build matrix declares for it, or,
- * where discovery derived the project, its configuration file's path below the
- * target root.
+ * Runs one verb over the arguments after its name. The options are read the first
+ * time the verb asks for what they name, and a refusal the verb throws is written
+ * and turned into its exit code once the client the verb opened is closed.
  */
-function printProjectsVerb(args, out, err, host, openClient) {
-    let engine;
+function invoke(verb, args, streams, openClient) {
+    let options;
+    const read = () => (options ??= readOptions(args));
+    let opened;
     try {
-        const options = readOptions(args);
-        const matrix = resolveMatrix(inputsOf(host, options));
-        const scope = scopeOf(host, options);
-        engine = openClient(false);
-        const discovered = discoverProjects(engine, host, scope, matrix);
-        const ids = new Map(discovered.projects.map((project) => [project.configFile, project.id]));
-        const failures = [];
-        const { projects } = runSession(engine, discovered.configFiles, (project) => {
-            const errors = diagnosticErrors(diagnosticsOf(project));
-            failures.push(...errors.map(renderDiagnostic));
-            return ids.get(project.configFile) ?? project.configFile;
+        return verb({
+            ...streams,
+            inputs: () => inputsOf(streams.host, read()),
+            scope: () => scopeOf(streams.host, read()),
+            openClient: (collectTiming) => {
+                opened = openClient(collectTiming);
+                return opened;
+            },
+            emitters: EMITTERS,
         });
-        if (failures.length > 0) {
-            for (const line of failures) {
-                err.write(`${line}\n`);
-            }
-            err.write(`deadset-ts: ${String(failures.length)} error(s); no answer was produced\n`);
-            return EXIT_FAILURE;
-        }
-        for (const id of projects) {
-            out.write(`${id}\n`);
-        }
-        return EXIT_CLEAN;
-    }
-    catch (error) {
-        engine?.close();
-        return refuse(error, err);
-    }
-}
-/**
- * One root as a line: the declaration's reference, why it is a root, and the string
- * that named it, separated by tabs. A run of several configurations adds the ones
- * whose project holds the root as a fourth field, and writes the third present and
- * empty where no string named the root, so every line of one run holds the same
- * fields.
- */
-function rootLine(root, several) {
-    const line = `${root.ref}\t${root.kind}`;
-    if (several) {
-        return `${line}\t${root.source}\t${root.configurations.join(" ")}`;
-    }
-    return root.source === "" ? line : `${line}\t${root.source}`;
-}
-/**
- * Writes the root set of the run, one root per line, and then names on the error
- * stream, by its issue kind, every configured root or pattern that named nothing;
- * one such string fails the run. The line shape is this command's own rather than a
- * Contract format, so that sort and cut read it.
- */
-function printRootsVerb(args, out, err, host, openClient) {
-    let engine;
-    try {
-        const options = readOptions(args);
-        const { config, provenance } = resolve(inputsOf(host, options));
-        const scope = scopeOf(host, options);
-        engine = openClient(false);
-        const answer = runRoots(engine, host, scope, config, provenance);
-        const several = answer.configurations.length > 1;
-        for (const root of answer.roots) {
-            out.write(`${rootLine(root, several)}\n`);
-        }
-        for (const finding of answer.findings) {
-            err.write(`${finding.code}: roots.patterns names nothing: ${finding.symbol.ref}\n`);
-        }
-        return answer.findings.length > 0 ? EXIT_FINDINGS : EXIT_CLEAN;
-    }
-    catch (error) {
-        engine?.close();
-        return refuse(error, err);
-    }
-}
-/**
- * Writes every declaration an exemption held back in the production sweep a report is
- * built from, one per line, and nothing where no exemption held one back. One fact
- * several configurations found is one record, so the line names no configuration. The
- * line shape is this command's own rather than a Contract format, so that sort and cut
- * read it.
- */
-function printRetainedVerb(args, out, err, host, openClient) {
-    let engine;
-    try {
-        const options = readOptions(args);
-        const { config } = resolve(inputsOf(host, options));
-        const scope = scopeOf(host, options);
-        engine = openClient(false);
-        const swept = runSweep(engine, host, scope, config, {
-            marked: [],
-            mode: { production: true },
-        });
-        for (const line of retainedLines(swept.matrix.union.symbols, swept.retained)) {
-            out.write(`${line}\n`);
-        }
-        return EXIT_CLEAN;
     }
     catch (error) {
-        engine?.close();
-        return refuse(error, err);
+        opened?.close();
+        return refuse(error, streams.err);
     }
 }
 /** Turns one refusal into the exit code the Contract's table gives it. */

package/dist/src/schema.js

@@ -1,5 +1,10 @@
 import { ConfigError } from "./config.js";
 const leaf = { kind: "leaf" };
+/** A list of declarations, each entry in one of the three shapes the `ts` section states. */
+const declarations = {
+    kind: "list",
+    members: { symbol: leaf, module: leaf, name: leaf, global: leaf },
+};
 /**
  * The closed key list the Contract's configuration schema declares, derived from
  * that schema key by key. A test pins the two equal, so a Contract change that
@@ -44,7 +49,19 @@ export const SCHEMA_ROOT = {
             },
         },
         go: { kind: "section", members: {} },
-        ts: { kind: "section", members: { test_files: leaf, entry_files: leaf } },
+        ts: {
+            kind: "section",
+            members: {
+                test_files: leaf,
+                entry_files: leaf,
+                injection_registrations: declarations,
+                lifecycle_contracts: {
+                    kind: "list",
+                    members: { components: declarations, bases: declarations, members: leaf },
+                },
+                serializers: declarations,
+            },
+        },
         provenance: { kind: "map" },
     },
 };

package/dist/src/serialization-contract.js

@@ -0,0 +1,315 @@
+/**
+ * The serialization-contract class: the properties of a class whose values reach
+ * `JSON.stringify` or a call `ts.serializers` names, and those and `toJSON` and
+ * `toString` where a value is passed to an `unknown` or `any` parameter of a function
+ * outside the analysis. A function of the project handing such a parameter of its own
+ * to a destination is one, holding back what that destination does, to a fixpoint.
+ */
+import { isArrowFunction, isClassDeclaration, isClassExpression, isClassStaticBlockDeclaration, isFunctionDeclaration, isFunctionExpression, isGetAccessorDeclaration, isIdentifier, isMethodDeclaration, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectLiteralExpression, isParenthesizedExpression, isSetAccessorDeclaration, isSpreadElement, isStringLiteral, isVariableDeclaration, ModifierFlags, SyntaxKind, } from "@typescript/native/unstable/ast";
+import { SymbolFlags, TypeFlags, } from "@typescript/native/unstable/sync";
+import { aliasChains } from "./alias-chain.js";
+import { calleeName, resolvedTargets, valuesPassed } from "./calls.js";
+import { classMembers, memberComponent, typesAt } from "./class-members.js";
+import { names, namesADeclaration, resolveEntries, spelledEntry, } from "./configured-declarations.js";
+import { nodeKey } from "./inventory.js";
+import { renderPosition } from "./position.js";
+import { valueReach } from "./value-reach.js";
+/** The serializer every run reads, whatever the configuration names. */
+const JSON_STRINGIFY = { shape: "global", global: "JSON.stringify" };
+/** The methods a serializer and a formatter resolve by name on a value that left the analysis. */
+const CONVERSIONS = new Set(["toJSON", "toString"]);
+/** The parameter types that keep nothing of the value they are given. */
+const ERASED = TypeFlags.Any | TypeFlags.Unknown;
+/** The wider of two reaches, where either may be absent. */
+function wider(a, b) {
+    return a === "conversions" || b === "conversions" ? "conversions" : (a ?? b);
+}
+/** 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 opens a body whose `this` is not an instance of the enclosing class. */
+function resetsThis(node) {
+    return (isFunctionDeclaration(node) ||
+        isFunctionExpression(node) ||
+        isClassStaticBlockDeclaration(node) ||
+        isStatic(node) ||
+        ((isMethodDeclaration(node) ||
+            isGetAccessorDeclaration(node) ||
+            isSetAccessorDeclaration(node)) &&
+            isObjectLiteralExpression(node.parent)));
+}
+/** The parameters and declaring node of one function-like declaration of the project. */
+function functionOf(node) {
+    if (isFunctionDeclaration(node) ||
+        (isMethodDeclaration(node) && !isObjectLiteralExpression(node.parent))) {
+        return { declared: node, parameters: node.parameters };
+    }
+    if (isVariableDeclaration(node) &&
+        node.initializer !== undefined &&
+        (isArrowFunction(node.initializer) || isFunctionExpression(node.initializer))) {
+        return { declared: node, parameters: node.initializer.parameters };
+    }
+    return undefined;
+}
+/** Whether one parameter is a `this` parameter, which types `this` and binds no argument. */
+function isThisParameter(parameter) {
+    return isIdentifier(parameter.name) && parameter.name.text === "this";
+}
+/** Whether an argument is written in a form that holds no class instance, which saves a type. */
+function holdsNoInstance(argument) {
+    return (isArrowFunction(argument) ||
+        isFunctionExpression(argument) ||
+        isStringLiteral(argument) ||
+        isNumericLiteral(argument) ||
+        isNoSubstitutionTemplateLiteral(argument) ||
+        argument.kind === SyntaxKind.TemplateExpression);
+}
+/** The expression an argument evaluates, through parentheses and a spread. */
+function evaluated(argument) {
+    const value = isSpreadElement(argument) ? argument.expression : argument;
+    return isParenthesizedExpression(value) ? evaluated(value.expression) : value;
+}
+/**
+ * Every call of the project's own files with the class `this` stands for there, and
+ * every identifier-named parameter of every function, method and function-valued
+ * variable the project declares, at the position of the argument it binds.
+ */
+function walkProject(project, held) {
+    const sites = [];
+    const parameters = [];
+    for (const file of project.ownSourceFiles()) {
+        const visit = (node, self) => {
+            let inner = self;
+            if (isClassDeclaration(node) || isClassExpression(node)) {
+                inner = held.declarations.get(nodeKey(file, node));
+            }
+            else if (resetsThis(node)) {
+                inner = undefined;
+            }
+            if (node.kind === SyntaxKind.CallExpression) {
+                sites.push({ call: node, self });
+            }
+            const fn = functionOf(node);
+            const id = fn === undefined ? undefined : held.declarations.get(nodeKey(file, fn.declared));
+            if (fn !== undefined && id !== undefined) {
+                fn.parameters
+                    .filter((parameter) => !isThisParameter(parameter))
+                    .forEach((parameter, index) => {
+                    if (isIdentifier(parameter.name)) {
+                        parameters.push({
+                            fn: id,
+                            index,
+                            rest: parameter.dotDotDotToken !== undefined,
+                            name: parameter.name,
+                        });
+                    }
+                });
+            }
+            node.forEachChild((child) => {
+                visit(child, inner);
+            });
+        };
+        file.forEachChild((child) => {
+            visit(child, undefined);
+        });
+    }
+    return { sites, parameters };
+}
+/**
+ * The parameters that keep nothing of the value they are given: one typed `unknown` or
+ * `any`, and a rest parameter whose elements are, each by its symbol.
+ */
+function erasedParameters(project, parameters) {
+    const types = typesAt(project, parameters.map((parameter) => parameter.name));
+    const erased = parameters.filter((parameter, index) => {
+        const type = types[index];
+        if (type === undefined) {
+            return false;
+        }
+        if (!parameter.rest) {
+            return (type.flags & ERASED) !== 0;
+        }
+        const [element] = type.isTypeReference() ? project.checker.getTypeArguments(type) : [];
+        return element !== undefined && (element.flags & ERASED) !== 0;
+    });
+    const bySymbol = new Map();
+    project
+        .symbolsAt(erased.map((parameter) => project.handle(parameter.name)))
+        .forEach((symbol, index) => {
+        const parameter = erased[index];
+        if (symbol !== undefined && parameter !== undefined) {
+            bySymbol.set(symbol.id, parameter);
+        }
+    });
+    return bySymbol;
+}
+/** Each place a call's argument passes one of the erased parameters it can see. */
+function handedOn(project, sites, erased) {
+    const spellings = new Set([...erased.values()].map((parameter) => parameter.name.getText()));
+    const candidates = sites.flatMap((site) => site.call.arguments.flatMap((argument, index) => valuesPassed(argument)
+        .filter((value) => spellings.has(value.name.getText()))
+        .map((value) => ({ site, argument: index, value }))));
+    const plain = candidates.filter((one) => !one.value.shorthand);
+    const resolved = project.symbolsAt(plain.map((one) => project.handle(one.value.name)));
+    const symbolOf = new Map(plain.map((one, index) => [one, resolved[index]]));
+    return candidates.flatMap((one) => {
+        const symbol = one.value.shorthand
+            ? project.shorthandValueAt(project.handle(one.value.name))
+            : symbolOf.get(one);
+        const parameter = symbol === undefined ? undefined : erased.get(symbol.id);
+        return parameter === undefined ? [] : [{ parameter, site: one.site, argument: one.argument }];
+    });
+}
+/**
+ * The destinations of one project's calls. A call is one at every argument where its
+ * callee is a serializer an entry names; at the arguments its resolved signature types
+ * `unknown` or `any` where its callee is declared outside the analysis; and, where its
+ * callee is a function of the project, at each parameter the function hands on to a
+ * destination, holding back the widest of what those destinations hold back, which is
+ * settled by widening until no parameter moves.
+ */
+function destinations(input, chains, walked) {
+    const { project, held } = input;
+    const checker = project.checker;
+    const own = new Set(project.ownSourceFiles().map((file) => file.fileName));
+    const named = resolveEntries(project, held, [JSON_STRINGIFY, ...input.ts.serializers]).filter(namesADeclaration);
+    const callees = resolvedTargets(project, walked.sites.flatMap((site) => calleeName(site.call.expression) ?? []));
+    const calleeOf = (call) => {
+        const name = calleeName(call.expression);
+        return name === undefined ? undefined : callees.get(name);
+    };
+    const erased = erasedParameters(project, walked.parameters);
+    const byFunction = new Map();
+    for (const parameter of erased.values()) {
+        byFunction.set(parameter.fn, [...(byFunction.get(parameter.fn) ?? []), parameter]);
+    }
+    const outside = (target) => target.declarations.length > 0 &&
+        target.declarations.every((handle) => !own.has(handle.path) &&
+            !input.consumers.some((root) => handle.path === root || handle.path.startsWith(`${root}/`)));
+    const erasedArguments = new Map();
+    const erasedAt = (call, argument) => {
+        let indexes = erasedArguments.get(call);
+        if (indexes === undefined) {
+            const signature = checker.getResolvedSignature(call);
+            indexes = new Set(call.arguments.flatMap((_unused, index) => {
+                const type = signature === undefined ? undefined : checker.getParameterType(signature, index);
+                return type !== undefined && (type.flags & ERASED) !== 0 ? [index] : [];
+            }));
+            erasedArguments.set(call, indexes);
+        }
+        return indexes.has(argument);
+    };
+    const forwards = new Map();
+    const keyOf = (parameter) => `${parameter.fn}\u0000${String(parameter.index)}`;
+    const at = (call, argument) => {
+        const target = calleeOf(call);
+        if (target === undefined) {
+            return undefined;
+        }
+        const entry = named.find((one) => names(one, target, chains));
+        if (entry !== undefined) {
+            return { reach: "properties", callee: spelledEntry(entry.entry, held) };
+        }
+        const declared = chains.declarationsOf(target);
+        if (declared.length === 0) {
+            return outside(target) && erasedAt(call, argument)
+                ? { reach: "conversions", callee: call.expression.getText().replace(/\s+/gu, "") }
+                : undefined;
+        }
+        for (const fn of declared) {
+            const parameter = (byFunction.get(fn) ?? []).find((one) => one.index === argument || (one.rest && one.index <= argument));
+            const reach = parameter === undefined ? undefined : forwards.get(keyOf(parameter));
+            if (reach !== undefined) {
+                return { reach, callee: held.symbols.find((symbol) => symbol.id === fn)?.name ?? fn };
+            }
+        }
+        return undefined;
+    };
+    const forwarded = handedOn(project, walked.sites, erased);
+    for (let moved = true; moved;) {
+        moved = false;
+        for (const one of forwarded) {
+            const key = keyOf(one.parameter);
+            const before = forwards.get(key);
+            const after = wider(before, at(one.site.call, one.argument)?.reach);
+            if (after !== undefined && after !== before) {
+                forwards.set(key, after);
+                moved = true;
+            }
+        }
+    }
+    const mayReceive = (call) => {
+        const target = calleeOf(call);
+        if (target === undefined) {
+            return false;
+        }
+        const declared = chains.declarationsOf(target);
+        if (named.some((one) => names(one, target, chains))) {
+            return true;
+        }
+        if (declared.length === 0) {
+            return outside(target);
+        }
+        return declared.some((fn) => (byFunction.get(fn) ?? []).some((parameter) => forwards.has(keyOf(parameter))));
+    };
+    return { at, mayReceive };
+}
+/** Each argument of a call that can receive one whose value carries a class of the target. */
+function flowsOf(project, held, sites, to) {
+    const reach = valueReach(project, held);
+    const arguments_ = sites.flatMap((site) => to.mayReceive(site.call)
+        ? site.call.arguments.flatMap((argument, index) => {
+            const value = evaluated(argument);
+            return holdsNoInstance(value) ? [] : [{ site, argument: index, value }];
+        })
+        : []);
+    const asked = arguments_.filter((one) => one.value.kind !== SyntaxKind.ThisKeyword);
+    const types = typesAt(project, asked.map((one) => one.value));
+    const typeOf = new Map(asked.map((one, index) => [one.value, types[index]]));
+    return arguments_.flatMap((one) => {
+        const type = typeOf.get(one.value);
+        let classes = new Set();
+        if (one.value.kind === SyntaxKind.ThisKeyword) {
+            classes = new Set(one.site.self === undefined ? [] : [one.site.self]);
+        }
+        else if (type !== undefined) {
+            classes = reach.classesOf(type);
+        }
+        const destination = classes.size === 0 ? undefined : to.at(one.site.call, one.argument);
+        return destination === undefined ? [] : [{ site: one.value, classes, to: destination }];
+    });
+}
+/**
+ * The serialization-contract detector: each property of each class whose values reach
+ * a destination, and the two conversion methods where the destination is outside the
+ * analysis, recorded at the argument with the callee named.
+ */
+export function serializationContract(input) {
+    const { project, held, targetRoot } = input;
+    const walked = walkProject(project, held);
+    const flows = flowsOf(project, held, walked.sites, destinations(input, aliasChains(project, held), walked));
+    if (flows.length === 0) {
+        return [];
+    }
+    const members = classMembers(project, held, new Set(flows.flatMap((flow) => [...flow.classes])), "instance");
+    const byId = new Map(held.symbols.map((symbol) => [symbol.id, symbol]));
+    const found = [];
+    for (const flow of flows) {
+        const site = renderPosition(flow.site.getSourceFile(), targetRoot, flow.site.getStart());
+        const detail = `passed to ${flow.to.callee}`;
+        for (const member of [...flow.classes].flatMap((id) => members.get(id) ?? [])) {
+            const symbol = byId.get(member.id);
+            const isProperty = (member.flags & SymbolFlags.Property) !== 0;
+            const converts = flow.to.reach === "conversions" &&
+                (member.flags & SymbolFlags.Method) !== 0 &&
+                symbol !== undefined &&
+                CONVERSIONS.has(memberComponent(symbol, byId) ?? "");
+            if (isProperty || converts) {
+                found.push({ id: member.id, detail, site });
+            }
+        }
+    }
+    return found;
+}