evilution 1.3.0 → 1.4.0

data/lib/evilution/isolation/fork.rb

@@ -263,7 +263,8 @@ class Evilution::Isolation::Fork
         message: result[:error],
         klass: result[:error_class],
         backtrace: result[:error_backtrace]
-      )
+      ),
+      known_failures_only: result[:known_failures_only]
     )
   end
 end

data/lib/evilution/isolation/in_process.rb

@@ -9,6 +9,22 @@ require_relative "../result/mutation_result"
 require_relative "../isolation"
 
 class Evilution::Isolation::InProcess
+  # Raised into the run when its time is up. A SignalException, because the
+  # timeout has to end the whole test run and a test framework rescues nearly
+  # everything a test raises, Timeout::Error included: it would record one
+  # failed test and go on to the next, which may reach the same endless loop
+  # with no timer left to stop it. Minitest, Test::Unit and RSpec all let a
+  # SignalException through.
+  #
+  # Not an Interrupt, though it is one of those: tooling that handles the
+  # user's Ctrl-C (maxitest) rescues Interrupt and skips every test from then
+  # on, for the rest of the process.
+  class Expired < SignalException
+    def initialize(_message = nil)
+      super("SIGALRM")
+    end
+  end
+
   @null_out = File.open(File::NULL, "w")
   @null_err = File.open(File::NULL, "w")
 
@@ -33,7 +49,7 @@ class Evilution::Isolation::InProcess
   private
 
   # The Dir.chdir block is inside the Timeout.timeout block so that a
-  # Timeout::Error raised mid-call still unwinds through Dir.chdir's ensure
+  # timeout raised mid-call still unwinds through Dir.chdir's ensure
   # and restores the parent CWD before the rescue clause runs. The sandbox
   # contains any relative-path writes from path-relativizing mutations
   # (EV-wqxu / GH #1278). Evilution.with_isolated_worker signals the rest of
@@ -41,7 +57,7 @@ class Evilution::Isolation::InProcess
   # SourceEvaluator/Integration) to anchor project-relative paths to
   # PROJECT_ROOT for the duration of the call.
   def execute_with_timeout(mutation, test_command, timeout, sandbox_dir)
-    result = Timeout.timeout(timeout) do
+    result = Timeout.timeout(timeout, Expired) do
       Evilution.with_isolated_worker do
         Dir.chdir(sandbox_dir) do
           suppress_output { test_command.call(mutation) }
@@ -49,7 +65,7 @@ class Evilution::Isolation::InProcess
       end
     end
     { timeout: false }.merge(result)
-  rescue Timeout::Error
+  rescue Expired
     { timeout: true }
   rescue ScriptError, StandardError => e
     {
@@ -106,7 +122,8 @@ class Evilution::Isolation::InProcess
         message: result[:error],
         klass: result[:error_class],
         backtrace: result[:error_backtrace]
-      )
+      ),
+      known_failures_only: result[:known_failures_only]
     )
   end
 end

data/lib/evilution/mcp/info_tool/status_glossary.rb

@@ -32,8 +32,8 @@ module Evilution::MCP::InfoTool::StatusGlossary
     },
     {
       "status" => "neutral",
-      "meaning" => "Baseline tests already failed before the mutation was applied — pre-existing " \
-                   "test-suite problem (flaky spec, infra collision, fixture setup failure). " \
+      "meaning" => "No verdict: the tests failed only on examples that were already failing before " \
+                   "the mutation was applied, or the test process crashed on infrastructure. " \
                    "Not a meaningful mutation signal.",
       "counted_in_score" => false
     },

data/lib/evilution/mcp/mutate_tool/progress_streamer.rb

@@ -3,6 +3,7 @@
 require "json"
 require_relative "../mutate_tool"
 require_relative "../../reporter/suggestion"
+require_relative "../../diagnostic"
 
 module Evilution::MCP::MutateTool::ProgressStreamer
   def self.build(server_context:, suggest_tests:, integration:)
@@ -21,7 +22,7 @@ module Evilution::MCP::MutateTool::ProgressStreamer
         detail = build_suggestion_detail(result.mutation, suggestion)
         server_context.report_progress(survivor_index, message: ::JSON.generate(detail))
       rescue StandardError => e
-        warn "[evilution] progress stream disabled after error: #{e.class}: #{e.message}"
+        Evilution::Diagnostic.warn("[evilution] progress stream disabled after error: #{e.class}: #{e.message}")
         disabled = true
       end
     end

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,10 +8,14 @@ class Evilution::Mutation
   Slice = Data.define(:original, :mutated)
   Location = Data.define(:file_path, :line, :column)
 
-  attr_reader :subject, :operator_name, :parse_status, :location
+  # restore_source: the source that puts back what applying this mutation
+  # changed and re-evaluating another mutation of the file would not -- a
+  # scope declaration (see Mutator::Base#build_restore_source). nil when
+  # nothing needs restoring.
+  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
@@ -19,6 +23,7 @@ class Evilution::Mutation
     @slice = slice
     @parse_status = parse_status
     @eval_source = eval_source
+    @restore_source = restore_source
     @diff = nil
   end
 

data/lib/evilution/mutator/base.rb

@@ -84,12 +84,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 +101,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 +113,44 @@ 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
+
+  # Re-evaluating any mutation of a file redefines all its methods, which is
+  # how an in-process run puts a mutated method back. Class-body calls are
+  # neutralized in that source, so a mutated scope or aasm callable would stay
+  # installed; the original file with just that declaration kept replaces it
+  # again.
+  def build_restore_source(offset)
+    return nil 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
+
+  def redeclared_subject?
+    REDECLARED_KINDS.include?(@subject.kind)
+  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 +192,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)

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

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "../operator"
+
+# 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 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.
+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)
+    collector = DeclarationCollector.new
+    collector.visit(tree)
+
+    collector.declarations.filter_map do |declaration, scope|
+      declaration if first_method_line(scope) == subject.line_number
+    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
+
+    # 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
+  end
+end

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 = [
@@ -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 && 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/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/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 = node.arguments ? node.arguments.arguments : []
+    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