@cplieger/deadset-ts 8.0.0-dev.2 → 8.0.0-dev.20

package/dist/src/findings/non-code-artifacts.js

@@ -1,5 +1,4 @@
-const FILE_NEVER_BUILT = "DS1501";
-const FILE_NEVER_IMPORTED = "DS1502";
+import { CODE } from "../contract/contract.generated.js";
 /** The subject kind of a finding about a source file, from the finding schema's vocabulary. */
 const FILE_SUBJECT = "file";
 /** A file's subject starts at its first character. */
@@ -11,8 +10,8 @@ const FILE_START = 1;
  * derived matrix is never complete.
  */
 function completeMatrix(config) {
-    return (config.analysis.matrixComplete &&
-        config.analysis.configurations.some((entry) => entry.shape === "project"));
+    return (config.analysis.matrix.complete &&
+        config.analysis.configurations.some((entry) => "project" in entry));
 }
 /** One finding about a whole file. */
 function fileFinding(code, file, message) {
@@ -40,7 +39,7 @@ function fileNeverBuilt({ config, swept, files }) {
     const message = `no project of the build matrix includes this file (${swept.matrix.configurations.join(", ")})`;
     return files.tree
         .filter((file) => !built.has(file.path))
-        .map((file) => fileFinding(FILE_NEVER_BUILT, file, message));
+        .map((file) => fileFinding(CODE.fileNeverBuilt, file, message));
 }
 /**
  * The paths of the files a reference from a live declaration of another file reaches, a
@@ -125,14 +124,20 @@ function fileNeverImported(input) {
         const file = { path: symbol.position.path, ref: symbol.ref, endLine: symbol.endLine };
         return referenced.has(symbol.position.path)
             ? {
-                ...fileFinding(FILE_NEVER_IMPORTED, file, "only code that is itself dead imports this file, and no root names it or a declaration in it"),
+                ...fileFinding(CODE.fileNeverImported, file, "only code that is itself dead imports this file, and no root names it or a declaration in it"),
                 unreachableOnly: true,
             }
-            : fileFinding(FILE_NEVER_IMPORTED, file, "no import reaches this file and no root names it or a declaration in it");
+            : fileFinding(CODE.fileNeverImported, file, "no import reaches this file and no root names it or a declaration in it");
     });
 }
-/** The findings of the non-code-artifacts family, `DS1500` to `DS1599`. */
-export const nonCodeArtifacts = (input) => [
-    ...fileNeverBuilt(input),
-    ...fileNeverImported(input),
-];
+/**
+ * The findings of the files family, `DS1600` to `DS1699`, each at the class `possible` in a
+ * package a command of which may run a file whose path no word of it writes, since that
+ * command may run the file (confidence.35).
+ */
+export const nonCodeArtifacts = (input) => {
+    const unwritten = [...(input.files.unwrittenRuns ?? [])];
+    return [...fileNeverBuilt(input), ...fileNeverImported(input)].map((finding) => unwritten.some((dir) => dir === "." || finding.position.path === dir || finding.position.path.startsWith(`${dir}/`))
+        ? { ...finding, reachabilityClass: "possible" }
+        : finding);
+};

package/dist/src/findings/reads-and-writes.js

@@ -1,7 +1,11 @@
+import { CODE } from "../contract/contract.generated.js";
+import { WORDS } from "../inventory.js";
 import { positionKey } from "../position.js";
 import { declarationKey } from "../ref.js";
-/** The containers whose type parameters `DS1303` reports: a function and a class method. */
-const SIGNATURES = new Set(["function", "method"]);
+import { reachabilityClasses } from "./completion.js";
+import { bytewise } from "../text/compare.js";
+/** The containers whose type parameters `DS1006` reports: a function, a class method and a type alias. */
+const SIGNATURES = new Set(["function", "method", "type"]);
 function indexed(input) {
     const { matrix, sweep } = input.swept;
     return {
@@ -68,14 +72,16 @@ function parametersOnlyNamedBy(run, namedBy, member) {
         .map((symbol) => symbol.name);
 }
 /** What one write-only finding says, the declarations its deletion takes with it included. */
-function writeOnlyMessage(run, namedBy, symbol, held) {
+function writeOnlyMessage(run, written, subject) {
+    const { symbol, held } = subject;
     const writes = held.writes.length === 1 ? "once" : `at ${String(held.writes.length)} positions`;
     const read = run.input.stores.readInTests.has(symbol.id)
         ? "read only from test files"
         : "never read";
     const cascade = [
-        ...parametersOnlyNamedBy(run, namedBy, symbol).map((name) => `type parameter ${name}`),
-        ...[...held.alone].sort().map((name) => `import ${name}`),
+        ...parametersOnlyNamedBy(run, written.namedBy, symbol).map((name) => `type parameter ${name}`),
+        ...[...held.alone].sort(bytewise).map((name) => `import ${name}`),
+        ...(written.named.get(symbol.id) ?? []),
     ];
     const word = SUBJECT_WORDS[symbol.kind] ?? "member";
     const message = `${word} ${symbol.name} is written ${writes} and ${read}`;
@@ -84,16 +90,34 @@ function writeOnlyMessage(run, namedBy, symbol, held) {
         : `${message}, and deleting it with its writes deletes ${cascade.join(" and ")} too`;
 }
 /**
- * `DS1301`: a module-level variable, a type member or a class member the counted
- * references store into and never read, named with every position written.
+ * The kinds of declaration that fall with a write-only subject: a declaration of its own.
+ * A member falls with its container, and a type parameter is the type-parameter clause's.
+ */
+const FALLING = new Set([
+    "function",
+    "class",
+    "interface",
+    "type",
+    "enum",
+    "namespace",
+    "variable",
+]);
+const WRITTEN = new WeakMap();
+/**
+ * `DS1301`'s subjects: a module-level variable, a type member or a class member the
+ * counted references store into and never read.
  *
  * The subject is a live declaration: a store is a reference, so the sweep holds a
  * written one live and its candidates are never this kind's. Every reference that is
  * not a store reads, and so does an exemption record naming the declaration.
  */
-function writeOnlySymbols(run) {
+function writtenOf(run) {
+    const known = WRITTEN.get(run.input);
+    if (known !== undefined) {
+        return known;
+    }
     const { stores } = run.input;
-    const { matrix } = run.input.swept;
+    const { matrix, sweep } = run.input.swept;
     const uses = new Map();
     for (const reference of stores.references) {
         let held = uses.get(reference.to);
@@ -122,22 +146,49 @@ function writeOnlySymbols(run) {
             namedBy.set(reference.to, (namedBy.get(reference.to) ?? new Set()).add(reference.from));
         }
     }
-    const found = [];
-    for (const symbol of matrix.union.symbols) {
+    const subjects = matrix.union.symbols.flatMap((symbol) => {
         const held = uses.get(symbol.id);
-        if (held === undefined ||
+        return held === undefined ||
             held.writes.length === 0 ||
             held.reads > 0 ||
             !writable(run, symbol) ||
             stores.exempt.has(symbol.id) ||
-            run.candidates.has(symbol.id)) {
+            run.candidates.has(symbol.id)
+            ? []
+            : [{ symbol, held }];
+    });
+    const subjectIds = new Set(subjects.map((subject) => subject.symbol.id));
+    const classOf = reachabilityClasses(run.input);
+    const named = new Map();
+    const falls = new Set();
+    for (const symbol of matrix.union.symbols) {
+        const chains = sweep.carried.get(symbol.id);
+        if (chains === undefined ||
+            subjectIds.has(symbol.id) ||
+            !FALLING.has(symbol.kind) ||
+            classOf(symbol.id) !== "certain") {
             continue;
         }
-        found.push(findingAbout(symbol, "DS1301", writeOnlyMessage(run, namedBy, symbol, held), {
-            writePositions: held.writes,
-        }));
+        const innermost = chains.map((chain) => chain.find((id) => subjectIds.has(id)));
+        if (innermost.includes(undefined)) {
+            continue;
+        }
+        falls.add(symbol.id);
+        for (const subject of new Set(innermost)) {
+            const name = `${WORDS[symbol.kind]} ${symbol.name}`;
+            named.set(subject ?? "", [...(named.get(subject ?? "") ?? []), name]);
+        }
     }
-    return found;
+    const written = { subjects, namedBy, named, falls };
+    WRITTEN.set(run.input, written);
+    return written;
+}
+/** `DS1301`: each subject, named with every position written and what falls with it. */
+function writeOnlySymbols(run) {
+    const written = writtenOf(run);
+    return written.subjects.map((subject) => findingAbout(subject.symbol, CODE.writeOnlySymbol, writeOnlyMessage(run, written, subject), {
+        writePositions: subject.held.writes,
+    }));
 }
 /**
  * The candidates no reference of any file names whose container is not itself dead, of
@@ -157,23 +208,24 @@ function unnamed(run, kind) {
     });
 }
 /**
- * `DS1302`: a member of an enum declaration that nothing names. A member an enum-group
+ * `DS1005`: a member of an enum declaration that nothing names. A member an enum-group
  * record holds back is no candidate, so a member a conversion can produce never reaches
  * this kind.
  */
 function unusedEnumMembers(run) {
-    return unnamed(run, "enum-member").map((symbol) => findingAbout(symbol, "DS1302", `enum member ${symbol.name} is named nowhere`));
+    return unnamed(run, "enum-member").map((symbol) => findingAbout(symbol, CODE.unusedEnumMember, `enum member ${symbol.name} is named nowhere`));
 }
 /**
- * `DS1303`: a type parameter of a function or a class method that neither the
- * declaration's signature nor its body names. A type parameter of a class, an interface,
- * a type alias or a method signature belongs to a type declaration and is never
- * reported, because a phantom parameter makes two instantiations distinct types.
+ * `DS1006`: a type parameter of a function, a class method or a type alias that neither
+ * the declaration's signature nor its body names. An alias names no type of its own, so
+ * a parameter its type never names makes no two instantiations distinct. One of a class,
+ * an interface or a method signature is never reported: a class or an interface merges
+ * only with declarations of the same parameters.
  */
 function unusedTypeParameters(run) {
     return unnamed(run, "type-parameter")
         .filter((symbol) => SIGNATURES.has(run.symbols.get(symbol.parent)?.kind ?? ""))
-        .map((symbol) => findingAbout(symbol, "DS1303", `type parameter ${symbol.name} is named in neither its signature nor its body`));
+        .map((symbol) => findingAbout(symbol, CODE.unusedTypeParameter, `type parameter ${symbol.name} is named in neither its signature nor its body`));
 }
 /**
  * The keys of the declarations the write-only kind reports, whatever the
@@ -181,11 +233,18 @@ function unusedTypeParameters(run) {
  * supersedes narrowing it.
  */
 export function writeOnlyDeclarations(input) {
-    return new Set(writeOnlySymbols(indexed(input)).map((finding) => declarationKey(finding.symbol.ref, finding.position.path)));
+    return new Set(writtenOf(indexed(input)).subjects.map(({ symbol }) => declarationKey(symbol.ref, symbol.position.path)));
+}
+/**
+ * The declarations that fall with a write-only subject, whatever the severity: a finding
+ * about one would name code its subject's deletion already deletes.
+ */
+export function fallingWithWrites(input) {
+    return writtenOf(indexed(input)).falls;
 }
 /**
- * The findings of the reads-and-writes family, `DS1300` to `DS1399`, in code order and
- * each code's in site order.
+ * The findings of the reads-and-writes kinds, `DS1301`, `DS1005` and `DS1006`, in that
+ * order and each code's in site order.
  */
 export const readsAndWrites = (input) => {
     const run = indexed(input);

package/dist/src/findings/self-check.js

@@ -1,10 +1,8 @@
+import { CODE, REMEDIES } from "../contract/contract.generated.js";
 import { REPOSITORY_DOCUMENT } from "../config.js";
 import { FIXED_SEVERITY_CODES } from "../kinds.js";
-import { isDependencyCode, isUnsuppressibleCode, STALE_SUPPRESSION, SUPPRESSION_WITHOUT_REASON, } from "../suppress.js";
-/** The code a configured root that matches nothing is reported under. */
-const UNMATCHED_ROOT = "DS1704";
-/** The code a configured declaration that names nothing is reported under. */
-const UNMATCHED_DECLARATION = "DS1706";
+import { names, subjectOfCode, } from "../suppress.js";
+import { bytewise } from "../text/compare.js";
 /** The subject kind of a finding about a configured declaration. */
 const DECLARATION_SUBJECT = "configured-declaration";
 /** The subject kind of a finding about a suppression record. */
@@ -26,6 +24,39 @@ export function fileRefsOf(symbols) {
         .map((symbol) => [symbol.position.path, symbol.ref]));
     return (path) => byPath.get(path);
 }
+/**
+ * Why a record of `mechanism` naming `codes` can match nothing, one clause per subject whose
+ * findings kinds.json's remedies table lets no record of that mechanism name, in subject order.
+ */
+function unnameable(codes, mechanism) {
+    return Object.keys(REMEDIES).flatMap((subject) => {
+        const named = codes.filter((code) => subjectOfCode(code) === subject);
+        if (named.length === 0 || names(subject, mechanism)) {
+            return [];
+        }
+        const { names: what, suppressions } = REMEDIES[subject];
+        const reports = `${spelled(named)} ${named.length === 1 ? "reports" : "each report"} ${what}`;
+        if (suppressions.length > 0) {
+            const records = suppressions.map((one) => articled(WRITTEN[one]));
+            return [`${reports}, which only ${spelledOr(records)} can name`];
+        }
+        const settable = named.filter((code) => !FIXED_SEVERITY_CODES.includes(code));
+        const remedy = settable.length === 0
+            ? "fix what the finding names instead"
+            : `fix what the finding names or set the severity of ${spelled(settable)} instead`;
+        return [`${reports}, which no suppression can name; ${remedy}`];
+    });
+}
+/** A record's written name with its indefinite article. */
+function articled(name) {
+    return `${/^[aeiou]/u.test(name) ? "an" : "a"} ${name}`;
+}
+/** A list as a sentence names alternatives. */
+function spelledOr(items) {
+    return items.length < 2
+        ? items.join("")
+        : `${items.slice(0, -1).join(", ")} or ${items.at(-1) ?? ""}`;
+}
 /** A list of codes as a sentence names them. */
 function spelled(codes) {
     if (codes.length < 2) {
@@ -63,7 +94,7 @@ function suppressionRef(symbol, path, files) {
 }
 /** One finding per refused suppression: the grammar's reason refusal and its scope refusal. */
 function refusedSuppressions(refusals, files) {
-    return refusals.map((refused) => aboutSuppression(refused.reported, suppressionRef(refused.symbol, refused.path, files), refused.site, `${WRITTEN[refused.mechanism]} for ${refused.code} ${refused.reported === SUPPRESSION_WITHOUT_REASON
+    return refusals.map((refused) => aboutSuppression(refused.reported, suppressionRef(refused.symbol, refused.path, files), refused.site, `${WRITTEN[refused.mechanism]} for ${refused.code} ${refused.reported === CODE.suppressionWithoutReason
         ? "carries no reason"
         : "names a symbol and no path"}`, { mechanism: refused.mechanism, entry: writtenEntry(refused) }));
 }
@@ -83,36 +114,19 @@ export function staleSuppressions(stale, files) {
         bySite.set(key, held);
     }
     return [...bySite.values()].map(({ first, records }) => {
-        const codes = [...new Set(records.map((one) => one.record.code))].sort();
+        const codes = [...new Set(records.map((one) => one.record.code))].sort(bytewise);
         const reports = [...new Set(records.flatMap((one) => one.reports))]
             .filter((code) => !codes.includes(code))
-            .sort();
-        const rows = codes.filter(isUnsuppressibleCode);
-        const dependencies = first.mechanism === "inline" ? codes.filter(isDependencyCode) : [];
-        const settable = rows.filter((code) => !FIXED_SEVERITY_CODES.includes(code));
-        const remedy = settable.length === 0
-            ? "fix what the finding names instead"
-            : `fix what the finding names or set the severity of ${spelled(settable)} instead`;
+            .sort(bytewise);
         const declared = reports.length === 0 ? "" : `its declaration reports ${spelled(reports)}`;
-        const because = [
-            ...(rows.length > 0
-                ? [
-                    `${spelled(rows)} ${rows.length === 1 ? "reports a row" : "report rows"} of a document, which no suppression can name; ${remedy}`,
-                ]
-                : []),
-            ...(dependencies.length > 0
-                ? [
-                    `${spelled(dependencies)} ${dependencies.length === 1 ? "reports a dependency row" : "report dependency rows"}, which only an ignore entry or a baseline row can name`,
-                ]
-                : []),
-        ];
+        const because = unnameable(codes, first.mechanism);
         const instead = because.length > 0
             ? `, because ${because.join("; ")}${declared === "" ? "" : `; ${declared}`}`
             : declared === ""
                 ? ""
                 : `, and ${declared}`;
         return {
-            code: STALE_SUPPRESSION,
+            code: CODE.staleSuppression,
             mechanism: first.mechanism,
             entry: {
                 code: first.code,
@@ -141,7 +155,7 @@ function documentPosition(document) {
  */
 function unmatchedDeclarationFindings(unmatched) {
     return unmatched.map((one) => ({
-        code: UNMATCHED_DECLARATION,
+        code: CODE.unmatchedConfiguredDeclaration,
         position: documentPosition(one.document),
         symbol: { ref: one.ref, kind: DECLARATION_SUBJECT, name: one.ref, sizeLines: 1 },
         message: `${one.key} entry names no declaration in any project`,
@@ -157,7 +171,7 @@ function unmatchedDeclarationFindings(unmatched) {
 export function unmatchedRootFindings(sources, document) {
     const position = documentPosition(document);
     return sources.map((source) => ({
-        code: UNMATCHED_ROOT,
+        code: CODE.unmatchedRoot,
         position,
         symbol: { ref: source, kind: ROOT_SUBJECT, name: source, sizeLines: 1 },
         message: source.includes("*") || source.includes("?")
@@ -166,7 +180,7 @@ export function unmatchedRootFindings(sources, document) {
     }));
 }
 /**
- * The findings of the self-check family, `DS1700` to `DS1799`: a suppression refused for
+ * The findings of the configuration family, `DS9000` to `DS9099`: a suppression refused for
  * carrying no reason or naming no path, and a configured root or declaration that named
  * nothing. A
  * suppression that matched nothing is a record of the report's stale suppressions, which

package/dist/src/findings/unused-declarations.js

@@ -1,3 +1,5 @@
+import { CODE } from "../contract/contract.generated.js";
+import { WORDS } from "../inventory.js";
 import { unreachableExports } from "./visibility-narrowing.js";
 /** The kinds of declaration that are members of a class, an interface, a type or an enum. */
 const MEMBERS = new Set([
@@ -7,34 +9,16 @@ const MEMBERS = new Set([
     "enum-member",
 ]);
 /**
- * The kinds of declaration no code of this family reports: an interface and a method an
+ * The kinds of declaration no code of this emitter reports: an interface and a method an
  * interface declares are the interface kinds' subjects, and a type parameter is the
  * subject of the unused-type-parameter kind or of none.
  */
-const NOT_THIS_FAMILY = new Set([
+const NOT_REPORTED_HERE = new Set([
     "file",
     "interface",
     "interface-method",
     "type-parameter",
 ]);
-/** The reader's word for each kind of declaration a finding of the family names. */
-const WORDS = {
-    file: "file",
-    function: "function",
-    class: "class",
-    interface: "interface",
-    type: "type alias",
-    enum: "enum",
-    namespace: "namespace",
-    variable: "variable",
-    "export-alias": "re-export",
-    method: "method",
-    "class-member": "class member",
-    "interface-method": "interface method",
-    "type-member": "type member",
-    "enum-member": "enum member",
-    "type-parameter": "type parameter",
-};
 /** What the test-of-dead-code kind says, which states the rule it applies. */
 const TEST_OF_DEAD_CODE = "every target symbol this test references is reported dead";
 /**
@@ -48,9 +32,9 @@ const TEST_OF_DEAD_CODE = "every target symbol this test references is reported
 function codeOf(judged) {
     const { candidate, symbol } = judged;
     if (candidate.testOfDeadCode) {
-        return "DS1005";
+        return CODE.testOfDeadCode;
     }
-    if ((judged.test && !candidate.unreferencedTest) || NOT_THIS_FAMILY.has(symbol.kind)) {
+    if ((judged.test && !candidate.unreferencedTest) || NOT_REPORTED_HERE.has(symbol.kind)) {
         return undefined;
     }
     const referenced = candidate.productionRefs + candidate.testRefs > 0;
@@ -61,30 +45,30 @@ function codeOf(judged) {
         return unreferencedCode(symbol);
     }
     if (candidate.heldByTests === candidate.id) {
-        return "DS1004";
+        return CODE.testOnlyUse;
     }
     if (candidate.productionRefs === 0 && judged.deprecated) {
-        return "DS1006";
+        return CODE.deprecatedUnused;
     }
     if (candidate.testRefs > 0 &&
         (candidate.productionRefs === 0 ||
             (candidate.relation === "reachability" && candidate.keptByTests))) {
-        return "DS1004";
+        return CODE.testOnlyUse;
     }
     if (MEMBERS.has(symbol.kind)) {
-        return "DS1003";
+        return CODE.unusedMember;
     }
     if (!symbol.exported) {
-        return "DS1002";
+        return CODE.unusedUnexported;
     }
-    return judged.unreachable ? undefined : "DS1001";
+    return judged.unreachable ? undefined : CODE.unusedExported;
 }
 /** The code a declaration nothing references carries, by its shape and its visibility. */
 function unreferencedCode(symbol) {
     if (MEMBERS.has(symbol.kind)) {
-        return "DS1003";
+        return CODE.unusedMember;
     }
-    return symbol.exported ? "DS1001" : "DS1002";
+    return symbol.exported ? CODE.unusedExported : CODE.unusedUnexported;
 }
 /** The visibility a member's message names, where it narrows the member's reach. */
 function visibilityWord(symbol) {
@@ -107,16 +91,16 @@ function messageOf(code, judged) {
     const { candidate, symbol } = judged;
     const word = WORDS[symbol.kind];
     switch (code) {
-        case "DS1005":
+        case CODE.testOfDeadCode:
             return TEST_OF_DEAD_CODE;
-        case "DS1006":
+        case CODE.deprecatedUnused:
             return `deprecated ${word} has no production reference`;
-        case "DS1004":
+        case CODE.testOnlyUse:
             return candidate.productionRefs === 0
                 ? `${word} is referenced only from test files and never from production code`
                 : `${word} is referenced only from test files and from declarations that are themselves dead`;
     }
-    const subject = code === "DS1003"
+    const subject = code === CODE.unusedMember
         ? `${visibilityWord(symbol)}${word}`
         : symbol.kind === "export-alias"
             ? word
@@ -124,7 +108,7 @@ function messageOf(code, judged) {
     if (candidate.relation === "reachability") {
         return `${subject} is referenced only from declarations that are themselves dead`;
     }
-    if (code === "DS1001") {
+    if (code === CODE.unusedExported) {
         return `${subject} has no reference in the target and none from any loaded consumer`;
     }
     return `${subject} has no reference in the target`;
@@ -166,22 +150,22 @@ function brandMembers(input) {
 }
 /** The kinds of member a brand is: a data member of a type or of a class. */
 const BRANDS = new Set(["type-member", "class-member"]);
-/** The findings of the unused-declarations family, `DS1000` to `DS1099`. */
+/** The findings of the unused-declaration kinds, `DS1001` to `DS1004` and `DS1102` to `DS1104`. */
 export const unusedDeclarations = (input) => [
-    ...familyFindings(input, false),
+    ...emitterFindings(input, false),
     ...unusedImports(input),
 ];
 /**
- * The import bindings their file never reads, under the unexported code. A generated
- * file's are the generator's to remove unless the run includes generated files.
+ * The import bindings their file never reads. A generated file's are the generator's to
+ * remove unless the run includes generated files.
  */
 function unusedImports(input) {
-    const generated = input.config.analysis.generatedFiles === "include" ? undefined : input.files.generated;
+    const generated = input.config.analysis.generated_files === "include" ? undefined : input.files.generated;
     return input.intraFunction.imports.flatMap((binding) => binding.used || generated?.has(binding.position.path) === true
         ? []
         : [
             {
-                code: "DS1002",
+                code: CODE.unusedImport,
                 position: binding.position,
                 symbol: { ref: binding.ref, kind: "import", name: binding.name, sizeLines: 1 },
                 message: `import binding ${binding.name} is never read in its file`,
@@ -193,9 +177,9 @@ function unusedImports(input) {
  * a record on such a member is matched against, since the report carries the container's
  * finding rather than one of the member's own.
  */
-export const fallenMembers = (input) => familyFindings(input, true);
-/** The family's findings, or, where `fallen` is set, its dead containers' members' alone. */
-function familyFindings(input, fallen) {
+export const fallenMembers = (input) => emitterFindings(input, true);
+/** This emitter's findings, or, where `fallen` is set, its dead containers' members' alone. */
+function emitterFindings(input, fallen) {
     const union = input.swept.matrix.union;
     const dead = new Set(input.swept.sweep.candidates.map((candidate) => candidate.id));
     const unreachable = unreachableExports(input);
@@ -220,7 +204,7 @@ function familyFindings(input, fallen) {
         };
         const code = codeOf(judged);
         if (code === undefined ||
-            (code === "DS1003" && (brands ??= brandMembers(input)).has(symbol.id))) {
+            (code === CODE.unusedMember && (brands ??= brandMembers(input)).has(symbol.id))) {
             continue;
         }
         const endLine = Math.max(symbol.position.line, symbol.endLine);

package/dist/src/findings/visibility-narrowing.js

@@ -1,27 +1,16 @@
-import { OUTSIDE } from "../graph.js";
+import { CODE } from "../contract/contract.generated.js";
+import { OUTSIDE } from "../liveness/graph.js";
+import { WORDS } from "../inventory.js";
 import { declarationKey } from "../ref.js";
-import { runnerCalls } from "../sweep.js";
+import { runnerCalls } from "../liveness/sweep.js";
+import { exposedTypes, exposes } from "../exposure.js";
 import { writeOnlyDeclarations } from "./reads-and-writes.js";
-const UNNECESSARY_EXPORT = "DS1101";
-const UNREACHABLE_EXPORT = "DS1103";
-const REDUNDANT_EXPORT_KEYWORD = "DS1104";
 /**
  * The root kinds by which a consumer importing the package reaches a declaration. A
  * declaration or a file rooted by any other kind is entered by something that names it
  * from outside the reference graph: a runtime, a tool, a framework or the configuration.
  */
 const PUBLISHING = new Set(["manifest-entry", "published-api"]);
-/** The reader's word for each kind of declaration this family reports. */
-const WORDS = {
-    function: "function",
-    class: "class",
-    interface: "interface",
-    type: "type alias",
-    enum: "enum",
-    namespace: "namespace",
-    variable: "variable",
-    "export-alias": "re-export",
-};
 function publishes(kinds) {
     return [...(kinds ?? [])].some((kind) => PUBLISHING.has(kind));
 }
@@ -104,13 +93,10 @@ function topLevelExport(facts, at, symbol) {
     const parent = facts.graph.parent[at] ?? OUTSIDE;
     return symbol.exported && parent !== OUTSIDE && facts.graph.symbols[parent]?.kind === "file";
 }
-function wordOf(symbol) {
-    return WORDS[symbol.kind] ?? symbol.kind;
-}
 /** The visibility each narrowing code names, which only the narrowing codes carry. */
 const NARROWER = {
-    [REDUNDANT_EXPORT_KEYWORD]: "file",
-    [UNNECESSARY_EXPORT]: "package",
+    [CODE.redundantExportKeyword]: "file",
+    [CODE.unnecessaryExport]: "package",
 };
 function findingOf(symbol, code, message) {
     const { path, line, column } = symbol.position;
@@ -147,18 +133,18 @@ function narrowing(facts, at, symbol, world) {
         (facts.named[at] ?? 0) === 0) {
         return undefined;
     }
-    const word = wordOf(symbol);
+    const word = WORDS[symbol.kind];
     switch (facts.reach[at]) {
         case "file":
             if (facts.published[file] === true && !closed) {
                 return undefined;
             }
-            return findingOf(symbol, REDUNDANT_EXPORT_KEYWORD, `exported ${word} is referenced only inside the file that declares it`);
+            return findingOf(symbol, CODE.redundantExportKeyword, `exported ${word} is referenced only inside the file that declares it`);
         case "package":
-            if (!closed || !publishes(facts.rootedBy[at])) {
+            if (!closed || !publishes(facts.rootedBy[at]) || exposes(world.exposed, symbol)) {
                 return undefined;
             }
-            return findingOf(symbol, UNNECESSARY_EXPORT, `exported ${word} is referenced only inside the package that declares it`);
+            return findingOf(symbol, CODE.unnecessaryExport, `exported ${word} is referenced only inside the package that declares it`);
         default:
             return undefined;
     }
@@ -183,10 +169,10 @@ function unreachable(facts, at, symbol, candidate, input) {
     const found = candidate.relation === "reachability"
         ? "is referenced only from declarations that are themselves dead"
         : "has no reference in the target";
-    return findingOf(symbol, UNREACHABLE_EXPORT, `exported ${wordOf(symbol)} ${found}, and nothing outside can import the file that declares it`);
+    return findingOf(symbol, CODE.unreachableExport, `exported ${WORDS[symbol.kind]} ${found}, and nothing outside can import the file that declares it`);
 }
 /**
- * The visibility-narrowing family over one run: `DS1101`, `DS1103` and `DS1104`. A finding
+ * The visibility-narrowing kinds over one run: `DS1501`, `DS1101` and `DS1503`. A finding
  * about a symbol a declared cross-language edge names is reported here like any other, and
  * the edge's evaluation then holds it pending, because the edge stands for a reference from
  * outside the file and the package whose use is decided in the other language. A
@@ -195,10 +181,16 @@ function unreachable(facts, at, symbol, candidate, input) {
 export function narrowings(input) {
     const facts = factsOf(input.swept.matrix.union);
     const { declared, loaded } = input.boundary.consumers;
-    const closed = input.config.consumersComplete && declared.every((id) => loaded.includes(id));
-    const world = { closed, writeOnly: writeOnlyDeclarations(input) };
+    const closed = input.config.consumers.complete && declared.every((id) => loaded.includes(id));
+    const world = {
+        closed,
+        writeOnly: writeOnlyDeclarations(input),
+        exposed: closed
+            ? exposedTypes(facts.graph, facts.reach.map((reach) => reach === "outside"), input.boundary.carriers)
+            : new Set(),
+    };
     const candidates = new Map(input.swept.sweep.candidates.map((candidate) => [candidate.id, candidate]));
-    const generated = input.config.analysis.generatedFiles === "include" ? undefined : input.files.generated;
+    const generated = input.config.analysis.generated_files === "include" ? undefined : input.files.generated;
     const findings = [];
     facts.graph.symbols.forEach((symbol, at) => {
         if (generated?.has(symbol.position.path) === true) {
@@ -234,5 +226,5 @@ export function unreachableExports(input) {
     }
     return found;
 }
-/** The findings of the visibility-narrowing family, `DS1100` to `DS1199`. */
+/** The findings of the visibility-narrowing kinds, `DS1501`, `DS1101` and `DS1503`. */
 export const visibilityNarrowing = narrowings;