@cplieger/deadset-ts 7.0.0-dev.2 → 7.0.0-dev.4

package/dist/src/indexed-access.js

@@ -4,8 +4,8 @@
  * that parameter, and a call of a method of a generic receiver fixes the receiver's by its
  * type arguments. The type query of a type-query alias is no reference.
  */
-import { isArrowFunction, isCallExpression, isClassDeclaration, isClassExpression, isFunctionDeclaration, isFunctionExpression, isIdentifier, isNonNullExpression, isParenthesizedExpression, isNamedImports, isNamespaceImport, isImportDeclaration, isIndexedAccessTypeNode, isInterfaceDeclaration, isLiteralTypeNode, isMethodDeclaration, isMethodSignatureDeclaration, isNewExpression, isNoSubstitutionTemplateLiteral, isNumericLiteral, isParenthesizedTypeNode, isPropertyAccessExpression, isStringLiteral, isTypeAliasDeclaration, isTypeReferenceNode, isUnionTypeNode, isVariableDeclaration, } from "@typescript/native/unstable/ast";
-import { SymbolFlags } from "@typescript/native/unstable/sync";
+import { isArrowFunction, isBindingElement, isCallExpression, isClassDeclaration, isClassExpression, isFunctionDeclaration, isFunctionExpression, isFunctionTypeNode, isIdentifier, isIndexedAccessTypeNode, isInterfaceDeclaration, isLiteralTypeNode, isMappedTypeNode, isMethodDeclaration, isMethodSignatureDeclaration, isNewExpression, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectBindingPattern, isParenthesizedTypeNode, isPropertyAccessExpression, isPropertySignatureDeclaration, isStringLiteral, isTypeAliasDeclaration, isTypeOperatorNode, isTypeReferenceNode, isUnionTypeNode, isVariableDeclaration, SyntaxKind, } from "@typescript/native/ast";
+import { SignatureKind, SymbolFlags, } from "@typescript/native/sync";
 import { nodeKey } from "./inventory.js";
 import { renderPosition } from "./position.js";
 import { UNANSWERED } from "./query.js";
@@ -16,6 +16,7 @@ function isGeneric(node) {
         isMethodSignatureDeclaration(node) ||
         isArrowFunction(node) ||
         isFunctionExpression(node) ||
+        isFunctionTypeNode(node) ||
         isTypeAliasDeclaration(node) ||
         isInterfaceDeclaration(node) ||
         isClassDeclaration(node) ||
@@ -26,6 +27,29 @@ function isGeneric(node) {
 function isReceiver(node) {
     return isInterfaceDeclaration(node) || isClassDeclaration(node) || isClassExpression(node);
 }
+/**
+ * The class or the interface one member function belongs to: a method's parent, or for a
+ * function type a property declares, the declaration that holds the property.
+ */
+function receiverOf(member) {
+    const parent = member.parent;
+    if (isFunctionTypeNode(member) &&
+        parent !== undefined &&
+        isPropertySignatureDeclaration(parent)) {
+        return parent.parent;
+    }
+    return parent;
+}
+/** Whether a member function of a generic receiver declares no type parameter of its own. */
+function isReceiverMember(node) {
+    if (!(isMethodDeclaration(node) ||
+        isMethodSignatureDeclaration(node) ||
+        isFunctionTypeNode(node))) {
+        return false;
+    }
+    const receiver = receiverOf(node);
+    return receiver !== undefined && isReceiver(receiver) && isGeneric(receiver);
+}
 function unwrappedType(node) {
     return isParenthesizedTypeNode(node) ? unwrappedType(node.type) : node;
 }
@@ -86,6 +110,28 @@ function namedParameter(node, enclosing) {
     }
     return undefined;
 }
+/**
+ * The constraint of the mapped type whose type parameter one type node names whole: a
+ * mapped type instantiates what it holds once per constituent of that constraint.
+ */
+function mappedConstraint(node) {
+    const type = unwrappedType(node);
+    if (!isTypeReferenceNode(type) ||
+        !isIdentifier(type.typeName) ||
+        type.typeArguments !== undefined) {
+        return undefined;
+    }
+    const spelled = type.typeName.text;
+    for (let at = type.parent; at !== undefined; at = at.parent) {
+        if (isMappedTypeNode(at)) {
+            const { name, constraint } = at.typeParameter;
+            if (isIdentifier(name) && name.text === spelled) {
+                return constraint;
+            }
+        }
+    }
+    return undefined;
+}
 /** The name a site writes to reach one generic: its own, or its variable's. */
 function calledName(generic) {
     const own = generic.name;
@@ -93,15 +139,23 @@ function calledName(generic) {
         return own.text;
     }
     const parent = generic.parent;
-    return parent !== undefined && isVariableDeclaration(parent) && isIdentifier(parent.name)
+    return parent !== undefined &&
+        (isVariableDeclaration(parent) || isPropertySignatureDeclaration(parent)) &&
+        isIdentifier(parent.name)
         ? parent.name.text
         : undefined;
 }
 /** The generic a declaration a symbol names is: the function a variable is initialized with included. */
 function genericOf(node) {
-    if (isGeneric(node)) {
+    if (isGeneric(node) || isReceiverMember(node)) {
         return node;
     }
+    if (isPropertySignatureDeclaration(node)) {
+        // The typings mark the annotation present; a signature written without one has none.
+        const declared = node.type;
+        const type = declared === undefined ? undefined : unwrappedType(declared);
+        return type !== undefined && isFunctionTypeNode(type) ? genericOf(type) : undefined;
+    }
     if (isVariableDeclaration(node) &&
         node.initializer !== undefined &&
         isGeneric(node.initializer)) {
@@ -109,29 +163,60 @@ function genericOf(node) {
     }
     return undefined;
 }
+/** The operand of each `keyof` one type node holds, through every type node it is built of. */
+function keyofOperands(node) {
+    const found = [];
+    const visit = (at) => {
+        if (isTypeOperatorNode(at) && at.operator === SyntaxKind.KeyOfKeyword) {
+            found.push(at.type);
+            return;
+        }
+        at.forEachChild(visit);
+    };
+    visit(node);
+    return found;
+}
 /**
  * Each indexed access inside one generic whose index names a type parameter of it, read
  * from its own text: the object side is a type parameter of the same generic, one of the
- * receiver it is a method of, or a type it writes.
+ * receiver it is a member of, or a type it writes. A type parameter whose constraint holds
+ * `keyof X` is an index into `X` as `X[K]` is, and so is a parameter whose declared type
+ * holds `keyof X`, indexed by the argument a call passes it.
  */
 function carriedIn(generic) {
     const found = [];
-    const receiver = generic.parent;
+    const receiver = receiverOf(generic);
     const outer = receiver !== undefined && isReceiver(receiver) && isGeneric(receiver) ? receiver : undefined;
+    const sideOf = (object) => {
+        const own = namedParameter(object, [generic]);
+        const fromReceiver = own === undefined && outer !== undefined ? namedParameter(object, [outer]) : undefined;
+        return own !== undefined
+            ? { kind: "parameter", index: own.index }
+            : fromReceiver !== undefined
+                ? { kind: "receiver", index: fromReceiver.index }
+                : { kind: "written", node: object };
+    };
+    (generic.typeParameters ?? []).forEach((parameter, index) => {
+        const constraint = parameter.constraint;
+        for (const object of constraint === undefined ? [] : keyofOperands(constraint)) {
+            found.push({ object: sideOf(object), index: { kind: "parameter", index } });
+        }
+    });
+    (generic.parameters ?? []).forEach((parameter, index) => {
+        for (const object of parameter.type === undefined ? [] : keyofOperands(parameter.type)) {
+            if (namedParameter(object, [generic]) === undefined) {
+                found.push({ object: sideOf(object), index: { kind: "argument", index } });
+            }
+        }
+    });
     const visit = (node) => {
         if (isIndexedAccessTypeNode(node)) {
             const index = namedParameter(node.indexType, [generic]);
             if (index !== undefined) {
-                const own = namedParameter(node.objectType, [generic]);
-                const fromReceiver = own === undefined && outer !== undefined
-                    ? namedParameter(node.objectType, [outer])
-                    : undefined;
-                const object = own !== undefined
-                    ? { kind: "parameter", index: own.index }
-                    : fromReceiver !== undefined
-                        ? { kind: "receiver", index: fromReceiver.index }
-                        : { kind: "written", node: node.objectType };
-                found.push({ object, index: { kind: "parameter", index: index.index } });
+                found.push({
+                    object: sideOf(node.objectType),
+                    index: { kind: "parameter", index: index.index },
+                });
             }
         }
         if (node !== generic && isGeneric(node)) {
@@ -153,11 +238,8 @@ export function indexedAccessReferences(project, held, chains, root, testFiles)
     const carried = new Map();
     const names = new Set();
     const sites = [];
-    /**
-     * Calls passing a literal argument whose callee a package binding heads, or that call a
-     * method, which a dependency's generic may fix.
-     */
-    const literalCalls = [];
+    /** Calls passing an argument, which a generic declared outside the own files may fix. */
+    const argumentCalls = [];
     const carry = (generic, one) => {
         const known = carried.get(generic) ?? [];
         const same = known.some((other) => JSON.stringify(sideKey(other)) === JSON.stringify(sideKey(one)));
@@ -177,7 +259,6 @@ export function indexedAccessReferences(project, held, chains, root, testFiles)
             continue;
         }
         const aliasTypes = new Set(typeQueryAliases(file).map((alias) => alias.type));
-        const imported = packageBindings(file);
         const visit = (node, from, enclosing) => {
             const own = held.declarations.get(nodeKey(file, node));
             const holder = own ?? from;
@@ -206,13 +287,8 @@ export function indexedAccessReferences(project, held, chains, root, testFiles)
                 if (name !== undefined) {
                     const site = { file, from: holder, node, name, enclosing: inside };
                     sites.push(site);
-                    const literal = (node.arguments ?? []).some((argument) => isStringLiteral(argument) || isNumericLiteral(argument));
-                    const head = rootName(callee);
-                    const method = isPropertyAccessExpression(callee);
-                    if (literal &&
-                        isCallExpression(node) &&
-                        (method || (head !== undefined && imported.has(head)))) {
-                        literalCalls.push(site);
+                    if (isCallExpression(node) && node.arguments.length > 0) {
+                        argumentCalls.push(site);
                     }
                 }
             }
@@ -240,6 +316,47 @@ export function indexedAccessReferences(project, held, chains, root, testFiles)
             return generic === undefined ? [] : [generic];
         });
     };
+    /**
+     * The type a call's callee is read off: the receiver of a property access, the value an
+     * object binding pattern destructures the callee from, or the value whose member a
+     * variable holding the callee is initialized with.
+     */
+    const receiverTypeOf = (callee) => {
+        if (isPropertyAccessExpression(callee)) {
+            const type = queries.typeAt(callee.expression);
+            const args = type === UNANSWERED || type === undefined ? [] : queries.typeArguments(type);
+            if (type !== UNANSWERED && type !== undefined && args !== UNANSWERED && args.length > 0) {
+                return type;
+            }
+        }
+        const name = isPropertyAccessExpression(callee) ? callee.name : callee;
+        const [named] = queries.symbolsAt([name]);
+        const symbol = named === UNANSWERED || named === undefined || (named.flags & SymbolFlags.Alias) === 0
+            ? named
+            : queries.aliased(named);
+        if (symbol === UNANSWERED || symbol === undefined) {
+            return undefined;
+        }
+        for (const handle of symbol.declarations) {
+            const node = project.declarationAt(handle)?.node;
+            const holder = node !== undefined &&
+                isBindingElement(node) &&
+                isObjectBindingPattern(node.parent) &&
+                isVariableDeclaration(node.parent.parent)
+                ? node.parent.parent.initializer
+                : node !== undefined &&
+                    isVariableDeclaration(node) &&
+                    node.initializer !== undefined &&
+                    isPropertyAccessExpression(node.initializer)
+                    ? node.initializer.expression
+                    : undefined;
+            const type = holder === undefined ? undefined : queries.typeAt(holder);
+            if (type !== UNANSWERED && type !== undefined) {
+                return type;
+            }
+        }
+        return undefined;
+    };
     /** What one site fixes for one side of a carried access. */
     const fixedAt = (site, side, generic) => {
         if (side.kind === "written") {
@@ -248,23 +365,26 @@ export function indexedAccessReferences(project, held, chains, root, testFiles)
         const { node } = site;
         if (side.kind === "receiver") {
             const callee = isCallExpression(node) ? node.expression : undefined;
-            if (callee === undefined || !isPropertyAccessExpression(callee)) {
-                return undefined;
-            }
-            const receiver = queries.typeAt(callee.expression);
-            if (receiver === UNANSWERED || receiver === undefined) {
+            const receiver = callee === undefined ? undefined : receiverTypeOf(callee);
+            if (receiver === undefined) {
                 return undefined;
             }
             const args = queries.typeArguments(receiver);
             const type = args === UNANSWERED ? undefined : args[side.index];
             return type === undefined ? undefined : { kind: "type", type };
         }
+        if (side.kind === "argument") {
+            const argument = isTypeReferenceNode(node) ? undefined : node.arguments?.[side.index];
+            const type = argument === undefined ? undefined : queries.typeAt(argument);
+            return type === UNANSWERED || type === undefined ? undefined : { kind: "type", type };
+        }
         const written = node.typeArguments?.[side.index];
         if (written !== undefined) {
             const passed = namedParameter(written, site.enclosing);
-            return passed === undefined
-                ? { kind: "node", node: written }
-                : { kind: "passed", generic: passed.generic, index: passed.index };
+            const mapped = passed === undefined ? mappedConstraint(written) : undefined;
+            return passed !== undefined
+                ? { kind: "passed", generic: passed.generic, index: passed.index }
+                : { kind: "node", node: mapped ?? written };
         }
         if (isTypeReferenceNode(node)) {
             return undefined;
@@ -358,40 +478,120 @@ export function indexedAccessReferences(project, held, chains, root, testFiles)
             }
         });
     }
-    // A generic function or method declared outside the project's own files carries what
-    // its own text indexes by its type parameters and its receiver's.
-    const outside = literalCalls.filter((site) => !resolvedGenerics.has(site));
-    const methods = outside.length === 0
-        ? []
-        : queries.symbolsAt(outside.map((site) => {
-            const callee = site.node.expression;
-            return isPropertyAccessExpression(callee) ? callee.name : callee;
-        }));
+    // A generic declared outside the project's own files carries what its own text indexes
+    // by its type parameters and its receiver's. Only a call passing an argument the compiler
+    // types as a literal can fix an index, so only such a call's signature is resolved.
+    const outside = argumentCalls.filter((site) => !resolvedGenerics.has(site));
+    const argumentNodes = argumentCalls.flatMap((site) => [
+        ...site.node.arguments,
+    ]);
+    const argumentTypes = queries.typesAt(argumentNodes);
+    const literalArgument = new Set();
+    argumentTypes.forEach((type, at) => {
+        const node = argumentNodes[at];
+        if (node !== undefined &&
+            type !== UNANSWERED &&
+            type !== undefined &&
+            (literalTypeNames(type, partsOf)?.length ?? 0) > 0) {
+            literalArgument.add(node);
+        }
+    });
     const own = project.ownPaths();
-    outside.forEach((site, at) => {
-        const named = methods[at];
-        const symbol = named === UNANSWERED || named === undefined || (named.flags & SymbolFlags.Alias) === 0
-            ? named
-            : queries.aliased(named);
-        if (symbol === UNANSWERED ||
-            symbol === undefined ||
-            (symbol.flags & (SymbolFlags.Function | SymbolFlags.Method)) === 0) {
-            return;
+    for (const site of outside) {
+        if (!site.node.arguments.some((one) => literalArgument.has(one))) {
+            continue;
         }
-        for (const handle of symbol.declarations) {
-            if (own.has(handle.path)) {
-                continue;
+        const resolved = queries.resolvedSignature(site.node);
+        const handle = resolved === UNANSWERED || resolved === undefined ? undefined : resolved.declaration;
+        if (handle === undefined || own.has(handle.path)) {
+            continue;
+        }
+        const node = project.declarationAt(handle)?.node;
+        const generic = node === undefined ? undefined : genericOf(node);
+        if (generic === undefined) {
+            continue;
+        }
+        for (const one of carriedIn(generic)) {
+            readAt(site, generic, one);
+        }
+    }
+    for (const site of argumentCalls) {
+        if (site.node.arguments.some((one) => literalArgument.has(one))) {
+            accesses.push(...instantiatedAccesses(site));
+        }
+    }
+    /**
+     * The indexed accesses the generic signature a call instantiates holds, read through the
+     * checker: the signature its receiver's instantiation gives, so an object type its
+     * receiver fixes is concrete whatever declaration spells the receiver's type, a type
+     * literal a generic function returns among them. An index naming a type parameter is the
+     * literal type the call passes at each parameter of that type.
+     */
+    function instantiatedAccesses(site) {
+        const resolved = queries.resolvedSignature(site.node);
+        const generic = resolved === UNANSWERED || resolved === undefined ? undefined : queries.genericOf(resolved);
+        if (resolved === UNANSWERED ||
+            resolved === undefined ||
+            generic === UNANSWERED ||
+            generic === undefined) {
+            return [];
+        }
+        const count = site.node.arguments.length;
+        const parameters = [];
+        for (let at = 0; at < count; at += 1) {
+            const type = queries.parameterType(generic, at);
+            if (type !== UNANSWERED && type !== undefined) {
+                parameters[at] = type;
             }
-            const node = project.declarationAt(handle)?.node;
-            const generic = node === undefined ? undefined : genericOf(node);
-            if (generic === undefined) {
+        }
+        const result = queries.returnTypeOf(generic);
+        const held = [
+            ...parameters,
+            ...(result === UNANSWERED || result === undefined ? [] : [result]),
+        ];
+        // A parameter of a callback and a type argument, a rest tuple's among them, hold the
+        // accesses one level down: `fn: (payload: M[K]) => void` and `...[M[K]]`.
+        const nested = held.flatMap((type) => [
+            ...partsOf(type),
+            ...partsOf(type).flatMap((part) => {
+                const args = queries.typeArguments(part);
+                const calls = queries.signaturesOf(part, SignatureKind.Call);
+                return [
+                    ...(args === UNANSWERED ? [] : args),
+                    ...(calls === UNANSWERED ? [] : calls).flatMap((signature) => signature.parameters.flatMap((_parameter, index) => {
+                        const one = queries.parameterType(signature, index);
+                        return one === UNANSWERED || one === undefined ? [] : [one];
+                    })),
+                ];
+            }),
+        ]);
+        const found = [];
+        for (const type of nested) {
+            const access = queries.indexedAccessOf(type);
+            if (access === UNANSWERED || access === undefined || access.object.isTypeParameter()) {
                 continue;
             }
-            for (const one of carriedIn(generic)) {
-                readAt(site, generic, one);
+            const names = access.index.isTypeParameter()
+                ? parameters.flatMap((parameter, at) => {
+                    if (parameter.id !== access.index.id) {
+                        return [];
+                    }
+                    const passed = queries.typeAtPosition(resolved, at);
+                    return passed === UNANSWERED ? [] : (literalTypeNames(passed, partsOf) ?? []);
+                })
+                : (literalTypeNames(access.index, partsOf) ?? []);
+            if (names.length > 0) {
+                found.push({
+                    file: site.file,
+                    from: site.from,
+                    at: site.node,
+                    object: access.object,
+                    index: names,
+                });
             }
         }
-    });
+        return found;
+    }
     const typeNodes = accesses.flatMap((one) => [
         ...("kind" in one.object ? [one.object] : []),
         ...(!Array.isArray(one.index) && "kind" in one.index ? [one.index] : []),
@@ -443,67 +643,6 @@ export function indexedAccessReferences(project, held, chains, root, testFiles)
     }
     return found;
 }
-/**
- * The local names one file binds to a package: each name an import declaration with a
- * bare specifier binds, and each variable initialized by a call or a construction whose
- * callee such a name heads, read in source order.
- */
-function packageBindings(file) {
-    const names = new Set();
-    for (const statement of file.statements) {
-        if (!isImportDeclaration(statement) ||
-            !isStringLiteral(statement.moduleSpecifier) ||
-            /^[./]/u.test(statement.moduleSpecifier.text)) {
-            continue;
-        }
-        const clause = statement.importClause;
-        if (clause?.name !== undefined) {
-            names.add(clause.name.text);
-        }
-        const bindings = clause?.namedBindings;
-        if (bindings !== undefined && isNamespaceImport(bindings)) {
-            names.add(bindings.name.text);
-        }
-        else if (bindings !== undefined && isNamedImports(bindings)) {
-            bindings.elements.forEach((element) => names.add(element.name.text));
-        }
-    }
-    if (names.size === 0) {
-        return names;
-    }
-    const visit = (node) => {
-        if (isVariableDeclaration(node) &&
-            isIdentifier(node.name) &&
-            node.initializer !== undefined &&
-            (isCallExpression(node.initializer) || isNewExpression(node.initializer))) {
-            const head = rootName(node.initializer.expression);
-            if (head !== undefined && names.has(head)) {
-                names.add(node.name.text);
-            }
-        }
-        node.forEachChild(visit);
-    };
-    visit(file);
-    return names;
-}
-/** The identifier an expression is headed by, through property accesses and calls. */
-function rootName(expression) {
-    let at = expression;
-    for (;;) {
-        if (isIdentifier(at)) {
-            return at.text;
-        }
-        if (isPropertyAccessExpression(at) || isCallExpression(at) || isNewExpression(at)) {
-            at = at.expression;
-            continue;
-        }
-        if (isParenthesizedExpression(at) || isNonNullExpression(at)) {
-            at = at.expression;
-            continue;
-        }
-        return undefined;
-    }
-}
 /** What makes two carried accesses one: the kind and position of each side, or its written node. */
 function sideKey(one) {
     const key = (side) => side.kind === "written" ? ["written", side.node.pos, side.node.end] : [side.kind, side.index];

package/dist/src/injection-container.js

@@ -5,7 +5,7 @@
  * class's included. A constructor and its parameters are no declarations of the
  * inventory, so the class stands for them and the registration referencing it keeps it.
  */
-import { isClassDeclaration, isClassExpression, isConstructorDeclaration, isGetAccessorDeclaration, isPropertyDeclaration, isSetAccessorDeclaration, } from "@typescript/native/unstable/ast";
+import { isClassDeclaration, isClassExpression, isConstructorDeclaration, isGetAccessorDeclaration, isPropertyDeclaration, isSetAccessorDeclaration, } from "@typescript/native/ast";
 import { aliasChains } from "./alias-chain.js";
 import { calleeName, callsOf, classesPassed, decoratorsOf, spelledDecorator } from "./calls.js";
 import { classMembers } from "./class-members.js";

package/dist/src/interface-satisfaction.js

@@ -6,8 +6,8 @@
  * class, and a position typed by a type parameter reaches its constraint. The contextual
  * lookup has no batch form, so it is asked only of a value typed as a target class.
  */
-import { isCallExpression, isClassDeclaration, isClassExpression, isClassStaticBlockDeclaration, isFunctionDeclaration, isFunctionExpression, isGetAccessorDeclaration, isHeritageClause, isMethodDeclaration, isNewExpression, isObjectLiteralExpression, isSetAccessorDeclaration, ModifierFlags, SyntaxKind, } from "@typescript/native/unstable/ast";
-import { SymbolFlags } from "@typescript/native/unstable/sync";
+import { isCallExpression, isClassDeclaration, isClassExpression, isClassStaticBlockDeclaration, isFunctionDeclaration, isFunctionExpression, isGetAccessorDeclaration, isHeritageClause, isMethodDeclaration, isNewExpression, isObjectLiteralExpression, isSetAccessorDeclaration, ModifierFlags, SyntaxKind, } from "@typescript/native/ast";
+import { SymbolFlags } from "@typescript/native/sync";
 import { aliasChains } from "./alias-chain.js";
 import { emptyImplementation } from "./implementations.js";
 import { nodeKey } from "./inventory.js";

package/dist/src/intra-function-parts.js

@@ -4,7 +4,7 @@
  * call sites that use or discard it, each statement control flow cannot reach, each
  * write to a local that no read reaches, and each case an earlier case covers.
  */
-import { isArrayBindingPattern, isArrowFunction, isAwaitExpression, isBigIntLiteral, isBinaryExpression, isBlock, isBreakStatement, isBindingElement, isCallExpression, isCaseClause, isCatchClause, isClassDeclaration, isClassExpression, isContinueStatement, isDecorator, isDefaultClause, isEmptyStatement, isExportAssignment, isExportSpecifier, isExpressionStatement, isFunctionDeclaration, isFunctionExpression, isHeritageClause, isIdentifier, isIfStatement, isImportClause, isImportSpecifier, isInterfaceDeclaration, isMethodDeclaration, isModuleDeclaration, isNamespaceImport, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectBindingPattern, isObjectLiteralExpression, isParenthesizedExpression, isPrefixUnaryExpression, isPropertyAccessExpression, isQualifiedName, isReturnStatement, isShorthandPropertyAssignment, isStringLiteral, isSwitchStatement, isThrowStatement, isTypeAliasDeclaration, isTypeReferenceNode, isVariableStatement, isVoidExpression, NodeFlags, SyntaxKind, } from "@typescript/native/unstable/ast";
+import { isArrayBindingPattern, isArrowFunction, isAwaitExpression, isBigIntLiteral, isBinaryExpression, isBlock, isBreakStatement, isBindingElement, isCallExpression, isCaseClause, isCatchClause, isClassDeclaration, isClassExpression, isContinueStatement, isDecorator, isDefaultClause, isEmptyStatement, isExportAssignment, isExportSpecifier, isExpressionStatement, isFunctionDeclaration, isFunctionExpression, isHeritageClause, isIdentifier, isIfStatement, isImportClause, isImportSpecifier, isInterfaceDeclaration, isMethodDeclaration, isModuleDeclaration, isNamespaceImport, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectBindingPattern, isObjectLiteralExpression, isParenthesizedExpression, isPrefixUnaryExpression, isPropertyAccessExpression, isQualifiedName, isReturnStatement, isShorthandPropertyAssignment, isStringLiteral, isSwitchStatement, isThrowStatement, isTypeAliasDeclaration, isTypeReferenceNode, isVariableStatement, isVoidExpression, NodeFlags, SyntaxKind, } from "@typescript/native/ast";
 import { nodeKey } from "./inventory.js";
 import { positionKey, renderPosition } from "./position.js";
 import { isAnswered, UNANSWERED } from "./query.js";
@@ -46,16 +46,15 @@ function calleeName(call) {
     }
     return isPropertyAccessExpression(callee) && isIdentifier(callee.name) ? callee.name : undefined;
 }
-/**
- * Whether a call's value is discarded: the call is a statement of its own, awaited as a
- * statement, or the operand of `void`.
- */
-function discarded(call) {
+/** What a call does with its value. */
+function callUse(call) {
     const parent = outerParent(call);
     if (isExpressionStatement(parent) || isVoidExpression(parent)) {
-        return true;
+        return "discarded";
     }
-    return isAwaitExpression(parent) && isExpressionStatement(outerParent(parent));
+    return isAwaitExpression(parent) && isExpressionStatement(outerParent(parent))
+        ? "awaited"
+        : "used";
 }
 /** Whether one statement leaves its statement list on every path: the rest of the list never runs. */
 function abrupt(statement) {
@@ -348,7 +347,7 @@ export function projectParts(project, held, references, targetRoot) {
             if (isCallExpression(node)) {
                 const name = calleeName(node);
                 if (name !== undefined) {
-                    calls.set(position(name), discarded(node));
+                    calls.set(position(name), callUse(node));
                 }
             }
             if (isImportSpecifier(node) || isExportSpecifier(node)) {
@@ -728,7 +727,9 @@ function deadStores(file, root, block, holder, locals, ids) {
  * whether it is used is the call sites' to say, which the run decides over every project.
  */
 function resultParts(project, root, sites, references, calls) {
-    const discardedAt = new Set(references.filter((one) => calls.get(positionKey(one.position)) === true).map((one) => one.to));
+    const discardedAt = new Set(references
+        .filter((one) => (calls.get(positionKey(one.position)) ?? "used") !== "used")
+        .map((one) => one.to));
     const found = [];
     for (const { file, declared } of sites) {
         const { signature, node, id } = declared;
@@ -750,6 +751,8 @@ function resultParts(project, root, sites, references, calls) {
             continue;
         }
         const at = signature.type ?? node.name ?? node;
+        const valued = project.queries.nonNullable(result);
+        const members = isAnswered(valued) ? project.queries.propertiesOf(valued) : UNANSWERED;
         found.push({
             code: UNUSED_RESULT,
             declaration: id,
@@ -758,6 +761,7 @@ function resultParts(project, root, sites, references, calls) {
             position: spanOf(file, root, at),
             message: "result is discarded at every call site",
             used: false,
+            thenable: !isAnswered(members) || members.some((member) => member.name === "then"),
         });
     }
     return found;
@@ -789,6 +793,7 @@ export function intraFunctionFacts(projects, references, exempted) {
     }
     const valued = new Set();
     const called = new Map();
+    const awaited = new Set();
     for (const reference of references) {
         if (reference.use === "decorator" || reference.use === "evaluation") {
             continue;
@@ -796,7 +801,10 @@ export function intraFunctionFacts(projects, references, exempted) {
         const at = positionKey(reference.position);
         const call = reference.consumer === undefined ? calls.get(at) : undefined;
         if (call !== undefined) {
-            called.set(reference.to, (called.get(reference.to) ?? true) && call);
+            called.set(reference.to, (called.get(reference.to) ?? true) && call !== "used");
+            if (call === "awaited") {
+                awaited.add(reference.to);
+            }
         }
         else if (reference.consumer !== undefined || !specifiers.has(at)) {
             valued.add(reference.to);
@@ -810,6 +818,12 @@ export function intraFunctionFacts(projects, references, exempted) {
     const freeButValued = new Set(signatures
         .map((one) => one.declaration)
         .filter((id) => !fixed.has(id) && !exempted.has(id) && valued.has(id)));
-    const discardedEverywhere = new Set([...called].filter(([id, all]) => all && !valued.has(id)).map(([id]) => id));
+    // Awaiting a thenable result sequences on it, so a call that awaits one uses it.
+    const sequenced = new Set([...parts.values()]
+        .filter((part) => part.thenable === true && awaited.has(part.declaration))
+        .map((part) => part.declaration));
+    const discardedEverywhere = new Set([...called]
+        .filter(([id, all]) => all && !valued.has(id) && !sequenced.has(id))
+        .map(([id]) => id));
     return { parts: [...parts.values()], free, freeButValued, discardedEverywhere };
 }