evilution 0.28.0 → 0.30.0

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

@@ -4,27 +4,31 @@ require_relative "../operator"
 
 class Evilution::Mutator::Operator::BlockPassRemoval < Evilution::Mutator::Base
   def visit_call_node(node)
-    if node.block.is_a?(Prism::BlockArgumentNode)
-      block_node = node.block
-      call_start = node.location.start_offset
-      node_end = call_start + node.location.length
-      block_end = block_node.location.start_offset + block_node.location.length
-
-      prefix = @file_source.byteslice(call_start...block_node.location.start_offset).rstrip
-      suffix = @file_source.byteslice(block_end...node_end)
-
-      # Clean up: remove trailing comma from prefix, remove empty parens
-      prefix = prefix.sub(/,\s*\z/, "")
-      replacement = "#{prefix}#{suffix}".sub(/\(\s*\)/, "")
-
+    block_node = node.block
+    if block_node.is_a?(Prism::BlockArgumentNode)
       add_mutation(
-        offset: call_start,
+        offset: node.location.start_offset,
         length: node.location.length,
-        replacement: replacement,
+        replacement: build_replacement(node, block_node),
         node: node
       )
     end
 
     super
   end
+
+  private
+
+  # Drop the block-pass argument plus the trailing comma it leaves behind, and
+  # collapse the resulting `()` if the block-pass was the only argument.
+  def build_replacement(node, block_node)
+    call_start = node.location.start_offset
+    node_end = call_start + node.location.length
+    block_start = block_node.location.start_offset
+    block_end = block_start + block_node.location.length
+
+    prefix = @file_source.byteslice(call_start...block_start).rstrip.sub(/,\s*\z/, "")
+    suffix = @file_source.byteslice(block_end...node_end)
+    "#{prefix}#{suffix}".sub(/\(\s*\)/, "")
+  end
 end

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

@@ -40,16 +40,18 @@ class Evilution::Mutator::Operator::CaseWhen < Evilution::Mutator::Base
   end
 
   def remove_else_branch(node)
-    return if node.else_clause.nil?
-    return if node.else_clause.statements.nil?
+    else_clause = node.else_clause
+    return if else_clause.nil? || else_clause.statements.nil?
+
+    start_offset = else_clause.else_keyword_loc.start_offset
+    stmts_loc = else_clause.statements.location
+    end_offset = stmts_loc.start_offset + stmts_loc.length
 
-    start_offset = node.else_clause.else_keyword_loc.start_offset
-    end_offset = node.else_clause.statements.location.start_offset + node.else_clause.statements.location.length
     add_mutation(
       offset: start_offset,
       length: end_offset - start_offset,
       replacement: "",
-      node: node.else_clause
+      node: else_clause
     )
   end
 end

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

@@ -4,29 +4,29 @@ require_relative "../operator"
 
 class Evilution::Mutator::Operator::ConditionalBranch < Evilution::Mutator::Base
   def visit_if_node(node)
-    if node.statements && node.subsequent.nil?
-      add_mutation(
-        offset: node.statements.location.start_offset,
-        length: node.statements.location.length,
-        replacement: "nil",
-        node: node
-      )
-    elsif node.statements && node.subsequent&.statements
-      add_mutation(
-        offset: node.statements.location.start_offset,
-        length: node.statements.location.length,
-        replacement: "nil",
-        node: node
-      )
-
-      add_mutation(
-        offset: node.subsequent.statements.location.start_offset,
-        length: node.subsequent.statements.location.length,
-        replacement: "nil",
-        node: node
-      )
-    end
+    return super unless node.statements
+
+    add_nil_mutation(node.statements, node)
+    add_nil_mutation_to_else(node.subsequent, node)
 
     super
   end
+
+  private
+
+  def add_nil_mutation_to_else(subsequent, node)
+    return unless subsequent.is_a?(Prism::ElseNode)
+    return if subsequent.statements.nil?
+
+    add_nil_mutation(subsequent.statements, node)
+  end
+
+  def add_nil_mutation(statements, node)
+    add_mutation(
+      offset: statements.location.start_offset,
+      length: statements.location.length,
+      replacement: "nil",
+      node: node
+    )
+  end
 end

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

@@ -5,9 +5,8 @@ require_relative "../operator"
 class Evilution::Mutator::Operator::EqualityToIdentity < Evilution::Mutator::Base
   def visit_call_node(node)
     if node.name == :== && node.receiver && node.arguments
-      receiver_text = @file_source.byteslice(node.receiver.location.start_offset, node.receiver.location.length)
-      arg = node.arguments.arguments.first
-      arg_text = @file_source.byteslice(arg.location.start_offset, arg.location.length)
+      receiver_text = loc_text(node.receiver.location)
+      arg_text = loc_text(node.arguments.arguments.first.location)
 
       add_mutation(
         offset: node.location.start_offset,
@@ -19,4 +18,10 @@ class Evilution::Mutator::Operator::EqualityToIdentity < Evilution::Mutator::Bas
 
     super
   end
+
+  private
+
+  def loc_text(loc)
+    @file_source.byteslice(loc.start_offset, loc.length)
+  end
 end

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

@@ -23,25 +23,47 @@ class Evilution::Mutator::Operator::ExplicitSuperMutation < Evilution::Mutator::
   end
 
   def mutate_arguments(node, args)
-    # Remove all arguments: super(a, b) -> super()
+    emit_remove_all_args(node)
+    return unless args.length >= 2
+
+    args.each_index { |i| emit_remove_arg_at(node, args, i) }
+  end
+
+  # super(a, b) -> super()
+  #
+  # The argument list's byte range covers only the args themselves; the
+  # separator (`,` + whitespace) between the last arg and a following
+  # `&block` (or the closing `)` after a trailing comma) is owned by the
+  # SuperNode itself. Replacing only `arguments.location` with `""` leaves
+  # `super(, &block)` or `super(,)`. Extend the removal range to the start
+  # of the block argument when present, otherwise to the closing paren — so
+  # the separator goes along with the args.
+  def emit_remove_all_args(node)
+    start_offset = node.arguments.location.start_offset
+    end_offset = trailing_args_boundary(node)
+
     add_mutation(
-      offset: node.arguments.location.start_offset,
-      length: node.arguments.location.length,
+      offset: start_offset,
+      length: end_offset - start_offset,
       replacement: "",
       node: node
     )
+  end
 
-    return unless args.length >= 2
+  def trailing_args_boundary(node)
+    return node.block.location.start_offset if node.block
+    return node.rparen_loc.start_offset if node.rparen_loc
+
+    node.arguments.location.end_offset
+  end
 
-    # 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
+  def emit_remove_arg_at(node, args, 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

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

@@ -5,13 +5,10 @@ require_relative "../operator"
 class Evilution::Mutator::Operator::IndexToAt < Evilution::Mutator::Base
   def visit_call_node(node)
     if indexable?(node)
-      receiver_source = @file_source.byteslice(node.receiver.location.start_offset, node.receiver.location.length)
-      arg_source = @file_source.byteslice(node.arguments.location.start_offset, node.arguments.location.length)
-
       add_mutation(
         offset: node.location.start_offset,
         length: node.location.length,
-        replacement: "#{receiver_source}.at(#{arg_source})",
+        replacement: "#{loc_text(node.receiver.location)}.at(#{loc_text(node.arguments.location)})",
         node: node
       )
     end
@@ -21,10 +18,26 @@ class Evilution::Mutator::Operator::IndexToAt < Evilution::Mutator::Base
 
   private
 
+  def loc_text(loc)
+    @file_source.byteslice(loc.start_offset, loc.length)
+  end
+
+  # EV-pn5y / GH #1173: Hash has no #at method, so the symbol/string keys that
+  # almost always indicate a Hash receiver are skipped here — otherwise the
+  # mutated source crashes with NoMethodError instead of yielding a measurable
+  # mutation. Integer literals and variable/expression keys are still mutated;
+  # if the receiver in those cases turns out to be a Hash the mutation will
+  # still raise NoMethodError at runtime, but those shapes are far rarer in
+  # practice and the AST gives no reliable receiver-type signal to filter on.
   def indexable?(node)
     node.name == :[] &&
       node.receiver &&
       node.arguments &&
-      node.arguments.arguments.length == 1
+      node.arguments.arguments.length == 1 &&
+      !hash_key_shape?(node.arguments.arguments.first)
+  end
+
+  def hash_key_shape?(arg)
+    arg.is_a?(Prism::SymbolNode) || arg.is_a?(Prism::StringNode)
   end
 end

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

@@ -3,6 +3,9 @@
 require_relative "../operator"
 
 class Evilution::Mutator::Operator::IndexToDig < Evilution::Mutator::Base
+  Chain = Data.define(:root, :args)
+  private_constant :Chain
+
   def initialize(**options)
     super
     @consumed = Set.new
@@ -10,14 +13,11 @@ class Evilution::Mutator::Operator::IndexToDig < Evilution::Mutator::Base
 
   def visit_call_node(node)
     if chain_head?(node)
-      root, args = collect_chain(node)
-      root_source = byteslice_source(root.location.start_offset, root.location.length)
-      arg_sources = args.map { |a| byteslice_source(a.location.start_offset, a.location.length) }
-
+      chain = collect_chain(node)
       add_mutation(
         offset: node.location.start_offset,
         length: node.location.length,
-        replacement: "#{root_source}.dig(#{arg_sources.join(", ")})",
+        replacement: dig_replacement(chain),
         node: node
       )
     end
@@ -27,6 +27,12 @@ class Evilution::Mutator::Operator::IndexToDig < Evilution::Mutator::Base
 
   private
 
+  def dig_replacement(chain)
+    root_source = byteslice_source(chain.root.location.start_offset, chain.root.location.length)
+    arg_sources = chain.args.map { |a| byteslice_source(a.location.start_offset, a.location.length) }
+    "#{root_source}.dig(#{arg_sources.join(", ")})"
+  end
+
   def chain_head?(node)
     return false if @consumed.include?(node.object_id)
     return false unless single_arg_index?(node)
@@ -53,6 +59,6 @@ class Evilution::Mutator::Operator::IndexToDig < Evilution::Mutator::Base
       current = current.receiver
     end
 
-    [current, args]
+    Chain.new(root: current, args: args)
   end
 end

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

@@ -5,13 +5,10 @@ require_relative "../operator"
 class Evilution::Mutator::Operator::IndexToFetch < Evilution::Mutator::Base
   def visit_call_node(node)
     if indexable?(node)
-      receiver_source = byteslice_source(node.receiver.location.start_offset, node.receiver.location.length)
-      arg_source = byteslice_source(node.arguments.location.start_offset, node.arguments.location.length)
-
       add_mutation(
         offset: node.location.start_offset,
         length: node.location.length,
-        replacement: "#{receiver_source}.fetch(#{arg_source})",
+        replacement: "#{loc_text(node.receiver.location)}.fetch(#{loc_text(node.arguments.location)})",
         node: node
       )
     end
@@ -21,6 +18,10 @@ class Evilution::Mutator::Operator::IndexToFetch < Evilution::Mutator::Base
 
   private
 
+  def loc_text(loc)
+    byteslice_source(loc.start_offset, loc.length)
+  end
+
   def indexable?(node)
     node.name == :[] &&
       node.receiver &&

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

@@ -56,36 +56,41 @@ class Evilution::Mutator::Operator::KeywordArgument < Evilution::Mutator::Base
     return unless kr.is_a?(Prism::KeywordRestParameterNode)
 
     all_params = collect_all_params(params)
-
     if all_params.length < 2
-      add_mutation(
-        offset: kr.location.start_offset,
-        length: kr.location.length,
-        replacement: "",
-        node: kr
-      )
+      emit_remove_only_kr(kr)
     else
-      remaining = all_params.reject { |p| p.equal?(kr) }
-      replacement = remaining.map(&:slice).join(", ")
-
-      add_mutation(
-        offset: params.location.start_offset,
-        length: params.location.length,
-        replacement: replacement,
-        node: kr
-      )
+      emit_remove_kr_with_remaining(params, all_params, kr)
     end
   end
 
+  def emit_remove_only_kr(kr)
+    add_mutation(
+      offset: kr.location.start_offset,
+      length: kr.location.length,
+      replacement: "",
+      node: kr
+    )
+  end
+
+  def emit_remove_kr_with_remaining(params, all_params, kr)
+    remaining = all_params.reject { |p| p.equal?(kr) }
+    add_mutation(
+      offset: params.location.start_offset,
+      length: params.location.length,
+      replacement: remaining.map(&:slice).join(", "),
+      node: kr
+    )
+  end
+
   def collect_all_params(params)
-    result = []
-    result.concat(params.requireds)
-    result.concat(params.optionals)
-    result << params.rest if params.rest
-    result.concat(params.posts)
-    result.concat(params.keywords)
-    result << params.keyword_rest if params.keyword_rest
-    result << params.block if params.block
-    result
+    [
+      *params.requireds,
+      *params.optionals,
+      params.rest,
+      *params.posts,
+      *params.keywords,
+      params.keyword_rest,
+      params.block
+    ].compact
   end
 end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Removes a trailing literal expression (true/false/nil/integer/symbol) from
+# a method body. Targets the idiomatic Ruby pattern `def foo?; side_effect;
+# true; end` where the explicit literal return value is the high-signal
+# behavior under test — dropping it makes the method return whatever the
+# preceding statement evaluates to. Strong against predicates and
+# command-query split methods.
+class Evilution::Mutator::Operator::LastExpressionRemoval < Evilution::Mutator::Base
+  LITERAL_NODE_TYPES = [
+    Prism::TrueNode,
+    Prism::FalseNode,
+    Prism::NilNode,
+    Prism::IntegerNode,
+    Prism::SymbolNode
+  ].freeze
+
+  def visit_def_node(node)
+    last_literal = trailing_literal(node)
+    if last_literal
+      add_mutation(
+        offset: last_literal.location.start_offset,
+        length: last_literal.location.length,
+        replacement: "",
+        node: last_literal
+      )
+    end
+
+    super
+  end
+
+  private
+
+  def trailing_literal(node)
+    body = node.body
+    return nil unless body.is_a?(Prism::StatementsNode)
+    return nil if body.body.empty?
+
+    last = body.body.last
+    return nil unless LITERAL_NODE_TYPES.any? { |t| last.is_a?(t) }
+
+    last
+  end
+end

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

@@ -13,27 +13,33 @@ class Evilution::Mutator::Operator::MixinRemoval < Evilution::Mutator::Base
     @mutations = []
     @filter = filter
 
-    tree = self.class.parsed_tree_for(subject.file_path, @file_source)
-    enclosing = find_enclosing_scope(tree, subject.line_number)
+    enclosing = find_target_scope(subject)
     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
-
+    find_mixin_calls(enclosing).each { |call_node| emit_mixin_removal(call_node) }
     @mutations
   end
 
   private
 
+  def find_target_scope(subject)
+    tree = self.class.parsed_tree_for(subject.file_path, @file_source)
+    enclosing = find_enclosing_scope(tree, subject.line_number)
+    return nil unless enclosing
+    return nil unless find_first_method_line(enclosing) == subject.line_number
+
+    enclosing
+  end
+
+  def emit_mixin_removal(call_node)
+    add_mutation(
+      offset: call_node.location.start_offset,
+      length: call_node.location.length,
+      replacement: "",
+      node: call_node
+    )
+  end
+
   def find_enclosing_scope(tree, target_line)
     finder = ScopeFinder.new(target_line)
     finder.visit(tree)

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

@@ -18,19 +18,18 @@ class Evilution::Mutator::Operator::MultipleAssignment < Evilution::Mutator::Bas
   private
 
   def mutate_target_removal(node, lefts, values)
-    lefts.each_index do |i|
-      remaining_lefts = lefts.each_with_index.filter_map { |l, j| l.slice if j != i }
-      remaining_values = values.each_with_index.filter_map { |v, j| v.slice if j != i }
-
-      replacement = "#{remaining_lefts.join(", ")} = #{remaining_values.join(", ")}"
-
-      add_mutation(
-        offset: node.location.start_offset,
-        length: node.location.length,
-        replacement: replacement,
-        node: node
-      )
-    end
+    lefts.each_index { |i| emit_target_removal_at(node, lefts, values, i) }
+  end
+
+  def emit_target_removal_at(node, lefts, values, i)
+    remaining_lefts = lefts.each_with_index.filter_map { |l, j| l.slice if j != i }
+    remaining_values = values.each_with_index.filter_map { |v, j| v.slice if j != i }
+    add_mutation(
+      offset: node.location.start_offset,
+      length: node.location.length,
+      replacement: "#{remaining_lefts.join(", ")} = #{remaining_values.join(", ")}",
+      node: node
+    )
   end
 
   def mutate_swap(node, lefts, values)

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

@@ -3,21 +3,52 @@
 require_relative "../operator"
 
 class Evilution::Mutator::Operator::ReceiverReplacement < Evilution::Mutator::Base
-  def visit_call_node(node)
-    if node.receiver.is_a?(Prism::SelfNode)
-      call_without_self = @file_source.byteslice(
-        node.message_loc.start_offset,
-        node.location.start_offset + node.location.length - node.message_loc.start_offset
-      )
+  # Ruby reserved words. A call like `self.class` — when stripped of its
+  # `self.` receiver — becomes the bare token `class`, which the parser reads
+  # as the class-definition keyword rather than a method call. Producing this
+  # mutation guarantees an unparseable result. Skip when the call's method
+  # name collides with any reserved keyword.
+  RUBY_RESERVED_KEYWORDS = %i[
+    BEGIN END __ENCODING__ __FILE__ __LINE__
+    alias and begin break case class def defined? do else elsif end
+    ensure false for if in module next nil not or redo rescue retry
+    return self super then true undef unless until when while yield
+  ].to_set.freeze
 
+  def visit_call_node(node)
+    if eligible_self_call?(node)
       add_mutation(
         offset: node.location.start_offset,
         length: node.location.length,
-        replacement: call_without_self,
+        replacement: call_without_self_text(node),
         node: node
       )
     end
 
     super
   end
+
+  private
+
+  def eligible_self_call?(node)
+    return false unless node.receiver.is_a?(Prism::SelfNode)
+    return false if reserved_keyword_method?(node.name)
+
+    true
+  end
+
+  # `self.class = value` is a writer call whose Prism `name` is `:class=` —
+  # not `:class` — so a literal lookup in RUBY_RESERVED_KEYWORDS misses it,
+  # and stripping the receiver leaves `class = value` (parse error). Normalize
+  # the trailing `=` from writer forms before comparing.
+  def reserved_keyword_method?(name)
+    base = name.to_s.chomp("=").to_sym
+    RUBY_RESERVED_KEYWORDS.include?(base)
+  end
+
+  def call_without_self_text(node)
+    message_start = node.message_loc.start_offset
+    call_end = node.location.start_offset + node.location.length
+    @file_source.byteslice(message_start, call_end - message_start)
+  end
 end