@cplieger/deadset-ts 7.2.0-dev.4 → 8.0.0-dev.1

package/dist/src/entry-points.js

@@ -10,11 +10,12 @@
  * value that is not a literal is not evaluated and not guessed, so a file it would
  * have named is entered by nothing here.
  */
-import { isArrayLiteralExpression, isAsExpression, isCallExpression, isExportAssignment, isIdentifier, isMetaProperty, isNewExpression, isNoSubstitutionTemplateLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAccessExpression, isPropertyAssignment, isSatisfiesExpression, isStringLiteral, } from "@typescript/native/ast";
+import { isArrayLiteralExpression, isAsExpression, isBinaryExpression, isCallExpression, isExportAssignment, isIdentifier, isMetaProperty, isNewExpression, isNoSubstitutionTemplateLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAccessExpression, isPropertyAssignment, isSatisfiesExpression, isStringLiteral, isTemplateExpression, SyntaxKind, } from "@typescript/native/ast";
 import { SymbolFlags } from "@typescript/native/sync";
 import { configurationFiles, filesNamedBy, moduleStrings, } from "./configuration-files.js";
 import { globExpression } from "./glob.js";
 import { htmlEntries } from "./html-entries.js";
+import { documentEntries } from "./mdx-entries.js";
 import { dirnamePath, relativePath, resolvePath } from "./paths.js";
 import { UNANSWERED } from "./query.js";
 import { workflowEntries } from "./workflow-steps.js";
@@ -37,8 +38,11 @@ const BROWSER_TEST_MATCH = "**/*.{spec,test}.{js,ts,jsx,tsx,cjs,cts,cjsx,ctsx,mj
 const SETUP_MEMBERS = ["setupFiles", "globalSetup"];
 /** A member that moves the directory every path of a test-runner configuration is read from. */
 const ROOT_MEMBER = "root";
-/** The prefixes a literal is relative with, in a module specifier and a URL reference alike. */
-const RELATIVE_PREFIXES = ["./", "../"];
+/**
+ * A URL reference's scheme. A reference with none that does not start with a solidus is
+ * relative, the bare name included: https://url.spec.whatwg.org/#relative-url-string
+ */
+const URL_SCHEME = /^[a-z][a-z\d+.-]*:/iu;
 /** The constructors whose first argument addresses a worker script. */
 const WORKER_CONSTRUCTORS = new Set(["Worker", "SharedWorker"]);
 /** The file's name, the last segment of its path. */
@@ -138,9 +142,16 @@ function literalsOf(value) {
     }
     return found;
 }
-/** Whether a literal is relative in the sense a module specifier and a URL reference share. */
+/**
+ * Whether a literal is a relative URL reference, which is also how the test runner reads a
+ * setup file's path against its root.
+ */
 function isRelative(text) {
-    return RELATIVE_PREFIXES.some((prefix) => text.startsWith(prefix));
+    return text !== "" && !text.startsWith("/") && !URL_SCHEME.test(text);
+}
+/** Whether a module specifier is relative, which a bare name is not: it names a package. */
+function isModuleRelative(text) {
+    return text.startsWith("./") || text.startsWith("../");
 }
 /** A URL reference with its query and its fragment removed, which name no part of the file. */
 function pathPart(text) {
@@ -348,10 +359,10 @@ function workerSitesOf(file) {
     return found;
 }
 /**
- * The workers one file addresses. A call's names must resolve to the platform's own
- * declarations, which no file of the target declares and no import brings in; a
- * name the target binds itself is the target's own constructor or object, which
- * addresses no worker this rule knows. One batch per file that writes such a call.
+ * The workers one file addresses. A call's names must resolve to a symbol the platform
+ * declares, which a file of the target may augment and no import brings in; a name only
+ * the target declares is the target's own constructor or object, which addresses no
+ * worker this rule knows. One batch per file that writes such a call.
  */
 function workersOf(project, file, files) {
     const sites = workerSitesOf(file);
@@ -371,8 +382,7 @@ function workersOf(project, file, files) {
         }
         if (symbol !== undefined &&
             (symbol.flags & SymbolFlags.Alias) === 0 &&
-            symbol.declarations.length > 0 &&
-            symbol.declarations.every((handle) => !files.byName.has(handle.path))) {
+            symbol.declarations.some((handle) => !files.byName.has(handle.path))) {
             platform.add(name);
         }
     });
@@ -388,6 +398,87 @@ function workersOf(project, file, files) {
     }
     return found;
 }
+/** The literal text a computed path starts with: a template's head, or a concatenation's first literal. */
+function leadingLiteral(node) {
+    const at = unwrapped(node);
+    if (isTemplateExpression(at)) {
+        return at.head.text;
+    }
+    if (isBinaryExpression(at) && at.operatorToken.kind === SyntaxKind.PlusToken) {
+        return literalOf(unwrapped(at.left)) ?? leadingLiteral(at.left);
+    }
+    return undefined;
+}
+/** Whether one call is `import.meta.glob(...)`. */
+function isMetaGlob(node) {
+    if (!isCallExpression(node) || !isPropertyAccessExpression(node.expression)) {
+        return false;
+    }
+    const { expression, name } = node.expression;
+    return (isIdentifier(name) &&
+        name.text === "glob" &&
+        isMetaProperty(expression) &&
+        expression.keywordToken === SyntaxKind.ImportKeyword);
+}
+/**
+ * The files one file loads by a computed path, each with what exports: every own file
+ * below the directory a relative literal start of an `import()` or `require()` argument
+ * names, other than the calling file's own directory or one holding it, which would name
+ * every sibling, and
+ * every own file a relative literal glob of `import.meta.glob` matches, both read against
+ * the calling file's directory, as a bundler's context module reads them.
+ */
+function computedImportsOf(file, files) {
+    const dir = dirnamePath(file.fileName);
+    const found = [];
+    const below = (prefix) => {
+        const target = resolvePath(dir, prefix);
+        if (!isModuleRelative(prefix) ||
+            !prefix.endsWith("/") ||
+            target === dir ||
+            relativePath(target, dir) !== undefined) {
+            return;
+        }
+        for (const candidate of files.byName.values()) {
+            if (candidate !== file && relativePath(target, candidate.fileName) !== undefined) {
+                found.push({ file: candidate, rule: "computed-import", source: prefix, exports: true });
+            }
+        }
+    };
+    const globbed = (pattern) => {
+        if (!isModuleRelative(pattern)) {
+            return;
+        }
+        const expression = globExpression(resolvePath(dir, pattern));
+        for (const candidate of files.byName.values()) {
+            if (candidate !== file && expression.test(candidate.fileName)) {
+                found.push({ file: candidate, rule: "computed-import", source: pattern, exports: true });
+            }
+        }
+    };
+    const visit = (node) => {
+        if (isCallExpression(node)) {
+            const [first] = node.arguments;
+            const callee = node.expression;
+            const loads = callee.kind === SyntaxKind.ImportKeyword ||
+                (isIdentifier(callee) && callee.text === "require");
+            if (loads && first !== undefined) {
+                const prefix = leadingLiteral(first);
+                if (prefix !== undefined) {
+                    below(prefix);
+                }
+            }
+            else if (isMetaGlob(node) && first !== undefined) {
+                for (const pattern of literalsOf(first) ?? []) {
+                    globbed(pattern);
+                }
+            }
+        }
+        node.forEachChild(visit);
+    };
+    file.forEachChild(visit);
+    return found;
+}
 /**
  * Every file of one project the rules enter, in no particular order and possibly more
  * than once: a file two rules enter appears once per rule.
@@ -417,10 +508,20 @@ export function entryPoints(project, files, testFiles, host, targetRoot, parse,
             }
         }
         found.push(...workersOf(project, file, files));
+        found.push(...computedImportsOf(file, files));
     }
     for (const { file, source } of htmlEntries(host, targetRoot, files, parse)) {
         found.push({ file, rule: "html-entry", source, exports: true });
     }
+    for (const { file, source, names } of documentEntries(host, targetRoot, files)) {
+        found.push({
+            file,
+            rule: "document-import",
+            source,
+            exports: true,
+            ...(names === undefined ? {} : { names }),
+        });
+    }
     for (const { file, source } of workflowEntries(host, targetRoot, files)) {
         found.push({ file, rule: "workflow-step", source, exports: true });
     }

package/dist/src/findings/completion.js

@@ -4,12 +4,27 @@
  * together with every finding that falls with a root they withhold.
  */
 import { componentId } from "../components.js";
+import { deadComponents } from "../matrix.js";
 import { OUTSIDE } from "../graph.js";
 import { KINDS } from "../kinds.js";
 import { byPosition, positionKey } from "../position.js";
 import { declarationKey } from "../ref.js";
 import { FAMILY_KEY_LENGTH } from "../resolve.js";
 import { isPartSubject, isRowSubject } from "../suppress.js";
+/** The unused-file code, whose deletion removes every use its file writes. */
+const FILE_NEVER_IMPORTED = "DS1502";
+/**
+ * The codes whose subject the run that counts test references holds live, as
+ * finding.schema.json lists them, so a test file's candidate reported under one carries
+ * none of a dead declaration's sweep facts.
+ */
+const LIVE_SUBJECT = new Set([
+    "DS1101",
+    "DS1102",
+    "DS1104",
+    "DS1204",
+    "DS1301",
+]);
 /** The fixability grammar/analysis.md "Fixability" gives a finding about a held declaration. */
 const MANUAL = "manual";
 /** The member kinds an object property can declare, which an `in` expression tests by name. */
@@ -72,15 +87,11 @@ function testedByIn(input) {
  * published API, a public member of a published type included, is `certain` where the
  * run loaded every consumer the scope declared and declared one, `probable` where one did
  * not load, and `possible` where it declared none, whatever the configuration says of the
- * consumer set. Test-support code test code references, outside the test-of-dead-code
- * rule, what it contains, and a member an `in` expression tests by name are `possible`.
+ * consumer set. A member an `in` expression tests by name is `possible`.
  */
 function reachabilityClasses(input) {
     const tested = testedByIn(input);
     const published = publishedIds(input.swept.matrix.union);
-    const usedByTests = new Set(input.swept.sweep.candidates
-        .filter((candidate) => candidate.heldByTests !== undefined)
-        .map((candidate) => candidate.id));
     const { declared } = input.boundary.consumers;
     const outside = declared.length === 0
         ? "possible"
@@ -88,7 +99,7 @@ function reachabilityClasses(input) {
             ? "certain"
             : "probable";
     return (id) => {
-        if (usedByTests.has(id) || tested.has(id)) {
+        if (tested.has(id)) {
             return "possible";
         }
         return published.has(id) ? outside : "certain";
@@ -110,20 +121,33 @@ function testCeilings(input, classOf) {
         for (const edge of union.out[union.at(id)] ?? []) {
             const target = union.symbols[edge.to];
             const testCode = union.test[edge.to] === true || union.support[edge.to] === true;
-            if (target !== undefined && !testCode && union.subject[edge.to] === true) {
+            if (target !== undefined &&
+                !testCode &&
+                union.ambient[edge.to] !== true &&
+                union.subject[edge.to] === true) {
                 lowest = capped(lowest, classOf(target.id));
             }
         }
         return lowest;
     };
 }
+/**
+ * The ceiling the roots the run found put on one dead subject: a subject other declarations
+ * reference, found dead only because no root reaches them, is `probable` unless
+ * the configuration declares the roots complete, because a root the analysis cannot see
+ * would make it live; every other declaration has none below `certain`.
+ */
+function rootsCeiling(input, finding, candidate) {
+    const unreachable = candidate?.relation === "reachability" || finding.unreachableOnly === true;
+    return unreachable && !input.config.ts.rootsComplete ? "probable" : "certain";
+}
 /**
  * The component each dead declaration of the run falls in, and none for a live one, with
  * its members listed in the canonical order where the run lists a component in full.
  */
-function findingComponents(swept, cascade) {
+function findingComponents(swept, components, cascade) {
     const held = new Map();
-    for (const component of swept.sweep.components) {
+    for (const component of components) {
         for (const member of component.members) {
             held.set(member, component);
         }
@@ -159,6 +183,59 @@ function findingComponents(swept, cascade) {
             };
     };
 }
+/**
+ * The run's dead components with each file a `DS1502` finding reports dead among them, so
+ * the file's declarations fall with it, and with the components each subject that is no
+ * declaration falls with joined into one.
+ */
+function runComponents(swept, findings) {
+    const union = swept.matrix.union;
+    const reported = new Set(findings.filter((one) => one.code === FILE_NEVER_IMPORTED).map((one) => one.position.path));
+    const files = new Map(union.symbols.flatMap((symbol, at) => symbol.kind === "file" && reported.has(symbol.position.path) ? [[at, symbol]] : []));
+    const computed = files.size === 0
+        ? swept.sweep.components
+        : deadComponents(swept.matrix, swept.sweep, new Set(files.keys()));
+    const place = new Map();
+    computed.forEach((component, at) => {
+        for (const member of component.members) {
+            place.set(member, at);
+        }
+    });
+    const leader = computed.map((_component, at) => at);
+    const find = (at) => {
+        let top = at;
+        while ((leader[top] ?? top) !== top) {
+            top = leader[top] ?? top;
+        }
+        return top;
+    };
+    for (const { fallsWith } of findings) {
+        const joined = (fallsWith ?? []).flatMap((id) => place.get(id) ?? []).map(find);
+        const first = Math.min(...joined);
+        for (const one of joined) {
+            leader[one] = first;
+        }
+    }
+    const merged = new Map();
+    computed.forEach((component, at) => {
+        const top = find(at);
+        const into = merged.get(top);
+        merged.set(top, into === undefined
+            ? component
+            : {
+                id: into.id,
+                members: [...into.members, ...component.members],
+                roots: [...into.roots, ...component.roots],
+                deletableLines: into.deletableLines + component.deletableLines,
+                held: into.held && component.held,
+            });
+    });
+    return {
+        components: [...merged.values()],
+        computed: computed.length,
+        files: new Map([...files.values()].map((symbol) => [symbol.position.path, symbol.id])),
+    };
+}
 /**
  * Every finding of the run completed, in the order given. A dead declaration carries its
  * candidate's relation, counts, configurations and component; a live one carries no relation and
@@ -174,10 +251,12 @@ export function completed(input, findings, kinds = KINDS) {
     const candidates = new Map(swept.sweep.candidates.map((candidate) => [candidate.id, candidate]));
     const classOf = reachabilityClasses(input);
     const ceilingOf = testCeilings(input, classOf);
-    const componentOf = findingComponents(swept, input.config.reporters.cascade);
-    const held = new Set(swept.sweep.components.filter((one) => one.held).flatMap((one) => one.members));
-    let minted = swept.sweep.components.length;
-    const dead = new Set(swept.sweep.components.map((component) => component.id));
+    const { components, computed, files } = runComponents(swept, findings);
+    const componentOf = findingComponents(swept, components, input.config.reporters.cascade);
+    const held = new Set(components.filter((one) => one.held).flatMap((one) => one.members));
+    // A join keeps its first component's identifier, so a minted one counts past every computed one.
+    let minted = computed;
+    const dead = new Set(components.map((component) => component.id));
     const fallingWith = new Map();
     for (const { heldByTests } of swept.sweep.candidates) {
         if (heldByTests !== undefined) {
@@ -193,18 +272,30 @@ export function completed(input, findings, kinds = KINDS) {
         // a row is still never the declaration. Two declarations of one file can share a
         // reference, so the one the finding is positioned at is the subject where there is one.
         const declared = union.at(positionKey(finding.position));
+        const ref = finding.symbol.holder ?? finding.symbol.ref;
         const at = isRowSubject(finding.symbol.kind)
             ? OUTSIDE
-            : union.symbols[declared]?.ref === finding.symbol.ref
+            : union.symbols[declared]?.ref === ref
                 ? declared
-                : (positions.get(declarationKey(finding.symbol.ref, finding.position.path)) ?? OUTSIDE);
+                : (positions.get(declarationKey(ref, finding.position.path)) ?? OUTSIDE);
         // A part names the declaration that holds it, and is decided inside it rather than by
         // the declaration's liveness, so it carries none of the declaration's sweep facts.
         const part = isPartSubject(finding.symbol.kind);
         const symbol = union.symbols[at];
         const judged = !part && union.subject[at] === true ? symbol : undefined;
-        const candidate = judged === undefined ? undefined : candidates.get(judged.id);
-        const found = symbol === undefined || part ? undefined : componentOf(symbol.id);
+        const candidate = judged === undefined || LIVE_SUBJECT.has(finding.code)
+            ? undefined
+            : candidates.get(judged.id);
+        const fallsWith = finding.fallsWith?.[0];
+        const joined = fallsWith === undefined ? undefined : componentOf(fallsWith);
+        const file = finding.code === FILE_NEVER_IMPORTED ? files.get(finding.position.path) : undefined;
+        const found = joined !== undefined
+            ? { ...joined, root: false }
+            : file !== undefined
+                ? componentOf(file)
+                : symbol === undefined || part
+                    ? undefined
+                    : componentOf(symbol.id);
         // A test file's declaration is a component member only as a test of dead code, and
         // test code keeps the test-support code it references out of every component.
         if (candidate !== undefined &&
@@ -236,9 +327,13 @@ export function completed(input, findings, kinds = KINDS) {
                 row.findingFixabilities?.includes(MANUAL) === true
                 ? MANUAL
                 : row.fixability;
-        const lastUses = fixability === "deletable" && candidate !== undefined
-            ? input.dependencies.lastUses.get(candidate.id)
-            : undefined;
+        const lastUses = fixability !== "deletable"
+            ? undefined
+            : candidate !== undefined
+                ? input.dependencies.lastUses.get(candidate.id)
+                : finding.code === FILE_NEVER_IMPORTED
+                    ? input.dependencies.fileLastUses.get(finding.position.path)
+                    : undefined;
         return {
             code: finding.code,
             kind: row.name,
@@ -246,7 +341,7 @@ export function completed(input, findings, kinds = KINDS) {
             position: finding.position,
             symbol: finding.symbol,
             reachabilityClass,
-            confidence: capped(capped(reachabilityClass, row.maxClass), judged === undefined ? "certain" : ceilingOf(judged.id)),
+            confidence: capped(capped(capped(reachabilityClass, row.maxClass), rootsCeiling(input, finding, candidate)), judged === undefined ? "certain" : ceilingOf(judged.id)),
             ...(candidate === undefined ? {} : { livenessRelation: candidate.relation }),
             testOnly: judged !== undefined && counts?.production === 0 && counts.test > 0,
             generated,

package/dist/src/findings/dependencies-and-module-machinery.js

@@ -1,38 +1,84 @@
 import { declarationKey } from "../dependencies.js";
 import { renderRef } from "../ref.js";
+import { nonCodeArtifacts } from "./non-code-artifacts.js";
 const UNUSED_DEPENDENCY = "DS1601";
+const FILE_NEVER_IMPORTED = "DS1502";
 const MESSAGES = {
     dependency: "no import in the target needs the declared dependency",
     "dev-dependency": "no import in the target needs the declared development dependency",
     "peer-dependency": "no import in the target needs the declared peer dependency",
 };
+const DEAD_USERS_MESSAGES = {
+    dependency: "only code that is itself dead uses the declared dependency",
+    "dev-dependency": "only code that is itself dead uses the declared development dependency",
+    "peer-dependency": "only code that is itself dead uses the declared peer dependency",
+};
+/**
+ * The run's dead code: test code keeps the code it references out of every dead component
+ * unless that code is dead as well, and a file's top level is dead where the file is.
+ */
+function deadCode(input) {
+    const { swept } = input;
+    const union = swept.matrix.union;
+    const files = new Map(union.symbols.filter((one) => one.kind === "file").map((one) => [one.position.path, one.id]));
+    const dead = new Set(swept.sweep.components.flatMap((component) => component.members));
+    const reachedOnly = new Set(swept.sweep.candidates.filter((one) => one.relation === "reachability").map((one) => one.id));
+    for (const finding of nonCodeArtifacts(input)) {
+        const id = files.get(finding.position.path);
+        if (finding.code === FILE_NEVER_IMPORTED && id !== undefined) {
+            dead.add(id);
+            if (finding.unreachableOnly === true) {
+                reachedOnly.add(id);
+            }
+        }
+    }
+    const published = new Set(union.rooted
+        .filter((root) => root.kind === "published-api")
+        .flatMap((root) => union.symbols[root.at]?.id ?? []));
+    return { dead, reachedOnly, published };
+}
 /**
  * A dependency, development dependency or peer dependency of a manifest the run reads
- * that the target does not need, at the position of its key.
+ * that the target does not need, at the position of its key, and one whose every use is
+ * held by dead code, which is dead only through that code and falls with its component:
+ * at `possible` where one of its holders is published, and found under reachability alone
+ * where one of them is.
  */
-function unusedDependencies(dependencies) {
-    return dependencies.declared
-        .filter((dependency) => !dependencies.needed.has(declarationKey(dependency)) &&
-        !dependencies.ran.has(declarationKey(dependency)))
-        .map((dependency) => ({
-        code: UNUSED_DEPENDENCY,
-        position: dependency.position,
-        symbol: {
-            ref: renderRef(dependency.manifest, {
-                of: "dependency",
-                name: dependency.name,
-                section: dependency.section,
-            }),
-            kind: "dependency",
-            name: dependency.name,
-            sizeLines: 1,
-        },
-        message: MESSAGES[dependency.section],
-        details: { dependencyClass: dependency.section },
-        ...(dependencies.unbuilt.has(dependency.position.path)
-            ? { reachabilityClass: "possible" }
-            : {}),
-    }));
+function unusedDependencies(input, dependencies) {
+    const { dead, reachedOnly, published } = deadCode(input);
+    return dependencies.declared.flatMap((dependency) => {
+        const key = declarationKey(dependency);
+        const held = dependencies.heldBy.get(key);
+        const users = held?.every((id) => dead.has(id)) === true ? held : undefined;
+        if (dependencies.ran.has(key) || (dependencies.needed.has(key) && users === undefined)) {
+            return [];
+        }
+        const unbuilt = dependencies.unbuilt.has(dependency.position.path);
+        const atPossible = unbuilt || users?.some((id) => published.has(id)) === true;
+        return [
+            {
+                code: UNUSED_DEPENDENCY,
+                position: dependency.position,
+                symbol: {
+                    ref: renderRef(dependency.manifest, {
+                        of: "dependency",
+                        name: dependency.name,
+                        section: dependency.section,
+                    }),
+                    kind: "dependency",
+                    name: dependency.name,
+                    sizeLines: 1,
+                },
+                message: (users === undefined ? MESSAGES : DEAD_USERS_MESSAGES)[dependency.section],
+                details: { dependencyClass: dependency.section },
+                ...(atPossible ? { reachabilityClass: "possible" } : {}),
+                ...(users?.some((id) => reachedOnly.has(id)) === true
+                    ? { unreachableOnly: true }
+                    : {}),
+                ...(users === undefined ? {} : { fallsWith: users }),
+            },
+        ];
+    });
 }
 /** The findings of the dependencies-and-module-machinery family, `DS1600` to `DS1699`. */
-export const dependenciesAndModuleMachinery = ({ dependencies }) => unusedDependencies(dependencies);
+export const dependenciesAndModuleMachinery = (input) => unusedDependencies(input, input.dependencies);

package/dist/src/findings/emitters.js

@@ -100,7 +100,7 @@ function dialledOver(input, suppressed, found, unmarked) {
     const unanswered = heldKeys(input);
     const markup = markupKeys(input);
     const candidates = found.filter((finding) => {
-        const key = declarationKey(finding.symbol.ref, finding.position.path);
+        const key = declarationKey(finding.symbol.holder ?? finding.symbol.ref, finding.position.path);
         return (!ledger.withheld(finding) &&
             !unanswered.has(key) &&
             !markup.has(key) &&

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

@@ -1,4 +1,5 @@
 import { KINDS } from "../kinds.js";
+import { parameterRef } from "../ref.js";
 import { UNUSED_PARAMETER, UNUSED_RESULT } from "../intra-function-parts.js";
 import { reachedWithTheTests } from "../sweep.js";
 /** A list of rules as a sentence names them. */
@@ -8,24 +9,43 @@ function spelled(rules) {
     }
     return `${rules.slice(0, -1).join(", ")} and ${rules.at(-1) ?? ""}`;
 }
-/** The clause a message ends with: the other rules that report the kind, or that none is known. */
-function overlapClause(overlap) {
-    return overlap.length === 1 && overlap[0] === "none known"
+/** The compiler's rule of the parameter kind's overlap list, which reports only in a file it checks. */
+const COMPILER_PARAMETER_RULE = "tsc --noUnusedParameters";
+/**
+ * The clause a message ends with: the other rules that report the part, or that none is
+ * known. A parameter of a file the compiler does not check is no report of the compiler's.
+ */
+function overlapClause(overlap, part) {
+    const rules = part.parameter?.checked === false
+        ? overlap.filter((rule) => rule !== COMPILER_PARAMETER_RULE)
+        : overlap;
+    return rules.length === 1 && rules[0] === "none known"
         ? "no other rule is known to report it"
-        : `also reported by ${spelled(overlap)}`;
+        : `also reported by ${spelled(rules)}`;
 }
 /**
- * Whether one parameter's name is reported: every unread one of a function whose
- * signature is free, and of a function used as a value only one no read parameter follows,
- * because a caller may pass such a function more arguments than it declares.
+ * Whether one unread parameter is reported, and how. Of a free signature it is deleted. A
+ * caller may pass a function used as a value more arguments than it declares, so there one
+ * a read parameter follows is renamed to an underscore name, which the compilers read as
+ * declared unread, and one no read parameter follows is deleted: kept where the call's
+ * inference may read its annotation, at `probable` where nothing reads the annotation.
  */
-function parameterReported(part, free, freeButValued) {
+function parameterVerdict(part, free, freeButValued) {
     const place = part.parameter;
     if (place?.inValue !== true && free.has(part.declaration)) {
-        return true;
+        return place?.annotated === undefined ? { fix: "delete", confidence: "certain" } : undefined;
     }
     const valued = place?.inValue === true || freeButValued.has(part.declaration);
-    return valued && place?.beforeARead !== true;
+    if (!valued) {
+        return undefined;
+    }
+    if (place?.beforeARead === true) {
+        return { fix: "rename" };
+    }
+    if (place?.annotated === "steers") {
+        return undefined;
+    }
+    return { fix: "delete", confidence: place?.annotated === "free" ? "probable" : "certain" };
 }
 /**
  * Whether one part is reported. A parameter needs its function's signature free to
@@ -41,7 +61,7 @@ function reported(input, part, callersUnknown) {
     const { free, freeButValued, discardedEverywhere } = input.intraFunction;
     switch (part.code) {
         case UNUSED_PARAMETER:
-            return parameterReported(part, free, freeButValued);
+            return parameterVerdict(part, free, freeButValued) !== undefined;
         case UNUSED_RESULT:
             return (free.has(part.declaration) &&
                 discardedEverywhere.has(part.declaration) &&
@@ -96,20 +116,31 @@ export const intraFunction = (input) => {
         if (declaration === undefined || !judged(declaration.id) || !reported(input, part, unknown)) {
             continue;
         }
+        const verdict = part.code === UNUSED_PARAMETER
+            ? parameterVerdict(part, input.intraFunction.free, input.intraFunction.freeButValued)
+            : undefined;
+        const message = verdict?.fix === "rename"
+            ? `${part.message}, and a read parameter follows it, so rename it to _${part.name}`
+            : part.message;
         found.push({
             code: part.code,
             position: part.position,
             symbol: {
-                ref: declaration.ref,
+                ...(part.code === UNUSED_PARAMETER
+                    ? { ref: parameterRef(declaration.ref, part.name), holder: declaration.ref }
+                    : { ref: declaration.ref }),
                 kind: part.kind,
                 name: part.name,
                 sizeLines: part.position.endLine - part.position.line + 1,
             },
-            message: `${part.message}; ${overlapClause(overlap)}`,
+            message: `${message}; ${overlapClause(overlap, part)}`,
             details: {
                 ...(part.kind === "store" ? { writePositions: [part.position] } : {}),
                 overlap,
             },
+            ...(verdict?.fix === "delete" && verdict.confidence !== "certain"
+                ? { reachabilityClass: verdict.confidence }
+                : {}),
         });
     }
     return found;