evilution 1.4.0 → 1.5.0

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+require_relative "../../ast/round_half_mode"
+
+# Swap the tie-breaking mode of `round`: `amount.round(2, half: :even)`
+# becomes `half: :up` and `half: :down`.
+#
+# The modes differ only for a value sitting exactly on a tie (`2.5`), so a
+# survivor means no example rounds one — the case banker's rounding in money
+# code exists for.
+#
+# Only a literal mode is swapped; one held in a variable is left alone.
+# Integer, Float, Rational and BigDecimal all read `half:` the same way.
+class Evilution::Mutator::Operator::RoundHalfModeSwap < Evilution::Mutator::Base
+  def visit_call_node(node)
+    mode = Evilution::AST::RoundHalfMode.of(node)
+    swap(node, mode) if mode
+    super
+  end
+
+  private
+
+  def swap(node, mode)
+    others = Evilution::AST::RoundHalfMode::MODES - [mode.unescaped.to_sym]
+
+    others.each do |other|
+      add_mutation(
+        offset: mode.location.start_offset,
+        length: mode.location.length,
+        replacement: other.inspect,
+        node: node
+      )
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+require_relative "../../ast/never_nil"
+
+# Replace a plain call with safe navigation: `user.name` becomes
+# `user&.name`, and the same for the `||=`, `&&=` and operator-write forms.
+#
+# The mutant only differs when the receiver is nil: the call is then skipped
+# and the expression is nil, where the plain call raises NoMethodError or
+# runs a method nil has (`nil.to_a` is `[]`). A survivor means no test
+# reaches the call with a nil receiver and checks what comes of it.
+#
+# It touches nearly every call and survives wherever the receiver is never
+# nil, so it is registered for the strict profile only. Receivers that can
+# never be nil (`self`, literals other than `nil`, constants) are skipped,
+# since the mutant is equivalent there.
+class Evilution::Mutator::Operator::SafeNavigationInsertion < Evilution::Mutator::Base
+  # A constant could hold nil, but one that receives a call does not in
+  # practice.
+  CONSTANTS = [Prism::ConstantReadNode, Prism::ConstantPathNode].freeze
+  private_constant :CONSTANTS
+
+  def visit_call_node(node)
+    mutate_plain_call(node)
+    super
+  end
+
+  def visit_call_or_write_node(node)
+    mutate_plain_call(node)
+    super
+  end
+
+  def visit_call_and_write_node(node)
+    mutate_plain_call(node)
+    super
+  end
+
+  def visit_call_operator_write_node(node)
+    mutate_plain_call(node)
+    super
+  end
+
+  private
+
+  def mutate_plain_call(node)
+    operator = node.call_operator_loc
+    return unless operator && operator.slice == "."
+    return if never_nil?(node.receiver)
+
+    add_mutation(offset: operator.start_offset, length: operator.length, replacement: "&.", node: node)
+  end
+
+  def never_nil?(receiver)
+    Evilution::AST::NeverNil.node?(receiver) || CONSTANTS.include?(receiver.class)
+  end
+end

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../operator"
+require_relative "../../ast/never_nil"
 
 # Replace safe navigation with a plain call: `user&.name` becomes
 # `user.name`, and the same for the `||=`, `&&=` and operator-write forms.
@@ -12,29 +13,6 @@ require_relative "../operator"
 # Receivers that can never be nil — `self` and literals — are skipped, since
 # the mutant is equivalent there.
 class Evilution::Mutator::Operator::SafeNavigationRemoval < Evilution::Mutator::Base
-  NEVER_NIL_RECEIVERS = [
-    Prism::SelfNode,
-    Prism::StringNode,
-    Prism::InterpolatedStringNode,
-    Prism::XStringNode,
-    Prism::InterpolatedXStringNode,
-    Prism::SymbolNode,
-    Prism::InterpolatedSymbolNode,
-    Prism::IntegerNode,
-    Prism::FloatNode,
-    Prism::RationalNode,
-    Prism::ImaginaryNode,
-    Prism::ArrayNode,
-    Prism::HashNode,
-    Prism::RangeNode,
-    Prism::RegularExpressionNode,
-    Prism::InterpolatedRegularExpressionNode,
-    Prism::TrueNode,
-    Prism::FalseNode,
-    Prism::LambdaNode
-  ].freeze
-  private_constant :NEVER_NIL_RECEIVERS
-
   def visit_call_node(node)
     mutate_safe_navigation(node)
     super
@@ -59,7 +37,7 @@ class Evilution::Mutator::Operator::SafeNavigationRemoval < Evilution::Mutator::
 
   def mutate_safe_navigation(node)
     return unless node.safe_navigation?
-    return if NEVER_NIL_RECEIVERS.any? { |type| node.receiver.is_a?(type) }
+    return if Evilution::AST::NeverNil.node?(node.receiver)
 
     operator = node.call_operator_loc
     add_mutation(offset: operator.start_offset, length: operator.length, replacement: ".", node: node)

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Make a short-circuit operator evaluate both sides: `a && b` becomes
+# `a & b`, `a || b` becomes `a | b`.
+#
+# A survivor means no example depends on the right side being skipped: it
+# guards nothing (a nil receiver, a side effect), and both sides are plain
+# booleans, since `&` and `|` give another value for anything else.
+#
+# `&` and `|` bind tighter than `&&` and `||`, so an operand that would
+# regroup (`a == 1 && b` is not `a == 1 & b`) is parenthesized.
+class Evilution::Mutator::Operator::ShortCircuitToEager < Evilution::Mutator::Base
+  def visit_and_node(node)
+    mutate_to_eager(node, "&")
+    super
+  end
+
+  def visit_or_node(node)
+    mutate_to_eager(node, "|")
+    super
+  end
+
+  private
+
+  # An operand that only jumps (`a || return`) has no value to pass on; the
+  # result does not parse and is dropped.
+  def mutate_to_eager(node, operator)
+    replacement = "#{receiver_source(node.left)} #{operator} #{receiver_source(node.right)}"
+
+    replace_span(node:, target: node, replacement:)
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Take the wait out of a sleep whose duration is not a literal:
+# `sleep delay` becomes `sleep 0`.
+#
+# A survivor means the pause decides nothing an example observes. A killed
+# mutant means the suite depends on wall-clock time, which is worth knowing
+# too.
+#
+# A literal duration (`sleep 5`, `sleep 0.5`) is left to the literal
+# operators, which already take it to zero. Only `Kernel#sleep` is touched: a
+# `sleep` sent to another receiver may be something else.
+class Evilution::Mutator::Operator::SleepToZero < Evilution::Mutator::Base
+  LITERAL_DURATIONS = [Prism::IntegerNode, Prism::FloatNode, Prism::RationalNode].freeze
+  KERNEL = %w[Kernel ::Kernel].freeze
+
+  def visit_call_node(node)
+    duration = duration_of(node)
+    add_mutation(offset: duration.location.start_offset, length: duration.location.length, replacement: "0", node:) if duration
+
+    super
+  end
+
+  private
+
+  # The single argument of a `sleep` call, when it is one this operator
+  # replaces.
+  def duration_of(node)
+    return unless node.name == :sleep && kernel_call?(node) && node.arguments
+
+    arguments = node.arguments.arguments
+    return unless arguments.one?
+
+    duration = arguments.first
+    duration unless duration.is_a?(Prism::SplatNode) || LITERAL_DURATIONS.include?(duration.class)
+  end
+
+  def kernel_call?(node)
+    node.receiver.nil? || KERNEL.include?(node.receiver.slice)
+  end
+end

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

@@ -4,13 +4,15 @@ require_relative "../operator"
 
 class Evilution::Mutator::Operator::SplatOperator < Evilution::Mutator::Base
   def visit_splat_node(node)
-    mutate_remove_splat(node) if node.expression && !pattern_rests.include?(node)
+    mutate_remove_splat(node) if node.expression && !exempt_splats.include?(node)
 
     super
   end
 
+  # Inside a hash literal `**opts` merges a hash in; a bare `opts` is not an
+  # element (`{ opts }` is a syntax error), so these splats are skipped.
   def visit_hash_node(node)
-    node.elements.each { |el| hash_elements.add(el) }
+    exempt_splats.merge(node.elements.grep(Prism::AssocSplatNode))
     super
   end
 
@@ -23,18 +25,18 @@ class Evilution::Mutator::Operator::SplatOperator < Evilution::Mutator::Base
   # (`a, *b = x`) is still mutated: `a, b = x` parses and changes what `b`
   # binds.
   def visit_hash_pattern_node(node)
-    pattern_rests.add(node.rest) if node.rest
+    exempt_splats.add(node.rest) if node.rest
     super
   end
 
   def visit_array_pattern_node(node)
-    pattern_rests.add(node.rest) if node.rest
+    exempt_splats.add(node.rest) if node.rest
     super
   end
 
   def visit_find_pattern_node(node)
-    pattern_rests.add(node.left)
-    pattern_rests.add(node.right)
+    exempt_splats.add(node.left)
+    exempt_splats.add(node.right)
     super
   end
 
@@ -42,22 +44,17 @@ class Evilution::Mutator::Operator::SplatOperator < Evilution::Mutator::Base
   # `k: v` or another `**splat` precedes a `**opts` splat in the same call,
   # demoting `**opts` to bare `opts` puts a positional after a keyword
   # argument and Ruby rejects it (`bar(k: v, opts)` and `bar(**a, opts)` are
-  # syntax errors). Mark such splats so `visit_assoc_splat_node` skips them.
+  # syntax errors), so such splats are skipped.
   # A splat that comes first (`bar(**opts, k: v)`) is still safe —
   # positional-before-keyword is fine.
   def visit_keyword_hash_node(node)
-    node.elements.drop(1).each do |el|
-      kwarg_preceded_splats.add(el) if el.is_a?(Prism::AssocSplatNode)
-    end
-
+    exempt_splats.merge(node.elements.drop(1).grep(Prism::AssocSplatNode))
     super
   end
 
   def visit_assoc_splat_node(node)
     return super if node.value.nil?
-    return super if hash_elements.include?(node)
-    return super if kwarg_preceded_splats.include?(node)
-    return super if pattern_rests.include?(node)
+    return super if exempt_splats.include?(node)
 
     mutate_remove_double_splat(node)
 
@@ -66,16 +63,11 @@ class Evilution::Mutator::Operator::SplatOperator < Evilution::Mutator::Base
 
   private
 
-  def hash_elements
-    @hash_elements ||= Set.new.compare_by_identity
-  end
-
-  def kwarg_preceded_splats
-    @kwarg_preceded_splats ||= Set.new.compare_by_identity
-  end
-
-  def pattern_rests
-    @pattern_rests ||= Set.new.compare_by_identity
+  # Splats that are left as written: removing the `*` or `**` would not
+  # parse, or would change what a pattern matches. Each visitor that fills
+  # the set says why.
+  def exempt_splats
+    @exempt_splats ||= Set.new.compare_by_identity
   end
 
   def mutate_remove_splat(node)

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

@@ -3,6 +3,8 @@
 require_relative "../operator"
 
 class Evilution::Mutator::Operator::StringLiteral < Evilution::Mutator::Base
+  extend Evilution::Mutator::ConstantValueSubjects
+
   def initialize(skip_heredoc_literals: false, **rest)
     super(**rest)
     @skip_heredoc_literals = skip_heredoc_literals
@@ -32,6 +34,11 @@ class Evilution::Mutator::Operator::StringLiteral < Evilution::Mutator::Base
       return
     end
 
+    # The composed value as a whole, next to the chunks and interpolations
+    # inside it. A word of `%W[]` has no quotes of its own and is not a
+    # literal: `nil` there would be the word "nil".
+    emit_string_mutations(node) if node.opening_loc
+
     super
   end
 
@@ -59,11 +66,33 @@ class Evilution::Mutator::Operator::StringLiteral < Evilution::Mutator::Base
   end
 
   def visit_interpolated_x_string_node(node)
+    return if node.heredoc? && @skip_heredoc_literals
+
+    mutate_command_to_nil(node)
     visit_non_string_parts(node)
   end
 
+  def visit_x_string_node(node)
+    mutate_command_to_nil(node)
+    super
+  end
+
   private
 
+  # A command literal (`` `ls` ``, `%x(ls)`) is only ever replaced as a whole,
+  # by `nil`: the command then does not run. Its text is never rewritten, as
+  # a changed command would run for real wherever an example runs it.
+  def mutate_command_to_nil(node)
+    return if node.heredoc?
+
+    add_mutation(
+      offset: node.location.start_offset,
+      length: node.location.length,
+      replacement: "nil",
+      node: node
+    )
+  end
+
   def visit_non_string_parts(node)
     node.parts.each do |part|
       next if part.is_a?(Prism::StringNode)

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

@@ -3,7 +3,13 @@
 require "prism"
 
 require_relative "../operator"
+require_relative "../../ast/class_body"
 
+# Drop the superclass from a class definition: `class Admin < User` becomes
+# `class Admin`.
+#
+# The definition line belongs to no method, so the mutant is attributed to
+# the method anchoring the class body (see Evilution::AST::ClassBody).
 class Evilution::Mutator::Operator::SuperclassRemoval < Evilution::Mutator::Base
   def call(subject, filter: nil)
     @subject = subject
@@ -11,24 +17,22 @@ class Evilution::Mutator::Operator::SuperclassRemoval < Evilution::Mutator::Base
     @mutations = []
     @filter = filter
 
-    enclosing = find_target_class(subject)
-    return @mutations unless enclosing
-
-    offset, length = superclass_range(enclosing)
-    add_mutation(offset: offset, length: length, replacement: "", node: enclosing)
+    classes_with_superclass_for(subject).each do |class_node|
+      offset, length = superclass_range(class_node)
+      add_mutation(offset: offset, length: length, replacement: "", node: class_node)
+    end
 
     @mutations
   end
 
   private
 
-  def find_target_class(subject)
+  def classes_with_superclass_for(subject)
     tree = self.class.parsed_tree_for(subject.file_path, @file_source)
-    enclosing = find_enclosing_class(tree, subject.line_number)
-    return nil unless enclosing && enclosing.superclass
-    return nil unless find_first_method_line(enclosing) == subject.line_number
 
-    enclosing
+    Evilution::AST::ClassBody.anchored_at(tree, subject.line_number).map(&:node).select do |scope|
+      scope.is_a?(Prism::ClassNode) && scope.superclass
+    end
   end
 
   def superclass_range(class_node)
@@ -39,34 +43,4 @@ class Evilution::Mutator::Operator::SuperclassRemoval < Evilution::Mutator::Base
 
     [name_end, superclass_end - name_end]
   end
-
-  def find_enclosing_class(tree, target_line)
-    finder = ClassFinder.new(target_line)
-    finder.visit(tree)
-    finder.result
-  end
-
-  def find_first_method_line(class_node)
-    return nil unless class_node.body
-
-    class_node.body.body.each do |node|
-      return node.location.start_line if node.is_a?(Prism::DefNode)
-    end
-    nil
-  end
-
-  # Visitor to find the ClassNode enclosing a given line number.
-  class ClassFinder < 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
-  end
 end

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

@@ -1,10 +1,27 @@
 # frozen_string_literal: true
 
 require_relative "../operator"
+require_relative "../../ast/round_half_mode"
 
 class Evilution::Mutator::Operator::SymbolLiteral < Evilution::Mutator::Base
+  extend Evilution::Mutator::ConstantValueSubjects
+
+  def call(subject, filter: nil)
+    @round_half_modes = []
+    super
+  end
+
+  # The tie-breaking mode of `round` (`half: :even`) is left to
+  # RoundHalfModeSwap: a made-up symbol there only raises, and nil rounds
+  # like `:up`.
+  def visit_call_node(node)
+    mode = Evilution::AST::RoundHalfMode.of(node)
+    @round_half_modes << mode if mode
+    super
+  end
+
   def visit_symbol_node(node)
-    return super if label_form?(node)
+    return super if label_form?(node) || round_half_mode?(node)
 
     add_mutation(
       offset: node.location.start_offset,
@@ -23,10 +40,38 @@ class Evilution::Mutator::Operator::SymbolLiteral < Evilution::Mutator::Base
     super
   end
 
+  # An interpolated symbol (`:"visit_#{type}"`) as a whole. A label key
+  # (`"a#{x}": 1`) cannot be replaced by a value, and a word of `%I[]` has no
+  # quotes of its own: `nil` there would be the symbol `:nil`.
+  def visit_interpolated_symbol_node(node)
+    return super if node.opening_loc.nil? || label_form?(node)
+
+    add_mutation(
+      offset: node.location.start_offset,
+      length: node.location.length,
+      replacement: ':""',
+      node: node
+    )
+
+    add_mutation(
+      offset: node.location.start_offset,
+      length: node.location.length,
+      replacement: "nil",
+      node: node
+    )
+
+    super
+  end
+
   private
 
+  def round_half_mode?(node)
+    @round_half_modes.any? { |mode| mode.equal?(node) }
+  end
+
+  # `a:` closes with `:`, a quoted label (`"a b":`) with `":`.
   def label_form?(node)
     closing = node.closing_loc
-    !closing.nil? && closing.slice == ":"
+    !closing.nil? && closing.slice.end_with?(":")
   end
 end

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

@@ -29,7 +29,7 @@ class Evilution::Mutator::Operator::ToIToInteger < Evilution::Mutator::Base
   end
 
   def rewrite(node)
-    arguments = node.arguments ? node.arguments.arguments : []
+    arguments = argument_nodes(node)
     return if arguments.length > 1 || arguments.any?(Prism::SplatNode)
 
     parts = [node.receiver, *arguments].map { |part| source_of(part) }

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

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Replace a variable read with `nil`: a local, an instance, class or global
+# variable, or `self`.
+#
+# A survivor means the value read never reaches an assertion — the tests
+# would pass whatever the variable held. Where the read is passed as a
+# positional argument or interpolated into a string, the mutant is the one
+# argument_nil_substitution or string_interpolation already emits, and the
+# two are counted once.
+#
+# Positions where `nil` says nothing new are skipped:
+#
+# - the receiver of a call, which turns into `nil.name` — a NoMethodError
+#   any test that reaches it kills — and likewise the receiver of a write
+#   (`counter.total += 1`, `cache[key] ||= value`);
+# - a void statement (every statement of a body except the last), which
+#   statement_deletion deletes;
+# - the condition of an `if`, `unless`, `while` or `until`, where `nil` is
+#   the `false` conditional_negation already tries;
+# - the left operand of `&&` or `||`, where `nil && b` is the whole
+#   expression turned to nil and `nil || b` is `b` promoted;
+# - a block-pass argument, `&nil` being the call without its block;
+# - a double-splatted read, `**nil` raising before Ruby 3.4;
+# - the value a shorthand hash (`name:`) leaves unwritten.
+class Evilution::Mutator::Operator::VariableReadToNil < Evilution::Mutator::Base
+  include Evilution::Mutator::ReceiverPositions
+
+  def call(subject, **)
+    @skipped_nodes = Set.new
+    super
+  end
+
+  def visit_statements_node(node)
+    @skipped_nodes.merge(node.body[...-1])
+    super
+  end
+
+  def visit_if_node(node)
+    @skipped_nodes.add(node.predicate)
+    super
+  end
+
+  def visit_unless_node(node)
+    @skipped_nodes.add(node.predicate)
+    super
+  end
+
+  def visit_while_node(node)
+    @skipped_nodes.add(node.predicate)
+    super
+  end
+
+  def visit_until_node(node)
+    @skipped_nodes.add(node.predicate)
+    super
+  end
+
+  def visit_and_node(node)
+    @skipped_nodes.add(node.left)
+    super
+  end
+
+  def visit_or_node(node)
+    @skipped_nodes.add(node.left)
+    super
+  end
+
+  def visit_block_argument_node(node)
+    @skipped_nodes.add(node.expression)
+    super
+  end
+
+  def visit_assoc_splat_node(node)
+    @skipped_nodes.add(node.value)
+    super
+  end
+
+  # The read inside has no source of its own: it shares the key's.
+  def visit_implicit_node(_node); end
+
+  def visit_local_variable_read_node(node)
+    nilify(node)
+  end
+
+  def visit_instance_variable_read_node(node)
+    nilify(node)
+  end
+
+  def visit_class_variable_read_node(node)
+    nilify(node)
+  end
+
+  def visit_global_variable_read_node(node)
+    nilify(node)
+  end
+
+  def visit_self_node(node)
+    nilify(node)
+  end
+
+  private
+
+  def receiver_found(node)
+    @skipped_nodes.add(node)
+  end
+
+  def nilify(node)
+    mutate_to_nil(node) unless @skipped_nodes.include?(node)
+  end
+end