evilution 1.3.0 → 1.5.0

data/lib/evilution/mutator/receiver_positions.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require_relative "../mutator"
+
+# Visits every node that sends a message to a receiver, or defines
+# something on one, and hands that receiver to #receiver_found before the
+# receiver itself is visited.
+#
+# A plain call is one such node, but not the only one. An operator or
+# logical write on an attribute or an index (`a.b += c`, `a[b] ||= c`) and
+# an attribute or index target of a multiple assignment (`a.b, c[d] = e`)
+# each hold their receiver in a node of their own. An operator that treats
+# "the receiver of a call" specially — replacing it with `nil` only earns a
+# NoMethodError — has to mean all of them.
+#
+# A definition has a receiver too: the object a singleton method is defined
+# on (`def self.build`, `def helper.extra`) and the one a singleton class is
+# opened on (`class << self`). Replacing it does not change the method that
+# is already there — `def nil.build` defines another one, on `nil` — so the
+# mutant could never be killed.
+#
+# The includer defines #receiver_found(node). `node` is nil where the
+# message or the definition has no explicit receiver.
+module Evilution::Mutator::ReceiverPositions
+  def visit_call_node(node)
+    receiver_found(node.receiver)
+    super
+  end
+
+  def visit_call_operator_write_node(node)
+    receiver_found(node.receiver)
+    super
+  end
+
+  def visit_call_or_write_node(node)
+    receiver_found(node.receiver)
+    super
+  end
+
+  def visit_call_and_write_node(node)
+    receiver_found(node.receiver)
+    super
+  end
+
+  def visit_index_operator_write_node(node)
+    receiver_found(node.receiver)
+    super
+  end
+
+  def visit_index_or_write_node(node)
+    receiver_found(node.receiver)
+    super
+  end
+
+  def visit_index_and_write_node(node)
+    receiver_found(node.receiver)
+    super
+  end
+
+  def visit_call_target_node(node)
+    receiver_found(node.receiver)
+    super
+  end
+
+  def visit_index_target_node(node)
+    receiver_found(node.receiver)
+    super
+  end
+
+  def visit_def_node(node)
+    receiver_found(node.receiver)
+    super
+  end
+
+  def visit_singleton_class_node(node)
+    receiver_found(node.expression)
+    super
+  end
+end

data/lib/evilution/mutator/registry.rb

@@ -4,7 +4,10 @@ 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,
+    Evilution::Mutator::Operator::SafeNavigationInsertion
   ].freeze
 
   def self.for_profile(profile)
@@ -35,6 +38,8 @@ class Evilution::Mutator::Registry
       Evilution::Mutator::Operator::NilReplacement,
       Evilution::Mutator::Operator::IntegerLiteral,
       Evilution::Mutator::Operator::FloatLiteral,
+      Evilution::Mutator::Operator::ComplexLiteral,
+      Evilution::Mutator::Operator::RationalLiteral,
       Evilution::Mutator::Operator::StringLiteral,
       Evilution::Mutator::Operator::ArrayLiteral,
       Evilution::Mutator::Operator::HashLiteral,
@@ -136,7 +141,49 @@ 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::RoundHalfModeSwap,
+      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,
+      Evilution::Mutator::Operator::MemoizationBreak,
+      Evilution::Mutator::Operator::ShortCircuitToEager,
+      Evilution::Mutator::Operator::FreezeRemoval,
+      Evilution::Mutator::Operator::RescueClassWidening,
+      Evilution::Mutator::Operator::VisibilityRemoval,
+      Evilution::Mutator::Operator::AttrAccessorSwap,
+      Evilution::Mutator::Operator::SleepToZero,
+      Evilution::Mutator::Operator::IndexReceiverToSelf,
+      Evilution::Mutator::Operator::IndexToKeyPredicate,
+      Evilution::Mutator::Operator::IndexRangeToDrop,
+      Evilution::Mutator::Operator::IndexWriteToValue,
+      Evilution::Mutator::Operator::ConstantReadToNil,
+      Evilution::Mutator::Operator::ConstantNamespaceStrip,
+      Evilution::Mutator::Operator::ConstantWriteToNil,
+      Evilution::Mutator::Operator::VariableReadToNil,
+      Evilution::Mutator::Operator::OperatorWriteReceiverPromotion
     ].each { |op| registry.register(op) }
     registry
   end
@@ -152,11 +199,20 @@ 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
   end
 
+  # Whether any registered operator mutates subjects of this one's kind. A
+  # subject none does would only ever be listed with no mutations to its
+  # name.
+  def accepts?(subject)
+    @operators.any? { |operator_class| operator_class.subject_kinds.include?(subject.kind) }
+  end
+
   def operator_count
     @operators.length
   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/parallel/work_queue/channel/frame.rb

@@ -14,6 +14,10 @@ module Evilution::Parallel::WorkQueue::Channel::Frame
   # parent itself forked, transferred over a private pipe inside our process
   # tree. No external/untrusted input ever reaches this code. See
   # .rubocop.yml (Security/MarshalLoad) for the full rationale.
+  #
+  # Trusted is not the same as well-formed: a process the worker forked holds
+  # the pipe too. A frame of the announced length that does not load is a
+  # BadFrame; one shorter than announced is the end of the stream, nil.
   def decode(header, payload)
     return nil if header.nil? || header.bytesize < 4
 
@@ -21,5 +25,7 @@ module Evilution::Parallel::WorkQueue::Channel::Frame
     return nil if payload.nil? || payload.bytesize < length
 
     Marshal.load(payload)
+  rescue TypeError, ArgumentError => e
+    raise Evilution::Parallel::WorkQueue::Channel::BadFrame, "#{e.class}: #{e.message.gsub(/\s+/, " ")}"
   end
 end

data/lib/evilution/parallel/work_queue/channel.rb

@@ -1,8 +1,24 @@
 # frozen_string_literal: true
 
+require "io/wait"
 require_relative "../work_queue"
 
 module Evilution::Parallel::WorkQueue::Channel
+  # A frame that arrived but is not one the peer wrote: bytes that do not
+  # decode, or a frame that stops before the length its header announced.
+  #
+  # The pipes of the pool are inherited by the processes a worker forks, so
+  # the code under test can write into them. After such a frame the stream is
+  # out of step and nothing read from it later can be trusted; the reader
+  # gives the peer up. The end of the stream is not this: it reads as nil.
+  class BadFrame < StandardError; end
+
+  # Seconds a frame may take to arrive once its first byte has, header and
+  # payload together. A writer sends a frame in one call, so the rest follows
+  # at once; a header that announces bytes nobody will send must not hold the
+  # reader for ever.
+  FRAME_TIMEOUT = 10
+
   module_function
 
   def write(io, object)
@@ -10,14 +26,51 @@ module Evilution::Parallel::WorkQueue::Channel
     io.flush
   end
 
-  def read(io)
-    header = io.read(4)
-    return nil if header.nil? || header.bytesize < 4
+  # Waits for a frame without a limit, since an idle peer is no fault, and
+  # for the rest of one that has begun no longer than `frame_timeout`: one
+  # allowance for the whole frame.
+  def read(io, frame_timeout: FRAME_TIMEOUT)
+    io.wait_readable
+    allowance = Allowance.new(deadline: now + frame_timeout, seconds: frame_timeout)
+    header = read_exactly(io, 4, allowance)
+    return nil if header.bytesize < 4
 
-    length = header.unpack1("N")
-    payload = io.read(length)
+    payload = read_exactly(io, header.unpack1("N"), allowance)
     Frame.decode(header, payload)
   end
+
+  # What is left of the time a frame is given, and the figure it was given,
+  # which the message of a frame cut short names.
+  Allowance = Data.define(:deadline, :seconds)
+  private_constant :Allowance
+
+  # Up to `count` bytes: fewer only when the stream ended first.
+  def read_exactly(io, count, allowance)
+    buffer = String.new
+
+    while buffer.bytesize < count
+      chunk = io.read_nonblock(count - buffer.bytesize, exception: false)
+      return buffer if chunk.nil?
+
+      if chunk == :wait_readable
+        await(io, allowance, buffer.bytesize, count)
+      else
+        buffer << chunk
+      end
+    end
+    buffer
+  end
+
+  def await(io, allowance, arrived, count)
+    remaining = allowance.deadline - now
+    return if remaining.positive? && io.wait_readable(remaining)
+
+    raise BadFrame, "frame cut short: #{arrived} of #{count} bytes arrived within #{allowance.seconds}s"
+  end
+
+  def now
+    Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  end
 end
 
 require_relative "channel/frame"

data/lib/evilution/parallel/work_queue/dispatcher/reply.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "../dispatcher"
+require_relative "../channel"
+
+# Reads what a worker sent and says what it is: a result of an item the worker
+# holds, the end of its stream (nil), or something that cannot be trusted.
+#
+# The result pipe is inherited by the processes a worker forks, so a frame on
+# it is not always the worker's. One that does not decode is UNREADABLE, and
+# so is one that decodes to something other than a result: what a stray
+# process writes may happen to be a marshal dump, and taken at its word it
+# would move the Dispatcher's counters or be raised as the error of the run.
+# After either, the stream is out of step, and the Dispatcher gives the worker
+# up.
+#
+# Keeping the wire-level judgement here leaves the Dispatcher with what to do
+# about each answer.
+module Evilution::Parallel::WorkQueue::Dispatcher::Reply
+  UNREADABLE = Object.new.freeze
+
+  module_function
+
+  def from(worker)
+    message = worker.read_result
+    return nil if message.nil?
+
+    result_of?(worker, message) ? message : UNREADABLE
+  rescue Evilution::Parallel::WorkQueue::Channel::BadFrame
+    UNREADABLE
+  end
+
+  def result_of?(worker, message)
+    return false unless message.is_a?(Array) && message.length == 3
+
+    index, status, value = message
+    return false unless worker.in_flight_indices.include?(index)
+
+    status == :ok || (status == :error && value.is_a?(Exception))
+  end
+end

data/lib/evilution/parallel/work_queue/dispatcher.rb

@@ -74,8 +74,9 @@ class Evilution::Parallel::WorkQueue::Dispatcher
   end
 
   def handle(worker, io_to_worker, result_ios)
-    message = worker.read_result
+    message = Reply.from(worker)
     return handle_dead(worker, io_to_worker, result_ios) if message.nil?
+    return handle_unreadable(worker, io_to_worker, result_ios) if message.equal?(Reply::UNREADABLE)
 
     record(message, worker)
     return false if recycle_and_dispatch(worker, io_to_worker, result_ios)
@@ -96,6 +97,17 @@ class Evilution::Parallel::WorkQueue::Dispatcher
     @deadlines.refresh(worker)
   end
 
+  # After a frame that is not the worker's, nothing read from its pipe later
+  # can be trusted: the stream is out of step. The worker is given up the way
+  # a dead one is, after being killed, since it may well be alive. Only the
+  # items it held lose their result.
+  def handle_unreadable(worker, io_to_worker, result_ios)
+    worker.kill
+    mark_unfinished(worker, Evilution::Parallel::WorkQueue::UNREADABLE)
+    retire_or_replace(worker, io_to_worker, result_ios)
+    false
+  end
+
   # A worker that exited without replying loses only its in-flight item(s)
   # (marked :died) and is recycled; the run continues rather than aborting.
   def handle_dead(worker, io_to_worker, result_ios)
@@ -183,3 +195,4 @@ class Evilution::Parallel::WorkQueue::Dispatcher
 end
 
 require_relative "dispatcher/deadline_tracker"
+require_relative "dispatcher/reply"

data/lib/evilution/parallel/work_queue/worker/loop.rb

@@ -23,6 +23,11 @@ module Evilution::Parallel::WorkQueue::Worker::Loop
     Evilution::Parallel::WorkQueue::Channel.write(
       res_io, [Evilution::Parallel::WorkQueue::STATS, busy, wall]
     )
+  rescue Evilution::Parallel::WorkQueue::Channel::BadFrame
+    # A command that does not decode leaves a stream this worker cannot follow.
+    # It ends without the stats frame, which the parent, still waiting for a
+    # result, would take for one; the closed pipe tells the parent to replace it.
+    nil
   ensure
     cmd_io.close unless cmd_io.closed?
     res_io.close unless res_io.closed?

data/lib/evilution/parallel/work_queue/worker.rb

@@ -91,8 +91,8 @@ class Evilution::Parallel::WorkQueue::Worker
     @in_flight_indices << index
   end
 
-  def read_result
-    Evilution::Parallel::WorkQueue::Channel.read(@res_read)
+  def read_result(frame_timeout: Evilution::Parallel::WorkQueue::Channel::FRAME_TIMEOUT)
+    Evilution::Parallel::WorkQueue::Channel.read(@res_read, frame_timeout: frame_timeout)
   end
 
   def shutdown
@@ -138,16 +138,25 @@ class Evilution::Parallel::WorkQueue::Worker
 
   private
 
+  # The grace period covers the read as well as the wait for it: a stats frame
+  # that begins inside it and never completes must not outlast it.
   def drain_stats
     zero = Timing.new(busy: 0.0, wall: 0.0)
+    deadline = monotonic_now + Evilution::Parallel::WorkQueue::TIMING_GRACE_PERIOD
     return zero unless @res_read.wait_readable(Evilution::Parallel::WorkQueue::TIMING_GRACE_PERIOD)
 
-    message = read_result
-    return zero if message.nil?
+    message = read_result(frame_timeout: [deadline - monotonic_now, 0].max)
+    return zero unless message.is_a?(Array)
 
     tag, busy, wall = message
     return zero unless tag == Evilution::Parallel::WorkQueue::STATS
 
     Timing.new(busy: busy, wall: wall)
+  rescue Evilution::Parallel::WorkQueue::Channel::BadFrame
+    zero
+  end
+
+  def monotonic_now
+    Process.clock_gettime(Process::CLOCK_MONOTONIC)
   end
 end

data/lib/evilution/parallel/work_queue.rb

@@ -16,6 +16,7 @@ class Evilution::Parallel::WorkQueue
   Unfinished = Data.define(:reason)
   TIMED_OUT = Unfinished.new(reason: :timeout)
   DIED = Unfinished.new(reason: :died)
+  UNREADABLE = Unfinished.new(reason: :unreadable)
 
   def initialize(size:, hooks: nil, prefetch: 1, item_timeout: nil, worker_max_items: nil)
     Validators::PositiveInt.call!(:size, size)
@@ -80,17 +81,16 @@ class Evilution::Parallel::WorkQueue
     deadline = monotonic_now + TIMING_GRACE_PERIOD
 
     until io_to_worker.empty?
-      remaining = deadline - monotonic_now
-      break if remaining <= 0
-      break unless poll_and_apply(io_to_worker, remaining)
+      break if deadline - monotonic_now <= 0
+      break unless poll_and_apply(io_to_worker, deadline)
     end
   end
 
-  def poll_and_apply(io_to_worker, remaining)
-    readable, = IO.select(io_to_worker.keys, nil, nil, remaining)
+  def poll_and_apply(io_to_worker, deadline)
+    readable, = IO.select(io_to_worker.keys, nil, nil, deadline - monotonic_now)
     return false unless readable
 
-    readable.each { |io| apply_final_timing(io_to_worker.delete(io), io) }
+    readable.each { |io| apply_final_timing(io_to_worker.delete(io), io, deadline) }
     true
   end
 
@@ -98,15 +98,21 @@ class Evilution::Parallel::WorkQueue
     Process.clock_gettime(Process::CLOCK_MONOTONIC)
   end
 
-  def apply_final_timing(worker, io)
-    message = Evilution::Parallel::WorkQueue::Channel.read(io)
-    return if message.nil?
+  # The timings are a courtesy: a frame that cannot be read here costs the
+  # figures and nothing else. The read gets what is left of the grace period,
+  # so a frame that begins inside it and never completes does not outlast it.
+  def apply_final_timing(worker, io, deadline)
+    allowed = [deadline - monotonic_now, 0].max
+    message = Evilution::Parallel::WorkQueue::Channel.read(io, frame_timeout: allowed)
+    return unless message.is_a?(Array)
 
     tag, busy_time, wall_time = message
     return unless tag == STATS
 
     worker.busy_time = busy_time
     worker.wall_time = wall_time
+  rescue Evilution::Parallel::WorkQueue::Channel::BadFrame
+    nil
   end
 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"