evilution 1.1.0 → 1.3.0

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "../operator"
+
+# Replace a single-expression method body with the empty value of the type it
+# returns: `def names(users); users.map(&:name); end` becomes
+# `def names(users); []; end`.
+#
+# A survivor means the suite asserts the shape of the returned value but never
+# its content — a test that only checks `be_an(Array)`, or that calls the method
+# for its side effects and ignores what comes back.
+#
+# CollectionReturn and ScalarReturn do this for bodies of two or more
+# statements, and the literal operators (array_literal, hash_literal,
+# string_literal, integer_literal, float_literal) cover a body that is itself a
+# literal. What neither reaches is the single-expression body whose type is not
+# written down — the common shape of readers and builders — so the type is taken
+# from the trailing call's selector instead.
+#
+# Only selectors whose return type is fixed by Ruby (or a widely-used extension with a stable contract,
+# e.g. ActiveSupport's `index_by`) are listed.
+# A method of the same name defined elsewhere can still return something else,
+# in which case the mutant raises where it is consumed and dies on contact; the
+# table is kept narrow to make that rare.
+class Evilution::Mutator::Operator::TypedDefaultReturn < Evilution::Mutator::Base
+  SELECTOR_TYPES = {
+    "[]" => %i[map collect select filter reject sort sort_by to_a compact flatten values keys uniq],
+    "{}" => %i[to_h group_by tally index_by transform_values transform_keys],
+    "0" => %i[count size length],
+    '""' => %i[to_s join upcase downcase strip]
+  }.freeze
+
+  REPLACEMENT_BY_SELECTOR = SELECTOR_TYPES.flat_map do |replacement, selectors|
+    selectors.map { |selector| [selector, replacement] }
+  end.to_h.freeze
+  private_constant :REPLACEMENT_BY_SELECTOR
+
+  def visit_def_node(node)
+    replace_body_with_default(node)
+    super
+  end
+
+  private
+
+  def replace_body_with_default(node)
+    statements = body_statements(node.body)
+    return if statements.nil?
+    return unless statements.body.length == 1
+
+    replacement = default_for(statements.body.first)
+    return if replacement.nil?
+
+    location = statements.location
+
+    add_mutation(
+      offset: location.start_offset,
+      length: location.length,
+      replacement: replacement,
+      node: node
+    )
+  end
+
+  # A method-level rescue/ensure (`def foo; stmts; rescue; ...; end`) makes the
+  # body a BeginNode whose location spans the entire `def...end`, keyword and
+  # matching `end` included. Replacing that range would delete the method
+  # framing, so only the leading statements are replaceable. Returns nil for a
+  # rescue/ensure-only body and for an empty method, whose body is nil.
+  def body_statements(body)
+    return body unless body.is_a?(Prism::BeginNode)
+
+    body.statements
+  end
+
+  # A body that is already a literal is left to the literal operators, which
+  # emit the same empty value for it.
+  def default_for(node)
+    case node
+    when Prism::InterpolatedStringNode then '""'
+    when Prism::CallNode then REPLACEMENT_BY_SELECTOR[node.name]
+    end
+  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

@@ -96,6 +96,14 @@ class Evilution::Mutator::Registry
       Evilution::Mutator::Operator::RegexCapture,
       Evilution::Mutator::Operator::LoopFlip,
       Evilution::Mutator::Operator::LoopBodyToRaise,
+      Evilution::Mutator::Operator::MethodBodyToRaise,
+      Evilution::Mutator::Operator::MethodBodyToSuper,
+      Evilution::Mutator::Operator::TypedDefaultReturn,
+      Evilution::Mutator::Operator::BlockParameterDrop,
+      Evilution::Mutator::Operator::OptionalParameterToRequired,
+      Evilution::Mutator::Operator::OptionalDefaultInjection,
+      Evilution::Mutator::Operator::BlockDestructuringExpansion,
+      Evilution::Mutator::Operator::ForwardingSuperToExplicit,
       Evilution::Mutator::Operator::StringInterpolation,
       Evilution::Mutator::Operator::RetryRemoval,
       Evilution::Mutator::Operator::CaseWhen,
@@ -105,7 +113,30 @@ 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
     ].each { |op| registry.register(op) }
     registry
   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

@@ -30,7 +30,9 @@ class Evilution::ProcessSupervisor
   # One tracked child: leader pid, its process-group id (== pid for a group
   # leader), the parent-side fds to close on reap, and an optional sandbox dir
   # to remove on reap.
-  Handle = Struct.new(:pid, :pgid, :fds, :sandbox_dir, keyword_init: true)
+  # `status` is filled in when the child is reaped, so a caller that got no
+  # payload out of it can still say how it died.
+  Handle = Struct.new(:pid, :pgid, :fds, :sandbox_dir, :status, keyword_init: true)
 
   @registry = [].freeze
 
@@ -158,7 +160,7 @@ class Evilution::ProcessSupervisor
   # release the resources the handle owns: close parent-side fds, remove the
   # sandbox dir, and drop the handle from the registry.
   def reap(handle)
-    safe_wait(handle.pid)
+    handle.status = safe_wait(handle.pid)
   ensure
     release(handle)
   end
@@ -170,21 +172,28 @@ class Evilution::ProcessSupervisor
   # it releases the handle in the same step it reaps, so the process-global
   # registry never holds a stale, already-reaped pgid.
   def reap_nonblock(handle)
-    return false unless nonblocking_wait(handle.pid)
+    outcome = nonblocking_wait(handle.pid)
+    return false unless outcome
 
+    handle.status = outcome if outcome.is_a?(::Process::Status)
     release(handle)
     true
   end
 
   private
 
-  # WNOHANG wait: returns the pid once the child has exited, nil while it is
-  # still running, and -- treating an already-reaped child as exited -- the pid
-  # again on ECHILD so the caller still releases the handle.
+  # WNOHANG wait: returns the child's Process::Status once it has exited, nil
+  # while it is still running, and -- treating an already-reaped child as
+  # exited -- the :already_reaped sentinel on ECHILD so the caller still
+  # releases the handle. The sentinel is deliberately not a status: $? would
+  # then hold some earlier child's, and attributing that one's death to this
+  # child is worse than admitting the status is unknown.
   def nonblocking_wait(pid)
-    ::Process.waitpid(pid, ::Process::WNOHANG)
+    return nil unless ::Process.waitpid(pid, ::Process::WNOHANG)
+
+    ::Process.last_status
   rescue Errno::ECHILD
-    pid
+    :already_reaped
   end
 
   def release(handle)
@@ -229,8 +238,11 @@ class Evilution::ProcessSupervisor
     nil
   end
 
+  # Returns the reaped child's Process::Status, or nil when it was already
+  # reaped elsewhere and the status is no longer attributable.
   def safe_wait(pid)
     ::Process.wait(pid)
+    ::Process.last_status
   rescue Errno::ECHILD
     nil
   end

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/item_formatters/neutral_group.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative "../item_formatters"
+require_relative "result_location"
+
+# The neutral mutations that share one reason, under a heading naming it.
+#
+# "Neutral" covers a spec that was already red and a test process that died on
+# infrastructure; grouping by reason is what tells the reader which of the two
+# they are looking at, and what to do about it (EV-5pob / GH #1606).
+class Evilution::Reporter::CLI::ItemFormatters::NeutralGroup
+  UNKNOWN_REASON = "reason not recorded"
+
+  def initialize(location: Evilution::Reporter::CLI::ItemFormatters::ResultLocation.new)
+    @location = location
+  end
+
+  def format(group)
+    reason, results = group
+    rows = results.map { |result| "  #{@location.format(result)}" }
+    ["  #{reason ? reason.to_s : UNKNOWN_REASON}:", *rows].join("\n")
+  end
+end

data/lib/evilution/reporter/cli/item_formatters/subject_score.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "../item_formatters"
+require_relative "../pct"
+
+# One line per subject, under its file's heading: what the method scored and
+# what that score is made of.
+#
+# A subject nothing reached says so rather than showing a bare 0.00%, which
+# would read like a method whose mutations all survived (EV-nlx1 / GH #1605).
+class Evilution::Reporter::CLI::ItemFormatters::SubjectScore
+  UNREACHED_NOTE = "nothing reached this subject"
+
+  def initialize(pct: Evilution::Reporter::CLI::Pct.new)
+    @pct = pct
+  end
+
+  def format(score)
+    "    #{method_name(score.name)}  #{@pct.format(score.score)}  #{counts(score)}#{note(score)}"
+  end
+
+  private
+
+  # The file heading already carries the class, so the row keeps the part that
+  # tells the subjects apart, separator included: "#label_for", ".build".
+  def method_name(name)
+    boundary = name.rindex(/[#.]/)
+    boundary ? name[boundary..] : name
+  end
+
+  # Killed over what got a verdict — except where nothing did, in which case the
+  # mutations that exist are the more honest denominator.
+  def counts(score)
+    return "(0/#{score.total})" unless score.reached?
+
+    "(#{score.killed}/#{score.verified})"
+  end
+
+  def note(score)
+    score.reached? ? "" : "  #{UNREACHED_NOTE}"
+  end
+end

data/lib/evilution/reporter/cli/item_formatters/subject_score_group.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "../item_formatters"
+require_relative "subject_score"
+
+# The subjects of one file, under that file's name.
+class Evilution::Reporter::CLI::ItemFormatters::SubjectScoreGroup
+  def initialize(row: Evilution::Reporter::CLI::ItemFormatters::SubjectScore.new)
+    @row = row
+  end
+
+  def format(scores)
+    rows = scores.map { |score| @row.format(score) }
+    ["  #{scores.first.file_path}", *rows].join("\n")
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative "../line_formatters"
+
+# EV-j0bv / GH #1607: parallel workers contending on shared infrastructure — a
+# database file, a lock — crash the test process in a way that says nothing
+# about the mutation. Those mutations are re-run serially once the pool is
+# done, and the run says so, because the alternative is a neutral count that
+# moves with --jobs on identical input with no explanation.
+class Evilution::Reporter::CLI::LineFormatters::InfraRetryNotice
+  def format(summary)
+    count = summary.infra_retried
+    return nil if count.zero?
+
+    noun = count == 1 ? "mutation" : "mutations"
+    pronoun = count == 1 ? "it" : "them"
+    "! #{count} #{noun} hit infrastructure errors under parallel workers; re-ran #{pronoun} serially."
+  end
+end

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

@@ -3,18 +3,42 @@
 require_relative "../line_formatters"
 require_relative "../pct"
 
+# The threshold comes from the run's own configuration. Printing a verdict
+# against a default the exit code did not share is what made a 0% score report
+# `FAIL` and exit 0 (EV-39t1 / GH #1604); with no minimum configured the line
+# states the score and says so, rather than implying a gate that is not armed.
 class Evilution::Reporter::CLI::LineFormatters::ResultLine
-  DEFAULT_MIN_SCORE = 0.8
-
-  def initialize(pct: Evilution::Reporter::CLI::Pct.new, min_score: DEFAULT_MIN_SCORE)
+  def initialize(pct: Evilution::Reporter::CLI::Pct.new, min_score: nil)
     @pct = pct
     @min_score = min_score
   end
 
   def format(summary)
+    return unresolved_targets_line(summary) if summary.unresolved_targets?
+    return no_threshold_line(summary) unless gate?
+
     pass_fail = summary.success?(min_score: @min_score) ? "PASS" : "FAIL"
     score_pct = @pct.format(summary.score)
     threshold_pct = @pct.format(@min_score)
     "Result: #{pass_fail} (score #{score_pct} #{pass_fail == "PASS" ? ">=" : "<"} #{threshold_pct})"
   end
+
+  private
+
+  # A minimum of zero passes every score, so it is not a gate either.
+  def gate?
+    !@min_score.nil? && @min_score.positive?
+  end
+
+  def no_threshold_line(summary)
+    "Result: #{@pct.format(summary.score)} (no minimum score set)"
+  end
+
+  # The score covers only the files that resolved to a spec, so reporting it
+  # against the threshold here would name the wrong problem.
+  def unresolved_targets_line(summary)
+    count = summary.unresolved_target_files.length
+    subject = count == 1 ? "target file has" : "target files have"
+    "Result: FAIL (#{count} #{subject} no resolvable spec)"
+  end
 end

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

@@ -3,12 +3,30 @@
 require_relative "../line_formatters"
 require_relative "../pct"
 
+# The score covers only the mutations that got a verdict. Where a run left some
+# out — neutral, unresolved, equivalent, errored — full marks over a fraction of
+# it reads as a verdict on the whole, so the line says how much it covered
+# (EV-5pob / GH #1606).
 class Evilution::Reporter::CLI::LineFormatters::Score
   def initialize(pct: Evilution::Reporter::CLI::Pct.new)
     @pct = pct
   end
 
   def format(summary)
-    "Score: #{@pct.format(summary.score)} (#{summary.killed}/#{summary.score_denominator})"
+    "Score: #{@pct.format(summary.score)} (#{counts(summary)})"
+  end
+
+  private
+
+  def counts(summary)
+    verified = summary.score_denominator
+    pair = "#{summary.killed}/#{verified}"
+    return pair if verified == summary.total
+
+    "#{pair} verified of #{summary.total} mutations#{neutral_note(summary)}"
+  end
+
+  def neutral_note(summary)
+    summary.neutral.positive? ? ", #{summary.neutral} neutral" : ""
   end
 end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "../line_formatters"
+
+# EV-p4sm / GH #1603: a target file that resolves to no test file contributes
+# only a handful of `unresolved` mutations, which UnresolvedRateWarning dilutes
+# against every other file in the run — 14 unresolved out of 98 sits under its
+# threshold and says nothing at all. This formatter reports the stronger,
+# per-file fact instead, and names the files so the reader knows which of the
+# paths they passed was never tested.
+class Evilution::Reporter::CLI::LineFormatters::UnresolvedTargets
+  def format(summary)
+    return nil unless summary.unresolved_targets?
+
+    files = summary.unresolved_target_files
+    listing = files.map { |path| "    #{path}" }.join("\n")
+    "! #{headline(files.length, summary.target_file_count)}:\n#{listing}"
+  end
+
+  private
+
+  # The ratio is dropped rather than guessed when the run's target count is
+  # unknown, which is how a summary restored from a saved session arrives. The
+  # noun agrees with whichever number it follows ("1 of 2 target files has",
+  # "1 target file has"), the verb with how many were unresolved.
+  def headline(unresolved_count, target_file_count)
+    noun_count = target_file_count.nil? ? unresolved_count : target_file_count
+    noun = noun_count == 1 ? "target file" : "target files"
+    verb = unresolved_count == 1 ? "has" : "have"
+    tail = unresolved_count == 1 ? "it was never tested" : "they were never tested"
+    scope = target_file_count.nil? ? unresolved_count.to_s : "#{unresolved_count} of #{target_file_count}"
+
+    "#{scope} #{noun} #{verb} no resolvable spec — #{tail}"
+  end
+end

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

@@ -5,6 +5,8 @@ require_relative "line_formatters/mutations"
 require_relative "line_formatters/score"
 require_relative "line_formatters/error_rate_warning"
 require_relative "line_formatters/unresolved_rate_warning"
+require_relative "line_formatters/unresolved_targets"
+require_relative "line_formatters/infra_retry_notice"
 require_relative "line_formatters/duration"
 require_relative "line_formatters/efficiency"
 require_relative "line_formatters/peak_memory"
@@ -15,6 +17,8 @@ class Evilution::Reporter::CLI::MetricsBlock
     Evilution::Reporter::CLI::LineFormatters::Score.new,
     Evilution::Reporter::CLI::LineFormatters::ErrorRateWarning.new,
     Evilution::Reporter::CLI::LineFormatters::UnresolvedRateWarning.new,
+    Evilution::Reporter::CLI::LineFormatters::UnresolvedTargets.new,
+    Evilution::Reporter::CLI::LineFormatters::InfraRetryNotice.new,
     Evilution::Reporter::CLI::LineFormatters::Duration.new,
     Evilution::Reporter::CLI::LineFormatters::Efficiency.new,
     Evilution::Reporter::CLI::LineFormatters::PeakMemory.new

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

@@ -6,14 +6,18 @@ require_relative "line_formatters/result_line"
 require_relative "line_formatters/feedback_footer"
 
 class Evilution::Reporter::CLI::Trailer
-  DEFAULT_LINES = [
-    Evilution::Reporter::CLI::LineFormatters::TruncationNotice.new,
-    Evilution::Reporter::CLI::LineFormatters::ResultLine.new,
-    Evilution::Reporter::CLI::LineFormatters::FeedbackFooter.new
-  ].freeze
+  def self.default_lines(min_score: nil)
+    [
+      Evilution::Reporter::CLI::LineFormatters::TruncationNotice.new,
+      Evilution::Reporter::CLI::LineFormatters::ResultLine.new(min_score: min_score),
+      Evilution::Reporter::CLI::LineFormatters::FeedbackFooter.new
+    ]
+  end
+
+  DEFAULT_LINES = default_lines.freeze
 
-  def initialize(lines: DEFAULT_LINES)
-    @lines = lines
+  def initialize(lines: nil, min_score: nil)
+    @lines = lines || self.class.default_lines(min_score: min_score)
   end
 
   def call(summary)

data/lib/evilution/reporter/cli.rb

@@ -6,11 +6,12 @@ class Evilution::Reporter::CLI
   SEPARATOR = "=" * 44
 
   def initialize(
+    min_score: nil,
     header: LineFormatters::Header.new,
     metrics_block: MetricsBlock.new,
     section_renderer: SectionRenderer.new,
     sections: DEFAULT_SECTIONS,
-    trailer: Trailer.new
+    trailer: Trailer.new(min_score: min_score)
   )
     @header = header
     @metrics_block = metrics_block
@@ -46,6 +47,9 @@ require_relative "cli/line_formatters/result_line"
 require_relative "cli/line_formatters/feedback_footer"
 require_relative "cli/item_formatters/coverage_gap"
 require_relative "cli/item_formatters/result_location"
+require_relative "cli/item_formatters/neutral_group"
+require_relative "cli/item_formatters/subject_score"
+require_relative "cli/item_formatters/subject_score_group"
 require_relative "cli/item_formatters/error"
 require_relative "cli/item_formatters/disabled"
 require_relative "cli/metrics_block"
@@ -60,9 +64,21 @@ Evilution::Reporter::CLI.const_set(
       formatter: Evilution::Reporter::CLI::ItemFormatters::CoverageGap.new
     ),
     Evilution::Reporter::CLI::Section.new(
-      title: "Neutral mutations (test already failing):",
-      fetcher: lambda(&:neutral_results),
-      formatter: Evilution::Reporter::CLI::ItemFormatters::ResultLocation.new
+      title: lambda { |groups|
+        subjects = groups.sum(&:length)
+        "Subjects needing attention (#{subjects} subject#{"s" unless subjects == 1} " \
+          "in #{groups.length} file#{"s" unless groups.length == 1}):"
+      },
+      fetcher: lambda(&:subjects_needing_attention_by_file),
+      formatter: Evilution::Reporter::CLI::ItemFormatters::SubjectScoreGroup.new
+    ),
+    Evilution::Reporter::CLI::Section.new(
+      title: lambda { |groups|
+        count = groups.sum { |(_reason, results)| results.length }
+        "Neutral mutations (#{count}, not verified):"
+      },
+      fetcher: lambda(&:neutral_results_by_reason),
+      formatter: Evilution::Reporter::CLI::ItemFormatters::NeutralGroup.new
     ),
     Evilution::Reporter::CLI::Section.new(
       title: "Equivalent mutations (provably identical behavior):",

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "../json"
+
+# The per-subject rows of a JSON report.
+#
+# Every subject is listed, whether or not it needs attention: a consumer that
+# wants only the gaps filters on `reached` and `score`, while one asserting that
+# a method is covered at all needs to see the rest (EV-nlx1 / GH #1605).
+class Evilution::Reporter::JSON::Subjects
+  def call(summary)
+    summary.subject_scores.map { |score| row(score) }
+  end
+
+  private
+
+  def row(score)
+    {
+      name: score.name,
+      file: score.file_path,
+      total: score.total,
+      killed: score.killed,
+      verified: score.verified,
+      survived: score.survived,
+      score: score.score.round(4),
+      reached: score.reached?
+    }
+  end
+end