evilution 1.2.0 → 1.4.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/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/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/proc_to_lambda.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Turn a proc into a lambda: `proc { |a, b| ... }` and `Proc.new { ... }`
+# become `lambda { ... }`, with the block itself untouched.
+#
+# A lambda checks arity (wrong argument counts raise ArgumentError instead
+# of padding with nil or dropping extras), does not auto-splat a single
+# array argument, and `return` inside it returns from the lambda rather than
+# from the enclosing method. A survivor means no test relies on any of that.
+#
+# Only a literal block with no arguments qualifies: `proc(&blk)` and
+# `Proc.new(x) { }` are skipped.
+class Evilution::Mutator::Operator::ProcToLambda < Evilution::Mutator::Base
+  def visit_call_node(node)
+    rewrite(node) if proc_constructor?(node) && node.block.is_a?(Prism::BlockNode) && node.arguments.nil?
+    super
+  end
+
+  private
+
+  def proc_constructor?(node)
+    case node.name
+    when :proc then node.receiver.nil?
+    when :new then proc_constant?(node.receiver)
+    end
+  end
+
+  def proc_constant?(receiver)
+    case receiver
+    when Prism::ConstantReadNode then receiver.name == :Proc
+    when Prism::ConstantPathNode then receiver.parent.nil? && receiver.name == :Proc
+    end
+  end
+
+  # Replace the call head — `proc`, `Proc.new` or `Proc.new()` — leaving the
+  # block in place.
+  def rewrite(node)
+    head_end = (node.closing_loc || node.message_loc).end_offset
+    add_mutation(offset: node.start_offset, length: head_end - node.start_offset, replacement: "lambda", node: node)
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Swap a constructor for a sibling on the same receiver constant:
+# `Date.parse(value)` becomes `Date.iso8601(value)`, `Date.strptime(value)`,
+# `Date.rfc2822(value)` and the rest. Keyed on receiver and selector, which
+# the plain selector tables cannot express — `JSON.parse` is untouched.
+#
+# `parse` accepts almost any date-like string; the siblings accept one
+# format (strptime's default is ISO 8601) or, like `jd` / `civil`, numbers
+# only. A survivor means the tests only ever feed input every parser agrees
+# on, so an overly lenient parse goes unnoticed.
+#
+# Only the constant itself (`Date`, `::Date`) matches, not a namespaced
+# `Acme::Date`.
+class Evilution::Mutator::Operator::ReceiverConstructorSwap < Evilution::Mutator::Base
+  DATE_PARSE_SIBLINGS = %i[jd civil strptime iso8601 rfc3339 xmlschema rfc2822 rfc822 httpdate jisx0301].freeze
+  private_constant :DATE_PARSE_SIBLINGS
+
+  # receiver constant => { selector => replacements }. Time has no jd / civil
+  # / rfc3339 / jisx0301, and its strptime requires a format argument.
+  REPLACEMENTS = {
+    Date: { parse: DATE_PARSE_SIBLINGS },
+    DateTime: { parse: DATE_PARSE_SIBLINGS },
+    Time: { parse: %i[iso8601 xmlschema rfc2822 rfc822 httpdate] }
+  }.freeze
+  private_constant :REPLACEMENTS
+
+  def visit_call_node(node)
+    replacements_for(node).each do |replacement|
+      location = node.message_loc
+      add_mutation(offset: location.start_offset, length: location.length, replacement: replacement.to_s, node: node)
+    end
+    super
+  end
+
+  private
+
+  def replacements_for(node)
+    selectors = REPLACEMENTS[receiver_constant(node.receiver)]
+    selectors ? selectors.fetch(node.name, []) : []
+  end
+
+  def receiver_constant(receiver)
+    case receiver
+    when Prism::ConstantReadNode then receiver.name
+    when Prism::ConstantPathNode then receiver.name if receiver.parent.nil?
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Rewrite a `+` reduction into `sum`: `values.reduce(:+)` becomes
+# `values.sum`, `values.inject(10, :+)` becomes `values.sum(10)`, and the
+# same for the block-pass form `inject(&:+)`.
+#
+# The two differ on an empty collection (nil vs 0), on non-numeric elements
+# (`reduce` concatenates strings and arrays, `sum` raises TypeError without a
+# matching initial value) and on float precision (`sum` compensates rounding
+# error). A survivor means none of those edges is tested.
+class Evilution::Mutator::Operator::ReduceToSum < Evilution::Mutator::Base
+  SELECTORS = %i[reduce inject].freeze
+  private_constant :SELECTORS
+
+  NON_VALUE_ARGUMENTS = [Prism::SplatNode, Prism::KeywordHashNode].freeze
+  private_constant :NON_VALUE_ARGUMENTS
+
+  def visit_call_node(node)
+    rewrite(node) if node.receiver && SELECTORS.include?(node.name)
+    super
+  end
+
+  private
+
+  def rewrite(node)
+    initial = initial_arguments(node)
+    return unless initial && initial.length <= 1
+    return if initial.any? { |argument| NON_VALUE_ARGUMENTS.any? { |type| argument.is_a?(type) } }
+
+    # A literal block never reaches here, so the call ends at its argument
+    # list or block-pass: cut from the selector to the end of the call.
+    start = node.message_loc.start_offset
+    replacement = initial.empty? ? "sum" : "sum(#{source_of(initial.first)})"
+    add_mutation(offset: start, length: node.end_offset - start, replacement: replacement, node: node)
+  end
+
+  # The arguments besides the `+` operand — at most an initial value — when
+  # the call is a `+` reduction; nil otherwise.
+  def initial_arguments(node)
+    arguments = node.arguments ? node.arguments.arguments : []
+
+    if plus_block_pass?(node.block)
+      arguments unless plus_symbol?(arguments.last)
+    elsif node.block.nil? && plus_symbol?(arguments.last)
+      arguments[...-1]
+    end
+  end
+
+  def plus_block_pass?(block)
+    block.is_a?(Prism::BlockArgumentNode) && plus_symbol?(block.expression)
+  end
+
+  def plus_symbol?(node)
+    node.is_a?(Prism::SymbolNode) && node.unescaped == "+"
+  end
+end