@cplieger/deadset-ts 3.6.0 → 3.8.0

package/dist/src/kinds.js

@@ -1,52 +1,54 @@
 /**
- * The issue-kind codes whose severity the Contract fixes. A severity key naming
- * one, or a family prefix whose range holds one, is an unimplemented key rather
- * than a setting.
- *
- * The codes are written out rather than read from the Contract at run time: the
- * Contract is data a reader outside this program consults, and a product that
- * read it while running would need it installed beside itself. A test compares
- * this list against the Contract release the analyzer is written against, so a
- * code the Contract fixes arrives here as a failing test.
+ * Every live row of the issue-kind vocabulary, in ascending code order, written out
+ * rather than read at run time, because a product that read the Contract while running
+ * would need it installed beside itself. A test compares this table against the
+ * Contract release the analyzer is written against.
  */
-export const FIXED_SEVERITY_CODES = ["DS1703", "DS1704"];
+const ROWS = [
+    row("DS1001", "unused-exported", "deny", "deletable"),
+    row("DS1002", "unused-unexported", "deny", "deletable"),
+    row("DS1003", "unused-member", "deny", "deletable"),
+    row("DS1004", "test-only-use", "deny", "deletable"),
+    row("DS1005", "test-of-dead-code", "deny", "deletable"),
+    row("DS1006", "deprecated-unused", "deny", "deletable"),
+    row("DS1101", "unnecessary-export", "warn", "narrowable"),
+    row("DS1102", "unnecessary-exposure", "warn", "narrowable"),
+    row("DS1103", "unreachable-export", "deny", "deletable"),
+    row("DS1104", "redundant-export-keyword", "warn", "narrowable"),
+    row("DS1201", "unused-interface", "deny", "deletable"),
+    row("DS1203", "uncalled-interface-method", "warn", "manual"),
+    row("DS1204", "unused-satisfaction-assertion", "deny", "deletable"),
+    row("DS1301", "write-only-symbol", "deny", "deletable"),
+    row("DS1302", "unused-enum-member", "deny", "deletable"),
+    row("DS1303", "unused-type-parameter", "deny", "deletable"),
+    row("DS1501", "file-never-built", "deny", "deletable"),
+    row("DS1502", "file-never-imported", "deny", "deletable"),
+    row("DS1601", "unused-dependency", "deny", "manual"),
+    row("DS1605", "unused-module-directive", "warn", "deletable"),
+    row("DS1701", "suppression-without-reason", "deny", "none"),
+    row("DS1702", "unscoped-ignore-entry", "deny", "none"),
+    { ...row("DS1703", "stale-suppression", "deny", "none"), fixed: true },
+    { ...row("DS1704", "unmatched-root", "deny", "none"), fixed: true },
+    row("DS1705", "stale-cross-language-edge", "deny", "none"),
+    row("DS1801", "unused-parameter", "warn", "manual"),
+    row("DS1802", "unused-receiver", "warn", "deletable"),
+    row("DS1803", "unused-result", "warn", "manual"),
+    row("DS1805", "unreachable-statement", "deny", "deletable"),
+    row("DS1807", "dead-store", "deny", "deletable"),
+    row("DS1809", "unreachable-case", "deny", "deletable"),
+];
+/** A row at the `certain` ceiling whose severity a configuration may set. */
+function row(code, name, defaultSeverity, fixability) {
+    return { code, name, defaultSeverity, maxClass: "certain", fixability, fixed: false };
+}
+/** Every live row of the issue-kind vocabulary, by its code, in ascending code order. */
+export const KINDS = new Map(ROWS.map((one) => [one.code, one]));
 /**
  * The code of every live issue kind, in ascending order. A severity key names one of
  * them or a family prefix whose range holds one; a key naming a retired code, an
  * unassigned code or a range holding no live kind is an unimplemented key, so every
- * severity a configuration sets is one some analyzer reports under. A test compares
- * this list against the Contract release the analyzer is written against.
+ * severity a configuration sets is one some analyzer reports under.
  */
-export const LIVE_CODES = [
-    "DS1001",
-    "DS1002",
-    "DS1003",
-    "DS1004",
-    "DS1005",
-    "DS1006",
-    "DS1101",
-    "DS1102",
-    "DS1103",
-    "DS1104",
-    "DS1201",
-    "DS1203",
-    "DS1204",
-    "DS1301",
-    "DS1302",
-    "DS1303",
-    "DS1501",
-    "DS1502",
-    "DS1601",
-    "DS1605",
-    "DS1701",
-    "DS1702",
-    "DS1703",
-    "DS1704",
-    "DS1705",
-    "DS1801",
-    "DS1802",
-    "DS1803",
-    "DS1805",
-    "DS1807",
-    "DS1809",
-];
+export const LIVE_CODES = ROWS.map((one) => one.code);
+/** The issue-kind codes whose severity the Contract fixes, in ascending order. */
+export const FIXED_SEVERITY_CODES = ROWS.filter((one) => one.fixed).map((one) => one.code);

package/dist/src/roots.js

@@ -9,18 +9,11 @@
  * candidate under reference counting.
  */
 import { aliasChains } from "./alias-chain.js";
-import { REPOSITORY_DOCUMENT } from "./config.js";
 import { entryPoints } from "./entry-points.js";
 import { globExpression } from "./glob.js";
 import { nodeKey } from "./inventory.js";
 import { byPosition } from "./position.js";
 import { sourceFilesOf } from "./source-files.js";
-/** The code the Contract gives a configured root that matches nothing. */
-const UNMATCHED_ROOT_CODE = "DS1704";
-/** The subject kind a finding under that code carries, from the Contract's vocabulary. */
-const UNMATCHED_ROOT_SUBJECT = "root";
-/** The fixed position of a finding about a document rather than about a line of one. */
-const DOCUMENT_POSITION = 1;
 /** Whether a configured string carries either special character. */
 function isPattern(text) {
     return text.includes("*") || text.includes("?");
@@ -293,30 +286,3 @@ function configured(held, patterns, add) {
 export function unmatchedEverywhere(patterns, perProject) {
     return [...new Set(patterns)].filter((pattern) => perProject.every((project) => project.unmatched.includes(pattern)));
 }
-/**
- * The findings a run reports for the configured strings that named nothing.
- *
- * `document` is the path of the document that declared the roots, below the target
- * root; where the run read them from no document of the target it is empty and the
- * finding names the conventional repository configuration, which is the document a
- * maintainer writes a configured root in. Every finding of one run sits at that
- * document's first position: the roots are written as an array whose members carry
- * no line of their own, so the string each finding names is what tells one from
- * another.
- */
-export function unmatchedRoots(sources, document) {
-    const position = {
-        path: document === "" ? REPOSITORY_DOCUMENT : document,
-        line: DOCUMENT_POSITION,
-        column: DOCUMENT_POSITION,
-        endLine: DOCUMENT_POSITION,
-    };
-    return sources.map((source) => ({
-        code: UNMATCHED_ROOT_CODE,
-        position,
-        symbol: { ref: source, kind: UNMATCHED_ROOT_SUBJECT, name: source, sizeLines: 1 },
-        message: isPattern(source)
-            ? "configured root pattern matches no symbol of the inventory"
-            : "configured root matches no symbol of the inventory",
-    }));
-}

package/dist/src/suppress-file.js

@@ -0,0 +1,196 @@
+/**
+ * The two file-backed suppression documents at the target root: the ignore file, whose
+ * entries a maintainer writes, and the baseline, whose rows an analyzer writes. They share
+ * one record shape, so one decoder and one matcher serve both, and a row moves into the
+ * ignore file by gaining a maintainer's reason.
+ */
+import { joinPath } from "./paths.js";
+import { positionAt, walkDocument } from "./json-document.js";
+import { CODE_FORM, SUPPRESSION_WITHOUT_REASON, SuppressionError, UNSCOPED_ENTRY, blankReason, isEntryPath, isSymbolRef, siteText, } from "./suppress.js";
+/** The name and the location the grammar fixes for the ignore file. */
+export const IGNORE_FILE = "deadset-ignore.json";
+/** The name and the location the grammar fixes for the baseline. */
+export const BASELINE_FILE = "deadset-baseline.json";
+const IGNORE_SHAPE = {
+    file: IGNORE_FILE,
+    array: "ignore",
+    mechanism: "ignore",
+    documentWant: "an object carrying the ignore array, and an optional description",
+    recordWant: "an entry naming code, symbol, path and reason, each a string",
+};
+const BASELINE_SHAPE = {
+    file: BASELINE_FILE,
+    array: "baseline",
+    mechanism: "baseline",
+    documentWant: "an object carrying the baseline array, and an optional description",
+    recordWant: "a row naming code, symbol, path and reason, each a string",
+};
+/** The closed key list of one entry or row. */
+const RECORD_KEYS = new Set(["code", "symbol", "path", "reason"]);
+const CODE_WANT = "DS followed by four digits";
+const SYMBOL_WANT = "a stable symbol reference, go://<import-path>#<fragment> or ts://<package>/<source-path>#<fragment>";
+const PATH_WANT = "a path relative to the target root, with the solidus as separator";
+/** The document itself, for a defect no record position describes. */
+function documentSite(shape) {
+    return { path: shape.file, line: 0, column: 0 };
+}
+function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function referenceKey(ref, path) {
+    return `${ref}\u0000${path}`;
+}
+/**
+ * Reads one entry or row: the records it binds, the refusals it carries, or the
+ * malformed value that ends the run.
+ */
+function readRecord(value, site, byReference, shape) {
+    const refuse = (text, want) => {
+        throw new SuppressionError(shape.mechanism, `${shape.file} ${siteText(site)}`, text, want);
+    };
+    if (!isObject(value)) {
+        return refuse(JSON.stringify(value), shape.recordWant);
+    }
+    for (const [key, held] of Object.entries(value)) {
+        if (!RECORD_KEYS.has(key)) {
+            refuse(`the member ${JSON.stringify(key)} is not one the grammar declares`, shape.recordWant);
+        }
+        if (typeof held !== "string") {
+            refuse(`the member ${JSON.stringify(key)} holds ${JSON.stringify(held)}`, shape.recordWant);
+        }
+    }
+    const entry = value;
+    const { code, symbol, path, reason } = {
+        code: entry["code"],
+        symbol: entry["symbol"],
+        path: entry["path"],
+        reason: entry["reason"],
+    };
+    if (code === undefined) {
+        return refuse("a record naming no code", shape.recordWant);
+    }
+    if (symbol === undefined) {
+        return refuse("a record naming no symbol", shape.recordWant);
+    }
+    if (!CODE_FORM.test(code)) {
+        return refuse(JSON.stringify(code), CODE_WANT);
+    }
+    if (!isSymbolRef(symbol)) {
+        return refuse(JSON.stringify(symbol), SYMBOL_WANT);
+    }
+    if (path !== undefined && path !== "" && !isEntryPath(path)) {
+        return refuse(JSON.stringify(path), PATH_WANT);
+    }
+    const written = {
+        code,
+        symbol,
+        path: path ?? "",
+        reason: reason ?? "",
+        site,
+        mechanism: shape.mechanism,
+    };
+    const refusals = [];
+    if (blankReason(reason)) {
+        refusals.push({ ...written, reported: SUPPRESSION_WITHOUT_REASON });
+    }
+    if (written.path === "") {
+        refusals.push({ ...written, reported: UNSCOPED_ENTRY });
+    }
+    if (refusals.length > 0) {
+        return { records: [], refusals };
+    }
+    const named = byReference.get(referenceKey(symbol, written.path)) ?? [];
+    if (named.length === 0) {
+        return { records: [{ ...written, bound: "" }], refusals: [] };
+    }
+    return { records: named.map((one) => ({ ...written, bound: one.id })), refusals: [] };
+}
+/** Reads one document at the target root, binding each record against the run's declarations. */
+function readDocument(host, targetRoot, symbols, shape) {
+    const file = joinPath(targetRoot, shape.file);
+    if (host.kindOf(file) === "absent") {
+        return { records: [], refusals: [] };
+    }
+    const text = host.readFile(file);
+    const malformed = (detail, site = documentSite(shape)) => {
+        throw new SuppressionError(shape.mechanism, siteText(site), detail, shape.documentWant);
+    };
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch (error) {
+        return malformed(`${shape.file}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (!isObject(parsed)) {
+        return malformed(shape.file);
+    }
+    const walk = walkDocument(text, shape.array);
+    if (walk.twice !== undefined) {
+        malformed(`the member ${JSON.stringify(walk.twice.name)} is written twice, so neither value is chosen`, positionAt(text, shape.file, walk.twice.offset));
+    }
+    for (const key of Object.keys(parsed)) {
+        if (key !== "description" && key !== shape.array) {
+            malformed(`the member ${JSON.stringify(key)} is not one the grammar declares`);
+        }
+    }
+    const description = parsed["description"];
+    const held = parsed[shape.array];
+    if ((description !== undefined && typeof description !== "string") || !Array.isArray(held)) {
+        return malformed(shape.file);
+    }
+    const byReference = new Map();
+    for (const symbol of symbols) {
+        const key = referenceKey(symbol.ref, symbol.position.path);
+        byReference.set(key, [...(byReference.get(key) ?? []), symbol]);
+    }
+    const records = [];
+    const refusals = [];
+    held.forEach((value, index) => {
+        const offset = walk.opened[index];
+        const site = offset === undefined ? documentSite(shape) : positionAt(text, shape.file, offset);
+        const read = readRecord(value, site, byReference, shape);
+        records.push(...read.records);
+        refusals.push(...read.refusals);
+    });
+    return { records, refusals };
+}
+/**
+ * The ignore file at the target root, each entry bound to the declaration whose reference
+ * and file both equal the ones it names, and never by glob, pattern or substring. An
+ * absent file is an empty one.
+ */
+export function readIgnoreFile(host, targetRoot, symbols) {
+    return readDocument(host, targetRoot, symbols, IGNORE_SHAPE);
+}
+/**
+ * The baseline at the target root, each row matched exactly as an ignore entry is. A row's
+ * reason is the provenance an analyzer wrote, never a maintainer's judgement: the finding
+ * it records is real, and the row says only that it was there when the baseline was
+ * written. An absent file is an empty one.
+ */
+export function readBaseline(host, targetRoot, symbols) {
+    return readDocument(host, targetRoot, symbols, BASELINE_SHAPE);
+}
+/** What a written document says about itself, so the same report writes the same bytes. */
+const BASELINE_DESCRIPTION = "Recorded findings: a run fails only on a finding this document does not hold. " +
+    "Every reason is the analyzer that recorded the row, never an adjudication.";
+/**
+ * A baseline holding one row per finding, in the order given, which is the report's. Every
+ * row carries the provenance as its reason. A finding missing a value a row needs, and an
+ * identity missing its name or version, are refused rather than written, because the
+ * grammar requires a reason on every row.
+ */
+export function writeBaseline(findings, provenance) {
+    if (provenance.analyzer === "" || provenance.version === "") {
+        throw new Error(`a baseline row would carry no reason: the analyzer identity names ${JSON.stringify(provenance.analyzer)} at version ${JSON.stringify(provenance.version)}`);
+    }
+    const reason = `recorded by ${provenance.analyzer} ${provenance.version}`;
+    const baseline = findings.map((found) => {
+        if (found.code === "" || found.symbol === "" || found.path === "") {
+            throw new Error(`a baseline row would carry no reason: a finding names code ${JSON.stringify(found.code)}, symbol ${JSON.stringify(found.symbol)} and path ${JSON.stringify(found.path)}`);
+        }
+        return { code: found.code, symbol: found.symbol, path: found.path, reason };
+    });
+    return `${JSON.stringify({ description: BASELINE_DESCRIPTION, baseline }, null, 2)}\n`;
+}

package/dist/src/suppress-inline.js

@@ -0,0 +1,259 @@
+/**
+ * The inline directive: `deadset:ignore`, the first token of a `//` line comment, naming
+ * one or more codes and a reason, and binding to every declaration that begins on the line
+ * below it.
+ */
+import { SyntaxKind } from "@typescript/native/unstable/ast";
+import { nodeKey } from "./inventory.js";
+import { byPosition, positionKey, renderPosition } from "./position.js";
+import { SUPPRESSION_WITHOUT_REASON, SuppressionError, siteText, } from "./suppress.js";
+/**
+ * The three expressions the grammar applies to the text of each line comment, in this
+ * order: a comment in the namespace, a well-formed directive, and a directive that lacks
+ * only its reason. A test pins each to the line the grammar page carries.
+ */
+export const DIRECTIVE_EXPRESSIONS = {
+    candidate: String.raw `^//[ \t]*deadset:`,
+    wellFormed: String.raw `^//[ \t]*deadset:ignore[ \t]+(?<codes>DS[0-9]{4}(?:,DS[0-9]{4})*)[ \t]+--[ \t]+(?<reason>[^ \t\r\n][^\r\n]*?)[ \t]*$`,
+    noReason: String.raw `^//[ \t]*deadset:ignore[ \t]+(?<codes>DS[0-9]{4}(?:,DS[0-9]{4})*)(?:[ \t]+--)?[ \t]*$`,
+};
+const CANDIDATE = new RegExp(DIRECTIVE_EXPRESSIONS.candidate);
+const WELL_FORMED = new RegExp(DIRECTIVE_EXPRESSIONS.wellFormed);
+const NO_REASON = new RegExp(DIRECTIVE_EXPRESSIONS.noReason);
+/** The form a malformed directive is told to take. */
+const DIRECTIVE_FORM = "// deadset:ignore DS0000[,DS0000...] -- <reason>";
+/** Applies the grammar's three expressions to the text of one comment, in order. */
+export function classifyComment(text) {
+    if (!CANDIDATE.test(text)) {
+        return { is: "none" };
+    }
+    const groups = WELL_FORMED.exec(text)?.groups;
+    if (groups !== undefined) {
+        return {
+            is: "directive",
+            codes: (groups["codes"] ?? "").split(","),
+            reason: groups["reason"] ?? "",
+        };
+    }
+    const bare = NO_REASON.exec(text)?.groups;
+    if (bare !== undefined) {
+        return { is: "no-reason", codes: (bare["codes"] ?? "").split(",") };
+    }
+    return { is: "malformed" };
+}
+/** The literal tokens whose text may hold `//` or `/*` without starting a comment. */
+const LITERALS = new Set([
+    SyntaxKind.StringLiteral,
+    SyntaxKind.NoSubstitutionTemplateLiteral,
+    SyntaxKind.TemplateHead,
+    SyntaxKind.TemplateMiddle,
+    SyntaxKind.TemplateTail,
+    SyntaxKind.RegularExpressionLiteral,
+    SyntaxKind.JsxText,
+]);
+/** Whether one character ends a line, under the language's line terminators. */
+function endsLine(char) {
+    return char === "\n" || char === "\r" || char === "\u2028" || char === "\u2029";
+}
+/** The offset where the line holding `from` ends. */
+function lineEnd(text, from) {
+    let at = from;
+    while (at < text.length && !endsLine(text[at])) {
+        at += 1;
+    }
+    return at;
+}
+/**
+ * The offset of the first token at or after `from`: whitespace, comments and a leading
+ * hashbang are trivia.
+ */
+export function tokenStart(text, from) {
+    let at = from;
+    if (at === 0 && text.startsWith("#!")) {
+        at = lineEnd(text, 0);
+    }
+    for (;;) {
+        if (/\s/u.test(text[at] ?? "")) {
+            at += 1;
+        }
+        else if (text.startsWith("//", at)) {
+            at = lineEnd(text, at);
+        }
+        else if (text.startsWith("/*", at)) {
+            const close = text.indexOf("*/", at + 2);
+            at = close < 0 ? text.length : close + 2;
+        }
+        else {
+            return at;
+        }
+    }
+}
+/**
+ * Every `//` line comment of one file, in file order. The text between tokens is read as
+ * the language reads it: a block comment holds no line comment, and the literal tokens the
+ * syntax tree holds are skipped, so a `//` inside a string, a template or a regular
+ * expression starts nothing.
+ */
+export function lineComments(file) {
+    const text = file.text;
+    const spans = [];
+    const visit = (node) => {
+        if (LITERALS.has(node.kind)) {
+            spans.push({ start: tokenStart(text, node.pos), end: node.end });
+        }
+        node.forEachChild(visit);
+    };
+    file.forEachChild(visit);
+    spans.sort((a, b) => a.start - b.start);
+    const found = [];
+    let next = 0;
+    let at = 0;
+    while (at < text.length) {
+        while (next < spans.length && (spans[next]?.start ?? 0) < at) {
+            next += 1;
+        }
+        const span = spans[next];
+        if (span?.start === at) {
+            at = Math.max(span.end, at + 1);
+        }
+        else if (text.startsWith("//", at)) {
+            const end = lineEnd(text, at);
+            found.push({ offset: at, text: text.slice(at, end) });
+            at = end;
+        }
+        else if (text.startsWith("/*", at)) {
+            const close = text.indexOf("*/", at + 2);
+            at = close < 0 ? text.length : close + 2;
+        }
+        else {
+            at += 1;
+        }
+    }
+    return found;
+}
+/**
+ * The declarations of one file by the line each begins on, the line of its first token: a
+ * decorator, a modifier or the keyword. A variable's first token is its statement's
+ * keyword, and a variable written on a later line of the statement also begins there.
+ */
+function declarationLines(file, held, symbols) {
+    const below = new Map();
+    const add = (offset, one) => {
+        const line = file.getLineAndCharacterOfPosition(tokenStart(file.text, offset)).line + 1;
+        const at = below.get(line) ?? [];
+        if (!at.some((known) => known.id === one.id)) {
+            at.push(one);
+        }
+        below.set(line, at);
+    };
+    const visit = (node) => {
+        const id = held.declarations.get(nodeKey(file, node));
+        const one = id === undefined ? undefined : symbols.get(id);
+        if (one !== undefined) {
+            add(node.pos, one);
+            const list = node.parent;
+            if (node.kind === SyntaxKind.VariableDeclaration &&
+                list.kind === SyntaxKind.VariableDeclarationList &&
+                list.parent.kind === SyntaxKind.VariableStatement) {
+                add(list.parent.pos, one);
+            }
+        }
+        node.forEachChild(visit);
+    };
+    file.forEachChild(visit);
+    return below;
+}
+/**
+ * Every comment in the namespace one project's own files hold, each with the declarations
+ * it binds, read while the project's view is open.
+ */
+export function inlineDirectives(project, held, targetRoot) {
+    const symbols = new Map(held.symbols
+        .filter((symbol) => symbol.kind !== "file")
+        .map((symbol) => [symbol.id, { id: symbol.id, ref: symbol.ref, position: symbol.position }]));
+    const found = [];
+    for (const file of project.ownSourceFiles()) {
+        const comments = lineComments(file).filter((comment) => CANDIDATE.test(comment.text));
+        if (comments.length === 0) {
+            continue;
+        }
+        const below = declarationLines(file, held, symbols);
+        for (const comment of comments) {
+            const site = renderPosition(file, targetRoot, comment.offset);
+            found.push({
+                site,
+                text: comment.text,
+                directive: classifyComment(comment.text),
+                bound: [...(below.get(site.line + 1) ?? [])],
+            });
+        }
+    }
+    return found;
+}
+/**
+ * The inline directives of a run's projects, each bound to the declarations that begin on
+ * the line below it, one directive binding the union of what each project holding its file
+ * declares there. A directive that lacks only its reason is one {@link Refusal} per code;
+ * any other malformed comment in the namespace ends the read with a
+ * {@link SuppressionError} naming the first one written.
+ */
+export function inlineSuppressions(perProject) {
+    const merged = new Map();
+    for (const written of perProject.flat()) {
+        const key = positionKey(written.site);
+        const known = merged.get(key);
+        if (known === undefined) {
+            merged.set(key, { ...written, bound: [...written.bound] });
+            continue;
+        }
+        for (const one of written.bound) {
+            if (!known.bound.some((other) => other.id === one.id)) {
+                known.bound.push(one);
+            }
+        }
+    }
+    const ordered = [...merged.values()].sort((a, b) => byPosition(a.site, b.site));
+    const records = [];
+    const refusals = [];
+    for (const { site, text, directive, bound } of ordered) {
+        switch (directive.is) {
+            case "none":
+                break;
+            case "malformed":
+                throw new SuppressionError("inline", siteText(site), JSON.stringify(text), DIRECTIVE_FORM);
+            case "no-reason":
+                for (const code of directive.codes) {
+                    refusals.push({
+                        reported: SUPPRESSION_WITHOUT_REASON,
+                        code,
+                        symbol: "",
+                        path: site.path,
+                        reason: "",
+                        site,
+                        mechanism: "inline",
+                    });
+                }
+                break;
+            case "directive": {
+                const declared = [...bound].sort((a, b) => byPosition(a.position, b.position));
+                for (const code of directive.codes) {
+                    const base = {
+                        code,
+                        path: site.path,
+                        reason: directive.reason,
+                        site,
+                        mechanism: "inline",
+                    };
+                    if (declared.length === 0) {
+                        records.push({ ...base, symbol: "", bound: "" });
+                    }
+                    for (const one of declared) {
+                        records.push({ ...base, symbol: one.ref, bound: one.id });
+                    }
+                }
+                break;
+            }
+        }
+    }
+    return { records, refusals };
+}