@cplieger/deadset-ts 8.0.0-dev.17 → 8.0.0-dev.19

package/dist/src/analysis.js

@@ -12,6 +12,7 @@ import { consumerReferences } from "./consumers.js";
 import { configuredDeclarations, configuredRef, declarationsNamed, } from "./roots/configured-declarations.js";
 import { decorator } from "./decorator.js";
 import { configurationNeeds, dependenciesOf, projectNeeds } from "./dependencies.js";
+import { carriersOf, NO_CARRIERS } from "./exposure.js";
 import { deprecatedDeclarations } from "./deprecation.js";
 import { moduleIdentity } from "./load/discover.js";
 import { loadRun } from "./load/load.js";
@@ -23,7 +24,7 @@ import { bindingsOf, distinctBindings } from "./bindings.js";
 import { generatedFile, generatedFilesOf } from "./generated-file.js";
 import { inOperandNames } from "./findings/in-operands.js";
 import { sourceFilesOf } from "./source-files.js";
-import { evidenceRecords, heldRecords, disabledClasses, exemptionsOf, holdingWhile, isUnansweredRecord, retainedIn, writtenRecords, } from "./exempt.js";
+import { evidenceRecords, heldRecords, disabledClasses, exemptionsOf, isUnansweredRecord, writtenRecords, } from "./exempt.js";
 import { heldByInclusion, sourcePaths, sourceTree } from "./file-facts.js";
 import { findingsPass, recordedFindings, rowKey } from "./findings-pass.js";
 import { unmatchedRootFindings } from "./findings/self-check.js";
@@ -35,7 +36,7 @@ import { intraFunctionFacts, projectParts } from "./intra-function-parts.js";
 import {} from "./inventory.js";
 import { inventory } from "./inventory/enumerate.js";
 import { readManifest } from "./roots/manifest.js";
-import { liveFilesAt, matrixOf, referenceKey, sweepMatrix, } from "./matrix.js";
+import { matrixOf, referenceKey } from "./liveness/matrix.js";
 import { ancestors, dirnamePath, extensionOf, joinPath, relativePath, resolvePath, } from "./paths.js";
 import { byPosition, isComponentFile } from "./position.js";
 import { skippedUnits } from "./type-errors.js";
@@ -52,6 +53,7 @@ import { accessorsOf, storesOf } from "./stores.js";
 import { isPartKind } from "./suppress.js";
 import { bindRows, readBaseline, readIgnoreFile } from "./suppress-file.js";
 import { inlineDirectives, inlineSuppressions } from "./suppress-inline.js";
+import { sweep } from "./liveness/sweep.js";
 import { readTemplates, templateField } from "./template-field.js";
 import { bytewise } from "./text/compare.js";
 import { holdsManifest, manifestAt } from "./fs/manifest.js";
@@ -454,6 +456,7 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
         ],
         projects,
         consumers: read.plan.discovery.consumers,
+        declaresConsumers: scope.consumers.length > 0,
         notBuilt: read.classified.notBuilt,
         unanswered: read.unanswered,
         componentsUnread: read.plan.workspace?.componentsUnread ?? [],
@@ -467,29 +470,6 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
         workflows: read.result.workflows,
     };
 }
-/**
- * The run swept under one set of marks with the records that hold. A record a component
- * file's markup holds counts only while the file is live, and what it holds may be what
- * keeps the file live, so each file's markup joins only once a sweep without it finds the
- * file live, until a sweep finds no further file live.
- */
-function holdingSweep(read, input) {
-    const paths = new Set(read.exempt.flatMap((record) => record.whileLive ?? []));
-    let live = new Set();
-    for (;;) {
-        const swept = {
-            ...input,
-            exempt: holdingWhile(read.exempt, live),
-            unanswered: read.unansweredHeld,
-        };
-        const result = sweepMatrix(read.matrix, swept);
-        const next = new Set(liveFilesAt(read.matrix, result, paths).map((one) => one.position.path));
-        if (next.size === live.size) {
-            return { swept, result };
-        }
-        live = next;
-    }
-}
 /**
  * The test references exemption evidence written in a test file makes: each is a read of
  * the declaration it would retain, made by the test file at the evidence's site.
@@ -547,55 +527,22 @@ function writtenOnly(read, mode) {
     }
     return new Set([...written].filter((id) => !readSome.has(id)));
 }
-/**
- * The sweep of a run read once, under one set of marks. Where a question went unanswered,
- * the run is swept once more without what that question could have kept live and without
- * the references that stood in for its answer, and every declaration that sweep judges
- * dead and this one judges live, or dead by another rule, is held by the gap too, as is
- * every declaration that makes such a reference.
- */
+/** The sweep of a run read once, under one set of marks. */
 function sweptOf(read, input) {
-    const { swept, result } = holdingSweep(read, input);
-    const exempt = swept.exempt ?? [];
-    const held = new Set(read.unansweredHeld);
-    if (held.size > 0) {
-        // What a declaration reads where the checker did not answer is unknown, so a rule
-        // over what it reads, the test of dead code among them, cannot judge it.
-        for (const { configured } of read.projects) {
-            for (const reference of configured.references) {
-                if (reference.guessed === true) {
-                    held.add(reference.from);
-                }
-            }
-        }
-        const dead = new Map(result.candidates.map((candidate) => [candidate.id, candidate]));
-        const answered = matrixOf(read.projects.map(({ configured }) => ({
-            ...configured,
-            references: configured.references.filter((one) => one.guessed !== true),
-        })));
-        const bare = {
-            ...swept,
-            exempt: exempt.filter((record) => !isUnansweredRecord(record)),
-            unanswered: [],
-        };
-        for (const candidate of sweepMatrix(answered, bare).candidates) {
-            const kept = dead.get(candidate.id);
-            if (kept?.testOfDeadCode !== candidate.testOfDeadCode ||
-                kept.relation !== candidate.relation) {
-                held.add(candidate.id);
-            }
-        }
-    }
+    const componentFiles = [...new Set(read.projects.flatMap((one) => one.componentFiles))].sort(bytewise);
     return {
         matrix: read.matrix,
-        sweep: result,
-        exempt,
-        retained: retainedIn(read.matrix, swept, writtenOnly(read, input.mode)),
+        sweep: sweep(read.matrix, {
+            ...input,
+            exempt: read.exempt,
+            unanswered: read.unansweredHeld,
+            componentFiles,
+            unseenCallers: !read.declaresConsumers,
+            writeOnly: writtenOnly(read, input.mode),
+        }),
         notBuilt: read.notBuilt,
         unanswered: read.unanswered,
-        heldByUnanswered: [...held],
         skipped: read.projects.flatMap((one) => one.skipped),
-        componentFiles: [...new Set(read.projects.flatMap((one) => one.componentFiles))].sort(bytewise),
     };
 }
 /**
@@ -631,6 +578,8 @@ export function readEmitterRun(engine, host, scope, config, mode, detectors) {
         declarationsNamed: declarationsNamed(project, read.held, configuredDeclarations(config)),
         parts: projectParts(project, read.held, references, targetRoot),
         unseenLoads,
+        // Only a closed world reports an unnecessary export, which is all the carriers decide.
+        carriers: config.consumers.complete ? carriersOf(project, read.held) : NO_CARRIERS,
     }));
     // Whether a declaration carries the marker decides its code, so one whose answer went
     // unread is reported by nothing.
@@ -694,7 +643,7 @@ export function emitterInputOver(host, scope, config, read, input, selfCheck) {
             references: one.configured.references,
             support: new Set(one.configured.supportFiles ?? []),
             accessors: one.extra.accessors,
-        })), swept.exempt, input.mode),
+        })), swept.sweep.exempt, input.mode),
         dependencies: dependenciesOf(host, targetRoot, read.workflows, [...projects.map((one) => one.extra.needs), configurationNeeds(read.conventionUses)], swept.sweep.candidates.map((candidate) => candidate.id), members.read, members.unbuilt, read.nestedDirs),
         implementations: mergeImplementations(projects.map((one) => one.extra.implementations)),
         files: {
@@ -703,6 +652,9 @@ export function emitterInputOver(host, scope, config, read, input, selfCheck) {
             generated: new Set(projects.flatMap((one) => [...one.extra.generated.keys()])),
             inOperands: new Set(projects.flatMap((one) => one.extra.inOperands)),
             unseenLoads: projects.flatMap((one) => one.extra.unseenLoads),
+            unwrittenRuns: new Set(projects.flatMap((one) => one.heldScripts
+                .filter((held) => held.unwritten)
+                .map((held) => relativePath(resolvePath(host.workingDirectory(), targetRoot), held.dir) ?? "."))),
         },
         boundary: {
             consumers: {
@@ -713,9 +665,15 @@ export function emitterInputOver(host, scope, config, read, input, selfCheck) {
             edges: readEdgeSides(host, targetRoot),
             filledOutside: new Set(projects.flatMap((one) => one.filledOutside)),
             possiblyLoaded: new Set(projects.flatMap((one) => one.possiblyLoaded)),
+            carriers: {
+                named: new Map([
+                    ...Map.groupBy(projects.flatMap((one) => [...one.extra.carriers.named]), ([id]) => id),
+                ].map(([id, entries]) => [id, [...new Set(entries.flatMap(([, named]) => named))]])),
+                unread: new Set(projects.flatMap((one) => [...one.extra.carriers.unread])),
+            },
         },
         selfCheck,
-        intraFunction: intraFunctionFacts(projects.map((one) => one.extra.parts), projects.flatMap((one) => one.configured.references), new Set([...swept.exempt.map((one) => one.id), ...swept.heldByUnanswered])),
+        intraFunction: intraFunctionFacts(projects.map((one) => one.extra.parts), projects.flatMap((one) => one.configured.references), new Set([...swept.sweep.exempt.map((one) => one.id), ...swept.sweep.held])),
     };
 }
 /**
@@ -828,11 +786,11 @@ export function runAnalysis(engine, host, scope, config, provenance, mode, detec
  * declarations of its own the run holds for them.
  */
 export function unansweredCounts(analysis) {
-    const held = new Set(analysis.swept.heldByUnanswered);
+    const held = new Set(analysis.swept.sweep.held);
     return analysis.run.projects.flatMap((project) => {
         const questions = analysis.run.unanswered.filter((one) => one.configFile === project.configFile).length +
             analysis.run.unread.filter((one) => one.kind === "manifest" && one.configFile === project.configFile).length +
-            analysis.run.heldScripts.filter((one) => one.configFile === project.configFile).length;
+            analysis.run.heldScripts.filter((one) => one.configFile === project.configFile && one.files.length > 0).length;
         if (questions === 0) {
             return [];
         }

package/dist/src/augmentations.js

@@ -8,7 +8,7 @@
  */
 import { isInterfaceDeclaration, isModuleBlock, isModuleDeclaration, } from "@typescript/native/ast";
 import { nodeKey } from "./inventory.js";
-import { referenceKey } from "./matrix.js";
+import { referenceKey } from "./liveness/matrix.js";
 /** Whether one declaration is a `declare global` block: a module-level namespace named `global`. */
 export function isGlobalBlock(symbol, held, files) {
     return (symbol.kind === "namespace" &&

package/dist/src/calls.js

@@ -1,12 +1,12 @@
 /**
  * The calls and decorators of one project that the configured classes read: what each
  * callee resolves to, and which of the target's classes a call passes or a decorator
- * is attached to. A class is passed as an argument, or as an element of an array
- * literal or a property value of an object literal written as one, at any depth, named
- * directly or through variables, and a decorator written as a call is a call.
+ * is attached to. A class is passed by each value an argument can be, at any depth inside
+ * the array and object literals it writes, named directly or through variables, and a
+ * decorator written as a call is a call.
  */
-import { isArrayLiteralExpression, isCallExpression, isClassDeclaration, isDecorator, isIdentifier, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAccessExpression, isPropertyAssignment, isShorthandPropertyAssignment, isSpreadElement, isVariableDeclaration, } from "@typescript/native/ast";
-import { SymbolFlags } from "@typescript/native/sync";
+import { isArrayLiteralExpression, isArrowFunction, isBinaryExpression, isBindingElement, isCallExpression, isClassDeclaration, isConditionalExpression, isDecorator, isFunctionDeclaration, isFunctionExpression, isIdentifier, isMethodDeclaration, isObjectLiteralExpression, isParameterDeclaration, isParenthesizedExpression, isPropertyAccessExpression, isPropertyAssignment, isPropertyDeclaration, isShorthandPropertyAssignment, isOmittedExpression, isSpreadAssignment, isSpreadElement, isVariableDeclaration, SyntaxKind, } from "@typescript/native/ast";
+import { ObjectFlags, SymbolFlags, } from "@typescript/native/sync";
 import { nodeKey } from "./inventory.js";
 import { must } from "./query.js";
 import { unwrapped } from "./unwrap.js";
@@ -66,77 +66,296 @@ export function resolvedTargets(project, nodes) {
     });
     return targets;
 }
-/** The values one expression passes: itself, or what an array or object literal holds. */
-function passedIn(expression, found) {
-    if (isParenthesizedExpression(expression)) {
-        passedIn(expression.expression, found);
-        return;
-    }
-    if (isArrayLiteralExpression(expression)) {
-        for (const element of expression.elements) {
-            passedIn(isSpreadElement(element) ? element.expression : element, found);
-        }
-        return;
+/** The declaration a shorthand property's value resolves to, an import followed to what it names. */
+function shorthandTarget(project, node) {
+    const value = must(project.shorthandValueAt(project.handle(node)));
+    if (value === undefined || (value.flags & SymbolFlags.Alias) === 0) {
+        return value;
     }
-    if (isObjectLiteralExpression(expression)) {
-        for (const property of expression.properties) {
-            if (isPropertyAssignment(property)) {
-                passedIn(property.initializer, found);
+    const aliased = must(project.queries.aliased(value));
+    return aliased.declarations.length === 0 ? undefined : aliased;
+}
+/**
+ * The values one expression passes: each value it can be ({@link leavesOf}), or what an
+ * array or object literal it can be holds, at any depth.
+ */
+function passedIn(written, found) {
+    for (const expression of leavesOf(written)) {
+        if (isArrayLiteralExpression(expression)) {
+            for (const element of expression.elements) {
+                passedIn(element, found);
             }
-            else if (isShorthandPropertyAssignment(property)) {
-                found.push({ site: property.name, name: property, shorthand: true });
+        }
+        else if (isObjectLiteralExpression(expression)) {
+            for (const property of expression.properties) {
+                if (isPropertyAssignment(property)) {
+                    passedIn(property.initializer, found);
+                }
+                else if (isSpreadAssignment(property)) {
+                    passedIn(property.expression, found);
+                }
+                else if (isShorthandPropertyAssignment(property)) {
+                    found.push({ site: property.name, name: property, shorthand: true });
+                }
             }
         }
-        return;
+        else if (!isOmittedExpression(expression)) {
+            found.push({ site: expression, name: calleeName(expression), shorthand: false });
+        }
     }
-    const name = calleeName(expression);
-    if (name !== undefined) {
-        found.push({ site: expression, name, shorthand: false });
+}
+/** The operators whose value is one of their operands. */
+const CHOOSING = new Set([
+    SyntaxKind.QuestionQuestionToken,
+    SyntaxKind.BarBarToken,
+    SyntaxKind.AmpersandAmpersandToken,
+]);
+/**
+ * The expressions one value can be: itself, or each branch of a conditional, each operand
+ * of `??`, `||` and `&&` and the last of a comma, inside any wrapper that changes no value.
+ * Each is read alone because the checker reduces a union by subtype, so the type at the
+ * whole drops a class structurally equal to, or a subtype of, another branch's.
+ */
+function leavesOf(written) {
+    const expression = unwrapped(isSpreadElement(written) ? written.expression : written);
+    if (isConditionalExpression(expression)) {
+        return [...leavesOf(expression.whenTrue), ...leavesOf(expression.whenFalse)];
     }
+    if (isBinaryExpression(expression)) {
+        const operator = expression.operatorToken.kind;
+        if (CHOOSING.has(operator)) {
+            return [...leavesOf(expression.left), ...leavesOf(expression.right)];
+        }
+        if (operator === SyntaxKind.CommaToken) {
+            return leavesOf(expression.right);
+        }
+    }
+    return [expression];
 }
 /** The values one argument passes, a spread argument's included. */
-export function valuesPassed(argument) {
+function leavesPassed(argument) {
     const found = [];
-    passedIn(isSpreadElement(argument) ? argument.expression : argument, found);
+    passedIn(argument, found);
     return found;
 }
+/** The values one argument passes that name their declaration. */
+export function valuesPassed(argument) {
+    return leavesPassed(argument).filter((value) => value.name !== undefined);
+}
 /**
- * The classes of the target each call passes, by the call. A name that is no class is
- * followed through the initializer of each variable it declares, so a class bound to a
- * variable first is passed. A value that names no class of the target, a class of
- * another program included, passes nothing here.
+ * What one passed value holds: the declaration its name resolves to, and the classes and
+ * functions the checker's type at it holds ({@link constructedAt}). `known` holds names
+ * already resolved in a batch.
+ */
+function heldBy(project, value, known) {
+    const { name } = value;
+    if (name === undefined) {
+        return { named: undefined, typed: constructedAt(project, value.site) };
+    }
+    if (value.shorthand) {
+        return { named: shorthandTarget(project, name), typed: [] };
+    }
+    return {
+        named: known?.get(name) ?? resolvedTargets(project, [name]).get(name),
+        typed: constructedAt(project, value.site),
+    };
+}
+/**
+ * The classes of the target each call passes, by the call: each class a value an argument
+ * can be holds as a constructor, as the checker types it. A name whose type erases the
+ * class is followed through what its declaration binds ({@link boundTo}) and, for a
+ * parameter, through what each call of its function passes at its place, so a class handed
+ * to a wrapper is passed. A class is used at each value that passes it. A class of another
+ * program passes nothing.
  */
 export function classesPassed(project, held, chains, calls) {
-    const passed = new Map(calls.map((call) => [call, call.arguments.flatMap((argument) => valuesPassed(argument))]));
-    const all = [...passed.values()].flat();
-    const targets = resolvedTargets(project, all.filter((value) => !value.shorthand).map((value) => value.name));
+    const passed = new Map(calls.map((call) => [call, call.arguments.flatMap(leavesPassed)]));
+    const targets = resolvedTargets(project, [...passed.values()].flat().flatMap((value) => (value.shorthand ? [] : (value.name ?? []))));
     const classes = new Set(held.symbols.filter((symbol) => symbol.kind === "class").map((symbol) => symbol.id));
+    let calling;
+    const callsOfFunction = (symbol) => {
+        calling ??= callsByDeclaration(project);
+        return symbol.declarations.flatMap((handle) => calling?.get(keyOf(handle)) ?? []);
+    };
+    const classesOf = (value, seen) => {
+        const { named, typed } = heldBy(project, value, targets);
+        return [
+            ...typed.flatMap((symbol) => chains.declarationsOf(symbol).filter((id) => classes.has(id))),
+            ...(named === undefined ? [] : reached(named, seen)),
+        ];
+    };
     const reached = (symbol, seen) => {
         const ids = chains.declarationsOf(symbol).filter((id) => classes.has(id));
         if (ids.length > 0 || seen.has(symbol.id)) {
             return ids;
         }
         seen.add(symbol.id);
+        const through = (written) => leavesPassed(written).flatMap((value) => classesOf(value, seen));
         return symbol.declarations.flatMap((handle) => {
             const node = project.declarationAt(handle)?.node;
-            if (node === undefined || !isVariableDeclaration(node) || node.initializer === undefined) {
+            if (node === undefined) {
                 return [];
             }
-            const name = calleeName(unwrapped(node.initializer));
-            const next = name === undefined ? undefined : resolvedTargets(project, [name]).get(name);
-            return next === undefined ? [] : reached(next, seen);
+            if (isParameterDeclaration(node)) {
+                return argumentsAt(project, node, callsOfFunction).flatMap(through);
+            }
+            const bound = boundTo(project, node);
+            return [
+                ...(bound.written === undefined ? [] : through(bound.written)),
+                ...bound.symbols.flatMap((next) => reached(next, seen)),
+            ];
+        });
+    };
+    return new Map([...passed].map(([call, values]) => {
+        const uses = new Map();
+        for (const value of values) {
+            for (const id of classesOf(value, new Set())) {
+                uses.set(`${id}\u0000${String(value.site.pos)}`, { id, site: value.site });
+            }
+        }
+        return [call, [...uses.values()]];
+    }));
+}
+/**
+ * The symbols of the classes and functions the checker's type at one expression holds as
+ * values, each member of a union: the static side of a class or a function is an
+ * anonymous type its declaration's symbol names, which an instance's type is not.
+ */
+function constructedAt(project, written) {
+    return heldIn(project, must(project.queries.typeAt(unwrapped(written))));
+}
+/** The classes and functions one type holds as values, as {@link constructedAt} reads them. */
+function heldIn(project, type) {
+    const { queries } = project;
+    return (type === undefined ? [] : must(queries.constituents(type))).flatMap((part) => {
+        if (!part.isObjectType() || (part.objectFlags & ObjectFlags.Anonymous) === 0) {
+            return [];
+        }
+        return must(queries.symbolOfType(part)) ?? [];
+    });
+}
+/**
+ * What a variable, a property or a destructured binding binds its name to: a variable's
+ * or a property's initializer, the value a shorthand property names, or the property of
+ * the destructured value a binding element reads.
+ */
+function boundTo(project, node) {
+    if (isShorthandPropertyAssignment(node)) {
+        const value = shorthandTarget(project, node);
+        return { symbols: value === undefined ? [] : [value] };
+    }
+    if (isBindingElement(node)) {
+        const key = node.propertyName ?? node.name;
+        if (key === undefined || !isIdentifier(key)) {
+            return { symbols: [] };
+        }
+        const source = must(project.queries.typeAt(node.parent));
+        const property = source === undefined
+            ? undefined
+            : must(project.queries.propertiesOf(source)).find((one) => one.name === key.text);
+        return { symbols: property === undefined ? [] : [property] };
+    }
+    const written = initializerOf(node);
+    return written === undefined ? { symbols: [] } : { written, symbols: [] };
+}
+/** The value a variable or a property declaration binds its name to, where it writes one. */
+function initializerOf(node) {
+    return isVariableDeclaration(node) || isPropertyAssignment(node) || isPropertyDeclaration(node)
+        ? node.initializer
+        : undefined;
+}
+/** The key of one declaration a symbol names, the same for each symbol the checker makes of it. */
+function keyOf(handle) {
+    return `${handle.path}#${String(handle.index)}`;
+}
+/**
+ * Every call of the project by the declarations its callee can be: the function or the
+ * method it names, or else each function the checker's type at it holds, wherever that
+ * value came from. A name is also followed through what its binding copies
+ * ({@link boundTo}), which is how a call reaches a function an annotation erases.
+ * Only the target's own declarations are keys, as only its own functions are asked for.
+ */
+function callsByDeclaration(project) {
+    const calls = callsOf(project);
+    const own = project.ownPaths();
+    const callees = resolvedTargets(project, calls.flatMap((call) => calleeName(call.expression) ?? []));
+    const named = new Map();
+    const keysOf = (symbol, seen) => {
+        const known = named.get(symbol.id);
+        if (known !== undefined || seen.has(symbol.id)) {
+            return known ?? [];
+        }
+        seen.add(symbol.id);
+        const keys = symbol.declarations
+            .filter((handle) => own.has(handle.path))
+            .flatMap((handle) => {
+            const node = project.declarationAt(handle)?.node;
+            const bound = node === undefined ? { symbols: [] } : boundTo(project, node);
+            const copied = [
+                ...bound.symbols,
+                ...(bound.written === undefined ? [] : leavesPassed(bound.written)).flatMap((value) => {
+                    const { named: next, typed } = heldBy(project, value);
+                    return [...typed, ...(next === undefined ? [] : [next])];
+                }),
+            ];
+            return [keyOf(handle), ...copied.flatMap((next) => keysOf(next, seen))];
         });
+        named.set(symbol.id, keys);
+        return keys;
     };
-    const classesOf = (value) => {
-        const symbol = value.shorthand
-            ? must(project.shorthandValueAt(project.handle(value.name)))
-            : targets.get(value.name);
-        return symbol === undefined ? [] : reached(symbol, new Set());
+    const calleeOf = (call) => {
+        const name = calleeName(call.expression);
+        return name === undefined ? undefined : callees.get(name);
     };
-    return new Map([...passed].map(([call, values]) => [
-        call,
-        values.flatMap((value) => classesOf(value).map((id) => ({ id, site: value.site }))),
-    ]));
+    const declared = (call) => ((calleeOf(call)?.flags ?? 0) & (SymbolFlags.Function | SymbolFlags.Method)) !== 0;
+    const typed = calls.filter((call) => !declared(call));
+    const types = new Map(project.queries
+        .typesAt(typed.map((call) => unwrapped(call.expression)))
+        .map((type, index) => [typed[index], must(type)]));
+    const found = new Map();
+    for (const call of calls) {
+        const callee = calleeOf(call);
+        const held = [
+            ...(callee === undefined ? [] : [callee]),
+            ...(types.has(call) ? heldIn(project, types.get(call)) : []),
+        ];
+        for (const key of new Set(held.flatMap((symbol) => keysOf(symbol, new Set())))) {
+            found.set(key, [...(found.get(key) ?? []), call]);
+        }
+    }
+    return found;
+}
+/**
+ * What each call of the function a parameter belongs to passes at the parameter's place,
+ * every argument from there on for a rest parameter. The function is the one the checker's
+ * type at its own declaration names, so a function with no name of its own is called too.
+ * A `this` parameter takes no place, and an argument at or after a spread argument passes
+ * at every place the spread's length can move it to.
+ */
+function argumentsAt(project, parameter, callsOfFunction) {
+    const owner = parameter.parent;
+    if (!isFunctionDeclaration(owner) &&
+        !isMethodDeclaration(owner) &&
+        !isArrowFunction(owner) &&
+        !isFunctionExpression(owner)) {
+        return [];
+    }
+    const calls = new Set(constructedAt(project, owner).flatMap(callsOfFunction));
+    const [first] = owner.parameters;
+    const erased = first !== undefined && isIdentifier(first.name) && first.name.text === "this";
+    const place = owner.parameters.indexOf(parameter) - (erased ? 1 : 0);
+    const rest = parameter.dotDotDotToken !== undefined;
+    return [...calls].flatMap((call) => {
+        let spreads = 0;
+        return call.arguments.flatMap((argument, index) => {
+            const spread = isSpreadElement(argument);
+            const earliest = index - spreads;
+            spreads += spread ? 1 : 0;
+            const open = spread || earliest < index;
+            const lands = open ? rest || earliest <= place : rest ? index >= place : index === place;
+            return lands ? [spread ? argument.expression : argument] : [];
+        });
+    });
 }
 /** Every class declaration of the target that carries a decorator. */
 export function decoratedClasses(project, held) {