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

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/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";

package/src/workflow-steps.ts

@@ -1,216 +0,0 @@
-/**
- * The source files a CI workflow's `run:` steps and the repository's git hooks name by their
- * path from the target root. A workflow or hook file is read as text, line by line, with no
- * YAML parsed.
- */
-
-import type { SourceFile } from "@typescript/native/ast";
-import type { Host } from "./host.ts";
-import { scriptTokens } from "./manifest.ts";
-import { joinPath, relativePath, resolvePath } from "./paths.ts";
-import type { SourceFiles } from "./source-files.ts";
-
-/** One file a workflow step names. */
-interface WorkflowEntry {
-  readonly file: SourceFile;
-  /** The token that named it, as the command writes it. */
-  readonly source: string;
-}
-
-const WORKFLOWS = ".github/workflows";
-
-/** A line holding a run command: indentation and one sequence marker before `run:`. */
-const RUN_LINE = /^(\s*(?:- )?)run:(.*)$/u;
-
-/** The directories whose every file is a git hook script, run as the shell runs it. */
-const HOOK_DIRS = [".husky", ".githooks"] as const;
-
-/** The hook manager files whose commands are written under a key, with that key. */
-const HOOK_MANAGERS: readonly (readonly [string, RegExp])[] = [
-  [".pre-commit-config.yaml", /^(\s*(?:- )?)entry:(.*)$/u],
-  ["lefthook.yml", RUN_LINE],
-  ["lefthook.yaml", RUN_LINE],
-  [".lefthook.yml", RUN_LINE],
-];
-
-/** The names GNU make reads a makefile under, in the order it tries them. */
-const MAKEFILES = ["GNUmakefile", "makefile", "Makefile"] as const;
-
-/** The operators that end one shell command of a recipe line. */
-const COMMAND_SEPARATORS = /&&|\|\||;|\|/u;
-
-const BLOCK_SCALAR = /^[|>][+-]?$/u;
-
-const QUOTED = /^(["'])(.*)\1$/su;
-
-/** A token holding one of these is computed or a pattern, so it names no file. */
-const COMPUTED = /[${*?[]/u;
-
-const INDENT = /^\s*/u;
-
-/** The files directly in one directory whose name `accepts`, in name order. */
-function filesIn(host: Host, dir: string, accepts: (name: string) => boolean): readonly string[] {
-  let entries;
-  try {
-    entries = host.readDirectory(dir);
-  } catch {
-    return [];
-  }
-  return entries
-    .filter((entry) => !entry.directory && accepts(entry.name))
-    .map((entry) => joinPath(dir, entry.name))
-    .sort();
-}
-
-function readText(host: Host, path: string): string | undefined {
-  try {
-    return host.readFile(path);
-  } catch {
-    return undefined;
-  }
-}
-
-/** Every command line one workflow file's `run:` steps, or the steps under `key`, hold. */
-export function runCommands(text: string, key: RegExp = RUN_LINE): readonly string[] {
-  const lines = text.split(/\r?\n/u);
-  const found: string[] = [];
-  for (let at = 0; at < lines.length; at += 1) {
-    const match = key.exec(lines[at] ?? "");
-    if (match === null) {
-      continue;
-    }
-    const column = (match[1] ?? "").length;
-    const value = (match[2] ?? "").trim().replace(QUOTED, "$2");
-    if (!BLOCK_SCALAR.test(value)) {
-      found.push(value);
-      continue;
-    }
-    for (let next = at + 1; next < lines.length; next += 1) {
-      const line = lines[next] ?? "";
-      if (line.trim() !== "" && (INDENT.exec(line)?.[0].length ?? 0) <= column) {
-        break;
-      }
-      found.push(line);
-    }
-  }
-  return found;
-}
-
-/**
- * Every token the recipe lines of the target root's makefile hold, each with the directory
- * below the root it is read against: a recipe line is one that starts with a tab, joined
- * with the lines a trailing `\` continues it onto, and make runs each in a shell of its
- * own, so a `cd` moves the directory of the later commands of its line alone.
- */
-function recipeTokens(host: Host, root: string): readonly { token: string; dir: string }[] {
-  const path = MAKEFILES.map((name) => joinPath(root, name)).find(
-    (candidate) => host.kindOf(candidate) === "file",
-  );
-  const text = path === undefined ? undefined : readText(host, path);
-  if (text === undefined) {
-    return [];
-  }
-  const found: { token: string; dir: string }[] = [];
-  for (const line of text.replace(/\\\r?\n/gu, " ").split(/\r?\n/u)) {
-    if (!line.startsWith("\t")) {
-      continue;
-    }
-    let dir = root;
-    for (const command of withoutComment(line.slice(1).replace(/^[@+-]+/u, "")).split(
-      COMMAND_SEPARATORS,
-    )) {
-      const tokens = scriptTokens(command);
-      const [first, target, ...rest] = tokens;
-      if (first === "cd" && target !== undefined && rest.length === 0 && !COMPUTED.test(target)) {
-        dir = resolvePath(dir, target);
-        continue;
-      }
-      for (const token of tokens) {
-        found.push({ token, dir: relativePath(root, dir) ?? "" });
-      }
-    }
-  }
-  return found;
-}
-
-/** One shell line up to its comment: a `#` that starts a word outside quotes. */
-function withoutComment(line: string): string {
-  let quote = "";
-  for (let at = 0; at < line.length; at += 1) {
-    const char = line[at];
-    if (quote !== "") {
-      if (char === quote) {
-        quote = "";
-      } else if (char === "\\" && quote === '"') {
-        at += 1;
-      }
-    } else if (char === "'" || char === '"') {
-      quote = char;
-    } else if (char === "\\") {
-      at += 1;
-    } else if (char === "#" && (at === 0 || /\s/u.test(line[at - 1] ?? ""))) {
-      return line.slice(0, at);
-    }
-  }
-  return line;
-}
-
-/**
- * Every token the target root's workflow steps, git hooks and makefile hold: the `run:`
- * steps of the workflow files in `.github/workflows`, every line of each file in `.husky`
- * and `.githooks`, the `entry:` commands of `.pre-commit-config.yaml`, the `run:` commands
- * of a lefthook file and the makefile's recipe lines.
- */
-export function workflowTokens(host: Host, targetRoot: string): readonly string[] {
-  const root = resolvePath(host.workingDirectory(), targetRoot);
-  const commands: string[] = [];
-  for (const path of filesIn(host, joinPath(root, WORKFLOWS), (name) => /\.ya?ml$/u.test(name))) {
-    commands.push(...runCommands(readText(host, path) ?? ""));
-  }
-  for (const dir of HOOK_DIRS) {
-    for (const path of filesIn(host, joinPath(root, dir), () => true)) {
-      commands.push(...(readText(host, path) ?? "").split(/\r?\n/u).map(withoutComment));
-    }
-  }
-  for (const [name, key] of HOOK_MANAGERS) {
-    commands.push(...runCommands(readText(host, joinPath(root, name)) ?? "", key));
-  }
-  return [
-    ...commands.flatMap((command) => scriptTokens(command)),
-    ...recipeTokens(host, root).map(({ token }) => token),
-  ];
-}
-
-/**
- * The own files the target root's workflow steps and git hooks name, as
- * {@link workflowTokens} reads them: a token equal to a file's path below the target root,
- * with or without a leading `./`, whatever directory the step runs in.
- */
-export function workflowEntries(
-  host: Host,
-  targetRoot: string,
-  files: SourceFiles,
-): readonly WorkflowEntry[] {
-  const found: WorkflowEntry[] = [];
-  for (const token of workflowTokens(host, targetRoot)) {
-    if (COMPUTED.test(token)) {
-      continue;
-    }
-    const file = files.byPath.get(token.startsWith("./") ? token.slice(2) : token);
-    if (file !== undefined) {
-      found.push({ file, source: token });
-    }
-  }
-  const root = resolvePath(host.workingDirectory(), targetRoot);
-  for (const { token, dir } of recipeTokens(host, root)) {
-    const below =
-      COMPUTED.test(token) || dir === ""
-        ? undefined
-        : relativePath(root, resolvePath(joinPath(root, dir), token));
-    const file = below === undefined ? undefined : files.byPath.get(below);
-    if (file !== undefined) {
-      found.push({ file, source: token });
-    }
-  }
-  return found;
-}