@cplieger/deadset-ts 8.0.0-dev.5 → 8.0.0-dev.6

package/src/suppress.ts

@@ -7,6 +7,12 @@
  * withholds every such finding anyway, and stale otherwise.
  */
 
+import {
+  type CODE,
+  KIND_ROWS,
+  SYMBOL_SUBJECTS,
+  type Subject,
+} from "./contract/contract.generated.ts";
 import { ConfigError } from "./config.ts";
 import type { Finding } from "./finding.ts";
 import { positionKey, type Position } from "./position.ts";
@@ -15,15 +21,6 @@ import { isRef } from "./ref.ts";
 /** Which document a suppression is written in, spelled as a finding carries it. */
 export type Mechanism = "inline" | "ignore" | "baseline";
 
-/** The code a suppression that carries no reason is reported under. */
-export const SUPPRESSION_WITHOUT_REASON = "DS1701";
-
-/** The code an ignore entry or a baseline row that names no path is reported under. */
-export const UNSCOPED_ENTRY = "DS1702";
-
-/** The code a suppression that withholds nothing is reported under. */
-export const STALE_SUPPRESSION = "DS1703";
-
 /**
  * One suppression record: one code bound to one site. A directive naming two codes is two
  * records with one reason, and a directive above a line that declares two symbols is one
@@ -49,7 +46,7 @@ export interface SuppressionRecord {
  * nothing, and its finding reports the suppression as written.
  */
 export interface Refusal {
-  readonly reported: typeof SUPPRESSION_WITHOUT_REASON | typeof UNSCOPED_ENTRY;
+  readonly reported: typeof CODE.suppressionWithoutReason | typeof CODE.unscopedIgnoreEntry;
   readonly code: string;
   /** The reference the entry names, empty for a directive. */
   readonly symbol: string;
@@ -158,48 +155,48 @@ export interface Ledger {
   readonly withheld: (finding: Finding) => boolean;
 }
 
-/**
- * The subject kinds that are a dependency row, each with the code that reports one. An
- * ignore entry or a baseline row naming the row's reference and file withholds its finding
- * and marks nothing, and an inline directive never binds one.
- */
-const DEPENDENCY_SUBJECTS: ReadonlyMap<string, readonly string[]> = new Map([
-  ["dependency", ["DS1601"]],
-  ["module-directive", ["DS1605"]],
-]);
+/** The subject of the kind each live code names. */
+const SUBJECT_OF_CODE: ReadonlyMap<string, Subject> = new Map(
+  KIND_ROWS.map((row): [string, Subject] => [row.code, row.subject]),
+);
+
+/** The subject a finding about one symbol kind is about. */
+function subjectOf(kind: string): Subject | undefined {
+  return Object.hasOwn(SYMBOL_SUBJECTS, kind)
+    ? SYMBOL_SUBJECTS[kind as keyof typeof SYMBOL_SUBJECTS]
+    : undefined;
+}
+
+/** Whether a subject is a row of a document rather than a declaration of the program. */
+function rowOf(subject: Subject | undefined): boolean {
+  return subject === "file" || subject === "dependency" || subject === "record";
+}
 
 /**
- * The subject kinds that are a row of a document rather than a declaration of the program,
- * each with the codes that report one. Apart from a dependency row, nothing withholds a
- * finding about one.
+ * Whether a finding's subject is a row of a document rather than a declaration. Apart
+ * from a dependency row, nothing withholds a finding about one.
  */
-const ROW_SUBJECTS: ReadonlyMap<string, readonly string[]> = new Map([
-  ["file", ["DS1501", "DS1502"]],
-  ...DEPENDENCY_SUBJECTS,
-  ["root", ["DS1704"]],
-  ["configured-declaration", ["DS1706"]],
-  ["suppression", ["DS1701", "DS1702", "DS1703"]],
-  ["edge", ["DS1705"]],
-]);
-
-/** Whether a finding's subject is a row of a document rather than a declaration. */
 export function isRowSubject(kind: string): boolean {
-  return ROW_SUBJECTS.has(kind);
+  return rowOf(subjectOf(kind));
 }
 
 /** Whether a code reports a row of a document. */
 export function isRowCode(code: string): boolean {
-  return [...ROW_SUBJECTS.values()].some((codes) => codes.includes(code));
+  return rowOf(SUBJECT_OF_CODE.get(code));
 }
 
-/** Whether a finding's subject is a dependency row. */
+/**
+ * Whether a finding's subject is a dependency row. An ignore entry or a baseline row
+ * naming the row's reference and file withholds its finding and marks nothing, and an
+ * inline directive never binds one.
+ */
 export function isDependencySubject(kind: string): boolean {
-  return DEPENDENCY_SUBJECTS.has(kind);
+  return subjectOf(kind) === "dependency";
 }
 
 /** Whether a code reports a dependency row, which only an ignore entry or a baseline row names. */
 export function isDependencyCode(code: string): boolean {
-  return [...DEPENDENCY_SUBJECTS.values()].some((codes) => codes.includes(code));
+  return SUBJECT_OF_CODE.get(code) === "dependency";
 }
 
 /** Whether a code reports a row of a document that no record of any mechanism can name. */
@@ -208,33 +205,20 @@ export function isUnsuppressibleCode(code: string): boolean {
 }
 
 /**
- * The subject kinds that are a part of a declaration rather than a declaration: a part
+ * Whether a finding's subject is a part of the declaration its reference names: a part
  * has no reference of its own, so a finding about one names the declaration that holds
  * it, and the part is decided inside that declaration whatever uses it.
  */
-const PART_SUBJECTS: ReadonlySet<string> = new Set([
-  "parameter",
-  "receiver",
-  "result",
-  "statement",
-  "case",
-  "store",
-]);
-
-/** Whether a finding's subject is a part of the declaration its reference names. */
 export function isPartSubject(kind: string): boolean {
-  return PART_SUBJECTS.has(kind);
+  return subjectOf(kind) === "part";
 }
 
-/** The prefix of the codes of the part kinds, the intra-function range. */
-const PART_KIND_PREFIX = "DS18";
-
 /**
  * Whether a code is a part kind, whose record withholds its finding and marks nothing:
  * the record says the part is wanted, not that the declaration holding it is.
  */
 export function isPartKind(code: string): boolean {
-  return code.startsWith(PART_KIND_PREFIX);
+  return SUBJECT_OF_CODE.get(code) === "part";
 }
 
 /** One finding's identity: its code and the position of the thing it names. */
@@ -254,14 +238,14 @@ export function pairs(record: SuppressionRecord, finding: Finding): boolean {
   if (record.code !== finding.code) {
     return false;
   }
-  if (DEPENDENCY_SUBJECTS.has(finding.symbol.kind)) {
+  if (isDependencySubject(finding.symbol.kind)) {
     return (
       record.mechanism !== "inline" &&
       record.symbol === finding.symbol.ref &&
       record.path === finding.position.path
     );
   }
-  if (ROW_SUBJECTS.has(finding.symbol.kind)) {
+  if (isRowSubject(finding.symbol.kind)) {
     return false;
   }
   if (record.bound !== "" && record.bound === positionKey(finding.position)) {

package/src/verbs/analyze.ts

@@ -1,3 +1,9 @@
+import {
+  CONTRACT_VERSION,
+  EXIT_CLEAN,
+  EXIT_FAILURE,
+  type Format,
+} from "../contract/contract.generated.ts";
 import {
   runAnalysis,
   runBaselineWrite,
@@ -6,7 +12,7 @@ import {
   type RunAnalysis,
   type RunProject,
 } from "../analysis.ts";
-import { ConfigError, kindOf, type Format } from "../config.ts";
+import { ConfigError, kindOf } from "../config.ts";
 import { CONFORMANCE, DECLARED_GAPS } from "../conformance.ts";
 import { moduleIdentity } from "../consumers.ts";
 import { analyzerProvenance, verdictOf } from "../findings-pass.ts";
@@ -20,19 +26,19 @@ import {
   LANGUAGE,
   capFindings,
   sortFindings,
-  type Report,
   type ReportConfiguration,
   type ReportNotBuilt,
   type ReportNote,
 } from "../report.ts";
+import type { Report } from "../contract/report.generated.ts";
+import { reportRefusals } from "../report-schema.ts";
 import { json } from "../reporters/json.ts";
 import { RENDERINGS } from "../reporters/reporters.ts";
 import { parseTemplate, TemplateError, type Template } from "../reporters/template.ts";
 import { resolve } from "../resolve.ts";
 import { otherSchemeRows, rowReason, writeBaseline, type Recorded } from "../suppress-file.ts";
 import type { UnseenLoad } from "../unseen-loads.ts";
-import { CONTRACT_VERSION } from "../version.ts";
-import { EXIT_CLEAN, EXIT_FAILURE, type Verb, type VerbOptions } from "./verb.ts";
+import { type Verb, type VerbOptions } from "./verb.ts";
 
 /** The options `analyze` takes beside the ones every verb takes. */
 export const ANALYZE_OPTIONS: VerbOptions = {
@@ -348,6 +354,12 @@ export const analyzeVerb: Verb = ({ err, host, inputs, scope, openClient, option
   }
 
   try {
+    const [refused] = reportRefusals(report);
+    if (refused !== undefined) {
+      throw new Error(
+        `the report breaks the report schema at ${refused.pointer || "the document"}: ${refused.keyword}: ${refused.reason}`,
+      );
+    }
     host.writeDocument(documents.report, json(report));
     const options = {
       readSource: (path: string) => host.readFile(joinPath(targetRoot, path)),

package/src/verbs/describe.ts

@@ -1,7 +1,13 @@
+import {
+  CONTRACT_VERSION,
+  EXIT_CLEAN,
+  EXIT_FAILURE,
+  EXIT_USAGE,
+  SCHEMA_VERSIONS,
+} from "../contract/contract.generated.ts";
 import { CONFORMANCE, type Conformance } from "../conformance.ts";
-import { ANALYZER_NAME, LANGUAGE, SCHEMA_VERSIONS_ACCEPTED } from "../report.ts";
-import { CONTRACT_VERSION } from "../version.ts";
-import { EXIT_CLEAN, EXIT_FAILURE, EXIT_USAGE, type Verb } from "./verb.ts";
+import { ANALYZER_NAME, LANGUAGE } from "../report.ts";
+import { type Verb } from "./verb.ts";
 
 /**
  * The document `describe` writes: the analyzer, the Contract version it implements, the
@@ -13,7 +19,7 @@ export function describeDocument(version: string, recorded: Conformance | undefi
     name: ANALYZER_NAME,
     version,
     contract_version: CONTRACT_VERSION,
-    schema_versions_accepted: SCHEMA_VERSIONS_ACCEPTED,
+    schema_versions_accepted: SCHEMA_VERSIONS,
     languages: [LANGUAGE],
     ...(recorded === undefined
       ? {}

package/src/verbs/explain.ts

@@ -1,3 +1,4 @@
+import { EXIT_CLEAN, EXIT_USAGE } from "../contract/contract.generated.ts";
 import { runAnalysis, type RunAnalysis } from "../analysis.ts";
 import { listing } from "../components.ts";
 import type { Cascade } from "../config.ts";
@@ -12,7 +13,7 @@ import { positionKey } from "../position.ts";
 import type { Reference } from "../references.ts";
 import { resolve } from "../resolve.ts";
 import type { Root } from "../roots.ts";
-import { EXIT_CLEAN, EXIT_USAGE, type Verb, type VerbOptions } from "./verb.ts";
+import { type Verb, type VerbOptions } from "./verb.ts";
 
 /**
  * The three spellings of an explanation request, each naming the symbol to explain. They are

package/src/verbs/print-config.ts

@@ -1,6 +1,7 @@
+import { EXIT_CLEAN } from "../contract/contract.generated.ts";
 import { printConfig } from "../print.ts";
 import { resolve } from "../resolve.ts";
-import { EXIT_CLEAN, type Verb } from "./verb.ts";
+import { type Verb } from "./verb.ts";
 
 /** Writes the resolved configuration with the source of every setting. */
 export const printConfigVerb: Verb = ({ out, inputs }) => {

package/src/verbs/print-projects.ts

@@ -1,8 +1,9 @@
+import { EXIT_CLEAN } from "../contract/contract.generated.ts";
 import { runProjects } from "../analysis.ts";
 import { partialNotes } from "../partial.ts";
 import { resolvePath } from "../paths.ts";
 import { resolveUnkinded } from "../resolve.ts";
-import { EXIT_CLEAN, type Verb } from "./verb.ts";
+import { type Verb } from "./verb.ts";
 
 /**
  * Writes the name of every project one run analyzes, one per line: the identifier the

package/src/verbs/print-retained.ts

@@ -1,9 +1,10 @@
+import { EXIT_CLEAN } from "../contract/contract.generated.ts";
 import { runSweep } from "../analysis.ts";
 import { retainedLines } from "../exempt.ts";
 import { partialNotes } from "../partial.ts";
 import { resolvePath } from "../paths.ts";
 import { resolve } from "../resolve.ts";
-import { EXIT_CLEAN, type Verb } from "./verb.ts";
+import { type Verb } from "./verb.ts";
 
 /**
  * Writes every declaration an exemption held back in the production sweep a report is

package/src/verbs/print-roots.ts

@@ -1,8 +1,9 @@
+import { EXIT_CLEAN, EXIT_FINDINGS } from "../contract/contract.generated.ts";
 import { runRoots, type RunRoot } from "../analysis.ts";
 import { partialNotes } from "../partial.ts";
 import { resolvePath } from "../paths.ts";
 import { resolve } from "../resolve.ts";
-import { EXIT_CLEAN, EXIT_FINDINGS, type Verb } from "./verb.ts";
+import { type Verb } from "./verb.ts";
 
 /**
  * One root as a line: the declaration's reference, why it is a root, and the string

package/src/verbs/verb.ts

@@ -4,12 +4,6 @@ import type { Writer } from "../run.ts";
 import type { Scope } from "../scope.ts";
 import type { Engine } from "../session.ts";
 
-/** The exit codes the Contract's exit-code table names. */
-export const EXIT_CLEAN = 0;
-export const EXIT_FINDINGS = 1;
-export const EXIT_USAGE = 2;
-export const EXIT_FAILURE = 3;
-
 /**
  * What one verb is handed: the streams it writes, the platform it reads, and the
  * options that follow its name, read only when the verb asks for what they name, so

package/src/verbs/version.ts

@@ -1,5 +1,5 @@
-import { CONTRACT_VERSION } from "../version.ts";
-import { EXIT_CLEAN, type Verb } from "./verb.ts";
+import { CONTRACT_VERSION, EXIT_CLEAN } from "../contract/contract.generated.ts";
+import { type Verb } from "./verb.ts";
 
 /** Writes the version the host reports and the Contract version this analyzer implements. */
 export const versionVerb: Verb = ({ out, host }) => {

package/dist/src/version.js

@@ -1,7 +0,0 @@
-/**
- * The Contract version this analyzer implements. It is the resolved value of
- * `contract_version` when no configuration source supplies one, and it moves
- * 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 = "8.0.0";

package/src/version.ts

@@ -1,7 +0,0 @@
-/**
- * The Contract version this analyzer implements. It is the resolved value of
- * `contract_version` when no configuration source supplies one, and it moves
- * 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 = "8.0.0";