@cplieger/deadset-ts 8.0.0-dev.16 → 8.0.0-dev.17

package/src/report.ts

@@ -18,7 +18,7 @@ import type {
 import type { AppliedConvention } from "./entries/conventions.ts";
 import type { PassResult } from "./findings-pass.ts";
 import type { StaleSuppression } from "./findings/self-check.ts";
-import type { TestFileRule } from "./references.ts";
+import type { TestFileRule } from "./tests/file-class.ts";
 import { bytewise } from "./text/compare.ts";
 import { LANGUAGE, PRODUCT } from "./product.ts";
 

package/src/roots/configured-declarations.ts

@@ -204,6 +204,9 @@ function modulesNamed<Brand>(
   project: ProjectView<Brand>,
   specifiers: ReadonlySet<string>,
 ): ReadonlyMap<string, TSSymbol> {
+  if (specifiers.size === 0) {
+    return new Map();
+  }
   const written = new Map<string, Node>();
   for (const file of project.ownSourceFiles()) {
     const visit = (node: Node): void => {

package/src/roots/root-set.ts

@@ -621,7 +621,7 @@ export function rootSet<Brand>(
   for (const id of skippedRoots(project, held, options.skips)) {
     add(id, "type-error", "");
   }
-  for (const id of mergedGlobalInterfaces(project, held, files)) {
+  for (const id of mergedGlobalInterfaces(project, held, files).kept) {
     add(id, "global-augmentation", "");
   }
 

package/src/roots/unseen-loads.ts

@@ -19,9 +19,18 @@ import {
   type Node,
   type SourceFile,
 } from "@typescript/native/ast";
+import { amdLoadOf, amdUnresolved } from "../amd.ts";
 import { membersNamed, textsOf, writtenValue, type Value } from "../entries/static-module.ts";
 import { writtenName } from "../platform-calls.ts";
-import { dirnamePath, relativePath, resolvePath } from "../paths.ts";
+import {
+  cannotStartPackageName,
+  dirnamePath,
+  hasURLScheme,
+  isAbsolutePath,
+  relativePath,
+  resolvePath,
+  startsRelativePath,
+} from "../paths.ts";
 import type { Position } from "../position.ts";
 import { unwrapped } from "../unwrap.ts";
 import { globExpression } from "../text/glob.ts";
@@ -54,7 +63,7 @@ function leadingLiteral(node: Node): string | undefined {
  * it, each of which would name every sibling.
  */
 function computedLoadDirectory(dir: string, prefix: string): string | undefined {
-  if (!(prefix.startsWith("./") || prefix.startsWith("../")) || !prefix.endsWith("/")) {
+  if (!startsRelativePath(prefix) || !prefix.endsWith("/")) {
     return undefined;
   }
   const target = resolvePath(dir, prefix);
@@ -74,11 +83,13 @@ interface Loadable {
 }
 
 /** One load by a computed path whose files the analysis resolves. */
-interface ComputedLoad {
+export interface ComputedLoad {
   readonly call: CallExpression;
   readonly from: string;
   /** The name a `require()` call is written with; {@link callsPlatform} owns which one loads. */
   readonly require: Identifier | undefined;
+  /** Whether the call is an AMD `define` or `require` (references-ts.37). */
+  readonly amd: boolean;
   readonly files: readonly Loadable[];
   /** Whether the load reads each file as text or as a URL, which references no declaration of it. */
   readonly asset: boolean;
@@ -136,7 +147,7 @@ function globbed(
   const dir = dirnamePath(file.fileName);
   const root = (): string | undefined => rootOf(file.fileName);
   const against = (at: string): string | undefined => {
-    if (!at.startsWith("/")) {
+    if (!isAbsolutePath(at)) {
       return resolvePath(dir, at);
     }
     const top = root();
@@ -149,9 +160,9 @@ function globbed(
     const negated = written.startsWith("!");
     const pattern = negated ? written.slice(1) : written;
     let path: string | undefined;
-    if (pattern.startsWith("/")) {
+    if (isAbsolutePath(pattern)) {
       path = against(pattern);
-    } else if (pattern.startsWith("./") || pattern.startsWith("../")) {
+    } else if (startsRelativePath(pattern)) {
       path = from === undefined ? undefined : resolvePath(from, pattern);
     } else if (pattern.startsWith("**")) {
       path = pattern;
@@ -173,7 +184,8 @@ function globbed(
  * file itself: an `import()` or `require()` whose path starts with a relative literal naming
  * a directory below the file's loads every candidate below it, as a bundler's context module
  * reads it, and an `import.meta.glob` every candidate its globs match ({@link globbed}). A
- * call of a computed path that names no such directory and no package is an unresolved load.
+ * call of a computed path that names no such directory and no package is an unresolved load,
+ * and so is an AMD call one of whose dependencies names no path ({@link amdUnresolved}).
  */
 export function computedLoadsOf(
   file: SourceFile,
@@ -196,6 +208,7 @@ export function computedLoadsOf(
           call,
           from,
           require: undefined,
+          amd: false,
           files: files ?? [],
           resolved: files !== undefined,
           asset,
@@ -203,6 +216,23 @@ export function computedLoadsOf(
         },
       ];
     }
+    const amd = amdLoadOf(call);
+    if (amd !== undefined) {
+      return amdUnresolved(amd)
+        ? [
+            {
+              call,
+              from,
+              require: amd.callee,
+              amd: true,
+              files: [],
+              resolved: false,
+              asset: false,
+              eager: false,
+            },
+          ]
+        : [];
+    }
     const argument = unwrapped(first);
     const require =
       call.expression.kind === SyntaxKind.ImportKeyword ? undefined : writtenName(call.expression);
@@ -219,7 +249,16 @@ export function computedLoadsOf(
         ? []
         : others.filter((candidate) => relativePath(target, candidate.file.fileName) !== undefined);
     return [
-      { call, from, require, files, resolved: target !== undefined, asset: false, eager: false },
+      {
+        call,
+        from,
+        require,
+        amd: false,
+        files,
+        resolved: target !== undefined,
+        asset: false,
+        eager: false,
+      },
     ];
   });
 }
@@ -300,8 +339,7 @@ function namesPackage(prefix: string | undefined): boolean {
   return (
     prefix !== undefined &&
     prefix !== "" &&
-    !prefix.startsWith(".") &&
-    !prefix.startsWith("/") &&
-    !/^[A-Za-z][A-Za-z\d+.-]*:/u.test(prefix)
+    !cannotStartPackageName(prefix) &&
+    !hasURLScheme(prefix)
   );
 }

package/src/serialization-contract.ts

@@ -1220,7 +1220,8 @@ export interface Decoded {
 
 /**
  * The data members the decodes and copies of `files` fill, as {@link Decoded} names them.
- * A generic declared outside the analysis, or only ambiently, fills the type that a type
+ * A generic declared outside the analysis, or only ambiently, or one that reads a value
+ * {@link readTypes} finds untyped as its own type parameter, fills the type that a type
  * parameter of its own no parameter names binds, where the awaited result carries that
  * type through its data members rather than only naming it, as a store's methods do: no
  * argument hands the value over, so it fills it where the analysis cannot see, and may
@@ -1282,6 +1283,10 @@ function decodedOf<Brand>(
   for (const file of files) {
     file.forEachChild(visit);
   }
+  const read = readTypes(project, untyped);
+  // A generic of the analysis that reads an untyped value as its own type parameter is a
+  // client of what made the value, and fills what that parameter binds as an outside one does.
+  const clients = new Set(read.made.flatMap((type) => (type.isTypeParameter() ? [type.id] : [])));
   const filled: { readonly carried: Type; readonly types: readonly Type[] }[] = [];
   const resolved = queries.resolvedSignatures(calls).map(must);
   for (const signature of resolved) {
@@ -1296,7 +1301,8 @@ function decodedOf<Brand>(
     if (
       declaration === undefined ||
       (inAnalysis(declaration.path) &&
-        (node === undefined || (node.flags & NodeFlags.Ambient) === 0))
+        (node === undefined || (node.flags & NodeFlags.Ambient) === 0) &&
+        !generic.some((id) => clients.has(id)))
     ) {
       continue;
     }
@@ -1318,7 +1324,6 @@ function decodedOf<Brand>(
       filled.push({ carried: awaited(project, given), types });
     }
   }
-  const read = readTypes(project, untyped);
   const copies = copiedNames(project, spreads, calls);
   if (
     filled.length === 0 &&

package/src/stores.ts

@@ -13,6 +13,7 @@ import { nodeKey, type Inventory } from "./inventory.ts";
 import type { Reference } from "./references.ts";
 import type { ProjectView } from "./session.ts";
 import type { Exemption, Mode } from "./sweep.ts";
+import { classedAsTest, madeByTestCode, withheldBy } from "./tests/file-class.ts";
 
 /** One run's stores and reads, over every configuration. */
 export interface Stores {
@@ -39,6 +40,8 @@ export interface Stores {
 /** What one configuration contributes to the run's stores. */
 interface ConfigurationStores {
   readonly references: readonly Reference[];
+  /** The configuration's test-support files, whose references are test code's. */
+  readonly support: ReadonlySet<string>;
   readonly accessors: readonly string[];
 }
 
@@ -71,12 +74,20 @@ export function storesOf(
 ): Stores {
   return {
     references: per.flatMap((one) =>
-      one.references.filter((reference) => !mode.production || !reference.test),
+      one.references.filter((reference) => !withheldBy(mode, reference, one.support)),
     ),
     readInTests: new Set(
       per.flatMap((one) =>
         one.references
-          .filter((reference) => reference.test && reference.use !== "write")
+          .filter(
+            (reference) =>
+              reference.use !== "write" &&
+              classedAsTest(
+                madeByTestCode(reference, one.support),
+                reference.consumer !== undefined,
+                mode,
+              ),
+          )
           .map((reference) => reference.to),
       ),
     ),

package/src/sweep.ts

@@ -7,7 +7,8 @@
  */
 
 import type { TSExemptionClass } from "./exempt-classes.ts";
-import { namesACaller, OUTSIDE, type Edge, type Graph } from "./graph.ts";
+import { namesACaller, OUTSIDE, type Counts, type Edge, type Graph } from "./graph.ts";
+import { edgeWithheldBy } from "./tests/file-class.ts";
 import type { InventorySymbol } from "./inventory.ts";
 import type { Position } from "./position.ts";
 
@@ -54,6 +55,32 @@ export interface Mode {
    * in a test file makes is such a reference, so nothing only a test reaches is live.
    */
   readonly production: boolean;
+  /**
+   * Classes a reference a loaded consumer's test file made as a production one rather than a
+   * test one, `analysis.consumer_tests` at `production`: a classification, not a filter, so it
+   * decides the split a candidate reports as well as what a production sweep counts.
+   */
+  readonly consumerTestsProduction?: boolean;
+}
+
+/** The references to one declaration the mode counts: under `production` none test code made but those it classes as production. */
+function countedRefs(made: Counts | undefined, mode: Mode): number {
+  if (made === undefined) {
+    return 0;
+  }
+  if (!mode.production) {
+    return made.production + made.test;
+  }
+  return made.production + (mode.consumerTestsProduction === true ? made.consumerTest : 0);
+}
+
+/** The references to one declaration, split as the mode classes them, whatever it counts. */
+export function splitRefs(
+  made: Counts | undefined,
+  mode: Mode,
+): { readonly production: number; readonly test: number } {
+  const moved = mode.consumerTestsProduction === true ? (made?.consumerTest ?? 0) : 0;
+  return { production: (made?.production ?? 0) + moved, test: (made?.test ?? 0) - moved };
 }
 
 /** What one sweep runs over besides the graph. */
@@ -134,13 +161,7 @@ export function sweep(graph: Graph, input: SweepInput): Liveness {
     }
   }
 
-  const counted = (at: number): number => {
-    const made = graph.made[at];
-    if (made === undefined) {
-      return 0;
-    }
-    return input.mode.production ? made.production : made.production + made.test;
-  };
+  const counted = (at: number): number => countedRefs(graph.made[at], input.mode);
   const reached = reachable(graph, held, input.mode);
   const liveUnder = graph.symbols.map((_symbol, at): readonly Relation[] => {
     const relations: Relation[] = [];
@@ -169,10 +190,11 @@ export function sweep(graph: Graph, input: SweepInput): Liveness {
     if (dead[at] !== true) {
       return;
     }
+    const split = splitRefs(graph.made[at], input.mode);
     candidates.push({
       id: symbol.id,
-      productionRefs: graph.made[at]?.production ?? 0,
-      testRefs: graph.made[at]?.test ?? 0,
+      productionRefs: split.production,
+      testRefs: split.test,
       relation: counted(at) === 0 ? "reference-counting" : "reachability",
       testOfDeadCode: testOfDeadCode[at] === true,
     });
@@ -223,11 +245,12 @@ export function reachedWithTheTests(
 }
 
 /**
- * The references a loaded consumer makes that the mode counts. A production mode counts
- * none a consumer's test file made, as it counts none of the target's.
+ * The references a loaded consumer or an unheld file makes that the mode counts. A
+ * production mode counts no test reference, but a loaded consumer's where the mode classes
+ * a consumer's tests as production.
  */
 function callsOf(graph: Graph, mode: Mode): readonly Edge[] {
-  return graph.consumed.filter((edge) => !mode.production || !edge.test);
+  return graph.consumed.filter((edge) => !edgeWithheldBy(mode, edge));
 }
 
 /** Per declaration of the graph, whether one of the identifiers names it. */
@@ -280,7 +303,7 @@ function reachable(
   const walk = (holding: boolean): void => {
     for (let at = queue.pop(); at !== undefined; at = queue.pop()) {
       for (const edge of graph.out[at] ?? []) {
-        if (!holding && mode.production && edge.test) {
+        if (!holding && edgeWithheldBy(mode, edge)) {
           continue;
         }
         enter(edge.to, namespaces && !edge.evaluation);

package/src/symbol-keys.ts

@@ -23,10 +23,9 @@ import {
 import { parenthesesRemoved } from "./unwrap.ts";
 import type { Symbol as TSSymbol, Type } from "@typescript/native/sync";
 import type { AliasChains } from "./alias-chain.ts";
-import { nodeKey, type Inventory, type InventorySymbol } from "./inventory.ts";
-import { renderPosition } from "./position.ts";
-import { isAnswered, type PropertyTables } from "./query.ts";
-import type { Reference } from "./references.ts";
+import type { InventorySymbol } from "./inventory.ts";
+import { isAnswered, UNANSWERED, type PropertyTables } from "./query.ts";
+import type { Read, ReadRule } from "./references/read-rule.ts";
 import type { ProjectView } from "./session.ts";
 
 /** One element access whose key is a name, and how the access uses the member it selects. */
@@ -193,104 +192,105 @@ function wellKnownName(name: Node | undefined): string | 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<Brand>(
-  project: ProjectView<Brand>,
-  held: Inventory,
-  chains: AliasChains,
-  root: string,
-  testFiles: ReadonlySet<string>,
-): readonly Reference[] {
-  const queries = project.queries;
-  const ownPaths = project.ownPaths();
-  const iterated: {
-    readonly file: SourceFile;
-    readonly from: string;
-    readonly operand: Expression;
-    readonly protocols: readonly Protocol[];
-  }[] = [];
-  for (const file of project.ownSourceFiles()) {
-    const fileId = held.declarations.get(nodeKey(file, file));
-    if (fileId === undefined) {
-      continue;
-    }
-    const visit = (node: Node, from: string): void => {
-      const holder = held.declarations.get(nodeKey(file, node)) ?? from;
-      if (isForOfStatement(node)) {
-        const protocols: readonly Protocol[] =
-          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<
-    number,
-    readonly { readonly name: string; readonly ids: readonly string[] }[]
-  >();
-  const membersOf = (
-    type: Type,
-  ): readonly { readonly name: string; readonly ids: readonly string[] }[] => {
-    const known = members.get(type.id);
-    if (known !== undefined) {
-      return known;
-    }
-    const keyed: { name: string; ids: readonly string[] }[] = [];
-    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 as { readonly name?: Node } | undefined)?.name);
-        if (name !== undefined) {
-          keyed.push({ name, ids: chains.declarationsOf(property) });
-          break;
-        }
-      }
-    }
-    members.set(type.id, keyed);
-    return keyed;
-  };
-  const found: Reference[] = [];
-  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 as readonly string[]).includes(member.name)) {
-          continue;
+export const iteration: ReadRule = {
+  start() {
+    const iterated: {
+      readonly file: SourceFile;
+      readonly from: string;
+      readonly operand: Expression;
+      readonly protocols: readonly Protocol[];
+    }[] = [];
+    return {
+      visit(node, { file, from }) {
+        if (isForOfStatement(node)) {
+          const protocols: readonly Protocol[] =
+            node.awaitModifier === undefined ? ["iterator"] : ["asyncIterator", "iterator"];
+          iterated.push({ file, from, operand: node.expression, protocols });
+        } 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: Read[] = [];
+        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<
+          number,
+          readonly { readonly name: string; readonly ids: readonly string[] }[] | typeof UNANSWERED
+        >();
+        const membersOf = (type: Type) => {
+          const known = members.get(type.id);
+          if (known !== undefined) {
+            return known;
+          }
+          const properties = queries.propertiesOf(type);
+          const keyed: { name: string; ids: readonly string[] }[] = [];
+          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 as { readonly name?: Node } | undefined)?.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: readonly Protocol[]): readonly string[] =>
+          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 as readonly string[]).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/src/tests/file-class.ts

@@ -0,0 +1,118 @@
+/**
+ * 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 type { SourceFile } from "@typescript/native/ast";
+import type { Edge } from "../graph.ts";
+import { renderPosition } from "../position.ts";
+import type { Reference } from "../references.ts";
+import type { ProjectView } from "../session.ts";
+import type { Mode } from "../sweep.ts";
+import { bytewise } from "../text/compare.ts";
+import { globExpression } from "../text/glob.ts";
+
+/** One rule that classified files as test files, and how many files it matched. */
+export interface TestFileRule {
+  /** The rule's name, as a report's own rule list spells one. */
+  readonly rule: string;
+  readonly matched: number;
+}
+
+/** Whether one file of a side is a test file. */
+export type TestFile = (file: SourceFile) => boolean;
+
+/** The test files of the target: each file the test-runner source names, by its file name. */
+export function targetTestFile(named: ReadonlySet<string>): TestFile {
+  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: readonly string[], root: string): TestFile {
+  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<Brand>(
+  project: ProjectView<Brand>,
+  root: string,
+  testFile: TestFile,
+): readonly string[] {
+  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: Reference, support: ReadonlySet<string>): boolean {
+  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: boolean, consumer: boolean, mode: Mode): boolean {
+  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: Mode,
+  reference: Reference,
+  support: ReadonlySet<string>,
+): boolean {
+  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: Mode, edge: Edge): boolean {
+  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: number): string {
+  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: readonly string[],
+  paths: readonly string[],
+  supportFiles: readonly string[] = [],
+): readonly TestFileRule[] {
+  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));
+}