evilution 0.16.0 → 0.17.0

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::PatternMatchingAlternative < Evilution::Mutator::Base
+  def visit_alternation_pattern_node(node)
+    remove_left(node)
+    remove_right(node)
+    swap_order(node)
+    super
+  end
+
+  private
+
+  def remove_left(node)
+    add_mutation(
+      offset: node.location.start_offset,
+      length: node.location.length,
+      replacement: source_for(node.right),
+      node: node
+    )
+  end
+
+  def remove_right(node)
+    add_mutation(
+      offset: node.location.start_offset,
+      length: node.location.length,
+      replacement: source_for(node.left),
+      node: node
+    )
+  end
+
+  def swap_order(node)
+    operator = @file_source.byteslice(node.operator_loc.start_offset, node.operator_loc.length)
+    add_mutation(
+      offset: node.location.start_offset,
+      length: node.location.length,
+      replacement: "#{source_for(node.right)} #{operator} #{source_for(node.left)}",
+      node: node
+    )
+  end
+
+  def source_for(node)
+    @file_source.byteslice(node.location.start_offset, node.location.length)
+  end
+end

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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::PatternMatchingArray < Evilution::Mutator::Base
+  def visit_array_pattern_node(node)
+    mutate_array_elements(node)
+    super
+  end
+
+  def visit_find_pattern_node(node)
+    mutate_find_elements(node)
+    super
+  end
+
+  private
+
+  def mutate_array_elements(node)
+    requireds = node.requireds
+    posts = node.posts
+    rest = node.rest
+    elements = requireds + posts
+    return if elements.empty?
+
+    elements.each_with_index do |_element, index|
+      remove_array_element(node, requireds, posts, rest, index) if elements.length > 1
+      wildcard_array_element(node, requireds, posts, rest, index)
+    end
+  end
+
+  def remove_array_element(node, requireds, posts, rest, skip_index)
+    parts = build_array_parts(requireds, posts, rest, skip_index: skip_index)
+    replace_pattern(node, parts)
+  end
+
+  def wildcard_array_element(node, requireds, posts, rest, wildcard_index)
+    parts = build_array_parts(requireds, posts, rest, wildcard_index: wildcard_index)
+    replace_pattern(node, parts)
+  end
+
+  def build_array_parts(requireds, posts, rest, skip_index: nil, wildcard_index: nil)
+    parts = []
+    requireds.each_with_index do |req, i|
+      next if i == skip_index
+
+      parts << (i == wildcard_index ? "_" : source_for(req))
+    end
+    parts << source_for(rest) if rest
+    posts.each_with_index do |post, i|
+      adjusted = requireds.length + i
+      next if adjusted == skip_index
+
+      parts << (adjusted == wildcard_index ? "_" : source_for(post))
+    end
+    parts
+  end
+
+  def mutate_find_elements(node)
+    return if node.requireds.empty?
+
+    node.requireds.each_with_index do |_element, index|
+      remove_find_element(node, index) if node.requireds.length > 1
+      wildcard_find_element(node, index)
+    end
+  end
+
+  def remove_find_element(node, skip_index)
+    parts = [source_for(node.left)]
+    node.requireds.each_with_index do |req, i|
+      parts << source_for(req) unless i == skip_index
+    end
+    parts << source_for(node.right)
+    replace_pattern(node, parts)
+  end
+
+  def wildcard_find_element(node, wildcard_index)
+    parts = [source_for(node.left)]
+    node.requireds.each_with_index do |req, i|
+      parts << (i == wildcard_index ? "_" : source_for(req))
+    end
+    parts << source_for(node.right)
+    replace_pattern(node, parts)
+  end
+
+  def replace_pattern(node, parts)
+    add_mutation(
+      offset: node.location.start_offset,
+      length: node.location.length,
+      replacement: "[#{parts.join(", ")}]",
+      node: node
+    )
+  end
+
+  def source_for(node)
+    @file_source.byteslice(node.location.start_offset, node.location.length)
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::PatternMatchingGuard < Evilution::Mutator::Base
+  def visit_in_node(node)
+    pattern = node.pattern
+    mutate_guard(pattern, node) if guarded?(pattern)
+    super
+  end
+
+  private
+
+  def guarded?(pattern)
+    pattern.is_a?(Prism::IfNode) || pattern.is_a?(Prism::UnlessNode)
+  end
+
+  def mutate_guard(pattern, in_node)
+    guard_start = pattern.statements.location.start_offset + pattern.statements.location.length
+    guard_end = pattern.predicate.location.start_offset + pattern.predicate.location.length
+
+    remove_guard(guard_start, guard_end, in_node)
+    negate_guard(pattern, in_node)
+  end
+
+  def remove_guard(guard_start, guard_end, in_node)
+    add_mutation(
+      offset: guard_start,
+      length: guard_end - guard_start,
+      replacement: "",
+      node: in_node
+    )
+  end
+
+  def negate_guard(pattern, in_node)
+    pred_loc = pattern.predicate.location
+    add_mutation(
+      offset: pred_loc.start_offset,
+      length: pred_loc.length,
+      replacement: "!(#{@file_source.byteslice(pred_loc.start_offset, pred_loc.length)})",
+      node: in_node
+    )
+  end
+end

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

@@ -5,10 +5,11 @@ require "prism"
 require_relative "../operator"
 
 class Evilution::Mutator::Operator::SuperclassRemoval < Evilution::Mutator::Base
-  def call(subject)
+  def call(subject, filter: nil)
     @subject = subject
     @file_source = File.read(subject.file_path)
     @mutations = []
+    @filter = filter
 
     tree = self.class.parsed_tree_for(subject.file_path, @file_source)
     enclosing = find_enclosing_class(tree, subject.line_number)

data/lib/evilution/mutator/registry.rb

@@ -51,7 +51,13 @@ class Evilution::Mutator::Registry
       Evilution::Mutator::Operator::BitwiseReplacement,
       Evilution::Mutator::Operator::BitwiseComplement,
       Evilution::Mutator::Operator::ZsuperRemoval,
-      Evilution::Mutator::Operator::ExplicitSuperMutation
+      Evilution::Mutator::Operator::ExplicitSuperMutation,
+      Evilution::Mutator::Operator::IndexToFetch,
+      Evilution::Mutator::Operator::IndexToDig,
+      Evilution::Mutator::Operator::IndexAssignmentRemoval,
+      Evilution::Mutator::Operator::PatternMatchingGuard,
+      Evilution::Mutator::Operator::PatternMatchingAlternative,
+      Evilution::Mutator::Operator::PatternMatchingArray
     ].each { |op| registry.register(op) }
     registry
   end
@@ -65,9 +71,9 @@ class Evilution::Mutator::Registry
     self
   end
 
-  def mutations_for(subject)
+  def mutations_for(subject, filter: nil)
     @operators.flat_map do |operator_class|
-      operator_class.new.call(subject)
+      operator_class.new.call(subject, filter: filter)
     end
   end
 

data/lib/evilution/parallel/pool.rb

@@ -3,10 +3,11 @@
 require_relative "../parallel"
 
 class Evilution::Parallel::Pool
-  def initialize(size:)
+  def initialize(size:, hooks: nil)
     raise ArgumentError, "pool size must be a positive integer, got #{size.inspect}" unless size.is_a?(Integer) && size >= 1
 
     @size = size
+    @hooks = hooks
   end
 
   def map(items, &block)
@@ -35,6 +36,7 @@ class Evilution::Parallel::Pool
   def fork_worker(item, read_io, write_io, &block)
     Process.fork do
       read_io.close
+      @hooks.fire(:worker_process_start) if @hooks
       result = block.call(item)
       Marshal.dump(result, write_io)
     rescue Exception => e # rubocop:disable Lint/RescueException

data/lib/evilution/reporter/cli.rb

@@ -60,6 +60,7 @@ class Evilution::Reporter::CLI
             "#{summary.survived} survived, #{summary.timed_out} timed out"
     parts += ", #{summary.neutral} neutral" if summary.neutral.positive?
     parts += ", #{summary.equivalent} equivalent" if summary.equivalent.positive?
+    parts += ", #{summary.skipped} skipped" if summary.skipped.positive?
     parts
   end
 

data/lib/evilution/reporter/html.rb

@@ -77,12 +77,19 @@ class Evilution::Reporter::HTML
         <div class="card"><span class="card-value">#{summary.errors}</span><span class="card-label">Errors</span></div>
         <div class="card"><span class="card-value">#{summary.neutral}</span><span class="card-label">Neutral</span></div>
         <div class="card"><span class="card-value">#{summary.equivalent}</span><span class="card-label">Equivalent</span></div>
+        #{build_skipped_card(summary)}
         <div class="card"><span class="card-value">#{format("%.2f", summary.duration)}s</span><span class="card-label">Duration</span></div>
         #{peak_html}
       </section>
     HTML
   end
 
+  def build_skipped_card(summary)
+    return "" unless summary.skipped.positive?
+
+    %(<div class="card"><span class="card-value">#{summary.skipped}</span><span class="card-label">Skipped</span></div>)
+  end
+
   def build_truncation_notice(summary)
     return "" unless summary.truncated?
 

data/lib/evilution/reporter/json.rb

@@ -46,6 +46,7 @@ class Evilution::Reporter::JSON
       duration: summary.duration.round(4)
     }
     data[:truncated] = true if summary.truncated?
+    data[:skipped] = summary.skipped if summary.skipped.positive?
     peak = summary.peak_memory_mb
     data[:peak_memory_mb] = peak.round(1) if peak
     data

data/lib/evilution/reporter/suggestion.rb

@@ -42,7 +42,13 @@ class Evilution::Reporter::Suggestion
     "bitwise_replacement" => "Add a test that checks the exact bitwise result to distinguish &, |, and ^ operators",
     "bitwise_complement" => "Add a test that verifies the bitwise complement (~) result, not just the sign or magnitude",
     "zsuper_removal" => "Add a test that verifies inherited behavior from super is needed, not just the subclass logic",
-    "explicit_super_mutation" => "Add a test that verifies the correct arguments are passed to super and the inherited result matters"
+    "explicit_super_mutation" => "Add a test that verifies the correct arguments are passed to super and the inherited result matters",
+    "index_to_fetch" => "Add a test that distinguishes [] (returns nil for missing keys) from .fetch (raises KeyError)",
+    "index_to_dig" => "Add a test that verifies chained [] access returns the correct nested value",
+    "index_assignment_removal" => "Add a test that verifies the []= assignment side effect is observable (the collection is modified)",
+    "pattern_matching_guard" => "Add a test with input that matches the pattern but fails the guard to verify filtering",
+    "pattern_matching_alternative" => "Add a test with input that matches only one specific alternative to verify each branch is reachable",
+    "pattern_matching_array" => "Add a test that verifies each element position in the array pattern matches the expected type or value"
   }.freeze
 
   CONCRETE_TEMPLATES = {
@@ -541,6 +547,86 @@ class Evilution::Reporter::Suggestion
           expect(result).to eq(expected)
         end
       RSPEC
+    },
+    "index_to_fetch" => lambda { |mutation|
+      method_name = parse_method_name(mutation.subject.name)
+      original_line, mutated_line = extract_diff_lines(mutation.diff)
+      <<~RSPEC.strip
+        # Mutation: changed `#{original_line}` to `#{mutated_line}` in #{mutation.subject.name}
+        # #{mutation.file_path}:#{mutation.line}
+        it 'distinguishes [] from .fetch for missing keys in ##{method_name}' do
+          # Access a missing key: [] returns nil, .fetch raises KeyError
+          expect { subject.#{method_name}(collection_with_missing_key) }.to raise_error(KeyError)
+        end
+      RSPEC
+    },
+    "index_to_dig" => lambda { |mutation|
+      method_name = parse_method_name(mutation.subject.name)
+      original_line, mutated_line = extract_diff_lines(mutation.diff)
+      <<~RSPEC.strip
+        # Mutation: changed `#{original_line}` to `#{mutated_line}` in #{mutation.subject.name}
+        # #{mutation.file_path}:#{mutation.line}
+        it 'verifies the chained [] access returns the correct nested value in ##{method_name}' do
+          # Assert the nested lookup produces the expected value
+          result = subject.#{method_name}(nested_collection)
+          expect(result).to eq(expected)
+        end
+      RSPEC
+    },
+    "index_assignment_removal" => lambda { |mutation|
+      method_name = parse_method_name(mutation.subject.name)
+      original_line, mutated_line = extract_diff_lines(mutation.diff)
+      <<~RSPEC.strip
+        # Mutation: changed `#{original_line}` to `#{mutated_line}` in #{mutation.subject.name}
+        # #{mutation.file_path}:#{mutation.line}
+        it 'verifies the []= assignment modifies the collection in ##{method_name}' do
+          # Assert the collection contains the assigned value after the method runs
+          result = subject.#{method_name}(collection)
+          expect(result).to include(expected_key => expected_value)
+        end
+      RSPEC
+    },
+    "pattern_matching_guard" => lambda { |mutation|
+      method_name = parse_method_name(mutation.subject.name)
+      original_line, mutated_line = extract_diff_lines(mutation.diff)
+      <<~RSPEC.strip
+        # Mutation: changed `#{original_line}` to `#{mutated_line}` in #{mutation.subject.name}
+        # #{mutation.file_path}:#{mutation.line}
+        it 'verifies the pattern guard filters correctly in ##{method_name}' do
+          # Test with input that matches the pattern but fails the guard condition
+          # The guard should prevent matching, routing to a different branch
+          result = subject.#{method_name}(input_matching_pattern_but_failing_guard)
+          expect(result).to eq(expected)
+        end
+      RSPEC
+    },
+    "pattern_matching_alternative" => lambda { |mutation|
+      method_name = parse_method_name(mutation.subject.name)
+      original_line, mutated_line = extract_diff_lines(mutation.diff)
+      <<~RSPEC.strip
+        # Mutation: changed `#{original_line}` to `#{mutated_line}` in #{mutation.subject.name}
+        # #{mutation.file_path}:#{mutation.line}
+        it 'verifies each pattern alternative is reachable in ##{method_name}' do
+          # Test with input that matches only one specific alternative
+          # Each alternative should have a dedicated test case
+          result = subject.#{method_name}(input_for_specific_alternative)
+          expect(result).to eq(expected)
+        end
+      RSPEC
+    },
+    "pattern_matching_array" => lambda { |mutation|
+      method_name = parse_method_name(mutation.subject.name)
+      original_line, mutated_line = extract_diff_lines(mutation.diff)
+      <<~RSPEC.strip
+        # Mutation: changed `#{original_line}` to `#{mutated_line}` in #{mutation.subject.name}
+        # #{mutation.file_path}:#{mutation.line}
+        it 'verifies each array pattern element matters in ##{method_name}' do
+          # Test with input where changing one element type causes a different match
+          # Each position in the array pattern should be validated
+          result = subject.#{method_name}(input_with_wrong_element_type)
+          expect(result).to eq(expected)
+        end
+      RSPEC
     }
   }.freeze
 

data/lib/evilution/result/summary.rb

@@ -3,12 +3,13 @@
 require_relative "../result"
 
 class Evilution::Result::Summary
-  attr_reader :results, :duration
+  attr_reader :results, :duration, :skipped
 
-  def initialize(results:, duration: 0.0, truncated: false)
+  def initialize(results:, duration: 0.0, truncated: false, skipped: 0)
     @results = results
     @duration = duration
     @truncated = truncated
+    @skipped = skipped
     freeze
   end
 

data/lib/evilution/runner.rb

@@ -20,13 +20,15 @@ require_relative "baseline"
 require_relative "cache"
 require_relative "parallel/pool"
 require_relative "session/store"
+require_relative "ast/pattern/filter"
 
 class Evilution::Runner
   attr_reader :config
 
-  def initialize(config: Evilution::Config.new, on_result: nil)
+  def initialize(config: Evilution::Config.new, on_result: nil, hooks: nil)
     @config = config
     @on_result = on_result
+    @hooks = hooks
     @parser = Evilution::AST::Parser.new
     @registry = Evilution::Mutator::Registry.default
     @isolator = build_isolator
@@ -41,7 +43,7 @@ class Evilution::Runner
 
     baseline_result = run_baseline(subjects)
 
-    mutations = generate_mutations(subjects)
+    mutations, skipped_count = generate_mutations(subjects)
     equivalent_mutations, mutations = filter_equivalent(mutations)
     release_subject_nodes(subjects)
     clear_operator_caches
@@ -54,7 +56,8 @@ class Evilution::Runner
 
     duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
 
-    summary = Evilution::Result::Summary.new(results: results, duration: duration, truncated: truncated)
+    summary = Evilution::Result::Summary.new(results: results, duration: duration, truncated: truncated,
+                                             skipped: skipped_count)
     output_report(summary)
     save_session(summary)
 
@@ -63,7 +66,7 @@ class Evilution::Runner
 
   private
 
-  attr_reader :parser, :registry, :isolator, :cache, :on_result
+  attr_reader :parser, :registry, :isolator, :cache, :on_result, :hooks
 
   def parse_and_filter_subjects
     subjects = parse_subjects
@@ -169,9 +172,18 @@ class Evilution::Runner
   end
 
   def generate_mutations(subjects)
-    subjects.flat_map do |subject|
-      registry.mutations_for(subject)
+    filter = build_ignore_filter
+    mutations = subjects.flat_map do |subject|
+      registry.mutations_for(subject, filter: filter)
     end
+    [mutations, filter ? filter.skipped_count : 0]
+  end
+
+  def build_ignore_filter
+    patterns = config.ignore_patterns
+    return nil if patterns.nil? || patterns.empty?
+
+    Evilution::AST::Pattern::Filter.new(patterns)
   end
 
   def filter_equivalent(mutations)
@@ -240,7 +252,7 @@ class Evilution::Runner
 
   def run_mutations_parallel(mutations, baseline_result = nil)
     integration = build_integration
-    pool = Evilution::Parallel::Pool.new(size: config.jobs)
+    pool = Evilution::Parallel::Pool.new(size: config.jobs, hooks: @hooks)
     worker_isolator = Evilution::Isolation::InProcess.new
     spec_resolver = baseline_result&.failed? ? Evilution::SpecResolver.new : nil
     state = { results: [], survived_count: 0, truncated: false, completed: 0 }
@@ -341,7 +353,7 @@ class Evilution::Runner
 
   def build_isolator
     case resolve_isolation
-    when :fork then Evilution::Isolation::Fork.new
+    when :fork then Evilution::Isolation::Fork.new(hooks: @hooks)
     when :in_process then Evilution::Isolation::InProcess.new
     end
   end
@@ -356,7 +368,7 @@ class Evilution::Runner
     case config.integration
     when :rspec
       test_files = config.spec_files.empty? ? nil : config.spec_files
-      Evilution::Integration::RSpec.new(test_files: test_files)
+      Evilution::Integration::RSpec.new(test_files: test_files, hooks: @hooks)
     else
       raise Evilution::Error, "unknown integration: #{config.integration}"
     end

data/lib/evilution/session/store.rb

@@ -69,12 +69,13 @@ class Evilution::Session::Store
       timed_out_count: summary.timed_out,
       error_count: summary.errors,
       neutral_count: summary.neutral,
-      equivalent_count: summary.equivalent
+      equivalent_count: summary.equivalent,
+      skipped_count: summary.skipped
     }
   end
 
   def build_summary(summary)
-    {
+    data = {
       total: summary.total,
       killed: summary.killed,
       survived: summary.survived,
@@ -85,6 +86,8 @@ class Evilution::Session::Store
       score: summary.score.round(4),
       duration: summary.duration.round(4)
     }
+    data[:skipped] = summary.skipped if summary.skipped.positive?
+    data
   end
 
   def build_mutation_detail(result)

data/lib/evilution/version.rb

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

data/lib/evilution.rb

@@ -11,6 +11,12 @@ require_relative "evilution/parallel"
 require_relative "evilution/ast/source_surgeon"
 require_relative "evilution/ast/parser"
 require_relative "evilution/ast/inheritance_scanner"
+require_relative "evilution/ast/pattern"
+require_relative "evilution/ast/pattern/matcher"
+require_relative "evilution/ast/pattern/parser"
+require_relative "evilution/hooks"
+require_relative "evilution/hooks/registry"
+require_relative "evilution/hooks/loader"
 require_relative "evilution/mutator"
 require_relative "evilution/mutator/base"
 require_relative "evilution/mutator/operator"
@@ -60,6 +66,12 @@ require_relative "evilution/mutator/operator/bitwise_replacement"
 require_relative "evilution/mutator/operator/bitwise_complement"
 require_relative "evilution/mutator/operator/zsuper_removal"
 require_relative "evilution/mutator/operator/explicit_super_mutation"
+require_relative "evilution/mutator/operator/index_to_fetch"
+require_relative "evilution/mutator/operator/index_to_dig"
+require_relative "evilution/mutator/operator/index_assignment_removal"
+require_relative "evilution/mutator/operator/pattern_matching_guard"
+require_relative "evilution/mutator/operator/pattern_matching_alternative"
+require_relative "evilution/mutator/operator/pattern_matching_array"
 require_relative "evilution/mutator/registry"
 require_relative "evilution/equivalent"
 require_relative "evilution/equivalent/heuristic"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: evilution
 version: !ruby/object:Gem::Version
-  version: 0.16.0
+  version: 0.17.0
 platform: ruby
 authors:
 - Denis Kiselev
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-03-29 00:00:00.000000000 Z
+date: 2026-03-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: diff-lcs
@@ -76,11 +76,16 @@ files:
 - README.md
 - Rakefile
 - claude-swarm.yml
+- docs/ast_pattern_syntax.md
 - exe/evilution
 - lib/evilution.rb
 - lib/evilution/ast.rb
 - lib/evilution/ast/inheritance_scanner.rb
 - lib/evilution/ast/parser.rb
+- lib/evilution/ast/pattern.rb
+- lib/evilution/ast/pattern/filter.rb
+- lib/evilution/ast/pattern/matcher.rb
+- lib/evilution/ast/pattern/parser.rb
 - lib/evilution/ast/source_surgeon.rb
 - lib/evilution/baseline.rb
 - lib/evilution/cache.rb
@@ -97,6 +102,9 @@ files:
 - lib/evilution/equivalent/heuristic/noop_source.rb
 - lib/evilution/git.rb
 - lib/evilution/git/changed_files.rb
+- lib/evilution/hooks.rb
+- lib/evilution/hooks/loader.rb
+- lib/evilution/hooks/registry.rb
 - lib/evilution/integration.rb
 - lib/evilution/integration/base.rb
 - lib/evilution/integration/rspec.rb
@@ -138,6 +146,9 @@ 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/index_assignment_removal.rb
+- lib/evilution/mutator/operator/index_to_dig.rb
+- lib/evilution/mutator/operator/index_to_fetch.rb
 - lib/evilution/mutator/operator/inline_rescue.rb
 - lib/evilution/mutator/operator/instance_variable_write.rb
 - lib/evilution/mutator/operator/integer_literal.rb
@@ -148,6 +159,9 @@ files:
 - lib/evilution/mutator/operator/negation_insertion.rb
 - lib/evilution/mutator/operator/next_statement.rb
 - lib/evilution/mutator/operator/nil_replacement.rb
+- 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/range_replacement.rb
 - lib/evilution/mutator/operator/receiver_replacement.rb
 - lib/evilution/mutator/operator/redo_statement.rb