evilution 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 26a7a721749a19cb1f10d77b46a9d78d394ce5c112ba5d5fab8963de4a1a5f14
-  data.tar.gz: 65ee839279c74e07dd84d153015bfff6e29daf56d87929da75991fdef67e49c5
+  metadata.gz: 71f26de1d4437f62a01f5d5784a3a67ffdc914418ae952cb279de392ec401ecb
+  data.tar.gz: 92d18647ec19836335c5eaa3156ce6da7db1857b285b66f49efc2ed66de49ed0
 SHA512:
-  metadata.gz: 587598737cb636180b40cfb2466ecd0aac34c827eddb5432b543fc33b2b7e94b2e5b2a03915598fb9c41e9174bab8baad06ffab620f4174d8f686f9173f8fd1b
-  data.tar.gz: 85be8b922c45fab5e0e50fd8f17a6d5a572a9b9a2139181f0ca0283dc52c241bcd54b512e0cb3a5be9588edc31cd8b46fedd10437e8caf0c3e3104229c1f7127
+  metadata.gz: 0174eb2e10182274ed8cbda806172a8d4956caeff7af844c409daa6f3de711b709a450be89cf4dc3a08b36e7df84ca0c0473a66d21909d8752a83bce4309aab2
+  data.tar.gz: 8bf2f8cfce0633f537186cd08aaf6abd66c06869d56308647f0be34352d6d94c06912b8c1c0e8128ca19b45acc60536b5a6f35028996ce25ca2a0501bdc1b508

data/.beads/interactions.jsonl

@@ -448,3 +448,24 @@
 {"id":"int-616f39e1","kind":"field_change","created_at":"2026-07-15T13:33:53.68007233Z","actor":"Denis Kiselev","issue_id":"EV-y194","extra":{"field":"status","new_value":"closed","old_value":"in_progress","reason":"Closed"}}
 {"id":"int-abcaeb3a","kind":"field_change","created_at":"2026-07-15T13:33:54.363899883Z","actor":"Denis Kiselev","issue_id":"EV-j2kz","extra":{"field":"status","new_value":"closed","old_value":"in_progress","reason":"Closed"}}
 {"id":"int-b8027311","kind":"field_change","created_at":"2026-07-15T13:34:47.737536249Z","actor":"Denis Kiselev","issue_id":"EV-w07i","extra":{"field":"status","new_value":"closed","old_value":"open","reason":"Closed"}}
+{"id":"int-e7b1f137","kind":"field_change","created_at":"2026-08-14T05:36:05.821384373Z","actor":"Denis Kiselev","issue_id":"EV-4ild","extra":{"field":"status","new_value":"closed","old_value":"in_progress","reason":"Closed"}}
+{"id":"int-c003e7fa","kind":"field_change","created_at":"2026-08-22T04:23:28.006710286Z","actor":"Denis Kiselev","issue_id":"EV-170m.1","extra":{"field":"status","new_value":"in_progress","old_value":"open"}}
+{"id":"int-f912a48c","kind":"field_change","created_at":"2026-08-22T15:26:32.589708305Z","actor":"Denis Kiselev","issue_id":"EV-170m.1","extra":{"field":"status","new_value":"closed","old_value":"in_progress","reason":"Closed"}}
+{"id":"int-d74d2ac8","kind":"field_change","created_at":"2026-08-22T17:21:54.118527965Z","actor":"Denis Kiselev","issue_id":"EV-170m.2","extra":{"field":"status","new_value":"closed","old_value":"in_progress","reason":"Closed"}}
+{"id":"int-d694451a","kind":"field_change","created_at":"2026-08-22T17:21:59.468788556Z","actor":"Denis Kiselev","issue_id":"EV-170m.3","extra":{"field":"status","new_value":"closed","old_value":"in_progress","reason":"Closed"}}
+{"id":"int-9cd4dc49","kind":"field_change","created_at":"2026-08-22T17:22:05.341826256Z","actor":"Denis Kiselev","issue_id":"EV-170m.5","extra":{"field":"status","new_value":"closed","old_value":"in_progress","reason":"Closed"}}
+{"id":"int-9a64fd8d","kind":"field_change","created_at":"2026-08-23T05:54:32.093591437Z","actor":"Denis Kiselev","issue_id":"EV-170m.14","extra":{"field":"status","new_value":"closed","old_value":"in_progress","reason":"Closed"}}
+{"id":"int-990ddf2a","kind":"field_change","created_at":"2026-08-23T05:54:35.35056636Z","actor":"Denis Kiselev","issue_id":"EV-170m.15","extra":{"field":"status","new_value":"closed","old_value":"in_progress","reason":"Closed"}}
+{"id":"int-aa07e9f8","kind":"field_change","created_at":"2026-08-23T05:54:38.655416932Z","actor":"Denis Kiselev","issue_id":"EV-170m.16","extra":{"field":"status","new_value":"closed","old_value":"in_progress","reason":"Closed"}}
+{"id":"int-e7ba9d2f","kind":"field_change","created_at":"2026-08-23T05:54:41.957571538Z","actor":"Denis Kiselev","issue_id":"EV-170m.10","extra":{"field":"status","new_value":"closed","old_value":"in_progress","reason":"Closed"}}
+{"id":"int-c4cf46e8","kind":"field_change","created_at":"2026-08-23T05:54:43.220109392Z","actor":"Denis Kiselev","issue_id":"EV-170m.11","extra":{"field":"status","new_value":"closed","old_value":"in_progress","reason":"Closed"}}
+{"id":"int-46ac995b","kind":"field_change","created_at":"2026-08-23T05:54:46.601240327Z","actor":"Denis Kiselev","issue_id":"EV-170m.12","extra":{"field":"status","new_value":"closed","old_value":"in_progress","reason":"Closed"}}
+{"id":"int-ee1da7ed","kind":"field_change","created_at":"2026-08-23T05:54:58.551793942Z","actor":"Denis Kiselev","issue_id":"EV-170m.8","extra":{"field":"status","new_value":"closed","old_value":"in_progress","reason":"Closed"}}
+{"id":"int-a2659f70","kind":"field_change","created_at":"2026-08-23T06:17:48.940199465Z","actor":"Denis Kiselev","issue_id":"EV-zfh6","extra":{"field":"status","new_value":"closed","old_value":"in_progress","reason":"Closed"}}
+{"id":"int-3ef2119d","kind":"field_change","created_at":"2026-08-23T06:22:32.612716343Z","actor":"Denis Kiselev","issue_id":"EV-9mrs","extra":{"field":"status","new_value":"closed","old_value":"in_progress","reason":"Closed"}}
+{"id":"int-4f24cfc1","kind":"field_change","created_at":"2026-08-23T06:22:36.754337802Z","actor":"Denis Kiselev","issue_id":"EV-170m.4","extra":{"field":"status","new_value":"closed","old_value":"open","reason":"Closed"}}
+{"id":"int-db1a15c4","kind":"field_change","created_at":"2026-08-23T06:22:40.226188047Z","actor":"Denis Kiselev","issue_id":"EV-170m.6","extra":{"field":"status","new_value":"closed","old_value":"open","reason":"Closed"}}
+{"id":"int-ee6c5593","kind":"field_change","created_at":"2026-08-23T06:22:43.665223358Z","actor":"Denis Kiselev","issue_id":"EV-170m.7","extra":{"field":"status","new_value":"closed","old_value":"open","reason":"Closed"}}
+{"id":"int-a9687ce8","kind":"field_change","created_at":"2026-08-23T06:22:47.016572566Z","actor":"Denis Kiselev","issue_id":"EV-170m.9","extra":{"field":"status","new_value":"closed","old_value":"open","reason":"Closed"}}
+{"id":"int-6979f453","kind":"field_change","created_at":"2026-08-23T06:22:50.346314707Z","actor":"Denis Kiselev","issue_id":"EV-170m.13","extra":{"field":"status","new_value":"closed","old_value":"open","reason":"Closed"}}
+{"id":"int-c0c4ce61","kind":"field_change","created_at":"2026-08-23T06:22:53.658409885Z","actor":"Denis Kiselev","issue_id":"EV-170m.17","extra":{"field":"status","new_value":"closed","old_value":"open","reason":"Closed"}}

data/CHANGELOG.md

@@ -2,6 +2,32 @@
 
 Versioning policy: see [docs/versioning.md](docs/versioning.md).
 
+## [1.1.0] - 2026-08-23
+
+Control-flow and pattern-matching operator expansion: the `default` profile grows from 74 to 80 operators, and three existing operators gain mutations they were silently missing. Adding operators to `default` is a MINOR change under [docs/versioning.md](docs/versioning.md), and mutation scores will move — every new operator produces mutants your suite has never been measured against. Pin the gem version and the operator profile if you need a stable score across runs.
+
+### Added
+
+- **Six new mutation operators for control flow and pattern matching (`default` profile: 74 -> 80)** — closing the value-level and branch-level gaps in an operator set that previously mutated control-flow nodes only at the keyword level (epic EV-170m, GH #1418):
+  - **`boolean_operand_promotion`** — drops one side of a compound boolean: `a && b` becomes `a` and `b`, and the same for `||` and the `and` / `or` keyword forms. Kills tests that only ever exercise one side of a condition, which `boolean_operator_replacement` cannot: it swaps the operator but always keeps both operands (EV-170m.2, PR #1565, GH #1431)
+  - **`boolean_expression_to_nil`** — replaces a whole compound boolean with `nil`, targeting conditions that are run for their side effects rather than their value (EV-170m.3, PR #1566, GH #1432)
+  - **`if_branch_swap`** — replaces the if-branch with the else body and drops the else: `if c; x; else; y; end` becomes `if c; y; end`. Both outcomes of the condition change, which is out of reach of `conditional_negation` (pins the predicate to one branch) and `conditional_branch` (blanks one body to `nil`) (EV-170m.5, PR #1567, GH #1434)
+  - **`loop_body_to_raise`** — replaces a `while` / `until` body with a bare `raise`, so a survivor means no test ever enters the loop. The raise ends the loop on its first iteration, so the mutant cannot spin (EV-170m.8, PR #1569, GH #1437)
+  - **`case_in`** — the first operator to visit Ruby's pattern-matching grammar (`Prism::CaseMatchNode`): drops one `in` clause from a `case/in`, or drops its `else`. Input that used to match then falls through to a later arm, to the `else`, or — with neither — raises `NoMatchingPatternError` (EV-170m.14 / EV-170m.15, PRs #1573 / #1574, GH #1443 / #1444)
+  - **`pattern_predicate`** — one-line pattern match to `false`: `x in Integer` becomes `false`. The mutant differs from the original only on inputs the pattern actually matches, so a survivor means no test ever feeds it a matching value (EV-170m.16, PR #1575, GH #1445)
+- **`case_when` covers two more shapes** — an empty `when` arm now gets a `raise` inserted, and a multi-condition arm is shortened one value at a time (`when a, b` becomes `when a` and `when b`). Neither was previously reachable: dropping an empty arm is indistinguishable from falling through to a missing `else`, and whole-arm removal cannot tell which of several listed values a test exercises (EV-170m.11 / EV-170m.12, PRs #1571 / #1572, GH #1440 / #1441)
+
+### Fixed
+
+- **`conditional_branch` ignored `unless` entirely** — the operator defined only `visit_if_node`, so neither `unless c; x; end` nor `unless c; x; else; y; end` received any branch-body mutation, while the equivalent `if` forms received one per branch. Prism gives `unless` its own node type and names the else slot `else_clause` rather than `IfNode`'s `subsequent`; both forms now share the branch handling, so `unless` bodies — including the modifier form — get the same branch-to-`nil` mutants (EV-9mrs, PR #1578, GH #1568)
+- **MCP list responses omitted the mandatory `resultType` field** — protocol revision 2026-07-28 (SEP-2322) makes `resultType` mandatory on list results, and the `mcp` gem echoes back that revision while still omitting the field. Strict clients therefore rejected the whole list and saw a server exposing no tools at all. `Evilution::MCP::CompleteResultServer` now marks every list result `"complete"` (PR #1417)
+
+### Changed
+
+- **Post-form loops (`begin ... end while c`) verified across the loop operators** — `loop_body_to_raise` reaches through the `BeginNode` that Prism reports as the loop's statements, so the wrapper, and with it the guaranteed first iteration, survives the mutation; editing the outer span would have rewritten the loop as `raise while c`, which tests the condition first. `loop_flip` and `begin_unwrap` gained the post-form coverage they never had, including the fact that unwrapping such a loop legitimately drops its run-once guarantee. A sweep of every operator over post-form loops found no mutation that fails to parse (EV-170m.10, PR #1570, GH #1439)
+- **Shared operator primitives (`Mutator::Primitives`)** — `mutate_to_nil` and `promote_child`, built on `Base#add_mutation(skip_unparseable: true)`. Operators built on them skip rather than emit when the result would not parse in its surrounding context, so a promotion that cannot parse no longer reaches the `unparseable` bucket that the point operators still populate (EV-170m.1, PR #1564, GH #1430)
+- **Dependency bumps** — `mcp` 0.24.0 -> 1.2.0 (PRs #1411, #1413, #1414, #1563), CI Ruby versions and gem dependencies (PR #1415), `ruby/setup-ruby` 1.318.0 -> 1.321.0 (PRs #1409, #1412), `actions/checkout` 7.0.0 -> 7.0.1 (PR #1410), `rubygems/release-gem` 1.4.0 -> 1.4.1 (PR #1562)
+
 ## [1.0.0] - 2026-07-15
 
 First stable release. From `1.0.0` onward evilution follows [Semantic Versioning](https://semver.org): the public contract — CLI commands and flags, `.evilution.yml` configuration keys, session JSON files, the MCP tool schemas, and process exit codes — is frozen and covered by the SemVer guarantees and deprecation cycle in [docs/versioning.md](docs/versioning.md). The `1.0.0` milestone is the culmination of the readiness work that shipped across the `0.31`–`0.35` line (config and session-JSON schema versioning, MCP tool-contract stabilization, the CLI flag deprecation sweep, real-world Rails validation, the parallel/isolation stress suite, and running evilution against its own suite to a mutation-score target).

data/README.md

@@ -157,7 +157,7 @@ Every command, subcommand, and flag listed in this section is part of evilution'
 
 Two profiles ship out of the box:
 
-- **`default`** — the 74 stable operators registered in `Mutator::Registry.default`. Suitable for everyday CI runs; balances coverage signal against survivor noise.
+- **`default`** — the 80 stable operators registered in `Mutator::Registry.default`. Suitable for everyday CI runs; balances coverage signal against survivor noise.
 - **`strict`** — adds extra truthiness mutators on top of `default`. Currently `PredicateToNil` (replaces every `x.predicate?` call with `nil` to surface tests that only assert truthiness rather than exact return values). Use for pre-merge audits where you want maximum sensitivity at the cost of more survivors.
 
 Set via `--profile=strict`, the `--strict` shortcut, or `profile: strict` in `.evilution.yml`.
@@ -390,7 +390,7 @@ Compatibility policy for the `1.x` gem line:
 
 Unresolved mutations indicate a missing test mapping — the file has no corresponding test file that the resolver could find (for example, an RSpec `_spec.rb` file or a Minitest `_test.rb` file, depending on configuration). The resolver searches the `lib/`-mirrored path, common non-mirrored buckets (`spec/unit`, `spec/lib`, `test/unit`, `test/lib`), and the flat `test_`-prefixed Minitest/Test::Unit convention (`test/test_connection_pool_timed_stack.rb`), so a high unresolved rate usually means a genuinely missing or unconventionally-placed test; a run that leaves many mutations unresolved prints an unresolved-rate warning with a best-guess spec path per source file. They are reported separately so you can act on them (add a test, adjust test naming, pass `--spec`, or opt in to the full-suite fallback) without inflating the error count.
 
-## Mutation Operators (74 total)
+## Mutation Operators (80 total)
 
 Each operator name is stable and appears in JSON output under `survived[].operator`.
 
@@ -399,6 +399,8 @@ Each operator name is stable and appears in JSON output under `survived[].operat
 | `arithmetic_replacement` | Swap arithmetic operators | `a + b` -> `a - b` |
 | `comparison_replacement` | Swap comparison operators | `a >= b` -> `a > b` |
 | `boolean_operator_replacement` | Swap `&&` / `\|\|` | `a && b` -> `a \|\| b` |
+| `boolean_operand_promotion` | Drop one side of `&&` / `\|\|` | `a && b` -> `a`, `b` |
+| `boolean_expression_to_nil` | Replace a whole compound boolean with `nil` | `a && b` -> `nil` |
 | `boolean_literal_replacement` | Flip boolean literals | `true` -> `false` |
 | `nil_replacement` | Replace `nil` with `true`, `false`, `0`, `""` | `nil` -> `true` |
 | `integer_literal` | Boundary-value integer mutations | `n` -> `0`, `1`, `n+1`, `n-1` |
@@ -408,7 +410,8 @@ Each operator name is stable and appears in JSON output under `survived[].operat
 | `hash_literal` | Empty the hash | `{k: v}` -> `{}` |
 | `symbol_literal` | Replace with sentinel symbol | `:foo` -> `:__evilution_mutated__` |
 | `conditional_negation` | Replace condition with `true`/`false` | `if cond` -> `if true` |
-| `conditional_branch` | Remove if/else branch | Deletes branch body |
+| `conditional_branch` | Remove if/unless/else branch | Deletes branch body |
+| `if_branch_swap` | Replace the if-branch with the else body, drop the else | `if c; x; else; y; end` -> `if c; y; end` |
 | `conditional_flip` | Flip `if` to `unless` and vice versa | `if cond` -> `unless cond` |
 | `statement_deletion` | Remove statements from method bodies | Deletes a statement |
 | `method_body_replacement` | Replace entire method body | Method body -> `nil`, `self`, `super` |
@@ -460,9 +463,12 @@ Each operator name is stable and appears in JSON output under `survived[].operat
 | `defined_check` | Replace `defined?` with `true` | `defined?(x)` -> `true` |
 | `regex_capture` | Swap or nil-ify capture refs | `$1` -> `$2`, `$1` -> `nil` |
 | `loop_flip` | Swap while/until loops | `while cond` -> `until cond` |
+| `loop_body_to_raise` | Replace a loop body with `raise` | `while c; body; end` -> `while c; raise; end` |
 | `string_interpolation` | Replace interpolation content with nil | `"hello #{name}"` -> `"hello #{nil}"` |
 | `retry_removal` | Remove retry statements | `retry` -> `nil` |
-| `case_when` | Remove/replace case/when branches | Remove `when` branch, body -> `nil`, remove `else` |
+| `case_when` | Remove/replace case/when branches | Remove `when` branch, drop one condition from `when a, b`, body -> `nil`, empty body -> `raise`, remove `else` |
+| `case_in` | Drop one `in` clause from a `case/in`, or its `else` | `case x; in Integer; …; in String; …; end` -> drops an arm; `else` -> `NoMatchingPatternError` |
+| `pattern_predicate` | One-line pattern match -> `false` | `x in Integer` -> `false` |
 | `predicate_replacement` | Replace predicate calls with booleans | `x.empty?` -> `true`, `x.empty?` -> `false` |
 | `equality_to_identity` | Replace equality with identity check | `a == b` -> `a.equal?(b)` |
 | `lambda_body` | Replace lambda body with nil | `-> { expr }` -> `-> { nil }` |
@@ -810,7 +816,7 @@ points — see [docs/architecture.md](docs/architecture.md).
 1. **Parse** — Prism parses Ruby files into ASTs with exact byte offsets
 2. **Extract** — Methods are identified as mutation subjects
 3. **Filter** — Disable comments, Sorbet `sig` blocks, and AST ignore patterns exclude mutations before execution
-4. **Mutate** — 74 operators produce text replacements at precise byte offsets (source-level surgery, no AST unparsing); heredoc literal text is skipped by default. Identical byte-mutations from different operators are deduplicated by `(file_path, mutated_source)` so the count is not inflated by overlap
+4. **Mutate** — 80 operators produce text replacements at precise byte offsets (source-level surgery, no AST unparsing); heredoc literal text is skipped by default. Identical byte-mutations from different operators are deduplicated by `(file_path, mutated_source)` so the count is not inflated by overlap
 5. **Isolate** — Mutations are applied to temporary file copies (never modifying originals); load-path redirection ensures `require` resolves the mutated copy. Default isolation is in-process for plain Ruby projects (no gemspec) and fork for Rails projects and packaged gems (auto-detected); `--isolation fork` forces forked child processes. Both sequential and parallel (`--jobs N`) modes respect the configured isolation strategy
 6. **Test** — The configured test framework (RSpec, Minitest, or Test::Unit) executes against the mutated source
 7. **Collect** — Source strings and AST nodes are released after use to minimize memory retention

data/docs/architecture.md

@@ -48,7 +48,7 @@ Everything lives under `lib/evilution/`.
 | `Config`, `Config::*` | Merge `.evilution.yml` + CLI flags + env, validate, freeze. | `config.rb`, `config/sources.rb`, `config/validators/*` |
 | `Runner`, `Runner::*` | Orchestrate the whole run. Each stage is its own collaborator. | `runner.rb`, `runner/*` |
 | `AST`, `Subject` | Prism parse, find method subjects, source surgery, pattern matching, heredoc spans. | `ast/parser.rb`, `ast/source_surgeon.rb`, `subject.rb` |
-| `Mutator`, `Mutator::Operator::*` | 74 operators (default profile) that emit byte-edits; registry + profiles. | `mutator/base.rb`, `mutator/registry.rb`, `mutator/operator/*` |
+| `Mutator`, `Mutator::Operator::*` | 80 operators (default profile) that emit byte-edits; registry + profiles. | `mutator/base.rb`, `mutator/registry.rb`, `mutator/operator/*` |
 | `Mutation` | An immutable mutation record (original/mutated sources, slice, location, parse status). | `mutation.rb` |
 | `SpecResolver`, `SpecSelector` | Map a source file to its covering spec files (layout heuristics + explicit mappings). | `spec_resolver.rb`, `spec_selector.rb` |
 | `Isolation::{Fork,InProcess}`, `ProcessSupervisor` | Run one mutation's tests in isolation; process-group lifecycle, sandboxing, TERM/KILL ladder. | `isolation/fork.rb`, `process_supervisor.rb` |

data/lib/evilution/integration/loading/redefinition_recovery.rb

@@ -65,7 +65,7 @@ class Evilution::Integration::Loading::RedefinitionRecovery
     msg = error.message
     # `msg` is a String and patterns are substrings, so `include?` is a
     # substring test — `intersect?` would compare array elements, not text.
-    IDEMPOTENCY_PATTERNS.any? { |pat| msg.include?(pat) } # rubocop:disable Style/ArrayIntersect
+    IDEMPOTENCY_PATTERNS.any? { msg.include?(_1) }
   end
 
   def superclass_mismatch?(error)

data/lib/evilution/mcp/complete_result_server.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "mcp"
+
+require_relative "../mcp"
+
+# MCP protocol revision 2026-07-28 (SEP-2322) makes `resultType` mandatory on list results: a
+# client may only treat a missing field as "complete" for servers that negotiated an earlier
+# revision. The mcp gem echoes back any client-offered revision it supports — 2026-07-28
+# included — yet its list handlers still omit the field, so strict clients reject the whole
+# list and the server appears to expose no tools at all.
+#
+# Every list result this server produces is final (there is no `input_required` round trip in
+# the evilution tool surface), so the field is always `"complete"`. The value is written as a
+# literal rather than `MCP::ResultType::COMPLETE` because the gem dependency allows versions
+# that predate that constant. Older revisions ignore the extra key.
+class Evilution::MCP::CompleteResultServer < MCP::Server
+  RESULT_TYPE_COMPLETE = "complete"
+
+  private
+
+  def list_tools(request)
+    mark_complete(super)
+  end
+
+  def list_prompts(request)
+    mark_complete(super)
+  end
+
+  def list_resources(request)
+    mark_complete(super)
+  end
+
+  def list_resource_templates(request)
+    mark_complete(super)
+  end
+
+  def mark_complete(result)
+    result.merge(resultType: RESULT_TYPE_COMPLETE)
+  end
+end

data/lib/evilution/mcp/server.rb

@@ -2,6 +2,7 @@
 
 require "mcp"
 require_relative "../version"
+require_relative "complete_result_server"
 require_relative "mutate_tool"
 require_relative "session_tool"
 require_relative "info_tool"
@@ -10,7 +11,7 @@ require_relative "../mcp"
 
 class Evilution::MCP::Server
   def self.build
-    ::MCP::Server.new(
+    Evilution::MCP::CompleteResultServer.new(
       name: "evilution",
       version: Evilution::VERSION,
       tools: [Evilution::MCP::MutateTool, Evilution::MCP::SessionTool, Evilution::MCP::InfoTool]

data/lib/evilution/mutator/base.rb

@@ -3,10 +3,13 @@
 require "prism"
 
 require_relative "../mutator"
+require_relative "primitives"
 require_relative "../integration/loading/body_call_neutralizer"
 require_relative "../ast/heredoc_span"
 
 class Evilution::Mutator::Base < Prism::Visitor
+  include Evilution::Mutator::Primitives
+
   AffectedSlices = Data.define(:original, :mutated)
   private_constant :AffectedSlices
 
@@ -41,7 +44,12 @@ class Evilution::Mutator::Base < Prism::Visitor
 
   private
 
-  def add_mutation(offset:, length:, replacement:, node:)
+  # `skip_unparseable` makes the mutation vanish rather than be recorded when
+  # the surgery does not parse. Off by default: the point operators rely on
+  # unparseable bytes reaching the reporter as their own bucket. The shared
+  # primitives opt in, since a nil-ification or promotion that does not parse
+  # carries no signal.
+  def add_mutation(offset:, length:, replacement:, node:, skip_unparseable: false)
     return if @filter && @filter.skip?(node)
 
     # When the byte range opens a heredoc but stops at its inline anchor,
@@ -67,6 +75,8 @@ class Evilution::Mutator::Base < Prism::Visitor
     surgery = Evilution::AST::SourceSurgeon.apply(
       @file_source, offset: offset, length: length, replacement: replacement
     )
+    return if skip_unparseable && surgery.unparseable?
+
     slices = slice_affected_lines(
       mutated_source: surgery.source,
       offset: offset,
@@ -74,7 +84,9 @@ class Evilution::Mutator::Base < Prism::Visitor
       replacement_bytesize: replacement.bytesize
     )
 
-    @mutations << build_mutation_record(node, surgery, slices)
+    mutation = build_mutation_record(node, surgery, slices)
+    @mutations << mutation
+    mutation
   end
 
   def build_mutation_record(node, surgery, slices)

data/lib/evilution/mutator/operator/boolean_expression_to_nil.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Replace a whole compound boolean with `nil`: `a && b` becomes `nil`, and
+# the same for `||` and the `and` / `or` keyword forms.
+#
+# Where BooleanOperandPromotion drops one side, this drops both. The
+# survivor it targets is a condition whose value is never asserted — code
+# that runs the expression for its side effects, or a test that only checks
+# the branch was taken rather than what the branch was given.
+class Evilution::Mutator::Operator::BooleanExpressionToNil < Evilution::Mutator::Base
+  def visit_and_node(node)
+    mutate_to_nil(node)
+    super
+  end
+
+  def visit_or_node(node)
+    mutate_to_nil(node)
+    super
+  end
+end

data/lib/evilution/mutator/operator/boolean_operand_promotion.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Drop one side of a compound boolean: `a && b` becomes `a` and `b`, and the
+# same for `||` (both the symbol and the `and` / `or` keyword forms).
+#
+# BooleanOperatorReplacement swaps the operator but always keeps both
+# operands, so a test that only ever exercises one side of a condition
+# survives it. Promoting an operand kills exactly those tests.
+class Evilution::Mutator::Operator::BooleanOperandPromotion < Evilution::Mutator::Base
+  def visit_and_node(node)
+    promote_operands(node)
+    super
+  end
+
+  def visit_or_node(node)
+    promote_operands(node)
+    super
+  end
+
+  private
+
+  # Nested expressions need no special handling: `a && b && c` is an outer
+  # AndNode over an inner one, so the outer visit yields `a && b` and `c`
+  # while `super` descends and the inner visit yields `a && c` and `b`.
+  def promote_operands(node)
+    promote_child(node, node.left)
+    promote_child(node, node.right)
+  end
+end

data/lib/evilution/mutator/operator/case_in.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Drop one `in` clause from a `case/in`, leaving the rest of the arms in
+# place.
+#
+# Input that used to match the removed pattern now falls through to a later
+# arm, to the `else`, or -- with neither -- raises NoMatchingPatternError. A
+# survivor means the suite never exercises that arm, so its pattern could be
+# deleted outright without any test noticing.
+#
+# Pattern matching had no visitor at all before this operator: the case/in
+# grammar is a CaseMatchNode of InNodes, unrelated to the CaseNode/WhenNode
+# pair CaseWhen handles.
+class Evilution::Mutator::Operator::CaseIn < Evilution::Mutator::Base
+  def visit_case_match_node(node)
+    remove_in_clauses(node)
+    remove_else_branch(node)
+    super
+  end
+
+  private
+
+  # A case/in needs at least one arm to parse, so a lone clause stays put.
+  def remove_in_clauses(node)
+    return if node.conditions.length < 2
+
+    node.conditions.each do |in_node|
+      location = in_node.location
+
+      add_mutation(
+        offset: location.start_offset,
+        length: location.length,
+        replacement: "",
+        node: in_node
+      )
+    end
+  end
+
+  # Without an else, an unmatched value raises NoMatchingPatternError rather
+  # than falling through, so a survivor means nothing in the suite reaches the
+  # fallback.
+  #
+  # An empty else body is worth removing here, which is where this parts ways
+  # with CaseWhen: a case/when yields nil whether its else is empty or absent,
+  # but an empty case/in else yields nil while an absent one raises. Prism
+  # reports no statements for that shape, so the edit covers the keyword alone.
+  def remove_else_branch(node)
+    else_clause = node.else_clause
+    return if else_clause.nil?
+
+    keyword_location = else_clause.else_keyword_loc
+    statements = else_clause.statements
+    end_offset = statements.nil? ? keyword_location.end_offset : statements.location.end_offset
+
+    add_mutation(
+      offset: keyword_location.start_offset,
+      length: end_offset - keyword_location.start_offset,
+      replacement: "",
+      node: else_clause
+    )
+  end
+end

data/lib/evilution/mutator/operator/case_when.rb

@@ -5,7 +5,9 @@ require_relative "../operator"
 class Evilution::Mutator::Operator::CaseWhen < Evilution::Mutator::Base
   def visit_case_node(node)
     remove_when_branches(node)
+    remove_when_conditions(node)
     replace_when_bodies(node)
+    raise_in_empty_when_bodies(node)
     remove_else_branch(node)
 
     super
@@ -26,9 +28,42 @@ class Evilution::Mutator::Operator::CaseWhen < Evilution::Mutator::Base
     end
   end
 
+  # `when a, b` matches on either value, so dropping the whole arm cannot tell
+  # which of them a test actually exercises. Shortening the list one value at a
+  # time can. WhenNode#conditions holds the values; the enclosing CaseNode's
+  # own #conditions holds the arms.
+  def remove_when_conditions(node)
+    node.conditions.each do |when_node|
+      values = when_node.conditions
+      next if values.length < 2
+
+      values.each_index do |index|
+        offset, length = condition_removal_span(values, index)
+
+        add_mutation(offset: offset, length: length, replacement: "", node: when_node)
+      end
+    end
+  end
+
+  # Each value has to take its separating comma with it, or the arm is left
+  # with a dangling one. The first value owns the comma that follows it; every
+  # later value owns the comma that precedes it. Taking whole byte ranges
+  # between value boundaries also sweeps up any newline the list wraps on.
+  def condition_removal_span(values, index)
+    if index.zero?
+      start_offset = values[0].location.start_offset
+      end_offset = values[1].location.start_offset
+    else
+      start_offset = values[index - 1].location.end_offset
+      end_offset = values[index].location.end_offset
+    end
+
+    [start_offset, end_offset - start_offset]
+  end
+
   def replace_when_bodies(node)
     node.conditions.each do |when_node|
-      next if when_node.statements.nil? || when_node.statements.body.empty?
+      next if empty_body?(when_node)
 
       add_mutation(
         offset: when_node.statements.location.start_offset,
@@ -39,6 +74,42 @@ class Evilution::Mutator::Operator::CaseWhen < Evilution::Mutator::Base
     end
   end
 
+  # An empty arm is a deliberate no-op, so there is no body to blank out --
+  # dropping the arm entirely is indistinguishable from falling through to a
+  # missing else. Inserting a raise is what proves the arm was selected.
+  def raise_in_empty_when_bodies(node)
+    node.conditions.each do |when_node|
+      next unless empty_body?(when_node)
+
+      indent = " " * (indentation_of(when_node.keyword_loc.start_offset) + 2)
+
+      add_mutation(
+        offset: body_insert_offset(when_node),
+        length: 0,
+        replacement: "\n#{indent}raise",
+        node: when_node
+      )
+    end
+  end
+
+  def empty_body?(when_node)
+    statements = when_node.statements
+    statements.nil? || statements.body.empty?
+  end
+
+  # `when 1, 2` puts the body after the last condition; `when 1 then` after the
+  # keyword. Prism reports a nil then_keyword_loc when the form omits it.
+  def body_insert_offset(when_node)
+    then_keyword_loc = when_node.then_keyword_loc
+    location = then_keyword_loc.nil? ? when_node.conditions.last.location : then_keyword_loc
+
+    location.start_offset + location.length
+  end
+
+  def indentation_of(offset)
+    offset - line_start_byte(@file_source, offset)
+  end
+
   def remove_else_branch(node)
     else_clause = node.else_clause
     return if else_clause.nil? || else_clause.statements.nil?

data/lib/evilution/mutator/operator/conditional_branch.rb

@@ -4,21 +4,34 @@ require_relative "../operator"
 
 class Evilution::Mutator::Operator::ConditionalBranch < Evilution::Mutator::Base
   def visit_if_node(node)
-    return super unless node.statements
+    blank_branches(node, node.subsequent)
 
-    add_nil_mutation(node.statements, node)
-    add_nil_mutation_to_else(node.subsequent, node)
+    super
+  end
+
+  # Prism gives `unless` its own node type, and names the else slot
+  # `else_clause` rather than IfNode's `subsequent`. Everything below that is
+  # the same shape, so both forms share the branch handling.
+  def visit_unless_node(node)
+    blank_branches(node, node.else_clause)
 
     super
   end
 
   private
 
-  def add_nil_mutation_to_else(subsequent, node)
-    return unless subsequent.is_a?(Prism::ElseNode)
-    return if subsequent.statements.nil?
+  def blank_branches(node, else_clause)
+    return if node.statements.nil?
+
+    add_nil_mutation(node.statements, node)
+    add_nil_mutation_to_else(else_clause, node)
+  end
+
+  def add_nil_mutation_to_else(else_clause, node)
+    return unless else_clause.is_a?(Prism::ElseNode)
+    return if else_clause.statements.nil?
 
-    add_nil_mutation(subsequent.statements, node)
+    add_nil_mutation(else_clause.statements, node)
   end
 
   def add_nil_mutation(statements, node)

data/lib/evilution/mutator/operator/if_branch_swap.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Replace the if-branch with the else body and drop the else:
+# `if c; x; else; y; end` becomes `if c; y; end`.
+#
+# The condition still runs and still selects, but both of its outcomes
+# change: truthy now yields the else body, falsy now yields nil. That is out
+# of reach of the existing conditional operators — ConditionalNegation
+# pins the predicate to one branch, ConditionalBranch blanks a body to nil —
+# so this survives only when the suite never distinguishes the two branch
+# values from each other.
+class Evilution::Mutator::Operator::IfBranchSwap < Evilution::Mutator::Base
+  def visit_if_node(node)
+    swap_branches(node)
+    super
+  end
+
+  private
+
+  # The edit spans from the start of the if-branch to the end of the else
+  # body, which swallows the `else` keyword along with the original branch.
+  # It deliberately stops short of ElseNode#location, which runs on to the
+  # closing `end` the mutation needs to keep.
+  #
+  # `subsequent` is an IfNode rather than an ElseNode on an `elsif`, and
+  # nil on a bare `if`; neither has an else body to promote. A ternary does
+  # reach the edit, but `c ? y` does not parse, so add_mutation drops it.
+  def swap_branches(node)
+    else_node = node.subsequent
+    return unless else_node.is_a?(Prism::ElseNode)
+
+    then_statements = node.statements
+    else_statements = else_node.statements
+    return if then_statements.nil? || else_statements.nil?
+
+    offset = then_statements.location.start_offset
+
+    add_mutation(
+      offset: offset,
+      length: else_statements.location.end_offset - offset,
+      replacement: source_of(else_statements),
+      node: node,
+      skip_unparseable: true
+    )
+  end
+end

data/lib/evilution/mutator/operator/loop_body_to_raise.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Replace a loop body with a bare `raise`: `while c; body; end` becomes
+# `while c; raise; end`.
+#
+# A survivor means no test ever enters the loop, so the body is either dead
+# or reached only by paths the suite never exercises. The raise terminates
+# the loop on its first iteration, which is what makes this safe where
+# body-to-nil is not: nil-ing a body that advances the predicate spins until
+# the per-mutation timeout (EV-170m.7).
+class Evilution::Mutator::Operator::LoopBodyToRaise < Evilution::Mutator::Base
+  def visit_while_node(node)
+    replace_body_with_raise(node)
+    super
+  end
+
+  def visit_until_node(node)
+    replace_body_with_raise(node)
+    super
+  end
+
+  private
+
+  def replace_body_with_raise(node)
+    statements = body_statements(node)
+    return if statements.nil?
+    return if bare_raise?(statements)
+
+    location = statements.location
+
+    add_mutation(
+      offset: location.start_offset,
+      length: location.length,
+      replacement: "raise",
+      node: node
+    )
+  end
+
+  # A post-form loop (`begin ... end while c`) hangs its body off a BeginNode,
+  # and that node's own span is what WhileNode#statements reports. Editing the
+  # outer span would rewrite the loop as `raise while c`, which checks the
+  # predicate first and so no longer runs the body unconditionally -- exactly
+  # the property this mutation exists to probe. Reach through to the inner
+  # statements instead and leave `begin ... end while c` standing.
+  #
+  # begin_modifier? is set only for that post-form, where the grammar
+  # guarantees the single wrapped statement is the BeginNode.
+  def body_statements(node)
+    statements = node.statements
+    return statements unless node.begin_modifier?
+
+    statements.body.first.statements
+  end
+
+  # A body that already raises unconditionally would mutate to itself.
+  def bare_raise?(statements)
+    body = statements.body
+    return false unless body.length == 1
+
+    only = body.first
+    only.is_a?(Prism::CallNode) &&
+      only.name == :raise &&
+      only.arguments.nil? &&
+      only.receiver.nil?
+  end
+end

data/lib/evilution/mutator/operator/pattern_predicate.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Replace a one-line pattern match with `false`: `x in Integer` becomes
+# `false`.
+#
+# The mutant differs from the original only on inputs the pattern actually
+# matches, so a survivor means no test ever feeds it a matching value -- the
+# true path of the predicate is unexercised.
+#
+# Only Prism::MatchPredicateNode is mutated. Its sibling MatchRequiredNode
+# (`x => Integer`) raises NoMatchingPatternError rather than returning a
+# boolean, so `false` would not stand in for it.
+class Evilution::Mutator::Operator::PatternPredicate < Evilution::Mutator::Base
+  def visit_match_predicate_node(node)
+    location = node.location
+
+    add_mutation(
+      offset: location.start_offset,
+      length: location.length,
+      replacement: "false",
+      node: node
+    )
+
+    super
+  end
+end

data/lib/evilution/mutator/primitives.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative "../mutator"
+
+# Mutation shapes shared across the operator families: replacing an
+# expression with `nil`, and replacing an expression with the source of one
+# of its children. Both are built on Base#add_mutation, so the
+# equivalent-mutant filter and the heredoc-span guards still apply.
+#
+# Unlike a bare add_mutation call, these skip rather than emit when the
+# result would not parse in its surrounding context. A promotion that does
+# not parse is noise rather than signal, so it never reaches the
+# `unparseable` bucket the point operators still populate.
+module Evilution::Mutator::Primitives
+  private
+
+  # Replace `target`'s byte span with `nil`, attributing the mutation to
+  # `node`. `target` defaults to `node`; pass an inner node to nil out a body
+  # while keeping the reported location on the enclosing construct.
+  def mutate_to_nil(node, target: node)
+    replace_span(node: node, target: target, replacement: "nil")
+  end
+
+  # Replace `target`'s byte span with `child`'s source, verbatim. `child` may
+  # be nil — Prism leaves optional slots (a call's receiver, an if's else)
+  # empty — in which case there is nothing to promote.
+  def promote_child(node, child, target: node)
+    return nil if child.nil?
+
+    replace_span(node: node, target: target, replacement: source_of(child))
+  end
+
+  def replace_span(node:, target:, replacement:)
+    return nil if target.nil?
+
+    location = target.location
+    return nil if replacement == byteslice_source(location.start_offset, location.length)
+
+    add_mutation(
+      offset: location.start_offset,
+      length: location.length,
+      replacement: replacement,
+      node: node,
+      skip_unparseable: true
+    )
+  end
+
+  def source_of(child)
+    location = child.location
+    byteslice_source(location.start_offset, location.length)
+  end
+end

data/lib/evilution/mutator/registry.rb

@@ -29,6 +29,8 @@ class Evilution::Mutator::Registry
       Evilution::Mutator::Operator::ComparisonReplacement,
       Evilution::Mutator::Operator::ArithmeticReplacement,
       Evilution::Mutator::Operator::BooleanOperatorReplacement,
+      Evilution::Mutator::Operator::BooleanOperandPromotion,
+      Evilution::Mutator::Operator::BooleanExpressionToNil,
       Evilution::Mutator::Operator::BooleanLiteralReplacement,
       Evilution::Mutator::Operator::NilReplacement,
       Evilution::Mutator::Operator::IntegerLiteral,
@@ -39,6 +41,7 @@ class Evilution::Mutator::Registry
       Evilution::Mutator::Operator::SymbolLiteral,
       Evilution::Mutator::Operator::ConditionalNegation,
       Evilution::Mutator::Operator::ConditionalBranch,
+      Evilution::Mutator::Operator::IfBranchSwap,
       Evilution::Mutator::Operator::LastExpressionRemoval,
       Evilution::Mutator::Operator::StatementDeletion,
       Evilution::Mutator::Operator::MethodBodyReplacement,
@@ -92,9 +95,12 @@ class Evilution::Mutator::Registry
       Evilution::Mutator::Operator::DefinedCheck,
       Evilution::Mutator::Operator::RegexCapture,
       Evilution::Mutator::Operator::LoopFlip,
+      Evilution::Mutator::Operator::LoopBodyToRaise,
       Evilution::Mutator::Operator::StringInterpolation,
       Evilution::Mutator::Operator::RetryRemoval,
       Evilution::Mutator::Operator::CaseWhen,
+      Evilution::Mutator::Operator::CaseIn,
+      Evilution::Mutator::Operator::PatternPredicate,
       Evilution::Mutator::Operator::PredicateReplacement,
       Evilution::Mutator::Operator::EqualityToIdentity,
       Evilution::Mutator::Operator::LambdaBody,

data/lib/evilution/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Evilution
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
 end

data/lib/evilution.rb

@@ -27,11 +27,14 @@ require_relative "evilution/mutator/operator/integer_literal"
 require_relative "evilution/mutator/operator/float_literal"
 require_relative "evilution/mutator/operator/nil_replacement"
 require_relative "evilution/mutator/operator/boolean_operator_replacement"
+require_relative "evilution/mutator/operator/boolean_operand_promotion"
+require_relative "evilution/mutator/operator/boolean_expression_to_nil"
 require_relative "evilution/mutator/operator/arithmetic_replacement"
 require_relative "evilution/mutator/operator/string_literal"
 require_relative "evilution/mutator/operator/array_literal"
 require_relative "evilution/mutator/operator/hash_literal"
 require_relative "evilution/mutator/operator/conditional_branch"
+require_relative "evilution/mutator/operator/if_branch_swap"
 require_relative "evilution/mutator/operator/symbol_literal"
 require_relative "evilution/mutator/operator/conditional_negation"
 require_relative "evilution/mutator/operator/negation_insertion"
@@ -85,9 +88,12 @@ require_relative "evilution/mutator/operator/splat_operator"
 require_relative "evilution/mutator/operator/defined_check"
 require_relative "evilution/mutator/operator/regex_capture"
 require_relative "evilution/mutator/operator/loop_flip"
+require_relative "evilution/mutator/operator/loop_body_to_raise"
 require_relative "evilution/mutator/operator/string_interpolation"
 require_relative "evilution/mutator/operator/retry_removal"
 require_relative "evilution/mutator/operator/case_when"
+require_relative "evilution/mutator/operator/case_in"
+require_relative "evilution/mutator/operator/pattern_predicate"
 require_relative "evilution/mutator/operator/predicate_replacement"
 require_relative "evilution/mutator/operator/predicate_to_nil"
 require_relative "evilution/mutator/operator/equality_to_identity"

data/scripts/compare_targeting

@@ -128,8 +128,10 @@ module CompareTargeting
     def lost_kills(mode = "coverage")
       full = @modes.fetch("full_file")
       other = @modes.fetch(mode)
-      full.keys.select { |key| full.status(key) == "killed" && other.status(key) != "killed" }
-               .map { |key| full.label(key) }
+      full
+        .keys
+        .select { |key| full.status(key) == "killed" && other.status(key) != "killed" }
+        .map { |key| full.label(key) }
     end
 
     def to_row(repo)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: evilution
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Denis Kiselev
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-07-15 00:00:00.000000000 Z
+date: 2026-08-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: diff-lcs
@@ -273,6 +273,7 @@ files:
 - lib/evilution/load_path.rb
 - lib/evilution/load_path/subpath_resolver.rb
 - lib/evilution/mcp.rb
+- lib/evilution/mcp/complete_result_server.rb
 - lib/evilution/mcp/info_tool.rb
 - lib/evilution/mcp/info_tool/actions.rb
 - lib/evilution/mcp/info_tool/actions/base.rb
@@ -313,9 +314,12 @@ files:
 - lib/evilution/mutator/operator/block_param_removal.rb
 - lib/evilution/mutator/operator/block_pass_removal.rb
 - lib/evilution/mutator/operator/block_removal.rb
+- lib/evilution/mutator/operator/boolean_expression_to_nil.rb
 - lib/evilution/mutator/operator/boolean_literal_replacement.rb
+- lib/evilution/mutator/operator/boolean_operand_promotion.rb
 - lib/evilution/mutator/operator/boolean_operator_replacement.rb
 - lib/evilution/mutator/operator/break_statement.rb
+- lib/evilution/mutator/operator/case_in.rb
 - lib/evilution/mutator/operator/case_when.rb
 - lib/evilution/mutator/operator/class_variable_write.rb
 - lib/evilution/mutator/operator/collection_replacement.rb
@@ -332,6 +336,7 @@ files:
 - lib/evilution/mutator/operator/float_literal.rb
 - lib/evilution/mutator/operator/global_variable_write.rb
 - lib/evilution/mutator/operator/hash_literal.rb
+- lib/evilution/mutator/operator/if_branch_swap.rb
 - lib/evilution/mutator/operator/index_assignment_removal.rb
 - lib/evilution/mutator/operator/index_to_at.rb
 - lib/evilution/mutator/operator/index_to_dig.rb
@@ -343,6 +348,7 @@ files:
 - lib/evilution/mutator/operator/lambda_body.rb
 - lib/evilution/mutator/operator/last_expression_removal.rb
 - lib/evilution/mutator/operator/local_variable_assignment.rb
+- lib/evilution/mutator/operator/loop_body_to_raise.rb
 - lib/evilution/mutator/operator/loop_flip.rb
 - lib/evilution/mutator/operator/method_body_replacement.rb
 - lib/evilution/mutator/operator/method_call_removal.rb
@@ -354,6 +360,7 @@ files:
 - lib/evilution/mutator/operator/pattern_matching_alternative.rb
 - lib/evilution/mutator/operator/pattern_matching_array.rb
 - lib/evilution/mutator/operator/pattern_matching_guard.rb
+- lib/evilution/mutator/operator/pattern_predicate.rb
 - lib/evilution/mutator/operator/predicate_replacement.rb
 - lib/evilution/mutator/operator/predicate_to_nil.rb
 - lib/evilution/mutator/operator/range_replacement.rb
@@ -376,6 +383,7 @@ files:
 - lib/evilution/mutator/operator/symbol_literal.rb
 - lib/evilution/mutator/operator/yield_statement.rb
 - lib/evilution/mutator/operator/zsuper_removal.rb
+- lib/evilution/mutator/primitives.rb
 - lib/evilution/mutator/registry.rb
 - lib/evilution/parallel.rb
 - lib/evilution/parallel/pool.rb