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

package/dist/src/sweep.js

@@ -70,16 +70,30 @@ export function sweep(graph, input) {
     });
     return { liveUnder: live, candidates };
 }
+/**
+ * The directory a test runner reads a manual mock from, whose exports it puts in place of
+ * the module's: https://jestjs.io/docs/manual-mocks
+ */
+const MANUAL_MOCKS = "__mocks__";
+/** Whether a test runner calls or reads one export of a test file: a function, or any export of a manual mock. */
+export function runnerCalls(symbol) {
+    return symbol.kind === "function" || symbol.position.path.split("/").includes(MANUAL_MOCKS);
+}
 /**
  * Per declaration of the graph, whether the run that counts test references reaches it.
- * That run's roots are the graph's own and each test file, being the file's top level
- * and every declaration it exports, which a test runner may call; `held` seeds it as a
- * mark or an exemption seeds a sweep.
+ * That run's roots are the graph's own and, of each test file, its top level and every
+ * function it exports, which a test runner may call, and every export of a manual mock,
+ * which the runner reads; any other export of a test file, and test-support code, which
+ * runs where a test imports it, are judged as any file's are.
+ * `held` seeds it as a mark or an exemption seeds a sweep.
  */
 export function reachedWithTheTests(graph, held) {
     const tests = graph.symbols.flatMap((symbol, at) => {
-        const top = symbol.kind === "file" || graph.symbols[graph.parent[at] ?? OUTSIDE]?.kind === "file";
-        return graph.test[at] === true && top && (symbol.kind === "file" || symbol.exported)
+        const exported = symbol.exported && graph.symbols[graph.parent[at] ?? OUTSIDE]?.kind === "file";
+        const called = exported && runnerCalls(symbol);
+        return graph.test[at] === true &&
+            graph.support[at] !== true &&
+            (symbol.kind === "file" || called)
             ? [{ at, kind: "test-runner" }]
             : [];
     });
@@ -162,10 +176,11 @@ function reachable(graph, held, mode) {
 }
 /**
  * Admits every test declaration whose set of referenced production declarations is
- * non-empty and wholly dead, and returns which it admitted. The set is read from every
- * reference the test makes, which a production sweep does not count. A test-support
- * declaration that a test referencing a live target also references is a live target of
- * every test referencing it. A marked or exempt test is never admitted.
+ * non-empty and wholly dead, and returns which it admitted. An ambient declaration describes
+ * code the target does not implement, so it is no production declaration here. The set is
+ * read from every reference the test makes, which a production sweep does not count. A
+ * test-support declaration a test referencing a live target also references is a live
+ * target of every test referencing it. A marked or exempt test is never admitted.
  */
 function admitTestsOfDeadCode(graph, dead, held) {
     const testCode = (at) => graph.test[at] === true || graph.support[at] === true;
@@ -174,7 +189,9 @@ function admitTestsOfDeadCode(graph, dead, held) {
         let live = 0;
         if (testCode(at) && graph.subject[at] === true && held[at] !== true) {
             for (const edge of graph.out[at] ?? []) {
-                if (testCode(edge.to) || graph.subject[edge.to] !== true) {
+                if (testCode(edge.to) ||
+                    graph.subject[edge.to] !== true ||
+                    graph.ambient[edge.to] === true) {
                     continue;
                 }
                 targets += 1;

package/dist/src/symbol-keys.js

@@ -2,9 +2,12 @@
  * The members a unique symbol keys, used through element accesses. `value[key]`, where
  * `key` is a constant of a `unique symbol` type, reads the member of the receiver's type
  * whose computed name is that same constant, and a store through the access writes it.
- * No name node resolves to such a member: the key's name resolves to the constant.
+ * No name node resolves to such a member: the key's name resolves to the constant. An
+ * iteration reads the member its well-known iteration symbol keys.
  */
-import { isComputedPropertyName, isIdentifier, isNoSubstitutionTemplateLiteral, isNumericLiteral, isParenthesizedExpression, isPropertyAccessExpression, isStringLiteral, } from "@typescript/native/ast";
+import { isComputedPropertyName, isForOfStatement, isIdentifier, isNoSubstitutionTemplateLiteral, isNumericLiteral, isParenthesizedExpression, isPropertyAccessExpression, isSpreadElement, isStringLiteral, } from "@typescript/native/ast";
+import { nodeKey } from "./inventory.js";
+import { renderPosition } from "./position.js";
 import { isAnswered } from "./query.js";
 /** The identifier an element access's argument names its key by, where it is a name. */
 export function keyNameOf(argument) {
@@ -112,3 +115,101 @@ export function keyedUses(project, chains, resolved, properties, cap) {
         return ids.length === 0 ? [] : [{ access: one.access, ids: [...new Set(ids)] }];
     });
 }
+/** The member name `[Symbol.<name>]` spells, where a computed name spells one. */
+function wellKnownName(name) {
+    if (name === undefined || !isComputedPropertyName(name)) {
+        return undefined;
+    }
+    const key = name.expression;
+    return isPropertyAccessExpression(key) &&
+        isIdentifier(key.expression) &&
+        key.expression.text === "Symbol" &&
+        isIdentifier(key.name)
+        ? key.name.text
+        : undefined;
+}
+/**
+ * The references the iterations of one project's own files make to the iteration members
+ * of the values they iterate: a `for…of` statement and a spread element read
+ * `[Symbol.iterator]`, and a `for await…of` statement reads `[Symbol.asyncIterator]` and,
+ * which it falls back to, `[Symbol.iterator]`. Each is made by the declaration holding it.
+ */
+export function iterationReferences(project, held, chains, root, testFiles) {
+    const queries = project.queries;
+    const ownPaths = project.ownPaths();
+    const iterated = [];
+    for (const file of project.ownSourceFiles()) {
+        const fileId = held.declarations.get(nodeKey(file, file));
+        if (fileId === undefined) {
+            continue;
+        }
+        const visit = (node, from) => {
+            const holder = held.declarations.get(nodeKey(file, node)) ?? from;
+            if (isForOfStatement(node)) {
+                const protocols = node.awaitModifier === undefined ? ["iterator"] : ["asyncIterator", "iterator"];
+                iterated.push({ file, from: holder, operand: node.expression, protocols });
+            }
+            else if (isSpreadElement(node)) {
+                iterated.push({ file, from: holder, operand: node.expression, protocols: ["iterator"] });
+            }
+            node.forEachChild((child) => {
+                visit(child, holder);
+            });
+        };
+        file.forEachChild((child) => {
+            visit(child, fileId);
+        });
+    }
+    if (iterated.length === 0) {
+        return [];
+    }
+    const types = queries.typesAt(iterated.map((one) => one.operand));
+    const members = new Map();
+    const membersOf = (type) => {
+        const known = members.get(type.id);
+        if (known !== undefined) {
+            return known;
+        }
+        const keyed = [];
+        const properties = queries.propertiesOf(type);
+        for (const property of isAnswered(properties) ? properties : []) {
+            for (const handle of property.declarations) {
+                const node = ownPaths.has(handle.path) ? project.declarationAt(handle)?.node : undefined;
+                const name = wellKnownName(node?.name);
+                if (name !== undefined) {
+                    keyed.push({ name, ids: chains.declarationsOf(property) });
+                    break;
+                }
+            }
+        }
+        members.set(type.id, keyed);
+        return keyed;
+    };
+    const found = [];
+    iterated.forEach((one, index) => {
+        const type = types[index];
+        if (type === undefined || !isAnswered(type)) {
+            return;
+        }
+        const parts = type.isUnionType() || type.isIntersectionType() ? queries.constituents(type) : [type];
+        const position = renderPosition(one.file, root, one.operand.getStart());
+        for (const part of isAnswered(parts) ? parts : []) {
+            for (const member of membersOf(part)) {
+                if (!one.protocols.includes(member.name)) {
+                    continue;
+                }
+                for (const to of member.ids) {
+                    found.push({
+                        from: one.from,
+                        to,
+                        position,
+                        use: "read",
+                        resolution: "keyed",
+                        test: testFiles.has(position.path),
+                    });
+                }
+            }
+        }
+    });
+    return found;
+}

package/dist/src/test-support.js

@@ -1,19 +1,116 @@
 /**
- * Test-support code: the files only tests reach. A test reaches each one through a chain
- * of references, and every reference to a declaration of one, an import for its effects
- * included, is written in a test file or in another such file, so it is judged with the
- * tests: what it references is referenced by test code.
+ * Test-support code: the files only tests reach that carry test evidence of their own. A
+ * test reaches each one through a chain of references, and every reference to a
+ * declaration of one, an import for its effects included, is written in a test file or in
+ * another such file, so it is judged with the tests: what it references is referenced by
+ * test code.
  */
+import { CONVENTION_ROWS } from "./convention-rows.js";
+import { packageOfSpecifier } from "./dependencies.js";
 /** The root kind that never takes a file out of test-support code: the skip only withholds. */
 const SKIP_ROOT = "type-error";
+/**
+ * The test runners and test libraries an import of which is test evidence: each runner a
+ * convention row reads test files for, the platform's own runner, and the libraries below.
+ */
+const TEST_PACKAGES = new Set([
+    ...CONVENTION_ROWS.filter((row) => row.testFiles !== undefined).map((row) => row.package),
+    "node:test",
+    "@playwright/test",
+]);
+/** The scopes every package of which is a test library. */
+const TEST_SCOPES = ["@testing-library/"];
+/**
+ * The Node.js built-in modules a bare specifier names, which are no package. The set is
+ * closed: Node.js adds a new built-in under the `node:` scheme alone
+ * (https://nodejs.org/api/modules.html#built-in-modules-with-mandatory-node-prefix).
+ */
+const NODE_BUILTINS = new Set([
+    "assert",
+    "async_hooks",
+    "buffer",
+    "child_process",
+    "cluster",
+    "console",
+    "constants",
+    "crypto",
+    "dgram",
+    "diagnostics_channel",
+    "dns",
+    "domain",
+    "events",
+    "fs",
+    "http",
+    "http2",
+    "https",
+    "inspector",
+    "module",
+    "net",
+    "os",
+    "path",
+    "perf_hooks",
+    "process",
+    "punycode",
+    "querystring",
+    "readline",
+    "repl",
+    "stream",
+    "string_decoder",
+    "sys",
+    "timers",
+    "tls",
+    "trace_events",
+    "tty",
+    "url",
+    "util",
+    "v8",
+    "vm",
+    "wasi",
+    "worker_threads",
+    "zlib",
+]);
+/** Whether a specifier names a test runner or a test library. */
+function namesTestPackage(specifier) {
+    const name = specifier.startsWith("node:") ? specifier : packageOfSpecifier(specifier);
+    return (name !== undefined &&
+        (TEST_PACKAGES.has(name) || TEST_SCOPES.some((scope) => name.startsWith(scope))));
+}
+/**
+ * Whether a file carries test evidence: an import of a test runner or a test library, or
+ * package imports, Node built-ins aside, that are all devDependencies no file imports
+ * outside the test files and `onlyTests`, the files only tests reach.
+ */
+function evidenceReader(tests, evidence) {
+    const importers = new Map();
+    for (const [path, specifiers] of evidence.imports) {
+        for (const specifier of specifiers) {
+            const name = packageOfSpecifier(specifier);
+            if (name !== undefined) {
+                importers.set(name, [...(importers.get(name) ?? []), path]);
+            }
+        }
+    }
+    return (onlyTests, path) => {
+        const specifiers = evidence.imports.get(path) ?? [];
+        if (specifiers.some(namesTestPackage)) {
+            return true;
+        }
+        const names = specifiers.flatMap((one) => packageOfSpecifier(one) ?? []);
+        const packages = names.filter((name) => !NODE_BUILTINS.has(name));
+        return (packages.length > 0 &&
+            packages.every((name) => evidence.devDependency(path, name) &&
+                (importers.get(name) ?? []).every((one) => tests.has(one) || onlyTests.has(one))));
+    };
+}
 /**
  * The files of one project that are test-support code, below the target root: the
  * largest set of files a test file reaches, none of them a test file or holding a root,
- * whose every user outside the set is a test file. A root has a caller outside the
- * reference graph: a runtime, a tool, a configuration, or a consumer of a library's
- * published API. `testFiles` are the files the test-file rules classified.
+ * each carrying test evidence of its own, whose every user outside the set is a test
+ * file. A root has a caller outside the reference graph: a runtime, a tool, a
+ * configuration, or a consumer of a library's published API. `testFiles` are the files
+ * the test-file rules classified.
  */
-export function testSupportFiles(symbols, references, roots, testFiles) {
+export function testSupportFiles(symbols, references, roots, testFiles, evidence) {
     const fileOf = new Map(symbols.map((symbol) => [symbol.id, symbol.position.path]));
     const users = new Map();
     const uses = new Map();
@@ -47,17 +144,24 @@ export function testSupportFiles(symbols, references, roots, testFiles) {
             }
         }
     }
-    const support = new Set([...reached].filter((path) => !rooted.has(path)));
-    for (let changed = true; changed;) {
-        changed = false;
-        for (const path of support) {
-            const from = users.get(path) ?? new Set();
-            if (![...from].every((one) => tests.has(one) || support.has(one))) {
-                support.delete(path);
-                changed = true;
+    const withoutOutsideUsers = (files) => {
+        for (let changed = true; changed;) {
+            changed = false;
+            for (const path of files) {
+                const from = users.get(path) ?? new Set();
+                if (![...from].every((one) => tests.has(one) || files.has(one))) {
+                    files.delete(path);
+                    changed = true;
+                }
             }
         }
-    }
+        return files;
+    };
+    // Evidence reads the files only tests reach, evidence or none, so it is fixed before the
+    // files without evidence leave the set.
+    const onlyTests = withoutOutsideUsers(new Set([...reached].filter((path) => !rooted.has(path))));
+    const carries = evidenceReader(tests, evidence);
+    const support = withoutOutsideUsers(new Set([...onlyTests].filter((path) => carries(onlyTests, path))));
     return support;
 }
 /** The references with every one a test-support file makes counted as a test reference. */

package/dist/src/type-errors.js

@@ -5,11 +5,12 @@
  * which only ever withholds a finding. `projectErrors` decides, before any of these, which
  * errors the compiler places in no file leave the project unloaded.
  */
-import { isClassDeclaration, isNoSubstitutionTemplateLiteral, isPropertyAccessExpression, isStringLiteral, } from "@typescript/native/ast";
+import { isClassDeclaration, isFunctionLikeDeclaration, isNoSubstitutionTemplateLiteral, isPropertyAccessExpression, isStringLiteral, } from "@typescript/native/ast";
 import { packageOfSpecifier } from "./dependencies.js";
 import { nodeKey } from "./inventory.js";
 import { dirnamePath, isAbsolutePath, joinPath, relativePath, resolvePath } from "./paths.js";
 import { isAnswered } from "./query.js";
+import { findWorkspace } from "./workspace.js";
 /** The compiler's codes for an import whose module it cannot find. */
 const MODULE_NOT_FOUND = new Set([2307, 2792]);
 const MANIFEST = "package.json";
@@ -163,20 +164,36 @@ function expectedModule(context, importer, specifier) {
     const manifest = name === undefined
         ? undefined
         : declaringManifest(host, dirnamePath(importer), targetRoot, name);
-    if (manifest === undefined) {
+    // No run requires a nested package that is no workspace member to be installed.
+    if (manifest === undefined ||
+        (dirnamePath(manifest) !== targetRoot && !context.member(manifest))) {
         return undefined;
     }
     const where = relativePath(targetRoot, manifest) ?? manifest;
     return `a dependency ${where} declares that is not installed: run the package manager's install`;
 }
 /**
- * The unit a type error at one offset skips: the class member holding it where a
- * top-level class does, else the top-level statement.
+ * The unit a type error at one offset skips: the innermost function holding it, else the
+ * class member holding it where a top-level class does, else the top-level statement.
  */
 function unitAt(file, offset) {
     const statement = file.statements.find((one) => one.pos <= offset && offset < one.end);
-    if (statement === undefined || !isClassDeclaration(statement)) {
-        return statement;
+    if (statement === undefined) {
+        return undefined;
+    }
+    let innermost;
+    const visit = (node) => {
+        if (offset < node.getStart() || offset >= node.end) {
+            return;
+        }
+        if (isFunctionLikeDeclaration(node)) {
+            innermost = node;
+        }
+        node.forEachChild(visit);
+    };
+    visit(statement);
+    if (innermost !== undefined || !isClassDeclaration(statement)) {
+        return innermost ?? statement;
     }
     return statement.members.find((one) => one.pos <= offset && offset < one.end) ?? statement;
 }
@@ -190,7 +207,17 @@ function messageOf(text, targetRoot) {
  * is no error here, and one in a file that is not the project's own is that file's
  * package's to answer for.
  */
-export function readErrors(project, errors, context) {
+export function readErrors(project, errors, where) {
+    let workspace = null;
+    const context = {
+        ...where,
+        member: (manifest) => {
+            if (workspace === null) {
+                workspace = findWorkspace(where.host, where.targetRoot, () => undefined);
+            }
+            return workspace?.memberOf(manifest) !== undefined;
+        },
+    };
     const files = new Map(project.ownSourceFiles().map((file) => [file.fileName, file]));
     const missing = [];
     const skips = [];

package/dist/src/type-parameter-reads.js

@@ -0,0 +1,172 @@
+/**
+ * The members a read through a value typed by a type parameter reaches: `value.kind`,
+ * where `value` is of a type parameter `T` of a generic function, reads `kind` on each
+ * object type no class declares that a call of the function passes for `T`, because the
+ * call's value is what the read reads, whatever member of the constraint the name resolves
+ * to. A class's members a constraint requires are interface satisfaction's.
+ */
+import { isBinaryExpression, isCallExpression, isIdentifier, isNewExpression, isPropertyAccessExpression, isTypeParameterDeclaration, SyntaxKind, } from "@typescript/native/ast";
+import { SymbolFlags } from "@typescript/native/sync";
+import { nodeKey } from "./inventory.js";
+import { renderPosition } from "./position.js";
+import { isAnswered } from "./query.js";
+/** How deep a parameter's type is matched against the type a call passes: `readonly T[]` is one level. */
+const MATCH_DEPTH = 3;
+/** The name a call reaches one generic by: its own, or that of what holds it. */
+function nameOf(generic) {
+    const own = generic.name;
+    const holder = generic.parent?.name;
+    const name = own ?? holder;
+    return name !== undefined && isIdentifier(name) ? name.text : undefined;
+}
+/** Whether a property access is the target of a plain assignment, which writes the member. */
+function assignedTo(access) {
+    const parent = access.parent;
+    return (isBinaryExpression(parent) &&
+        parent.operatorToken.kind === SyntaxKind.EqualsToken &&
+        parent.left === access);
+}
+/**
+ * The references the reads through type-parameter-typed values of one project's own files
+ * make to the members of the types its calls pass, each made by the declaration holding
+ * the read.
+ */
+export function typeParameterReads(project, held, chains, root, testFiles) {
+    const queries = project.queries;
+    const reads = [];
+    const calls = [];
+    for (const file of project.ownSourceFiles()) {
+        const fileId = held.declarations.get(nodeKey(file, file));
+        if (fileId === undefined) {
+            continue;
+        }
+        const visit = (node, from, generic) => {
+            const holder = held.declarations.get(nodeKey(file, node)) ?? from;
+            const inside = generic ||
+                node.typeParameters !== undefined;
+            if (inside &&
+                isPropertyAccessExpression(node) &&
+                isIdentifier(node.name) &&
+                !assignedTo(node)) {
+                reads.push({ file, from: holder, access: node });
+            }
+            if (isCallExpression(node) || isNewExpression(node)) {
+                calls.push(node);
+            }
+            node.forEachChild((child) => {
+                visit(child, holder, inside);
+            });
+        };
+        file.forEachChild((child) => {
+            visit(child, fileId, false);
+        });
+    }
+    if (reads.length === 0) {
+        return [];
+    }
+    // The reads whose receiver the checker types as a type parameter, by the generic declaring it.
+    const receivers = queries.typesAt(reads.map((read) => read.access.expression));
+    const byGeneric = new Map();
+    reads.forEach((read, at) => {
+        const type = receivers[at];
+        if (type === undefined || !isAnswered(type) || !type.isTypeParameter()) {
+            return;
+        }
+        const symbol = queries.symbolOfType(type);
+        const declaration = symbol === undefined || !isAnswered(symbol)
+            ? undefined
+            : symbol.declarations
+                .map((handle) => project.declarationAt(handle)?.node)
+                .find((node) => node !== undefined && isTypeParameterDeclaration(node));
+        const generic = declaration?.parent;
+        if (generic !== undefined) {
+            byGeneric.set(generic, [...(byGeneric.get(generic) ?? []), { read, parameter: type }]);
+        }
+    });
+    if (byGeneric.size === 0) {
+        return [];
+    }
+    /** The types `instantiated` holds where `declared` holds `parameter`, matched part for part. */
+    const passedFor = (parameter, declared, instantiated, depth) => {
+        if (declared.id === parameter.id) {
+            return [instantiated];
+        }
+        if (depth >= MATCH_DEPTH) {
+            return [];
+        }
+        const a = queries.typeArguments(declared);
+        const b = queries.typeArguments(instantiated);
+        if (!isAnswered(a) || !isAnswered(b) || a.length !== b.length) {
+            return [];
+        }
+        return a.flatMap((one, at) => {
+            const other = b[at];
+            return other === undefined ? [] : passedFor(parameter, one, other, depth + 1);
+        });
+    };
+    // Only a call spelling a generic's name is resolved: one request each.
+    const spelled = new Set([...byGeneric.keys()].flatMap((generic) => nameOf(generic) ?? []));
+    const found = new Map();
+    for (const call of calls) {
+        const callee = call.expression;
+        const written = isIdentifier(callee)
+            ? callee.text
+            : isPropertyAccessExpression(callee) && isIdentifier(callee.name)
+                ? callee.name.text
+                : undefined;
+        if (written === undefined || !spelled.has(written)) {
+            continue;
+        }
+        const resolved = queries.resolvedSignature(call);
+        if (resolved === undefined || !isAnswered(resolved) || resolved.declaration === undefined) {
+            continue;
+        }
+        const generic = project.declarationAt(resolved.declaration)?.node;
+        const pending = generic === undefined ? undefined : byGeneric.get(generic);
+        const declared = pending === undefined ? undefined : queries.genericOf(resolved);
+        if (pending === undefined || declared === undefined || !isAnswered(declared)) {
+            continue;
+        }
+        const count = (generic?.parameters ?? []).length;
+        for (const { read, parameter } of pending) {
+            const passed = [];
+            for (let at = 0; at < count; at += 1) {
+                const own = queries.parameterType(declared, at);
+                const given = queries.typeAtPosition(resolved, at);
+                if (own !== undefined && isAnswered(own) && isAnswered(given)) {
+                    passed.push(...passedFor(parameter, own, given, 0));
+                }
+            }
+            const name = read.access.name.text;
+            const position = renderPosition(read.file, root, read.access.name.getStart());
+            for (const type of passed) {
+                const parts = type.isUnionType() ? queries.constituents(type) : [type];
+                for (const part of isAnswered(parts) ? parts : []) {
+                    const owner = queries.symbolOfType(part);
+                    if (!isAnswered(owner) ||
+                        owner === undefined ||
+                        (owner.flags & SymbolFlags.Class) !== 0) {
+                        continue;
+                    }
+                    const properties = queries.propertiesOf(part);
+                    for (const property of isAnswered(properties) ? properties : []) {
+                        if (property.name !== name) {
+                            continue;
+                        }
+                        for (const to of chains.declarationsOf(property)) {
+                            found.set(`${read.from}\u0000${to}\u0000${String(read.access.name.pos)}`, {
+                                from: read.from,
+                                to,
+                                position,
+                                use: "read",
+                                resolution: "batch",
+                                test: testFiles.has(position.path),
+                            });
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return [...found.values()];
+}

package/dist/src/verbs/analyze.js

@@ -62,6 +62,21 @@ function runRelative(invoked, path) {
     }
     return below;
 }
+/**
+ * One note per manifest entry the run reads back to no source file: what the entry names
+ * reaches nothing, so the findings its file would have rooted are reported.
+ */
+function unmappedNotes(entries, targetRoot) {
+    return entries.map((entry) => {
+        const named = relativePath(targetRoot, entry.path) ?? entry.path;
+        return {
+            kind: "unmapped-entry",
+            path: relativePath(targetRoot, entry.dir) ?? ".",
+            key: "ts.entry_files",
+            message: `the manifest's ${entry.member} names ${named}, which reads back to no source file of the target: name the file it is built from in ts.entry_files`,
+        };
+    });
+}
 /** Each project the run dropped as a report names it, by its configuration file below the target. */
 function notBuiltOf(dropped, targetRoot) {
     return dropped.map((one) => {
@@ -207,6 +222,7 @@ export const analyzeVerb = ({ err, host, inputs, scope, openClient, option, repe
             typeErrorSkips: run.typeErrorSkips,
             unanswered: unansweredCounts(analysis),
             conventionsApplied: run.conventionsApplied,
+            notes: unmappedNotes(run.unmappedEntries, resolvePath(invoked, targetRoot)),
         });
         report = capFindings(sortFindings(built, config.reporters.sort), config.reporters.maxFindings);
         verdict = verdictOf(result, config);

package/dist/src/verbs/explain.js

@@ -257,11 +257,13 @@ function reported(found) {
 /**
  * Every finding of the run that names the declaration by its reference and reports at
  * another position: a part of it, or a suppression record naming it. Each is published under
- * the reference asked about, so an explanation leaving it out would disagree with the report.
+ * the reference asked about, or a parameter's under one it starts, so an explanation leaving
+ * it out would disagree with the report.
  */
 function namedElsewhere(findings, subject) {
     return findings
-        .filter((found) => found.symbol.ref === subject.ref && positionKey(found.position) !== subject.id)
+        .filter((found) => (found.symbol.holder ?? found.symbol.ref) === subject.ref &&
+        positionKey(found.position) !== subject.id)
         .map((found) => `also reported: ${found.code} ${found.kind}\t${positionKey(found.position)}\t${found.symbol.kind} ${found.symbol.name}\n`)
         .join("");
 }

package/dist/src/version.js

@@ -4,4 +4,4 @@
  * independently of the analyzer's own version, which is the one the host answers
  * from the package the analyzer was installed from.
  */
-export const CONTRACT_VERSION = "7.2.0";
+export const CONTRACT_VERSION = "8.0.0";