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

package/dist/src/suppress-inline.js

@@ -3,13 +3,14 @@
  * one or more codes and a reason, and binding to every declaration that begins on the line
  * below it, or on its own line where it trails a token there.
  */
-import { isConstructorDeclaration, SyntaxKind, } from "@typescript/native/ast";
+import { CODE } from "./contract/contract.generated.js";
+import { SyntaxKind } from "@typescript/native/ast";
 import { importBindings } from "./import-bindings.js";
-import { isParameterProperty, nodeKey } from "./inventory.js";
-import { byPosition, positionKey, renderPosition } from "./position.js";
+import { nodeKey } from "./inventory.js";
+import { relativePath } from "./paths.js";
+import { byPosition, lineEnd, positionKey, renderPosition, startLine, tokenStart, } from "./position.js";
 import { importRef } from "./ref.js";
-import { signatureOf } from "./signatures.js";
-import { isPartKind, SUPPRESSION_WITHOUT_REASON, SuppressionError, siteText, } from "./suppress.js";
+import { isPartKind, 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
@@ -54,43 +55,6 @@ const LITERALS = new Set([
     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
@@ -139,55 +103,42 @@ function lineComments(file) {
 function bindingKey(one) {
     return `${one.declared?.id ?? ""}\u0000${one.part.id}`;
 }
+/** The placed declarations of a project by the path of the file each is in. */
+function placedByPath(held, symbols) {
+    const byPath = new Map();
+    for (const [id, placed] of held.placement) {
+        const one = symbols.get(id);
+        const holder = symbols.get(placed.holder);
+        if (one === undefined || holder === undefined) {
+            continue;
+        }
+        const at = byPath.get(one.position.path) ?? [];
+        at.push({ one, holder, startLines: placed.startLines, partLines: placed.partLines });
+        byPath.set(one.position.path, at);
+    }
+    return byPath;
+}
 /**
- * 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. A
- * function also begins, for a directive, on the line of each of its parameters, and a
- * class, for a part kind, on the lines of its constructor and its constructor's parameters.
+ * The declarations of one file by the line a directive binds each on, as the inventory
+ * places them, and each import binding of the file on its statement's lines.
  */
-function declarationLines(file, held, symbols, targetRoot) {
+function declarationLines(file, placed, held, targetRoot) {
     const below = new Map();
-    const add = (offset, one) => {
-        const line = file.getLineAndCharacterOfPosition(tokenStart(file.text, offset)).line + 1;
+    const add = (line, one) => {
         const at = below.get(line) ?? [];
         if (!at.some((known) => bindingKey(known) === bindingKey(one))) {
             at.push(one);
         }
         below.set(line, at);
     };
-    const declaredAt = (node) => {
-        const id = held.declarations.get(nodeKey(file, node));
-        return id === undefined ? undefined : symbols.get(id);
-    };
-    const visit = (node) => {
-        const one = declaredAt(node);
-        const owner = isConstructorDeclaration(node) ? declaredAt(node.parent) : undefined;
-        if (owner !== undefined && isConstructorDeclaration(node)) {
-            for (const at of [node, ...node.parameters.filter((one) => !isParameterProperty(one))]) {
-                add(at.pos, { declared: undefined, part: owner });
-            }
-        }
-        const holder = one !== undefined && isParameterProperty(node) ? declaredAt(node.parent.parent) : one;
-        if (one !== undefined && holder !== undefined) {
-            add(node.pos, { declared: one, part: holder });
+    for (const { one, holder, startLines, partLines } of placed) {
+        for (const line of startLines) {
+            add(line, { declared: one, part: holder });
         }
-        if (one !== undefined) {
-            // A parameter on a later line of a wrapped signature takes its directive on the
-            // line above it, inside the parameter list, and the directive binds the function.
-            for (const parameter of signatureOf(node)?.parameters ?? []) {
-                add(parameter.pos, { declared: one, part: one });
-            }
-            const list = node.parent;
-            if (node.kind === SyntaxKind.VariableDeclaration &&
-                list.kind === SyntaxKind.VariableDeclarationList &&
-                list.parent.kind === SyntaxKind.VariableStatement) {
-                add(list.parent.pos, { declared: one, part: one });
-            }
+        for (const line of partLines) {
+            add(line, { declared: undefined, part: one });
         }
-        node.forEachChild(visit);
-    };
-    file.forEachChild(visit);
+    }
     // An import binding is a subject of its own, bound on its line as a declaration is.
     const fileId = held.declarations.get(nodeKey(file, file));
     const moduleRef = held.symbols.find((symbol) => symbol.id === fileId)?.ref ?? "";
@@ -199,7 +150,7 @@ function declarationLines(file, held, symbols, targetRoot) {
             statement = statement.parent;
         }
         for (const at of [statement.pos, name.getStart()]) {
-            add(at, { declared: one, part: one });
+            add(startLine(file, at), { declared: one, part: one });
         }
     }
     return below;
@@ -220,13 +171,15 @@ 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 placed = placedByPath(held, symbols);
     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, targetRoot);
+        const path = relativePath(targetRoot, file.fileName) ?? "";
+        const below = declarationLines(file, placed.get(path) ?? [], held, targetRoot);
         for (const comment of comments) {
             const site = renderPosition(file, targetRoot, comment.offset);
             const target = trails(file, comment.offset) ? site.line : site.line + 1;
@@ -274,7 +227,7 @@ export function inlineSuppressions(perProject) {
             case "no-reason":
                 for (const code of directive.codes) {
                     refusals.push({
-                        reported: SUPPRESSION_WITHOUT_REASON,
+                        reported: CODE.suppressionWithoutReason,
                         code,
                         symbol: "",
                         path: site.path,

package/dist/src/suppress.js

@@ -4,25 +4,20 @@
  * ignore entry or a baseline row. A bound record marks its declaration live before the
  * sweep, unless its code reports a part or a dependency row, and is in effect when it
  * withholds a finding its code would have produced there, dormant when the configuration
- * withholds every such finding anyway, and stale otherwise.
+ * or a hold withholds every such finding anyway, and stale otherwise.
  */
-import { ConfigError } from "./config.js";
+import { KIND_ROWS, REMEDIES, SYMBOL_SUBJECTS, } from "./contract/contract.generated.js";
+import { UsageError } from "./usage.js";
 import { positionKey } from "./position.js";
 import { isRef } from "./ref.js";
-/** 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";
 /**
  * A directive, an entry or a document the grammar refuses before any finding exists: an
  * instruction the analysis cannot carry out. It is a malformed input, so the command line
  * answers it with the usage code.
  */
-export class SuppressionError extends ConfigError {
+export class SuppressionError extends UsageError {
     constructor(mechanism, at, text, want) {
-        super("malformed", at, `${mechanism} ${at}: ${text}: want ${want}`);
+        super(`${mechanism} ${at}: ${text}: want ${want}`);
         this.name = "SuppressionError";
     }
 }
@@ -71,73 +66,54 @@ export function isSymbolRef(value) {
 export function blankReason(reason) {
     return reason === undefined || /^[ \t\r\n]*$/u.test(reason);
 }
-/**
- * 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 = new Map([
-    ["dependency", ["DS1601"]],
-    ["module-directive", ["DS1605"]],
-]);
-/**
- * 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.
- */
-const ROW_SUBJECTS = new Map([
-    ["file", ["DS1501", "DS1502"]],
-    ...DEPENDENCY_SUBJECTS,
-    ["root", ["DS1704"]],
-    ["configured-declaration", ["DS1706"]],
-    ["suppression", ["DS1701", "DS1702", "DS1703"]],
-    ["edge", ["DS1705"]],
-]);
+/** No hold. */
+const NO_HOLDS = { withholds: () => false, holdsRecord: () => false };
+/** The subject of the kind each live code names. */
+const SUBJECT_OF_CODE = new Map(KIND_ROWS.map((row) => [row.code, row.subject]));
+/** The subject a finding about one symbol kind is about. */
+function subjectOf(kind) {
+    return Object.hasOwn(SYMBOL_SUBJECTS, kind)
+        ? SYMBOL_SUBJECTS[kind]
+        : undefined;
+}
+/** Whether a subject is a row of a document rather than a declaration of the program. */
+function rowOf(subject) {
+    return subject === "file" || subject === "dependency" || subject === "record";
+}
 /** Whether a finding's subject is a row of a document rather than a declaration. */
 export function isRowSubject(kind) {
-    return ROW_SUBJECTS.has(kind);
+    return rowOf(subjectOf(kind));
 }
-/** Whether a code reports a row of a document. */
-export function isRowCode(code) {
-    return [...ROW_SUBJECTS.values()].some((codes) => codes.includes(code));
+/** The subject a code reports, which kinds.json's remedies table answers for. */
+export function subjectOfCode(code) {
+    return SUBJECT_OF_CODE.get(code);
 }
-/** Whether a finding's subject is a dependency row. */
-export function isDependencySubject(kind) {
-    return DEPENDENCY_SUBJECTS.has(kind);
-}
-/** Whether a code reports a dependency row, which only an ignore entry or a baseline row names. */
-export function isDependencyCode(code) {
-    return [...DEPENDENCY_SUBJECTS.values()].some((codes) => codes.includes(code));
+/**
+ * Whether a record of `mechanism` can name a finding about `subject`, as kinds.json's
+ * remedies table lists the suppressions of each subject. A subject the table does not
+ * know is a declaration's.
+ */
+export function names(subject, mechanism) {
+    return REMEDIES[subject ?? "declaration"].suppressions.includes(mechanism);
 }
-/** Whether a code reports a row of a document that no record of any mechanism can name. */
-export function isUnsuppressibleCode(code) {
-    return isRowCode(code) && !isDependencyCode(code);
+/** Whether a finding about a symbol of `kind` is one a record of `mechanism` can name. */
+export function namesKind(kind, mechanism) {
+    return names(subjectOf(kind), mechanism);
 }
 /**
- * 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 = 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) {
-    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) {
-    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. */
 function claimKey(finding) {
@@ -155,14 +131,13 @@ export function pairs(record, finding) {
     if (record.code !== finding.code) {
         return false;
     }
-    if (DEPENDENCY_SUBJECTS.has(finding.symbol.kind)) {
-        return (record.mechanism !== "inline" &&
-            record.symbol === finding.symbol.ref &&
-            record.path === finding.position.path);
-    }
-    if (ROW_SUBJECTS.has(finding.symbol.kind)) {
+    const subject = subjectOf(finding.symbol.kind);
+    if (!names(subject, record.mechanism)) {
         return false;
     }
+    if (subject === "dependency") {
+        return record.symbol === finding.symbol.ref && record.path === finding.position.path;
+    }
     if (record.bound !== "" && record.bound === positionKey(finding.position)) {
         return true;
     }
@@ -174,10 +149,10 @@ export function pairs(record, finding) {
  * there: swept with no mark for a liveness kind, and as swept otherwise. The first record
  * in reading order claims a finding, so a second naming it is stale; a part-kind record
  * claims every finding of its code about a part of its declaration. A record is dormant
- * when the dials withhold every finding it claims, read from those findings alone, or when
- * it claims none and its code's severity is `allow`.
+ * when the dials or `holds` withhold every finding it claims, or when it claims none and
+ * its code is at `allow` or a hold keeps its declaration live.
  */
-export function ledgerOf(records, would, dials) {
+export function ledgerOf(records, would, dials, holds = NO_HOLDS) {
     const taken = new Set();
     const verdicts = [];
     for (const record of records) {
@@ -185,13 +160,17 @@ export function ledgerOf(records, would, dials) {
         const first = would.find(open);
         const claimed = first === undefined ? [] : isPartKind(record.code) ? would.filter(open) : [first];
         if (claimed.length === 0) {
-            verdicts.push(record.bound !== "" && dials.allows(record.code) ? "dormant" : "stale");
+            verdicts.push(record.bound !== "" && (dials.allows(record.code) || holds.holdsRecord(record))
+                ? "dormant"
+                : "stale");
             continue;
         }
         for (const finding of claimed) {
             taken.add(claimKey(finding));
         }
-        verdicts.push(claimed.every((finding) => dials.withholds(finding)) ? "dormant" : "in-effect");
+        verdicts.push(claimed.every((finding) => dials.withholds(finding) || holds.withholds(finding))
+            ? "dormant"
+            : "in-effect");
     }
     return {
         verdicts,

package/dist/src/symbol-keys.js

@@ -5,16 +5,12 @@
  * No name node resolves to such a member: the key's name resolves to the constant. An
  * iteration reads the member its well-known iteration symbol keys.
  */
-import { isComputedPropertyName, isForOfStatement, isIdentifier, isNoSubstitutionTemplateLiteral, isNumericLiteral, isParenthesizedExpression, isPropertyAccessExpression, isSpreadElement, isStringLiteral, } from "@typescript/native/ast";
-import { nodeKey } from "./inventory.js";
-import { renderPosition } from "./position.js";
-import { isAnswered } from "./query.js";
+import { isComputedPropertyName, isForOfStatement, isIdentifier, isNoSubstitutionTemplateLiteral, isNumericLiteral, isPropertyAccessExpression, isSpreadElement, isStringLiteral, } from "@typescript/native/ast";
+import { parenthesesRemoved } from "./unwrap.js";
+import { isAnswered, UNANSWERED } from "./query.js";
 /** The identifier an element access's argument names its key by, where it is a name. */
 export function keyNameOf(argument) {
-    let at = argument;
-    while (isParenthesizedExpression(at)) {
-        at = at.expression;
-    }
+    const at = parenthesesRemoved(argument);
     if (isIdentifier(at)) {
         return at;
     }
@@ -129,87 +125,95 @@ function wellKnownName(name) {
         : undefined;
 }
 /**
- * The references the iterations of one project's own files make to the iteration members
- * of the values they iterate: a `for…of` statement and a spread element read
- * `[Symbol.iterator]`, and a `for await…of` statement reads `[Symbol.asyncIterator]` and,
- * which it falls back to, `[Symbol.iterator]`. Each is made by the declaration holding it.
+ * The reads the iterations of a side's files make of the iteration members of the values they
+ * iterate: a `for…of` statement and a spread element read `[Symbol.iterator]`, and a
+ * `for await…of` statement reads `[Symbol.asyncIterator]` and, which it falls back to,
+ * `[Symbol.iterator]`. Each is made by the declaration holding it. A value whose type or
+ * members the checker leaves unanswered holds the members those names could spell.
  */
-export function iterationReferences(project, held, chains, root, testFiles) {
-    const queries = project.queries;
-    const ownPaths = project.ownPaths();
-    const iterated = [];
-    for (const file of project.ownSourceFiles()) {
-        const fileId = held.declarations.get(nodeKey(file, file));
-        if (fileId === undefined) {
-            continue;
-        }
-        const visit = (node, from) => {
-            const holder = held.declarations.get(nodeKey(file, node)) ?? from;
-            if (isForOfStatement(node)) {
-                const protocols = node.awaitModifier === undefined ? ["iterator"] : ["asyncIterator", "iterator"];
-                iterated.push({ file, from: holder, operand: node.expression, protocols });
-            }
-            else if (isSpreadElement(node)) {
-                iterated.push({ file, from: holder, operand: node.expression, protocols: ["iterator"] });
-            }
-            node.forEachChild((child) => {
-                visit(child, holder);
-            });
-        };
-        file.forEachChild((child) => {
-            visit(child, fileId);
-        });
-    }
-    if (iterated.length === 0) {
-        return [];
-    }
-    const types = queries.typesAt(iterated.map((one) => one.operand));
-    const members = new Map();
-    const membersOf = (type) => {
-        const known = members.get(type.id);
-        if (known !== undefined) {
-            return known;
-        }
-        const keyed = [];
-        const properties = queries.propertiesOf(type);
-        for (const property of isAnswered(properties) ? properties : []) {
-            for (const handle of property.declarations) {
-                const node = ownPaths.has(handle.path) ? project.declarationAt(handle)?.node : undefined;
-                const name = wellKnownName(node?.name);
-                if (name !== undefined) {
-                    keyed.push({ name, ids: chains.declarationsOf(property) });
-                    break;
+export const iteration = {
+    start() {
+        const iterated = [];
+        return {
+            visit(node, { file, from }) {
+                if (isForOfStatement(node)) {
+                    const protocols = node.awaitModifier === undefined ? ["iterator"] : ["asyncIterator", "iterator"];
+                    iterated.push({ file, from, operand: node.expression, protocols });
                 }
-            }
-        }
-        members.set(type.id, keyed);
-        return keyed;
-    };
-    const found = [];
-    iterated.forEach((one, index) => {
-        const type = types[index];
-        if (type === undefined || !isAnswered(type)) {
-            return;
-        }
-        const parts = type.isUnionType() || type.isIntersectionType() ? queries.constituents(type) : [type];
-        const position = renderPosition(one.file, root, one.operand.getStart());
-        for (const part of isAnswered(parts) ? parts : []) {
-            for (const member of membersOf(part)) {
-                if (!one.protocols.includes(member.name)) {
-                    continue;
+                else if (isSpreadElement(node)) {
+                    iterated.push({ file, from, operand: node.expression, protocols: ["iterator"] });
                 }
-                for (const to of member.ids) {
-                    found.push({
-                        from: one.from,
-                        to,
-                        position,
-                        use: "read",
-                        resolution: "keyed",
-                        test: testFiles.has(position.path),
-                    });
+            },
+            reads({ project, chains }) {
+                const found = [];
+                if (iterated.length === 0) {
+                    return found;
                 }
-            }
-        }
-    });
-    return found;
-}
+                const queries = project.queries;
+                const ownPaths = project.ownPaths();
+                const types = queries.typesAt(iterated.map((one) => one.operand));
+                const members = new Map();
+                const membersOf = (type) => {
+                    const known = members.get(type.id);
+                    if (known !== undefined) {
+                        return known;
+                    }
+                    const properties = queries.propertiesOf(type);
+                    const keyed = [];
+                    for (const property of isAnswered(properties) ? properties : []) {
+                        for (const handle of property.declarations) {
+                            const node = ownPaths.has(handle.path)
+                                ? project.declarationAt(handle)?.node
+                                : undefined;
+                            const name = wellKnownName(node?.name);
+                            if (name !== undefined) {
+                                keyed.push({ name, ids: chains.declarationsOf(property) });
+                                break;
+                            }
+                        }
+                    }
+                    const result = isAnswered(properties) ? keyed : UNANSWERED;
+                    members.set(type.id, result);
+                    return result;
+                };
+                // A member a well-known symbol keys is named by the symbol's computed name.
+                const spelled = (protocols) => protocols.map((protocol) => `Symbol.${protocol}`);
+                iterated.forEach((one, index) => {
+                    const type = types[index];
+                    if (type === UNANSWERED) {
+                        found.push({ kind: "held", from: one.from, names: spelled(one.protocols) });
+                        return;
+                    }
+                    if (type === undefined) {
+                        return;
+                    }
+                    const parts = type.isUnionType() || type.isIntersectionType() ? queries.constituents(type) : [type];
+                    for (const part of isAnswered(parts) ? parts : [type]) {
+                        const keyed = membersOf(part);
+                        if (keyed === UNANSWERED) {
+                            found.push({ kind: "held", from: one.from, names: spelled(one.protocols) });
+                            continue;
+                        }
+                        for (const member of keyed) {
+                            if (!one.protocols.includes(member.name)) {
+                                continue;
+                            }
+                            for (const to of member.ids) {
+                                found.push({
+                                    kind: "named",
+                                    from: one.from,
+                                    to,
+                                    file: one.file,
+                                    at: one.operand,
+                                    use: "read",
+                                    via: "keyed",
+                                });
+                            }
+                        }
+                    }
+                });
+                return found;
+            },
+        };
+    },
+};

package/dist/src/tests/file-class.js

@@ -0,0 +1,76 @@
+/**
+ * The file classes the run counts references by. A test file is one a `ts.test_files`
+ * pattern or a test runner's row names (the test-runner entry source decides which), a test
+ * file no project holds, or a consumer's file a pattern names below the consumer's root.
+ * A test-support file is test code as well, decided once the references are known
+ * (`support.ts`), so a reference carries only whether a test file made it and the counters
+ * read the support class beside it.
+ */
+import { renderPosition } from "../position.js";
+import { bytewise } from "../text/compare.js";
+import { globExpression } from "../text/glob.js";
+/** The test files of the target: each file the test-runner source names, by its file name. */
+export function targetTestFile(named) {
+    return (file) => named.has(file.fileName);
+}
+/** The test files a pattern names, each by its path below `root`: a consumer's, below the consumer's root. */
+export function patternTestFile(patterns, root) {
+    const expressions = patterns.map(globExpression);
+    return (file) => {
+        const path = renderPosition(file, root, 0).path;
+        return expressions.some((expression) => expression.test(path));
+    };
+}
+/** The own files of a project that are test files, by their path below `root`, ascending. */
+export function testFilePaths(project, root, testFile) {
+    return project
+        .ownSourceFiles()
+        .filter(testFile)
+        .map((file) => renderPosition(file, root, 0).path)
+        .sort(bytewise);
+}
+/** Whether test code made one reference: a test file, or a test-support file of the target. */
+export function madeByTestCode(reference, support) {
+    return (reference.test || (reference.consumer === undefined && support.has(reference.position.path)));
+}
+/** Whether the mode classes a reference test code made as a test one: any but a loaded consumer's it classes as production. */
+export function classedAsTest(test, consumer, mode) {
+    return test && !(consumer && mode.consumerTestsProduction === true);
+}
+/** Whether a production mode counts no reference of this one: test code made it, as the mode classes it. */
+export function withheldBy(mode, reference, support) {
+    return (mode.production &&
+        classedAsTest(madeByTestCode(reference, support), reference.consumer !== undefined, mode));
+}
+/** Whether a production mode follows no edge like this one: {@link withheldBy} for a graph edge. */
+export function edgeWithheldBy(mode, edge) {
+    return mode.production && classedAsTest(edge.test, edge.consumer, mode);
+}
+/** The rule a file the analysis classified as test-support code is counted under. */
+const TEST_SUPPORT_RULE = "test-support";
+/**
+ * The name one test-file rule takes. A rule's name is a word list the report's own
+ * vocabulary spells, which cannot carry a pattern, so a rule is named by the place of
+ * its pattern in the configured list.
+ */
+function patternRule(index) {
+    return `test-file-pattern-${String(index + 1)}`;
+}
+/**
+ * The rules over the test files of several projects at once, ordered by rule: a file two
+ * projects hold is one file, so each rule counts the distinct paths it matches.
+ */
+export function testFileRulesOf(testFiles, paths, supportFiles = []) {
+    const distinct = [...new Set(paths)];
+    const support = new Set(supportFiles).size;
+    return [
+        ...testFiles.map((pattern, index) => {
+            const expression = globExpression(pattern);
+            return {
+                rule: patternRule(index),
+                matched: distinct.filter((path) => expression.test(path)).length,
+            };
+        }),
+        ...(support === 0 ? [] : [{ rule: TEST_SUPPORT_RULE, matched: support }]),
+    ].sort((a, b) => bytewise(a.rule, b.rule));
+}