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

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: {
@@ -713,9 +662,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,7 +783,7 @@ 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 +

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) {

package/dist/src/conformance-record.js

@@ -4,7 +4,7 @@ export const RECORD = {
     conformance: {
         corpusVersion: "6.0.0",
         result: "pass",
-        digest: "sha256:a4ffbc1c2d9dc7903ccbf52af0e1a22094e0b50363f59365f6aa37b9437d3427",
+        digest: "sha256:140f095d52fa8140de070f46d13a132b723c634ecf24a8b96e6a92c410c4b848",
     },
     gaps: [],
 };

package/dist/src/contract/contract.generated.js

@@ -372,7 +372,7 @@ export const KIND_ROWS = [
         subject: "declaration",
         holdsLive: true,
         rule: "An exported symbol whose every reference is inside the symbol's own package or module, reported as a candidate for unexporting. The subject is a package-level declaration or a method. Three subjects are excluded. An interface method is excluded because its exportedness is the contract of the interface that declares it. A struct field is excluded because an encoder reads it by name. A method that satisfies an interface some symbol uses as a type is excluded because it cannot be unexported without its type ceasing to satisfy that interface, and so is a method whose name and signature are those of a method of an exported interface type declared by a package outside the target that the import closure holds, because that interface fixes them whether or not the program converts the method's type to it. The finding names the narrower visibility the references support. A declared cross-language edge counts as an out-of-package reference. Where the edge's other side is unknown to the analyzer, the finding is emitted pending. A reference from a Go external test package, a test file whose package clause names its directory's package with the suffix _test, is a reference from outside the package, because that test builds as another package and needs the export.",
-        precondition: "Closed world only. A Go main package, and an internal/ directory tree for importers outside its parent, are closed worlds whatever the configuration declares, because no other program can import them, so this finding is reported there always. A published package is a closed world only when the configuration declares the consumer set complete and every declared consumer loads. A library with no consumer loaded and no complete consumer set declared gets this finding on its internal/ tree and its main packages and never on its published API. A symbol the rule of DS1301 holds for is not reported under this code, whatever severity the configuration gives DS1301, because the write-only finding names the defect to fix first. A type that a parameter or a result of an exported function or method of its own package names is not reported when a reference from outside the package references that function or method, because the caller holds values of the type, and unexporting it would leave an exported signature naming a type its callers cannot name. A package-level declaration whose name a string literal spells carries the class grammar/analysis/confidence.md gives it.",
+        precondition: "Closed world only. A Go main package, and an internal/ directory tree for importers outside its parent, are closed worlds whatever the configuration declares, because no other program can import them, so this finding is reported there always. A published package is a closed world only when the configuration declares the consumer set complete and every declared consumer loads. A library with no consumer loaded and no complete consumer set declared gets this finding on its internal/ tree and its main packages and never on its published API. A symbol the rule of DS1301 holds for is not reported under this code, whatever severity the configuration gives DS1301, because the write-only finding names the defect to fix first. A type is not reported when a reference from outside the package reaches its values through its own package's exported declarations: a reference to an exported function or method whose parameters or results name the type, to an exported variable or constant whose type names it, to an exported field or property whose type names it, an embedded field included, or to an exported member of the type itself, a field promoted through an embedding included. A type a reference from outside the package names, or whose values such a reference reaches, passes the reach on to each type its definition names other than through an unexported member, whether it is exported or not, so an unexported type an exported function returns passes it to the types its exported fields name. A type names another through every composite that spells it: a pointer, an array, a slice, a map key or value, a channel, a function signature and a type argument. The referencing code holds values of the type, so unexporting it would leave an exported declaration naming a type its users cannot name. A package-level declaration whose name a string literal spells carries the class grammar/analysis/confidence.md gives it.",
         details: { narrower_visibility: "required", name_literal: "optional" },
         defaultEnabled: true,
         defaultSeverity: "warn",
@@ -387,7 +387,7 @@ export const KIND_ROWS = [
         subject: "declaration",
         holdsLive: true,
         rule: "An exported symbol of a non-internal package whose every reference is inside the target module, reported as a candidate for relocation behind an internal boundary. The subject is a package-level declaration or a method. Three subjects are excluded. An interface method is excluded because its exportedness is the contract of the interface that declares it. A struct field is excluded because an encoder reads it by name. A method that satisfies an interface some symbol uses as a type is excluded because it cannot be unexported without its type ceasing to satisfy that interface, and so is a method whose name and signature are those of a method of an exported interface type declared by a package outside the target that the import closure holds, because that interface fixes them whether or not the program converts the method's type to it. The finding names the narrower visibility the references support. A declared cross-language edge counts as an out-of-package reference. Where the edge's other side is unknown to the analyzer, the finding is emitted pending. A reference from a Go external test package, a test file whose package clause names its directory's package with the suffix _test, is a reference from outside the package, because that test builds as another package and needs the export.",
-        precondition: "Closed world only. Reported always for a main package and an internal/ directory tree, and for a published package only when the configuration declares the consumer set complete and every declared consumer loads. A library with no consumer loaded and no complete consumer set declared gets this finding on its internal/ tree and its main packages and never on its published API. A symbol the rule of DS1301 holds for is not reported under this code, whatever severity the configuration gives DS1301, because the write-only finding names the defect to fix first. A type that a parameter or a result of an exported function or method of its own package names is not reported when a reference from outside the target module references that function or method, because the caller holds values of the type, and moving it behind an internal boundary would leave an exported signature naming a type its callers cannot name.",
+        precondition: "Closed world only. Reported always for a main package and an internal/ directory tree, and for a published package only when the configuration declares the consumer set complete and every declared consumer loads. A library with no consumer loaded and no complete consumer set declared gets this finding on its internal/ tree and its main packages and never on its published API. A symbol the rule of DS1301 holds for is not reported under this code, whatever severity the configuration gives DS1301, because the write-only finding names the defect to fix first. A type is not reported when a reference from outside the target module reaches its values through its own package's exported declarations, as DS1501 defines that reach, because the referencing code holds values of the type, and moving it behind an internal boundary would leave an exported declaration naming a type its users cannot name.",
         details: { narrower_visibility: "required", name_literal: "optional" },
         defaultEnabled: true,
         defaultSeverity: "warn",

package/dist/src/exempt.js

@@ -10,7 +10,6 @@ import { EXEMPTION_CLASSES } from "./contract/contract.generated.js";
 import { TS_EXEMPTION_CLASSES, typescriptVisibilityOf, } from "./exempt-classes.js";
 import { byPosition, positionKey } from "./position.js";
 import { Unanswerable } from "./query.js";
-import { sweep } from "./sweep.js";
 import { bytewise } from "./text/compare.js";
 /**
  * The classes `exemptions.disabled` switches off. A class that runs on another language
@@ -130,13 +129,6 @@ export function exemptionsOf(found) {
         return true;
     });
 }
-/**
- * The records that hold while the component files at `live` are live: every record that
- * holds whatever is live, and each one a live file's markup holds, as a record of the run.
- */
-export function holdingWhile(records, live) {
-    return exemptionsOf(records.flatMap(({ whileLive, ...record }) => whileLive === undefined || live.has(whileLive) ? [record] : []));
-}
 /** The records per declaration, each declaration's in the order given. */
 function byDeclaration(records) {
     const grouped = new Map();
@@ -151,24 +143,6 @@ function byDeclaration(records) {
     }
     return grouped;
 }
-/**
- * The records that held back a declaration: one some configuration's graph, swept
- * again with no exemption and its marks, judges a candidate, whatever another
- * configuration answers, or one in `writeOnly`, which the run would report as written
- * and never read without the record's read. A declaration a relation or a mark holds
- * live in every configuration is held back by no record. The order is the
- * declarations' site order, and for one declaration the input's.
- */
-export function retainedIn(matrix, input, writeOnly = new Set()) {
-    const exempt = input.exempt ?? [];
-    if (exempt.length === 0) {
-        return [];
-    }
-    const bare = { marked: input.marked, mode: input.mode };
-    const dead = new Set(matrix.graphs.flatMap((graph) => sweep(graph, bare).candidates.map((candidate) => candidate.id)));
-    const held = byDeclaration(exempt.filter((record) => dead.has(record.id) || writeOnly.has(record.id)));
-    return matrix.union.symbols.flatMap((symbol) => held.get(symbol.id) ?? []);
-}
 /**
  * One line per held-back declaration, in site order: its reference and position, then
  * each record's class, site and detail, all separated by tabs.