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

package/src/suppress.ts

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

package/src/symbol-keys.ts

@@ -12,7 +12,6 @@ import {
   isIdentifier,
   isNoSubstitutionTemplateLiteral,
   isNumericLiteral,
-  isParenthesizedExpression,
   isPropertyAccessExpression,
   isSpreadElement,
   isStringLiteral,
@@ -21,6 +20,7 @@ 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";
@@ -52,10 +52,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;
   }

package/src/template-field.ts

@@ -20,6 +20,8 @@ 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";
 
 /** One template, by its path below the target root. */
 interface TemplateFile {
@@ -50,14 +52,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
@@ -69,15 +63,8 @@ function compare(a: string, b: string): number {
 export function readTemplates(host: Host, targetRoot: string, analysis: 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));
@@ -104,7 +91,7 @@ export function readTemplates(host: Host, targetRoot: string, analysis: Analysis
     delimiters: analysis.templateDelimiters,
     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/test-globals.ts

@@ -25,10 +25,12 @@ import {
 } from "@typescript/native/ast";
 import type { ParseFile } from "./configuration-files.ts";
 import type { Host } from "./host.ts";
-import { dirnamePath, joinPath } from "./paths.ts";
+import { ancestors, dirnamePath, joinPath } from "./paths.ts";
 import { UNANSWERED } from "./query.ts";
 import type { Engine, ProjectView } from "./session.ts";
 import { writtenPath, type WorkspaceProgram } from "./workspace-programs.ts";
+import { filesIn } from "./fs/tree.ts";
+import { holdsManifest, INSTALLED_PACKAGES } from "./fs/manifest.ts";
 
 /** The test runner whose configuration injects the globals, and the `types` entry declaring them. */
 export const GLOBALS_RUNNER = "vitest";
@@ -120,16 +122,7 @@ function setsGlobals(file: SourceFile): boolean {
 
 /** Whether the runner's configuration in one manifest's directory injects the globals. */
 function injectsGlobals(host: Host, parse: ParseFile, dir: string): boolean {
-  let names: readonly string[];
-  try {
-    names = host
-      .readDirectory(dir)
-      .filter((entry) => !entry.directory && RUNNER_CONFIG.test(entry.name))
-      .map((entry) => entry.name);
-  } catch {
-    return false;
-  }
-  return names.some((name) => {
+  return filesIn(host, dir, (name) => RUNNER_CONFIG.test(name)).some((name) => {
     const path = joinPath(dir, name);
     try {
       return setsGlobals(parse(path, host.readFile(path)));
@@ -141,26 +134,15 @@ function injectsGlobals(host: Host, parse: ParseFile, dir: string): boolean {
 
 /** Whether a file declaring the globals is installed where the configuration resolves packages from. */
 function globalsInstalled(host: Host, configFile: string): boolean {
-  for (let dir = dirnamePath(configFile); ; dir = dirnamePath(dir)) {
-    if (host.kindOf(joinPath(dir, "node_modules", GLOBALS_RUNNER, "globals.d.ts")) === "file") {
-      return true;
-    }
-    if (dirnamePath(dir) === dir) {
-      return false;
-    }
-  }
+  return ancestors(dirnamePath(configFile)).some(
+    (dir) =>
+      host.kindOf(joinPath(dir, INSTALLED_PACKAGES, GLOBALS_RUNNER, "globals.d.ts")) === "file",
+  );
 }
 
 /** The directory of the manifest nearest one configuration file, at or above its own. */
 function manifestDir(host: Host, configFile: string): string | undefined {
-  for (let dir = dirnamePath(configFile); ; dir = dirnamePath(dir)) {
-    if (host.kindOf(joinPath(dir, "package.json")) === "file") {
-      return dir;
-    }
-    if (dirnamePath(dir) === dir) {
-      return undefined;
-    }
-  }
+  return ancestors(dirnamePath(configFile)).find((dir) => holdsManifest(host, dir));
 }
 
 function typesOf(value: unknown): readonly string[] | undefined {

package/src/test-joins.ts

@@ -8,9 +8,11 @@
 
 import { sourcePaths } from "./file-facts.ts";
 import type { Host } from "./host.ts";
-import { dirnamePath, joinPath, relativePath } from "./paths.ts";
+import { ancestors, dirnamePath, joinPath } from "./paths.ts";
 import type { Engine } from "./session.ts";
 import { writtenPath, type WorkspaceProgram } from "./workspace-programs.ts";
+import { bytewise } from "./text/compare.ts";
+import { holdsManifest } from "./fs/manifest.ts";
 
 const PREFERRED = "/tsconfig.json";
 
@@ -18,7 +20,7 @@ const PREFERRED = "/tsconfig.json";
 function byPreference(a: string, b: string): number {
   const first = a.endsWith(PREFERRED) ? 0 : 1;
   const second = b.endsWith(PREFERRED) ? 0 : 1;
-  return first - second || (a < b ? -1 : a > b ? 1 : 0);
+  return first - second || bytewise(a, b);
 }
 
 /**
@@ -54,17 +56,13 @@ export function joinedTestFiles(
     if (listed.has(file) || !patterns.some((pattern) => pattern.test(path))) {
       continue;
     }
-    for (let dir = dirnamePath(file); ; dir = dirnamePath(dir)) {
+    for (const dir of ancestors(dirnamePath(file), root)) {
       const [nearest] = byDir.get(dir) ?? [];
       if (nearest !== undefined) {
         joins.set(nearest, [...(joins.get(nearest) ?? []), file]);
         break;
       }
-      if (
-        host.kindOf(joinPath(dir, "package.json")) === "file" ||
-        dir === root ||
-        relativePath(root, dir) === undefined
-      ) {
+      if (holdsManifest(host, dir)) {
         break;
       }
     }

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;
+}

package/src/text/glob.ts

@@ -0,0 +1,210 @@
+/**
+ * Glob patterns over paths in two forms. The configured form (the configuration, convention
+ * rows, bundler entries, workspace member patterns) has `*` and `?` within a segment, `**`
+ * across segments and brace lists. A `.gitignore` line has git's form: bracket expressions
+ * and backslash escapes, no brace lists (https://git-scm.com/docs/gitignore#_pattern_format).
+ * A configured root is not a glob: it names a symbol reference, and is read where it is used.
+ */
+
+type GlobForm = "configured" | "gitignore";
+
+/**
+ * One character of a pattern as the expression syntax reads it literally. The set escaped
+ * is closed: under the unicode flag an escape of any other character is refused outright.
+ */
+function quoted(character: string): string {
+  return /[.*+?^${}()|[\]\\/]/u.test(character) ? `\\${character}` : character;
+}
+
+/**
+ * The ASCII ranges each POSIX class a bracket expression may name holds, as git's own
+ * character table reads them, each range written as its first and last character.
+ */
+const CLASSES: ReadonlyMap<string, string> = new Map([
+  ["alnum", "09AZaz"],
+  ["alpha", "AZaz"],
+  ["blank", "\t\t  "],
+  ["cntrl", "\0\x1f\x7f\x7f"],
+  ["digit", "09"],
+  ["graph", "!~"],
+  ["lower", "az"],
+  ["print", " ~"],
+  ["punct", "!/:@[`{~"],
+  ["space", "\t\n\r\r  "],
+  ["upper", "AZ"],
+  ["xdigit", "09AFaf"],
+]);
+
+/** What a pattern git cannot read matches: nothing, as git aborts the whole match. */
+const NOTHING = "(?!)";
+
+/** One code point as a member of an expression class. */
+function member(point: number): string {
+  return `\\u{${point.toString(16)}}`;
+}
+
+/**
+ * The class a bracket expression opening at `open` denotes, and the index past its `]`,
+ * read as git's wildmatch reads it: a leading `!` or `^` negates it, a `]` first is a
+ * member, `\` escapes one character, `x-y` is a range (one whose `y` is below `x` holds
+ * `x` alone) and `[:name:]` a POSIX class. An unclosed bracket or an unknown class name
+ * matches nothing. Neither form matches the solidus.
+ */
+function bracket(pattern: string, open: number): { source: string; end: number } {
+  let at = open + 1;
+  const negated = pattern[at] === "!" || pattern[at] === "^";
+  if (negated) {
+    at += 1;
+  }
+  const next = (): number | undefined => {
+    const point = pattern.codePointAt(at);
+    at += point !== undefined && point > 0xffff ? 2 : 1;
+    return point;
+  };
+  let members = "";
+  let low: number | undefined;
+  for (let first = true; ; first = false) {
+    let point = next();
+    if (point === undefined) {
+      return { source: NOTHING, end: pattern.length };
+    }
+    if (point === 0x5d && !first) {
+      return { source: negated ? `[^/${members}]` : `(?!/)[${members}]`, end: at };
+    }
+    if (point === 0x2d && low !== undefined && at < pattern.length && pattern[at] !== "]") {
+      let high = next();
+      if (high === 0x5c) {
+        high = next();
+      }
+      if (high === undefined) {
+        return { source: NOTHING, end: pattern.length };
+      }
+      members += high >= low ? `${member(low)}-${member(high)}` : "";
+      low = undefined;
+      continue;
+    }
+    if (point === 0x5b && pattern[at] === ":") {
+      const close = pattern.indexOf("]", at + 1);
+      if (close < 0) {
+        return { source: NOTHING, end: pattern.length };
+      }
+      if (close > at + 1 && pattern[close - 1] === ":") {
+        const ranges = CLASSES.get(pattern.slice(at + 1, close - 1));
+        if (ranges === undefined) {
+          return { source: NOTHING, end: pattern.length };
+        }
+        for (let one = 0; one < ranges.length; one += 2) {
+          members += `${member(ranges.charCodeAt(one))}-${member(ranges.charCodeAt(one + 1))}`;
+        }
+        low = undefined;
+        at = close + 1;
+        continue;
+      }
+    }
+    if (point === 0x5c) {
+      point = next();
+      if (point === undefined) {
+        return { source: NOTHING, end: pattern.length };
+      }
+    }
+    members += member(point);
+    low = point;
+  }
+}
+
+/** The expression source of one pattern with no brace list. */
+function source(pattern: string, form: GlobForm): string {
+  let text = "";
+  let at = 0;
+  while (at < pattern.length) {
+    if (pattern.startsWith("**/", at)) {
+      text += "(?:[^/]*/)*";
+      at += 3;
+      continue;
+    }
+    if (pattern.startsWith("**", at)) {
+      text += ".*";
+      at += 2;
+      continue;
+    }
+    const character = pattern[at] ?? "";
+    if (form === "gitignore" && character === "[") {
+      const read = bracket(pattern, at);
+      text += read.source;
+      at = read.end;
+      continue;
+    }
+    if (form === "gitignore" && character === "\\" && at + 1 < pattern.length) {
+      text += quoted(pattern[at + 1] ?? "");
+      at += 2;
+      continue;
+    }
+    at += 1;
+    text += character === "*" ? "[^/]*" : character === "?" ? "[^/]" : quoted(character);
+  }
+  return text;
+}
+
+/** A pattern with every brace list expanded into its alternatives; a lone `{` stands for itself. */
+export function braceExpanded(pattern: string): readonly string[] {
+  const open = pattern.indexOf("{");
+  const close = open < 0 ? -1 : pattern.indexOf("}", open);
+  if (close < 0) {
+    return [pattern];
+  }
+  const before = pattern.slice(0, open);
+  const after = pattern.slice(close + 1);
+  return pattern
+    .slice(open + 1, close)
+    .split(",")
+    .flatMap((member) => braceExpanded(before + member + after));
+}
+
+/** The expression one whole-path pattern of the configured form denotes. */
+export function globExpression(pattern: string): RegExp {
+  const alternatives = braceExpanded(pattern).map((one) => source(one, "configured"));
+  return new RegExp(`^(?:${alternatives.join("|")})$`, "u");
+}
+
+/** The expression one `.gitignore` pattern denotes over a path below its file's directory. */
+export function gitignoreExpression(pattern: string): RegExp {
+  return new RegExp(`^${source(pattern, "gitignore")}$`, "u");
+}
+
+const SEGMENTS = new Map<string, RegExp>();
+
+/**
+ * Whether one directory name matches one segment of a workspace's member pattern, its brace
+ * lists already expanded. Neither `*` nor `?` matches a leading dot, as npm's workspaces read
+ * them: https://docs.npmjs.com/cli/using-npm/workspaces
+ */
+export function segmentMatches(segment: string, name: string): boolean {
+  if (name.startsWith(".") && !segment.startsWith(".")) {
+    return false;
+  }
+  let expression = SEGMENTS.get(segment);
+  if (expression === undefined) {
+    expression = globExpression(segment);
+    SEGMENTS.set(segment, expression);
+  }
+  return expression.test(name);
+}
+
+/**
+ * Whether one path's segments match a member pattern's, `**` standing for any run of segments
+ * that starts with no dot.
+ */
+export function pathMatches(pattern: readonly string[], path: readonly string[]): boolean {
+  const [head, ...rest] = pattern;
+  if (head === undefined) {
+    return path.length === 0;
+  }
+  if (head === "**") {
+    return (
+      pathMatches(rest, path) ||
+      (path.length > 0 && !(path[0] ?? "").startsWith(".") && pathMatches(pattern, path.slice(1)))
+    );
+  }
+  const [name, ...below] = path;
+  return name !== undefined && segmentMatches(head, name) && pathMatches(rest, below);
+}