@cplieger/deadset-ts 8.0.0-dev.3 → 8.0.0-dev.4

package/dist/src/roots.js

@@ -9,6 +9,7 @@
  */
 import { isArrowFunction, isAssertionExpression, isExpressionWithTypeArguments, isFunctionLikeDeclaration, isIdentifier, isMethodDeclaration, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAssignment, isReturnStatement, isSatisfiesExpression, isPropertyAccessExpression, isQualifiedName, isTypeQueryNode, isTypeReferenceNode, isPropertyDeclaration, isVariableDeclaration, isVariableStatement, SyntaxKind, } from "@typescript/native/ast";
 import { aliasChains } from "./alias-chain.js";
+import { isGlobalBlock } from "./augmentations.js";
 import { filesNamedBy, outsideChain, relativeSpecifiers, } from "./configuration-files.js";
 import { conventionEntries } from "./conventions.js";
 import { entryPoints } from "./entry-points.js";
@@ -443,9 +444,11 @@ const EXPORTING_CONTAINERS = new Set(["file", "namespace"]);
  * Every declaration a consumer of the library can name: what the published files export,
  * and below each the members a consumer writes, a namespace's exported ones and any other
  * declaration's public and protected ones. A declaration a published one's type names is
- * published too, and so is an exported declaration a release tag marks. A type name the
- * checker leaves unanswered publishes every declaration spelled as it is, as `guessed`. A
- * published file is not itself published.
+ * published too, and so is an exported declaration a release tag marks, and every
+ * declaration a `declare global` block of a published file, or of a file holding a published
+ * declaration, holds: the consumer's compiler loads that file's typings and their global
+ * scope with it. A type name the checker leaves unanswered publishes every declaration
+ * spelled as it is, as `guessed`. A published file is not itself published.
  */
 function publishedAPI(project, published, exportsOf, held, byPath, tagged) {
     const byId = new Map(held.symbols.map((symbol) => [symbol.id, symbol]));
@@ -471,55 +474,80 @@ function publishedAPI(project, published, exportsOf, held, byPath, tagged) {
             reach(id);
         }
     }
-    while (pending.length > 0) {
-        const round = [];
-        for (let next = pending.shift(); next !== undefined; next = pending.shift()) {
-            round.push(next);
-            const exporting = EXPORTING_CONTAINERS.has(byId.get(next)?.kind ?? "");
-            for (const member of children.get(next) ?? []) {
-                const reachable = exporting
-                    ? member.exported
-                    : member.visibility !== "private" && member.visibility !== "private-name";
-                if (member.kind !== "type-parameter" && reachable) {
+    const files = new Set(held.symbols.filter((one) => one.kind === "file").map((one) => one.id));
+    const blocks = held.symbols.filter((one) => isGlobalBlock(one, held, files));
+    const fileOf = (id) => {
+        let at = byId.get(id);
+        while (at !== undefined && at.kind !== "file") {
+            at = byId.get(at.parent);
+        }
+        return at?.id;
+    };
+    const publishedFiles = published.flatMap((file) => held.declarations.get(nodeKey(file, file)) ?? []);
+    const globalsReached = () => {
+        const typed = new Set([...publishedFiles, ...[...reached].flatMap((id) => fileOf(id) ?? [])]);
+        const before = pending.length;
+        for (const block of blocks.filter((one) => typed.has(one.parent))) {
+            reach(block.id);
+            for (const member of children.get(block.id) ?? []) {
+                if (member.kind !== "type-parameter") {
                     reach(member.id);
                 }
             }
         }
-        const named = round.flatMap((id) => {
-            const symbol = byId.get(id);
-            return symbol === undefined || symbol.kind === "file" ? [] : nodes.typeNamesOf(symbol);
-        });
-        const inferred = inferredTypeSymbols(project, round.flatMap((id) => {
-            const symbol = byId.get(id);
-            return symbol === undefined ? [] : nodes.nodesOf(symbol);
-        }));
-        for (const symbol of inferred.types) {
-            for (const target of chains.chainOf(symbol)) {
-                reach(target.id);
-            }
-        }
-        for (const symbol of inferred.members) {
-            for (const target of chains.chainOf(symbol)) {
-                const member = byId.get(target.id);
-                if (member?.visibility === "public" || member?.visibility === "protected") {
-                    reach(target.id);
+        return pending.length > before;
+    };
+    do {
+        while (pending.length > 0) {
+            const round = [];
+            for (let next = pending.shift(); next !== undefined; next = pending.shift()) {
+                round.push(next);
+                const exporting = EXPORTING_CONTAINERS.has(byId.get(next)?.kind ?? "");
+                for (const member of children.get(next) ?? []) {
+                    const reachable = exporting
+                        ? member.exported
+                        : member.visibility !== "private" && member.visibility !== "private-name";
+                    if (member.kind !== "type-parameter" && reachable) {
+                        reach(member.id);
+                    }
                 }
             }
-        }
-        project.symbolsAt(named.map((node) => project.handle(node))).forEach((symbol, index) => {
-            if (symbol === UNANSWERED) {
-                for (const id of held.byName.get(named[index]?.getText() ?? "") ?? []) {
-                    guessed.add(id);
-                    reach(id);
+            const named = round.flatMap((id) => {
+                const symbol = byId.get(id);
+                return symbol === undefined || symbol.kind === "file" ? [] : nodes.typeNamesOf(symbol);
+            });
+            const inferred = inferredTypeSymbols(project, round.flatMap((id) => {
+                const symbol = byId.get(id);
+                return symbol === undefined ? [] : nodes.nodesOf(symbol);
+            }));
+            for (const symbol of inferred.types) {
+                for (const target of chains.chainOf(symbol)) {
+                    reach(target.id);
                 }
             }
-            else if (symbol !== undefined) {
+            for (const symbol of inferred.members) {
                 for (const target of chains.chainOf(symbol)) {
-                    reach(target.id);
+                    const member = byId.get(target.id);
+                    if (member?.visibility === "public" || member?.visibility === "protected") {
+                        reach(target.id);
+                    }
                 }
             }
-        });
-    }
+            project.symbolsAt(named.map((node) => project.handle(node))).forEach((symbol, index) => {
+                if (symbol === UNANSWERED) {
+                    for (const id of held.byName.get(named[index]?.getText() ?? "") ?? []) {
+                        guessed.add(id);
+                        reach(id);
+                    }
+                }
+                else if (symbol !== undefined) {
+                    for (const target of chains.chainOf(symbol)) {
+                        reach(target.id);
+                    }
+                }
+            });
+        }
+    } while (globalsReached());
     return { ids: [...reached], guessed: [...guessed] };
 }
 /** The type names declarations of the inventory write, each file walked once, when first asked. */

package/dist/src/serialization-contract.js

@@ -6,7 +6,7 @@
  * 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, isFunctionLikeDeclaration, isGetAccessorDeclaration, isIdentifier, isInterfaceDeclaration, isMethodDeclaration, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectLiteralExpression, isParenthesizedExpression, isForInStatement, 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 { SignatureKind, SymbolFlags, TypeFlags, } from "@typescript/native/sync";
 import { aliasChains } from "./alias-chain.js";
 import { calleeName, resolvedTargets, valuesPassed } from "./calls.js";
@@ -14,7 +14,7 @@ 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. */
@@ -25,6 +25,8 @@ const CONVERSIONS = new Set(["toJSON", "toString"]);
 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. */
@@ -135,9 +137,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));
             }
@@ -171,7 +180,7 @@ 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([
@@ -182,15 +191,15 @@ const ENUMERATIONS = new Set([
     "assign",
 ]);
 /**
- * Whether a parameter type keeps no member name of the value it is given: `unknown`, `any`,
- * or an object type of a string index signature and no property.
+ * 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 ||
-        must(project.queries.propertiesOf(type)).length > 0) {
+    if ((type.flags & TypeFlags.Object) === 0) {
         return false;
     }
     return must(project.queries.indexInfosOf(type)).some((info) => (info.keyType.flags & TypeFlags.String) !== 0);
@@ -711,6 +720,34 @@ function typeParametersOf(project, type, depth) {
         ...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
@@ -838,6 +875,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());
@@ -846,16 +887,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;
+}

package/dist/src/verbs/analyze.js

@@ -259,7 +259,6 @@ export const analyzeVerb = ({ err, host, inputs, scope, openClient, option, repe
     try {
         host.writeDocument(documents.report, json(report));
         const options = {
-            failOn: config.reporters.failOn,
             readSource: (path) => host.readFile(joinPath(targetRoot, path)),
             template,
         };

package/dist/src/workflow-steps.js

@@ -74,24 +74,32 @@ export function runCommands(text, key = RUN_LINE) {
     return found;
 }
 /**
- * Every token the recipe lines of the target root's makefile hold, each with the directory
- * below the root it is read against: a recipe line is one that starts with a tab, joined
- * with the lines a trailing `\` continues it onto, and make runs each in a shell of its
- * own, so a `cd` moves the directory of the later commands of its line alone.
+ * The commands of the recipe lines of the target root's makefile, each line's in order: a
+ * recipe line is one that starts with a tab, joined with the lines a trailing `\`
+ * continues it onto.
  */
-function recipeTokens(host, root) {
+function recipeLines(host, root) {
     const path = MAKEFILES.map((name) => joinPath(root, name)).find((candidate) => host.kindOf(candidate) === "file");
     const text = path === undefined ? undefined : readText(host, path);
     if (text === undefined) {
         return [];
     }
+    return text
+        .replace(/\\\r?\n/gu, " ")
+        .split(/\r?\n/u)
+        .filter((line) => line.startsWith("\t"))
+        .map((line) => withoutComment(line.slice(1).replace(/^[@+-]+/u, "")).split(COMMAND_SEPARATORS));
+}
+/**
+ * Every token the recipe lines of the target root's makefile hold, each with the directory
+ * below the root it is read against: make runs each line in a shell of its own, so a `cd`
+ * moves the directory of the later commands of its line alone.
+ */
+function recipeTokens(host, root) {
     const found = [];
-    for (const line of text.replace(/\\\r?\n/gu, " ").split(/\r?\n/u)) {
-        if (!line.startsWith("\t")) {
-            continue;
-        }
+    for (const line of recipeLines(host, root)) {
         let dir = root;
-        for (const command of withoutComment(line.slice(1).replace(/^[@+-]+/u, "")).split(COMMAND_SEPARATORS)) {
+        for (const command of line) {
             const tokens = scriptTokens(command);
             const [first, target, ...rest] = tokens;
             if (first === "cd" && target !== undefined && rest.length === 0 && !COMPUTED.test(target)) {
@@ -131,13 +139,25 @@ function withoutComment(line) {
     return line;
 }
 /**
- * Every token the target root's workflow steps, git hooks and makefile hold: the `run:`
+ * Every command the target root's workflow steps, git hooks and makefile run: the `run:`
  * steps of the workflow files in `.github/workflows`, every line of each file in `.husky`
  * and `.githooks`, the `entry:` commands of `.pre-commit-config.yaml`, the `run:` commands
  * of a lefthook file and the makefile's recipe lines.
  */
+export function workflowCommands(host, targetRoot) {
+    const root = resolvePath(host.workingDirectory(), targetRoot);
+    return [...stepCommands(host, root), ...recipeLines(host, root).flat()];
+}
+/** Every token the commands {@link workflowCommands} reads hold. */
 export function workflowTokens(host, targetRoot) {
     const root = resolvePath(host.workingDirectory(), targetRoot);
+    return [
+        ...stepCommands(host, root).flatMap((command) => scriptTokens(command)),
+        ...recipeTokens(host, root).map(({ token }) => token),
+    ];
+}
+/** The commands of the workflow steps, git hooks and hook managers at one root. */
+function stepCommands(host, root) {
     const commands = [];
     for (const path of filesIn(host, joinPath(root, WORKFLOWS), (name) => /\.ya?ml$/u.test(name))) {
         commands.push(...runCommands(readText(host, path) ?? ""));
@@ -150,10 +170,7 @@ export function workflowTokens(host, targetRoot) {
     for (const [name, key] of HOOK_MANAGERS) {
         commands.push(...runCommands(readText(host, joinPath(root, name)) ?? "", key));
     }
-    return [
-        ...commands.flatMap((command) => scriptTokens(command)),
-        ...recipeTokens(host, root).map(({ token }) => token),
-    ];
+    return commands;
 }
 /**
  * The own files the target root's workflow steps and git hooks name, as

package/jsr.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "8.0.0-dev.3",
+  "version": "8.0.0-dev.4",
   "license": "GPL-3.0-or-later",
   "exports": {
     ".": "./src/index.ts"