evilution 1.3.0 → 1.4.0

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Swallow the error of a statement that raises by convention:
+# `record.save!` becomes `record.save! rescue nil`.
+#
+# The mutant behaves like the original until the statement fails; then it
+# carries on with nil instead of raising. A survivor means no example makes
+# that statement fail and checks the error comes out. It is the inverse of
+# RescueRemoval: handling is added where there is none.
+#
+# Only calls whose failure is part of their contract are reached: bang
+# methods, `fetch`, and the conversion functions `Integer`, `Float` and
+# `Rational`. Wrapping every statement would mostly report that no test makes
+# a log line raise. Statements already covered by a rescue are left alone, as
+# is `raise`, whose swallowed form behaves as deleting the statement.
+class Evilution::Mutator::Operator::ExceptionSwallow < Evilution::Mutator::Base
+  CONVERSION_FUNCTIONS = %i[Integer Float Rational].freeze
+
+  # A bang method name, as opposed to the `!` and `!=` operators.
+  BANG_METHOD = /\w!\z/
+
+  # Bangs that do not raise: Ruby's in-place methods mark a change to the
+  # receiver, and exit! ends the process without raising.
+  NON_RAISING_BANGS = %i[
+    uniq! sort! sort_by! select! filter! reject! map! collect! compact! flatten!
+    shuffle! reverse! rotate! slice! merge! transform_keys! transform_values!
+    gsub! sub! strip! lstrip! rstrip! chomp! chop! squeeze! tr! tr_s! delete!
+    downcase! upcase! capitalize! swapcase! unicode_normalize! scrub! encode!
+    exit!
+  ].freeze
+
+  # Assignments whose value is the statement's call.
+  WRITE_TYPES = [
+    Prism::LocalVariableWriteNode, Prism::InstanceVariableWriteNode,
+    Prism::ClassVariableWriteNode, Prism::GlobalVariableWriteNode
+  ].freeze
+
+  def visit_statements_node(node)
+    node.body.each { |statement| swallow(statement) }
+    super
+  end
+
+  # Everything under a `begin` (or a `def` or block body) with a rescue clause
+  # is already handled there, so the visitor does not descend into it.
+  def visit_begin_node(node)
+    super if node.rescue_clause.nil?
+  end
+
+  private
+
+  def swallow(statement)
+    call = statement_call(statement)
+    return unless call && raising?(call)
+
+    add_mutation(
+      offset: statement.location.end_offset,
+      length: 0,
+      replacement: " rescue nil",
+      node: call
+    )
+  end
+
+  def statement_call(statement)
+    statement = statement.value if WRITE_TYPES.include?(statement.class)
+    statement if statement.is_a?(Prism::CallNode)
+  end
+
+  def raising?(call)
+    name = call.name
+    return !NON_RAISING_BANGS.include?(name) if name.to_s.match?(BANG_METHOD)
+    return raising_fetch?(call) if name == :fetch
+
+    call.receiver.nil? && CONVERSION_FUNCTIONS.include?(name)
+  end
+
+  # With a default value or a block, fetch returns that instead of raising.
+  def raising_fetch?(call)
+    return false if call.receiver.nil? || call.block
+
+    call.arguments.nil? || call.arguments.arguments.length == 1
+  end
+end

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

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Loosen the conversion specifiers of a literal format string, one at a time:
+#
+#   format("%05d", n)    ->  format("%d", n)     flags and width dropped
+#   sprintf("%.2f", x)   ->  sprintf("%f", x)    precision dropped
+#                        ->  sprintf("%s", x)    rendered as a plain string
+#
+# A survivor means the output is produced but its shape — padding, decimals,
+# number base — is never asserted.
+#
+# Reaches the format string of receiverless `format`, `sprintf` and `printf`
+# and the string receiver of `"..." % args`, when it is a plain literal. Integer
+# conversions (`%d`, `%i`, `%u`) are not turned into `%s`: for an integer
+# argument both print the same digits.
+class Evilution::Mutator::Operator::FormatSpecifierSwap < Evilution::Mutator::Base
+  FORMAT_METHODS = %i[format sprintf printf].freeze
+
+  # `%%` and `%{name}` are matched so they are not mistaken for the start of
+  # a specifier; neither is mutated.
+  SPECIFIER = /
+    %(?:
+      %
+      | \{\w+\}
+      | (?<name><\w+>)?(?<flags>[-+\ 0\#]*)(?<width>\d+|\*)?(?:\.(?<precision>\d+|\*))?(?<type>[a-zA-Z])
+    )
+  /x
+
+  # Conversions whose output differs from `%s` for the values they take.
+  STRINGIFIABLE_TYPES = %w[f e E g G a A x X o b B].freeze
+
+  def visit_call_node(node)
+    format_string = format_string_of(node)
+    mutate_specifiers(node, format_string) if format_string
+    super
+  end
+
+  private
+
+  def format_string_of(node)
+    candidate =
+      if node.receiver.nil? && FORMAT_METHODS.include?(node.name)
+        first_argument(node)
+      elsif node.name == :%
+        node.receiver
+      end
+
+    candidate if plain_literal?(candidate)
+  end
+
+  def first_argument(node)
+    node.arguments.arguments.first if node.arguments
+  end
+
+  # A heredoc's content sits after the line that opens it, so edits inside
+  # it are left alone along with interpolated strings. Only `%w[]` elements
+  # lack an opening delimiter, and those never stand here on their own.
+  def plain_literal?(node)
+    node.is_a?(Prism::StringNode) && !node.opening_loc.slice.start_with?("<<")
+  end
+
+  def mutate_specifiers(node, format_string)
+    specifiers(format_string).each do |match, offset|
+      variants(match).each do |replacement|
+        add_mutation(offset: offset, length: match[0].bytesize, replacement: replacement, node: node)
+      end
+    end
+  end
+
+  # Each conversion specifier with its offset in the file. The scan runs over
+  # the source text between the quotes, so offsets line up with the file even
+  # when the string holds escapes.
+  def specifiers(format_string)
+    content = format_string.content_loc
+    text = byteslice_source(content.start_offset, content.length)
+
+    text.to_enum(:scan, SPECIFIER).filter_map do
+      match = Regexp.last_match
+      [match, content.start_offset + match.byteoffset(0).first] unless match[:type].nil?
+    end
+  end
+
+  # A `*` width or precision consumes an argument of its own, so dropping it
+  # would shift every argument after it.
+  def variants(match)
+    return [] if [match[:width], match[:precision]].include?("*")
+
+    name = match[:name]
+    replacements = []
+    replacements << "%#{name}#{match[:type]}" if modifiers?(match)
+    replacements << "%#{name}s" if STRINGIFIABLE_TYPES.include?(match[:type])
+    replacements
+  end
+
+  def modifiers?(match)
+    !match[:flags].empty? || !match[:width].nil? || !match[:precision].nil?
+  end
+end

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

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Stop forwarding one part of the arguments a method passes through unnamed:
+# `target.call(*, **, &)` becomes `target.call(**, &)`, and so on for each part.
+#
+# A survivor means that part never reaches an assertion — nothing checks that
+# the positional arguments, the keywords or the block arrive at the other end.
+#
+# Two spellings are handled. Anonymous `*` and `**` are dropped from the
+# argument list they are written in. A `...` cannot be split where it stands,
+# because `*`, `**` and `&` may not be written under a `...` signature, so the
+# signature is spelled out as `(*, **, &)` along with every use, and one use
+# loses one part: `def f(...) = g(...)` becomes `def f(*, **, &) = g(**, &)`.
+#
+# Named splats are left to SplatOperator and KeywordArgument, and an anonymous
+# `&` written on its own to BlockPassRemoval.
+class Evilution::Mutator::Operator::ForwardedArgumentDrop < Evilution::Mutator::Base
+  PARTS = ["*", "**", "&"].freeze
+  ALL_PARTS = PARTS.join(", ").freeze
+
+  def visit_def_node(node)
+    drop_forwarded_parts(node)
+    super
+  end
+
+  def visit_call_node(node)
+    drop_anonymous_arguments(node)
+    super
+  end
+
+  def visit_super_node(node)
+    drop_anonymous_arguments(node)
+    super
+  end
+
+  def visit_yield_node(node)
+    drop_anonymous_arguments(node)
+    super
+  end
+
+  private
+
+  def drop_anonymous_arguments(node)
+    return if node.arguments.nil?
+
+    items = argument_items(node.arguments)
+    # Dropping the only argument leaves an empty list, which is the mutant
+    # ArgumentListRemoval already emits.
+    return if items.length < 2
+
+    items.each_index do |index|
+      emit_argument_drop(node, items, index) if anonymous?(items[index])
+    end
+  end
+
+  # Keywords sit together in one KeywordHashNode, `**` among them; they are
+  # listed individually so each can be dropped on its own.
+  def argument_items(arguments)
+    arguments.arguments.flat_map do |argument|
+      argument.is_a?(Prism::KeywordHashNode) ? argument.elements : [argument]
+    end
+  end
+
+  def anonymous?(item)
+    case item
+    when Prism::SplatNode then item.expression.nil?
+    when Prism::AssocSplatNode then item.value.nil?
+    else false
+    end
+  end
+
+  def emit_argument_drop(node, items, index)
+    remaining = items.map(&:slice)
+    remaining.delete_at(index)
+    location = node.arguments.location
+
+    add_mutation(
+      offset: location.start_offset,
+      length: location.length,
+      replacement: remaining.join(", "),
+      node: node
+    )
+  end
+
+  def drop_forwarded_parts(node)
+    return if node.body.nil?
+
+    uses = forwarding_uses(node.body)
+    uses.each do |target|
+      PARTS.each { |part| emit_part_drop(node, uses, target, part) }
+    end
+  end
+
+  # Every `...` the method forwards. A method defined in the body is not
+  # searched: its `...` forwards that method's own arguments.
+  def forwarding_uses(node)
+    return [] if node.is_a?(Prism::DefNode)
+    return [node] if node.is_a?(Prism::ForwardingArgumentsNode)
+
+    node.compact_child_nodes.flat_map { |child| forwarding_uses(child) }
+  end
+
+  # A `...` can only be forwarded by the method that declares it, so a use
+  # found in the body means the signature ends in the matching parameter.
+  def emit_part_drop(node, uses, target, part)
+    edits = uses.map do |use|
+      [use.location, use.equal?(target) ? (PARTS - [part]).join(", ") : ALL_PARTS]
+    end
+    edits << [node.parameters.keyword_rest.location, ALL_PARTS]
+
+    emit_rewrite(node, edits.sort_by { |location, _text| location.start_offset })
+  end
+
+  # The signature and the uses are apart in the source, while a mutation
+  # replaces one contiguous range, so the range runs from the first edit to
+  # the last and is rewritten with every edit applied.
+  def emit_rewrite(node, edits)
+    start_offset = edits.first.first.start_offset
+    length = edits.last.first.end_offset - start_offset
+
+    add_mutation(
+      offset: start_offset,
+      length: length,
+      replacement: apply_edits(byteslice_source(start_offset, length), edits, start_offset),
+      node: node
+    )
+  end
+
+  # Applied last to first, so an edit never shifts the offsets of those still
+  # to come.
+  def apply_edits(text, edits, base_offset)
+    edits.reverse_each do |location, replacement|
+      text = text.byteslice(0, location.start_offset - base_offset) +
+             replacement +
+             text.byteslice((location.end_offset - base_offset)..)
+    end
+
+    text
+  end
+end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Turn a division into `fdiv`: `a / b` becomes `a.fdiv(b)`.
+#
+# Between integers `/` drops the remainder while `fdiv` keeps it as a float,
+# and for exact types such as Rational or BigDecimal `fdiv` falls back to
+# Float. A survivor means no example divides values that leave a remainder,
+# or none checks what happens to it.
+#
+# A float literal on either side is skipped: float division and `fdiv` give
+# the same answer, so the mutant would change nothing.
+class Evilution::Mutator::Operator::IntegerDivisionToFdiv < Evilution::Mutator::Base
+  # Receivers that `.fdiv` can follow directly. Anything else is an operator
+  # expression, which `.fdiv` would bind into, so it is grouped first.
+  SIMPLE_RECEIVER_TYPES = [
+    Prism::LocalVariableReadNode, Prism::InstanceVariableReadNode, Prism::ClassVariableReadNode,
+    Prism::GlobalVariableReadNode, Prism::ConstantReadNode, Prism::ConstantPathNode,
+    Prism::IntegerNode, Prism::ParenthesesNode, Prism::SelfNode
+  ].freeze
+
+  # A method name, as opposed to an operator such as `*` or `-@`.
+  METHOD_NAME = /\A[a-zA-Z_]\w*[?!]?\z/
+
+  def visit_call_node(node)
+    replace_division(node) if division?(node)
+    super
+  end
+
+  private
+
+  # The explicit form (`a./(b)`) is left alone: it is rare, and rewriting it
+  # gains nothing over the operator form. The operator form always has a
+  # receiver and exactly one divisor.
+  def division?(node)
+    return false unless node.name == :/ && node.call_operator_loc.nil?
+
+    [node.receiver, *node.arguments.arguments].none?(Prism::FloatNode)
+  end
+
+  def replace_division(node)
+    divisor = node.arguments.arguments.first
+
+    add_mutation(
+      offset: node.location.start_offset,
+      length: node.location.length,
+      replacement: "#{receiver_text(node.receiver)}.fdiv(#{divisor.slice})",
+      node: node
+    )
+  end
+
+  def receiver_text(receiver)
+    simple_receiver?(receiver) ? receiver.slice : "(#{receiver.slice})"
+  end
+
+  def simple_receiver?(receiver)
+    return true if SIMPLE_RECEIVER_TYPES.include?(receiver.class)
+
+    receiver.is_a?(Prism::CallNode) && receiver.name.to_s.match?(METHOD_NAME)
+  end
+end

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

@@ -8,7 +8,7 @@ class Evilution::Mutator::Operator::KeywordArgument < Evilution::Mutator::Base
     if params
       mutate_optional_keyword_defaults(params)
       mutate_optional_keyword_removal(params)
-      mutate_keyword_rest_removal(params)
+      mutate_keyword_rest_removal(node)
     end
 
     super
@@ -51,9 +51,11 @@ class Evilution::Mutator::Operator::KeywordArgument < Evilution::Mutator::Base
     end
   end
 
-  def mutate_keyword_rest_removal(params)
+  def mutate_keyword_rest_removal(node)
+    params = node.parameters
     kr = params.keyword_rest
     return unless kr.is_a?(Prism::KeywordRestParameterNode)
+    return if anonymous_rest_used?(node.body)
 
     all_params = collect_all_params(params)
     if all_params.length < 2
@@ -63,6 +65,27 @@ class Evilution::Mutator::Operator::KeywordArgument < Evilution::Mutator::Base
     end
   end
 
+  # An anonymous `**` in the body (`bar(**)`, `{ ** }`) only parses while the
+  # signature declares one, so removing it there would leave the body
+  # unparseable. Finding one also tells the rest is anonymous: Ruby rejects it
+  # next to a named rest. A named rest is safe to remove: without it the body
+  # reads an undefined name, which parses and fails at runtime.
+  def anonymous_rest_used?(body)
+    return false if body.nil?
+
+    uses_anonymous_rest?(body)
+  end
+
+  # A nested def is not searched: an anonymous `**` inside it belongs to that
+  # method's own signature. Blocks and lambdas share the enclosing method's
+  # parameters, so they are.
+  def uses_anonymous_rest?(node)
+    return false if node.is_a?(Prism::DefNode)
+    return true if node.is_a?(Prism::AssocSplatNode) && node.value.nil?
+
+    node.compact_child_nodes.any? { |child| uses_anonymous_rest?(child) }
+  end
+
   def emit_remove_only_kr(kr)
     add_mutation(
       offset: kr.location.start_offset,

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