evilution 1.3.0 → 1.4.0

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

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Swap two adjacent commands: `charge(card); send_receipt(user)` becomes
+# `send_receipt(user); charge(card)`.
+#
+# A survivor means no example depends on the order the two side effects
+# happen in. Most pairs of statements could swap without anyone noticing, so
+# only pairs that are likely to matter are touched:
+#
+# - both statements are commands: they call a method, append, write an index,
+#   yield or call super. Assigning a local or instance variable stores a
+#   value, and statements without such effects swap freely.
+# - neither writes a variable the other reads or writes. Such a pair fails at
+#   once when swapped, which tests nothing about order.
+# - neither contains control flow (`return`, `break`, `next`, `redo`, `retry`,
+#   `raise`, `fail`), which would skip the other statement.
+# - the second is not the last statement of its body, which gives the body
+#   its value.
+# - neither contains a heredoc, whose body sits outside the statement's
+#   source range.
+# - they are not writes to different literal keys of the same receiver
+#   (`opts[:a] = 1; opts[:b] = 2`), which cannot affect each other.
+class Evilution::Mutator::Operator::StatementReorder < Evilution::Mutator::Base
+  CONTROL_FLOW_TYPES = [
+    Prism::ReturnNode, Prism::BreakNode, Prism::NextNode, Prism::RedoNode, Prism::RetryNode
+  ].freeze
+  RAISING_METHODS = %i[raise fail].freeze
+
+  # Calls that change their receiver without a method name: `a << b`, `a[k] = v`.
+  MUTATING_OPERATORS = %i[<< []=].freeze
+  METHOD_NAME = /\A[a-zA-Z_]/
+
+  EFFECT_TYPES = [Prism::YieldNode, Prism::SuperNode, Prism::ForwardingSuperNode].freeze
+
+  # Statements that store a value rather than act.
+  VALUE_WRITE_TYPES = [
+    Prism::LocalVariableWriteNode, Prism::LocalVariableOperatorWriteNode,
+    Prism::LocalVariableOrWriteNode, Prism::LocalVariableAndWriteNode,
+    Prism::InstanceVariableWriteNode, Prism::InstanceVariableOperatorWriteNode,
+    Prism::InstanceVariableOrWriteNode, Prism::InstanceVariableAndWriteNode
+  ].freeze
+
+  # Nodes that set a variable, and nodes that read one.
+  WRITE_TYPES = [
+    *VALUE_WRITE_TYPES, Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode,
+    Prism::ClassVariableWriteNode, Prism::ClassVariableOperatorWriteNode, Prism::ClassVariableOrWriteNode,
+    Prism::ClassVariableAndWriteNode, Prism::ClassVariableTargetNode,
+    Prism::GlobalVariableWriteNode, Prism::GlobalVariableOperatorWriteNode, Prism::GlobalVariableOrWriteNode,
+    Prism::GlobalVariableAndWriteNode, Prism::GlobalVariableTargetNode
+  ].freeze
+  LITERAL_KEY_TYPES = [Prism::SymbolNode, Prism::StringNode, Prism::IntegerNode].freeze
+
+  READ_TYPES = [
+    Prism::LocalVariableReadNode, Prism::InstanceVariableReadNode,
+    Prism::ClassVariableReadNode, Prism::GlobalVariableReadNode
+  ].freeze
+
+  def visit_statements_node(node)
+    statements = node.body
+    # The last statement stays put, so pairs end one before it.
+    statements[0...-1].each_cons(2) do |first, second|
+      emit_swap(first, second) if swappable?(first, second)
+    end
+    super
+  end
+
+  private
+
+  def swappable?(first, second)
+    [first, second].all? { |statement| command?(statement) && !control_flow?(statement) && !heredoc?(statement) } &&
+      independent?(first, second) && !distinct_key_writes?(first, second)
+  end
+
+  def command?(statement)
+    return false if VALUE_WRITE_TYPES.include?(statement.class)
+
+    nodes_in(statement).any? { |node| effect?(node) }
+  end
+
+  def effect?(node)
+    return true if EFFECT_TYPES.include?(node.class)
+    return false unless node.is_a?(Prism::CallNode)
+
+    node.name.to_s.match?(METHOD_NAME) || MUTATING_OPERATORS.include?(node.name)
+  end
+
+  def control_flow?(statement)
+    nodes_in(statement).any? do |node|
+      CONTROL_FLOW_TYPES.include?(node.class) ||
+        (node.is_a?(Prism::CallNode) && node.receiver.nil? && RAISING_METHODS.include?(node.name))
+    end
+  end
+
+  def heredoc?(statement)
+    nodes_in(statement).any? do |node|
+      node.respond_to?(:heredoc?) && node.heredoc?
+    end
+  end
+
+  def distinct_key_writes?(first, second)
+    writes = [index_write(first), index_write(second)]
+    return false if writes.include?(nil)
+    return false unless writes.first.receiver.slice == writes.last.receiver.slice
+
+    distinct_literal_keys?(writes.map { |write| write.arguments.arguments.first })
+  end
+
+  def distinct_literal_keys?(keys)
+    keys.all? { |key| LITERAL_KEY_TYPES.include?(key.class) } && keys.first.slice != keys.last.slice
+  end
+
+  # `h[k] = v` on its own or under a modifier condition (`h[k] = v if v`).
+  def index_write(statement)
+    if statement.is_a?(Prism::IfNode) || statement.is_a?(Prism::UnlessNode)
+      body = statement.statements
+      statement = body.body.first if body && body.body.length == 1
+    end
+    statement if statement.is_a?(Prism::CallNode) && statement.name == :[]=
+  end
+
+  def independent?(first, second)
+    first_writes = names(first, WRITE_TYPES)
+    second_writes = names(second, WRITE_TYPES)
+
+    !first_writes.intersect?(names(second, READ_TYPES) | second_writes) &&
+      !second_writes.intersect?(names(first, READ_TYPES))
+  end
+
+  def names(statement, types)
+    nodes_in(statement).filter_map { |node| node.name if types.include?(node.class) }.to_set
+  end
+
+  def nodes_in(node)
+    [node, *node.compact_child_nodes.flat_map { |child| nodes_in(child) }]
+  end
+
+  # Whatever separates the two statements — a line break and indentation, or
+  # `; ` — stays between them.
+  def emit_swap(first, second)
+    start_offset = first.location.start_offset
+    end_offset = second.location.end_offset
+    separator = byteslice_source(first.location.end_offset, second.location.start_offset - first.location.end_offset)
+
+    add_mutation(
+      offset: start_offset,
+      length: end_offset - start_offset,
+      replacement: "#{second.slice}#{separator}#{first.slice}",
+      node: first
+    )
+  end
+end

data/lib/evilution/mutator/registry.rb

@@ -4,7 +4,9 @@ require_relative "../mutator"
 
 class Evilution::Mutator::Registry
   STRICT_EXTRA_OPERATORS = [
-    Evilution::Mutator::Operator::PredicateToNil
+    Evilution::Mutator::Operator::PredicateToNil,
+    Evilution::Mutator::Operator::ExceptionSwallow,
+    Evilution::Mutator::Operator::StatementReorder
   ].freeze
 
   def self.for_profile(profile)
@@ -136,7 +138,32 @@ class Evilution::Mutator::Registry
       Evilution::Mutator::Operator::ReceiverConstructorSwap,
       Evilution::Mutator::Operator::BlockBodyToNil,
       Evilution::Mutator::Operator::BlockBodyToRaise,
-      Evilution::Mutator::Operator::BlockBodyPromotion
+      Evilution::Mutator::Operator::BlockBodyPromotion,
+      Evilution::Mutator::Operator::DataStructMember,
+      Evilution::Mutator::Operator::PinOperatorRemoval,
+      Evilution::Mutator::Operator::RightwardAssignment,
+      Evilution::Mutator::Operator::NumberedParameterSwap,
+      Evilution::Mutator::Operator::ForwardedArgumentDrop,
+      Evilution::Mutator::Operator::PatternWildcardWidening,
+      Evilution::Mutator::Operator::NoMatchingPatternElse,
+      Evilution::Mutator::Operator::ArgumentOrderPermutation,
+      Evilution::Mutator::Operator::KeywordValueSwap,
+      Evilution::Mutator::Operator::ComparisonOperandSwap,
+      Evilution::Mutator::Operator::IntegerDivisionToFdiv,
+      Evilution::Mutator::Operator::OffByOneBoundary,
+      Evilution::Mutator::Operator::FormatSpecifierSwap,
+      Evilution::Mutator::Operator::AliasRemoval,
+      Evilution::Mutator::Operator::RegexpCharacterTypeComplement,
+      Evilution::Mutator::Operator::RegexpAnchorPromotion,
+      Evilution::Mutator::Operator::RegexpAlternationBranchDeletion,
+      Evilution::Mutator::Operator::RegexpQuantifierMinimumSwap,
+      Evilution::Mutator::Operator::RegexpCaptureToPassive,
+      Evilution::Mutator::Operator::RegexpNamedGroupRename,
+      Evilution::Mutator::Operator::RegexpOptionRemoval,
+      Evilution::Mutator::Operator::RescueHandlerPromotion,
+      Evilution::Mutator::Operator::RescueHandlerConcatenation,
+      Evilution::Mutator::Operator::RescueElseConcatenation,
+      Evilution::Mutator::Operator::ReturnKeywordRemoval
     ].each { |op| registry.register(op) }
     registry
   end
@@ -152,6 +179,8 @@ class Evilution::Mutator::Registry
 
   def mutations_for(subject, filter: nil, operator_options: {})
     @operators.flat_map do |operator_class|
+      next [] unless operator_class.subject_kinds.include?(subject.kind)
+
       operator = build_operator(operator_class, operator_options)
       operator.call(subject, filter: filter)
     end

data/lib/evilution/mutator/rescue_handlers.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "../mutator"
+require_relative "../ast/local_reads"
+
+# The rescue clauses of a `begin` (or of a method or block body with a rescue),
+# and the rule for which of their handlers can run outside the rescue.
+#
+# Operators that move a handler — promoting it over the body, or running it
+# after the body as well — share the rule: a handler that reads the rescued
+# exception (its `=> e` variable or `$!` / `$@`), re-raises it with a bare
+# `raise` / `fail`, or retries only makes sense inside the rescue, and moved
+# out it would fail for that reason alone.
+class Evilution::Mutator::RescueHandlers
+  EXCEPTION_GLOBALS = %i[$! $@].freeze
+  RERAISING_METHODS = %i[raise fail].freeze
+
+  attr_reader :clauses
+
+  def initialize(begin_node)
+    @clauses = []
+    clause = begin_node.rescue_clause
+    while clause
+      @clauses << clause
+      clause = clause.subsequent
+    end
+  end
+
+  # Whether a handler can run outside its rescue. A missing handler (an empty
+  # rescue clause) can.
+  def self.movable?(handler, reference)
+    return true if handler.nil?
+
+    !reads_exception?(handler, reference) && !rescue_only?(handler)
+  end
+
+  # Binding the exception to anything but a local (`=> @error`) leaves it set
+  # for code after the rescue, which the handler alone cannot speak for, so
+  # such a handler counts as reading it. An underscore name announces a binding
+  # that is not read.
+  def self.reads_exception?(handler, reference)
+    return true if nodes_in(handler).any? { |node| exception_global?(node) }
+    return false if reference.nil?
+    return true unless reference.is_a?(Prism::LocalVariableTargetNode)
+
+    name = reference.name.to_s
+    !name.start_with?("_") && Evilution::AST::LocalReads.new.call(handler, name)
+  end
+
+  def self.exception_global?(node)
+    node.is_a?(Prism::GlobalVariableReadNode) && EXCEPTION_GLOBALS.include?(node.name)
+  end
+
+  def self.rescue_only?(handler)
+    nodes_in(handler).any? do |node|
+      node.is_a?(Prism::RetryNode) ||
+        (node.is_a?(Prism::CallNode) && node.receiver.nil? && RERAISING_METHODS.include?(node.name) &&
+          node.arguments.nil?)
+    end
+  end
+
+  # What goes between the last statement of a body and code appended after
+  # it: a new line at that statement's indentation, or `; ` when the body
+  # does not end its line (`begin; a; rescue ...`).
+  def self.continuation(source, statements)
+    end_offset = statements.location.end_offset
+    return "; " unless source.byteslice(end_offset, 1) == "\n"
+
+    start_offset = statements.body.last.location.start_offset
+    line_start = (source.byterindex("\n", start_offset - 1) || -1) + 1
+    "\n#{source.byteslice(line_start, start_offset - line_start)}"
+  end
+
+  def self.nodes_in(node)
+    [node, *node.compact_child_nodes.flat_map { |child| nodes_in(child) }]
+  end
+
+  private_class_method :reads_exception?, :exception_global?, :rescue_only?, :nodes_in
+end

data/lib/evilution/process_supervisor.rb

@@ -3,6 +3,7 @@
 require "fileutils"
 require_relative "version"
 require_relative "temp_dir_tracker"
+require_relative "diagnostic"
 
 # Single owner of the process-lifecycle invariant: every pid spawned here is
 # group-isolated, tracked in a signal-safe registry, group-signalled through a
@@ -219,8 +220,8 @@ class Evilution::ProcessSupervisor
     # group: a later group-kill won't sweep its subtree. Don't raise (spawn
     # must still return a usable handle), but surface it so the leak is
     # debuggable rather than silent.
-    warn "evilution: could not isolate process #{pid} into its own process " \
-         "group (#{e.class}: #{e.message}); grandchildren may survive a kill."
+    Evilution::Diagnostic.warn("evilution: could not isolate process #{pid} into its own process " \
+                               "group (#{e.class}: #{e.message}); grandchildren may survive a kill.")
   end
 
   # True once the child has been reaped (now or earlier). WNOHANG returns the

data/lib/evilution/reporter/cli/line_formatters/baseline_neutralized_notice.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative "../line_formatters"
+require_relative "../../../baseline"
+
+# An example that was failing before any mutation ran fails in every mutation
+# run it takes part in. Where nothing else failed, that failure is not a kill:
+# the mutation is recorded neutral and drops out of the score. Left unsaid, a
+# red spec file would read as full marks, so the score never goes out without
+# saying how many kills were not counted, for which spec file, and why it was
+# red.
+class Evilution::Reporter::CLI::LineFormatters::BaselineNeutralizedNotice
+  DETAIL_INDENT = "    "
+
+  def initialize(failure_formatter: Evilution::Baseline::FailureFormatter.new)
+    @failure_formatter = failure_formatter
+  end
+
+  def format(summary)
+    neutralizations = summary.baseline_neutralizations
+    return nil if neutralizations.empty?
+
+    neutralizations.flat_map { |neutralization| [headline(neutralization), *detail(neutralization)] }.join("\n")
+  end
+
+  private
+
+  def headline(neutralization)
+    count = neutralization.count
+    subject = count == 1 ? "1 kill" : "#{count} kills"
+    verdict = count == 1 ? "that mutation has no verdict" : "those mutations have no verdict"
+    "! #{subject} not counted#{spec_files(neutralization)}: only examples already failing in the baseline " \
+      "failed, so #{verdict}."
+  end
+
+  def spec_files(neutralization)
+    names = neutralization.spec_file ? [neutralization.spec_file] : neutralization.failures.map(&:spec_file)
+    names.empty? ? "" : " for #{names.join(", ")}"
+  end
+
+  # One spec file's detail sits straight under the headline that names it;
+  # several are each put under their own name.
+  def detail(neutralization)
+    failures = neutralization.failures
+    return failure_lines(failures.first, DETAIL_INDENT) if failures.length == 1
+
+    failures.flat_map do |failure|
+      ["#{DETAIL_INDENT}#{failure.spec_file}:", *failure_lines(failure, "#{DETAIL_INDENT}  ")]
+    end
+  end
+
+  def failure_lines(failure, indent)
+    @failure_formatter.call(failure).map { |line| "#{indent}#{line}" }
+  end
+end

data/lib/evilution/reporter/cli/metrics_block.rb

@@ -3,6 +3,7 @@
 require_relative "../cli"
 require_relative "line_formatters/mutations"
 require_relative "line_formatters/score"
+require_relative "line_formatters/baseline_neutralized_notice"
 require_relative "line_formatters/error_rate_warning"
 require_relative "line_formatters/unresolved_rate_warning"
 require_relative "line_formatters/unresolved_targets"
@@ -15,6 +16,7 @@ class Evilution::Reporter::CLI::MetricsBlock
   DEFAULT_LINES = [
     Evilution::Reporter::CLI::LineFormatters::Mutations.new,
     Evilution::Reporter::CLI::LineFormatters::Score.new,
+    Evilution::Reporter::CLI::LineFormatters::BaselineNeutralizedNotice.new,
     Evilution::Reporter::CLI::LineFormatters::ErrorRateWarning.new,
     Evilution::Reporter::CLI::LineFormatters::UnresolvedRateWarning.new,
     Evilution::Reporter::CLI::LineFormatters::UnresolvedTargets.new,

data/lib/evilution/reporter/json/baseline.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "../json"
+
+# The summary fields that speak for a red baseline: the kills it took out of
+# the score because only examples that were already failing failed, and why
+# each spec file was red. Each is present only when there is something to say.
+class Evilution::Reporter::JSON::Baseline
+  def call(summary)
+    fields = {}
+    fields[:baseline_neutralized] = summary.baseline_neutralized if summary.baseline_neutralized.positive?
+    fields[:baseline_failures] = summary.baseline_failures.map(&:to_h) unless summary.baseline_failures.empty?
+    fields
+  end
+end

data/lib/evilution/reporter/json.rb

@@ -8,9 +8,10 @@ require_relative "../reporter"
 require_relative "../session/schema"
 
 class Evilution::Reporter::JSON
-  def initialize(suggest_tests: false, integration: :rspec, subjects: Subjects.new)
+  def initialize(suggest_tests: false, integration: :rspec, subjects: Subjects.new, baseline: Baseline.new)
     @suggestion = Evilution::Reporter::Suggestion.new(suggest_tests: suggest_tests, integration: integration)
     @subjects = subjects
+    @baseline = baseline
   end
 
   def call(summary)
@@ -104,10 +105,13 @@ class Evilution::Reporter::JSON
   end
 
   # What the run had to say about itself rather than about the mutations: a
-  # target that was never tested, work that had to be redone serially.
+  # target that was never tested, work that had to be redone serially,
+  # survivors a red baseline took out of the score.
   def append_diagnostic_summary_fields(data, summary)
     data[:unresolved_target_files] = summary.unresolved_target_files if summary.unresolved_targets?
     data[:infra_retried] = summary.infra_retried if summary.infra_retried.positive?
+    data[:uncovered_code] = summary.uncovered_code if summary.uncovered_code?
+    data.merge!(@baseline.call(summary))
   end
 
   def build_mutation_detail(result)
@@ -183,3 +187,4 @@ class Evilution::Reporter::JSON
 end
 
 require_relative "json/subjects"
+require_relative "json/baseline"

data/lib/evilution/result/baseline_neutralization.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative "../result"
+
+# The kills one red spec file left uncounted -- mutations whose tests failed
+# on nothing but examples that were already failing -- with why it was red.
+#
+# spec_file is nil when no single red file can be named, as in a run given
+# its spec files explicitly; failures then holds all of them.
+Evilution::Result::BaselineNeutralization = Data.define(:spec_file, :count, :failures)

data/lib/evilution/result/mutation_result.rb

@@ -9,8 +9,11 @@ class Evilution::Result::MutationResult
 
   attr_reader :mutation, :status, :duration, :killing_test, :test_command, :memory, :error, :neutral_reason
 
+  # known_failures_only: the tests failed, but every example that did was
+  # already failing before any mutation ran, so the failure says nothing
+  # about this one.
   def initialize(mutation:, status:, duration: 0.0, killing_test: nil,
-                 test_command: nil, memory: nil, error: nil, neutral_reason: nil)
+                 test_command: nil, memory: nil, error: nil, neutral_reason: nil, known_failures_only: false)
     raise ArgumentError, "invalid status: #{status}" unless STATUSES.include?(status)
 
     @mutation = mutation
@@ -21,6 +24,7 @@ class Evilution::Result::MutationResult
     @memory = memory
     @error = error
     @neutral_reason = neutral_reason
+    @known_failures_only = known_failures_only == true
     freeze
   end
 
@@ -54,6 +58,10 @@ class Evilution::Result::MutationResult
     @error.is_a?(Evilution::Result::ErrorInfo) ? @error.backtrace : nil
   end
 
+  def known_failures_only?
+    @known_failures_only
+  end
+
   def killed?
     status == :killed
   end

data/lib/evilution/result/summary.rb

@@ -3,13 +3,15 @@
 require_relative "../result"
 require_relative "coverage_gap_grouper"
 require_relative "subject_scorer"
+require_relative "baseline_neutralization"
 
 class Evilution::Result::Summary
   attr_reader :results, :duration, :skipped, :disabled_mutations, :unresolved_target_files,
-              :target_file_count, :infra_retried
+              :target_file_count, :infra_retried, :uncovered_code, :baseline_failures
 
   def initialize(results:, duration: 0.0, truncated: false, skipped: 0, disabled_mutations: [],
-                 unresolved_target_files: [], target_file_count: nil, infra_retried: 0)
+                 unresolved_target_files: [], target_file_count: nil, infra_retried: 0, uncovered_code: [],
+                 baseline_failures: [])
     @results = results
     @duration = duration
     @truncated = truncated
@@ -18,9 +20,27 @@ class Evilution::Result::Summary
     @unresolved_target_files = unresolved_target_files.freeze
     @target_file_count = target_file_count
     @infra_retried = infra_retried
+    @uncovered_code = uncovered_code.freeze
+    @baseline_failures = baseline_failures.freeze
     freeze
   end
 
+  # The kills not counted because only examples already failing in the
+  # baseline failed, gathered under the spec file that was red and paired with
+  # why it was. They are out of the score, so a red spec file would read as
+  # full marks unless the report says they are there.
+  def baseline_neutralizations
+    baseline_neutralized_results.group_by { |result| result.neutral_reason.detail }.map do |spec_file, results|
+      Evilution::Result::BaselineNeutralization.new(
+        spec_file: spec_file, count: results.length, failures: baseline_failures_for(spec_file)
+      )
+    end
+  end
+
+  def baseline_neutralized
+    baseline_neutralized_results.length
+  end
+
   # Neutral results gathered by the reason they were recorded, which is what the
   # report needs to say which kind of neutral a reader is looking at
   # (EV-5pob / GH #1606).
@@ -53,6 +73,12 @@ class Evilution::Result::Summary
     !unresolved_target_files.empty?
   end
 
+  # Targeted lines that hold code outside every subject, so no mutation was
+  # ever generated for them: `{ file:, lines: ["2-4", "9"] }` per file.
+  def uncovered_code?
+    !uncovered_code.empty?
+  end
+
   def truncated?
     @truncated
   end
@@ -167,4 +193,18 @@ class Evilution::Result::Summary
 
     max_rss && (max_rss / 1024.0)
   end
+
+  private
+
+  def baseline_neutralized_results
+    neutral_results.select { |result| result.neutral_reason && result.neutral_reason.kind == :baseline_failure }
+  end
+
+  # No spec file named means the run was given its spec files explicitly, and
+  # any of them being red neutralizes the survivor.
+  def baseline_failures_for(spec_file)
+    return baseline_failures if spec_file.nil?
+
+    baseline_failures.select { |failure| failure.spec_file == spec_file }
+  end
 end

data/lib/evilution/runner/baseline_runner.rb

@@ -12,6 +12,7 @@ require_relative "../integration/test_unit"
 require_relative "../example_filter"
 require_relative "../spec_ast_cache"
 require_relative "../source_ast_cache"
+require_relative "../diagnostic"
 
 unless defined?(Evilution::Runner::INTEGRATIONS)
   Evilution::Runner::INTEGRATIONS = {
@@ -33,15 +34,19 @@ class Evilution::Runner::BaselineRunner
     end
   end
 
-  def build_integration
+  # baseline_result: what the baseline found, when it ran. The tests it saw
+  # failing are handed to the integration, which can then tell a mutation run
+  # that fails on nothing else from one that kills.
+  def build_integration(baseline_result = nil)
     klass = integration_class
-    kwargs = base_integration_kwargs
+    kwargs = base_integration_kwargs(baseline_result)
     kwargs.merge!(rspec_integration_kwargs) if klass == Evilution::Integration::RSpec
     klass.new(**kwargs)
   end
 
-  def base_integration_kwargs
+  def base_integration_kwargs(baseline_result = nil)
     {
+      known_failures: baseline_result ? baseline_result.failed_example_ids : [],
       test_files: config.spec_files.empty? ? nil : config.spec_files,
       hooks: hooks,
       fallback_to_full_suite: config.fallback_to_full_suite?,
@@ -119,7 +124,7 @@ class Evilution::Runner::BaselineRunner
 
     Evilution::CoverageExampleFilter.new(map: map, lexical: lexical)
   rescue StandardError => e
-    warn "evilution: coverage targeting unavailable (#{e.class}: #{e.message}); using lexical targeting"
+    Evilution::Diagnostic.warn("evilution: coverage targeting unavailable (#{e.class}: #{e.message}); using lexical targeting")
     lexical
   end
 

data/lib/evilution/runner/canary.rb

@@ -6,6 +6,7 @@ require "securerandom"
 require_relative "../runner"
 require_relative "../mutation"
 require_relative "../subject"
+require_relative "canary_failure_message"
 
 # Runs one guaranteed-unobservable synthetic mutation through the configured
 # integration + isolation at session start. The synthetic spec never references
@@ -34,7 +35,7 @@ class Evilution::Runner::Canary
       test_command: ->(mutation) { build_integration(spec_path).call(mutation) },
       timeout: @config.timeout
     )
-    raise Failed, failure_message(result) unless result.status == :survived
+    raise Failed, Evilution::Runner::CanaryFailureMessage.new(result).to_s unless result.status == :survived
 
     nil
   ensure
@@ -145,60 +146,4 @@ class Evilution::Runner::Canary
   def build_integration(spec_path)
     @integration_class.new(test_files: [spec_path], hooks: @hooks)
   end
-
-  # When the child reported an error, that error IS the diagnosis -- naming it
-  # beats guessing. The speculative list stays only for the cases that carry no
-  # error at all (:killed, :timeout), where guesses are the only help there is.
-  # Diagnosing GH #1581 meant rebuilding this canary by hand to read the field
-  # this message used to drop, and none of the four guesses was the cause.
-  # EV-65nf / GH #1586.
-  def failure_message(result)
-    "#{failure_preamble(result.status)} #{diagnosis(result)} " \
-      "Re-run with --no-canary to bypass this check."
-  end
-
-  def failure_preamble(status)
-    "evilution proof-of-life canary failed: a guaranteed-unobservable synthetic " \
-      "mutation was scored #{status.inspect} instead of :survived. The mutation " \
-      "pipeline is misreporting — every score this run would produce is unreliable."
-  end
-
-  def diagnosis(result)
-    reported = reported_error(result)
-    return speculative_causes if reported.nil?
-
-    "The child reported: #{reported}"
-  end
-
-  def reported_error(result)
-    message = result.error_message
-    return nil if message.nil? || message.empty?
-
-    described = with_class_prefix(message, result.error_class)
-    frame = first_frame(result)
-    frame.nil? ? described : "#{described} (at #{frame})"
-  end
-
-  # MutationApplier already prefixes the class onto the message it packs
-  # ("#{e.class}: #{e.message}"), while other paths pack the bare message and
-  # leave the class in its own field. Prefixing unconditionally would print
-  # "NameError: NameError: ..." for the former.
-  def with_class_prefix(message, klass)
-    return message if klass.nil? || klass.empty? || message.start_with?("#{klass}:")
-
-    "#{klass}: #{message}"
-  end
-
-  def first_frame(result)
-    backtrace = result.error_backtrace
-    return nil if backtrace.nil? || backtrace.empty?
-
-    backtrace.first
-  end
-
-  def speculative_causes
-    "Likely causes: Rails/Zeitwerk autoloading breaking child eval; an env-specific " \
-      "RSpec config (e.g. fail_if_no_examples); a classify_status fallback defect; or " \
-      "an isolation-mode defect."
-  end
 end