evilution 1.4.0 → 1.5.0

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

@@ -3,6 +3,7 @@
 require "prism"
 
 require_relative "../operator"
+require_relative "../../ast/class_body"
 
 # Drop an alias declaration from a class or module body: `alias length size`
 # and `alias_method :count, :size` are removed.
@@ -12,11 +13,11 @@ require_relative "../operator"
 # asserts.
 #
 # Declarations sit in the class body, outside every method, where no subject
-# reaches them. They are attributed to the first method of the innermost
-# enclosing class, module or `class << self`, the way DataStructMember and
-# MixinRemoval attribute theirs. An `alias_method` call inside a method is
-# left to the generic call operators, and global-variable aliases
-# (`alias $new $old`) are not method surface.
+# reaches them. They are attributed to the method anchoring the enclosing
+# body (see Evilution::AST::ClassBody); a top-level alias has no body to be
+# attributed to. An `alias_method` call inside a method is left to the
+# generic call operators, and global-variable aliases (`alias $new $old`)
+# are not method surface.
 class Evilution::Mutator::Operator::AliasRemoval < Evilution::Mutator::Base
   def call(subject, filter: nil)
     @subject = subject
@@ -41,86 +42,15 @@ class Evilution::Mutator::Operator::AliasRemoval < Evilution::Mutator::Base
 
   def declarations_for(subject)
     tree = self.class.parsed_tree_for(subject.file_path, @file_source)
-    collector = DeclarationCollector.new
-    collector.visit(tree)
 
-    collector.declarations.filter_map do |declaration, scope|
-      declaration if first_method_line(scope) == subject.line_number
+    Evilution::AST::ClassBody.anchored_at(tree, subject.line_number).flat_map do |body|
+      body.declarations { |node| declaration?(node) }
     end
   end
 
-  def first_method_line(scope)
-    finder = FirstMethodFinder.new
-    scope.compact_child_nodes.each { |child| finder.visit(child) }
-    finder.line
-  end
-
-  # Collects alias declarations written in a class, module or singleton class
-  # body, each paired with the innermost such scope. Method bodies are not
-  # searched, and a top-level alias has no scope to attribute it to.
-  class DeclarationCollector < Prism::Visitor
-    attr_reader :declarations
-
-    def initialize
-      super
-      @declarations = []
-      @scopes = []
-    end
-
-    def visit_class_node(node)
-      within(node) { super }
-    end
-
-    def visit_module_node(node)
-      within(node) { super }
-    end
-
-    def visit_singleton_class_node(node)
-      within(node) { super }
-    end
-
-    def visit_def_node(_node); end
-
-    def visit_alias_method_node(node)
-      record(node)
-      super
-    end
+  def declaration?(node)
+    return true if node.is_a?(Prism::AliasMethodNode)
 
-    # Blocks in the body (`included do ... end`) are searched too: an alias
-    # there still belongs to the enclosing scope.
-    def visit_call_node(node)
-      record(node) if node.name == :alias_method && node.receiver.nil?
-      super
-    end
-
-    private
-
-    def record(node)
-      @declarations << [node, @scopes.last] unless @scopes.empty?
-    end
-
-    def within(scope)
-      @scopes.push(scope)
-      yield
-    ensure
-      @scopes.pop
-    end
-  end
-
-  # Finds the line of the first method written in a scope. Nested classes,
-  # modules and singleton classes are not searched: their methods are subjects
-  # of that inner scope.
-  class FirstMethodFinder < Prism::Visitor
-    attr_reader :line
-
-    def visit_class_node(_node); end
-
-    def visit_module_node(_node); end
-
-    def visit_singleton_class_node(_node); end
-
-    def visit_def_node(node)
-      @line = node.location.start_line if @line.nil?
-    end
+    node.is_a?(Prism::CallNode) && node.name == :alias_method && node.receiver.nil?
   end
 end

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

@@ -11,7 +11,7 @@ class Evilution::Mutator::Operator::ArgumentNilSubstitution < Evilution::Mutator
   ].freeze
 
   def visit_call_node(node)
-    args = node.arguments&.arguments
+    args = argument_nodes(node)
     args.each_index { |i| emit_nil_substitution(node, args, i) } if mutable?(node, args)
 
     super
@@ -30,7 +30,7 @@ class Evilution::Mutator::Operator::ArgumentNilSubstitution < Evilution::Mutator
   end
 
   def mutable?(node, args)
-    args && args.length >= 1 && positional_only?(args) && node.name != :[]=
+    positional_only?(args) && node.name != :[]=
   end
 
   def positional_only?(args)

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

@@ -12,7 +12,7 @@ class Evilution::Mutator::Operator::ArgumentRemoval < Evilution::Mutator::Base
   ].freeze
 
   def visit_call_node(node)
-    args = node.arguments&.arguments
+    args = argument_nodes(node)
     args.each_index { |i| emit_argument_removal(node, args, i) } if mutable?(node, args)
 
     super
@@ -31,7 +31,7 @@ class Evilution::Mutator::Operator::ArgumentRemoval < Evilution::Mutator::Base
   end
 
   def mutable?(node, args)
-    args && args.length >= 2 && positional_only?(args) && node.name != :[]= && !member_list?(node)
+    args.length >= 2 && positional_only?(args) && node.name != :[]= && !member_list?(node)
   end
 
   # DataStructMember owns the member list of `Data.define` / `Struct.new` and

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

@@ -3,6 +3,8 @@
 require_relative "../operator"
 
 class Evilution::Mutator::Operator::ArrayLiteral < Evilution::Mutator::Base
+  extend Evilution::Mutator::ConstantValueSubjects
+
   def visit_array_node(node)
     if node.opening_loc && node.elements.any?
       add_mutation(
@@ -18,8 +20,35 @@ class Evilution::Mutator::Operator::ArrayLiteral < Evilution::Mutator::Base
         replacement: "nil",
         node: node
       )
+
+      mutate_delete_elements(node.elements)
+      mutate_promote_only_element(node)
     end
 
     super
   end
+
+  private
+
+  # Delete each element in turn: a survivor means no example checks that
+  # element. A single element is left to the `[]` replacement. A heredoc
+  # element stays: its body sits after the closing bracket, so one cut cannot
+  # take both, and the cut that does not parse is dropped.
+  def mutate_delete_elements(elements)
+    return if elements.one?
+
+    elements.each_index { |index| delete_element(elements, index) }
+  end
+
+  # `[x]` becomes `x`: a survivor means the wrapping does not matter, as when
+  # the caller flattens or splats the value anyway. The words of `%w[a]` are
+  # not written as expressions and stay. An element that is not an expression
+  # on its own (`*x`, the bare keywords of `[a: 1]`) does not parse once
+  # promoted and is dropped, and so is a heredoc, whose body cannot follow
+  # the cut.
+  def mutate_promote_only_element(node)
+    return unless node.elements.one? && node.opening == "["
+
+    replace_span(node:, target: node, replacement: receiver_source(node.elements.first))
+  end
 end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "../operator"
+require_relative "../../ast/class_body"
+
+# Mutate an attribute declaration in a class or module body two ways.
+#
+# Widening: `attr_reader :name` and `attr_writer :name` become
+# `attr_accessor :name`. A survivor means no example checks that the missing
+# half is missing: that the attribute cannot be written, or cannot be read.
+#
+# Removal: an `attr_reader`, `attr_writer` or `attr_accessor` declaration is
+# dropped. A survivor means no example uses any of the methods it defines.
+#
+# Declarations 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 top-level declaration has no body
+# to be attributed to. A declaration wrapped in a visibility call
+# (`private attr_reader :name`) is left alone: removing it would leave a bare
+# `private` behind.
+class Evilution::Mutator::Operator::AttrAccessorSwap < Evilution::Mutator::Base
+  WIDENED = "attr_accessor"
+  NARROW = %i[attr_reader attr_writer].freeze
+  DECLARATIONS = [*NARROW, :attr_accessor].freeze
+
+  def call(subject, filter: nil)
+    @subject = subject
+    @file_source = File.read(subject.file_path)
+    @mutations = []
+    @filter = filter
+
+    declarations_for(subject).each do |declaration|
+      widen(declaration) if NARROW.include?(declaration.name)
+      remove(declaration)
+    end
+    @mutations
+  end
+
+  private
+
+  def widen(declaration)
+    name = declaration.message_loc
+    add_mutation(offset: name.start_offset, length: name.length, replacement: WIDENED, node: declaration)
+  end
+
+  def remove(declaration)
+    add_mutation(
+      offset: declaration.location.start_offset,
+      length: declaration.location.length,
+      replacement: "",
+      node: declaration
+    )
+  end
+
+  def declarations_for(subject)
+    tree = self.class.parsed_tree_for(subject.file_path, @file_source)
+
+    Evilution::AST::ClassBody.anchored_at(tree, subject.line_number).flat_map do |body|
+      body.declarations { |node| declaration?(node) }
+    end
+  end
+
+  def declaration?(node)
+    node.is_a?(Prism::CallNode) && node.receiver.nil? && DECLARATIONS.include?(node.name) && !node.arguments.nil?
+  end
+end

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

@@ -3,6 +3,8 @@
 require_relative "../operator"
 
 class Evilution::Mutator::Operator::BooleanLiteralReplacement < Evilution::Mutator::Base
+  extend Evilution::Mutator::ConstantValueSubjects
+
   def visit_true_node(node)
     add_mutation(
       offset: node.location.start_offset,

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

@@ -13,9 +13,13 @@ require_relative "../operator"
 # (every statement of a body except the last) has no value to replace;
 # deleting it is statement_deletion's job. A call used as the receiver of
 # another call turns into `nil.foo`, a NoMethodError any test that reaches it
-# kills; the outer call is nil-ified instead. An attribute or index write
-# (`a.b = c`, `a[i] = c`) is a side effect, not a value.
+# kills; the outer call is nil-ified instead. The receiver of a write
+# (`user.account.total += 1`, `cache[key] ||= value`) is skipped likewise. An
+# attribute or index write (`a.b = c`, `a[i] = c`) is a side effect, not a
+# value.
 class Evilution::Mutator::Operator::CallToNil < Evilution::Mutator::Base
+  include Evilution::Mutator::ReceiverPositions
+
   def call(subject, **)
     @skipped_calls = Set.new
     super
@@ -27,8 +31,13 @@ class Evilution::Mutator::Operator::CallToNil < Evilution::Mutator::Base
   end
 
   def visit_call_node(node)
-    @skipped_calls.add(node.receiver)
     mutate_to_nil(node) unless @skipped_calls.include?(node) || node.attribute_write?
     super
   end
+
+  private
+
+  def receiver_found(node)
+    @skipped_calls.add(node)
+  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

@@ -38,7 +38,7 @@ class Evilution::Mutator::Operator::DataStructMember < Evilution::Mutator::Base
   private
 
   def mutate_members(node)
-    arguments = node.arguments ? node.arguments.arguments : []
+    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.

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