probatio 0.0.0-stage → 0.0.1

package/dist/mutate/node-coverage.mjs

@@ -0,0 +1,245 @@
+// Baseline-only per-test line map for node --test. Loaded with --import in each
+// test-file process. Writes one shard; the runner merges shards after the suite.
+// takePreciseCoverage resets counters, so each sample is only what ran since the last take.
+import { randomBytes } from "node:crypto"
+import { mkdirSync, writeFileSync } from "node:fs"
+import { Session } from "node:inspector/promises"
+import { findSourceMap } from "node:module"
+import { after, afterEach, before } from "node:test"
+import path from "node:path"
+import { fileURLToPath } from "node:url"
+
+const B64 = new Int32Array(128)
+for (let i = 0; i < 64; i++) B64["ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".charCodeAt(i)] = i
+
+function decodeSegments(row) {
+  const segments = []
+  let i = 0
+  while (i < row.length) {
+    const fields = []
+    while (i < row.length && row.charCodeAt(i) !== 44) {
+      let value = 0
+      let shift = 0
+      let digit = 0
+      do {
+        digit = B64[row.charCodeAt(i++)]
+        value |= (digit & 31) << shift
+        shift += 5
+      } while (digit & 32)
+      fields.push(value & 1 ? -(value >> 1) : value >> 1)
+    }
+    if (row.charCodeAt(i) === 44) i++
+    if (fields.length > 0) segments.push(fields)
+  }
+  return segments
+}
+
+const mapPath = process.env.PROBATIO_COVERAGE_MAP
+if (mapPath) {
+  const session = new Session()
+  let started = false
+  try {
+    session.connect()
+    await session.post("Profiler.enable")
+    await session.post("Debugger.enable")
+    await session.post("Profiler.startPreciseCoverage", { callCount: true, detailed: true })
+    started = true
+  } catch (err) {
+    writeFileSync(`${mapPath}.error`, `${err instanceof Error ? err.message : String(err)}\n`)
+  }
+
+  if (started) {
+    const textCache = new Map()
+    const indexCache = new Map()
+    /** @type {Map<string, Map<number, Set<string>>>} */
+    const byFile = new Map()
+    /** @type {Array<{ file: string, line: number }>} */
+    let prelude = []
+
+    async function scriptText(script) {
+      if (textCache.has(script.scriptId)) return textCache.get(script.scriptId)
+      let text = ""
+      try {
+        const got = await session.post("Debugger.getScriptSource", { scriptId: script.scriptId })
+        text = got.scriptSource || ""
+      } catch {
+        text = ""
+      }
+      textCache.set(script.scriptId, text)
+      return text
+    }
+
+    function relPath(url) {
+      if (!url || url.startsWith("node:")) return null
+      let abs
+      try {
+        abs = fileURLToPath(url.split("?")[0].split("#")[0])
+      } catch {
+        return null
+      }
+      const rel = path.relative(process.cwd(), abs).split(path.sep).join("/")
+      if (!rel || rel.startsWith("..") || path.isAbsolute(rel)) return null
+      if (rel.split("/").includes("node_modules")) return null
+      if (rel.endsWith("node-coverage.mjs")) return null
+      return rel
+    }
+
+    function indexFor(scriptId, text, sm) {
+      if (indexCache.has(scriptId)) return indexCache.get(scriptId)
+      const mapped = sm && sm.payload && typeof sm.payload.mappings === "string" ? linesFromMappings(text, sm.payload.mappings) : null
+      const lines = mapped && hasLine(mapped) ? mapped : linesFromNewlines(text, sm)
+      indexCache.set(scriptId, lines)
+      return lines
+    }
+
+    function hasLine(lines) {
+      for (let i = 0; i < lines.length; i++) if (lines[i] > 0) return true
+      return false
+    }
+
+    function linesFromNewlines(text, sm) {
+      const lines = new Int32Array(text.length + 1)
+      if (!sm) {
+        let line = 1
+        for (let i = 0; i < text.length; i++) {
+          lines[i] = line
+          if (text.charCodeAt(i) === 10) line++
+        }
+        return lines
+      }
+      // Node 22 reports SourceMap.findEntry originalLine as 0-based.
+      let genLine = 0
+      let col = 0
+      for (let i = 0; i < text.length; i++) {
+        const entry = sm.findEntry(genLine, col)
+        if (entry && Number.isInteger(entry.originalLine) && entry.originalLine >= 0) lines[i] = entry.originalLine + 1
+        if (text.charCodeAt(i) === 10) {
+          genLine++
+          col = 0
+        } else {
+          col++
+        }
+      }
+      return lines
+    }
+
+    function linesFromMappings(text, mappings) {
+      const lines = new Int32Array(text.length + 1)
+      const starts = [0]
+      for (let i = 0; i < text.length; i++) if (text.charCodeAt(i) === 10) starts.push(i + 1)
+      let carryLine = 0
+      const rows = mappings.split(";")
+      for (let genLine = 0; genLine < rows.length && genLine < starts.length; genLine++) {
+        const start = starts[genLine]
+        const next = genLine + 1 < starts.length ? starts[genLine + 1] : text.length
+        let col = 0
+        let cursor = start
+        let active = -1
+        for (const fields of decodeSegments(rows[genLine])) {
+          col += fields[0]
+          const at = Math.min(next, start + Math.max(0, col))
+          if (active >= 0) {
+            for (let i = cursor; i < at; i++) lines[i] = active + 1
+          }
+          cursor = at
+          if (fields.length >= 4) {
+            carryLine += fields[2]
+            active = carryLine
+          } else {
+            active = -1
+          }
+        }
+        if (active >= 0) {
+          for (let i = cursor; i < next; i++) lines[i] = active + 1
+        }
+      }
+      return lines
+    }
+
+    function applyRanges(text, script, lines) {
+      const ranges = []
+      for (const fn of script.functions || []) {
+        for (const range of fn.ranges || []) ranges.push(range)
+      }
+      // Outer ranges first. A nested block then overwrites its own offsets, so a dead
+      // branch stays at 0 while a condition earlier on that same line can stay covered.
+      ranges.sort((a, b) => a.startOffset - b.startOffset || b.endOffset - a.endOffset)
+      const offsets = new Int32Array(text.length)
+      for (const range of ranges) {
+        const end = Math.min(text.length, range.endOffset)
+        for (let i = Math.max(0, range.startOffset); i < end; i++) offsets[i] = range.count
+      }
+      const counts = new Map()
+      for (let i = 0; i < text.length; i++) {
+        const line = lines[i]
+        if (line <= 0 || offsets[i] <= 0) continue
+        if (offsets[i] > (counts.get(line) || 0)) counts.set(line, offsets[i])
+      }
+      return counts
+    }
+
+    async function positiveLines() {
+      const cov = await session.post("Profiler.takePreciseCoverage")
+      /** @type {Array<{ file: string, line: number }>} */
+      const found = []
+      for (const script of cov.result || []) {
+        const file = relPath(script.url)
+        if (!file) continue
+        const text = await scriptText(script)
+        if (!text) continue
+        const counts = applyRanges(text, script, indexFor(script.scriptId, text, findSourceMap(script.url)))
+        for (const [line, count] of counts) {
+          if (count > 0) found.push({ file, line })
+        }
+      }
+      return found
+    }
+
+    function add(hits, name) {
+      if (!name) return
+      for (const hit of hits) {
+        let lines = byFile.get(hit.file)
+        if (!lines) {
+          lines = new Map()
+          byFile.set(hit.file, lines)
+        }
+        let names = lines.get(hit.line)
+        if (!names) {
+          names = new Set()
+          lines.set(hit.line, names)
+        }
+        names.add(name)
+      }
+    }
+
+    before(async () => {
+      try {
+        prelude = await positiveLines()
+      } catch (err) {
+        writeFileSync(`${mapPath}.error`, `${err instanceof Error ? err.message : String(err)}\n`)
+      }
+    })
+
+    afterEach(async (t) => {
+      try {
+        add(prelude, t.name)
+        add(await positiveLines(), t.name)
+      } catch (err) {
+        writeFileSync(`${mapPath}.error`, `${err instanceof Error ? err.message : String(err)}\n`)
+      }
+    })
+
+    after(() => {
+      if (byFile.size === 0) return
+      const files = {}
+      for (const [file, lines] of byFile) {
+        const bucket = {}
+        for (const [line, names] of lines) bucket[String(line)] = [...names].sort()
+        files[file] = bucket
+      }
+      const dir = `${mapPath}.parts`
+      mkdirSync(dir, { recursive: true })
+      writeFileSync(path.join(dir, `${process.pid}-${randomBytes(4).toString("hex")}.json`), JSON.stringify({ files }))
+    })
+  }
+}

package/dist/mutate/operators.js

@@ -0,0 +1,122 @@
+import ts from "typescript";
+const SWAP = {
+    [ts.SyntaxKind.AmpersandAmpersandToken]: { op: "and-to-or", replacement: "||" },
+    [ts.SyntaxKind.BarBarToken]: { op: "or-to-and", replacement: "&&" },
+    [ts.SyntaxKind.EqualsEqualsEqualsToken]: { op: "eq-to-neq", replacement: "!==" },
+    [ts.SyntaxKind.ExclamationEqualsEqualsToken]: { op: "neq-to-eq", replacement: "===" },
+    [ts.SyntaxKind.LessThanToken]: { op: "lt-to-le", replacement: "<=" },
+    [ts.SyntaxKind.LessThanEqualsToken]: { op: "le-to-lt", replacement: "<" },
+    [ts.SyntaxKind.GreaterThanToken]: { op: "gt-to-ge", replacement: ">=" },
+    [ts.SyntaxKind.GreaterThanEqualsToken]: { op: "ge-to-gt", replacement: ">" },
+};
+/**
+ * Operator mutants in code only. Strings, comments, and type positions are not code.
+ * A condition that contains a string (`name === "x"`) is still code: the span is not
+ * itself inside the string.
+ */
+export function findMutants(file, text) {
+    const scriptKind = file.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS;
+    const source = ts.createSourceFile(file, text, ts.ScriptTarget.Latest, true, scriptKind);
+    const raw = [];
+    const visit = (node) => {
+        if (isTypePosition(node))
+            return;
+        const point = pointAt(source, file, text, node);
+        if (point)
+            raw.push(point);
+        ts.forEachChild(node, visit);
+    };
+    visit(source);
+    const hidden = hiddenSpans(source, text, scriptKind);
+    const points = [];
+    const violations = [];
+    for (const point of raw) {
+        const inside = hidden.some((span) => point.start >= span.start && point.end <= span.end);
+        if (inside)
+            violations.push(point);
+        else
+            points.push(point);
+    }
+    return { points, violations };
+}
+function isTypePosition(node) {
+    return (ts.isTypeNode(node) ||
+        ts.isTypeAliasDeclaration(node) ||
+        ts.isInterfaceDeclaration(node) ||
+        ts.isTypeParameterDeclaration(node) ||
+        ts.isIndexSignatureDeclaration(node));
+}
+function pointAt(source, file, text, node) {
+    if (ts.isIfStatement(node) || ts.isWhileStatement(node) || ts.isDoStatement(node)) {
+        return negate(source, file, text, node.expression, "negate-condition");
+    }
+    if (ts.isConditionalExpression(node)) {
+        return negate(source, file, text, node.condition, "negate-ternary");
+    }
+    if (ts.isForStatement(node) && node.condition) {
+        return negate(source, file, text, node.condition, "negate-condition");
+    }
+    if (ts.isBinaryExpression(node)) {
+        const swap = SWAP[node.operatorToken.kind];
+        if (!swap)
+            return undefined;
+        const start = node.operatorToken.getStart(source);
+        const end = node.operatorToken.getEnd();
+        return make(source, file, text, start, end, swap.op, swap.replacement);
+    }
+    if (node.kind === ts.SyntaxKind.TrueKeyword || node.kind === ts.SyntaxKind.FalseKeyword) {
+        const start = node.getStart(source);
+        const end = node.getEnd();
+        const original = text.slice(start, end);
+        const replacement = original === "true" ? "false" : "true";
+        const op = original === "true" ? "true-to-false" : "false-to-true";
+        return make(source, file, text, start, end, op, replacement);
+    }
+    if (ts.isPrefixUnaryExpression(node) &&
+        node.operator === ts.SyntaxKind.ExclamationToken &&
+        !ts.isPrefixUnaryExpression(node.operand)) {
+        const start = node.getStart(source);
+        const end = node.operand.getStart(source);
+        return make(source, file, text, start, end, "drop-not", "");
+    }
+    return undefined;
+}
+function negate(source, file, text, expr, op) {
+    const start = expr.getStart(source);
+    const end = expr.getEnd();
+    return make(source, file, text, start, end, op, `!(${text.slice(start, end)})`);
+}
+function make(source, file, text, start, end, op, replacement) {
+    const { line } = source.getLineAndCharacterOfPosition(start);
+    return { file, start, end, line: line + 1, op, original: text.slice(start, end), replacement };
+}
+function hiddenSpans(source, text, scriptKind) {
+    const literals = [];
+    const visit = (node) => {
+        if (ts.isStringLiteral(node) ||
+            ts.isNoSubstitutionTemplateLiteral(node) ||
+            ts.isTemplateHead(node) ||
+            ts.isTemplateMiddle(node) ||
+            ts.isTemplateTail(node) ||
+            ts.isRegularExpressionLiteral(node) ||
+            ts.isJsxText(node)) {
+            literals.push({ start: node.getStart(source), end: node.getEnd() });
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(source);
+    const variant = scriptKind === ts.ScriptKind.TSX ? ts.LanguageVariant.JSX : ts.LanguageVariant.Standard;
+    const scanner = ts.createScanner(ts.ScriptTarget.Latest, false, variant, text);
+    const comments = [];
+    let token = scanner.scan();
+    while (token !== ts.SyntaxKind.EndOfFileToken) {
+        const leading = ts.getLeadingCommentRanges(text, scanner.getTokenStart()) ?? [];
+        const trailing = ts.getTrailingCommentRanges(text, scanner.getTokenEnd()) ?? [];
+        for (const comment of [...leading, ...trailing])
+            comments.push({ start: comment.pos, end: comment.end });
+        token = scanner.scan();
+    }
+    // A `//` inside a template is text, not a comment. Drop ranges that begin in a literal.
+    const real = comments.filter((comment) => !literals.some((span) => comment.start >= span.start && comment.start < span.end));
+    return [...literals, ...real];
+}

package/dist/mutate/patch.js

@@ -0,0 +1,135 @@
+import { spawnSync } from "node:child_process";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+export function readHeader(raw) {
+    const lines = raw.split(/\r?\n/);
+    let direction = null;
+    let index = 0;
+    while (index < lines.length && !lines[index].startsWith("---") && !lines[index].startsWith("diff ")) {
+        const match = lines[index].match(/direction=(forward|reverse)/);
+        if (match)
+            direction = match[1];
+        index++;
+    }
+    const body = lines.slice(index).join("\n");
+    return { direction, body: body.endsWith("\n") || body.length === 0 ? body : `${body}\n` };
+}
+/** `diff -u` patch that applies onto the original and produces the mutant. */
+export function forwardDiff(rel, original, mutated) {
+    const dir = mkdtempSync(path.join(tmpdir(), "probatio-diff-"));
+    try {
+        const before = path.join(dir, "before");
+        const after = path.join(dir, "after");
+        writeFileSync(before, original);
+        writeFileSync(after, mutated);
+        const diff = spawnSync("diff", ["-u", "-L", `a/${rel}`, "-L", `b/${rel}`, before, after], { encoding: "utf8" });
+        if (diff.status === 0)
+            return "";
+        if (diff.status !== 1)
+            throw new Error(diff.stderr.trim() || "diff failed");
+        const body = diff.stdout.endsWith("\n") ? diff.stdout : `${diff.stdout}\n`;
+        return `# probatio-mutant direction=forward meaning=apply-to-introduce-the-bug\n${body}`;
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+}
+export function filesInDiff(raw) {
+    const body = readHeader(raw).body;
+    const files = [];
+    const chunks = body.split(/^diff --git .*$/m);
+    const pieces = chunks.length > 1 ? chunks.slice(1) : [body];
+    for (const piece of pieces) {
+        const plus = piece.match(/^\+\+\+ ([^\t\n]+)/m);
+        const hunk = piece.match(/^@@ -\d+(?:,\d+)? \+(\d+)/m);
+        if (!plus)
+            continue;
+        let file = plus[1];
+        if (file === "/dev/null")
+            continue;
+        // git diff -R swaps the labels, so the path may be a/ or b/.
+        if (file.startsWith("a/") || file.startsWith("b/"))
+            file = file.slice(2);
+        files.push({ file, line: hunk ? Number(hunk[1]) : 1 });
+    }
+    return files;
+}
+/**
+ * Original lines a patch removes or replaces.
+ * A unified hunk starts on context, so the hunk header is not the edited line.
+ */
+export function changedLines(raw) {
+    const body = readHeader(raw).body;
+    const chunks = body.split(/^diff --git .*$/m);
+    const pieces = chunks.length > 1 ? chunks.slice(1) : [body];
+    const found = [];
+    for (const piece of pieces) {
+        const plus = piece.match(/^\+\+\+ ([^\t\n]+)/m);
+        if (!plus)
+            continue;
+        let file = plus[1];
+        if (file === "/dev/null")
+            continue;
+        if (file.startsWith("a/") || file.startsWith("b/"))
+            file = file.slice(2);
+        let oldLine = 0;
+        let inHunk = false;
+        for (const line of piece.split(/\r?\n/)) {
+            const hunk = /^@@ -(\d+)(?:,\d+)? \+\d+/.exec(line);
+            if (hunk) {
+                oldLine = Number(hunk[1]);
+                inHunk = true;
+                continue;
+            }
+            if (!inHunk)
+                continue;
+            if (line.startsWith("+") || line.startsWith("\\"))
+                continue;
+            if (line.startsWith("-")) {
+                found.push({ file, line: oldLine });
+                oldLine += 1;
+                continue;
+            }
+            if (line.startsWith(" ")) {
+                oldLine += 1;
+                continue;
+            }
+            inHunk = false;
+        }
+    }
+    return found;
+}
+export function git(repo, args, input) {
+    const result = spawnSync("git", ["-C", repo, ...args], { encoding: "utf8", input });
+    const stderr = [result.stderr ?? "", result.error?.message ?? ""].filter((part) => part.length > 0).join("\n");
+    return { status: result.status ?? 1, stdout: result.stdout ?? "", stderr };
+}
+export function patchApplies(repo, raw, direction) {
+    const args = ["apply", "--check", "--whitespace=nowarn", ...(direction === "reverse" ? ["-R"] : []), "-"];
+    return git(repo, args, readHeader(raw).body).status === 0;
+}
+export function chooseDirection(repo, raw, requested) {
+    if (requested !== "auto")
+        return requested;
+    const header = readHeader(raw).direction;
+    if (header)
+        return header;
+    if (patchApplies(repo, raw, "forward"))
+        return "forward";
+    if (patchApplies(repo, raw, "reverse"))
+        return "reverse";
+    return null;
+}
+export function applyPatch(repo, raw, direction) {
+    const args = ["apply", "--whitespace=nowarn", ...(direction === "reverse" ? ["-R"] : []), "-"];
+    const result = git(repo, args, readHeader(raw).body);
+    if (result.status === 0)
+        return { ok: true };
+    return { ok: false, error: (result.stderr || result.stdout).trim() || "apply failed" };
+}
+/** Put a throwaway worktree back. A diff label is not trusted for the path list. */
+export function restoreTree(repo) {
+    git(repo, ["checkout", "--", "."]);
+    git(repo, ["clean", "-fd", "-e", "node_modules"]);
+}

package/dist/mutate/py-pytest-reporter.py

@@ -0,0 +1,145 @@
+#!/usr/bin/env python3
+"""Run pytest and print one Probatio report as a single JSON line.
+
+When PROBATIO_COVERAGE_MAP is set and coverage.py imports, also write a
+per-test line map. A missing coverage module leaves the map unwritten.
+"""
+import json
+import os
+import sys
+
+# The sysmon core on this interpreter drops dynamic context switches.
+os.environ.setdefault("COVERAGE_CORE", "ctrace")
+
+import pytest
+
+
+class Collector:
+    def __init__(self):
+        self.names = []
+        self.failed = []
+
+    def pytest_collectreport(self, report):
+        if not report.failed:
+            return
+        self._add(getattr(report, "nodeid", "") or "pytest", report)
+
+    def pytest_runtest_logreport(self, report):
+        if report.when not in ("setup", "call"):
+            return
+        if report.when == "setup" and not report.failed:
+            return
+        name = report.nodeid
+        if report.when == "call" and name not in self.names:
+            self.names.append(name)
+        if report.failed:
+            self._add(name, report)
+
+    def _add(self, name, report):
+        if any(item["name"] == name for item in self.failed):
+            return
+        location = getattr(report, "location", None) or ("", 0, "")
+        self.failed.append({"name": name, "file": str(location[0] or ""), "line": int(location[1] or 0)})
+
+
+class ContextSwitch:
+    def __init__(self, cov):
+        self.cov = cov
+
+    def pytest_runtest_setup(self, item):
+        self.cov.switch_context(item.nodeid)
+
+
+def start_coverage():
+    dest = os.environ.get("PROBATIO_COVERAGE_MAP")
+    if not dest:
+        return None, None
+    try:
+        import coverage
+    except ImportError:
+        return None, None
+    data_file = dest + ".data"
+    try:
+        cov = coverage.Coverage(cover_pylib=False, data_file=data_file)
+        cov.start()
+        return cov, dest
+    except Exception:
+        return None, None
+
+
+def write_coverage(cov, dest):
+    try:
+        cov.stop()
+        cov.save()
+    except Exception:
+        return
+    try:
+        data = cov.get_data()
+    except Exception:
+        return
+    root = os.path.realpath(os.getcwd())
+    files = {}
+    for filename in data.measured_files():
+        full = os.path.realpath(filename)
+        if not full.startswith(root + os.sep):
+            continue
+        if "/site-packages/" in full or "/node_modules/" in full:
+            continue
+        rel = full[len(root) + 1 :]
+        try:
+            by_line = data.contexts_by_lineno(filename) or {}
+        except Exception:
+            continue
+        lines = {}
+        for lineno, contexts in by_line.items():
+            names = [item for item in contexts if item]
+            if names:
+                lines[str(lineno)] = names
+        if lines:
+            files[rel] = lines
+    with open(dest, "w", encoding="utf-8") as handle:
+        json.dump({"files": files}, handle)
+        handle.write("\n")
+
+
+def main():
+    args = []
+    index = 1
+    while index < len(sys.argv):
+        if sys.argv[index] == "--pattern":
+            args.extend(["-k", sys.argv[index + 1]])
+            index += 2
+            continue
+        args.append(sys.argv[index])
+        index += 1
+    cov, dest = start_coverage()
+    collector = Collector()
+    plugins = [collector]
+    if cov is not None:
+        plugins.append(ContextSwitch(cov))
+    code = 1
+    try:
+        code = pytest.main([*args, "-p", "no:cacheprovider", "--tb=no", "-q"], plugins=plugins) or 0
+    except BaseException:
+        code = 1
+    finally:
+        if cov is not None and dest:
+            write_coverage(cov, dest)
+    names = collector.names or [item["name"] for item in collector.failed]
+    failed = collector.failed
+    # Exit 4 is a usage error (a bad -k expression). No test ran, so this is not a kill.
+    if not names and code != 0:
+        names = []
+        failed = []
+    report = {
+        "tests": len(names),
+        "pass": len(names) - len(failed),
+        "fail": len(failed),
+        "failed": failed,
+        "names": names,
+    }
+    sys.stdout.write(json.dumps(report) + "\n")
+
+
+if __name__ == "__main__":
+    main()