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

package/src/setup-failure.ts

@@ -1,39 +0,0 @@
-/**
- * A setup failure: a file or a component the analysis needs and the project does not
- * provide. Each one names what is missing and the fix, on one line of the error stream
- * that starts with its class.
- */
-
-/** The classes of setup failure this analyzer meets. */
-type SetupClass =
-  | "missing-module"
-  | "missing-consumer"
-  | "workspace-member-without-source"
-  | "convention-not-literal";
-
-export interface SetupFailure {
-  readonly setupClass: SetupClass;
-  /** What is missing and the fix, on one line. */
-  readonly detail: string;
-}
-
-/** The failure as the one line of the error stream that names it. */
-export function setupLine(failure: SetupFailure): string {
-  return `setup failure: ${failure.setupClass}: ${failure.detail}`;
-}
-
-/**
- * A run that met a setup failure where none may be dropped: in a configuration the
- * configuration document or the scope declares, in a declared consumer, or in every
- * configuration discovery derived. It ends the run with the failure code and no finding
- * list.
- */
-export class SetupError extends Error {
-  readonly failures: readonly SetupFailure[];
-
-  constructor(failures: readonly SetupFailure[]) {
-    super(failures.map(setupLine).join("\n"));
-    this.name = "SetupError";
-    this.failures = failures;
-  }
-}

package/src/sweep.ts

@@ -1,347 +0,0 @@
-/**
- * Which declarations of one graph are dead, and under which liveness relation.
- * Reference counting holds a declaration live when any declaration references it,
- * whatever that one's own liveness, or when it is a root of a kind that names a caller;
- * reachability holds it live when a path of references reaches it from a root. So a
- * declaration only unreachable ones reference is live under the first, dead under the second.
- */
-
-import type { TSExemptionClass } from "./exempt-classes.ts";
-import { namesACaller, OUTSIDE, type Edge, type Graph } from "./graph.ts";
-import type { InventorySymbol } from "./inventory.ts";
-import type { Position } from "./position.ts";
-
-/** The liveness relation that decided a declaration, as a finding spells it. */
-export type Relation = "reference-counting" | "reachability";
-
-/** One declaration an exemption class holds back, and the evidence it was found by. */
-export interface Exemption {
-  /** The identifier of the declaration held back. */
-  readonly id: string;
-  readonly class: TSExemptionClass;
-  /** One clause naming the relation, then the thing it relates to: `passed to JSON.stringify`. */
-  readonly detail: string;
-  /** Where the evidence is written. */
-  readonly site: Position;
-  /**
-   * The component file, below the target root, whose markup holds the evidence. The
-   * record holds only while that file is live.
-   */
-  readonly whileLive?: string;
-  /**
-   * The interface methods the retained member implements, and whether its body is empty.
-   * The record holds only while one of them is called through its interface.
-   */
-  readonly implementing?: Implementing;
-}
-
-/** The interface methods one retained class member implements, and whether its body is empty. */
-export interface Implementing {
-  /** The declarations of the interface's methods the member answers, by identifier. */
-  readonly methods: readonly string[];
-  readonly empty: boolean;
-}
-
-/**
- * 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;
-}
-
-/** What one sweep runs over besides the graph. */
-export interface SweepInput {
-  /**
-   * The declarations a matched suppression names. A mark holds its declaration live
-   * under both relations and seeds reachability through every reference it makes, so
-   * nothing only a marked declaration references is dead.
-   */
-  readonly marked: readonly string[];
-  /**
-   * The exemptions the run computed. An exempt declaration is never a candidate, and it
-   * seeds reachability as a mark does, so nothing it references is dead; it is live
-   * under reference counting only where something references it. Absent, the sweep
-   * holds nothing back.
-   */
-  readonly exempt?: readonly Exemption[];
-  /**
-   * The declarations a question the checker did not answer could have kept live. Each
-   * is held as an exempt declaration is. Absent, the sweep holds nothing back for one.
-   */
-  readonly unanswered?: readonly string[];
-  readonly mode: Mode;
-}
-
-/** One dead declaration, the relation that found it, and the counts a kind reads. */
-export interface Candidate {
-  readonly id: string;
-  /** The references a production file made to the declaration, whatever the mode counts. */
-  readonly productionRefs: number;
-  /** The references a test file made to it. */
-  readonly testRefs: number;
-  /**
-   * Reference counting where the mode counts no reference to the declaration, and
-   * reachability otherwise, so a declaration dead under both carries the stronger claim.
-   */
-  readonly relation: Relation;
-  /**
-   * Whether the test-of-dead-code rule admitted the declaration: a test declaration whose
-   * set of referenced production declarations is non-empty and wholly dead.
-   */
-  readonly testOfDeadCode: boolean;
-}
-
-/** One graph's answer: what each relation holds live, and what is dead. */
-export interface Liveness {
-  /**
-   * Per declaration, the relations that hold it live, reference counting first. A
-   * declaration neither holds live has no entry.
-   */
-  readonly liveUnder: ReadonlyMap<string, readonly Relation[]>;
-  /** The dead declarations, in the order the inventory holds them. */
-  readonly candidates: readonly Candidate[];
-}
-
-/**
- * Answers which declarations of one graph are dead under the input's mode.
- *
- * The order is the order the answers depend on: the callers and the marks are live
- * before either relation runs, the candidate set is every judged declaration at least
- * one relation does not hold live and no exemption holds back, and the tests of dead
- * code join it.
- */
-export function sweep(graph: Graph, input: SweepInput): Liveness {
-  const marked = flagged(graph, input.marked);
-  const exempt = flagged(graph, [
-    ...(input.exempt ?? []).map((record) => record.id),
-    ...(input.unanswered ?? []),
-  ]);
-  const held = marked.map((mark, at) => mark || exempt[at] === true);
-  // Every root, every mark and every exemption seeds reachability. A root of a kind that
-  // names a caller, and a mark, are live under reference counting as well; a root that
-  // only supposes a caller is not, and neither is an exemption.
-  const called = graph.symbols.map(() => false);
-  for (const root of graph.rooted) {
-    if (namesACaller(root.kind)) {
-      called[root.at] = true;
-    }
-  }
-
-  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 reached = reachable(graph, held, input.mode);
-  const liveUnder = graph.symbols.map((_symbol, at): readonly Relation[] => {
-    const relations: Relation[] = [];
-    if (marked[at] === true || called[at] === true || counted(at) > 0) {
-      relations.push("reference-counting");
-    }
-    if (reached[at] === true) {
-      relations.push("reachability");
-    }
-    return relations;
-  });
-
-  const dead = graph.symbols.map(
-    (_symbol, at) =>
-      graph.subject[at] === true && exempt[at] !== true && (liveUnder[at]?.length ?? 0) < 2,
-  );
-  const testOfDeadCode = admitTestsOfDeadCode(graph, dead, held);
-
-  const candidates: Candidate[] = [];
-  const live = new Map<string, readonly Relation[]>();
-  graph.symbols.forEach((symbol, at) => {
-    const relations = liveUnder[at] ?? [];
-    if (relations.length > 0) {
-      live.set(symbol.id, relations);
-    }
-    if (dead[at] !== true) {
-      return;
-    }
-    candidates.push({
-      id: symbol.id,
-      productionRefs: graph.made[at]?.production ?? 0,
-      testRefs: graph.made[at]?.test ?? 0,
-      relation: counted(at) === 0 ? "reference-counting" : "reachability",
-      testOfDeadCode: testOfDeadCode[at] === true,
-    });
-  });
-
-  return { liveUnder: live, candidates };
-}
-
-/**
- * The directory a test runner reads a manual mock from, whose exports it puts in place of
- * the module's: https://jestjs.io/docs/manual-mocks
- */
-const MANUAL_MOCKS = "__mocks__";
-
-/** Whether a test runner calls or reads one export of a test file: a function, or any export of a manual mock. */
-export function runnerCalls(symbol: InventorySymbol): boolean {
-  return symbol.kind === "function" || symbol.position.path.split("/").includes(MANUAL_MOCKS);
-}
-
-/**
- * Per declaration of the graph, whether the run that counts test references reaches it.
- * That run's roots are the graph's own and, of each test file, its top level and every
- * function it exports, which a test runner may call, and every export of a manual mock,
- * which the runner reads; any other export of a test file, and test-support code, which
- * runs where a test imports it, are judged as any file's are.
- * `held` seeds it as a mark or an exemption seeds a sweep.
- */
-export function reachedWithTheTests(graph: Graph, held: readonly string[]): readonly boolean[] {
-  const tests = graph.symbols.flatMap((symbol, at) => {
-    const exported = symbol.exported && graph.symbols[graph.parent[at] ?? OUTSIDE]?.kind === "file";
-    const called = exported && runnerCalls(symbol);
-    return graph.test[at] === true &&
-      graph.support[at] !== true &&
-      (symbol.kind === "file" || called)
-      ? [{ at, kind: "test-runner" as const }]
-      : [];
-  });
-  return reachable({ ...graph, rooted: [...graph.rooted, ...tests] }, flagged(graph, held), {
-    production: false,
-  });
-}
-
-/**
- * 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.
- */
-function callsOf(graph: Graph, mode: Mode): readonly Edge[] {
-  return graph.consumed.filter((edge) => !mode.production || !edge.test);
-}
-
-/** Per declaration of the graph, whether one of the identifiers names it. */
-function flagged(graph: Graph, ids: readonly string[]): boolean[] {
-  const flags = graph.symbols.map(() => false);
-  for (const id of ids) {
-    const at = graph.at(id);
-    if (at !== OUTSIDE) {
-      flags[at] = true;
-    }
-  }
-  return flags;
-}
-
-/**
- * Per declaration, whether a seed reaches it. The two seeds reach through different
- * reference sets: a held declaration, marked or exempt, is live by a mechanism the
- * analysis cannot see, so no mode withholds a reference it makes, a test declaration's
- * included, while a root reaches through the references the mode counts. The held seed
- * runs first, so what it reaches is expanded under the wider rule.
- */
-function reachable(graph: Graph, held: readonly boolean[], mode: Mode): readonly boolean[] {
-  const reached = graph.symbols.map(() => false);
-  const expanded = graph.symbols.map(() => false);
-  const queue: number[] = [];
-
-  // Reaching a file reaches its top level: the references written outside every
-  // declaration it holds. A reference that reads a file reads the module's namespace,
-  // which reaches what the module exports as well. An evaluation runs the top level
-  // and reads no export, and a root does not expand either: a file a runtime runs
-  // without reading its exports is a root by itself.
-  const enter = (at: number, expands: boolean): void => {
-    if (!reached[at]) {
-      reached[at] = true;
-      queue.push(at);
-    }
-    if (!expands || expanded[at] === true) {
-      return;
-    }
-    expanded[at] = true;
-    for (const exported of graph.exportsOf[at] ?? []) {
-      enter(exported, false);
-    }
-  };
-  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) {
-          continue;
-        }
-        enter(edge.to, !edge.evaluation);
-      }
-    }
-  };
-
-  held.forEach((hold, at) => {
-    if (hold) {
-      enter(at, false);
-    }
-  });
-  walk(true);
-  for (const root of graph.rooted) {
-    enter(root.at, false);
-  }
-  // A consumer's reference reaches what it names as one of the target's own does.
-  for (const edge of callsOf(graph, mode)) {
-    enter(edge.to, !edge.evaluation);
-  }
-  walk(false);
-  return reached;
-}
-
-/**
- * Admits every test declaration whose set of referenced production declarations is
- * non-empty and wholly dead, and returns which it admitted. An ambient declaration describes
- * code the target does not implement, so it is no production declaration here. The set is
- * read from every reference the test makes, which a production sweep does not count. A
- * test-support declaration a test referencing a live target also references is a live
- * target of every test referencing it. A marked or exempt test is never admitted.
- */
-function admitTestsOfDeadCode(
-  graph: Graph,
-  dead: boolean[],
-  held: readonly boolean[],
-): readonly boolean[] {
-  const testCode = (at: number): boolean => graph.test[at] === true || graph.support[at] === true;
-  const judged = graph.symbols.map((_symbol, at) => {
-    let targets = 0;
-    let live = 0;
-    if (testCode(at) && graph.subject[at] === true && held[at] !== true) {
-      for (const edge of graph.out[at] ?? []) {
-        if (
-          testCode(edge.to) ||
-          graph.subject[edge.to] !== true ||
-          graph.ambient[edge.to] === true
-        ) {
-          continue;
-        }
-        targets += 1;
-        if (dead[edge.to] !== true) {
-          live += 1;
-        }
-      }
-    }
-    return { targets, live };
-  });
-  const shared = new Set<number>();
-  judged.forEach(({ live }, at) => {
-    if (live > 0) {
-      for (const edge of graph.out[at] ?? []) {
-        if (graph.support[edge.to] === true) {
-          shared.add(edge.to);
-        }
-      }
-    }
-  });
-  const admitted = graph.symbols.map(() => false);
-  judged.forEach(({ targets, live }, at) => {
-    const sharing = (graph.out[at] ?? []).some((edge) => shared.has(edge.to) && edge.to !== at);
-    if (targets > 0 && live === 0 && !sharing) {
-      dead[at] = true;
-      admitted[at] = true;
-    }
-  });
-  return admitted;
-}

package/src/test-joins.ts

@@ -1,120 +0,0 @@
-/**
- * The test files a derived matrix holds although no configuration's file list names them.
- * The test runner compiles such a file with the options of the nearest compiler
- * configuration at or above it, so the file joins that configuration's program as a file
- * its list names, unless a `package.json` below that configuration's directory makes the
- * file another package's, which its own test runner compiles.
- */
-
-import { sourcePaths } from "./file-facts.ts";
-import type { Host } from "./host.ts";
-import { dirnamePath, joinPath, relativePath } from "./paths.ts";
-import type { Engine } from "./session.ts";
-import { writtenPath, type WorkspaceProgram } from "./workspace-programs.ts";
-
-const PREFERRED = "/tsconfig.json";
-
-/** The configurations of one directory in the order a file joins them: `tsconfig.json` first. */
-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);
-}
-
-/**
- * Per configuration of `configFiles`, the absolute paths of the test files that join it:
- * each file below `root` a pattern of `patterns` names, that no configuration's file list
- * holds, joins the configuration nearest at or above its directory when no `package.json`
- * sits between them. A configuration the compiler cannot read lists nothing and is joined
- * by nothing.
- */
-export function joinedTestFiles(
-  engine: Engine,
-  host: Host,
-  root: string,
-  configFiles: readonly string[],
-  patterns: readonly RegExp[],
-): ReadonlyMap<string, readonly string[]> {
-  const listed = new Set<string>();
-  const byDir = new Map<string, string[]>();
-  for (const configFile of configFiles) {
-    let fileNames: readonly string[];
-    try {
-      fileNames = engine.parseConfigFile(configFile).fileNames;
-    } catch {
-      continue;
-    }
-    fileNames.forEach((name) => listed.add(name));
-    const dir = dirnamePath(configFile);
-    byDir.set(dir, [...(byDir.get(dir) ?? []), configFile].sort(byPreference));
-  }
-  const joins = new Map<string, string[]>();
-  for (const path of sourcePaths(host, root)) {
-    const file = joinPath(root, path);
-    if (listed.has(file) || !patterns.some((pattern) => pattern.test(path))) {
-      continue;
-    }
-    for (let dir = dirnamePath(file); ; dir = dirnamePath(dir)) {
-      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
-      ) {
-        break;
-      }
-    }
-  }
-  return joins;
-}
-
-/**
- * How the snapshot reads each configuration a test file joins: the program `programs`
- * describes with the files added to its root files, or a configuration only the snapshot
- * holds that extends the one `programs` writes, or the configuration itself, and lists
- * every file the configuration lists and the joined ones.
- */
-export function withJoinedTests(
-  engine: Engine,
-  host: Host,
-  programs: ReadonlyMap<string, WorkspaceProgram>,
-  joins: ReadonlyMap<string, readonly string[]>,
-): ReadonlyMap<string, WorkspaceProgram> {
-  const found = new Map(programs);
-  for (const [configFile, files] of joins) {
-    const program = programs.get(configFile);
-    if (program?.kind === "program") {
-      found.set(configFile, {
-        kind: "program",
-        params: {
-          ...program.params,
-          rootFiles: [...(program.params.rootFiles ?? []), ...files],
-        },
-      });
-      continue;
-    }
-    let listed: readonly string[];
-    try {
-      listed =
-        program?.kind === "configuration"
-          ? engine.parseConfigJson(JSON.parse(program.text), program.file).fileNames
-          : engine.parseConfigFile(configFile).fileNames;
-    } catch {
-      continue;
-    }
-    const value =
-      program?.kind === "configuration"
-        ? { ...(JSON.parse(program.text) as Record<string, unknown>), files: [...listed, ...files] }
-        : { extends: configFile, files: [...listed, ...files] };
-    found.set(configFile, {
-      kind: "configuration",
-      file: program?.kind === "configuration" ? program.file : writtenPath(host, configFile),
-      text: `${JSON.stringify({ ...value, include: [] }, null, 2)}\n`,
-    });
-  }
-  return found;
-}

package/src/value-flow.ts

@@ -1,104 +0,0 @@
-/**
- * The values a program hands to a position the checker types from its context: the
- * initializer of a declaration whose type is written, an assignment's right side, an
- * argument, a returned value, an arrow function's expression body, an array element, an
- * object property, and the operand of `as` or `satisfies`.
- */
-
-import {
-  isArrayLiteralExpression,
-  isArrowFunction,
-  isAsExpression,
-  isBinaryExpression,
-  isCallExpression,
-  isConditionalExpression,
-  isIdentifier,
-  isNewExpression,
-  isParameterDeclaration,
-  isParenthesizedExpression,
-  isPropertyAssignment,
-  isPropertyDeclaration,
-  isReturnStatement,
-  isSatisfiesExpression,
-  isShorthandPropertyAssignment,
-  isSpreadElement,
-  isVariableDeclaration,
-  SyntaxKind,
-  type Expression,
-  type Node,
-} from "@typescript/native/ast";
-
-/** The operators of an assignment whose right side is stored into the left side's type. */
-const STORES: ReadonlySet<SyntaxKind> = new Set([
-  SyntaxKind.EqualsToken,
-  SyntaxKind.QuestionQuestionEqualsToken,
-  SyntaxKind.BarBarEqualsToken,
-  SyntaxKind.AmpersandAmpersandEqualsToken,
-]);
-
-/** Whether a declaration writes its type, so its initializer is read in that type's context. */
-function writesType(node: Node): boolean {
-  return (node as { readonly type?: Node }).type !== undefined;
-}
-
-/**
- * The values one written expression hands on: the expression itself, or what it
- * evaluates to through parentheses, a conditional and the operators whose result is
- * one of their operands.
- */
-export function valuesOf(expression: Expression): readonly Expression[] {
-  if (isParenthesizedExpression(expression)) {
-    return valuesOf(expression.expression);
-  }
-  if (isConditionalExpression(expression)) {
-    return [...valuesOf(expression.whenTrue), ...valuesOf(expression.whenFalse)];
-  }
-  if (isBinaryExpression(expression)) {
-    const operator = expression.operatorToken.kind;
-    if (operator === SyntaxKind.QuestionQuestionToken || operator === SyntaxKind.BarBarToken) {
-      return [...valuesOf(expression.left), ...valuesOf(expression.right)];
-    }
-    if (operator === SyntaxKind.AmpersandAmpersandToken || operator === SyntaxKind.CommaToken) {
-      return valuesOf(expression.right);
-    }
-  }
-  return [expression];
-}
-
-/** The expressions one node hands to a position typed by its context. */
-export function handedOn(node: Node): readonly Expression[] {
-  if (
-    (isVariableDeclaration(node) || isPropertyDeclaration(node) || isParameterDeclaration(node)) &&
-    node.initializer !== undefined &&
-    writesType(node)
-  ) {
-    return [node.initializer];
-  }
-  if (isBinaryExpression(node) && STORES.has(node.operatorToken.kind)) {
-    return [node.right];
-  }
-  if (isCallExpression(node) || isNewExpression(node)) {
-    return (node.arguments ?? []).filter((argument) => !isSpreadElement(argument));
-  }
-  if (isReturnStatement(node)) {
-    return node.expression === undefined ? [] : [node.expression];
-  }
-  if (isArrowFunction(node)) {
-    return node.body.kind === SyntaxKind.Block ? [] : [node.body];
-  }
-  if (isArrayLiteralExpression(node)) {
-    return node.elements.filter(
-      (element) => !isSpreadElement(element) && element.kind !== SyntaxKind.OmittedExpression,
-    );
-  }
-  if (isPropertyAssignment(node)) {
-    return [node.initializer];
-  }
-  if (isShorthandPropertyAssignment(node)) {
-    return isIdentifier(node.name) ? [node.name] : [];
-  }
-  if (isAsExpression(node) || isSatisfiesExpression(node)) {
-    return [node.expression];
-  }
-  return [];
-}

package/src/version.ts

@@ -1,7 +0,0 @@
-/**
- * The Contract version this analyzer implements. It is the resolved value of
- * `contract_version` when no configuration source supplies one, and it moves
- * independently of the analyzer's own version, which is the one the host answers
- * from the package the analyzer was installed from.
- */
-export const CONTRACT_VERSION = "8.0.0";