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

package/dist/src/sweep.js

@@ -1,224 +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 { namesACaller, OUTSIDE } from "./graph.js";
-/**
- * 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, input) {
-    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) => {
-        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) => {
-        const relations = [];
-        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 = [];
-    const live = new Map();
-    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) {
-    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, held) {
-    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" }]
-            : [];
-    });
-    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, mode) {
-    return graph.consumed.filter((edge) => !mode.production || !edge.test);
-}
-/** Per declaration of the graph, whether one of the identifiers names it. */
-function flagged(graph, ids) {
-    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, held, mode) {
-    const reached = graph.symbols.map(() => false);
-    const expanded = graph.symbols.map(() => false);
-    const queue = [];
-    // 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, expands) => {
-        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) => {
-        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, dead, held) {
-    const testCode = (at) => 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();
-    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/dist/src/test-joins.js

@@ -1,101 +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.js";
-import { dirnamePath, joinPath, relativePath } from "./paths.js";
-import { writtenPath } from "./workspace-programs.js";
-const PREFERRED = "/tsconfig.json";
-/** The configurations of one directory in the order a file joins them: `tsconfig.json` first. */
-function byPreference(a, b) {
-    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, host, root, configFiles, patterns) {
-    const listed = new Set();
-    const byDir = new Map();
-    for (const configFile of configFiles) {
-        let fileNames;
-        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();
-    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, host, programs, joins) {
-    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;
-        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), 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/dist/src/version.js

@@ -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/dist/src/workflow-steps.js

@@ -1,185 +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 { scriptTokens } from "./manifest.js";
-import { joinPath, relativePath, resolvePath } from "./paths.js";
-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"];
-/** The hook manager files whose commands are written under a key, with that key. */
-const HOOK_MANAGERS = [
-    [".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"];
-/** 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, dir, accepts) {
-    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, path) {
-    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, key = RUN_LINE) {
-    const lines = text.split(/\r?\n/u);
-    const found = [];
-    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, root) {
-    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 = [];
-    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) {
-    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, targetRoot) {
-    const root = resolvePath(host.workingDirectory(), targetRoot);
-    const commands = [];
-    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, targetRoot, files) {
-    const found = [];
-    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;
-}

package/src/base-url.ts

@@ -1,24 +0,0 @@
-import { resolvePath } from "./paths.ts";
-import type { Engine } from "./session.ts";
-
-type CompilerOptions = ReturnType<Engine["parseConfigFile"]>["options"];
-
-/**
- * The `paths` one configuration's resolved options map under the compilers before version
- * 7, each target absolute: a target is read against the effective `baseUrl`, and a specifier
- * no other pattern maps is looked up below it. Undefined where no `baseUrl` is set, so the
- * options' own `paths` stand. Version 7 reads no `baseUrl`:
- * https://github.com/microsoft/TypeScript/issues/62207
- */
-export function baseUrlPaths(options: CompilerOptions): Record<string, string[]> | undefined {
-  const baseUrl: unknown = Reflect.get(options, "baseUrl");
-  if (typeof baseUrl !== "string") {
-    return undefined;
-  }
-  return Object.fromEntries(
-    Object.entries({ "*": ["*"], ...options.paths }).map(([key, targets]) => [
-      key,
-      targets.map((target) => resolvePath(baseUrl, target)),
-    ]),
-  );
-}