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

CosmicRayLine

One line of cosmic-ray dump output: a [work_item, result] pair. The result is absent (null) for an un-executed work item.

CrMutation

One mutation, pared to the location + operator the rule reads. cosmic-ray also carries occurrence, end_pos, operator_args; those are ignored.

CrResult

A work item’s result; only the test outcome is read (survived / killed / incompetent).

CrWorkItem

A cosmic-ray work item, pared to its one mutation’s location. (cosmic-ray models a list of mutations per item, but the operators here produce one apiece.)

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

cosmic_ray_mutated_lines

The (file, line) locations cosmic-ray ran a viable (executed) mutant for — survived or killed, not the incompetent mutants that never ran (a syntax error) or the un-executed (null-result) work items. The #226 guard reads this the same way as the cargo-mutants / Stryker mutated_lines.

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 cosmic-ray over the Python project at root and return its un-exempted survivors — the Python arm of the mutation rule (#203), 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_cosmic_ray_dump

Parse cosmic-ray dump output (JSON Lines) into the surviving mutants — the raw list before exemptions.

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).