evilution 1.1.0 → 1.3.0

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

@@ -12,22 +12,47 @@ class Evilution::Mutator::Operator::ComparisonReplacement < Evilution::Mutator::
     :!= => [:==]
   }.freeze
 
+  # Operators rewritten into a method call, since the method cannot be
+  # swapped in as an operator (`a eql? b` does not parse). Ordering
+  # comparisons collapse to the stricter equalities — `a < b` becomes
+  # `a.eql?(b)` and `a.equal?(b)` — and `a =~ b` becomes `a.match?(b)`,
+  # which returns a boolean and leaves `$~` / `$1` unset.
+  EQUALITY_METHODS = %i[eql? equal?].freeze
+  private_constant :EQUALITY_METHODS
+
+  METHOD_REPLACEMENTS = {
+    :< => EQUALITY_METHODS,
+    :<= => EQUALITY_METHODS,
+    :> => EQUALITY_METHODS,
+    :>= => EQUALITY_METHODS,
+    :=~ => [:match?]
+  }.freeze
+  private_constant :METHOD_REPLACEMENTS
+
   def visit_call_node(node)
-    replacements = REPLACEMENTS[node.name]
-    return super unless replacements
+    replace_operator(node)
+    replace_with_methods(node)
+    super
+  end
+
+  private
 
+  def replace_operator(node)
     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
-      )
+
+    REPLACEMENTS.fetch(node.name, []).each do |replacement|
+      add_mutation(offset: loc.start_offset, length: loc.length, replacement: replacement.to_s, node: node)
     end
+  end
 
-    super
+  def replace_with_methods(node)
+    methods = METHOD_REPLACEMENTS[node.name]
+    return unless methods && (node.arguments in Prism::ArgumentsNode[arguments: [argument]])
+
+    left = receiver_source(node.receiver)
+    methods.each do |method|
+      add_mutation(offset: node.start_offset, length: node.location.length,
+                   replacement: "#{left}.#{method}(#{source_of(argument)})", node: node)
+    end
   end
 end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Resolve a dynamic constant lookup with a literal name into a constant path:
+# `Registry.const_get(:Handler)` becomes `Registry::Handler`. A literal
+# inherit flag is dropped; a receiverless call resolves against `self`.
+#
+# Both forms find the same own, inherited and mixed-in constants and raise the
+# same NameError for a missing one. They differ on top-level constants (found
+# by `const_get` through Object, rejected by `::`), on private constants
+# (returned by `const_get` only) and with `inherit = false` (ancestors skipped
+# by `const_get`, searched by `::`). A survivor means none of those paths is
+# exercised, so the dynamic lookup may not be needed.
+#
+# Safe navigation is skipped: a constant path has no nil-safe form.
+class Evilution::Mutator::Operator::ConstGetToConstantPath < Evilution::Mutator::Base
+  CONSTANT_NAME = /\A[A-Z]\w*\z/
+  private_constant :CONSTANT_NAME
+
+  # `nil` behaves like `false`.
+  INHERIT_FLAGS = [Prism::TrueNode, Prism::FalseNode, Prism::NilNode].freeze
+  private_constant :INHERIT_FLAGS
+
+  def visit_call_node(node)
+    rewrite(node) if node.name == :const_get && node.block.nil? && !node.safe_navigation?
+    super
+  end
+
+  private
+
+  def rewrite(node)
+    name = constant_name(node)
+    return if name.nil?
+
+    receiver = node.receiver ? source_of(node.receiver) : "self"
+    add_mutation(offset: node.start_offset, length: node.location.length, replacement: "#{receiver}::#{name}", node: node)
+  end
+
+  def constant_name(node)
+    return unless node.arguments in Prism::ArgumentsNode[arguments: [Prism::SymbolNode => symbol, *flags]]
+    return unless flags.empty? || literal_inherit_flag?(flags)
+
+    symbol.unescaped if symbol.unescaped.match?(CONSTANT_NAME)
+  end
+
+  def literal_inherit_flag?(flags)
+    flags.length == 1 && INHERIT_FLAGS.any? { |type| flags.first.is_a?(type) }
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Make the first step of a `dig` strict: `config.dig(:db, :host)` becomes
+# `config.fetch(:db).dig(:host)`. The reverse of index_to_dig.
+#
+# `dig` returns nil when the first key is missing or holds nil; the fetch
+# chain raises there instead (KeyError / IndexError, or NoMethodError on
+# `nil.dig`). A survivor means no test reaches the lookup with that key
+# absent.
+#
+# Only calls with two or more positional keys qualify; the remaining keys
+# keep their original formatting.
+class Evilution::Mutator::Operator::DigToFetchChain < Evilution::Mutator::Base
+  NON_POSITIONAL = [Prism::SplatNode, Prism::KeywordHashNode, Prism::ForwardingArgumentsNode].freeze
+  private_constant :NON_POSITIONAL
+
+  def visit_call_node(node)
+    rewrite(node) if node.name == :dig && node.receiver && node.block.nil?
+    super
+  end
+
+  private
+
+  # Replace `dig(first, ` with `fetch(first).dig(` — up to the second key —
+  # keeping whatever opened the argument list (`(`, a newline, a space).
+  def rewrite(node)
+    return unless node.arguments in Prism::ArgumentsNode[arguments: [first, second, *]]
+    return unless positional_keys?(node.arguments.arguments)
+
+    start = node.message_loc.start_offset
+    add_mutation(offset: start, length: second.start_offset - start, replacement: fetch_prefix(node, first), node: node)
+  end
+
+  def positional_keys?(keys)
+    keys.none? { |key| NON_POSITIONAL.any? { |type| key.is_a?(type) } }
+  end
+
+  def fetch_prefix(node, first)
+    message_end = node.message_loc.end_offset
+    opener = byteslice_source(message_end, first.start_offset - message_end)
+    "fetch(#{source_of(first)}).dig#{opener}"
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Replace a double negation with its operand: `!!value` becomes `value`, and
+# the same for the `not not value` keyword form.
+#
+# A survivor means no test distinguishes a truthy object from `true` (or nil
+# from `false`) — the boolean coercion is never observed.
+class Evilution::Mutator::Operator::DoubleNegationRemoval < Evilution::Mutator::Base
+  def visit_call_node(node)
+    inner = node.receiver
+    promote_child(node, inner.receiver) if negation?(node) && negation?(inner)
+    super
+  end
+
+  private
+
+  def negation?(node)
+    node.is_a?(Prism::CallNode) && node.name == :!
+  end
+end

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Resolve a dynamic dispatch with a literal symbol into a direct call:
+# `target.send(:reset)` becomes `target.reset`, and the same for `__send__`
+# and `public_send`. Remaining arguments, a block-pass and a literal block
+# stay attached.
+#
+# The two forms differ only in visibility checks, so the mutant is emitted
+# only where those checks can disagree:
+#
+# - send / __send__ on an explicit receiver other than self: the direct call
+#   raises NoMethodError for a private method. With an implicit or self
+#   receiver a private method resolves either way (Ruby 2.7+).
+# - public_send with an implicit or self receiver: the direct call reaches a
+#   private method that public_send refuses. On any other receiver both
+#   refuse it, and only a protected method called from inside its class
+#   would differ.
+#
+# method_missing is reached the same way by both forms.
+class Evilution::Mutator::Operator::DynamicDispatchResolution < Evilution::Mutator::Base
+  SEND_SELECTORS = %i[send __send__].freeze
+  private_constant :SEND_SELECTORS
+
+  OPERATOR_NAMES = %w[
+    + - * / % ** == != < > <= >= <=> === =~ !~ ! [] []= << >> & | ^ ~ +@ -@
+  ].to_set.freeze
+  private_constant :OPERATOR_NAMES
+
+  METHOD_NAME = /\A[[:alpha:]_][[:alnum:]_]*[?!=]?\z/
+  private_constant :METHOD_NAME
+
+  def visit_call_node(node)
+    selector = literal_selector(node)
+    resolve(node, selector) if selector && visibility_can_differ?(node)
+    super
+  end
+
+  private
+
+  def literal_selector(node)
+    return unless node.arguments in Prism::ArgumentsNode[arguments: [Prism::SymbolNode => symbol, *]]
+
+    name = symbol.unescaped
+    name if name.match?(METHOD_NAME) || OPERATOR_NAMES.include?(name)
+  end
+
+  def visibility_can_differ?(node)
+    self_receiver = node.receiver.nil? || node.receiver.is_a?(Prism::SelfNode)
+
+    if SEND_SELECTORS.include?(node.name)
+      !self_receiver
+    else
+      node.name == :public_send && self_receiver
+    end
+  end
+
+  def resolve(node, selector)
+    start = node.message_loc.start_offset
+    following = following_item(node)
+
+    if following
+      replacement = "#{selector}#{node.opening_loc ? "(" : " "}"
+      finish = following.start_offset
+    else
+      replacement = selector
+      finish = node.closing_loc ? node.closing_loc.end_offset : node.arguments.end_offset
+    end
+
+    add_mutation(offset: start, length: finish - start, replacement: replacement, node: node)
+  end
+
+  # The argument after the selector, or the block-pass when the selector is
+  # the only argument.
+  def following_item(node)
+    node.arguments.arguments[1] || (node.block if node.block.is_a?(Prism::BlockArgumentNode))
+  end
+end

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "../operator"
+
+# Give a forwarding `super` an empty argument list: `def f(a); super; end`
+# becomes `def f(a); super(); end`.
+#
+# Bare `super` hands the parent whatever the method was called with; `super()`
+# hands it nothing. A survivor means the forwarded arguments never reach an
+# assertion — the parent ignores them, or nothing exercises what it does with
+# them. ZsuperRemoval only turns the same node into `nil`, which asks whether
+# the call happens rather than what it carries, and ExplicitSuperMutation works
+# the other direction, on a super that already lists its arguments.
+#
+# The enclosing method must declare something to forward. With no parameters
+# the two forms are identical, and so they are with only a block parameter:
+# `super()` still passes the block along, so nothing would change.
+class Evilution::Mutator::Operator::ForwardingSuperToExplicit < Evilution::Mutator::Base
+  KEYWORD_LENGTH = "super".length
+  private_constant :KEYWORD_LENGTH
+
+  def visit_def_node(node)
+    enclosing_methods.push(node)
+    super
+  ensure
+    enclosing_methods.pop
+  end
+
+  def visit_forwarding_super_node(node)
+    add_parentheses(node) if forwards_arguments?
+    super
+  end
+
+  private
+
+  # A stack, so a def nested in another method's body is answered with its own
+  # parameters rather than the outer method's.
+  def enclosing_methods
+    @enclosing_methods ||= []
+  end
+
+  # Traversal always starts at the subject's own def, so a forwarding super is
+  # never reached without one on the stack.
+  def forwards_arguments?
+    parameters = enclosing_methods.last.parameters
+    return false if parameters.nil?
+
+    !only_block_parameter?(parameters)
+  end
+
+  # `&blk` is forwarded either way, so it is not something `super()` drops.
+  # Post-required parameters are not checked: a signature only has them after a
+  # rest parameter, which the rest check already rejects.
+  def only_block_parameter?(parameters)
+    parameters.requireds.empty? && parameters.optionals.empty? && parameters.keywords.empty? &&
+      parameters.rest.nil? && parameters.keyword_rest.nil?
+  end
+
+  # The parentheses are inserted right after the keyword rather than replacing
+  # the node, whose span also covers a block written on the super.
+  def add_parentheses(node)
+    add_mutation(
+      offset: node.location.start_offset + KEYWORD_LENGTH,
+      length: 0,
+      replacement: "()",
+      node: node
+    )
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Rewrite an inequality with stricter comparisons: `a != b` becomes
+# `!a.eql?(b)` and `!a.equal?(b)`.
+#
+# `eql?` adds a type check (`1 != 1.0` is false, `!1.eql?(1.0)` is true) and
+# `equal?` compares identity (two equal strings or arrays are still
+# different objects). A survivor means no test separates value equality from
+# the stricter forms, so the comparison in use is never pinned down.
+#
+# Comparisons against nil, true, false or a symbol literal are skipped: those
+# are singletons, so all three forms always agree.
+class Evilution::Mutator::Operator::InequalityToNegatedIdentity < Evilution::Mutator::Base
+  SELECTORS = %i[eql? equal?].freeze
+  private_constant :SELECTORS
+
+  SINGLETON_LITERALS = [Prism::NilNode, Prism::TrueNode, Prism::FalseNode, Prism::SymbolNode].freeze
+  private_constant :SINGLETON_LITERALS
+
+  def visit_call_node(node)
+    rewrite(node) if node.name == :!=
+    super
+  end
+
+  private
+
+  def rewrite(node)
+    return unless node.arguments in Prism::ArgumentsNode[arguments: [argument]]
+    return if [node.receiver, argument].any? { |operand| singleton_literal?(operand) }
+
+    left = receiver_source(node.receiver)
+    SELECTORS.each do |selector|
+      add_mutation(offset: node.start_offset, length: node.location.length,
+                   replacement: "!#{left}.#{selector}(#{source_of(argument)})", node: node)
+    end
+  end
+
+  def singleton_literal?(operand)
+    SINGLETON_LITERALS.any? { |type| operand.is_a?(type) }
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Drop one keyword argument at a call site: `build(name: "x", size: 2)`
+# becomes `build(size: 2)` and `build(name: "x")`. Applies to any argument
+# list — calls, `super` and `yield`.
+#
+# A survivor means the callee never consumes that keyword, or its default
+# happens to match. argument_removal and argument_nil_substitution skip
+# keyword arguments entirely.
+#
+# Only `key: value` pairs are dropped; a `**opts` double splat stays, though
+# it still counts as a neighbour when removing the separator. A lone keyword
+# that is the whole argument list is left to argument_list_removal.
+class Evilution::Mutator::Operator::KeywordArgumentRemoval < Evilution::Mutator::Base
+  def visit_arguments_node(node)
+    node.arguments.each_with_index do |argument, index|
+      next unless argument.is_a?(Prism::KeywordHashNode)
+
+      drop_keywords(argument, index.zero? ? nil : node.arguments[index - 1])
+    end
+
+    super
+  end
+
+  private
+
+  def drop_keywords(hash, previous_argument)
+    elements = hash.elements
+    return if elements.length == 1 && previous_argument.nil?
+
+    elements.each_with_index do |element, index|
+      next unless element.is_a?(Prism::AssocNode)
+
+      drop_element(element, elements[index + 1], index.zero? ? previous_argument : elements[index - 1])
+    end
+  end
+
+  # Cut from the element to the next one, or — for the last element — from
+  # the end of whatever precedes it, so the separating comma goes too.
+  def drop_element(element, following, preceding)
+    start, finish = following ? [element.start_offset, following.start_offset] : [preceding.end_offset, element.end_offset]
+
+    add_mutation(offset: start, length: finish - start, replacement: "", node: element, skip_unparseable: true)
+  end
+end

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

@@ -46,9 +46,18 @@ class Evilution::Mutator::Operator::MethodBodyReplacement < Evilution::Mutator::
   # class has no parent implementation of the method. We emit it only when the
   # original body already calls super, using that as a heuristic that a super
   # target is intended in this context.
+  #
+  # The search stops at a nested def, whose super belongs to that method rather
+  # than to this one. Counting it would emit a super replacement for a method
+  # that may have no parent to call, and the mutant would raise NoMethodError on
+  # contact — a kill that proves nothing (EV-vk1f / GH #1625). A block is not a
+  # boundary: `values.each { super }` does call this method's parent.
+  # MethodBodyToSuper#calls_super? draws the same line.
   def body_calls_super?(node)
     return true if node.is_a?(Prism::SuperNode) || node.is_a?(Prism::ForwardingSuperNode)
 
-    node.child_nodes.any? { |child| child && body_calls_super?(child) }
+    node.child_nodes.any? do |child|
+      child && !child.is_a?(Prism::DefNode) && body_calls_super?(child)
+    end
   end
 end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Replace a whole method body with a bare `raise`: `def foo; body; end` becomes
+# `def foo; raise; end`.
+#
+# A survivor means no example ever calls the method on a path it asserts, so
+# the method is either dead or reached only where the suite looks away. Where
+# body-to-nil (MethodBodyReplacement) asks whether the return value matters,
+# this asks the prior question of whether the call happens at all — a method
+# whose result is discarded survives the nil mutation but not this one.
+class Evilution::Mutator::Operator::MethodBodyToRaise < Evilution::Mutator::Base
+  def visit_def_node(node)
+    replace_body_with_raise(node)
+    super
+  end
+
+  private
+
+  def replace_body_with_raise(node)
+    statements = body_statements(node.body)
+    return if statements.nil?
+    return if single_raise?(statements)
+
+    location = statements.location
+
+    add_mutation(
+      offset: location.start_offset,
+      length: location.length,
+      replacement: "raise",
+      node: node
+    )
+  end
+
+  # A method-level rescue/ensure (`def foo; stmts; rescue; ...; end`) makes the
+  # body a BeginNode whose location spans the entire `def...end`, keyword and
+  # matching `end` included. Replacing that range would delete the method
+  # framing and leave a bare `raise` at the enclosing scope, so only the leading
+  # statements are replaceable. Returns nil for a rescue/ensure-only body, where
+  # there are none, and for an empty method, whose body is nil outright.
+  def body_statements(body)
+    return body unless body.is_a?(Prism::BeginNode)
+
+    body.statements
+  end
+
+  # A body that already consists of one unconditional raise would mutate to a
+  # near-equivalent: `raise NotImplementedError` -> `raise` only changes the
+  # error class, which is what RaiseArgumentStrip (#1537) probes. Arguments are
+  # not inspected, so a bare raise is skipped on the same rule.
+  def single_raise?(statements)
+    body = statements.body
+    return false unless body.length == 1
+
+    only = body.first
+    only.is_a?(Prism::CallNode) && only.name == :raise && only.receiver.nil?
+  end
+end

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

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "../operator"
+
+# Replace a whole method body with a bare `super`: `def foo; body; end` becomes
+# `def foo; super; end`.
+#
+# A survivor means the body adds nothing the suite asserts over whatever
+# ancestor implementation it might be overriding. MethodBodyReplacement emits
+# the same replacement, but only for a body that already calls super, so a plain
+# override — the case worth probing — is never reached by it.
+#
+# `super` needs somewhere to go: without one the mutant raises NoMethodError and
+# dies on contact, which scores a kill that proves nothing. Emission is
+# therefore limited to methods whose enclosing scope has a plausible super
+# chain: an explicit superclass, or a mixin in the right position for that kind
+# of method (include/prepend for instance methods, extend for singleton ones).
+# Whether an ancestor actually defines this method name cannot be known from the
+# source, so a class that inherits or mixes in anything qualifies.
+class Evilution::Mutator::Operator::MethodBodyToSuper < Evilution::Mutator::Base
+  INSTANCE_MIXINS = %i[include prepend].freeze
+  SINGLETON_MIXINS = %i[extend].freeze
+
+  def visit_def_node(node)
+    replace_body_with_super(node)
+    super
+  end
+
+  private
+
+  def replace_body_with_super(node)
+    statements = body_statements(node.body)
+    return if statements.nil?
+    return if calls_super?(statements)
+    return unless super_target?(node)
+
+    location = statements.location
+
+    add_mutation(
+      offset: location.start_offset,
+      length: location.length,
+      replacement: "super",
+      node: node
+    )
+  end
+
+  # A method-level rescue/ensure (`def foo; stmts; rescue; ...; end`) makes the
+  # body a BeginNode whose location spans the entire `def...end`, keyword and
+  # matching `end` included. Replacing that range would delete the method
+  # framing, so only the leading statements are replaceable. Returns nil for a
+  # rescue/ensure-only body and for an empty method, whose body is nil.
+  def body_statements(body)
+    return body unless body.is_a?(Prism::BeginNode)
+
+    body.statements
+  end
+
+  # MethodBodyReplacement owns bodies that already reach for the parent
+  # implementation; emitting here would attribute one mutation to two operators.
+  #
+  # The search stops at a nested def, whose `super` belongs to that method
+  # rather than to the body being mutated. A nested class or module would be a
+  # boundary too, but Ruby rejects both inside a method body, so a def is the
+  # only one reachable here. A block is not a boundary: `values.map { super }`
+  # still calls the enclosing method's parent.
+  def calls_super?(node)
+    return true if node.is_a?(Prism::SuperNode) || node.is_a?(Prism::ForwardingSuperNode)
+
+    node.child_nodes.any? do |child|
+      child && !child.is_a?(Prism::DefNode) && calls_super?(child)
+    end
+  end
+
+  # `def self.foo` and a def inside `class << self` both define singleton
+  # methods, which inherit through the singleton class: an explicit superclass
+  # carries them, `extend` mixes into them, `include`/`prepend` do not.
+  def super_target?(def_node)
+    scope = enclosing_scope(def_node)
+    return false unless scope
+
+    singleton = def_node.receiver || scope[:singleton]
+    return true if scope[:node].is_a?(Prism::ClassNode) && scope[:node].superclass
+
+    mixins = singleton ? SINGLETON_MIXINS : INSTANCE_MIXINS
+    mixin?(scope[:node], mixins)
+  end
+
+  # The innermost class or module containing the def. A `class << self` body is
+  # transparent to the search — the mixins that matter live in the class around
+  # it — but it marks everything inside as a singleton method.
+  def enclosing_scope(def_node)
+    tree = self.class.parsed_tree_for(@subject.file_path, @file_source)
+    finder = ScopeFinder.new(def_node.location.start_line)
+    finder.visit(tree)
+    finder.result
+  end
+
+  # A scope is only consulted once a def was found inside it, so its body is
+  # never nil here. A bare `include` with nothing to mix in parses with a nil
+  # arguments node, which is what separates it from a real mixin call.
+  def mixin?(scope_node, names)
+    scope_node.body.body.any? do |child|
+      child.is_a?(Prism::CallNode) && child.receiver.nil? &&
+        names.include?(child.name) && child.arguments
+    end
+  end
+
+  # Visitor that reports the innermost class/module enclosing a line, and
+  # whether that line sits inside a `class << self` body.
+  class ScopeFinder < Prism::Visitor
+    def initialize(target_line)
+      @target_line = target_line
+      @scope = nil
+      @singleton = false
+      super()
+    end
+
+    # The enclosing scope and the `class << self` flag are collected
+    # independently: the class node is visited before the singleton-class body
+    # inside it, so a flag read at that point would always be false.
+    def result
+      return nil unless @scope
+
+      { node: @scope, singleton: @singleton }
+    end
+
+    def visit_class_node(node)
+      @scope = node if covers?(node)
+      super
+    end
+
+    def visit_module_node(node)
+      @scope = node if covers?(node)
+      super
+    end
+
+    def visit_singleton_class_node(node)
+      @singleton = true if covers?(node)
+      super
+    end
+
+    private
+
+    def covers?(node)
+      @target_line.between?(node.location.start_line, node.location.end_line)
+    end
+  end
+end