@cplieger/deadset-ts 4.0.1 → 5.1.0

package/dist/src/analysis.js

@@ -7,15 +7,19 @@
  * carries a project's identity in its type so a handle cannot cross to another
  * project's checker, and that holds only for views the session itself hands out.
  */
+import { lineOf, readComponent } from "./component-files.js";
 import { consumerLoads, consumerReferences, moduleIdentity, } from "./consumers.js";
 import { configuredDeclarations, configuredRef, declarationsNamed, } from "./configured-declarations.js";
 import { decorator } from "./decorator.js";
 import { dependenciesOf, projectNeeds } from "./dependencies.js";
 import { deprecatedDeclarations } from "./deprecation.js";
 import { discoverProjects, DiscoveryError, isGuess, projectErrors, renderDiagnostic, targetRelative, } from "./discover.js";
+import { conventionFailuresFor, generatedFiles, readConventions, } from "./conventions.js";
 import { readEdgeSides } from "./edges.js";
 import { enumGroup } from "./enum-group.js";
-import { computeExemptions, disabledClasses, exemptionsOf, isUnansweredRecord, retainedIn, } from "./exempt.js";
+import { generatedFile } from "./generated-file.js";
+import { sourceFilesOf } from "./source-files.js";
+import { detectExemptions, disabledClasses, exemptionsOf, holdingWhile, isUnansweredRecord, retainedIn, } from "./exempt.js";
 import { heldByInclusion, sourceTree } from "./file-facts.js";
 import { findingsPass, recordedFindings, rowKey } from "./findings-pass.js";
 import { NO_SELF_CHECK, unmatchedRootFindings, } from "./findings/self-check.js";
@@ -26,19 +30,23 @@ import { interfaceSatisfaction } from "./interface-satisfaction.js";
 import { intraFunctionFacts, projectParts } from "./intra-function-parts.js";
 import { inventory } from "./inventory.js";
 import { readManifest } from "./manifest.js";
-import { matrixOf, referenceKey, sweepMatrix, } from "./matrix.js";
-import { relativePath, resolvePath } from "./paths.js";
-import { byPosition } from "./position.js";
+import { liveFilesAt, matrixOf, referenceKey, sweepMatrix, } from "./matrix.js";
+import { joinPath, relativePath, resolvePath } from "./paths.js";
+import { byPosition, isComponentFile } from "./position.js";
+import { SetupError, setupLine } from "./setup-failure.js";
+import { pathsOf, readErrors, skippedRoots, skippedUnits, } from "./type-errors.js";
 import { reflectiveLookup } from "./reflective-lookup.js";
 import { references, testFileRulesOf } from "./references.js";
 import { roots, unmatchedEverywhere } from "./roots.js";
 import { serializationContract } from "./serialization-contract.js";
-import { diagnosticsOf, runSession } from "./session.js";
+import { supportReferences, testSupportFiles } from "./test-support.js";
+import { diagnosticsOf, ownedAs, runSession } from "./session.js";
 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 { readTemplates, templateField } from "./template-field.js";
+import { ownErrors, workspaceRun } from "./workspace-run.js";
 /** The setting whose source decides where a finding about a configured root sits. */
 const ROOTS_SETTING = "roots.patterns";
 /**
@@ -63,12 +71,29 @@ function compare(a, b) {
     return a < b ? -1 : 1;
 }
 /**
- * Reads every project the scope discovers, and every project of each consumer it
- * declares, in one snapshot, each checked for errors first. A target project is
- * enumerated, rooted and handed to `stage`; a consumer project is read for its references
- * to the target. A guess that does not load is dropped into `notBuilt` (see
- * {@link isGuess}); any other project that does not load or carries an error fails the
- * run, as does a run whose every guess was dropped.
+ * The manifests the analysis reads, each once: the target's own, then every workspace
+ * member's below the target root.
+ */
+function conventionManifests(host, targetRoot, memberDirs) {
+    const found = new Map();
+    if (host.kindOf(joinPath(targetRoot, "package.json")) === "file") {
+        found.set(targetRoot, { dir: targetRoot, path: "package.json" });
+    }
+    for (const dir of memberDirs) {
+        const below = relativePath(targetRoot, dir);
+        if (below !== undefined && !found.has(dir)) {
+            found.set(dir, { dir, path: `${below}/package.json` });
+        }
+    }
+    return [...found.values()];
+}
+/**
+ * Reads every project the scope discovers, and each declared consumer's, in one snapshot,
+ * each checked for errors first. `stage` is handed a target project and enumerates and roots
+ * it if it reads it; a consumer project is read for its references to the target. A type error
+ * in an own file skips the unit holding it. A guess that does not load or meets a setup failure
+ * is dropped into `notBuilt` (see {@link isGuess}); any other such project fails the run, as
+ * does a run whose every guess was dropped.
  */
 function readProjects(engine, host, scope, config, stage) {
     const targetRoot = scope.target.path;
@@ -76,14 +101,20 @@ function readProjects(engine, host, scope, config, stage) {
     const ids = new Map(discovered.projects.map((project) => [project.configFile, project.id]));
     const loads = consumerLoads(engine, host, scope, discovered.configFiles);
     const consumerOf = new Map(loads.flatMap((load) => load.configFiles.map((configFile) => [configFile, load.consumer])));
+    const absoluteRoot = resolvePath(host.workingDirectory(), targetRoot);
+    const workspace = workspaceRun(engine, host, absoluteRoot, discovered.configFiles, readManifest(host, targetRoot));
+    const conventions = readConventions(host, (fileName, text) => engine.parseSourceFile(fileName, text), conventionManifests(host, absoluteRoot, workspace?.memberDirs ?? []), config.ts.disabledConventions);
     const options = {
-        manifest: readManifest(host, targetRoot),
+        host,
+        manifest: workspace?.manifest ?? readManifest(host, targetRoot),
+        workspaceEntries: workspace?.entries,
         patterns: config.rootPatterns,
         entryFiles: config.ts.entryFiles,
+        conventions,
         testFiles: config.ts.testFiles,
+        parse: (fileName, text) => engine.parseSourceFile(fileName, text),
         publishedAPI: config.targetKind === "library",
     };
-    const absoluteRoot = resolvePath(host.workingDirectory(), targetRoot);
     const notBuilt = [...discovered.notBuilt];
     const dropped = (configFile, error) => {
         notBuilt.push({
@@ -93,10 +124,36 @@ function readProjects(engine, host, scope, config, stage) {
         });
     };
     const failures = [];
+    const unbuildable = [];
+    const setupDropped = [];
     const consumed = new Map();
-    const session = runSession(engine, [...discovered.configFiles, ...consumerOf.keys()], (project) => {
-        const errors = projectErrors(diagnosticsOf(project));
-        const consumer = consumerOf.get(project.configFile);
+    const setupMet = (configFile, met) => {
+        const [first] = met;
+        if (first !== undefined && isGuess(discovered, configFile)) {
+            dropped(configFile, setupLine(first));
+            setupDropped.push(...met);
+        }
+        else {
+            unbuildable.push(...met);
+        }
+    };
+    const session = runSession(engine, [...discovered.configFiles, ...consumerOf.keys()], (opened) => {
+        const consumer = consumerOf.get(opened.configFile);
+        const setup = consumer === undefined ? workspace?.unbuildable(opened.configFile) : undefined;
+        if (setup !== undefined) {
+            setupMet(opened.configFile, [
+                { setupClass: "workspace-member-without-source", detail: setup },
+            ]);
+            return undefined;
+        }
+        const referenceOnly = workspace === undefined || consumer !== undefined
+            ? () => false
+            : workspace.referenceOnly(opened.configFile, opened.rootFiles);
+        const project = workspace === undefined || consumer !== undefined
+            ? opened
+            : ownedAs(opened, (file, fromExternalLibrary) => workspace.ownFile(file, fromExternalLibrary));
+        const raw = projectErrors(diagnosticsOf(project));
+        const errors = { load: raw.load, check: ownErrors(raw.check, referenceOnly) };
         const [unloaded] = errors.load;
         if (unloaded !== undefined &&
             consumer === undefined &&
@@ -104,8 +161,37 @@ function readProjects(engine, host, scope, config, stage) {
             dropped(project.configFile, renderDiagnostic(unloaded, (path) => relativePath(absoluteRoot, path) ?? path));
             return undefined;
         }
-        if (errors.load.length > 0 || errors.check.length > 0) {
-            failures.push(...errors.load, ...errors.check);
+        if (errors.load.length > 0) {
+            failures.push(...errors.load);
+            return undefined;
+        }
+        const reading = readErrors(project, errors.check, {
+            host,
+            targetRoot: consumer === undefined
+                ? absoluteRoot
+                : resolvePath(host.workingDirectory(), consumer.path),
+            paths: pathsOf(engine, project.configFile),
+        });
+        if (reading.failing.length > 0) {
+            failures.push(...reading.failing);
+            return undefined;
+        }
+        if (consumer !== undefined && reading.missing.length > 0) {
+            unbuildable.push(...reading.missing.map((one) => ({
+                setupClass: "missing-consumer",
+                detail: `the consumer ${consumer.path} does not build, its dependencies not installed: ${one.detail}`,
+            })));
+            return undefined;
+        }
+        if (reading.missing.length > 0) {
+            setupMet(project.configFile, reading.missing);
+            return undefined;
+        }
+        const unconventional = consumer === undefined
+            ? conventionFailuresFor(conventions, project.configFile, project.ownSourceFiles().map((file) => file.fileName))
+            : [];
+        if (unconventional.length > 0) {
+            setupMet(project.configFile, unconventional);
             return undefined;
         }
         if (consumer !== undefined) {
@@ -117,22 +203,53 @@ function readProjects(engine, host, scope, config, stage) {
             }
             return undefined;
         }
-        const held = inventory(project, host, targetRoot);
-        const rooted = roots(project, held, targetRoot, options);
         const configuration = ids.get(project.configFile) ?? project.configFile;
-        return stage(project, { configuration, configFile: project.configFile, held, rooted });
-    }, discovered.derived ? "record" : "refuse");
+        const read = () => {
+            const held = inventory(project, host, targetRoot);
+            const found = roots(project, held, targetRoot, options);
+            const kept = skippedRoots(project, held, reading.skips);
+            const rooted = kept.length === 0
+                ? found
+                : {
+                    ...found,
+                    liveUnderReachability: [
+                        ...found.liveUnderReachability,
+                        ...kept.map((id) => ({ id, kind: "type-error", source: "" })),
+                    ],
+                };
+            return {
+                configuration,
+                configFile: project.configFile,
+                held,
+                rooted,
+                typeErrorSkips: reading.skips.map((one) => one.record),
+                skipped: skippedUnits(reading.skips, absoluteRoot),
+                referenceOnly: project
+                    .ownSourceFiles()
+                    .filter((file) => referenceOnly(file.fileName))
+                    .flatMap((file) => relativePath(absoluteRoot, file.fileName) ?? []),
+                generated: generatedFiles(conventions, sourceFilesOf(project, targetRoot)),
+            };
+        };
+        return stage(project, { configuration, read });
+    }, discovered.derived ? "record" : "refuse", workspace?.programs);
     for (const configFile of session.unopened) {
         if (consumerOf.has(configFile) || !isGuess(discovered, configFile)) {
             throw new DiscoveryError(`${configFile} opened no project`, []);
         }
         dropped(configFile, "the compiler opened no project for the configuration");
     }
+    if (unbuildable.length > 0) {
+        throw new SetupError(unbuildable);
+    }
     if (failures.length > 0) {
         throw new DiscoveryError(`${String(failures.length)} error(s), so no answer was produced`, failures);
     }
     const answers = session.projects.filter((answer) => answer !== undefined);
     const [first] = notBuilt;
+    if (answers.length === 0 && setupDropped.length > 0) {
+        throw new SetupError(setupDropped);
+    }
     if (answers.length === 0 && first !== undefined) {
         throw new DiscoveryError(`no configuration discovery derived could be built; ${first.id}: ${first.error}`, []);
     }
@@ -144,8 +261,19 @@ function readProjects(engine, host, scope, config, stage) {
         },
         notBuilt,
         unanswered: session.unanswered,
+        componentsUnread: workspace?.componentsUnread ?? [],
+        conventionsApplied: conventions.applied,
     };
 }
+/**
+ * The projects the run the scope and the configuration describe analyzes, each read
+ * for the errors and setup failures that decide whether it is analyzed, dropped or
+ * fails the run, exactly as the analysis reads them.
+ */
+export function runProjects(engine, host, scope, config) {
+    const read = readProjects(engine, host, scope, config, (_project, opened) => opened.configuration);
+    return { configurations: read.answers, notBuilt: read.notBuilt, unanswered: read.unanswered };
+}
 /**
  * The root set of the run the scope and the configuration describe.
  *
@@ -154,7 +282,7 @@ function readProjects(engine, host, scope, config, stage) {
  */
 export function runRoots(engine, host, scope, config, provenance) {
     const targetRoot = scope.target.path;
-    const read = readProjects(engine, host, scope, config, (_project, projectRead) => projectRead);
+    const read = readProjects(engine, host, scope, config, (_project, opened) => opened.read());
     const projects = read.answers;
     const configurations = [];
     const merged = new Map();
@@ -197,6 +325,7 @@ export function runRoots(engine, host, scope, config, provenance) {
 const DETECTORS = new Map([
     ["interface-satisfaction", interfaceSatisfaction],
     ["enum-group", enumGroup],
+    ["generated-file", generatedFile],
     ["template-field", templateField],
     ["reflective-lookup", reflectiveLookup],
     ["decorator", decorator],
@@ -217,36 +346,64 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
         ? { delimiters: config.analysis.templateDelimiters, files: [] }
         : readTemplates(host, targetRoot, config.analysis);
     const consumers = scope.consumers.map((consumer) => consumer.path);
-    const read = readProjects(engine, host, scope, config, (project, projectRead) => {
+    const read = readProjects(engine, host, scope, config, (project, opened) => {
+        const projectRead = opened.read();
         const resolved = references(project, projectRead.held, targetRoot, {
             testFiles: config.ts.testFiles,
         });
+        const support = testSupportFiles(projectRead.held.symbols, resolved.references, projectRead.rooted.liveUnderReachability, resolved.testFilePaths);
+        const detected = detectExemptions({
+            project,
+            held: projectRead.held,
+            targetRoot,
+            templates,
+            ts: config.ts,
+            consumers,
+            ...(config.analysis.generatedFiles === "include"
+                ? {}
+                : { generated: projectRead.generated }),
+        }, detectors, {
+            disabled,
+            mode,
+            testFiles: new Set([...resolved.testFilePaths, ...support]),
+        });
+        const exempt = detected.records;
+        const made = supportReferences(resolved.references, support);
         const configured = {
             configuration: projectRead.configuration,
             symbols: projectRead.held.symbols,
-            references: resolved.references,
+            references: [...made, ...evidenceReferences(projectRead.held.symbols, detected.inTestFiles)],
             roots: projectRead.rooted.liveUnderReachability,
             testFiles: resolved.testFilePaths,
+            ...(support.size === 0 ? {} : { supportFiles: [...support].sort() }),
+            ...(projectRead.referenceOnly.length === 0
+                ? {}
+                : { referenceOnly: projectRead.referenceOnly }),
         };
-        const exempt = computeExemptions({ project, held: projectRead.held, targetRoot, templates, ts: config.ts, consumers }, detectors, {
-            disabled,
-            mode,
-            testFiles: new Set(resolved.testFilePaths),
-        });
         const unanswered = [
             ...projectRead.held.unanswered,
             ...projectRead.rooted.unanswered,
-            ...resolved.references
+            ...made
                 .filter((reference) => reference.resolution === "by-name")
                 .map((reference) => reference.to),
             ...exempt.filter(isUnansweredRecord).map((record) => record.id),
         ];
+        const components = project.ownSourceFiles().filter(isComponentFile);
+        const pathOf = (file) => relativePath(targetRoot, file.fileName) ?? file.fileName;
         return {
             configFile: projectRead.configFile,
             configured,
             exempt,
             unanswered,
-            extra: extra(project, projectRead, resolved.references),
+            typeErrorSkips: projectRead.typeErrorSkips,
+            skipped: projectRead.skipped,
+            componentFiles: components.map(pathOf),
+            componentWarnings: components.flatMap((file) => readComponent(file.originalText).warnings.map((warning) => ({
+                path: pathOf(file),
+                line: lineOf(file.originalText, warning.offset),
+                reason: warning.reason,
+            }))),
+            extra: extra(project, projectRead, made),
         };
     });
     const consumed = read.consumers.references;
@@ -272,8 +429,82 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
         consumers: read.consumers.loaded,
         notBuilt: read.notBuilt,
         unanswered: read.unanswered,
+        componentsUnread: read.componentsUnread,
+        conventionsApplied: read.conventionsApplied,
     };
 }
+/**
+ * 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.
+ */
+function evidenceReferences(symbols, inTestFiles) {
+    if (inTestFiles.length === 0) {
+        return [];
+    }
+    const files = new Map(symbols
+        .filter((symbol) => symbol.kind === "file")
+        .map((symbol) => [symbol.position.path, symbol.id]));
+    return inTestFiles.flatMap((record) => {
+        const from = files.get(record.site.path);
+        return from === undefined
+            ? []
+            : [
+                {
+                    from,
+                    to: record.id,
+                    position: record.site,
+                    use: "read",
+                    resolution: "syntax",
+                    test: true,
+                },
+            ];
+    });
+}
+/**
+ * The declarations every reference the mode counts stores into, a loaded consumer's
+ * reference counting as a read: what the write-only kind would report but for a record.
+ */
+function writtenOnly(read, mode) {
+    const written = new Set();
+    const readSome = new Set();
+    for (const { configured } of read.projects) {
+        for (const reference of configured.references) {
+            if (mode.production && reference.test) {
+                continue;
+            }
+            if (reference.use === "write" && reference.consumer === undefined) {
+                written.add(reference.to);
+            }
+            else {
+                readSome.add(reference.to);
+            }
+        }
+    }
+    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
@@ -282,8 +513,8 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
  * every declaration that makes such a reference.
  */
 function sweptOf(read, input) {
-    const swept = { ...input, exempt: read.exempt, unanswered: read.unansweredHeld };
-    const result = sweepMatrix(read.matrix, swept);
+    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
@@ -302,7 +533,7 @@ function sweptOf(read, input) {
         })));
         const bare = {
             ...swept,
-            exempt: read.exempt.filter((record) => !isUnansweredRecord(record)),
+            exempt: exempt.filter((record) => !isUnansweredRecord(record)),
             unanswered: [],
         };
         for (const candidate of sweepMatrix(answered, bare).candidates) {
@@ -316,10 +547,13 @@ function sweptOf(read, input) {
     return {
         matrix: read.matrix,
         sweep: result,
-        retained: retainedIn(read.matrix, swept),
+        exempt,
+        retained: retainedIn(read.matrix, swept, 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(compare),
     };
 }
 /**
@@ -341,11 +575,12 @@ function readEmitterRun(engine, host, scope, config, mode, detectors) {
     const run = readRun(engine, host, scope, config, mode, detectors, (project, read, references) => ({
         deprecation: deprecatedDeclarations(project, read.held),
         accessors: accessorsOf(project, read.held),
-        needs: projectNeeds(project, read.held, host),
+        needs: projectNeeds(project, read.held, host, targetRoot, (fileName, text) => engine.parseSourceFile(fileName, text)),
         implementations: implementations(project, read.held),
         heldByInclusion: heldByInclusion(project, targetRoot),
+        generated: [...read.generated.keys()],
         rooted: read.rooted,
-        directives: inlineDirectives(project, read.held, targetRoot),
+        directives: inlineDirectives(project, read.held, targetRoot).filter((directive) => !read.referenceOnly.includes(directive.site.path)),
         declarationsNamed: declarationsNamed(project, read.held, configuredDeclarations(config)),
         parts: projectParts(project, read.held, references, targetRoot),
     }));
@@ -371,12 +606,13 @@ function emitterInputOver(host, scope, config, read, input, selfCheck) {
         stores: storesOf(projects.map((one) => ({
             references: one.configured.references,
             accessors: one.extra.accessors,
-        })), read.exempt, input.mode),
+        })), swept.exempt, input.mode),
         dependencies: dependenciesOf(host, targetRoot, projects.map((one) => one.extra.needs), swept.sweep.candidates.map((candidate) => candidate.id)),
         implementations: mergeImplementations(projects.map((one) => one.extra.implementations)),
         files: {
             tree: sourceTree(host, targetRoot),
             heldByInclusion: new Set(projects.flatMap((one) => one.extra.heldByInclusion)),
+            generated: new Set(projects.flatMap((one) => one.extra.generated)),
         },
         boundary: {
             consumers: {
@@ -387,7 +623,7 @@ function emitterInputOver(host, scope, config, read, input, selfCheck) {
             edges: readEdgeSides(host, targetRoot),
         },
         selfCheck,
-        intraFunction: intraFunctionFacts(projects.map((one) => one.extra.parts), projects.flatMap((one) => one.configured.references), new Set([...read.exempt.map((one) => one.id), ...swept.heldByUnanswered])),
+        intraFunction: intraFunctionFacts(projects.map((one) => one.extra.parts), projects.flatMap((one) => one.configured.references), new Set([...swept.exempt.map((one) => one.id), ...swept.heldByUnanswered])),
     };
 }
 /**
@@ -424,10 +660,18 @@ function readAnalysis(engine, host, scope, config, provenance, mode, detectors)
                 id: one.configured.configuration,
                 configFile: one.configFile,
             })),
-            testFileRules: testFileRulesOf(config.ts.testFiles, read.projects.flatMap((one) => one.configured.testFiles)),
+            testFileRules: testFileRulesOf(config.ts.testFiles, read.projects.flatMap((one) => one.configured.testFiles), read.projects.flatMap((one) => one.configured.supportFiles ?? [])),
+            typeErrorSkips: read.projects.flatMap((one) => one.typeErrorSkips),
+            componentWarnings: [
+                ...new Map(read.projects
+                    .flatMap((one) => one.componentWarnings)
+                    .map((one) => [`${one.path}:${String(one.line)}:${one.reason}`, one])).values(),
+            ],
             consumers: read.consumers,
             notBuilt: read.notBuilt,
             unanswered: read.unanswered,
+            componentsUnread: read.componentsUnread,
+            conventionsApplied: read.conventionsApplied,
         },
         configured: read.projects.map((one) => one.configured),
         symbols,
@@ -475,6 +719,22 @@ export function runAnalysis(engine, host, scope, config, provenance, mode, detec
     const inputs = reader.inputsUnder(readBaseline(host, scope.target.path, reader.symbols));
     return analysisOf(reader, inputs);
 }
+/**
+ * One count per configuration of the run in which the checker left a question unanswered:
+ * the questions asked in its project, and the declarations of its own the run holds for them.
+ */
+export function unansweredCounts(analysis) {
+    const held = new Set(analysis.swept.heldByUnanswered);
+    return analysis.run.projects.flatMap((project) => {
+        const questions = analysis.run.unanswered.filter((one) => one.configFile === project.configFile).length;
+        if (questions === 0) {
+            return [];
+        }
+        const symbols = analysis.configured.find((one) => one.configuration === project.id)?.symbols;
+        const declarations = new Set((symbols ?? []).map((one) => one.id).filter((id) => held.has(id)));
+        return [{ configuration: project.id, questions, declarations: declarations.size }];
+    });
+}
 function analysisOf(reader, inputs) {
     return {
         result: findingsPass(inputs),