probatio 0.0.0-stage → 0.0.2

package/dist/mutate/java-coverage.js

@@ -0,0 +1,188 @@
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const JACOCO = "0.8.15";
+const ASM = "9.10.1";
+const RUNNER = fileURLToPath(new URL("./probatio-jacoco-run.java", import.meta.url));
+/**
+ * One JVM, one JaCoCo dump per Surefire test method.
+ * The default jacoco.exec file does not name the test.
+ */
+export function writeJavaCoverage(pkg, testNames, dest) {
+    const tests = testNames.map(junitMethod).filter((name) => name !== null);
+    if (tests.length === 0)
+        return { ok: false, detail: "java coverage: no class.method test names" };
+    const classDirs = findClassDirs(pkg);
+    if (classDirs.length === 0)
+        return { ok: false, detail: "java coverage: no target/classes" };
+    const work = path.join(path.dirname(dest), "java-cover");
+    mkdirSync(work, { recursive: true });
+    const jars = resolveJars(pkg, work);
+    if ("error" in jars)
+        return { ok: false, detail: jars.error };
+    const source = path.join(work, "ProbatioJacocoRun.java");
+    writeFileSync(source, readFileSync(RUNNER));
+    const compileCp = [jars.agent, jars.junit, jars.core, jars.asm, jars.asmCommons, jars.asmTree].join(path.delimiter);
+    const compiled = run(javaTool("javac"), ["-encoding", "UTF-8", "-cp", compileCp, "-d", work, source], pkg);
+    if (compiled.status !== 0)
+        return { ok: false, detail: clip(compiled.stderr || compiled.stdout || compiled.error?.message || "javac failed") };
+    const testsFile = path.join(work, "tests.txt");
+    writeFileSync(testsFile, `${tests.join("\n")}\n`);
+    const projectCp = buildClasspath(pkg, work);
+    if ("error" in projectCp)
+        return { ok: false, detail: projectCp.error };
+    // Our asm and JaCoCo must win over a project that still ships an older asm. That older reader rejects Java 27 class files.
+    const cp = [work, jars.core, jars.asm, jars.asmCommons, jars.asmTree, jars.junit, ...classDirs, ...testClassDirs(pkg), projectCp.cp].filter(Boolean).join(path.delimiter);
+    const dump = path.join(work, "hits.txt");
+    const ran = run(javaTool("java"), [`-javaagent:${jars.agent}=output=none,excludes=ProbatioJacocoRun`, "-cp", cp, "ProbatioJacocoRun", classDirs.join(path.delimiter), testsFile, dump, pkg], pkg);
+    if (ran.error && ran.error.code === "ETIMEDOUT") {
+        return { ok: false, detail: "java coverage: timed out" };
+    }
+    if (ran.status !== 0 || !existsSync(dump)) {
+        return { ok: false, detail: clip(ran.stderr || ran.stdout || ran.error?.message || "java coverage runner failed") };
+    }
+    const files = hitsToMap(readFileSync(dump, "utf8"));
+    if (Object.keys(files).length === 0)
+        return { ok: false, detail: "java coverage: no covered lines" };
+    writeFileSync(dest, `${JSON.stringify({ files }, null, 2)}\n`);
+    return { ok: true, detail: `${Object.keys(files).length} files` };
+}
+export function hitsToMap(text) {
+    const files = {};
+    for (const raw of text.split("\n")) {
+        const line = raw.trim();
+        if (!line.startsWith("HIT "))
+            continue;
+        const parts = line.slice(4).split(" ");
+        if (parts.length < 3)
+            continue;
+        const test = parts.pop() ?? "";
+        const number = parts.pop() ?? "";
+        const file = parts.join(" ");
+        if (!file || !/^\d+$/.test(number) || !test)
+            continue;
+        const lines = files[file] ?? {};
+        const names = lines[number] ?? [];
+        if (!names.includes(test))
+            names.push(test);
+        lines[number] = names;
+        files[file] = lines;
+    }
+    return files;
+}
+function junitMethod(name) {
+    const leaf = name.split("::").pop() ?? name;
+    const dot = leaf.lastIndexOf(".");
+    if (dot <= 0 || dot === leaf.length - 1)
+        return null;
+    if (leaf.startsWith("maven-") || leaf === "javac")
+        return null;
+    return `${leaf.slice(0, dot)}#${leaf.slice(dot + 1)}`;
+}
+function findClassDirs(root) {
+    const found = [];
+    const walk = (dir, depth) => {
+        if (depth > 4)
+            return;
+        let entries = [];
+        try {
+            entries = readdirSync(dir);
+        }
+        catch {
+            return;
+        }
+        for (const name of entries) {
+            if (name === "node_modules" || name === ".git" || name === "java-cover")
+                continue;
+            const full = path.join(dir, name);
+            if (name === "target") {
+                const classes = path.join(full, "classes");
+                if (existsSync(classes))
+                    found.push(classes);
+                continue;
+            }
+            if (name.startsWith("."))
+                continue;
+            walk(full, depth + 1);
+        }
+    };
+    walk(root, 0);
+    return found;
+}
+function testClassDirs(root) {
+    return findClassDirs(root).map((dir) => path.join(path.dirname(dir), "test-classes")).filter((dir) => existsSync(dir));
+}
+function resolveJars(pkg, work) {
+    const copies = [
+        [`org.jacoco:org.jacoco.agent:${JACOCO}:jar:runtime`, "agent.jar"],
+        [`org.jacoco:org.jacoco.core:${JACOCO}`, "core.jar"],
+        [`org.ow2.asm:asm:${ASM}`, "asm.jar"],
+        [`org.ow2.asm:asm-commons:${ASM}`, "asm-commons.jar"],
+        [`org.ow2.asm:asm-tree:${ASM}`, "asm-tree.jar"],
+        ["junit:junit:4.13.2", "junit.jar"],
+    ];
+    const paths = {};
+    for (const [artifact, name] of copies) {
+        const dest = path.join(work, name);
+        if (!existsSync(dest)) {
+            const before = new Set(readdirSync(work));
+            const copied = run("mvn", ["-B", "-q", "org.apache.maven.plugins:maven-dependency-plugin:3.6.1:copy", `-Dartifact=${artifact}`, `-DoutputDirectory=${work}`], pkg);
+            if (copied.status !== 0)
+                return { error: clip(copied.stderr || copied.stdout || copied.error?.message || `mvn copy ${artifact} failed`) };
+            const created = readdirSync(work).find((item) => !before.has(item) && item.endsWith(".jar"));
+            if (!created)
+                return { error: `java coverage: missing ${artifact}` };
+            writeFileSync(dest, readFileSync(path.join(work, created)));
+        }
+        paths[name] = dest;
+    }
+    return {
+        agent: paths["agent.jar"],
+        core: paths["core.jar"],
+        asm: paths["asm.jar"],
+        asmCommons: paths["asm-commons.jar"],
+        asmTree: paths["asm-tree.jar"],
+        junit: paths["junit.jar"],
+    };
+}
+function buildClasspath(pkg, work) {
+    const file = path.join(work, "classpath.txt");
+    const built = run("mvn", ["-B", "-q", "dependency:build-classpath", "-DincludeScope=test", `-Dmdep.outputFile=${file}`], pkg);
+    if (built.status !== 0)
+        return { error: clip(built.stderr || built.stdout || built.error?.message || "mvn classpath failed") };
+    try {
+        return { cp: readFileSync(file, "utf8").trim() };
+    }
+    catch {
+        return { error: "java coverage: classpath file missing" };
+    }
+}
+function javaTool(name) {
+    const home = process.env.JAVA_HOME;
+    if (home) {
+        const candidate = path.join(home, "bin", name);
+        if (existsSync(candidate) && toolWorks(candidate))
+            return candidate;
+    }
+    if (toolWorks(name))
+        return name;
+    for (const dir of ["/opt/homebrew/opt/openjdk/bin", "/usr/local/opt/openjdk/bin"]) {
+        const candidate = path.join(dir, name);
+        if (existsSync(candidate) && toolWorks(candidate))
+            return candidate;
+    }
+    return name;
+}
+function toolWorks(bin) {
+    const probed = spawnSync(bin, ["-version"], { encoding: "utf8" });
+    const text = `${probed.stdout ?? ""}${probed.stderr ?? ""}`;
+    return probed.status === 0 && !/Unable to locate a Java Runtime/i.test(text);
+}
+function run(bin, args, cwd) {
+    return spawnSync(bin, args, { cwd, encoding: "utf8", timeout: 180_000 });
+}
+function clip(text) {
+    const line = text.trim().split("\n").find((item) => item.trim()) ?? "java coverage failed";
+    return line.slice(0, 240);
+}

package/dist/mutate/kill-label.js

@@ -0,0 +1,34 @@
+/** Names that mean the process failed to compile. These are not test titles. */
+const BUILD_NAMES = new Set([
+    "build",
+    "javac",
+    "compiler",
+    "cobc",
+    "nasm",
+    "clang",
+    "cargo",
+    "tsc",
+    "dotnet",
+    "swiftc",
+]);
+/**
+ * A named test and a compile failure are different facts.
+ * The build next step says the build failed and does not ask for a test
+ * named after the compiler.
+ */
+export function killLabel(killedBy) {
+    if (killedBy.length === 0)
+        return null;
+    if (killedBy.every((item) => BUILD_NAMES.has(bareName(item)))) {
+        return { cause: "build", next: "Killed because the build failed. Record it as a compile kill." };
+    }
+    return { cause: "test", next: `Killed by ${killedBy.join(", ")}.` };
+}
+/** True when the id names a compiler, not a test. */
+export function isBuildName(id) {
+    return BUILD_NAMES.has(bareName(id));
+}
+function bareName(id) {
+    const mark = id.lastIndexOf("::");
+    return (mark >= 0 ? id.slice(mark + 2) : id).trim().toLowerCase();
+}

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