@cplieger/deadset-ts 3.12.1 → 4.0.0

package/dist/src/discover.js

@@ -19,14 +19,35 @@ export class DiscoveryError extends Error {
         this.diagnostics = diagnostics;
     }
 }
+/** The category an error diagnostic carries, which the protocol sends as a number. */
+const ERROR_CATEGORY = DiagnosticCategory.Error;
 /** Whether one diagnostic is an error, which is what fails a run closed. */
 export function isError(diagnostic) {
-    return diagnostic.category === DiagnosticCategory.Error;
+    return diagnostic.category === ERROR_CATEGORY;
 }
-/** One diagnostic as a line naming its position, its code and its message. */
-export function renderDiagnostic(diagnostic) {
-    const where = diagnostic.fileName ?? "<no file>";
-    return `${where}:${String(diagnostic.pos)}: TS${String(diagnostic.code)}: ${diagnostic.text}`;
+/**
+ * One diagnostic as a line naming its file, its line and column, its code and its
+ * message: `path:line:column: TScode: message`, the position left out where the
+ * diagnostic names none and the file where it names none. `display` spells the
+ * file's path; it answers the path itself where it is not given.
+ */
+export function renderDiagnostic(located, display = (path) => path) {
+    const { diagnostic, at } = located;
+    const message = `TS${String(diagnostic.code)}: ${diagnostic.text}`;
+    if (diagnostic.fileName === undefined) {
+        return message;
+    }
+    const where = display(diagnostic.fileName);
+    return at === undefined
+        ? `${where}: ${message}`
+        : `${where}:${String(at.line)}:${String(at.column)}: ${message}`;
+}
+/** Each diagnostic with the line and column its offset falls on. */
+function locatedIn(diagnostics, locate) {
+    return diagnostics.map((diagnostic) => ({
+        diagnostic,
+        at: diagnostic.fileName === undefined ? undefined : locate(diagnostic.fileName, diagnostic.pos),
+    }));
 }
 /**
  * Every error a project's three diagnostic sets carry, in the order the compiler
@@ -38,6 +59,32 @@ export function renderDiagnostic(diagnostic) {
 export function diagnosticErrors(sets) {
     return [...sets.configParsing, ...sets.syntactic, ...sets.semantic].filter(isError);
 }
+/** The errors one open project carries, each located in the file it names. */
+export function projectErrors(sets) {
+    const load = sets.configParsing.filter(isError);
+    return {
+        load: locatedIn(load, sets.locate),
+        check: load.length > 0 ? [] : locatedIn(diagnosticErrors(sets), sets.locate),
+    };
+}
+/**
+ * The first line of one error about the target, every mention of the target root
+ * spelled relative to it: a path below the root loses the root and its separator, and
+ * the root itself is `.`.
+ */
+export function targetRelative(text, targetRoot) {
+    const root = targetRoot.endsWith("/") ? targetRoot.slice(0, -1) : targetRoot;
+    const [first = ""] = text.split(/\r?\n/u);
+    const spelled = first.split(`${root}/`).join("").split(root).join(".").trim();
+    return spelled === "" ? "the configuration could not be built" : spelled;
+}
+/**
+ * Whether one configuration is the analyzer's own guess: discovery derived it and the
+ * scope did not name it. A guess that does not load is dropped; any other ends the run.
+ */
+export function isGuess(discovery, configFile) {
+    return discovery.derived && !discovery.fromScope.includes(configFile);
+}
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -130,9 +177,11 @@ function scopeConfigFiles(host, scope) {
 /**
  * Every configuration file reached from `pending`, in the order discovery reads them:
  * each once, each followed by the configurations it references, transitively. A
- * configuration the compiler cannot read ends the run naming it.
+ * configuration the compiler cannot read ends the run naming it, unless `unreadable`
+ * is given, which is then told the configuration and why, and the walk goes on
+ * without it.
  */
-function derivedFrom(engine, host, pending) {
+function derivedFrom(engine, host, pending, unreadable) {
     const seen = new Set();
     const found = [];
     while (pending.length > 0) {
@@ -145,7 +194,14 @@ function derivedFrom(engine, host, pending) {
             continue;
         }
         seen.add(path);
-        parseOrRefuse(engine, path, path);
+        const reason = unreadableReason(engine, path);
+        if (reason !== undefined) {
+            if (unreadable === undefined) {
+                throw new DiscoveryError(`${path} cannot be read as a compiler configuration: ${reason}`, []);
+            }
+            unreadable(path, reason);
+            continue;
+        }
         found.push(path);
         pending.push(...referencesOf(host, path));
     }
@@ -179,18 +235,25 @@ export function consumerProjects(engine, host, root) {
 function derivedId(targetRoot, configFile) {
     return relativePath(targetRoot, configFile) ?? configFile;
 }
+/** Why the compiler cannot read one configuration file, or undefined where it can. */
+function unreadableReason(engine, configFile) {
+    try {
+        engine.parseConfigFile(configFile);
+        return undefined;
+    }
+    catch (error) {
+        return error instanceof Error ? error.message : String(error);
+    }
+}
 /**
  * Resolves one compiler configuration file, or ends the run naming it: a project
  * opened from a configuration the compiler cannot read would be analyzed with no
  * type information.
  */
 function parseOrRefuse(engine, configFile, named) {
-    try {
-        engine.parseConfigFile(configFile);
-    }
-    catch (error) {
-        throw new DiscoveryError(`${named} cannot be read as a compiler configuration: ` +
-            (error instanceof Error ? error.message : String(error)), []);
+    const reason = unreadableReason(engine, configFile);
+    if (reason !== undefined) {
+        throw new DiscoveryError(`${named} cannot be read as a compiler configuration: ${reason}`, []);
     }
 }
 /**
@@ -232,25 +295,41 @@ function declaredProjects(engine, host, targetRoot, entries) {
                 "into the program that references it, so the matrix names it too", []);
         }
     }
-    return { projects, configFiles: projects.map((project) => project.configFile), fromScope: [] };
+    return {
+        projects,
+        derived: false,
+        notBuilt: [],
+        configFiles: projects.map((project) => project.configFile),
+        fromScope: [],
+    };
 }
 /**
  * The projects a run derives where the matrix declares none, in the order discovery
  * reads them: the paths the scope names, then every compiler configuration under
  * the target root that is not inside an ignored directory, then the configurations
- * each of those references, transitively. Each configuration appears once.
+ * each of those references, transitively. Each configuration appears once. A
+ * configuration the scope names directly is the caller's own and ends the run where
+ * it cannot be read; one the walk found is dropped and named.
  */
 function derivedProjects(engine, host, scope) {
+    const targetRoot = scope.target.path;
     const fromScope = scopeConfigFiles(host, scope);
-    const configFiles = derivedFrom(engine, host, [
-        ...fromScope,
-        ...configFilesUnder(host, scope.target.path),
-    ]);
+    const notBuilt = [];
+    const configFiles = derivedFrom(engine, host, [...fromScope, ...configFilesUnder(host, targetRoot)], (configFile, reason) => {
+        if (fromScope.includes(configFile)) {
+            throw new DiscoveryError(`${configFile} cannot be read as a compiler configuration: ${reason}`, []);
+        }
+        notBuilt.push({
+            id: derivedId(targetRoot, configFile),
+            configFile,
+            error: targetRelative(reason, resolvePath(host.workingDirectory(), targetRoot)),
+        });
+    });
     const projects = configFiles.map((configFile) => ({
-        id: derivedId(scope.target.path, configFile),
+        id: derivedId(targetRoot, configFile),
         configFile,
     }));
-    return { projects, configFiles, fromScope };
+    return { projects, derived: true, notBuilt, configFiles, fromScope };
 }
 /**
  * Every project one run analyzes.
@@ -262,12 +341,10 @@ function derivedProjects(engine, host, scope) {
  * scope and the target tree. A platform entry names a configuration of another
  * language and plays no part here.
  *
- * A configuration file the compiler cannot read ends the run with the failure code,
- * so a project that would have been analyzed with no type information is never
- * analyzed at all, whether the matrix declared it or discovery derived it. What a
- * configuration's own contents say is refused once its project is open, by
- * {@link diagnosticErrors} over the three sets a program reports, because a
- * resolution carries no diagnostics.
+ * A configuration file the compiler cannot read is never analyzed. One the matrix or
+ * the scope names ends the run with the failure code; a guess is dropped and named in
+ * {@link Discovery.notBuilt}. What a configuration's own contents say is read once its
+ * project is open, by {@link diagnosticErrors}, because a resolution carries none.
  *
  * Nothing reads a build output: a project is the files its configuration names, so a
  * package whose sources ship as TypeScript is analyzed as it stands.

package/dist/src/edges.js

@@ -8,6 +8,7 @@ import { ConfigError } from "./config.js";
 import { positionAt, walkDocument } from "./json-document.js";
 import { joinPath } from "./paths.js";
 import { positionKey } from "./position.js";
+import { isPartSubject } from "./suppress.js";
 /** The name and the location the Contract fixes for the edges document. */
 export const EDGES_FILE = "deadset-edges.json";
 /** The language prefix of every reference this analyzer evaluates. */
@@ -169,7 +170,9 @@ export function evaluateEdges(findings, sides, symbols) {
     }
     const held = new Map();
     findings.forEach((finding, at) => {
-        held.set(positionKey(finding.position), at);
+        if (!isPartSubject(finding.symbol.kind)) {
+            held.set(positionKey(finding.position), at);
+        }
     });
     const pending = new Set();
     const evaluations = sides.map((side) => {

package/dist/src/entry-points.js

@@ -14,6 +14,7 @@ import { isArrayLiteralExpression, isAsExpression, isCallExpression, isExportAss
 import { SymbolFlags } from "@typescript/native/unstable/sync";
 import { globExpression } from "./glob.js";
 import { dirnamePath, relativePath, resolvePath } from "./paths.js";
+import { UNANSWERED } from "./query.js";
 /** The extensions the test runner and the browser-test runner load a configuration from. */
 const MODULE_EXTENSIONS = ["js", "mjs", "cjs", "ts", "mts", "cts"];
 /** The extensions the linter's flat configuration and the mutation tester's are loaded from. */
@@ -331,8 +332,14 @@ function workersOf(project, file, files) {
     const names = sites.flatMap((site) => site.platformNames);
     const symbols = project.symbolsAt(names.map((name) => project.handle(name)));
     const platform = new Set();
+    // A name the checker could not resolve is read as the platform's, so a worker it
+    // stands on is rooted rather than reported.
     names.forEach((name, index) => {
         const symbol = symbols[index];
+        if (symbol === UNANSWERED) {
+            platform.add(name);
+            return;
+        }
         if (symbol !== undefined &&
             (symbol.flags & SymbolFlags.Alias) === 0 &&
             symbol.declarations.length > 0 &&

package/dist/src/enum-group.js

@@ -11,7 +11,7 @@ import { TypeFlags } from "@typescript/native/unstable/sync";
 import { aliasChains } from "./alias-chain.js";
 import { nodeKey } from "./inventory.js";
 import { renderPosition } from "./position.js";
-import { DEFAULT_BATCH_CAP } from "./references.js";
+import { isAnswered, UNANSWERED } from "./query.js";
 /** The operand types a conversion produces an enum value from. */
 const NUMBER = TypeFlags.NumberLike;
 const STRING = TypeFlags.StringLike;
@@ -104,24 +104,31 @@ function sitesOf(file) {
  * union, and itself otherwise. An enum's own value, or one of its members, is a value the
  * source names, whichever number or string it also is.
  */
-function partsOf(type) {
-    const parts = type.isUnionType() ? type.getTypes() : [type];
-    return parts.filter((part) => (part.flags & TypeFlags.EnumLike) === 0);
+function partsOf(project, type) {
+    const parts = type.isUnionType() ? project.queries.constituents(type) : [type];
+    return isAnswered(parts)
+        ? parts.filter((part) => (part.flags & TypeFlags.EnumLike) === 0)
+        : parts;
 }
+/** The detail a site records whose operand's type the checker could not answer. */
+const UNTYPED_DETAIL = "converted from a value of unanswered type";
 /**
  * The detail one site records about the enum it produces, or undefined where the
  * operand's type converts nothing: a number, or a string an assertion converts, is
  * converted, a value of type `any` or `unknown` is decoded, and a value of an enum is one
  * the source names.
  */
-function detailOf(site, enumName, operand) {
+function detailOf(project, site, enumName, operand) {
     if (site.form === "lookup") {
         return `looked up by an element access on ${enumName}`;
     }
     if (operand === undefined) {
         return undefined;
     }
-    const parts = partsOf(operand);
+    const parts = operand === UNANSWERED ? UNANSWERED : partsOf(project, operand);
+    if (parts === UNANSWERED) {
+        return UNTYPED_DETAIL;
+    }
     if (parts.some((part) => (part.flags & NUMBER) !== 0)) {
         return "converted from number";
     }
@@ -160,32 +167,33 @@ export function enumGroup(input) {
     const sites = files.flatMap(sitesOf);
     const named = new Map();
     const chains = aliasChains(project, held);
-    for (let from = 0; from < sites.length; from += DEFAULT_BATCH_CAP) {
-        const run = sites.slice(from, from + DEFAULT_BATCH_CAP);
-        project.symbolsAt(run.map((site) => project.handle(site.name))).forEach((symbol, index) => {
-            const site = run[index];
-            if (symbol === undefined || site === undefined) {
-                return;
-            }
-            const target = chains.chainOf(symbol).find((link) => enums.has(link.id));
-            if (target !== undefined) {
-                named.set(site, target.id);
+    // A name the checker could not resolve may stand for any enum of the target it spells.
+    const enumsNamed = (text) => [...enums].flatMap(([id, name]) => (name === text ? [id] : []));
+    project.symbolsAt(sites.map((site) => project.handle(site.name))).forEach((symbol, index) => {
+        const site = sites[index];
+        if (symbol === undefined || site === undefined) {
+            return;
+        }
+        if (symbol === UNANSWERED) {
+            const ids = enumsNamed(site.name.getText());
+            if (ids.length > 0) {
+                named.set(site, ids);
             }
-        });
-    }
+            return;
+        }
+        const target = chains.chainOf(symbol).find((link) => enums.has(link.id));
+        if (target !== undefined) {
+            named.set(site, [target.id]);
+        }
+    });
     const typed = sites.filter((site) => named.has(site) && site.operand !== undefined);
     const operandType = new Map();
-    for (let from = 0; from < typed.length; from += DEFAULT_BATCH_CAP) {
-        const run = typed.slice(from, from + DEFAULT_BATCH_CAP);
-        project.checker
-            .getTypeAtLocation(run.map((site) => site.operand ?? site.at))
-            .forEach((type, index) => {
-            const site = run[index];
-            if (type !== undefined && site !== undefined) {
-                operandType.set(site, type);
-            }
-        });
-    }
+    project.queries.typesAt(typed.map((site) => site.operand ?? site.at)).forEach((type, index) => {
+        const site = typed[index];
+        if (type !== undefined && site !== undefined) {
+            operandType.set(site, type);
+        }
+    });
     const members = new Map();
     for (const symbol of held.symbols) {
         if (symbol.kind === "enum-member" && enums.has(symbol.parent)) {
@@ -200,17 +208,15 @@ export function enumGroup(input) {
     }
     const found = [];
     for (const site of sites) {
-        const enumId = named.get(site);
-        if (enumId === undefined) {
-            continue;
-        }
-        const detail = detailOf(site, enums.get(enumId) ?? "", operandType.get(site));
-        if (detail === undefined) {
-            continue;
-        }
-        const position = renderPosition(site.at.getSourceFile(), targetRoot, site.at.getStart());
-        for (const id of members.get(enumId) ?? []) {
-            found.push({ id, detail, site: position });
+        for (const enumId of named.get(site) ?? []) {
+            const detail = detailOf(project, site, enums.get(enumId) ?? "", operandType.get(site));
+            if (detail === undefined) {
+                continue;
+            }
+            const position = renderPosition(site.at.getSourceFile(), targetRoot, site.at.getStart());
+            for (const id of members.get(enumId) ?? []) {
+                found.push({ id, detail, site: position });
+            }
         }
     }
     return found;

package/dist/src/exempt.js

@@ -9,6 +9,7 @@
 import { ConfigError } from "./config.js";
 import { EXEMPTION_CLASSES, isExemptionClass, TS_EXEMPTION_CLASSES, typescriptVisibilityOf, } from "./exempt-classes.js";
 import { byPosition, positionKey } from "./position.js";
+import { Unanswerable } from "./query.js";
 import { sweep } from "./sweep.js";
 /**
  * The classes `exemptions.disabled` switches off. A name is refused unless the
@@ -39,6 +40,46 @@ function retainable(allowed, visibility) {
     }
     return true;
 }
+/**
+ * The kinds of declaration each class can hold back, which a detector that stops holds
+ * back whole. A class with no row here holds back every declaration but a file.
+ */
+const RETAINABLE = new Map([
+    ["interface-satisfaction", new Set(["method", "class-member"])],
+    ["enum-group", new Set(["enum-member"])],
+    ["injection-container", new Set(["method", "class-member"])],
+    ["framework-lifecycle", new Set(["method", "class-member"])],
+    [
+        "serialization-contract",
+        new Set(["method", "class-member", "interface-method", "type-member"]),
+    ],
+]);
+/** The detail of a record a detector that could not finish holds. */
+const UNANSWERED_DETAIL = "kept live by a question the checker did not answer";
+/** Whether one record is held by a detector that could not finish. */
+export function isUnansweredRecord(record) {
+    return record.detail === UNANSWERED_DETAIL;
+}
+/**
+ * What one detector holds back over one project. A detector that stops because the
+ * checker left a question it needs unanswered holds back every declaration of the
+ * project its class could hold back, each recorded at its own position, so the gap
+ * never yields a finding.
+ */
+function detected(exemptionClass, detect, input) {
+    try {
+        return detect(input);
+    }
+    catch (error) {
+        if (!(error instanceof Unanswerable)) {
+            throw error;
+        }
+        const kinds = RETAINABLE.get(exemptionClass);
+        return input.held.symbols
+            .filter((symbol) => (kinds === undefined ? symbol.kind !== "file" : kinds.has(symbol.kind)))
+            .map((symbol) => ({ id: symbol.id, detail: UNANSWERED_DETAIL, site: symbol.position }));
+    }
+}
 /**
  * The records one project's detectors found, each class in the vocabulary's order and
  * none of a switched-off class. Evidence on a private member the class's row says it
@@ -55,7 +96,7 @@ export function computeExemptions(input, detectors, holding) {
             continue;
         }
         const allowed = typescriptVisibilityOf(exemptionClass);
-        for (const evidence of detect(input)) {
+        for (const evidence of detected(exemptionClass, detect, input)) {
             if (!retainable(allowed, visibility.get(evidence.id))) {
                 continue;
             }

package/dist/src/findings/completion.js

@@ -6,8 +6,9 @@
 import { componentId } from "../components.js";
 import { OUTSIDE } from "../graph.js";
 import { KINDS } from "../kinds.js";
+import { byPosition } from "../position.js";
 import { FAMILY_KEY_LENGTH } from "../resolve.js";
-import { isRowSubject } from "../suppress.js";
+import { isPartSubject, isRowSubject } from "../suppress.js";
 /** The classes ranked by the claim each makes, the strongest highest. */
 const RANK = { certain: 3, probable: 2, possible: 1 };
 /** The weaker of two classes, which is a class capped by a ceiling. */
@@ -66,14 +67,35 @@ function reachabilityClasses(input) {
             : "probable";
     return (id) => (published.has(id) ? outside : "certain");
 }
-/** The component each dead declaration of the run falls in, and none for a live one. */
-function findingComponents(swept) {
+/**
+ * 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) {
     const held = new Map();
     for (const component of swept.sweep.components) {
         for (const member of component.members) {
             held.set(member, component);
         }
     }
+    const symbols = new Map(swept.matrix.union.symbols.map((symbol) => [symbol.id, symbol]));
+    const listed = (component) => component.members
+        .flatMap((member) => {
+        const symbol = symbols.get(member);
+        return symbol === undefined
+            ? []
+            : [
+                {
+                    ref: symbol.ref,
+                    name: symbol.name,
+                    position: {
+                        ...symbol.position,
+                        endLine: Math.max(symbol.position.line, symbol.endLine),
+                    },
+                },
+            ];
+    })
+        .sort((a, b) => byPosition(a.position, b.position) || (a.ref === b.ref ? 0 : a.ref < b.ref ? -1 : 1));
     return (id) => {
         const component = held.get(id);
         return component === undefined
@@ -83,6 +105,7 @@ function findingComponents(swept) {
                 root: component.roots.includes(id),
                 symbolCount: component.members.length,
                 deletableLines: component.deletableLines,
+                ...(cascade === "full" ? { members: listed(component) } : {}),
             };
     };
 }
@@ -101,7 +124,7 @@ export function completed(input, findings, kinds = KINDS) {
     const positions = new Map(union.symbols.map((symbol, at) => [symbol.ref, at]));
     const candidates = new Map(swept.sweep.candidates.map((candidate) => [candidate.id, candidate]));
     const classOf = reachabilityClasses(input);
-    const componentOf = findingComponents(swept);
+    const componentOf = findingComponents(swept, input.config.reporters.cascade);
     let minted = swept.sweep.components.length;
     return findings.map((finding) => {
         const row = kinds.get(finding.code);
@@ -113,11 +136,15 @@ export function completed(input, findings, kinds = KINDS) {
         const at = isRowSubject(finding.symbol.kind)
             ? OUTSIDE
             : (positions.get(finding.symbol.ref) ?? 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 = union.subject[at] === true ? symbol : undefined;
+        const judged = !part && union.subject[at] === true ? symbol : undefined;
         const candidate = judged === undefined ? undefined : candidates.get(judged.id);
-        const found = symbol === undefined ? undefined : componentOf(symbol.id);
-        if (candidate !== undefined && found === undefined) {
+        const found = symbol === undefined || part ? undefined : componentOf(symbol.id);
+        // A test file's declaration is a component member only as a test of dead code.
+        if (candidate !== undefined && found === undefined && union.test[at] !== true) {
             throw new Error(`${candidate.id} is judged dead and falls in no dead component`);
         }
         let component = found;
@@ -148,7 +175,9 @@ export function completed(input, findings, kinds = KINDS) {
             component,
             retainedBy: [],
             configurations: candidate?.configurations ??
-                (judged === undefined ? swept.matrix.configurations : (swept.matrix.heldIn[at] ?? [])),
+                (judged === undefined && !part
+                    ? swept.matrix.configurations
+                    : (swept.matrix.heldIn[at] ?? swept.matrix.configurations)),
             consumersLoaded: input.boundary.consumers.loaded,
             fixability: row.fixability,
             severity: severityOf(input, finding.code, row.defaultSeverity),

package/dist/src/findings/emitters.js

@@ -7,7 +7,7 @@ import { intraFunction } from "./intra-function.js";
 import { nonCodeArtifacts } from "./non-code-artifacts.js";
 import { readsAndWrites } from "./reads-and-writes.js";
 import { selfCheck } from "./self-check.js";
-import { unusedDeclarations } from "./unused-declarations.js";
+import { fallenMembers, unusedDeclarations } from "./unused-declarations.js";
 import { visibilityNarrowing } from "./visibility-narrowing.js";
 /** Every kind family this analyzer reports, each by its emitter, in code order. */
 export const EMITTERS = new Map([
@@ -20,9 +20,22 @@ export const EMITTERS = new Map([
     ["self-check", selfCheck],
     ["intra-function", intraFunction],
 ]);
-/** Every family's findings over one sweep, completed by one step. */
-function completedOver(input) {
-    return completed(input, [...EMITTERS.values()].flatMap((emit) => emit(input)));
+/**
+ * The references of every declaration an unanswered question could have kept live, which
+ * the run reports nothing about: a finding about one would be computed from the gap.
+ */
+function heldRefs(input) {
+    const held = new Set(input.swept.heldByUnanswered);
+    if (held.size === 0) {
+        return held;
+    }
+    return new Set(input.swept.matrix.union.symbols
+        .filter((symbol) => held.has(symbol.id))
+        .map((symbol) => symbol.ref));
+}
+/** Every family's findings over one sweep, and those of any further emitter, completed by one step. */
+function completedOver(input, ...more) {
+    return completed(input, [...EMITTERS.values(), ...more].flatMap((emit) => emit(input)));
 }
 /**
  * The dials over the findings a record could name, each read against the sweep that
@@ -47,10 +60,11 @@ function dialsOver(input, found, suppressed, unmarked) {
  */
 export function decidedFindings(input, suppressed = { unmarked: input, records: [] }) {
     const found = completedOver(input);
-    const unmarked = suppressed.records.length === 0 ? [] : completedOver(suppressed.unmarked);
+    const unmarked = suppressed.records.length === 0 ? [] : completedOver(suppressed.unmarked, fallenMembers);
     const would = [...unmarked, ...found];
     const ledger = ledgerOf(suppressed.records, would, dialsOver(input, found, suppressed, unmarked));
-    const kept = reportable(input, found.filter((finding) => !ledger.withheld(finding)));
+    const unanswered = heldRefs(input);
+    const kept = reportable(input, found.filter((finding) => !ledger.withheld(finding) && !unanswered.has(finding.symbol.ref)));
     const evaluated = evaluateEdges(kept, input.boundary.edges, input.swept.matrix.union.symbols);
     return {
         findings: evaluated.findings,

package/dist/src/findings/interfaces.js

@@ -88,8 +88,14 @@ function unusedMessage(candidate) {
         ? UNUSED_TEST_MESSAGE
         : UNUSED_MESSAGE;
 }
-/** Whether one interface method has implementations and every one has an empty body. */
+/**
+ * Whether one interface method has implementations and every one has an empty body, or
+ * is one whose implementations the run could not read in full.
+ */
 function marker(input, method) {
+    if (input.implementations.unknown.has(method)) {
+        return true;
+    }
     const bodies = [...(input.implementations.bodies.get(method)?.values() ?? [])];
     return bodies.length > 0 && bodies.every((empty) => empty);
 }