@cplieger/deadset-ts 3.12.1 → 4.0.0

package/dist/src/reporters/sarif.js

@@ -1,14 +1,14 @@
+import { jsonChunks } from "../json-chunks.js";
 import { KINDS } from "../kinds.js";
 import { lineHashes, symbolFingerprint } from "./fingerprint.js";
 import { RenderError } from "./reporter.js";
-import { RULE_TEXTS } from "./rules.js";
 import { utf8Bytes } from "./sha256.js";
 const SCHEMA = "https://docs.oasis-open.org/sarif/sarif/v2.1.0/errata01/os/schemas/sarif-schema-2.1.0.json";
 const VERSION = "2.1.0";
 /** The unit a finding's column counts. */
 const COLUMN_KIND = "utf16CodeUnits";
 const URI_BASE_ID = "%SRCROOT%";
-const ROOT_DESCRIPTION = "The target root, the directory the analyzer was run on.";
+const ROOT_DESCRIPTION = "The target root.";
 /** The most related locations one result carries; the report stays complete beyond them. */
 const MAX_RELATED = 100;
 const INDENT = 2;
@@ -32,23 +32,23 @@ function firstSentence(text) {
     }
     return text;
 }
+/** Every live kind whose languages include one of the run's, in code order. */
+function kindsOf(languages) {
+    return [...KINDS.values()].filter((kind) => kind.languages.some((language) => languages.includes(language)));
+}
 /**
- * One rule per live kind of this analyzer's language, in code order, whether or not a result
+ * One rule per live kind of the run's languages, in code order, whether or not a result
  * names it, so a rule's index is the same in every run and under every configuration.
  */
-function rules() {
-    return [...RULE_TEXTS].map(([code, text]) => {
-        const kind = KINDS.get(code);
-        if (kind === undefined) {
-            throw new RenderError(`the rule ${code} names no live kind`);
-        }
+function rules(kinds) {
+    return kinds.map((kind) => {
         return {
-            id: code,
+            id: kind.code,
             name: kind.name,
-            shortDescription: { text: firstSentence(text.rule) },
-            fullDescription: { text: text.rule },
+            shortDescription: { text: firstSentence(kind.rule) },
+            fullDescription: { text: kind.rule },
             help: {
-                text: text.precondition === undefined ? text.rule : `${text.rule}\n\n${text.precondition}`,
+                text: kind.precondition === undefined ? kind.rule : `${kind.rule}\n\n${kind.precondition}`,
             },
             defaultConfiguration: { level: LEVEL[kind.defaultSeverity] },
             properties: {
@@ -120,6 +120,11 @@ function relatedOf(found) {
     for (const at of found.details.write_positions ?? []) {
         related.push({ label: "write", at, endLine: at.end_line });
     }
+    for (const one of found.component.members ?? []) {
+        if (one.ref !== found.symbol.ref) {
+            related.push({ label: "member", at: one.position, endLine: one.position.end_line });
+        }
+    }
     return related.slice(0, MAX_RELATED);
 }
 /** The finding's message, then a link to each related location, since only a linked one shows. */
@@ -202,8 +207,9 @@ function staleResult(stale, index, hashOf) {
  * rendering, because a line fingerprint computed from other bytes opens a second alert.
  */
 export function sarif(report, options) {
-    const ruleList = rules();
-    const index = new Map([...RULE_TEXTS.keys()].map((code, at) => [code, at]));
+    const kinds = kindsOf(report.analyzer.languages);
+    const ruleList = rules(kinds);
+    const index = new Map(kinds.map((kind, at) => [kind.code, at]));
     const hashOf = lineHashCache(options.readSource);
     const results = [
         ...report.findings.map((found) => findingResult(found, index, hashOf)),
@@ -231,5 +237,5 @@ export function sarif(report, options) {
             },
         ],
     };
-    return `${JSON.stringify(log, null, INDENT)}\n`;
+    return jsonChunks(log, INDENT);
 }

package/dist/src/reporters/template.js

@@ -6,6 +6,7 @@
  * and `println`. Any other function, `define`, `template` and `block` are refused at parse,
  * and a member the document does not carry fails the rendering.
  */
+import { CHUNK_LENGTH } from "../json-chunks.js";
 import { RenderError } from "./reporter.js";
 import { utf8Bytes } from "./sha256.js";
 /** A template that does not parse, which refuses the invocation before any analysis. */
@@ -49,7 +50,10 @@ const ESCAPES = {
 /** The number of hexadecimal digits each numeric escape takes. */
 const ESCAPE_WIDTHS = { x: 2, u: 4, U: 8 };
 const IDENTIFIER = /[A-Za-z_][A-Za-z0-9_]*/uy;
-const NUMBER = /[+-]?[0-9]+(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?/uy;
+/** A number as the lexer reads one, before the subset decides whether it is a decimal integer. */
+const NUMBER = /[+-]?[0-9][0-9A-Za-z_.]*/uy;
+/** The one number form the subset admits: a decimal integer with no leading zero. */
+const DECIMAL_INTEGER = /^[+-]?(?:0|[1-9][0-9]*)$/u;
 function lineOf(source, at) {
     let line = 1;
     for (let i = 0; i < at; i += 1) {
@@ -153,6 +157,9 @@ function lexAction(source, at, line) {
         NUMBER.lastIndex = i;
         const number = NUMBER.exec(source)?.[0];
         if (number !== undefined) {
+            if (!DECIMAL_INTEGER.test(number)) {
+                throw new TemplateError(`line ${String(line)}: ${JSON.stringify(number)} is not a decimal integer`);
+            }
             tokens.push({ t: "lit", value: Number(number) });
             i += number.length;
             continue;
@@ -530,8 +537,61 @@ function compareBasic(name, a, b) {
     if (kind === "boolean") {
         return Number.NaN;
     }
+    if (kind === "string") {
+        return byCodePoints(a, b);
+    }
     return a < b ? -1 : 1;
 }
+/**
+ * Two strings ordered by the bytes of their UTF-8 encodings, which is the order of their
+ * code points: the order of their UTF-16 code units differs above U+FFFF.
+ */
+function byCodePoints(a, b) {
+    let at = 0;
+    while (at < a.length && at < b.length) {
+        const x = a.codePointAt(at) ?? 0;
+        const y = b.codePointAt(at) ?? 0;
+        if (x !== y) {
+            return x < y ? -1 : 1;
+        }
+        at += x > 0xffff ? 2 : 1;
+    }
+    return a.length - b.length;
+}
+/** The escapes `%q` writes for the control characters that have one of their own. */
+const QUOTED_ESCAPES = {
+    '"': '\\"',
+    "\\": "\\\\",
+    "\u0007": "\\a",
+    "\b": "\\b",
+    "\f": "\\f",
+    "\n": "\\n",
+    "\r": "\\r",
+    "\t": "\\t",
+    "\v": "\\v",
+};
+/**
+ * The text `%q` writes: double quotes around the text, a quote and a backslash escaped,
+ * each control character with an escape of its own written as it, every other character
+ * below U+0020 and U+007F written as `\x` and two lowercase hexadecimal digits, and every
+ * other character as itself.
+ */
+function goQuoted(text) {
+    let out = '"';
+    for (const char of text) {
+        const code = char.codePointAt(0) ?? 0;
+        if (Object.hasOwn(QUOTED_ESCAPES, char)) {
+            out += QUOTED_ESCAPES[char] ?? "";
+        }
+        else if (code < 0x20 || code === 0x7f) {
+            out += `\\x${code.toString(16).padStart(2, "0")}`;
+        }
+        else {
+            out += char;
+        }
+    }
+    return `${out}"`;
+}
 /** `printf`'s verbs, each over one operand. */
 function printf(format, args) {
     let out = "";
@@ -556,10 +616,10 @@ function printf(format, args) {
         switch (verb) {
             case "v":
             case "s":
-                out += formatted(arg, false);
+                out += formatted(arg, true);
                 break;
             case "q":
-                out += JSON.stringify(formatted(arg, false));
+                out += goQuoted(formatted(arg, true));
                 break;
             case "d":
                 if (typeof arg !== "number" || !Number.isInteger(arg)) {
@@ -659,11 +719,11 @@ function call(name, args) {
             return args
                 .map((arg, i) => {
                 const spaced = i > 0 && typeof arg !== "string" && typeof args[i - 1] !== "string";
-                return `${spaced ? " " : ""}${formatted(arg, false)}`;
+                return `${spaced ? " " : ""}${formatted(arg, true)}`;
             })
                 .join("");
         case "println":
-            return `${args.map((arg) => formatted(arg, false)).join(" ")}\n`;
+            return `${args.map((arg) => formatted(arg, true)).join(" ")}\n`;
         case "printf":
             if (typeof first !== "string") {
                 throw new RenderError("printf takes a format string first");
@@ -676,10 +736,22 @@ function call(name, args) {
 /** One execution of a template over a document. */
 class Execution {
     scopes;
-    out = "";
+    /** The rendering so far, in pieces of about {@link CHUNK_LENGTH}, the last still growing. */
+    pieces = [""];
     constructor(root) {
         this.scopes = [new Map([["$", root]])];
     }
+    write(text) {
+        const last = this.pieces.length - 1;
+        const held = (this.pieces[last] ?? "") + text;
+        if (held.length >= CHUNK_LENGTH) {
+            this.pieces[last] = held;
+            this.pieces.push("");
+        }
+        else {
+            this.pieces[last] = held;
+        }
+    }
     lookup(name) {
         for (let i = this.scopes.length - 1; i >= 0; i -= 1) {
             const scope = this.scopes[i];
@@ -783,12 +855,12 @@ class Execution {
         for (const node of nodes) {
             switch (node.k) {
                 case "text":
-                    this.out += node.text;
+                    this.write(node.text);
                     break;
                 case "action": {
                     const value = this.pipeline(node.pipe, dot, true);
                     if (node.pipe.vars.length === 0) {
-                        this.out += formatted(value, false);
+                        this.write(formatted(value, false));
                     }
                     break;
                 }
@@ -866,12 +938,40 @@ class Execution {
     }
 }
 /**
- * The template's rendering of one document. The rendering is built whole, so a template
- * that fails partway renders nothing, and the failure names what it could not evaluate.
+ * One document as the JSON value it encodes: what `JSON.stringify` would write for it,
+ * read back, without writing it. A member holding nothing is left out, and an array
+ * element holding nothing, like a number that is not finite, is null.
+ */
+function plainOf(value) {
+    if (Array.isArray(value)) {
+        return value.map((element) => plainOf(element) ?? null);
+    }
+    if (typeof value === "object" && value !== null) {
+        const held = {};
+        for (const [key, member] of Object.entries(value)) {
+            const plain = plainOf(member);
+            if (plain !== undefined) {
+                held[key] = plain;
+            }
+        }
+        return held;
+    }
+    if (typeof value === "number") {
+        return Number.isFinite(value) ? value : null;
+    }
+    if (typeof value === "string" || typeof value === "boolean" || value === null) {
+        return value;
+    }
+    return undefined;
+}
+/**
+ * The template's rendering of one document, in pieces of about {@link CHUNK_LENGTH}.
+ * The rendering is complete before it is answered, so a template that fails partway
+ * renders nothing, and the failure names what it could not evaluate.
  */
 export function renderTemplate(template, document) {
-    const root = JSON.parse(JSON.stringify(document));
+    const root = plainOf(document) ?? null;
     const execution = new Execution(root);
     execution.run(template.nodes, root);
-    return execution.out;
+    return execution.pieces.filter((piece) => piece !== "");
 }

package/dist/src/reporters/text.js

@@ -1,3 +1,4 @@
+import { coalesced } from "../json-chunks.js";
 /** The kind token and the confidence a stale suppression is rendered with, both fixed. */
 const STALE_KIND = "suppression";
 const STALE_CONFIDENCE = "certain";
@@ -24,11 +25,12 @@ function summary(totals) {
  * summary is deliberately not in that shape, so a filter for finding lines yields exactly
  * them. Nothing else is written: no timestamp, duration or host detail.
  */
-export const text = (report) => {
-    const lines = report.findings.map((found) => `${found.position.path}:${String(found.position.line)}:${String(found.position.column)}: ${found.symbol.kind} ${found.symbol.name}: ${found.message} [${found.confidence}] (${found.code})`);
+export const text = (report) => coalesced((function* lines() {
+    for (const found of report.findings) {
+        yield `${found.position.path}:${String(found.position.line)}:${String(found.position.column)}: ${found.symbol.kind} ${found.symbol.name}: ${found.message} [${found.confidence}] (${found.code})\n`;
+    }
     for (const stale of report.stale_suppressions) {
-        lines.push(`${stale.position.path}:${String(stale.position.line)}:${String(stale.position.column)}: ${STALE_KIND} ${stale.symbol}: ${stale.message} [${STALE_CONFIDENCE}] (${stale.code})`);
+        yield `${stale.position.path}:${String(stale.position.line)}:${String(stale.position.column)}: ${STALE_KIND} ${stale.symbol}: ${stale.message} [${STALE_CONFIDENCE}] (${stale.code})\n`;
     }
-    lines.push(summary(report.totals));
-    return `${lines.join("\n")}\n`;
-};
+    yield `${summary(report.totals)}\n`;
+})());

package/dist/src/roots.js

@@ -12,6 +12,7 @@ import { entryPoints } from "./entry-points.js";
 import { globExpression } from "./glob.js";
 import { nodeKey } from "./inventory.js";
 import { byPosition } from "./position.js";
+import { UNANSWERED } from "./query.js";
 import { sourceFilesOf } from "./source-files.js";
 /** Whether a configured string carries either special character. */
 function isPattern(text) {
@@ -142,7 +143,7 @@ export function roots(project, held, targetRoot, options) {
     for (const point of entryPoints(project, files, options.testFiles)) {
         enter(point.file, point.rule, point.source, point.exports);
     }
-    const exportsOf = exportTables(project, held, [
+    const { tables: exportsOf, answered } = exportTables(project, held, [
         ...entered.filter((entry) => entry.exports).map((entry) => entry.file),
         ...published,
     ]);
@@ -171,41 +172,56 @@ export function roots(project, held, targetRoot, options) {
         const site = left === undefined || right === undefined ? 0 : byPosition(left, right);
         return site || compare(a.kind, b.kind) || compare(a.source, b.source);
     });
-    return { configFile: project.configFile, liveUnderReachability: ordered, unmatched };
+    return {
+        configFile: project.configFile,
+        liveUnderReachability: ordered,
+        unmatched,
+        unanswered: answered ? [] : held.symbols.map((symbol) => symbol.id),
+    };
 }
 /**
  * Every declaration each file's module exports, by the file's name: the declaration
  * each name of the export table is, and every link of a re-export's chain. A name
- * whose declaration is outside the project's own files belongs to another program
- * and names nothing here.
- *
- * One batch resolves every file to its module and one request per module reads
- * its export table, star re-exports resolved into it. A file that is no module
- * exports nothing.
+ * whose declaration is outside the project's own files names nothing here. One batch
+ * resolves every file to its module and one request per module reads its export
+ * table, star re-exports resolved into it. A file that is no module exports nothing.
+ * `answered` is false where the checker left a table or a link of a chain unanswered.
  */
 function exportTables(project, held, wanted) {
     const unique = [...new Map(wanted.map((file) => [file.fileName, file])).values()];
     const tables = new Map();
+    let answered = true;
     if (unique.length === 0) {
-        return tables;
+        return { tables, answered };
     }
     const modules = project.symbolsAt(unique.map((file) => project.handle(file)));
     const chains = aliasChains(project, held);
+    const topLevel = (file) => {
+        const fileId = held.declarations.get(nodeKey(file, file));
+        return held.symbols.filter((symbol) => symbol.parent === fileId).map((symbol) => symbol.id);
+    };
     unique.forEach((file, index) => {
         const module = modules[index];
         if (module === undefined) {
             tables.set(file.fileName, []);
             return;
         }
+        const table = module === UNANSWERED ? UNANSWERED : project.queries.exportsOfModule(module);
+        if (table === UNANSWERED) {
+            answered = false;
+            tables.set(file.fileName, topLevel(file));
+            return;
+        }
         const ids = new Set();
-        for (const exported of project.checker.getExportsOfModule(module)) {
+        for (const exported of table) {
             for (const target of chains.chainOf(exported)) {
+                answered &&= !target.guessed;
                 ids.add(target.id);
             }
         }
         tables.set(file.fileName, [...ids]);
     });
-    return tables;
+    return { tables, answered };
 }
 /** The kinds of container whose export table, not its members' visibility, says what it publishes. */
 const EXPORTING_CONTAINERS = new Set(["file", "namespace"]);

package/dist/src/serialization-contract.js

@@ -1,11 +1,12 @@
 /**
- * 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. A
- * function invoked through `Function.prototype.call`, `apply` or `bind` is the callee,
- * given the arguments those methods pass it.
+ * The serialization-contract class: the data members and `toJSON` of every class,
+ * interface and object type a value's static type names, and of every such type its
+ * data members' types reach, where the value reaches `JSON.stringify` or a call
+ * `ts.serializers` names, and those and `toString` where it 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. A function invoked through `Function.prototype.call`,
+ * `apply` or `bind` is the callee, given the arguments those methods pass it.
  */
 import { isArrayLiteralExpression, isArrowFunction, isCallExpression, isClassDeclaration, isClassExpression, isClassStaticBlockDeclaration, isFunctionDeclaration, isFunctionExpression, isGetAccessorDeclaration, isIdentifier, isMethodDeclaration, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAccessExpression, isSetAccessorDeclaration, isSpreadElement, isStringLiteral, isVariableDeclaration, ModifierFlags, SyntaxKind, } from "@typescript/native/unstable/ast";
 import { SignatureKind, SymbolFlags, TypeFlags, } from "@typescript/native/unstable/sync";
@@ -15,11 +16,14 @@ 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 { must } from "./query.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 method a serializer calls on a value that carries one, wherever the value goes. */
+const SERIALIZED_CONVERSION = "toJSON";
 /** 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. */
@@ -182,12 +186,13 @@ function erasedParameters(project, parameters) {
         if (!parameter.rest) {
             return (type.flags & ERASED) !== 0;
         }
-        const [element] = type.isTypeReference() ? project.checker.getTypeArguments(type) : [];
+        const [element] = must(project.queries.typeArguments(type));
         return element !== undefined && (element.flags & ERASED) !== 0;
     });
     const bySymbol = new Map();
     project
         .symbolsAt(erased.map((parameter) => project.handle(parameter.name)))
+        .map(must)
         .forEach((symbol, index) => {
         const parameter = erased[index];
         if (symbol !== undefined && parameter !== undefined) {
@@ -203,11 +208,11 @@ function handedOn(project, sites, erased, invocationOf) {
         .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 resolved = project.symbolsAt(plain.map((one) => project.handle(one.value.name))).map(must);
     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))
+            ? must(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 }];
@@ -223,8 +228,8 @@ function handedOn(project, sites, erased, invocationOf) {
  */
 function destinations(input, chains, walked) {
     const { project, held } = input;
-    const checker = project.checker;
-    const own = new Set(project.ownSourceFiles().map((file) => file.fileName));
+    const queries = project.queries;
+    const own = project.ownPaths();
     const named = resolveEntries(project, held, [JSON_STRINGIFY, ...input.ts.serializers]).filter(namesADeclaration);
     const forms = new Map();
     for (const site of walked.sites) {
@@ -256,7 +261,7 @@ function destinations(input, chains, walked) {
         if (form !== undefined &&
             method !== undefined &&
             outside(method) &&
-            FUNCTION_INTERFACES.has(method.getParent()?.name ?? "")) {
+            FUNCTION_INTERFACES.has(must(project.queries.parentOf(method))?.name ?? "")) {
             return form.invocation;
         }
         return { callee: call.expression, arguments: call.arguments, indirect: false };
@@ -272,14 +277,14 @@ function destinations(input, chains, walked) {
             const invoked = invocation(call);
             // Through a method of the prototype the resolved signature is the method's, so
             // the parameters are read off the callee's own signatures, any one erasing.
-            const type = invoked.indirect ? checker.getTypeAtLocation(invoked.callee) : undefined;
+            const type = invoked.indirect ? must(queries.typeAt(invoked.callee)) : undefined;
             const signatures = invoked.indirect
                 ? type === undefined
                     ? []
-                    : checker.getSignaturesOfType(type, SignatureKind.Call)
-                : [checker.getResolvedSignature(call)].filter((one) => one !== undefined);
+                    : must(queries.signaturesOf(type, SignatureKind.Call))
+                : [must(queries.resolvedSignature(call))].filter((one) => one !== undefined);
             indexes = new Set(invoked.arguments.flatMap((_unused, index) => signatures.some((signature) => {
-                const parameter = checker.getParameterType(signature, index);
+                const parameter = must(queries.parameterType(signature, index));
                 return parameter !== undefined && (parameter.flags & ERASED) !== 0;
             })
                 ? [index]
@@ -360,46 +365,62 @@ function flowsOf(project, held, sites, to) {
     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();
+        let reached = { classes: new Set(), members: [] };
         if (one.value.kind === SyntaxKind.ThisKeyword) {
-            classes = new Set(one.site.self === undefined ? [] : [one.site.self]);
+            reached = {
+                classes: new Set(one.site.self === undefined ? [] : [one.site.self]),
+                members: [],
+            };
         }
         else if (type !== undefined) {
-            classes = reach.classesOf(type);
+            reached = reach.reachedFrom(type);
         }
-        const destination = classes.size === 0 ? undefined : to.at(one.site.call, one.argument);
-        return destination === undefined ? [] : [{ site: one.value, classes, to: destination }];
+        const carries = reached.classes.size > 0 || reached.members.length > 0;
+        const destination = carries ? to.at(one.site.call, one.argument) : undefined;
+        return destination === undefined
+            ? []
+            : [{ site: one.value, classes: reached.classes, members: reached.members, 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.
+ * The serialization-contract detector: each data member and `toJSON` of each class,
+ * interface and object type a value that reaches a destination carries, and `toString`
+ * as well 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));
+    const chains = aliasChains(project, held);
+    const flows = flowsOf(project, held, walked.sites, destinations(input, chains, 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]));
+    // A destination holds back a data member and `toJSON`, and `toString` as well where
+    // the value left the analysis.
+    const holdsBack = (flags, name, to) => (flags & SymbolFlags.Property) !== 0 ||
+        ((flags & SymbolFlags.Method) !== 0 &&
+            (name === SERIALIZED_CONVERSION || (to.reach === "conversions" && CONVERSIONS.has(name))));
     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) {
+            const name = symbol === undefined ? "" : (memberComponent(symbol, byId) ?? "");
+            if (holdsBack(member.flags, name, flow.to)) {
                 found.push({ id: member.id, detail, site });
             }
         }
+        for (const member of flow.members) {
+            if (holdsBack(member.flags, member.name, flow.to)) {
+                for (const id of chains.declarationsOf(member)) {
+                    found.push({ id, detail, site });
+                }
+            }
+        }
     }
     return found;
 }