evilution 1.3.0 → 1.5.0

data/lib/evilution/memory/leak_check.rb

@@ -9,9 +9,11 @@ class Evilution::Memory::LeakCheck
 
   attr_reader :samples
 
-  def initialize(iterations: DEFAULT_ITERATIONS, max_growth_kb: DEFAULT_MAX_GROWTH_KB)
+  def initialize(iterations: DEFAULT_ITERATIONS, max_growth_kb: DEFAULT_MAX_GROWTH_KB,
+                 warmup_iterations: WARMUP_ITERATIONS)
     @iterations = iterations
     @max_growth_kb = max_growth_kb
+    @warmup_iterations = warmup_iterations
     @samples = []
   end
 
@@ -32,8 +34,23 @@ class Evilution::Memory::LeakCheck
     samples.last - samples.first
   end
 
-  def passed?
+  # Growth from the first sample to the last, less the largest rise between two
+  # consecutive samples.
+  #
+  # RSS does not grow by the byte. The allocator takes memory in chunks, so a
+  # workload that has stopped growing can still step up once, by several MB,
+  # wherever the heap happens to cross a boundary, and that one step decided
+  # the endpoint reading. A leak is not one step: it grows across the run, and
+  # taking out its largest step leaves the rest of it.
+  def sustained_growth_kb
     kb = growth_kb
+    return kb if kb.nil? || samples.size < 2
+
+    kb - [largest_step_kb, 0].max
+  end
+
+  def passed?
+    kb = sustained_growth_kb
     return false if kb.nil?
 
     kb <= @max_growth_kb
@@ -41,8 +58,12 @@ class Evilution::Memory::LeakCheck
 
   private
 
+  def largest_step_kb
+    samples.each_cons(2).map { |before, after| after - before }.max
+  end
+
   def warmup(&block)
-    WARMUP_ITERATIONS.times { block.call }
+    @warmup_iterations.times { block.call }
     GC.start
     GC.compact if GC.respond_to?(:compact)
   end
@@ -74,10 +95,13 @@ class Evilution::Memory::LeakCheck
   end
 
   def result
+    sustained_kb = sustained_growth_kb
     {
       passed: passed?,
       growth_kb: growth_kb,
       growth_mb: growth_kb ? growth_kb / 1024.0 : nil,
+      sustained_growth_kb: sustained_kb,
+      sustained_growth_mb: sustained_kb ? sustained_kb / 1024.0 : nil,
       samples: samples,
       iterations: @iterations,
       max_growth_kb: @max_growth_kb,

data/lib/evilution/mutation.rb

@@ -8,26 +8,38 @@ class Evilution::Mutation
   Slice = Data.define(:original, :mutated)
   Location = Data.define(:file_path, :line, :column)
 
-  attr_reader :subject, :operator_name, :parse_status, :location
+  # What a mutation holds once its sources are released (see strip_sources!),
+  # and when it was built without a slice. Their fields read as nil, so the
+  # readers below need no nil check of their own.
+  STRIPPED_SOURCES = Sources.new(original: nil, mutated: nil)
+  NO_SLICE = Slice.new(original: nil, mutated: nil)
+  private_constant :STRIPPED_SOURCES, :NO_SLICE
+
+  # restore_source: the original file, evaluated after the mutation's tests
+  # to put back what applying it changed (see
+  # Mutator::Base#build_restore_source). nil when a mutation was built
+  # without one.
+  attr_reader :subject, :operator_name, :parse_status, :location, :restore_source
 
   def initialize(subject:, operator_name:, sources:, location:,
-                 slice: nil, parse_status: :ok, eval_source: nil)
+                 slice: nil, parse_status: :ok, eval_source: nil, restore_source: nil)
     @subject = subject
     @operator_name = operator_name
     @sources = sources
     @location = location
-    @slice = slice
+    @slice = slice || NO_SLICE
     @parse_status = parse_status
     @eval_source = eval_source
+    @restore_source = restore_source
     @diff = nil
   end
 
   def original_source
-    @sources&.original
+    @sources.original
   end
 
   def mutated_source
-    @sources&.mutated
+    @sources.mutated
   end
 
   # Source to feed to the load-time evaluator. Defaults to mutated_source
@@ -41,11 +53,11 @@ class Evilution::Mutation
   end
 
   def original_slice
-    @slice&.original
+    @slice.original
   end
 
   def mutated_slice
-    @slice&.mutated
+    @slice.mutated
   end
 
   def file_path
@@ -76,7 +88,7 @@ class Evilution::Mutation
 
   def strip_sources!
     diff # ensure diff is cached before clearing sources
-    @sources = nil
+    @sources = STRIPPED_SOURCES
   end
 
   def to_s
@@ -100,7 +112,7 @@ class Evilution::Mutation
   end
 
   def compute_unified_diff
-    return nil if @slice.nil?
+    return nil if @slice == NO_SLICE
 
     original_lines = @slice.original.lines
     mutated_lines = @slice.mutated.lines

data/lib/evilution/mutator/base.rb

@@ -4,6 +4,8 @@ require "prism"
 
 require_relative "../mutator"
 require_relative "primitives"
+require_relative "constant_value_subjects"
+require_relative "receiver_positions"
 require_relative "../integration/loading/body_call_neutralizer"
 require_relative "../ast/heredoc_span"
 
@@ -84,12 +86,12 @@ class Evilution::Mutator::Base < Prism::Visitor
       replacement_bytesize: replacement.bytesize
     )
 
-    mutation = build_mutation_record(node, surgery, slices)
+    mutation = build_mutation_record(node, surgery, slices, offset)
     @mutations << mutation
     mutation
   end
 
-  def build_mutation_record(node, surgery, slices)
+  def build_mutation_record(node, surgery, slices, offset)
     Evilution::Mutation.new(
       subject: @subject,
       operator_name: self.class.operator_name,
@@ -101,7 +103,8 @@ class Evilution::Mutator::Base < Prism::Visitor
         column: node.location.start_column
       ),
       parse_status: surgery.status,
-      eval_source: build_eval_source(surgery)
+      eval_source: build_eval_source(surgery, offset),
+      restore_source: build_restore_source(offset)
     )
   end
 
@@ -112,10 +115,47 @@ class Evilution::Mutator::Base < Prism::Visitor
   # them at apply time. Passing the subject's file path lets the neutralizer
   # skip files the parent never preloaded — those are lazy plugin files whose
   # DSL calls are still needed for the child fork's first-time load.
-  def build_eval_source(surgery)
+  # A scope or aasm subject's mutation sits inside a class-body declaration,
+  # which must run again for the mutated body to replace the loaded one, so
+  # that one declaration is kept.
+  def build_eval_source(surgery, offset)
     return surgery.source unless surgery.ok?
 
-    @body_call_neutralizer.call(surgery.source, file_path: @subject.file_path)
+    @body_call_neutralizer.call(surgery.source, file_path: @subject.file_path, **redeclaration(offset))
+  end
+
+  # The original file, evaluated after a mutation's tests to put back what
+  # the mutation changed. Without it an in-process run would leave the last
+  # mutation of a file applied while the files after it are mutated, failing
+  # their tests for them. Its class-body calls are neutralized like the eval
+  # source's; a scope, aasm or callback subject keeps its own declaration, so
+  # the mutated callable is declared over again as written.
+  def build_restore_source(offset)
+    return self.class.original_restore_source(@subject.file_path, @file_source, @body_call_neutralizer) unless redeclared_subject?
+
+    @body_call_neutralizer.call(@file_source, file_path: @subject.file_path, **redeclaration(offset))
+  end
+
+  # Subjects whose body is written inside a class-body declaration and only
+  # takes effect when that declaration runs again.
+  REDECLARED_KINDS = %i[scope aasm callback].freeze
+  private_constant :REDECLARED_KINDS
+
+  # So is anything written in a concern's hook block, a method included: the
+  # block has to run again on the classes that took the concern already.
+  def redeclared_subject?
+    REDECLARED_KINDS.include?(@subject.kind) || @subject.concern_hook?
+  end
+
+  # What the neutralizer needs to keep a redeclared subject's declaration:
+  # where the mutation is, and the lines the declaration takes up in the
+  # file as it was loaded -- which is where the callbacks it registered then
+  # say they come from, whatever the mutation does to its length.
+  def redeclaration(offset)
+    return {} unless redeclared_subject?
+
+    first = @subject.line_number
+    { keep_offset: offset, keep_lines: first..(first + @subject.source.count("\n")) }
   end
 
   NEWLINE_BYTE = 10
@@ -157,6 +197,15 @@ class Evilution::Mutator::Base < Prism::Visitor
               .downcase
   end
 
+  # The kinds of Subject the operator mutates. Operators work on method
+  # bodies, and on the bodies of callables handed to a scope, aasm or
+  # callback declaration, which run as part of the class's behaviour; one that also has
+  # something to say about a constant subject (a definition outside any
+  # method) adds :constant.
+  def self.subject_kinds
+    %i[method scope aasm callback]
+  end
+
   @parse_cache = {}
 
   def self.parsed_tree_for(file_path, file_source)
@@ -169,7 +218,22 @@ class Evilution::Mutator::Base < Prism::Visitor
     tree
   end
 
+  @restore_cache = {}
+
+  # The restore source of a subject with no declaration of its own to keep is
+  # the same for every mutation of the file: neutralized once and shared.
+  def self.original_restore_source(file_path, file_source, neutralizer)
+    cache = Evilution::Mutator::Base.instance_variable_get(:@restore_cache)
+    entry = cache[file_path]
+    return entry[:source] if entry && entry[:source_hash] == file_source.hash
+
+    source = neutralizer.call(file_source, file_path: file_path).freeze
+    cache[file_path] = { source_hash: file_source.hash, source: source }
+    source
+  end
+
   def self.clear_parse_cache!
     Evilution::Mutator::Base.instance_variable_set(:@parse_cache, {})
+    Evilution::Mutator::Base.instance_variable_set(:@restore_cache, {})
   end
 end

data/lib/evilution/mutator/constant_value_subjects.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative "../mutator"
+
+# Extended by the operators that mutate a value wherever it is written, so
+# that they also run on the value of a constant assignment: a literal in
+# `LIMIT = 10` or in `DEFAULTS = { size: 1 }` is as much a literal as one in
+# a method body.
+module Evilution::Mutator::ConstantValueSubjects
+  def subject_kinds
+    super + %i[constant_write]
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+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.
+#
+# A survivor means no example calls the method by its alias, so the alias is
+# a surface the suite never exercises — dead, or reached only where nothing
+# asserts.
+#
+# 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 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
+    @file_source = File.read(subject.file_path)
+    @mutations = []
+    @filter = filter
+
+    declarations_for(subject).each { |declaration| remove(declaration) }
+    @mutations
+  end
+
+  private
+
+  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)
+    return true if node.is_a?(Prism::AliasMethodNode)
+
+    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_order_permutation.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Swap neighbouring positional arguments: `compute(a, b)` becomes
+# `compute(b, a)`.
+#
+# A survivor means no example tells the two values apart — typically a test
+# whose fixtures are symmetric, so the method could take them in either order
+# unnoticed.
+#
+# Keyword arguments and a block argument stay where they are, and a splat
+# keeps its neighbours in place: it stands for an unknown number of
+# arguments, so a value swapped with it would not land where the original
+# stood. Identical neighbours are not swapped, since that would reproduce the
+# original call.
+class Evilution::Mutator::Operator::ArgumentOrderPermutation < Evilution::Mutator::Base
+  # `raise ArgumentError, "message"` reversed raises TypeError wherever it is
+  # reached, which only shows that the line ran.
+  RAISING_METHODS = %i[raise fail].freeze
+
+  # The format string swapped with a value raises TypeError the same way;
+  # what the string renders is FormatSpecifierSwap's job.
+  FORMAT_METHODS = %i[format sprintf printf].freeze
+
+  # Core methods that treat their arguments as an unordered set of
+  # alternatives, so any order gives the same answer.
+  ORDER_FREE_METHODS = %i[start_with? end_with?].freeze
+
+  # Arguments whose position does not map to a single value.
+  POSITIONLESS_TYPES = [Prism::SplatNode, Prism::ForwardingArgumentsNode].freeze
+
+  def visit_call_node(node)
+    swap_arguments(node) if swappable_call?(node)
+    super
+  end
+
+  def visit_super_node(node)
+    swap_arguments(node)
+    super
+  end
+
+  def visit_yield_node(node)
+    swap_arguments(node)
+    super
+  end
+
+  private
+
+  # The last argument of an index write is the value being stored, not a peer
+  # of the index.
+  def swappable_call?(node)
+    return false if node.name == :[]=
+    return false if ORDER_FREE_METHODS.include?(node.name)
+    return false if set_literal?(node)
+
+    !(node.receiver.nil? && (RAISING_METHODS.include?(node.name) || FORMAT_METHODS.include?(node.name)))
+  end
+
+  # `Set[a, b]` builds a set, where the order of elements does not count.
+  def set_literal?(node)
+    return false unless node.name == :[]
+
+    receiver = node.receiver
+    case receiver
+    when Prism::ConstantReadNode then receiver.name == :Set
+    when Prism::ConstantPathNode then receiver.parent.nil? && receiver.name == :Set
+    else false
+    end
+  end
+
+  def swap_arguments(node)
+    return if node.arguments.nil?
+
+    positionals = node.arguments.arguments.grep_v(Prism::KeywordHashNode)
+    positionals.each_cons(2) do |left, right|
+      emit_swap(node, left, right) if swappable_pair?(left, right)
+    end
+  end
+
+  def swappable_pair?(left, right)
+    return false if [left, right].any? { |argument| POSITIONLESS_TYPES.include?(argument.class) }
+
+    left.slice != right.slice
+  end
+
+  # Whatever separates the two arguments — the comma, line breaks, comments —
+  # stays between them, so the call keeps its layout.
+  def emit_swap(node, left, right)
+    start_offset = left.location.start_offset
+    end_offset = right.location.end_offset
+    separator = byteslice_source(left.location.end_offset, right.location.start_offset - left.location.end_offset)
+
+    add_mutation(
+      offset: start_offset,
+      length: end_offset - start_offset,
+      replacement: "#{right.slice}#{separator}#{left.slice}",
+      node: node
+    )
+  end
+end

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../operator"
+require_relative "../../ast/value_object_definition"
 
 class Evilution::Mutator::Operator::ArgumentRemoval < Evilution::Mutator::Base
   SKIP_TYPES = [
@@ -11,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
@@ -30,7 +31,14 @@ class Evilution::Mutator::Operator::ArgumentRemoval < Evilution::Mutator::Base
   end
 
   def mutable?(node, args)
-    args && args.length >= 2 && positional_only?(args) && node.name != :[]=
+    args.length >= 2 && positional_only?(args) && node.name != :[]= && !member_list?(node)
+  end
+
+  # DataStructMember owns the member list of `Data.define` / `Struct.new` and
+  # drops each member itself; removing an argument here would emit the same
+  # mutant a second time.
+  def member_list?(node)
+    Evilution::AST::ValueObjectDefinition.match?(node)
   end
 
   def positional_only?(args)

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