evilution 1.3.0 → 1.5.0

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Swap the operands of a spaceship comparison: `a <=> b` becomes `b <=> a`.
+#
+# The result changes sign, so a sort block sorts the other way and a custom
+# `<=>` orders the other way round. A survivor means no example asserts the
+# direction of the ordering.
+#
+# Two-argument ordering methods (`between?`, `clamp`) are reversed by
+# ArgumentOrderPermutation. Identical operands are not swapped, since that
+# would reproduce the original comparison, and neither is a safe-navigation
+# call, where moving the other operand into the receiver's place changes what
+# may be nil.
+class Evilution::Mutator::Operator::ComparisonOperandSwap < Evilution::Mutator::Base
+  def visit_call_node(node)
+    swap_operands(node) if spaceship?(node)
+    super
+  end
+
+  private
+
+  # Ruby has no receiverless spaceship, but the explicit form can be written
+  # with no argument or several (`a.<=>`, `a.<=>(b, c)`); those have no pair
+  # of operands to swap.
+  def spaceship?(node)
+    return false unless node.name == :<=> && !node.safe_navigation?
+    return false if node.arguments.nil?
+
+    node.arguments.arguments.length == 1
+  end
+
+  # Whatever sits between the operands — the operator and its spacing, or
+  # `.<=>(` in the explicit form — stays in place.
+  def swap_operands(node)
+    left = node.receiver
+    right = node.arguments.arguments.first
+    return if left.slice == right.slice
+
+    start_offset = left.location.start_offset
+
+    add_mutation(
+      offset: start_offset,
+      length: right.location.end_offset - start_offset,
+      replacement: "#{right.slice}#{source_between(left, right)}#{left.slice}",
+      node: node
+    )
+  end
+
+  def source_between(left, right)
+    byteslice_source(left.location.end_offset, right.location.start_offset - left.location.end_offset)
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Replace a complex literal (`5i`) with `0i`, `1i`, its two neighbours along
+# the imaginary axis (`6i`, `4i`) and `nil`.
+#
+# The literal is replaced as a whole: IntegerLiteral and FloatLiteral leave
+# its numeric part alone.
+class Evilution::Mutator::Operator::ComplexLiteral < Evilution::Mutator::Base
+  extend Evilution::Mutator::ConstantValueSubjects
+
+  def visit_imaginary_node(node)
+    replacements_for(node.numeric).each { |part| add_mutation_with_replacement(node, "#{part}i") }
+    add_mutation_with_replacement(node, "nil")
+
+    super
+  end
+
+  private
+
+  # Equal values are emitted once, the integer first: `1i` over `1.0i`.
+  def replacements_for(numeric)
+    part = numeric.value
+    [0, 1, *neighbours_of(numeric)].reject { |candidate| candidate == part }.uniq(&:to_r)
+  end
+
+  # A rational part (`3ri`) gets none: its neighbours have no literal of
+  # their own in general.
+  def neighbours_of(numeric)
+    return [] if numeric.is_a?(Prism::RationalNode)
+
+    [numeric.value + 1, numeric.value - 1]
+  end
+
+  def add_mutation_with_replacement(node, replacement)
+    add_mutation(offset: node.location.start_offset, length: node.location.length, replacement:, node:)
+  end
+end

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

@@ -3,6 +3,8 @@
 require_relative "../operator"
 
 class Evilution::Mutator::Operator::CompoundAssignment < Evilution::Mutator::Base
+  extend Evilution::Mutator::ConstantValueSubjects
+
   REPLACEMENTS = {
     :+ => %i[- *],
     :- => [:+],
@@ -37,6 +39,51 @@ class Evilution::Mutator::Operator::CompoundAssignment < Evilution::Mutator::Bas
     super
   end
 
+  # `obj.count += 1`: the target is read through `count` and written
+  # through `count=`.
+  def visit_call_operator_write_node(node)
+    mutate_operator_write(node)
+    super
+  end
+
+  # `counts[key] += 1`: read through `[]` and written through `[]=`.
+  def visit_index_operator_write_node(node)
+    mutate_operator_write(node)
+    super
+  end
+
+  # `TOTAL += 1` is written outside any method and is a constant-write
+  # subject of its own, like the assignment `TOTAL = 1` before it.
+  def visit_constant_operator_write_node(node)
+    mutate_operator_write(node)
+    super
+  end
+
+  def visit_constant_path_operator_write_node(node)
+    mutate_operator_write(node)
+    super
+  end
+
+  def visit_call_and_write_node(node)
+    mutate_logical_write(node, "||=")
+    super
+  end
+
+  def visit_call_or_write_node(node)
+    mutate_logical_write(node, "&&=")
+    super
+  end
+
+  def visit_index_and_write_node(node)
+    mutate_logical_write(node, "||=")
+    super
+  end
+
+  def visit_index_or_write_node(node)
+    mutate_logical_write(node, "&&=")
+    super
+  end
+
   def visit_local_variable_and_write_node(node)
     mutate_logical_write(node, "||=")
     super

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Strip the namespace off a constant path: `Config::LIMIT` becomes `LIMIT`.
+# A longer path is stripped at each level, so `App::Config::LIMIT` gives
+# both `LIMIT` and `Config::LIMIT`.
+#
+# The bare name is looked up from where the code stands instead of inside
+# the namespace. It either finds another constant or raises NameError; a
+# survivor means the same constant is reachable without the qualifier, or
+# that nothing depends on which one is found. A namespace given by an
+# expression (`self.class::LIMIT`) is stripped too — there the survivor says
+# no test overrides the constant in a subclass.
+#
+# A top-level path (`::LIMIT`) has no namespace to strip. The target of an
+# operator write (`Config::LIMIT ||= x`) is left alone: bare, `LIMIT ||= x`
+# is a dynamic constant assignment inside a method. Prism lets it through,
+# where parse.y rejects it with a SyntaxError, so whether the mutant exists
+# would depend on the parser the interpreter compiles with.
+class Evilution::Mutator::Operator::ConstantNamespaceStrip < Evilution::Mutator::Base
+  def call(subject, **)
+    @write_targets = Set.new
+    super
+  end
+
+  def visit_constant_path_or_write_node(node)
+    @write_targets.add(node.target)
+    super
+  end
+
+  def visit_constant_path_and_write_node(node)
+    @write_targets.add(node.target)
+    super
+  end
+
+  def visit_constant_path_operator_write_node(node)
+    @write_targets.add(node.target)
+    super
+  end
+
+  def visit_constant_path_node(node)
+    replace_span(node: node, target: node, replacement: name_source(node)) if strippable?(node)
+    super
+  end
+
+  private
+
+  def strippable?(node)
+    node.parent && !@write_targets.include?(node)
+  end
+
+  def name_source(node)
+    location = node.name_loc
+    byteslice_source(location.start_offset, location.length)
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Replace a constant reference with `nil`: `MAX` becomes `nil`, and a path
+# such as `Config::MAX` goes as a whole.
+#
+# A survivor means the constant's value never reaches an assertion — the
+# tests would pass whatever it held.
+#
+# Four positions are skipped as noise. A constant used as the receiver of a
+# call turns into `nil.new`, a NoMethodError any test that reaches it kills;
+# so does the receiver of a write (`Counter.total += 1`, `CACHE[key] ||= v`).
+# The namespace of a path would leave `nil::MAX`, a TypeError; the path is
+# nil-ified instead. A constant in void statement position (every statement
+# of a body except the last) has no value to replace; deleting it is
+# statement_deletion's job. And the exception classes of a `rescue` clause
+# belong to the rescue operators — `rescue nil` only fails once something is
+# raised, and then with a TypeError of its own.
+class Evilution::Mutator::Operator::ConstantReadToNil < 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_rescue_node(node)
+    @skipped_nodes.merge(node.exceptions)
+    super
+  end
+
+  def visit_constant_path_node(node)
+    @skipped_nodes.add(node.parent)
+    nilify(node)
+    super
+  end
+
+  def visit_constant_read_node(node)
+    nilify(node)
+    super
+  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

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Assign `nil` to a constant instead of its value: `LIMIT = 10` becomes
+# `LIMIT = nil`.
+#
+# A survivor means nothing the tests run depends on what the constant holds.
+# The literal operators go on to change the value piece by piece; this one
+# takes it away whole, whatever it is — a literal, a call, a lambda.
+#
+# It works on constant-write subjects, each being one assignment, and does
+# not look inside the value: a constant assigned there (in the block of a
+# `Class.new`) is a subject of its own. A constant already assigned `nil`
+# has nothing to lose. An operator write (`LIMIT += 1`) is left to
+# compound_assignment, which replaces the whole of it with `nil`.
+#
+# Code that read the constant while the file first loaded keeps the old
+# value (see Subject), so only what reads it when called sees the mutant.
+class Evilution::Mutator::Operator::ConstantWriteToNil < Evilution::Mutator::Base
+  def self.subject_kinds
+    %i[constant_write]
+  end
+
+  def visit_constant_write_node(node)
+    mutate_to_nil(node, target: node.value)
+  end
+
+  def visit_constant_path_write_node(node)
+    mutate_to_nil(node, target: node.value)
+  end
+end

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "../operator"
+require_relative "../../ast/value_object_definition"
+
+# Mutate the member list of a value-object definition: `Data.define(:a, :b)`
+# and `Struct.new(:a, :b)` lose one member at a time, and have each adjacent
+# pair of members swapped.
+#
+# A surviving drop means no example reads or sets that member. A surviving swap
+# means the type is built positionally somewhere the order is never asserted,
+# so two members could trade values unnoticed.
+#
+# Definitions outside any method — assigned to a constant, or the superclass
+# of a class — are constant subjects of their own, and this operator mutates
+# them there. A constant subject is the definition alone: definitions nested
+# in its block are subjects of their own too.
+class Evilution::Mutator::Operator::DataStructMember < Evilution::Mutator::Base
+  # Arguments whose position and meaning are known: members are symbols, a
+  # string is the class name `Struct.new("Name", ...)` takes first, and the
+  # keyword hash carries `keyword_init:`. Anything else (a splat, a variable)
+  # hides the member list, so the definition is left alone.
+  KNOWN_ARGUMENT_TYPES = [Prism::SymbolNode, Prism::StringNode, Prism::KeywordHashNode].freeze
+
+  def self.subject_kinds
+    %i[method constant]
+  end
+
+  # A constant subject's node is the definition itself, so the visit stops
+  # there rather than reaching definitions nested in its block.
+  def visit_call_node(node)
+    mutate_members(node) if Evilution::AST::ValueObjectDefinition.match?(node)
+    super unless @subject.kind == :constant
+  end
+
+  private
+
+  def mutate_members(node)
+    arguments = argument_nodes(node)
+    members = member_indexes(arguments)
+    # A lone member has no neighbour to swap with, and dropping it would leave
+    # `Struct.new()`, which raises on Rubies that require at least one member.
+    return if members.length < 2
+
+    slices = arguments.map(&:slice)
+    members.each { |index| emit_member_drop(node, slices, index) }
+    members.each_cons(2) { |left, right| emit_member_swap(node, slices, left, right) }
+  end
+
+  def member_indexes(arguments)
+    return [] unless arguments.all? { |argument| KNOWN_ARGUMENT_TYPES.include?(argument.class) }
+
+    arguments.each_index.select { |index| arguments[index].is_a?(Prism::SymbolNode) }
+  end
+
+  def emit_member_drop(node, slices, index)
+    remaining = slices.dup
+    remaining.delete_at(index)
+    replace_arguments(node, remaining)
+  end
+
+  def emit_member_swap(node, slices, left, right)
+    return if slices[left] == slices[right]
+
+    swapped = slices.dup
+    swapped[left], swapped[right] = swapped[right], swapped[left]
+    replace_arguments(node, swapped)
+  end
+
+  def replace_arguments(node, slices)
+    location = node.arguments.location
+
+    add_mutation(
+      offset: location.start_offset,
+      length: location.length,
+      replacement: slices.join(", "),
+      node: node
+    )
+  end
+end

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/explicit_super_mutation.rb

@@ -5,8 +5,8 @@ require_relative "../operator"
 class Evilution::Mutator::Operator::ExplicitSuperMutation < Evilution::Mutator::Base
   def visit_super_node(node)
     replace_with_zsuper(node)
-    args = node.arguments&.arguments
-    mutate_arguments(node, args) if args && !args.empty?
+    args = argument_nodes(node)
+    mutate_arguments(node, args) unless args.empty?
 
     super
   end

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

@@ -3,27 +3,62 @@
 require_relative "../operator"
 
 class Evilution::Mutator::Operator::FloatLiteral < Evilution::Mutator::Base
+  extend Evilution::Mutator::ConstantValueSubjects
+
+  # NaN fails every comparison and equality; the infinities break arithmetic
+  # on bounds. None of them can be reached from `0.0`, `1.0` or `nil`.
+  SPECIAL_VALUES = ["Float::NAN", "Float::INFINITY", "-Float::INFINITY"].freeze
+
+  # A guard wraps the pattern of its branch: `in Float if x > 1.0`.
+  GUARDS = [Prism::IfNode, Prism::UnlessNode].freeze
+
   def visit_float_node(node)
-    replacement = case node.value
-                  when 0.0 then "1.0"
-                  when 1.0 then "0.0"
-                  else "0.0"
-                  end
-
-    add_mutation(
-      offset: node.location.start_offset,
-      length: node.location.length,
-      replacement: replacement,
-      node: node
-    )
-
-    add_mutation(
-      offset: node.location.start_offset,
-      length: node.location.length,
-      replacement: "nil",
-      node: node
-    )
+    add_mutation_with_replacement(node, node.value == 0.0 ? "1.0" : "0.0")
+    SPECIAL_VALUES.each { |value| add_mutation_with_replacement(node, value) } unless pattern_literals.include?(node)
+    add_mutation_with_replacement(node, "nil")
+
+    super
+  end
 
+  # A pattern takes literals, not expressions: `in -Float::INFINITY` and
+  # `in Float::NAN..2.0` do not parse. The floats of a pattern keep the
+  # literal replacements only. A guard and a pinned expression (`^(x + 1.0)`)
+  # are ordinary code.
+  def visit_in_node(node)
+    pattern = node.pattern
+    pattern = pattern.statements if GUARDS.include?(pattern.class)
+    mark_pattern_literals(pattern)
     super
   end
+
+  def visit_match_predicate_node(node)
+    mark_pattern_literals(node.pattern)
+    super
+  end
+
+  def visit_match_required_node(node)
+    mark_pattern_literals(node.pattern)
+    super
+  end
+
+  # A complex literal (`5i`) is replaced as a whole by ComplexLiteral. Its
+  # numeric part is not a literal of its own: `nili` is not a value.
+  def visit_imaginary_node(_node); end
+
+  private
+
+  def pattern_literals
+    @pattern_literals ||= Set.new.compare_by_identity
+  end
+
+  def mark_pattern_literals(node)
+    return if node.is_a?(Prism::PinnedExpressionNode)
+
+    pattern_literals.add(node) if node.is_a?(Prism::FloatNode)
+    node.compact_child_nodes.each { |child| mark_pattern_literals(child) }
+  end
+
+  def add_mutation_with_replacement(node, replacement)
+    add_mutation(offset: node.location.start_offset, length: node.location.length, replacement:, node:)
+  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