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

package/src/symbol-keys.ts

@@ -12,7 +12,6 @@ import {
   isIdentifier,
   isNoSubstitutionTemplateLiteral,
   isNumericLiteral,
-  isParenthesizedExpression,
   isPropertyAccessExpression,
   isSpreadElement,
   isStringLiteral,
@@ -21,12 +20,12 @@ import {
   type Node,
   type SourceFile,
 } from "@typescript/native/ast";
+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. */
@@ -52,10 +51,7 @@ interface KeyedUse {
 
 /** The identifier an element access's argument names its key by, where it is a name. */
 export function keyNameOf(argument: Node): Node | undefined {
-  let at = argument;
-  while (isParenthesizedExpression(at)) {
-    at = at.expression;
-  }
+  const at = parenthesesRemoved(argument);
   if (isIdentifier(at)) {
     return at;
   }
@@ -196,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/template-field.ts

@@ -13,13 +13,16 @@
  */
 
 import { readComponent } from "./component-files.ts";
-import { ConfigError, type Analysis, type TemplateDelimiters } from "./config.ts";
+import type { ResolvedConfig, TemplateDelimiters } from "./config.ts";
 import type { DetectorInput, Evidence } from "./exempt.ts";
 import type { Host } from "./host.ts";
 import type { SymbolKind } from "./inventory.ts";
 import { memberNames } from "./member-names.ts";
 import { extensionOf, isAbsolutePath, joinPath, normalizePath, relativePath } from "./paths.ts";
 import { isComponentFile, type Position } from "./position.ts";
+import { bytewise } from "./text/compare.ts";
+import { filesBelow } from "./fs/tree.ts";
+import { UsageError } from "./usage.ts";
 
 /** One template, by its path below the target root. */
 interface TemplateFile {
@@ -50,14 +53,6 @@ const READ_BY_MARKUP: ReadonlySet<SymbolKind> = new Set([...READ_BY_A_TEMPLATE,
 /** One identifier, as the grammar of the analyzed language spells one. */
 const IDENTIFIER = /[\p{ID_Start}$_][\p{ID_Continue}$\u200C\u200D]*/uy;
 
-/** Two strings ordered bytewise. */
-function compare(a: string, b: string): number {
-  if (a === b) {
-    return 0;
-  }
-  return a < b ? -1 : 1;
-}
-
 /**
  * Every template under the configured directories, read once for the run, in path
  * order and each file once. A directory is named relative to the target root, and
@@ -66,25 +61,22 @@ function compare(a: string, b: string): number {
  * exemption it was configured for off. A symbolic link to a directory is not
  * followed.
  */
-export function readTemplates(host: Host, targetRoot: string, analysis: Analysis): Templates {
+export function readTemplates(
+  host: Host,
+  targetRoot: string,
+  analysis: ResolvedConfig["analysis"],
+): Templates {
   const files = new Map<string, string>();
   const read = (dir: string): void => {
-    const entries = [...host.readDirectory(joinPath(targetRoot, dir))].sort((a, b) =>
-      compare(a.name, b.name),
-    );
-    for (const entry of entries) {
-      const path = joinPath(dir, entry.name);
-      if (entry.directory) {
-        read(path);
-        continue;
-      }
+    for (const below of filesBelow(host, joinPath(targetRoot, dir), () => true)) {
+      const path = joinPath(dir, below);
       const absolute = joinPath(targetRoot, path);
       if (!files.has(path) && host.kindOf(absolute) === "file") {
         files.set(path, host.readFile(absolute));
       }
     }
   };
-  for (const configured of analysis.templateDirs) {
+  for (const configured of analysis.template_dirs) {
     const dir = normalizePath(configured);
     if (
       isAbsolutePath(dir) ||
@@ -92,19 +84,17 @@ export function readTemplates(host: Host, targetRoot: string, analysis: Analysis
       dir.startsWith("../") ||
       host.kindOf(joinPath(targetRoot, dir)) !== "directory"
     ) {
-      throw new ConfigError(
-        "malformed",
-        "analysis.template_dirs",
+      throw new UsageError(
         `analysis.template_dirs: ${JSON.stringify(configured)} is not a directory below the target root`,
       );
     }
     read(dir);
   }
   return {
-    delimiters: analysis.templateDelimiters,
+    delimiters: analysis.template_delimiters,
     files: [...files]
       .map(([path, text]) => ({ path, text }))
-      .sort((a, b) => compare(a.path, b.path)),
+      .sort((a, b) => bytewise(a.path, b.path)),
   };
 }
 

package/src/tests/file-class.ts

@@ -0,0 +1,135 @@
+/**
+ * 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 "../liveness/graph.ts";
+import { renderPosition } from "../position.ts";
+import type { Reference } from "../references.ts";
+import type { ProjectView } from "../session.ts";
+import { bytewise } from "../text/compare.ts";
+import { globExpression } from "../text/glob.ts";
+
+/**
+ * The run's reference mode, decided once by the composition and read by every stage
+ * that counts references.
+ */
+export interface Mode {
+  /**
+   * Counts no reference a test file made, under either relation. Every reference a root
+   * 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;
+}
+
+/** 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));
+}

package/src/{outside-tests.ts → tests/outside.ts}

@@ -19,19 +19,25 @@ import {
   type Node,
   type SourceFile,
 } from "@typescript/native/ast";
-import { RESOLVED_EXTENSIONS, type ParseFile } from "./configuration-files.ts";
-import { emittedFrom } from "./emit-map.ts";
-import type { Host } from "./host.ts";
-import type { Inventory } from "./inventory.ts";
-import { namesImported } from "./module-declarations.ts";
-import { dirnamePath, joinPath, normalizePath, queriedModulePath } from "./paths.ts";
-import { renderPosition } from "./position.ts";
-import { nameComponent } from "./ref.ts";
-import type { Reference } from "./references.ts";
+import { RESOLVED_EXTENSIONS, type ParseFile } from "../entries/configuration-files.ts";
+import { emittedFrom } from "../load/emit-map.ts";
+import type { Host } from "../host.ts";
+import type { Inventory } from "../inventory.ts";
+import { namesImported } from "../import-bindings.ts";
+import {
+  dirnamePath,
+  joinPath,
+  normalizePath,
+  queriedModulePath,
+  startsRelativePath,
+} from "../paths.ts";
+import { renderPosition } from "../position.ts";
+import { nameComponent } from "../ref.ts";
+import type { Reference } from "../references.ts";
 
 /** The paths below the target root one relative specifier may name, written path first. */
 function candidates(dir: string, specifier: string): readonly string[] {
-  if (!specifier.startsWith("./") && !specifier.startsWith("../")) {
+  if (!startsRelativePath(specifier)) {
     return [];
   }
   const path = normalizePath(dir === "" ? specifier : `${dir}/${specifier}`);

package/src/{test-support.ts → tests/support.ts}

@@ -6,11 +6,15 @@
  * test code.
  */
 
-import { CONVENTION_ROWS, TEST_LIBRARIES, TEST_LIBRARY_SCOPES } from "./convention-rows.ts";
-import { packageOfSpecifier } from "./dependencies.ts";
-import type { InventorySymbol } from "./inventory.ts";
-import type { Reference } from "./references.ts";
-import type { Root } from "./roots.ts";
+import {
+  CONVENTION_ROWS,
+  TEST_LIBRARIES,
+  TEST_LIBRARY_SCOPES,
+} from "../entries/convention-rows.ts";
+import { packageOfSpecifier } from "../dependencies.ts";
+import type { InventorySymbol } from "../inventory.ts";
+import type { Reference } from "../references.ts";
+import type { Root } from "../roots/root-set.ts";
 
 /** The root kind that never takes a file out of test-support code: the skip only withholds. */
 const SKIP_ROOT = "type-error";
@@ -20,7 +24,12 @@ const SKIP_ROOT = "type-error";
  * convention row reads test files for, and the convention table's test libraries.
  */
 const TEST_PACKAGES: ReadonlySet<string> = new Set([
-  ...CONVENTION_ROWS.filter((row) => row.testFiles !== undefined).map((row) => row.package),
+  ...CONVENTION_ROWS.filter(
+    (row) =>
+      row.testFiles !== undefined ||
+      row.testDirectories !== undefined ||
+      row.testRunner !== undefined,
+  ).map((row) => row.package),
   ...TEST_LIBRARIES,
 ]);
 
@@ -209,18 +218,3 @@ export function testSupportFiles(
   );
   return { support, testUsed: new Set([...onlyTests].filter((path) => !support.has(path))) };
 }
-
-/** The references with every one a test-support file makes counted as a test reference. */
-export function supportReferences(
-  references: readonly Reference[],
-  support: ReadonlySet<string>,
-): readonly Reference[] {
-  if (support.size === 0) {
-    return references;
-  }
-  return references.map((reference) =>
-    !reference.test && support.has(reference.position.path)
-      ? { ...reference, test: true }
-      : reference,
-  );
-}

package/src/text/compare.ts

@@ -0,0 +1,27 @@
+/**
+ * Two strings in the order of their UTF-8 bytes, the order every set of a run is read in.
+ * That is code point order, which UTF-16 code unit order (`<` on strings) breaks above
+ * U+FFFF: a surrogate unit is below U+E000 while the code point it encodes is above U+FFFF.
+ */
+export function bytewise(a: string, b: string): number {
+  if (a === b) {
+    return 0;
+  }
+  const length = Math.min(a.length, b.length);
+  for (let at = 0; at < length; at += 1) {
+    const x = a.charCodeAt(at);
+    const y = b.charCodeAt(at);
+    if (x !== y) {
+      return ranked(x) < ranked(y) ? -1 : 1;
+    }
+  }
+  return a.length < b.length ? -1 : 1;
+}
+
+/** One UTF-16 unit moved so that a surrogate ranks above every unit of U+E000 to U+FFFF. */
+function ranked(unit: number): number {
+  if (unit >= 0xe000) {
+    return unit - 0x800;
+  }
+  return unit >= 0xd800 ? unit + 0x2000 : unit;
+}