evilution 1.1.0 → 1.2.0

data/lib/evilution/cli/parser/options_builder.rb

@@ -55,6 +55,7 @@ class Evilution::CLI::Parser::OptionsBuilder
 
   def add_spec_filter_options(opts)
     opts.on("--min-score FLOAT", Float, "Minimum mutation score to pass") { |s| @options[:min_score] = s }
+    opts.on("--output FILE", "Write the report to FILE instead of stdout") { |f| @options[:output] = f }
     opts.on("--spec FILES", Array, "Spec files to run (comma-separated)") { |f| @options[:spec_files] = f }
     opts.on("--spec-dir DIR", "Include all specs in DIR") { |d| expand_spec_dir(d) }
     opts.on("--spec-pattern GLOB",

data/lib/evilution/cli.rb

@@ -18,6 +18,7 @@ require_relative "cli/commands/session_diff"
 require_relative "cli/commands/session_gc"
 require_relative "cli/commands/compare"
 require_relative "cli/commands/run"
+require_relative "cli/exit_guard"
 
 # @api private
 class Evilution::CLI

data/lib/evilution/config.rb

@@ -17,7 +17,7 @@ class Evilution::Config
     save_session: false, line_ranges: {}, spec_files: [], ignore_patterns: [],
     show_disabled: false, baseline_session: nil, skip_heredoc_literals: false,
     related_specs_heuristic: false, fallback_to_full_suite: false, preload: nil,
-    spec_mappings: {}, spec_pattern: nil, example_targeting: true,
+    output: nil, spec_mappings: {}, spec_pattern: nil, example_targeting: true,
     example_targeting_fallback: :full_file, example_targeting_strategy: :lexical,
     example_targeting_cache: { max_files: 50, max_blocks: 10_000 },
     quiet_children: false, quiet_children_dir: "tmp/evilution_children",
@@ -25,7 +25,7 @@ class Evilution::Config
   }.freeze
 
   attr_reader :target_files, :schema_version, :timeout, :format,
-              :target, :min_score, :integration, :verbose, :quiet,
+              :target, :min_score, :integration, :verbose, :quiet, :output,
               :jobs, :fail_fast, :baseline, :isolation, :incremental, :suggest_tests,
               :progress, :save_session, :line_ranges, :spec_files, :hooks,
               :ignore_patterns, :show_disabled, :baseline_session,
@@ -243,6 +243,7 @@ class Evilution::Config
     format: :to_sym.to_proc,
     target: nil,
     min_score: :to_f.to_proc,
+    output: nil,
     verbose: nil,
     quiet: nil,
     baseline: nil,

data/lib/evilution/diagnostic.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "../evilution"
+
+# Evilution's own advisory messages -- "no matching spec found", and the like.
+#
+# These deliberately bypass Kernel#warn. That routes through Warning.warn,
+# which a project is free to replace: the `warning` gem with a raising handler
+# turns every Ruby warning into an exception, and both dry-schema and
+# dry-monads configure exactly that in their spec_helper. Under such a project
+# our advisory message would be promoted to a fatal error, so a mutation we
+# meant to classify :unresolved would be reported :error instead -- 239 of
+# dry-monads' 240 mutations, in the run that found this.
+#
+# A message about how evilution is behaving must never be able to fail a
+# user's mutation. Writing straight to the stream keeps it a diagnostic.
+# EV-df7u / GH #1588.
+module Evilution::Diagnostic
+  def self.warn(message, stream: $stderr)
+    stream.puts(message)
+  end
+end

data/lib/evilution/integration/loading/concern_state_cleaner.rb

@@ -11,6 +11,22 @@ require_relative "../../load_path/subpath_resolver"
 class Evilution::Integration::Loading::ConcernStateCleaner
   IVARS = %i[@_included_block @_prepended_block].freeze
 
+  # ObjectSpace hands us every Module in the VM, including ones that answer no
+  # message honestly. ActiveSupport::Deprecation::DeprecatedConstantProxy
+  # subclasses Module and undefines all of its instance methods, so a plain
+  # `mod.singleton_class` lands in its method_missing and emits the
+  # deprecation; where the deprecator's behaviour is :raise (grape's
+  # spec_helper sets that), the sweep blows up on a module it merely walked
+  # past. Calling through UnboundMethods bypasses the object's own method
+  # table, so a proxy is never given the chance to intercept -- and this holds
+  # for any method_missing-based wrapper, not just ActiveSupport's.
+  # EV-v2rc / GH #1581.
+  SINGLETON_CLASS = Object.instance_method(:singleton_class)
+  IVAR_DEFINED = Object.instance_method(:instance_variable_defined?)
+  IVAR_GET = Object.instance_method(:instance_variable_get)
+  REMOVE_IVAR = Object.instance_method(:remove_instance_variable)
+  private_constant :SINGLETON_CLASS, :IVAR_DEFINED, :IVAR_GET, :REMOVE_IVAR
+
   def initialize(subpath_resolver: Evilution::LoadPath::SubpathResolver.new)
     @subpath_resolver = subpath_resolver
   end
@@ -22,7 +38,7 @@ class Evilution::Integration::Loading::ConcernStateCleaner
     subpath = @subpath_resolver.call(file_path)
 
     ObjectSpace.each_object(Module) do |mod|
-      next unless mod.singleton_class.ancestors.include?(ActiveSupport::Concern)
+      next unless SINGLETON_CLASS.bind_call(mod).ancestors.include?(ActiveSupport::Concern)
 
       clear_concern_ivars(mod, absolute, subpath)
     end
@@ -32,14 +48,14 @@ class Evilution::Integration::Loading::ConcernStateCleaner
 
   def clear_concern_ivars(mod, absolute, subpath)
     IVARS.each do |ivar|
-      next unless mod.instance_variable_defined?(ivar)
+      next unless IVAR_DEFINED.bind_call(mod, ivar)
 
-      block = mod.instance_variable_get(ivar)
+      block = IVAR_GET.bind_call(mod, ivar)
       block_file = block.source_location&.first
       next unless block_file
 
       expanded = File.expand_path(block_file)
-      mod.remove_instance_variable(ivar) if source_matches?(expanded, absolute, subpath)
+      REMOVE_IVAR.bind_call(mod, ivar) if source_matches?(expanded, absolute, subpath)
     end
   end
 

data/lib/evilution/integration/loading/reeval_warning_filter.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative "../loading"
+
+# Suppresses exactly the Ruby warnings that re-evaluating a file is guaranteed
+# to produce, and nothing else.
+#
+# Applying a mutation re-evaluates the file, which redefines its methods and
+# reassigns its constants. Ruby reports that in verbose mode, and a project
+# that also promotes warnings to exceptions -- dry-schema's `.rspec` carries
+# `--warnings` while its spec_helper installs `Warning.process { |w| raise w }`
+# -- fails every mutation on a message describing evilution's mechanism rather
+# than the code under test.
+#
+# The blunt fix, `$VERBOSE = nil` around the eval, costs too much: the
+# evaluated file then sees a different $VERBOSE than a normal load would (code
+# branching on it takes the other path), and genuine warnings introduced BY a
+# mutation are swallowed along with ours -- losing a kill that a raising
+# handler would otherwise hand us. So the filter matches the specific
+# mechanism messages instead and delegates everything else to whatever handler
+# the project installed.
+#
+# EV-df7u / GH #1588.
+class Evilution::Integration::Loading::ReevalWarningFilter
+  MECHANISM_WARNINGS = Regexp.union(
+    /method redefined; discarding old /,
+    /already initialized constant /,
+    /previous definition of .+ was here/
+  ).freeze
+
+  ACTIVE_KEY = :__evilution_reeval_warning_filter_active
+
+  # Prepended to Warning's singleton, so it sits AHEAD of any handler the
+  # project extended in (the `warning` gem extends Warning::Processor), and
+  # `super` still reaches that handler for everything it does not drop.
+  module Filter
+    def warn(message, *args, **kwargs)
+      filter = Evilution::Integration::Loading::ReevalWarningFilter
+      return if filter.active? && filter.mechanism_warning?(message)
+
+      super
+    end
+  end
+
+  class << self
+    def suppress
+      install
+      previous = Thread.current[ACTIVE_KEY]
+      Thread.current[ACTIVE_KEY] = true
+      yield
+    ensure
+      Thread.current[ACTIVE_KEY] = previous
+    end
+
+    def active?
+      Thread.current[ACTIVE_KEY] ? true : false
+    end
+
+    def mechanism_warning?(message)
+      MECHANISM_WARNINGS.match?(message)
+    end
+
+    # Idempotent: prepending twice would run the filter twice per warning.
+    # `target` exists so a test can install into a throwaway module -- once
+    # Warning's singleton has the filter there is no way to take it back off.
+    def install(target = Warning.singleton_class)
+      return if target.ancestors.include?(Filter)
+
+      target.prepend(Filter)
+    end
+  end
+end

data/lib/evilution/integration/loading/source_evaluator.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../loading"
+require_relative "reeval_warning_filter"
 
 # Evaluate source with __FILE__ set to the absolute original path so that
 # `require_relative` and `__dir__` resolve against the real source tree, where
@@ -17,6 +18,8 @@ class Evilution::Integration::Loading::SourceEvaluator
     # GH #1278), anchor the eval __FILE__ against PROJECT_ROOT so siblings
     # `require_relative` can find each other from the real source tree.
     absolute = File.expand_path(file_path, Evilution.project_base_dir)
-    eval(source, TOPLEVEL_BINDING, absolute, 1)
+    Evilution::Integration::Loading::ReevalWarningFilter.suppress do
+      eval(source, TOPLEVEL_BINDING, absolute, 1)
+    end
   end
 end

data/lib/evilution/integration/minitest.rb

@@ -2,6 +2,7 @@
 
 require "stringio"
 require_relative "base"
+require_relative "../diagnostic"
 require_relative "minitest_crash_detector"
 require_relative "loading/test_load_path"
 require_relative "../spec_resolver"
@@ -276,7 +277,7 @@ class Evilution::Integration::Minitest < Evilution::Integration::Base
     return if @warned_files.include?(file_path)
 
     @warned_files << file_path
-    warn unresolved_test_message(file_path)
+    Evilution::Diagnostic.warn(unresolved_test_message(file_path))
   end
 
   # Name both recovery paths when skipping :unresolved; when already falling

data/lib/evilution/integration/rspec/crash_detector_lifecycle.rb

@@ -10,8 +10,16 @@ class Evilution::Integration::RSpec::CrashDetectorLifecycle
       @detector.reset
     else
       @detector = Evilution::Integration::CrashDetector.new(StringIO.new)
-      ::RSpec.configuration.add_formatter(@detector)
     end
     @detector
   end
+
+  # The run rebuilds RSpec's formatter loader so its formatters are bound to the
+  # run's own streams (EV-m6xc / GH #1627), which drops any formatter registered
+  # before it — the detector included. It is registered per run instead.
+  def register
+    detector = current
+    ::RSpec.configuration.add_formatter(detector)
+    detector
+  end
 end

data/lib/evilution/integration/rspec/state_guard/configuration_streams.rb

@@ -18,7 +18,10 @@ require_relative "internals"
 # writing the ivars directly: configuration#output_stream= is guarded (it warns
 # and no-ops once a reporter exists), so the public setter cannot put it back.
 class Evilution::Integration::RSpec::StateGuard::ConfigurationStreams
-  IVARS = %i[@color_mode @output_stream @error_stream].freeze
+  #   - @reporter and @formatter_loader -- both hold the stream they were built
+  #                     with, so the run drops them to rebuild against its own
+  #                     (EV-m6xc / GH #1627); the host's are restored here.
+  IVARS = %i[@color_mode @output_stream @error_stream @reporter @formatter_loader].freeze
 
   def snapshot
     config = ::RSpec.configuration

data/lib/evilution/integration/rspec/unresolved_spec_warner.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../rspec"
+require_relative "../../diagnostic"
 
 class Evilution::Integration::RSpec::UnresolvedSpecWarner
   def initialize
@@ -11,7 +12,7 @@ class Evilution::Integration::RSpec::UnresolvedSpecWarner
     return if @warned.include?(file_path)
 
     @warned << file_path
-    warn message(file_path, fallback_to_full_suite)
+    Evilution::Diagnostic.warn(message(file_path, fallback_to_full_suite))
   end
 
   private

data/lib/evilution/integration/rspec.rb

@@ -70,6 +70,26 @@ class Evilution::Integration::RSpec < Evilution::Integration::Base
     targets = @example_filter_applier.call(mutation, files)
     return @result_builder.unresolved_example(mutation) if targets.nil?
 
+    result = run_targets(targets)
+    return result unless confirm_survivor?(result, targets, files)
+
+    run_targets(files)
+  end
+
+  # Targeting runs a subset of the examples in a spec file, chosen by name. A
+  # mutation that subset does not catch looks like a survivor whether or not the
+  # rest of the file would have caught it, and a survivor nobody can reproduce
+  # is worse than a missed kill: it sends the reader to write a test that is
+  # already there (EV-f8h3 / GH #1624).
+  #
+  # So a survivor is re-run against the whole resolved file, and that run is the
+  # one reported. Only survivors pay for it, and only where the subset was
+  # actually narrower than the file.
+  def confirm_survivor?(result, targets, files)
+    result[:passed] && targets != files
+  end
+
+  def run_targets(targets)
     args = ["--format", "progress", "--no-color", "--order", "defined", *resolve_targets(targets)]
     command = "rspec #{args.join(" ")}"
 
@@ -115,10 +135,13 @@ class Evilution::Integration::RSpec < Evilution::Integration::Base
   end
 
   def execute_run(args, command)
-    detector = @crash_detector_lifecycle.current
     snapshot = @state_guard.snapshot
     begin
-      status = ::RSpec::Core::Runner.run(args, StringIO.new, StringIO.new)
+      out = StringIO.new
+      err = StringIO.new
+      claim_rspec_streams(out, err)
+      detector = @crash_detector_lifecycle.register
+      status = ::RSpec::Core::Runner.run(args, err, out)
       @result_builder.from_run(status, command, detector, examples_loaded:)
     rescue StandardError => e
       { passed: false, error: e.message, test_command: command }
@@ -127,6 +150,29 @@ class Evilution::Integration::RSpec < Evilution::Integration::Base
     end
   end
 
+  # RSpec redirects its own output to the streams it is handed only when the
+  # stream its configuration already holds is the current `$stdout`. In-process
+  # isolation swaps `$stdout` for a null IO around every mutation, and a
+  # configuration built before that swap — which is what `--preload` produces,
+  # since the project's spec_helper calls RSpec.configure — still holds the real
+  # stdout. The two no longer match, RSpec keeps its own stream, and the run's
+  # output lands on the real stdout ahead of the report (EV-m6xc / GH #1627).
+  #
+  # So the streams are claimed outright rather than offered. The ivars are
+  # written directly because `output_stream=` is guarded once a reporter exists.
+  # The reporter and its formatters are dropped along with them: both hold the
+  # stream they were built with, so leaving them in place would keep writing
+  # wherever the host pointed. StateGuard snapshots all four ivars and puts the
+  # host's back afterwards.
+  def claim_rspec_streams(out, err)
+    config = ::RSpec.configuration
+    config.instance_variable_set(:@output_stream, out)
+    config.instance_variable_set(:@error_stream, err)
+    %i[@reporter @formatter_loader].each do |ivar|
+      config.remove_instance_variable(ivar) if config.instance_variable_defined?(ivar)
+    end
+  end
+
   # Count of examples loaded into RSpec.world by this run. Used to distinguish
   # "test failed → mutation killed" (positive count, nonzero status) from
   # "spec file failed to load / RSpec returned nonzero with nothing observed"

data/lib/evilution/integration/test_unit/test_file_resolver.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../test_unit"
+require_relative "../../diagnostic"
 
 # Resolves the list of test files to load for a given mutation. Encapsulates
 # the explicit-override path, spec-selector lookup, fallback glob, and the
@@ -41,7 +42,7 @@ class Evilution::Integration::TestUnit::TestFileResolver
     return if @warned_files.include?(file_path)
 
     @warned_files << file_path
-    warn unresolved_message(file_path)
+    Evilution::Diagnostic.warn(unresolved_message(file_path))
   end
 
   # Name both recovery paths when skipping :unresolved; when already falling

data/lib/evilution/isolation/fork.rb

@@ -142,9 +142,9 @@ class Evilution::Isolation::Fork
       # Child exited. Drain any final payload that arrived between
       # wait_readable timeout and the reap (race) before declaring empty.
       final = read_payload(read_io, Process.clock_gettime(Process::CLOCK_MONOTONIC) + 0.1)
-      return decode_payload(final) if final
+      return decode_payload(final, handle) if final
 
-      return empty_result
+      return empty_result(handle)
     end
   end
 
@@ -161,11 +161,13 @@ class Evilution::Isolation::Fork
 
       if Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
         @supervisor.terminate(handle, grace: GRACE_PERIOD)
-        break
+        # The status now records OUR signal, so it cannot be reported as the
+        # child's own cause of death.
+        return decode_payload(payload, handle, terminated: true)
       end
       sleep 0.05
     end
-    decode_payload(payload)
+    decode_payload(payload, handle)
   end
 
   def read_payload(read_io, deadline)
@@ -201,14 +203,33 @@ class Evilution::Isolation::Fork
     buf
   end
 
-  def decode_payload(data)
-    return empty_result if data.nil? || data.empty?
+  def decode_payload(data, handle = nil, terminated: false)
+    return empty_result(handle, terminated: terminated) if data.nil? || data.empty?
 
     { timeout: false }.merge(Marshal.load(data))
   end
 
-  def empty_result
-    { timeout: false, passed: false, error: "empty result from child" }
+  def empty_result(handle, terminated: false)
+    { timeout: false, passed: false, error: child_death_reason(handle, terminated: terminated) }
+  end
+
+  # A child that wrote no payload has usually left its stdout/stderr capture
+  # empty too, so its termination status is the only evidence of what happened.
+  # Reporting it separates a segfault from an OOM kill from a clean early exit,
+  # all of which reach this path identically.
+  def child_death_reason(handle, terminated: false)
+    return "child was terminated after the reap deadline without writing a result" if terminated
+
+    status = handle.nil? ? nil : handle.status
+    return "empty result from child" unless status.is_a?(Process::Status)
+    return "child exited #{status.exitstatus} without writing a result" unless status.signaled?
+
+    "child died on #{signal_name(status.termsig)} without writing a result"
+  end
+
+  def signal_name(termsig)
+    name = Signal.signame(termsig)
+    name.nil? ? "signal #{termsig}" : "SIG#{name}"
   end
 
   def timeout_result(handle)

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "../operator"
+
+# Flatten a destructuring group in a block's parameter list:
+# `pairs.each_with_index { |(key, value), index| ... }` becomes
+# `pairs.each_with_index { |key, value, index| ... }`.
+#
+# The two forms bind differently once the group has a sibling: given `[1, 2]`
+# and `3`, the grouped form binds key=1, value=2, index=3, while the flat form
+# binds key=[1, 2], value=3, index=nil. A survivor means nothing asserts the
+# shape of what the yielder hands over.
+#
+# A lone group is left alone. With one parameter and a single yielded array —
+# what `each` over pairs, and `Hash#each`, actually yield — both forms bind the
+# same values, so the mutation would be behaviour-preserving and survive every
+# suite. The forms do diverge there for a yielder that passes several values,
+# but which one a block is handed cannot be known from the source, and a
+# guaranteed survivor on the common idiom is the worse trade.
+#
+# Methods and lambdas are left alone as well: both bind by arity, so flattening
+# a group in their signatures raises ArgumentError at every call site instead of
+# changing how arguments are distributed.
+class Evilution::Mutator::Operator::BlockDestructuringExpansion < Evilution::Mutator::Base
+  def visit_block_node(node)
+    expand_groups(node)
+    super
+  end
+
+  private
+
+  def expand_groups(node)
+    parameters = node.parameters
+    return unless parameters.is_a?(Prism::BlockParametersNode)
+
+    inner = parameters.parameters
+    return unless inner.is_a?(Prism::ParametersNode)
+    return unless siblings?(inner)
+
+    groups(inner).each { |group| flatten_group(group) }
+  end
+
+  # Both lists can hold a destructuring group: `|(a, b), c|` puts it in
+  # requireds, `|*rest, (a, b)|` in posts.
+  def groups(parameters)
+    [*parameters.requireds, *parameters.posts].grep(Prism::MultiTargetNode)
+  end
+
+  def siblings?(parameters)
+    parameter_count(parameters) > 1
+  end
+
+  # Block-local variables (`|a; tmp|`) are not parameters and so are not
+  # siblings — they change nothing about how arguments bind.
+  def parameter_count(parameters)
+    [
+      *parameters.requireds,
+      *parameters.optionals,
+      parameters.rest,
+      *parameters.posts,
+      *parameters.keywords,
+      parameters.keyword_rest,
+      parameters.block
+    ].compact.length
+  end
+
+  # Only the group's own parentheses go; anything nested inside keeps its own.
+  # A group written in a block's parameter list always carries them — the
+  # parenthesis-free MultiTargetNode belongs to multiple assignment, which is
+  # not reachable from here.
+  def flatten_group(group)
+    lparen = group.lparen_loc
+    rparen = group.rparen_loc
+
+    inner_start = lparen.start_offset + lparen.length
+    add_mutation(
+      offset: group.location.start_offset,
+      length: group.location.length,
+      replacement: byteslice_source(inner_start, rparen.start_offset - inner_start),
+      node: group
+    )
+  end
+end

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

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "../operator"
+
+# Drop the single parameter of a block: `users.each { |u| touch(u) }` becomes
+# `users.each { touch(u) }`.
+#
+# A block tolerates being handed more arguments than it declares, so the mutant
+# runs until the body reads the dropped name, where it raises NameError. A
+# survivor therefore means the block never ran on a path the suite asserts —
+# the collection was empty, or the call was stubbed away.
+#
+# Not to be confused with BlockParamRemoval, which removes a method's `&block`
+# parameter from its signature.
+#
+# Two shapes are deliberately left alone. A parameter the body never reads makes
+# the mutation behaviour-preserving, so it would survive every suite and report
+# a coverage gap that is not there. A lambda checks its arity, so dropping its
+# parameter raises ArgumentError on every call, whatever the body does.
+class Evilution::Mutator::Operator::BlockParameterDrop < Evilution::Mutator::Base
+  def visit_block_node(node)
+    drop_parameter(node)
+    super
+  end
+
+  private
+
+  def drop_parameter(node)
+    return unless droppable?(node)
+
+    location = node.parameters.location
+    leading = leading_space(location)
+
+    add_mutation(
+      offset: location.start_offset - leading,
+      length: location.length + leading,
+      replacement: "",
+      node: node
+    )
+  end
+
+  def droppable?(node)
+    parameters = node.parameters
+    return false unless parameters.is_a?(Prism::BlockParametersNode)
+    return false unless parameters.locals.empty?
+
+    names = single_parameter_names(parameters.parameters)
+    names.any? { |name| body_reads?(node.body, name) }
+  end
+
+  # The space the block keyword leaves in front of the parameters goes with
+  # them, so `{ |u| body }` mutates to `{ body }` and `do |u|` to `do` rather
+  # than leaving a double space or a trailing one.
+  def leading_space(location)
+    preceding = @file_source.byteslice(location.start_offset - 1, 1)
+    preceding == " " ? 1 : 0
+  end
+
+  # The names bound by a lone required parameter, which is either a plain name
+  # or a destructuring target (`|(key, value)|`). Anything else — a second
+  # parameter, an optional, a rest, a keyword, a block pass, or the implicit
+  # rest Prism reports for the trailing comma in `|key,|` — means this is not a
+  # single-parameter block, and numbered parameters carry no node to remove.
+  def single_parameter_names(parameters)
+    return [] unless parameters.is_a?(Prism::ParametersNode)
+    return [] unless parameters.requireds.length == 1
+    return [] unless other_parameters_absent?(parameters)
+
+    parameter_names(parameters.requireds.first)
+  end
+
+  # Post-required parameters are not checked: block syntax only produces them
+  # after a rest parameter, which is rejected here anyway.
+  def other_parameters_absent?(parameters)
+    parameters.optionals.empty? && parameters.keywords.empty? &&
+      parameters.rest.nil? && parameters.keyword_rest.nil? && parameters.block.nil?
+  end
+
+  def parameter_names(node)
+    case node
+    when Prism::RequiredParameterNode then [node.name.to_s]
+    when Prism::MultiTargetNode then node.lefts.flat_map { |child| parameter_names(child) }
+    else []
+    end
+  end
+
+  # An underscore-prefixed name announces a parameter that is not meant to be
+  # read, so it is treated as unused even where the body happens to mention it.
+  def body_reads?(body, name)
+    return false if name.start_with?("_")
+
+    Evilution::AST::LocalReads.new.call(body, name)
+  end
+end