evilution 1.3.0 → 1.5.0

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Swap the values of neighbouring keyword arguments, keeping the keys:
+# `compute(x: a, y: b)` becomes `compute(x: b, y: a)`.
+#
+# A survivor means no example tells the two values apart — the keyword form
+# of the defect ArgumentOrderPermutation probes for positional arguments.
+#
+# Only keyword arguments written in the call are swapped: a braced hash is a
+# single positional argument whose pairs are data. A double splat stays in
+# place, and identical values are not swapped, since that would reproduce the
+# original call. A shorthand key (`compute(a:, b:)`) has no value of its own
+# to move, so the swap spells it out: `compute(a: b, b: a)`.
+class Evilution::Mutator::Operator::KeywordValueSwap < Evilution::Mutator::Base
+  def visit_call_node(node)
+    swap_keyword_values(node)
+    super
+  end
+
+  def visit_super_node(node)
+    swap_keyword_values(node)
+    super
+  end
+
+  def visit_yield_node(node)
+    swap_keyword_values(node)
+    super
+  end
+
+  private
+
+  def swap_keyword_values(node)
+    return if node.arguments.nil?
+
+    node.arguments.arguments.grep(Prism::KeywordHashNode).each do |keywords|
+      pairs = keywords.elements.grep(Prism::AssocNode)
+      pairs.each_cons(2) do |left, right|
+        emit_swap(node, left, right) unless value_text(left) == value_text(right)
+      end
+    end
+  end
+
+  # Whatever separates the two pairs — the comma, a double splat, line breaks,
+  # comments — stays between them, so the call keeps its layout.
+  def emit_swap(node, left, right)
+    start_offset = left.location.start_offset
+
+    add_mutation(
+      offset: start_offset,
+      length: right.location.end_offset - start_offset,
+      replacement: "#{key_text(left)}#{value_text(right)}#{source_between(left, right)}" \
+                   "#{key_text(right)}#{value_text(left)}",
+      node: node
+    )
+  end
+
+  def source_between(left, right)
+    byteslice_source(left.location.end_offset, right.location.start_offset - left.location.end_offset)
+  end
+
+  # The key with everything up to its value: `x: `, `"x" => `.
+  def key_text(pair)
+    return "#{pair.key.slice} " if pair.value.is_a?(Prism::ImplicitNode)
+
+    byteslice_source(pair.location.start_offset, pair.value.location.start_offset - pair.location.start_offset)
+  end
+
+  # A shorthand key stands for the local variable or method of the same name.
+  def value_text(pair)
+    value = pair.value
+    value.is_a?(Prism::ImplicitNode) ? value.value.name.to_s : value.slice
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Turn a memoizing assignment into a plain one: `@x ||= expr` becomes
+# `@x = expr`, so the value is computed again on every call.
+#
+# A survivor means no example tells one computation from several: nothing
+# counts the calls behind the value, and nothing depends on getting the same
+# object back.
+class Evilution::Mutator::Operator::MemoizationBreak < Evilution::Mutator::Base
+  def visit_instance_variable_or_write_node(node)
+    operator = node.operator_loc
+    add_mutation(offset: operator.start_offset, length: operator.length, replacement: "=", node: node)
+
+    super
+  end
+end

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

@@ -3,7 +3,15 @@
 require "prism"
 
 require_relative "../operator"
-
+require_relative "../../ast/class_body"
+
+# Drop a mixin from a class or module body: `include`, `extend` and `prepend`
+# calls are removed.
+#
+# The calls sit in the class body, outside every method, where no subject
+# reaches them. They are attributed to the method anchoring the enclosing
+# body (see Evilution::AST::ClassBody). A mixin call inside a method is left
+# to the generic call operators.
 class Evilution::Mutator::Operator::MixinRemoval < Evilution::Mutator::Base
   MIXIN_METHODS = %i[include extend prepend].freeze
 
@@ -13,22 +21,22 @@ class Evilution::Mutator::Operator::MixinRemoval < Evilution::Mutator::Base
     @mutations = []
     @filter = filter
 
-    enclosing = find_target_scope(subject)
-    return @mutations unless enclosing
-
-    find_mixin_calls(enclosing).each { |call_node| emit_mixin_removal(call_node) }
+    mixin_calls_for(subject).each { |call_node| emit_mixin_removal(call_node) }
     @mutations
   end
 
   private
 
-  def find_target_scope(subject)
+  def mixin_calls_for(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
+    Evilution::AST::ClassBody.anchored_at(tree, subject.line_number).flat_map do |body|
+      body.declarations { |node| mixin_call?(node) }
+    end
+  end
+
+  def mixin_call?(node)
+    node.is_a?(Prism::CallNode) && MIXIN_METHODS.include?(node.name) && node.receiver.nil?
   end
 
   def emit_mixin_removal(call_node)
@@ -39,49 +47,4 @@ class Evilution::Mutator::Operator::MixinRemoval < Evilution::Mutator::Base
       node: call_node
     )
   end
-
-  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/nil_replacement.rb

@@ -3,6 +3,8 @@
 require_relative "../operator"
 
 class Evilution::Mutator::Operator::NilReplacement < Evilution::Mutator::Base
+  extend Evilution::Mutator::ConstantValueSubjects
+
   REPLACEMENTS = %w[true false 0 ""].freeze
 
   def visit_nil_node(node)

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Give a `case/in` that has no `else` an empty one.
+#
+# Without an else, a value no pattern matches raises NoMatchingPatternError;
+# with an empty one the expression quietly yields nil. A survivor means no
+# example feeds the match a value outside its patterns, so nothing asserts
+# that such a value is rejected.
+#
+# The opposite edit, removing an else that is there, belongs to CaseIn.
+class Evilution::Mutator::Operator::NoMatchingPatternElse < Evilution::Mutator::Base
+  def visit_case_match_node(node)
+    add_else(node) if node.else_clause.nil? && !exhaustive?(node)
+    super
+  end
+
+  private
+
+  def add_else(node)
+    offset = node.end_keyword_loc.start_offset
+
+    add_mutation(
+      offset: offset,
+      length: 0,
+      replacement: else_clause_before(offset),
+      node: node
+    )
+  end
+
+  # An `end` on a line of its own gets the else on the line above, indented
+  # alike. Otherwise the case is written on one line and the else joins it.
+  def else_clause_before(offset)
+    line_start = line_start_byte(@file_source, offset)
+    indentation = byteslice_source(line_start, offset - line_start)
+
+    indentation.strip.empty? ? "else\n#{indentation}" : "else; "
+  end
+
+  # A bare name (`in other`, `in _`) matches every value, so an else after it
+  # could never run and adding one would change nothing. A guarded capture is
+  # not a bare name: Prism wraps it in the guard's conditional.
+  def exhaustive?(node)
+    node.conditions.any? { |clause| clause.pattern.is_a?(Prism::LocalVariableTargetNode) }
+  end
+end

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Swap the numbered parameters of a block: `pairs.map { _1 - _2 }` becomes
+# `pairs.map { _2 - _1 }`.
+#
+# A survivor means no example tells the two values apart, so the block could
+# take them in either order unnoticed.
+#
+# Only parameters the body reads are swapped with each other, each with its
+# neighbour. Swapping in a parameter the body never reads (`{ _1 }` to
+# `{ _2 }`) would change how many values the block takes, which is a different
+# mutation from reordering them.
+class Evilution::Mutator::Operator::NumberedParameterSwap < Evilution::Mutator::Base
+  NUMBERED_NAME = /\A_[1-9]\z/
+
+  def visit_block_node(node)
+    swap_parameters(node)
+    super
+  end
+
+  def visit_lambda_node(node)
+    swap_parameters(node)
+    super
+  end
+
+  private
+
+  def swap_parameters(node)
+    return unless node.parameters.is_a?(Prism::NumberedParametersNode)
+
+    reads = numbered_reads(node.body)
+    names = reads.map { |read| read.name.to_s }.uniq.sort
+    names.each_cons(2) { |left, right| emit_swap(node, reads, left, right) }
+  end
+
+  # Every read of a numbered parameter in the body. Blocks nested in it are
+  # searched too: a numbered parameter read there can only be this block's,
+  # since Ruby rejects a nested block that declares its own. A method defined
+  # in the body opens a new scope, whose blocks have parameters of their own.
+  def numbered_reads(node)
+    return [] if node.is_a?(Prism::DefNode)
+    return [node] if node.is_a?(Prism::LocalVariableReadNode) && node.name.to_s.match?(NUMBERED_NAME)
+
+    node.compact_child_nodes.flat_map { |child| numbered_reads(child) }
+  end
+
+  # The reads are scattered through the body, while a mutation replaces one
+  # contiguous range, so the range runs from the first affected read to the
+  # last and is rewritten with the two names exchanged.
+  def emit_swap(node, reads, left, right)
+    affected = reads.select { |read| [left, right].include?(read.name.to_s) }
+                    .sort_by { |read| read.location.start_offset }
+    start_offset = affected.first.location.start_offset
+    end_offset = affected.last.location.end_offset
+
+    add_mutation(
+      offset: start_offset,
+      length: end_offset - start_offset,
+      replacement: exchange(affected, start_offset, end_offset, left => right, right => left),
+      node: node
+    )
+  end
+
+  def exchange(affected, start_offset, end_offset, renames)
+    text = byteslice_source(start_offset, end_offset - start_offset)
+
+    affected.reverse_each do |read|
+      location = read.location
+      text = text.byteslice(0, location.start_offset - start_offset) +
+             renames.fetch(read.name.to_s) +
+             text.byteslice((location.end_offset - start_offset)..)
+    end
+
+    text
+  end
+end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Shift a count held in a variable down by one: `n.times` becomes
+# `(n - 1).times`, `items.first(n)` becomes `items.first(n - 1)`.
+#
+# A survivor means no example checks the last iteration or the last element,
+# the classic fencepost slip. A literal count is left to IntegerLiteral, which
+# already shifts it; this operator reaches the counts that have no literal.
+class Evilution::Mutator::Operator::OffByOneBoundary < Evilution::Mutator::Base
+  # Methods whose receiver is the count.
+  RECEIVER_COUNT_METHODS = %i[times].freeze
+
+  # Methods whose single argument is the count or the bound.
+  ARGUMENT_COUNT_METHODS = %i[upto downto take first last drop each_slice each_cons].freeze
+
+  # Arguments that stand in the list without being a value: a splat,
+  # keywords, forwarded arguments. Subtracting from them would not parse.
+  NON_VALUE_ARGUMENT_TYPES = [
+    Prism::SplatNode, Prism::KeywordHashNode, Prism::ForwardingArgumentsNode
+  ].freeze
+
+  def visit_call_node(node)
+    shift_count(node) unless node.safe_navigation?
+    super
+  end
+
+  private
+
+  def shift_count(node)
+    count = count_of(node)
+    return if count.nil? || count.is_a?(Prism::IntegerNode)
+
+    add_mutation(
+      offset: count.location.start_offset,
+      length: count.location.length,
+      replacement: lowered(node, count),
+      node: node
+    )
+  end
+
+  def count_of(node)
+    if RECEIVER_COUNT_METHODS.include?(node.name)
+      node.receiver if node.arguments.nil?
+    elsif ARGUMENT_COUNT_METHODS.include?(node.name)
+      single_argument(node)
+    end
+  end
+
+  def single_argument(node)
+    return nil if node.arguments.nil?
+
+    arguments = node.arguments.arguments
+    return nil unless arguments.length == 1
+    return nil if NON_VALUE_ARGUMENT_TYPES.include?(arguments.first.class)
+
+    arguments.first
+  end
+
+  # A receiver is followed by `.method`, so the subtraction is grouped; an
+  # argument stands on its own and only needs grouping when it is not a
+  # primary expression.
+  def lowered(node, count)
+    subtraction = "#{receiver_source(count)} - 1"
+    count.equal?(node.receiver) ? "(#{subtraction})" : subtraction
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Retarget an operator write on an attribute at the instance variable it
+# goes through: `@account.balance += amount` becomes `@account += amount`.
+#
+# The value is still computed and still assigned, only to the wrong place:
+# the object's attribute is left as it was and the variable is replaced. A
+# survivor means the tests exercise the line without ever looking at what it
+# was meant to change. Where the object does not answer the operator the
+# mutant raises NoMethodError, which any test reaching the line kills.
+#
+# Only a receiver that is an instance variable qualifies. `self` cannot be
+# assigned to, and behind a longer receiver (`@user.account.balance += x`)
+# sits another attribute, not a variable.
+class Evilution::Mutator::Operator::OperatorWriteReceiverPromotion < Evilution::Mutator::Base
+  def visit_call_operator_write_node(node)
+    promote_receiver(node) if node.receiver.is_a?(Prism::InstanceVariableReadNode)
+    super
+  end
+
+  private
+
+  # Replaces `@account.balance`, up to the end of the attribute's name, with
+  # `@account`. What is left is an operator write on a variable, which always
+  # parses.
+  def promote_receiver(node)
+    offset = node.start_offset
+
+    add_mutation(
+      offset: offset,
+      length: node.message_loc.end_offset - offset,
+      replacement: source_of(node.receiver),
+      node: node
+    )
+  end
+end

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

@@ -12,21 +12,32 @@ require_relative "../operator"
 # that pass the argument are unaffected, which is what separates this from a
 # mutation that breaks every call site.
 #
-# Ruby allows a required parameter to follow an optional one, so each optional
-# is mutated on its own and the rest of the signature stays as written.
+# Optional parameters have to sit side by side, so only the ends of a run of
+# them are mutated; a required parameter in the middle would split it in two.
+# The first can always join the required parameters before it. The last can
+# join those after it, unless a rest parameter follows: a required parameter
+# cannot stand between an optional one and `*rest`. The rest of the signature
+# stays as written.
 # KeywordArgument owns optional keyword parameters. Blocks are left alone: a
 # block ignores arity, so a missing argument arrives as nil rather than raising,
 # and making its parameter required would change nothing.
 class Evilution::Mutator::Operator::OptionalParameterToRequired < Evilution::Mutator::Base
   def visit_def_node(node)
     parameters = node.parameters
-    parameters.optionals.each { |optional| require_parameter(optional) } if parameters
+    mutable_optionals(parameters).each { |optional| require_parameter(optional) } if parameters
 
     super
   end
 
   private
 
+  def mutable_optionals(parameters)
+    optionals = parameters.optionals
+    return optionals.first(1) if parameters.rest
+
+    [optionals.first, optionals.last].compact.uniq
+  end
+
   def require_parameter(node)
     location = node.location
     name_loc = node.name_loc

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

@@ -83,14 +83,25 @@ class Evilution::Mutator::Operator::PatternMatchingArray < Evilution::Mutator::B
   end
 
   def replace_pattern(node, parts)
+    constant = node.constant ? source_for(node.constant) : ""
+    opening, closing = delimiters(node)
+
     add_mutation(
       offset: node.location.start_offset,
       length: node.location.length,
-      replacement: "[#{parts.join(", ")}]",
+      replacement: "#{constant}#{opening}#{parts.join(", ")}#{closing}",
       node: node
     )
   end
 
+  # A pattern written without brackets (`in a, b`) has no delimiters of its
+  # own, so the mutant is given square ones.
+  def delimiters(node)
+    return ["[", "]"] if node.opening_loc.nil?
+
+    [node.opening_loc.slice, node.closing_loc.slice]
+  end
+
   def source_for(node)
     @file_source.byteslice(node.location.start_offset, node.location.length)
   end

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

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Widen a pattern so it accepts input the original rejects:
+#
+#   in [a, b]               ->  in [a, b, *]        longer arrays
+#   in { age: Integer }     ->  in { age: _ }       any value under the key
+#   in { name: String, age: Integer }
+#                           ->  in { name: String } hashes without the key
+#   in { kind: :a, **nil }  ->  in { kind: :a }     hashes with other keys
+#
+# A survivor means no example feeds the pattern one of the shapes it is written
+# to turn away.
+#
+# Elements of array and find patterns are widened by PatternMatchingArray. Here
+# the pattern itself is opened up, and every edit keeps the variables the
+# pattern binds, so the branch body still runs as written.
+class Evilution::Mutator::Operator::PatternWildcardWidening < Evilution::Mutator::Base
+  WILDCARD = "_"
+  UNWIDENABLE_VALUE_TYPES = [Prism::LocalVariableTargetNode, Prism::ImplicitNode].freeze
+
+  def visit_array_pattern_node(node)
+    append_rest(node)
+    super
+  end
+
+  def visit_hash_pattern_node(node)
+    widen_pairs(node)
+    drop_closing_rest(node)
+    super
+  end
+
+  private
+
+  # A pattern with a rest is open already, at whichever end the rest sits, and
+  # an empty one has no element to append after.
+  def append_rest(node)
+    return unless node.rest.nil?
+    return if node.requireds.empty?
+
+    add_mutation(
+      offset: node.requireds.last.location.end_offset,
+      length: 0,
+      replacement: ", *",
+      node: node
+    )
+  end
+
+  def widen_pairs(node)
+    node.elements.each_with_index do |pair, index|
+      next if binds_variable?(pair.value)
+
+      wildcard_value(node, pair)
+      # `in {}` matches the empty hash only, so dropping the last key would
+      # narrow the pattern rather than widen it.
+      drop_pair(node, index) if node.elements.length > 1
+    end
+  end
+
+  # A bare name reaching here is an underscore one, which already accepts any
+  # value; rewriting it to `_` would change nothing. A shorthand key
+  # (`_ignored:`) has no value pattern of its own: its implicit value spans the
+  # key, so writing a wildcard there would rename the key instead.
+  def wildcard_value(node, pair)
+    return if UNWIDENABLE_VALUE_TYPES.include?(pair.value.class)
+
+    location = pair.value.location
+
+    add_mutation(
+      offset: location.start_offset,
+      length: location.length,
+      replacement: WILDCARD,
+      node: node
+    )
+  end
+
+  def drop_pair(node, index)
+    remaining = node.elements.dup
+    remaining.delete_at(index)
+    replace_members(node, remaining + [node.rest].compact)
+  end
+
+  # `**nil` forbids keys the pattern does not name. On its own it leaves a
+  # pattern that matches the empty hash only, with or without it.
+  def drop_closing_rest(node)
+    return unless node.rest.is_a?(Prism::NoKeywordsParameterNode)
+    return if node.elements.empty?
+
+    replace_members(node, node.elements)
+  end
+
+  # Rewrites what sits between the delimiters, so braces, parentheses and a
+  # constant in front of them stay as written.
+  def replace_members(node, members)
+    all = node.elements + [node.rest].compact
+    start_offset = all.first.location.start_offset
+    end_offset = all.last.location.end_offset
+
+    add_mutation(
+      offset: start_offset,
+      length: end_offset - start_offset,
+      replacement: members.map(&:slice).join(", "),
+      node: node
+    )
+  end
+
+  # Whether the value pattern captures into a variable the branch body could
+  # read. Taking such a pair away, or widening it to a wildcard, would break
+  # the body on the missing name whatever the tests assert. An underscore name
+  # is a wildcard by convention and is not counted.
+  def binds_variable?(node)
+    return !node.name.start_with?(WILDCARD) if node.is_a?(Prism::LocalVariableTargetNode)
+
+    node.compact_child_nodes.any? { |child| binds_variable?(child) }
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Drop the pin of a pattern variable: `in ^expected` becomes `in expected`.
+#
+# A pinned variable compares the matched value against an existing binding;
+# without the pin the same name captures whatever is there, so the pattern
+# matches every value. A survivor means no example feeds the pattern a value
+# that differs from the pinned one.
+class Evilution::Mutator::Operator::PinOperatorRemoval < Evilution::Mutator::Base
+  def initialize(**options)
+    super
+    @alternation_depth = 0
+  end
+
+  # An alternative pattern (`^a | ^b`) may not capture, at any depth inside it,
+  # so no pin under one has an unpinned form. Tracked here rather than left to
+  # the parse check: older Prism releases accept the capture that Ruby rejects.
+  def visit_alternation_pattern_node(node)
+    @alternation_depth += 1
+    super
+  ensure
+    @alternation_depth -= 1
+  end
+
+  def visit_pinned_variable_node(node)
+    remove_pin(node) if @alternation_depth.zero?
+    super
+  end
+
+  private
+
+  # Other pins without an unpinned form are caught by the parse check. Only a
+  # local name can stand as a capturing pattern, so `^@expected` and
+  # `^$expected` have none, and neither does a numbered parameter (`^_1`).
+  # Those rewrites carry no signal, so they are dropped rather than reported
+  # as unparseable.
+  def remove_pin(node)
+    add_mutation(
+      offset: node.location.start_offset,
+      length: node.location.length,
+      replacement: node.variable.slice,
+      node: node,
+      skip_unparseable: true
+    )
+  end
+end

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

@@ -3,6 +3,8 @@
 require_relative "../operator"
 
 class Evilution::Mutator::Operator::RangeReplacement < Evilution::Mutator::Base
+  extend Evilution::Mutator::ConstantValueSubjects
+
   def visit_range_node(node)
     replacement = node.operator == ".." ? "..." : ".."