evilution 1.2.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/operator/symbol_to_proc_replacement.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+require_relative "send_mutation"
+require_relative "collection_replacement"
+
+# Apply the call-site selector tables to a symbol block-pass: `map(&:to_s)`
+# becomes `map(&:to_i)`, `map(&:first)` becomes `map(&:last)`.
+#
+# send_mutation and collection_replacement only see explicit calls, so a
+# selector passed as `&:sym` was never swapped — only removed. This reads
+# both tables live, so selectors added to them apply here too.
+#
+# Replacements that are Ruby aliases of the original (`collect` / `map`,
+# `find` / `detect`, `select` / `filter`, `length` / `size` / `count`) are
+# skipped: on the receivers these selectors are normally mapped over, the
+# mutant behaves identically.
+class Evilution::Mutator::Operator::SymbolToProcReplacement < Evilution::Mutator::Base
+  TABLES = [
+    Evilution::Mutator::Operator::SendMutation::REPLACEMENTS,
+    Evilution::Mutator::Operator::CollectionReplacement::REPLACEMENTS
+  ].freeze
+  private_constant :TABLES
+
+  ALIAS_GROUPS = [
+    %i[map collect],
+    %i[find detect],
+    %i[select filter],
+    %i[length size count]
+  ].freeze
+  private_constant :ALIAS_GROUPS
+
+  def visit_block_argument_node(node)
+    symbol = node.expression
+    replace_selector(node, symbol) if symbol.is_a?(Prism::SymbolNode)
+    super
+  end
+
+  private
+
+  def replace_selector(node, symbol)
+    selector = symbol.unescaped.to_sym
+    location = symbol.value_loc
+
+    replacements_for(selector).each do |replacement|
+      add_mutation(
+        offset: location.start_offset,
+        length: location.length,
+        replacement: replacement.to_s,
+        node: node
+      )
+    end
+  end
+
+  def replacements_for(selector)
+    aliases = ALIAS_GROUPS.find { |group| group.include?(selector) } || []
+    TABLES.flat_map { |table| table.fetch(selector, []) }.uniq - aliases
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Replace a lenient `to_i` with the strict `Integer()` conversion:
+# `value.to_i` becomes `Integer(value)`, `value.to_i(16)` becomes
+# `Integer(value, 16)`.
+#
+# `to_i` never fails — malformed input ("abc", "12abc", "") and nil become 0
+# or a leading-digits prefix — where `Integer()` raises. `Integer()` also
+# honours radix prefixes ("0x1A" is 26, "012" is octal 10) that `to_i`
+# ignores. A survivor means no test feeds invalid or prefixed input.
+#
+# Numeric literal receivers are skipped: both conversions agree on them.
+class Evilution::Mutator::Operator::ToIToInteger < Evilution::Mutator::Base
+  NUMERIC_LITERALS = [Prism::IntegerNode, Prism::FloatNode, Prism::RationalNode, Prism::ImaginaryNode].freeze
+  private_constant :NUMERIC_LITERALS
+
+  def visit_call_node(node)
+    rewrite(node) if node.name == :to_i && convertible?(node)
+    super
+  end
+
+  private
+
+  def convertible?(node)
+    receiver = node.receiver
+    receiver && node.block.nil? && NUMERIC_LITERALS.none? { |type| receiver.is_a?(type) }
+  end
+
+  def rewrite(node)
+    arguments = node.arguments ? node.arguments.arguments : []
+    return if arguments.length > 1 || arguments.any?(Prism::SplatNode)
+
+    parts = [node.receiver, *arguments].map { |part| source_of(part) }
+    replace_span(node: node, target: node, replacement: "Integer(#{parts.join(", ")})")
+  end
+end

data/lib/evilution/mutator/primitives.rb

@@ -49,4 +49,29 @@ module Evilution::Mutator::Primitives
     location = child.location
     byteslice_source(location.start_offset, location.length)
   end
+
+  # `operand`'s source, parenthesized unless it is a primary expression — so
+  # it can take a method call: `a + b` becomes `(a + b)` in `(a + b).eql?(c)`.
+  def receiver_source(operand)
+    primary_operand?(operand) ? source_of(operand) : "(#{source_of(operand)})"
+  end
+
+  PRIMARY_OPERANDS = [
+    Prism::LocalVariableReadNode, Prism::InstanceVariableReadNode, Prism::ClassVariableReadNode,
+    Prism::GlobalVariableReadNode, Prism::ConstantReadNode, Prism::ConstantPathNode, Prism::SelfNode,
+    Prism::ParenthesesNode, Prism::StringNode, Prism::IntegerNode, Prism::FloatNode, Prism::ArrayNode,
+    Prism::RegularExpressionNode
+  ].freeze
+  private_constant :PRIMARY_OPERANDS
+
+  METHOD_NAME = /\A[[:alpha:]_]/
+  private_constant :METHOD_NAME
+
+  # A named method call or an index (`a.size`, `a[0]`) binds tighter than a
+  # following `.`; an operator send (`a + b`, `!a`, `-a`) does not.
+  def primary_operand?(operand)
+    return true if PRIMARY_OPERANDS.any? { |type| operand.is_a?(type) }
+
+    operand.is_a?(Prism::CallNode) && (operand.name.match?(METHOD_NAME) || operand.name == :[])
+  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)
@@ -113,7 +115,55 @@ class Evilution::Mutator::Registry
       Evilution::Mutator::Operator::EqualityToIdentity,
       Evilution::Mutator::Operator::LambdaBody,
       Evilution::Mutator::Operator::BeginUnwrap,
-      Evilution::Mutator::Operator::BlockParamRemoval
+      Evilution::Mutator::Operator::BlockParamRemoval,
+      Evilution::Mutator::Operator::CallToNil,
+      Evilution::Mutator::Operator::SafeNavigationRemoval,
+      Evilution::Mutator::Operator::AttributeWriteToRead,
+      Evilution::Mutator::Operator::ArgumentPropagation,
+      Evilution::Mutator::Operator::ArgumentListRemoval,
+      Evilution::Mutator::Operator::SymbolToProcReplacement,
+      Evilution::Mutator::Operator::DynamicDispatchResolution,
+      Evilution::Mutator::Operator::KeywordArgumentRemoval,
+      Evilution::Mutator::Operator::DoubleNegationRemoval,
+      Evilution::Mutator::Operator::RegexpAnchorToPredicate,
+      Evilution::Mutator::Operator::ReduceToSum,
+      Evilution::Mutator::Operator::ArrayCoercionToLiteral,
+      Evilution::Mutator::Operator::ToIToInteger,
+      Evilution::Mutator::Operator::CoercionEmptying,
+      Evilution::Mutator::Operator::ConstGetToConstantPath,
+      Evilution::Mutator::Operator::ProcToLambda,
+      Evilution::Mutator::Operator::DigToFetchChain,
+      Evilution::Mutator::Operator::InequalityToNegatedIdentity,
+      Evilution::Mutator::Operator::BinaryOperandPromotion,
+      Evilution::Mutator::Operator::ReceiverConstructorSwap,
+      Evilution::Mutator::Operator::BlockBodyToNil,
+      Evilution::Mutator::Operator::BlockBodyToRaise,
+      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
@@ -129,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/parallel/pool.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "../parallel"
 require_relative "work_queue"
 
 class Evilution::Parallel::Pool

data/lib/evilution/parallel_db_warning.rb

@@ -2,7 +2,7 @@
 
 require "erb"
 require "yaml"
-require_relative "../evilution"
+require_relative "version"
 
 # EV-kdns / GH #817: nudge users running parallel jobs against SQLite to adopt
 # the parallel_tests convention. WorkQueue sets TEST_ENV_NUMBER per worker, but

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/rails_warmup.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative "diagnostic"
+
+# Warms Rails state that initialises lazily on a process's first request, once
+# in the parent after the preload, so forked mutations inherit it instead of
+# each paying the cold start.
+#
+# Every step is side-effect free. A real request is deliberately NOT used:
+# controller callbacks change process-global state -- I18n.locale,
+# PaperTrail.request, a session row -- that every fork would then inherit,
+# failing unrelated tests and reporting them as kills.
+#
+# A step whose library is not loaded is skipped silently; a step that raises
+# (no application stylesheet, an unusual asset setup) is skipped with a note.
+# Warm-up is an optimisation and must never fail or skew the run.
+class Evilution::RailsWarmup
+  def initialize(application, stream: $stderr)
+    @application = application
+    @stream = stream
+  end
+
+  def call
+    step("i18n") { warm_i18n }
+    step("routes") { warm_routes }
+    step("assets") { warm_assets }
+    step("templates") { warm_templates }
+  end
+
+  private
+
+  def step(name)
+    yield
+  rescue StandardError, ScriptError => e
+    Evilution::Diagnostic.warn("[evilution] rails warmup: skipped #{name} (#{e.class}: #{e.message})", stream: @stream)
+  end
+
+  def warm_i18n
+    ::I18n.eager_load! if defined?(::I18n) && ::I18n.respond_to?(:eager_load!)
+  end
+
+  # Rails 8 can draw routes lazily; building url_helpers compiles the helpers
+  # module every request would otherwise build on first use.
+  def warm_routes
+    routes = @application.routes
+    routes.eager_load! if routes.respond_to?(:eager_load!)
+    routes.url_helpers
+  end
+
+  def warm_assets
+    ::ActionController::Base.helpers.stylesheet_path("application") if defined?(::ActionController::Base)
+  end
+
+  # Optional: jhawthorn/actionview_precompiler compiles templates up front.
+  def warm_templates
+    return unless Gem.loaded_specs.key?("actionview_precompiler")
+
+    require "actionview_precompiler"
+    ::ActionviewPrecompiler.precompile
+  end
+end

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/html/report.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "../html"
 require_relative "section"
 require_relative "stylesheet"
 require_relative "baseline_keys"

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)