@cplieger/deadset-ts 7.2.0-dev.4 → 8.0.0-dev.10

package/dist/src/serialization-contract.js

@@ -1,12 +1,13 @@
 /**
  * The serialization-contract class: the data members and `toJSON` of every type a value's
  * static type reaches, where the value reaches `JSON.stringify` or a call `ts.serializers`
- * names, and `toString` too where it reaches an `unknown` or `any` parameter of a function
- * outside the analysis or an erased property of a type the program does not declare. A
- * function of the project handing such a parameter to a destination is one, to a fixpoint,
- * and a function invoked through `call`, `apply` or `bind` is the callee.
+ * names, and `toString` too where it reaches an erased parameter of a function outside the
+ * analysis, or an erased property of a type the program does not declare. A function of
+ * the project handing such a parameter to a destination is one, to a fixpoint, and a
+ * function invoked through `call`, `apply` or `bind` is the callee.
  */
-import { isArrayLiteralExpression, isArrowFunction, isAsExpression, isCallExpression, isClassDeclaration, isClassExpression, isClassStaticBlockDeclaration, isFunctionDeclaration, isFunctionExpression, isGetAccessorDeclaration, isIdentifier, isInterfaceDeclaration, isMethodDeclaration, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAccessExpression, isPropertyDeclaration, isSatisfiesExpression, isSetAccessorDeclaration, isSpreadElement, isStringLiteral, isTypeLiteralNode, isVariableDeclaration, ModifierFlags, NodeFlags, SyntaxKind, } from "@typescript/native/ast";
+import { isArrayLiteralExpression, isArrowFunction, isAsExpression, isAwaitExpression, isCallExpression, isClassDeclaration, isClassExpression, isClassStaticBlockDeclaration, isElementAccessExpression, isExpressionStatement, isFunctionDeclaration, isFunctionExpression, isFunctionLikeDeclaration, isGetAccessorDeclaration, isIdentifier, isInterfaceDeclaration, isMethodDeclaration, isNonNullExpression, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectLiteralExpression, isParenthesizedExpression, isForInStatement, isPropertyAccessExpression, isPropertyDeclaration, isReturnStatement, isSatisfiesExpression, isSetAccessorDeclaration, isSourceFile, isSpreadAssignment, isSpreadElement, isStringLiteral, isTypeAssertion, isTypeLiteralNode, isVariableDeclaration, ModifierFlags, NodeFlags, SyntaxKind, } from "@typescript/native/ast";
+import { parenthesesRemoved } from "./unwrap.js";
 import { SignatureKind, SymbolFlags, TypeFlags, } from "@typescript/native/sync";
 import { aliasChains } from "./alias-chain.js";
 import { calleeName, resolvedTargets, valuesPassed } from "./calls.js";
@@ -14,17 +15,21 @@ 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 { must, Unanswerable } from "./query.js";
 import { erasedStores } from "./erased-stores.js";
 import { checkedTypes, CONVERSION_MEMBERS, valueReach } from "./value-reach.js";
 /** The serializer every run reads, whatever the configuration names. */
-const JSON_STRINGIFY = { shape: "global", global: "JSON.stringify" };
+const JSON_STRINGIFY = { 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 standard library's promise types, whose value is their one type argument. */
+const PROMISES = new Set(["Promise", "PromiseLike"]);
+/** How deep a callee's result is searched for a type parameter: `Promise<Box<T>>` is two levels. */
+const MENTION_DEPTH = 3;
 /** The wider of two reaches, where either may be absent. */
 function wider(a, b) {
     return a === "conversions" || b === "conversions" ? "conversions" : (a ?? b);
@@ -84,11 +89,6 @@ const FUNCTION_INTERFACES = new Set([
     "CallableFunction",
     "NewableFunction",
 ]);
-function unparenthesized(expression) {
-    return isParenthesizedExpression(expression)
-        ? unparenthesized(expression.expression)
-        : expression;
-}
 /**
  * The invocation a call writes through a method of `Function.prototype`, read from
  * the syntax alone: `f.call(self, a)`, `f.apply(self, [a])`, `f.bind(self, a)`, which
@@ -97,12 +97,12 @@ function unparenthesized(expression) {
  * carries. Whether the method is the prototype's is resolution's to say.
  */
 function throughMethod(call) {
-    const expression = unparenthesized(call.expression);
+    const expression = parenthesesRemoved(call.expression);
     if (isPropertyAccessExpression(expression) && FUNCTION_METHODS.has(expression.name.text)) {
         const [, ...rest] = call.arguments;
         let passed = rest;
         if (expression.name.text === "apply") {
-            const list = rest[0] === undefined ? undefined : unparenthesized(rest[0]);
+            const list = rest[0] === undefined ? undefined : parenthesesRemoved(rest[0]);
             passed = list === undefined ? [] : isArrayLiteralExpression(list) ? list.elements : [list];
         }
         return {
@@ -111,7 +111,7 @@ function throughMethod(call) {
         };
     }
     if (isCallExpression(expression)) {
-        const bound = unparenthesized(expression.expression);
+        const bound = parenthesesRemoved(expression.expression);
         if (isPropertyAccessExpression(bound) && bound.name.text === "bind") {
             return {
                 method: bound.name,
@@ -133,9 +133,16 @@ function throughMethod(call) {
 function walkProject(project, held) {
     const sites = [];
     const parameters = [];
+    const initialized = new Set();
     for (const file of project.ownSourceFiles()) {
         const visit = (node, self) => {
             let inner = self;
+            if (isPropertyDeclaration(node) && node.initializer !== undefined) {
+                const id = held.declarations.get(nodeKey(file, node));
+                if (id !== undefined) {
+                    initialized.add(id);
+                }
+            }
             if (isClassDeclaration(node) || isClassExpression(node)) {
                 inner = held.declarations.get(nodeKey(file, node));
             }
@@ -169,11 +176,33 @@ function walkProject(project, held) {
             visit(child, undefined);
         });
     }
-    return { sites, parameters };
+    return { sites, parameters, initialized };
+}
+/** The calls of `Object` that read every own property of their argument by name. */
+const ENUMERATIONS = new Set([
+    "keys",
+    "entries",
+    "values",
+    "getOwnPropertyNames",
+    "assign",
+]);
+/**
+ * Whether a parameter type keeps no member name of the value it is given beyond the
+ * properties it names: `unknown`, `any`, or an object type of a string index signature,
+ * under which every other member of the value is held.
+ */
+function keepsNoName(project, type) {
+    if ((type.flags & ERASED) !== 0) {
+        return true;
+    }
+    if ((type.flags & TypeFlags.Object) === 0) {
+        return false;
+    }
+    return must(project.queries.indexInfosOf(type)).some((info) => (info.keyType.flags & TypeFlags.String) !== 0);
 }
 /**
- * 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.
+ * The parameters that keep no member name of the value they are given, as `keepsNoName`
+ * reads it, and a rest parameter whose elements keep none, each by its symbol.
  */
 function erasedParameters(project, parameters) {
     const types = typesAt(project, parameters.map((parameter) => parameter.name));
@@ -183,10 +212,10 @@ function erasedParameters(project, parameters) {
             return false;
         }
         if (!parameter.rest) {
-            return (type.flags & ERASED) !== 0;
+            return keepsNoName(project, type);
         }
         const [element] = must(project.queries.typeArguments(type));
-        return element !== undefined && (element.flags & ERASED) !== 0;
+        return element !== undefined && keepsNoName(project, element);
     });
     const bySymbol = new Map();
     project
@@ -200,6 +229,103 @@ function erasedParameters(project, parameters) {
     });
     return bySymbol;
 }
+/** Whether one node is a function, whose body runs only where something calls it. */
+function isFunctionNode(node) {
+    return (isFunctionDeclaration(node) ||
+        isFunctionExpression(node) ||
+        isArrowFunction(node) ||
+        isMethodDeclaration(node) ||
+        isGetAccessorDeclaration(node) ||
+        isSetAccessorDeclaration(node));
+}
+/** The name a function nested in another is called by: its own, or the variable it initializes. */
+function nestedName(fn) {
+    if (isFunctionDeclaration(fn)) {
+        return fn.name?.text;
+    }
+    let at = fn.parent;
+    while (isParenthesizedExpression(at) || isAsExpression(at) || isSatisfiesExpression(at)) {
+        at = at.parent;
+    }
+    return isVariableDeclaration(at) && isIdentifier(at.name) ? at.name.text : undefined;
+}
+/** The names one function's body writes as identifiers, other than the names its declarations bind. */
+function namesWritten(fn) {
+    const found = new Set();
+    const visit = (node) => {
+        const declares = (isFunctionDeclaration(node.parent) || isVariableDeclaration(node.parent)) &&
+            node.parent.name === node;
+        if (isIdentifier(node) && !declares) {
+            found.add(node.text);
+        }
+        node.forEachChild(visit);
+    };
+    fn.forEachChild(visit);
+    return found;
+}
+/**
+ * The erased parameters their own function enumerates: one an `Object.keys`, `entries`,
+ * `values`, `getOwnPropertyNames` or `assign` call takes, `Object` the standard library's,
+ * or a `for…in` statement walks, which reads every property of the value by its name. A
+ * nested function is read as the function's own only where its name is written in it, or
+ * it has none, a callback or a function called where it is written.
+ */
+function enumeratedParameters(project, erased) {
+    const asked = [];
+    for (const parameter of erased.values()) {
+        const fn = parameter.name.parent.parent;
+        const spelled = parameter.name.getText();
+        const written = namesWritten(fn);
+        const visit = (node) => {
+            if (isFunctionNode(node)) {
+                const name = nestedName(node);
+                if (name !== undefined && !written.has(name)) {
+                    return;
+                }
+            }
+            const read = [];
+            let object;
+            if (isCallExpression(node)) {
+                const callee = node.expression;
+                if (isPropertyAccessExpression(callee) &&
+                    isIdentifier(callee.expression) &&
+                    callee.expression.text === "Object" &&
+                    ENUMERATIONS.has(callee.name.text)) {
+                    object = callee.expression;
+                    // `Object.assign` reads its sources, every argument after the target.
+                    read.push(...node.arguments.slice(...(callee.name.text === "assign" ? [1] : [0, 1])));
+                }
+            }
+            else if (isForInStatement(node)) {
+                read.push(node.expression);
+            }
+            for (const value of read.map(evaluated)) {
+                if (isIdentifier(value) && value.text === spelled) {
+                    asked.push({ node: value, parameter, object });
+                }
+            }
+            node.forEachChild(visit);
+        };
+        fn.forEachChild(visit);
+    }
+    const symbols = project.symbolsAt(asked.map((one) => project.handle(one.node))).map(must);
+    const objects = asked.flatMap((one) => (one.object === undefined ? [] : [one.object]));
+    const own = project.ownPaths();
+    const standard = new Set(project
+        .symbolsAt(objects.map((node) => project.handle(node)))
+        .map(must)
+        .flatMap((symbol, at) => symbol?.declarations.every((handle) => !own.has(handle.path)) === true ? [objects[at]] : []));
+    return [
+        ...new Set(asked.flatMap((one, at) => {
+            const symbol = symbols[at];
+            return symbol !== undefined &&
+                erased.get(symbol.id) === one.parameter &&
+                (one.object === undefined || standard.has(one.object))
+                ? [one.parameter]
+                : [];
+        })),
+    ];
+}
 /** Each place a call's argument passes one of the erased parameters it can see. */
 function handedOn(project, sites, erased, invocationOf) {
     const spellings = new Set([...erased.values()].map((parameter) => parameter.name.getText()));
@@ -283,8 +409,8 @@ function implementedOwners(project, inAnalysis) {
  * 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 or only ambiently
  * with no implementation in it; 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.
+ * parameter the function enumerates or hands on to a destination, holding back the widest
+ * of what those hold back, settled by widening until no parameter moves.
  */
 function destinations(input, chains, walked) {
     const { project, held } = input;
@@ -381,6 +507,28 @@ function destinations(input, chains, walked) {
         });
         return containing.length === 0 ? target.declarations : containing;
     };
+    /** Whether a type names a type parameter, through constituents, type arguments and call signatures. */
+    const mentions = (type, parameter, depth) => {
+        // A conditional type an alias names, `Awaited<T>` among them, carries its arguments
+        // only on the alias the client's type object reports.
+        const aliased = type
+            .aliasTypeArguments;
+        if (type.id === parameter.id || aliased?.includes(parameter.id) === true) {
+            return true;
+        }
+        if (depth >= MENTION_DEPTH) {
+            return false;
+        }
+        const inner = [
+            ...(type.isUnionType() || type.isIntersectionType() ? must(queries.constituents(type)) : []),
+            ...must(queries.typeArguments(type)),
+            ...must(queries.signaturesOf(type, SignatureKind.Call)).flatMap((signature) => [
+                ...signature.parameters.map((_parameter, at) => must(queries.typeAtPosition(signature, at))),
+                ...[must(queries.returnTypeOf(signature))].filter((one) => one !== undefined),
+            ]),
+        ];
+        return inner.some((one) => mentions(one, parameter, depth + 1));
+    };
     const erasedArguments = new Map();
     const erasedAt = (call, argument) => {
         let indexes = erasedArguments.get(call);
@@ -394,10 +542,32 @@ function destinations(input, chains, walked) {
                     ? []
                     : must(queries.signaturesOf(type, SignatureKind.Call))
                 : [resolvedOf(call)].filter((one) => one !== undefined);
-            indexes = new Set(invoked.arguments.flatMap((_unused, index) => signatures.some((signature) => {
-                const parameter = must(queries.parameterType(signature, index));
-                return parameter !== undefined && (parameter.flags & ERASED) !== 0;
-            })
+            // A type parameter of the callee that nothing constrains and its result does not name
+            // keeps nothing of the value either: the instantiated signature names the value's own
+            // type there instead, and a result that names it hands the value back.
+            const generic = invoked.indirect ? undefined : resolvedOf(call);
+            const declared = generic === undefined ? undefined : must(queries.genericOf(generic));
+            const unconstrained = (index) => {
+                const parameter = declared === undefined ? undefined : must(queries.parameterType(declared, index));
+                const parts = parameter === undefined
+                    ? []
+                    : parameter.isUnionType()
+                        ? must(queries.constituents(parameter))
+                        : [parameter];
+                const result = declared === undefined ? undefined : must(queries.returnTypeOf(declared));
+                return parts.some((part) => {
+                    if (!part.isTypeParameter() || (result !== undefined && mentions(result, part, 0))) {
+                        return false;
+                    }
+                    const constraint = must(queries.constraintOf(part));
+                    return constraint === undefined || (constraint.flags & ERASED) !== 0;
+                });
+            };
+            indexes = new Set(invoked.arguments.flatMap((_unused, index) => unconstrained(index) ||
+                signatures.some((signature) => {
+                    const parameter = must(queries.parameterType(signature, index));
+                    return parameter !== undefined && (parameter.flags & ERASED) !== 0;
+                })
                 ? [index]
                 : []));
             erasedArguments.set(call, indexes);
@@ -432,6 +602,9 @@ function destinations(input, chains, walked) {
         }
         return undefined;
     };
+    for (const parameter of enumeratedParameters(project, erased)) {
+        forwards.set(keyOf(parameter), "properties");
+    }
     const forwarded = handedOn(project, walked.sites, erased, invocation);
     for (let moved = true; moved;) {
         moved = false;
@@ -505,6 +678,14 @@ function flowsOf(project, held, sites, to, stores) {
                 },
             ];
     });
+    const generic = typeParameterFlows(project, reach, sites, arguments_.flatMap((one) => {
+        const type = typeOf.get(one.value);
+        const parameters = type === undefined ? [] : typeParametersOf(project, type, 0);
+        const destination = parameters.length === 0 ? undefined : to.at(one.site.call, one.argument);
+        return destination === undefined
+            ? []
+            : parameters.map((parameter) => ({ parameter, to: destination }));
+    }));
     const left = stores.outside.flatMap((store) => {
         const reached = reach.reachedFrom(store.type);
         return reached.classes.size === 0 && reached.members.length === 0
@@ -519,7 +700,155 @@ function flowsOf(project, held, sites, to, stores) {
                 },
             ];
     });
-    return [...passed, ...left];
+    return [...passed, ...generic, ...left];
+}
+/** The type parameters one type names, through constituents and type arguments. */
+function typeParametersOf(project, type, depth) {
+    if (type.isTypeParameter()) {
+        return [type];
+    }
+    if (depth >= MENTION_DEPTH) {
+        return [];
+    }
+    const { queries } = project;
+    return [
+        ...(type.isUnionType() || type.isIntersectionType() ? must(queries.constituents(type)) : []),
+        ...must(queries.typeArguments(type)),
+    ].flatMap((one) => typeParametersOf(project, one, depth + 1));
+}
+/**
+ * The type parameters one type names, by identifier: through constituents, type arguments,
+ * an alias's arguments and the parameters and results of its call signatures, so a callback
+ * parameter's result names the parameter its callee's result does.
+ */
+function namedTypeParameters(project, type, depth) {
+    const { queries } = project;
+    const aliased = type.aliasTypeArguments;
+    if (type.isTypeParameter()) {
+        return [type.id];
+    }
+    if (depth >= MENTION_DEPTH) {
+        return aliased ?? [];
+    }
+    return [
+        ...(aliased ?? []),
+        ...[
+            ...(type.isUnionType() || type.isIntersectionType() ? must(queries.constituents(type)) : []),
+            ...must(queries.typeArguments(type)),
+            ...must(queries.signaturesOf(type, SignatureKind.Call)).flatMap((signature) => [
+                ...signature.parameters.flatMap((_parameter, at) => [
+                    must(queries.typeAtPosition(signature, at)),
+                ]),
+                ...[must(queries.returnTypeOf(signature))].filter((one) => one !== undefined),
+            ]),
+        ].flatMap((one) => namedTypeParameters(project, one, depth + 1)),
+    ];
+}
+/**
+ * The types an instantiated type puts where a declared type names `parameter`: matched
+ * through type arguments, and in a union every constituent the declared union does not
+ * itself name.
+ */
+function bound(project, declared, instantiated, parameter, depth) {
+    if (declared.id === parameter.id) {
+        return [instantiated];
+    }
+    if (depth >= MENTION_DEPTH) {
+        return [];
+    }
+    const { queries } = project;
+    if (declared.isUnionType()) {
+        const parts = must(queries.constituents(declared));
+        if (parts.some((part) => part.id === parameter.id)) {
+            const kept = new Set(parts.map((part) => part.id));
+            const given = instantiated.isUnionType()
+                ? must(queries.constituents(instantiated))
+                : [instantiated];
+            return given.filter((part) => !kept.has(part.id));
+        }
+    }
+    const declaredArguments = must(queries.typeArguments(declared));
+    const givenArguments = must(queries.typeArguments(instantiated));
+    return declaredArguments.length !== givenArguments.length
+        ? []
+        : declaredArguments.flatMap((one, at) => {
+            const given = givenArguments[at];
+            return given === undefined ? [] : bound(project, one, given, parameter, depth + 1);
+        });
+}
+/**
+ * The flows a type parameter of a function of the project carries where a value its type
+ * names reaches a destination: each call of the function passes its type argument there,
+ * written or inferred from the arguments, and a type argument that is a type parameter
+ * of the calling function is followed on to that function's calls, to a fixpoint.
+ */
+function typeParameterFlows(project, reach, sites, pending) {
+    const { queries } = project;
+    const byName = new Map();
+    for (const site of sites) {
+        const name = calleeName(site.call.expression)?.getText();
+        if (name !== undefined) {
+            byName.set(name, [...(byName.get(name) ?? []), site]);
+        }
+    }
+    const found = [];
+    const seen = new Set();
+    for (let next = pending.pop(); next !== undefined; next = pending.pop()) {
+        const { parameter, to } = next;
+        if (seen.has(parameter.id)) {
+            continue;
+        }
+        seen.add(parameter.id);
+        const symbol = must(queries.symbolOfType(parameter));
+        const [handle] = symbol?.declarations ?? [];
+        const declaration = handle === undefined ? undefined : project.declarationAt(handle)?.node;
+        const fn = declaration?.parent;
+        const index = fn === undefined || !isFunctionLikeDeclaration(fn)
+            ? -1
+            : (fn.typeParameters ?? []).findIndex((one) => one === declaration);
+        const name = fn === undefined
+            ? undefined
+            : isMethodDeclaration(fn) && isIdentifier(fn.name)
+                ? fn.name.text
+                : nestedName(fn);
+        if (symbol === undefined || fn === undefined || index < 0 || name === undefined) {
+            continue;
+        }
+        for (const site of byName.get(name) ?? []) {
+            const resolved = must(queries.resolvedSignature(site.call));
+            const declared = resolved === undefined ? undefined : must(queries.genericOf(resolved));
+            const called = declared?.declaration === undefined
+                ? undefined
+                : project.declarationAt(declared.declaration)?.node;
+            if (resolved === undefined || declared === undefined || called !== fn) {
+                continue;
+            }
+            const written = site.call.typeArguments?.[index];
+            const given = written === undefined
+                ? site.call.arguments.flatMap((_argument, at) => {
+                    const from = must(queries.parameterType(declared, at));
+                    const into = must(queries.parameterType(resolved, at));
+                    return from === undefined || into === undefined
+                        ? []
+                        : bound(project, from, into, parameter, 0);
+                })
+                : typesAt(project, [written]).filter((type) => type !== undefined);
+            for (const type of given) {
+                const reached = reach.reachedFrom(type);
+                if (reached.classes.size > 0 || reached.members.length > 0) {
+                    found.push({
+                        site: site.call,
+                        classes: reached.classes,
+                        members: reached.members,
+                        to,
+                        detail: `passed to ${to.callee} through the type parameter ${symbol.name}`,
+                    });
+                }
+                pending.push(...typeParametersOf(project, type, 0).map((one) => ({ parameter: one, to })));
+            }
+        }
+    }
+    return found;
 }
 /**
  * The serialization-contract detector: each data member and `toJSON` of each class,
@@ -542,6 +871,10 @@ export function serializationContract(input) {
     const holdsBack = (flags, name, to) => (flags & SymbolFlags.Property) !== 0 ||
         ((flags & CONVERSION_MEMBERS) !== 0 &&
             (name === SERIALIZED_CONVERSION || (to.reach === "conversions" && CONVERSIONS.has(name))));
+    // The receiver reads only what the program wrote, so a data member holds while written.
+    const evidence = (id, flags, detail, site) => (flags & SymbolFlags.Property) !== 0 && !walked.initialized.has(id)
+        ? { id, detail, site, whileWritten: true }
+        : { id, detail, site };
     const found = [];
     for (const flow of flows) {
         const site = renderPosition(flow.site.getSourceFile(), targetRoot, flow.site.getStart());
@@ -550,16 +883,303 @@ export function serializationContract(input) {
             const symbol = byId.get(member.id);
             const name = symbol === undefined ? "" : (memberComponent(symbol, byId) ?? "");
             if (holdsBack(member.flags, name, flow.to)) {
-                found.push({ id: member.id, detail, site });
+                found.push(evidence(member.id, member.flags, 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 });
+                    found.push(evidence(id, member.flags, detail, site));
                 }
             }
         }
     }
     return found;
 }
+/**
+ * The data members the decodes and copies of `files` fill, as {@link Decoded} names them.
+ * A generic declared outside the analysis, or only ambiently, fills the type that a type
+ * parameter of its own no parameter names binds, where the awaited result carries that
+ * type through its data members rather than only naming it, as a store's methods do: no
+ * argument hands the value over, so it fills it where the analysis cannot see, and may
+ * read it. Where the checker leaves a question unanswered, every data member is `unanswered`.
+ */
+export function decodedMembers(project, held, files, consumers) {
+    try {
+        return { ...decodedOf(project, held, files, consumers), unanswered: [] };
+    }
+    catch (error) {
+        if (!(error instanceof Unanswerable)) {
+            throw error;
+        }
+        return {
+            filled: [],
+            parsed: [],
+            copied: [],
+            unanswered: held.symbols
+                .filter((symbol) => symbol.kind === "class-member" || symbol.kind === "type-member")
+                .map((symbol) => symbol.id),
+        };
+    }
+}
+function decodedOf(project, held, files, consumers) {
+    const { queries } = project;
+    const own = project.ownPaths();
+    const inAnalysis = (path) => own.has(path) || consumers.some((root) => path === root || path.startsWith(`${root}/`));
+    const calls = [];
+    const untyped = [];
+    const spreads = [];
+    const noteRead = (node) => {
+        const at = readAs(node);
+        if (at.tops.length > 0 || at.asserted.length > 0) {
+            untyped.push(node);
+        }
+    };
+    const visit = (node) => {
+        if (isCallExpression(node)) {
+            calls.push(node);
+            noteRead(node);
+        }
+        else if (isPropertyAccessExpression(node) || isElementAccessExpression(node)) {
+            noteRead(node);
+        }
+        else if (isSpreadAssignment(node)) {
+            spreads.push(node);
+        }
+        node.forEachChild(visit);
+    };
+    for (const file of files) {
+        file.forEachChild(visit);
+    }
+    const filled = [];
+    const resolved = queries.resolvedSignatures(calls).map(must);
+    for (const signature of resolved) {
+        const declared = signature?.target === undefined ? undefined : must(queries.genericOf(signature));
+        const declaration = declared?.declaration;
+        const generic = declared?.typeParameters ?? [];
+        if (signature === undefined || declared === undefined || generic.length === 0) {
+            continue;
+        }
+        const node = declaration === undefined ? undefined : project.declarationAt(declaration)?.node;
+        if (declaration === undefined ||
+            (inAnalysis(declaration.path) &&
+                (node === undefined || (node.flags & NodeFlags.Ambient) === 0))) {
+            continue;
+        }
+        const result = must(queries.returnTypeOf(declared));
+        const given = must(queries.returnTypeOf(signature));
+        if (result === undefined || given === undefined) {
+            continue;
+        }
+        const passed = new Set(declared.parameters.flatMap((_parameter, at) => {
+            const type = must(queries.parameterType(declared, at));
+            return type === undefined ? [] : namedTypeParameters(project, type, 0);
+        }));
+        const types = typeParametersOf(project, result, 0)
+            .filter((parameter) => generic.includes(parameter.id) && !passed.has(parameter.id))
+            .flatMap((parameter) => bound(project, result, given, parameter, 0));
+        if (types.length > 0) {
+            filled.push({ carried: awaited(project, given), types });
+        }
+    }
+    const read = readTypes(project, untyped);
+    const copies = copiedNames(project, spreads, calls);
+    if (filled.length === 0 &&
+        read.parsed.length === 0 &&
+        read.made.length === 0 &&
+        copies.length === 0) {
+        return { filled: [], parsed: [], copied: [] };
+    }
+    const reach = valueReach(project, held);
+    const chains = aliasChains(project, held);
+    const members = (type) => {
+        const reached = reach.reachedFrom(type);
+        const ofClasses = classMembers(project, held, reached.classes, "instance");
+        return [
+            ...[...reached.classes].flatMap((id) => (ofClasses.get(id) ?? []).flatMap((member) => (member.flags & SymbolFlags.Property) !== 0 ? [member.id] : [])),
+            ...reached.members.flatMap((member) => (member.flags & SymbolFlags.Property) !== 0 ? chains.declarationsOf(member) : []),
+        ];
+    };
+    return {
+        filled: [
+            ...new Set([
+                ...filled.flatMap(({ carried, types }) => {
+                    const carries = new Set(members(carried));
+                    return types.flatMap((type) => members(type).filter((id) => carries.has(id)));
+                }),
+                ...read.made.flatMap(members),
+            ]),
+        ],
+        parsed: [...new Set(read.parsed.flatMap(members))],
+        copied: [
+            ...new Set(copies.flatMap(({ into, names }) => must(queries.constituents(into)).flatMap((part) => must(queries.propertiesOf(part)).flatMap((property) => (property.flags & SymbolFlags.Property) !== 0 && names.has(property.name)
+                ? chains.declarationsOf(property)
+                : [])))),
+        ],
+    };
+}
+/**
+ * Where one value is read as a type: each `as` and angle-bracket assertion around it,
+ * through parentheses, `await` and `!`, and the outermost expression unless a statement
+ * of its own or the object or callee of a further access holds it. A `satisfies` check
+ * is stepped through and types nothing, its expression's type being its operand's. A
+ * callback's result is read as well where the call taking the callback is, which may
+ * hand it on inside its result, as `map` does.
+ */
+function readAs(value, depth = 0) {
+    const asserted = [];
+    let at = value;
+    for (;;) {
+        const parent = at.parent;
+        if (isAsExpression(parent) || isTypeAssertion(parent)) {
+            asserted.push(parent.type);
+        }
+        else if (!isParenthesizedExpression(parent) &&
+            !isAwaitExpression(parent) &&
+            !isNonNullExpression(parent) &&
+            !isSatisfiesExpression(parent)) {
+            break;
+        }
+        at = parent;
+    }
+    const parent = at.parent;
+    const unused = isExpressionStatement(parent) ||
+        ((isPropertyAccessExpression(parent) ||
+            isElementAccessExpression(parent) ||
+            isCallExpression(parent)) &&
+            parent.expression === at);
+    const call = depth < MENTION_DEPTH ? callTaking(at) : undefined;
+    const outer = call === undefined ? undefined : readAs(call, depth + 1);
+    return {
+        asserted: [...asserted, ...(outer?.asserted ?? [])],
+        tops: [...(unused ? [] : [at]), ...(outer?.tops ?? [])],
+    };
+}
+/** The call one value is returned to as a callback's result, an argument of that call. */
+function callTaking(value) {
+    const parent = value.parent;
+    let callback;
+    if (isArrowFunction(parent) && parent.body === value) {
+        callback = parent;
+    }
+    else if (isReturnStatement(parent)) {
+        let at = parent.parent;
+        while (!isFunctionLikeDeclaration(at) && !isSourceFile(at)) {
+            at = at.parent;
+        }
+        callback = isArrowFunction(at) || isFunctionExpression(at) ? at : undefined;
+    }
+    let at = callback?.parent;
+    while (at !== undefined && isParenthesizedExpression(at)) {
+        at = at.parent;
+    }
+    return at !== undefined && isCallExpression(at) && at.expression !== callback ? at : undefined;
+}
+/** The global the standard library declares one name of `JSON` or `Object` as. */
+function standardGlobal(callee, global, name) {
+    return isPropertyAccessExpression(callee) &&
+        isIdentifier(callee.expression) &&
+        callee.expression.text === global &&
+        callee.name.text === name
+        ? callee.expression
+        : undefined;
+}
+/**
+ * The types each value of `values` typed `any` or `unknown` is read as ({@link readAs}):
+ * `parsed` for a `JSON.parse` call of the standard library, `made` for any other call or
+ * property, whose maker the analysis cannot see. `JSON` must be the standard library's
+ * global.
+ */
+function readTypes(project, values) {
+    if (values.length === 0) {
+        return { parsed: [], made: [] };
+    }
+    const own = project.ownPaths();
+    const parses = values.map((value) => isCallExpression(value) ? standardGlobal(value.expression, "JSON", "parse") : undefined);
+    const globals = parses.flatMap((global) => (global === undefined ? [] : [global]));
+    const standard = new Set(project
+        .symbolsAt(globals.map((global) => project.handle(global)))
+        .map(must)
+        .flatMap((symbol, at) => symbol?.declarations.every((handle) => !own.has(handle.path)) === true ? [globals[at]] : []));
+    // An `await` around the value reads the value it resolves to.
+    const valueTypes = typesAt(project, values.map((value) => (isAwaitExpression(value.parent) ? value.parent : value)));
+    const sites = values.flatMap((value, at) => {
+        const parse = parses[at];
+        const parsed = parse !== undefined && standard.has(parse);
+        const type = valueTypes[at];
+        const untyped = type !== undefined && (type.flags & (TypeFlags.Any | TypeFlags.Unknown)) !== 0;
+        return parsed || untyped ? [{ ...readAs(value), parsed }] : [];
+    });
+    // Each type node and each outermost expression, with whether a `JSON.parse` call is read as it.
+    const typed = sites.flatMap((site) => site.asserted.map((node) => ({ node, parsed: site.parsed })));
+    const placed = sites.flatMap((site) => site.tops.map((node) => ({ node, parsed: site.parsed })));
+    const read = [
+        ...typesAt(project, typed.map((one) => one.node)).map((type, at) => ({ type, parsed: typed[at]?.parsed })),
+        ...project.queries
+            .contextualTypes(placed.map((one) => one.node))
+            .map(must)
+            .map((type, at) => ({ type, parsed: placed[at]?.parsed })),
+    ];
+    const typesWhere = (parsed) => read.flatMap((one) => (one.type !== undefined && one.parsed === parsed ? [one.type] : []));
+    return { parsed: typesWhere(true), made: typesWhere(false) };
+}
+/**
+ * The copies the spreads and calls of `files` make: for each spread in an object literal,
+ * the type the literal is read as, and for each `Object.assign` call of the standard
+ * library, its first argument's type, with the member names of the copied values' types.
+ */
+function copiedNames(project, spreads, calls) {
+    const own = project.ownPaths();
+    const assigns = calls.flatMap((call) => {
+        const global = standardGlobal(call.expression, "Object", "assign");
+        const [target, ...sources] = call.arguments;
+        return global === undefined || target === undefined || sources.length === 0
+            ? []
+            : [{ global, target, sources: sources.filter((source) => !isSpreadElement(source)) }];
+    });
+    const standard = project
+        .symbolsAt(assigns.map((one) => project.handle(one.global)))
+        .map(must)
+        .map((symbol) => symbol?.declarations.every((handle) => !own.has(handle.path)) === true);
+    const assigned = assigns.filter((_one, at) => standard[at] === true);
+    const literals = spreads.flatMap((spread) => isObjectLiteralExpression(spread.parent)
+        ? [{ literal: spread.parent, source: spread.expression }]
+        : []);
+    const contexts = project.queries.contextualTypes(literals.map((one) => one.literal)).map(must);
+    const targets = typesAt(project, assigned.map((one) => one.target));
+    const spreadTypes = typesAt(project, literals.map((one) => one.source));
+    const sourceTypes = assigned.map((one) => typesAt(project, one.sources));
+    const namesOf = (types) => new Set(types.flatMap((type) => type === undefined
+        ? []
+        : must(project.queries.propertiesOf(type)).map((property) => property.name)));
+    const found = [];
+    const add = (into, names) => {
+        if (into !== undefined && names.size > 0) {
+            found.push({ into, names });
+        }
+    };
+    contexts.forEach((into, at) => {
+        add(into, namesOf([spreadTypes[at]]));
+    });
+    targets.forEach((into, at) => {
+        add(into, namesOf(sourceTypes[at] ?? []));
+    });
+    return found;
+}
+/** The value a promise of the standard library resolves to, through nested promises. */
+function awaited(project, type) {
+    const { queries } = project;
+    let at = type;
+    for (let depth = 0; depth < MENTION_DEPTH; depth += 1) {
+        const symbol = must(queries.symbolOfType(at));
+        const [inner] = must(queries.typeArguments(at));
+        const standard = symbol !== undefined &&
+            PROMISES.has(symbol.name) &&
+            symbol.declarations.every((handle) => project.program.getSourceFileMetadata(handle.path)?.isDefaultLibrary === true);
+        if (!standard || inner === undefined) {
+            break;
+        }
+        at = inner;
+    }
+    return at;
+}