Module mutation 

Mutation testing for Rust (unit mutation --language rust, #201) — the rung above coverage. A test that runs a line still passes if you delete its assertions; a surviving mutant proves it. This module wraps cargo-mutants: it runs the engine, reads its outcomes.json, and reports the surviving mutants the suite failed to catch.

The gate is binary, not a percentage (equivalent mutants make a fixed score unreachable, and a score isn’t comparable across engines) and on by default: any un-exempted surviving mutant is a finding. This module stays a pure measurement — measure_rust returns the survivors and unexplained_survivors is the pure core over a parsed report; the CLI layer turns a non-empty result into the failure.

Diff-scoping (--base) is delegated to cargo-mutants’ own --in-diff: the <base>...HEAD diff is written out and passed through, so only mutants on changed lines are tested (“no unexplained surviving mutant on the lines you touched”).

Structs

LineCol

A line/column position; only the line is read.

MutantInfo

The mutant a scenario describes, pared to the location + description the report needs. cargo-mutants also carries function, genre, package, replacement; those are ignored.

MutantOutcome

One scenario’s outcome. summary is cargo-mutants’ result word — Success for the unmutated baseline, CaughtMutant / MissedMutant (and Timeout / Unviable) for each mutant.

MutantsReport

A cargo-mutants outcomes.json export, pared to what the rule reads. Unmodeled fields (total_mutants, caught, timings, …) are ignored.

NormalizedMutant

One mutant in the normalized result set (#239): the engine-agnostic shape every language adapter emits. Extra fields an adapter includes are ignored.

Span

A source span; only the start line is read.

Survivor

A surviving mutant — a mutation the unit suite ran but failed to catch.

Enums

MutantStatus

A mutant’s outcome, normalized across the engines (Stryker / cosmic-ray / cargo-mutants) — the union of their result vocabularies reduced to what the gate needs (#239). Each language adapter maps its native outcomes onto this so the Rust core gates on one representation instead of three per-engine report formats. The serialized form is snake_case (no_coverage, compile_error, …) — the wire contract adapters emit.

Scenario

The scenario a result came from: the unmutated baseline, or one mutant. Matches cargo-mutants’ externally-tagged JSON ("Baseline" vs {"Mutant": {…}}).

Functions

evaluate

The shared whole-file evaluation core: drop the survivors lifted by a file-level mutation exemption (a file-path match), leaving the rule’s findings. The line-scoped path (evaluate_scoped) generalizes this to per-line exemptions with a determinism guard.

evaluate_normalized

Gate a normalized result set: drop the survivors lifted by a file- or line-scoped mutation exemption (with the #226 determinism guard), leaving the rule’s findings.

evaluate_scoped

Apply file- and line-scoped mutation exemptions to the raw survivors, with the #226 determinism guard. mutated is the set of (file, line) that produced a viable mutant (caught or survived); whole_file is the file-level exemptions and line_scoped the per-line ones.

measure_python

Run the bundled Python mutation adapter over the project at root and return its un-exempted survivors — the Python arm of the mutation rule (#203 / #248), parity with measure_rust and measure_typescript.

measure_rust

Run cargo-mutants over the crate at root and return its un-exempted survivors.

measure_typescript

Run the bundled TypeScript mutation adapter over the project at root and return its un-exempted survivors — the TS arm of the mutation rule (#202), parity with measure_rust.

mutated_lines

The (file, line) locations cargo-mutants produced a viable, conclusive mutant for — caught or missed (CaughtMutant / MissedMutant), not the inconclusive Timeout / Unviable. The #226 line-scoped guard reads this to tell an over-exemption (a listed line whose mutants were all caught, no survivor) from an out-of-scope line (no mutant there at all — e.g. outside a --base diff).

parse_mutants_report

Parse a cargo-mutants outcomes.json export.

parse_normalized_results

Parse the normalized results an engine adapter emits — a flat JSON array of NormalizedMutant (#239).

unexplained_survivors

The surviving mutants not lifted by a mutation exemption — the rule’s findings.

Type Aliases

MutatedLines

The (file, line) locations an engine produced a viable mutant for — the input the #226 line-scoped guard reads to tell an over-exemption (a listed line whose mutants were all caught) from an out-of-scope line (no mutant there).