@cplieger/deadset-ts 8.0.0-dev.2 → 8.0.0-dev.21

package/dist/src/serialization-contract.js

@@ -1,611 +0,0 @@
-/**
- * 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 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 { SignatureKind, SymbolFlags, TypeFlags, } from "@typescript/native/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 { must } 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" };
-/** 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;
-/** 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);
-}
-/** 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;
-}
-/** The methods of `Function.prototype` that invoke a function with arguments of their own. */
-const FUNCTION_METHODS = new Set(["call", "apply", "bind"]);
-/** The interfaces of the standard library that declare those methods for a function value. */
-const FUNCTION_INTERFACES = new Set([
-    "Function",
-    "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
- * binds `a`, and `f.bind(self, a)(b)`, which passes `b` after it. An `apply` argument
- * that is no array literal is the value of the first parameter, whose elements it
- * carries. Whether the method is the prototype's is resolution's to say.
- */
-function throughMethod(call) {
-    const expression = unparenthesized(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]);
-            passed = list === undefined ? [] : isArrayLiteralExpression(list) ? list.elements : [list];
-        }
-        return {
-            method: expression.name,
-            invocation: { callee: expression.expression, arguments: passed, indirect: true },
-        };
-    }
-    if (isCallExpression(expression)) {
-        const bound = unparenthesized(expression.expression);
-        if (isPropertyAccessExpression(bound) && bound.name.text === "bind") {
-            return {
-                method: bound.name,
-                invocation: {
-                    callee: bound.expression,
-                    arguments: [...expression.arguments.slice(1), ...call.arguments],
-                    indirect: true,
-                },
-            };
-        }
-    }
-    return undefined;
-}
-/**
- * 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] = 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) {
-            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, invocationOf) {
-    const spellings = new Set([...erased.values()].map((parameter) => parameter.name.getText()));
-    const candidates = sites.flatMap((site) => invocationOf(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))).map(must);
-    const symbolOf = new Map(plain.map((one, index) => [one, resolved[index]]));
-    return candidates.flatMap((one) => {
-        const symbol = one.value.shorthand
-            ? 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 }];
-    });
-}
-/**
- * The symbols of the interfaces and object types code of the analysis implements: those a
- * class's `implements` and `extends` clauses name, those an object literal is typed as by
- * a variable or property annotation or a `satisfies` or `as` expression, and every type
- * each of those extends. Read at the first call, which asks the checker.
- */
-function implementedOwners(project, inAnalysis) {
-    let owners;
-    return () => {
-        if (owners !== undefined) {
-            return owners;
-        }
-        const found = new Set();
-        const queries = project.queries;
-        const own = project.ownPaths();
-        const files = [
-            ...project.ownSourceFiles(),
-            ...project.program
-                .getSourceFileNames()
-                .filter((name) => !own.has(name) && inAnalysis(name))
-                .flatMap((name) => project.program.getSourceFile(name) ?? []),
-        ];
-        const naming = [];
-        const visit = (node) => {
-            if (isClassDeclaration(node) || isClassExpression(node)) {
-                naming.push(...(node.heritageClauses ?? []).flatMap((clause) => [...clause.types]));
-            }
-            else if ((isVariableDeclaration(node) || isPropertyDeclaration(node)) &&
-                node.type !== undefined &&
-                node.initializer !== undefined &&
-                isObjectLiteralExpression(evaluated(node.initializer))) {
-                naming.push(node.type);
-            }
-            else if ((isSatisfiesExpression(node) || isAsExpression(node)) &&
-                isObjectLiteralExpression(evaluated(node.expression))) {
-                naming.push(node.type);
-            }
-            node.forEachChild(visit);
-        };
-        for (const file of files) {
-            file.forEachChild(visit);
-        }
-        const pending = typesAt(project, naming).filter((type) => type !== undefined);
-        const seen = new Set();
-        for (let type = pending.pop(); type !== undefined; type = pending.pop()) {
-            for (const part of must(queries.constituents(type))) {
-                const target = must(queries.targetOf(part));
-                if (!seen.has(target.id)) {
-                    seen.add(target.id);
-                    const symbol = must(queries.symbolOfType(target));
-                    if (symbol !== undefined) {
-                        found.add(symbol.id);
-                    }
-                    pending.push(...must(queries.baseTypes(target)));
-                }
-            }
-        }
-        owners = found;
-        return owners;
-    };
-}
-/**
- * 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 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.
- */
-function destinations(input, chains, walked) {
-    const { project, held } = input;
-    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) {
-        const form = throughMethod(site.call);
-        if (form !== undefined) {
-            forms.set(site.call, form);
-        }
-    }
-    const callees = resolvedTargets(project, [
-        ...walked.sites.flatMap((site) => calleeName(site.call.expression) ?? []),
-        ...[...forms.values()].flatMap((form) => {
-            const name = calleeName(form.invocation.callee);
-            return name === undefined ? [form.method] : [form.method, 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 inAnalysis = (path) => own.has(path) || input.consumers.some((root) => path === root || path.startsWith(`${root}/`));
-    const implemented = implementedOwners(project, inAnalysis);
-    /**
-     * Whether every one of `declarations`, all of the callee's by default, is outside the
-     * analysis or ambient. An ambient declaration has no body, so the code that runs is
-     * outside the analysis, unless it is a member of an interface or an object type a class
-     * or a typed object literal of the analysis implements; `settled` false skips that
-     * question, which asks the checker.
-     */
-    const outside = (target, settled, declarations = target.declarations) => declarations.length > 0 &&
-        declarations.every((handle) => {
-            if (!inAnalysis(handle.path)) {
-                return true;
-            }
-            const node = project.declarationAt(handle)?.node;
-            if (node === undefined || (node.flags & NodeFlags.Ambient) === 0) {
-                return false;
-            }
-            if (!settled || !(isInterfaceDeclaration(node.parent) || isTypeLiteralNode(node.parent))) {
-                return true;
-            }
-            const owner = must(queries.parentOf(target));
-            return owner === undefined || !implemented().has(owner.id);
-        });
-    /**
-     * Whether some one declaration of a callee is outside the analysis or ambient, without
-     * asking the checker. A project's declaration merged into a library's symbol leaves the
-     * library's beside it, so a call can still resolve to the library's.
-     */
-    const mayBeOutside = (target) => target.declarations.some((handle) => outside(target, false, [handle]));
-    const invocation = (call) => {
-        const form = forms.get(call);
-        const method = form === undefined ? undefined : callees.get(form.method);
-        // Only the standard library's function methods pass their arguments on: the
-        // program's own `call` and `Reflect.apply` invoke nothing here.
-        if (form !== undefined &&
-            method !== undefined &&
-            mayBeOutside(method) &&
-            FUNCTION_INTERFACES.has(must(project.queries.parentOf(method))?.name ?? "")) {
-            return form.invocation;
-        }
-        return { callee: call.expression, arguments: call.arguments, indirect: false };
-    };
-    const calleeOf = (call) => {
-        const name = calleeName(invocation(call).callee);
-        return name === undefined ? undefined : callees.get(name);
-    };
-    const signatures = new Map();
-    const resolvedOf = (call) => {
-        if (!signatures.has(call)) {
-            signatures.set(call, must(queries.resolvedSignature(call)));
-        }
-        return signatures.get(call);
-    };
-    /**
-     * The declarations of a callee that the declaration of a direct call's resolved
-     * signature lies in, or all of them where it lies in none: a declaration merged into
-     * the callee's symbol that the call does not resolve to does not decide where it runs.
-     */
-    const calledDeclarations = (call, target) => {
-        const declaration = invocation(call).indirect ? undefined : resolvedOf(call)?.declaration;
-        const signature = declaration === undefined ? undefined : project.declarationAt(declaration)?.node;
-        if (declaration === undefined || signature === undefined) {
-            return target.declarations;
-        }
-        const containing = target.declarations.filter((handle) => {
-            const node = handle.path === declaration.path ? project.declarationAt(handle)?.node : undefined;
-            return node !== undefined && node.pos <= signature.pos && signature.end <= node.end;
-        });
-        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);
-        if (indexes === undefined) {
-            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 ? must(queries.typeAt(invoked.callee)) : undefined;
-            const signatures = invoked.indirect
-                ? type === undefined
-                    ? []
-                    : must(queries.signaturesOf(type, SignatureKind.Call))
-                : [resolvedOf(call)].filter((one) => one !== undefined);
-            // 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);
-        }
-        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) };
-        }
-        if (outside(target, true, calledDeclarations(call, target))) {
-            return erasedAt(call, argument)
-                ? {
-                    reach: "conversions",
-                    callee: invocation(call).callee.getText().replace(/\s+/gu, ""),
-                }
-                : undefined;
-        }
-        for (const fn of chains.declarationsOf(target)) {
-            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, invocation);
-    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;
-        }
-        if (named.some((one) => names(one, target, chains)) || mayBeOutside(target)) {
-            return true;
-        }
-        return chains
-            .declarationsOf(target)
-            .some((fn) => (byFunction.get(fn) ?? []).some((parameter) => forwards.has(keyOf(parameter))));
-    };
-    return { invocation, at, mayReceive };
-}
-/** What two reaches carry together. */
-function joined(a, b) {
-    return { classes: new Set([...a.classes, ...b.classes]), members: [...a.members, ...b.members] };
-}
-/** Each argument of a call that can receive one whose value carries a class of the target. */
-function flowsOf(project, held, sites, to, stores) {
-    const reach = valueReach(project, held, stores.inside);
-    const arguments_ = sites.flatMap((site) => to.mayReceive(site.call)
-        ? to.invocation(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]]));
-    const checked = checkedTypes(project, arguments_.map((one) => one.value));
-    const passed = arguments_.flatMap((one, index) => {
-        const type = typeOf.get(one.value);
-        let reached = { classes: new Set(), members: [] };
-        if (one.value.kind === SyntaxKind.ThisKeyword) {
-            reached = {
-                classes: new Set(one.site.self === undefined ? [] : [one.site.self]),
-                members: [],
-            };
-        }
-        else if (type !== undefined) {
-            reached = reach.reachedFrom(type);
-        }
-        for (const stored of [...(checked[index] ?? []), ...(stores.ofVariable(one.value) ?? [])]) {
-            reached = joined(reached, reach.reachedFrom(stored));
-        }
-        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,
-                    detail: `passed to ${destination.callee}`,
-                },
-            ];
-    });
-    const left = stores.outside.flatMap((store) => {
-        const reached = reach.reachedFrom(store.type);
-        return reached.classes.size === 0 && reached.members.length === 0
-            ? []
-            : [
-                {
-                    site: store.value,
-                    classes: reached.classes,
-                    members: reached.members,
-                    to: { reach: "conversions", callee: store.property },
-                    detail: `stored in the property ${store.property} of a type the program does not declare`,
-                },
-            ];
-    });
-    return [...passed, ...left];
-}
-/**
- * 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 chains = aliasChains(project, held);
-    const flows = flowsOf(project, held, walked.sites, destinations(input, chains, walked), erasedStores(project));
-    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 & CONVERSION_MEMBERS) !== 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 } = flow;
-        for (const member of [...flow.classes].flatMap((id) => members.get(id) ?? [])) {
-            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 });
-            }
-        }
-        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;
-}

package/dist/src/setup-failure.js

@@ -1,23 +0,0 @@
-/**
- * A setup failure: a file or a component the analysis needs and the project does not
- * provide. Each one names what is missing and the fix, on one line of the error stream
- * that starts with its class.
- */
-/** The failure as the one line of the error stream that names it. */
-export function setupLine(failure) {
-    return `setup failure: ${failure.setupClass}: ${failure.detail}`;
-}
-/**
- * A run that met a setup failure where none may be dropped: in a configuration the
- * configuration document or the scope declares, in a declared consumer, or in every
- * configuration discovery derived. It ends the run with the failure code and no finding
- * list.
- */
-export class SetupError extends Error {
-    failures;
-    constructor(failures) {
-        super(failures.map(setupLine).join("\n"));
-        this.name = "SetupError";
-        this.failures = failures;
-    }
-}