evilution 0.14.0 → 0.16.0

data/lib/evilution/equivalent/detector.rb

@@ -4,6 +4,8 @@ require_relative "heuristic/noop_source"
 require_relative "heuristic/method_body_nil"
 require_relative "heuristic/alias_swap"
 require_relative "heuristic/dead_code"
+require_relative "heuristic/arithmetic_identity"
+require_relative "heuristic/comment_marking"
 
 require_relative "../equivalent"
 
@@ -34,7 +36,9 @@ class Evilution::Equivalent::Detector
       Evilution::Equivalent::Heuristic::NoopSource.new,
       Evilution::Equivalent::Heuristic::MethodBodyNil.new,
       Evilution::Equivalent::Heuristic::AliasSwap.new,
-      Evilution::Equivalent::Heuristic::DeadCode.new
+      Evilution::Equivalent::Heuristic::DeadCode.new,
+      Evilution::Equivalent::Heuristic::ArithmeticIdentity.new,
+      Evilution::Equivalent::Heuristic::CommentMarking.new
     ]
   end
 end

data/lib/evilution/equivalent/heuristic/alias_swap.rb

@@ -6,11 +6,14 @@ class Evilution::Equivalent::Heuristic::AliasSwap
   ALIAS_PAIRS = Set[
     Set[:detect, :find],
     Set[:length, :size],
-    Set[:collect, :map]
+    Set[:collect, :map],
+    Set[:count, :length]
   ].freeze
 
+  MATCHING_OPERATORS = Set["send_mutation", "collection_replacement"].freeze
+
   def match?(mutation)
-    return false unless mutation.operator_name == "send_mutation"
+    return false unless MATCHING_OPERATORS.include?(mutation.operator_name)
 
     diff = mutation.diff
     removed = extract_method(diff, "- ")

data/lib/evilution/equivalent/heuristic/arithmetic_identity.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "../heuristic"
+
+class Evilution::Equivalent::Heuristic::ArithmeticIdentity
+  # Patterns where the original expression is an arithmetic identity operation.
+  # "x + 0" is identity (equals x), so mutating the 0 to something else means
+  # the original was a no-op — if the test doesn't catch it, it's likely equivalent.
+  ADDITIVE_IDENTITY = /[\w)\].]+\s*[+-]\s*0\b|\b0\s*\+\s*[\w(\[]/
+  MULTIPLICATIVE_IDENTITY = %r{[\w)\].]+\s*[*/]\s*1\b|\b1\s*\*\s*[\w(\[]}
+  EXPONENT_IDENTITY = /[\w)\].]+\s*\*\*\s*1\b/
+
+  def match?(mutation)
+    return false unless mutation.operator_name == "integer_literal"
+
+    removed = diff_line(mutation.diff, "- ")
+    return false unless removed
+
+    content = removed.sub(/^- /, "")
+    content.match?(ADDITIVE_IDENTITY) ||
+      content.match?(MULTIPLICATIVE_IDENTITY) ||
+      content.match?(EXPONENT_IDENTITY)
+  end
+
+  private
+
+  def diff_line(diff, prefix)
+    diff.split("\n").find { |l| l.start_with?(prefix) }
+  end
+end

data/lib/evilution/equivalent/heuristic/comment_marking.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "../heuristic"
+
+class Evilution::Equivalent::Heuristic::CommentMarking
+  MARKER = /#\s*evilution:equivalent\b/
+
+  def match?(mutation)
+    source = mutation.original_source
+    return false unless source
+
+    lines = source.lines
+    line_index = mutation.line - 1
+    return false if line_index.negative? || line_index >= lines.length
+
+    return true if lines[line_index].match?(MARKER)
+    return true if line_index.positive? && lines[line_index - 1].match?(MARKER)
+
+    false
+  end
+end

data/lib/evilution/mutator/base.rb

@@ -49,4 +49,20 @@ class Evilution::Mutator::Base < Prism::Visitor
               .gsub(/([a-z\d])([A-Z])/, '\1_\2')
               .downcase
   end
+
+  @parse_cache = {}
+
+  def self.parsed_tree_for(file_path, file_source)
+    cache = Evilution::Mutator::Base.instance_variable_get(:@parse_cache)
+    entry = cache[file_path]
+    return entry[:tree] if entry && entry[:source_hash] == file_source.hash
+
+    tree = Prism.parse(file_source).value
+    cache[file_path] = { source_hash: file_source.hash, tree: tree }
+    tree
+  end
+
+  def self.clear_parse_cache!
+    Evilution::Mutator::Base.instance_variable_set(:@parse_cache, {})
+  end
 end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::BangMethod < Evilution::Mutator::Base
+  KNOWN_BANG_PAIRS = %i[
+    sort map collect select reject uniq compact flatten
+    shuffle reverse slice gsub sub strip chomp chop squeeze
+    delete encode merge update save
+  ].to_set.freeze
+
+  def visit_call_node(node)
+    return super unless node.receiver
+
+    loc = node.message_loc
+    return super unless loc
+
+    name = node.name.to_s
+
+    if name.end_with?("!")
+      generate_non_bang(node, loc, name)
+    elsif KNOWN_BANG_PAIRS.include?(node.name)
+      generate_bang(node, loc, name)
+    end
+
+    super
+  end
+
+  private
+
+  def generate_non_bang(node, loc, name)
+    add_mutation(
+      offset: loc.start_offset,
+      length: loc.length,
+      replacement: name.chomp("!"),
+      node: node
+    )
+  end
+
+  def generate_bang(node, loc, name)
+    add_mutation(
+      offset: loc.start_offset,
+      length: loc.length,
+      replacement: "#{name}!",
+      node: node
+    )
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::BitwiseComplement < Evilution::Mutator::Base
+  def visit_call_node(node)
+    if node.name == :~ && node.receiver && node.arguments.nil?
+      loc = node.message_loc
+      receiver_loc = node.receiver.location
+
+      # Remove ~: replace entire ~expr with just the receiver expression
+      receiver_source = @file_source[receiver_loc.start_offset, receiver_loc.length]
+      add_mutation(
+        offset: node.location.start_offset,
+        length: node.location.length,
+        replacement: receiver_source,
+        node: node
+      )
+
+      # Swap ~ with unary minus
+      add_mutation(
+        offset: loc.start_offset,
+        length: loc.length,
+        replacement: "-",
+        node: node
+      )
+    end
+
+    super
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::BitwiseReplacement < Evilution::Mutator::Base
+  REPLACEMENTS = {
+    :& => %i[| ^],
+    :| => %i[& ^],
+    :^ => %i[& |]
+  }.freeze
+
+  def visit_call_node(node)
+    replacements = REPLACEMENTS[node.name]
+    return super unless replacements
+
+    loc = node.message_loc
+    return super unless loc
+
+    replacements.each do |replacement|
+      add_mutation(
+        offset: loc.start_offset,
+        length: loc.length,
+        replacement: replacement.to_s,
+        node: node
+      )
+    end
+
+    super
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::BreakStatement < Evilution::Mutator::Base
+  def visit_break_node(node)
+    generate_removal(node)
+    generate_nil_value(node)
+    generate_next_swap(node)
+
+    super
+  end
+
+  private
+
+  def generate_removal(node)
+    loc = node.location
+
+    add_mutation(
+      offset: loc.start_offset,
+      length: loc.length,
+      replacement: "nil",
+      node: node
+    )
+  end
+
+  def generate_nil_value(node)
+    return if node.arguments.nil?
+
+    args_loc = node.arguments.location
+
+    add_mutation(
+      offset: args_loc.start_offset,
+      length: args_loc.length,
+      replacement: "nil",
+      node: node
+    )
+  end
+
+  def generate_next_swap(node)
+    keyword_loc = node.keyword_loc
+
+    add_mutation(
+      offset: keyword_loc.start_offset,
+      length: keyword_loc.length,
+      replacement: "next",
+      node: node
+    )
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::ClassVariableWrite < Evilution::Mutator::Base
+  def visit_class_variable_write_node(node)
+    # Mutation 1: remove assignment, keep only the value expression
+    add_mutation(
+      offset: node.location.start_offset,
+      length: node.location.length,
+      replacement: node.value.slice,
+      node: node
+    )
+
+    # Mutation 2: replace value with nil
+    add_mutation(
+      offset: node.value.location.start_offset,
+      length: node.value.location.length,
+      replacement: "nil",
+      node: node
+    )
+
+    super
+  end
+end

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

@@ -17,7 +17,31 @@ class Evilution::Mutator::Operator::CollectionReplacement < Evilution::Mutator::
     any?: [:all?],
     all?: [:any?],
     count: [:length],
-    length: [:count]
+    length: [:count],
+    pop: [:shift],
+    shift: [:pop],
+    push: [:unshift],
+    unshift: [:push],
+    each_key: [:each_value],
+    each_value: [:each_key],
+    assoc: [:rassoc],
+    rassoc: [:assoc],
+    grep: [:grep_v],
+    grep_v: [:grep],
+    take: [:drop],
+    drop: [:take],
+    min: [:max],
+    max: [:min],
+    min_by: [:max_by],
+    max_by: [:min_by],
+    compact: [:flatten],
+    flatten: [:compact],
+    zip: [:product],
+    product: [:zip],
+    first: [:last],
+    last: [:first],
+    keys: [:values],
+    values: [:keys]
   }.freeze
 
   def visit_call_node(node)

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::EnsureRemoval < Evilution::Mutator::Base
+  def visit_ensure_node(node)
+    remove_start = line_start_after_newline(node.ensure_keyword_loc.start_offset)
+    remove_end = line_start_after_newline(node.end_keyword_loc.start_offset)
+
+    add_mutation(
+      offset: remove_start,
+      length: remove_end - remove_start,
+      replacement: "",
+      node: node
+    )
+
+    super
+  end
+
+  private
+
+  def line_start_after_newline(offset)
+    pos = offset
+    pos -= 1 while pos.positive? && @file_source[pos - 1] != "\n"
+    pos
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::ExplicitSuperMutation < Evilution::Mutator::Base
+  def visit_super_node(node)
+    replace_with_zsuper(node)
+    args = node.arguments&.arguments
+    mutate_arguments(node, args) if args && !args.empty?
+
+    super
+  end
+
+  private
+
+  def replace_with_zsuper(node)
+    add_mutation(
+      offset: node.location.start_offset,
+      length: node.location.length,
+      replacement: "super",
+      node: node
+    )
+  end
+
+  def mutate_arguments(node, args)
+    # Remove all arguments: super(a, b) -> super()
+    add_mutation(
+      offset: node.arguments.location.start_offset,
+      length: node.arguments.location.length,
+      replacement: "",
+      node: node
+    )
+
+    return unless args.length >= 2
+
+    # Remove individual arguments
+    args.each_index do |i|
+      remaining = args.each_with_index.filter_map { |a, j| a.slice if j != i }
+      add_mutation(
+        offset: node.arguments.location.start_offset,
+        length: node.arguments.location.length,
+        replacement: remaining.join(", "),
+        node: node
+      )
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::GlobalVariableWrite < Evilution::Mutator::Base
+  def visit_global_variable_write_node(node)
+    # Mutation 1: remove assignment, keep only the value expression
+    add_mutation(
+      offset: node.location.start_offset,
+      length: node.location.length,
+      replacement: node.value.slice,
+      node: node
+    )
+
+    # Mutation 2: replace value with nil
+    add_mutation(
+      offset: node.value.location.start_offset,
+      length: node.value.location.length,
+      replacement: "nil",
+      node: node
+    )
+
+    super
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::InlineRescue < Evilution::Mutator::Base
+  def visit_rescue_modifier_node(node)
+    generate_rescue_removal(node)
+    generate_nil_fallback(node)
+
+    super
+  end
+
+  private
+
+  def generate_rescue_removal(node)
+    expr_end = node.expression.location.start_offset + node.expression.location.length
+    rescue_end = node.rescue_expression.location.start_offset + node.rescue_expression.location.length
+
+    add_mutation(
+      offset: expr_end,
+      length: rescue_end - expr_end,
+      replacement: "",
+      node: node
+    )
+  end
+
+  def generate_nil_fallback(node)
+    return if node.rescue_expression.is_a?(Prism::NilNode)
+
+    fallback_loc = node.rescue_expression.location
+
+    add_mutation(
+      offset: fallback_loc.start_offset,
+      length: fallback_loc.length,
+      replacement: "nil",
+      node: node
+    )
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::InstanceVariableWrite < Evilution::Mutator::Base
+  def visit_instance_variable_write_node(node)
+    # Mutation 1: remove assignment, keep only the value expression
+    add_mutation(
+      offset: node.location.start_offset,
+      length: node.location.length,
+      replacement: node.value.slice,
+      node: node
+    )
+
+    # Mutation 2: replace value with nil
+    add_mutation(
+      offset: node.value.location.start_offset,
+      length: node.value.location.length,
+      replacement: "nil",
+      node: node
+    )
+
+    super
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::LocalVariableAssignment < Evilution::Mutator::Base
+  def visit_local_variable_write_node(node)
+    add_mutation(
+      offset: node.location.start_offset,
+      length: node.location.length,
+      replacement: node.value.slice,
+      node: node
+    )
+
+    super
+  end
+end

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::MixinRemoval < Evilution::Mutator::Base
+  MIXIN_METHODS = %i[include extend prepend].freeze
+
+  def call(subject)
+    @subject = subject
+    @file_source = File.read(subject.file_path)
+    @mutations = []
+
+    tree = self.class.parsed_tree_for(subject.file_path, @file_source)
+    enclosing = find_enclosing_scope(tree, subject.line_number)
+    return @mutations unless enclosing
+
+    first_method_line = find_first_method_line(enclosing)
+    return @mutations unless first_method_line == subject.line_number
+
+    find_mixin_calls(enclosing).each do |call_node|
+      add_mutation(
+        offset: call_node.location.start_offset,
+        length: call_node.location.length,
+        replacement: "",
+        node: call_node
+      )
+    end
+
+    @mutations
+  end
+
+  private
+
+  def find_enclosing_scope(tree, target_line)
+    finder = ScopeFinder.new(target_line)
+    finder.visit(tree)
+    finder.result
+  end
+
+  def find_first_method_line(scope_node)
+    return nil unless scope_node.body
+
+    scope_node.body.body.each do |node|
+      return node.location.start_line if node.is_a?(Prism::DefNode)
+    end
+    nil
+  end
+
+  def find_mixin_calls(scope_node)
+    return [] unless scope_node.body
+
+    scope_node.body.body.select do |node|
+      node.is_a?(Prism::CallNode) &&
+        MIXIN_METHODS.include?(node.name) &&
+        node.receiver.nil?
+    end
+  end
+
+  # Visitor to find the ClassNode or ModuleNode enclosing a given line number.
+  class ScopeFinder < Prism::Visitor
+    attr_reader :result
+
+    def initialize(target_line)
+      @target_line = target_line
+      @result = nil
+    end
+
+    def visit_class_node(node)
+      @result = node if @target_line.between?(node.location.start_line, node.location.end_line)
+      super
+    end
+
+    def visit_module_node(node)
+      @result = node if @target_line.between?(node.location.start_line, node.location.end_line)
+      super
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::NextStatement < Evilution::Mutator::Base
+  def visit_next_node(node)
+    generate_removal(node)
+    generate_nil_value(node)
+    generate_break_swap(node)
+
+    super
+  end
+
+  private
+
+  def generate_removal(node)
+    loc = node.location
+
+    add_mutation(
+      offset: loc.start_offset,
+      length: loc.length,
+      replacement: "nil",
+      node: node
+    )
+  end
+
+  def generate_nil_value(node)
+    return if node.arguments.nil?
+
+    args_loc = node.arguments.location
+
+    add_mutation(
+      offset: args_loc.start_offset,
+      length: args_loc.length,
+      replacement: "nil",
+      node: node
+    )
+  end
+
+  def generate_break_swap(node)
+    keyword_loc = node.keyword_loc
+
+    add_mutation(
+      offset: keyword_loc.start_offset,
+      length: keyword_loc.length,
+      replacement: "break",
+      node: node
+    )
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::RedoStatement < Evilution::Mutator::Base
+  def visit_redo_node(node)
+    loc = node.location
+
+    add_mutation(
+      offset: loc.start_offset,
+      length: loc.length,
+      replacement: "nil",
+      node: node
+    )
+
+    super
+  end
+end