evilution 1.1.0 → 1.3.0

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

@@ -13,7 +13,9 @@ require_relative "../loading"
 # Strategy: walk Prism tree, find CallNodes that sit directly under a class
 # or module body (not inside a def). Calls on a small allowlist of patterns
 # known to be idempotent (`include`, `attr_*`, visibility modifiers, etc.)
-# are preserved; everything else is replaced byte-for-byte with `nil`.
+# are preserved; everything else has its source range replaced with `()`.
+# The replacement is shorter than the call it replaces, so edits are applied
+# from the end of the source backwards to keep earlier offsets valid.
 class Evilution::Integration::Loading::BodyCallNeutralizer
   IDEMPOTENT_CALLS = %i[
     include extend prepend using
@@ -25,6 +27,12 @@ class Evilution::Integration::Loading::BodyCallNeutralizer
     require require_relative autoload
   ].to_set.freeze
 
+  # `()` rather than `nil`: under -w Ruby flags a bare `nil` statement as
+  # "possibly useless use of nil in void context", which a project raising on
+  # warnings turns into an error for every mutation of the file. `()` evaluates
+  # to nil without the warning on every supported Ruby (`(nil)` still warns on 3.3).
+  REPLACEMENT = "()"
+
   class << self
     attr_writer :preloaded_features
 
@@ -80,7 +88,7 @@ class Evilution::Integration::Loading::BodyCallNeutralizer
   def apply_edits(source, edits)
     bytes = source.b
     edits.sort_by!(&:first).reverse_each do |start_offset, end_offset|
-      bytes[start_offset, end_offset - start_offset] = "nil"
+      bytes[start_offset, end_offset - start_offset] = REPLACEMENT
     end
     bytes.force_encoding(source.encoding)
   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/loading/test_load_path.rb

@@ -22,29 +22,37 @@ module Evilution::Integration::Loading::TestLoadPath
   # Prepend every relevant test directory to $LOAD_PATH (idempotently).
   # Iterate in reverse so the first entry from #dirs_for ends up frontmost,
   # preserving its order (mirrors how `ruby -Ia -Ib` lands a before b).
-  def add!(files, base: Evilution.project_base_dir)
-    dirs_for(files, base).reverse_each do |dir|
+  def add!(files, base: Evilution.project_base_dir, outside_root_dirs: true)
+    dirs_for(files, base, outside_root_dirs: outside_root_dirs).reverse_each do |dir|
       $LOAD_PATH.unshift(dir) unless $LOAD_PATH.include?(dir)
     end
   end
 
-  # The directories to put on $LOAD_PATH for the given resolved test files:
-  # the conventional test/ and spec/ roots under base, each file's own
-  # directory, and the topmost test/spec ancestor of each file (covers nested
-  # layouts like test/unit, spec/lib, spec/unit). Existing directories only,
-  # and only those inside the project base -- never a broad outside-project dir
-  # (e.g. a /tmp test file), which would over-widen $LOAD_PATH for the whole
-  # process (the baseline runs in the long-lived parent).
-  def dirs_for(files, base)
+  # The directories to put on $LOAD_PATH for the given files: the
+  # conventional test/ and spec/ roots under base, each file's own directory,
+  # and the topmost test/spec ancestor of each file (covers nested layouts
+  # like test/unit, spec/lib, spec/unit). Existing directories only, and only
+  # those inside the project base -- never a broad outside-project dir (e.g. a
+  # /tmp test file), which would over-widen $LOAD_PATH for the whole process
+  # (the baseline runs in the long-lived parent).
+  #
+  # A resolved test file outside every test root (a tests/ layout, a test
+  # reached through --spec or spec_mappings) still contributes its own
+  # directory, mirroring `ruby -Itests`. A preload does not: with
+  # `outside_root_dirs: false`, a `--preload config/evilution_preload.rb`
+  # would otherwise put config/ ahead of the gems, and `require "puma"` during
+  # Bundler.require would load the app's config/puma.rb (GH #1597).
+  def dirs_for(files, base, outside_root_dirs: true)
     base = File.expand_path(base)
     dirs = conventional_roots(base)
     Array(files).each do |file|
       file_dir = File.dirname(File.expand_path(file, base))
-      dirs << file_dir
       root = root_ancestor(file_dir, base)
-      dirs << root if root
+      next unless root || outside_root_dirs
+
+      dirs << file_dir << root
     end
-    dirs.uniq.select { |dir| File.directory?(dir) && within?(dir, base) }
+    dirs.compact.uniq.select { |dir| File.directory?(dir) && within?(dir, base) }
   end
 
   def within?(dir, base)

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_state.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "../state_guard"
 require_relative "../../rspec"
 
 # Restores the RSpec.configuration state that ::RSpec::Core::Runner.run mutates

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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "../state_guard"
 require_relative "../../rspec"
 require_relative "internals"
 
@@ -18,7 +19,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/state_guard/example_groups_constants.rb

@@ -1,9 +1,8 @@
 # frozen_string_literal: true
 
+require_relative "../state_guard"
 require_relative "../../rspec"
 
-class Evilution::Integration::RSpec::StateGuard; end unless defined?(Evilution::Integration::RSpec::StateGuard) # rubocop:disable Lint/EmptyClass
-
 class Evilution::Integration::RSpec::StateGuard::ExampleGroupsConstants
   def snapshot
     return nil unless defined?(::RSpec::ExampleGroups)

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

@@ -1,9 +1,8 @@
 # frozen_string_literal: true
 
+require_relative "../state_guard"
 require_relative "../../rspec"
 
-class Evilution::Integration::RSpec::StateGuard; end unless defined?(Evilution::Integration::RSpec::StateGuard) # rubocop:disable Lint/EmptyClass
-
 module Evilution::Integration::RSpec::StateGuard::Internals
   module_function
 

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

@@ -1,9 +1,8 @@
 # frozen_string_literal: true
 
+require_relative "../state_guard"
 require_relative "../../rspec"
 
-class Evilution::Integration::RSpec::StateGuard; end unless defined?(Evilution::Integration::RSpec::StateGuard) # rubocop:disable Lint/EmptyClass
-
 class Evilution::Integration::RSpec::StateGuard::ObjectSpaceExampleGroups
   def snapshot
     groups = Set.new

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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "../state_guard"
 require_relative "../../rspec"
 require_relative "internals"
 

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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "../state_guard"
 require_relative "../../rspec"
 require_relative "internals"
 

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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "../state_guard"
 require_relative "../../rspec"
 require_relative "internals"
 

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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "../state_guard"
 require_relative "../../rspec"
 require_relative "internals"
 

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

@@ -1,6 +1,12 @@
 # frozen_string_literal: true
 
 require_relative "../rspec"
+
+# Declared before the children are required: each child requires this file
+# and nests under StateGuard, while DEFAULT_STRATEGIES below needs the
+# children loaded, so the namespace must exist first.
+class Evilution::Integration::RSpec::StateGuard; end # rubocop:disable Lint/EmptyClass
+
 require_relative "state_guard/object_space_example_groups"
 require_relative "state_guard/world_example_groups"
 require_relative "state_guard/world_sources_by_path"

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/mcp/info_tool/actions/environment.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "../actions"
 require_relative "base"
 require_relative "../../../config"
 require_relative "../../../version"

data/lib/evilution/mcp/info_tool/actions/feedback.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "../actions"
 require_relative "base"
 require_relative "../../../version"
 require_relative "../../../feedback"

data/lib/evilution/mcp/info_tool/actions/statuses.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "../actions"
 require_relative "base"
 require_relative "../status_glossary"
 

data/lib/evilution/mcp/info_tool/actions/subjects.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "../actions"
 require_relative "base"
 require_relative "../config_factory"
 require_relative "../../../runner"

data/lib/evilution/mcp/info_tool/actions/tests.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "../actions"
 require_relative "base"
 require_relative "../config_factory"
 require_relative "../../../runner"

data/lib/evilution/mutation.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require "diff/lcs"
-require_relative "../evilution"
+require_relative "version"
 
 class Evilution::Mutation
   Sources = Data.define(:original, :mutated)

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Drop a call's whole argument list: `combine(a, b)` becomes `combine`,
+# `normalize(value)` becomes `normalize`. Every argument kind goes —
+# positional, splat, keywords and `...` — while a block-pass stays attached
+# (`each_slice(2, &block)` becomes `each_slice(&block)`) and so does a
+# literal block.
+#
+# A kill by ArgumentError proves arity is asserted; a survivor means the
+# arguments never mattered. argument_removal drops one argument at a time and
+# only from calls with two or more.
+#
+# Operator methods (`a + b`, `a[i]`) are left to binary operand promotion and
+# attribute writes to attribute_write_to_read.
+class Evilution::Mutator::Operator::ArgumentListRemoval < Evilution::Mutator::Base
+  IDENTIFIER = /\A[[:alpha:]_]/
+  private_constant :IDENTIFIER
+
+  def visit_call_node(node)
+    remove_argument_list(node) if removable?(node)
+    super
+  end
+
+  private
+
+  def removable?(node)
+    node.arguments && node.message_loc && node.name.match?(IDENTIFIER) && !node.attribute_write?
+  end
+
+  def remove_argument_list(node)
+    block_pass = node.block if node.block.is_a?(Prism::BlockArgumentNode)
+    start = node.message_loc.end_offset
+
+    add_mutation(
+      offset: start,
+      length: argument_list_end(node, block_pass) - start,
+      replacement: block_pass ? "(#{block_pass.slice})" : "",
+      node: node
+    )
+  end
+
+  # Without parentheses the list ends at its last element: the block-pass
+  # when there is one (it always comes last), else the last argument. The
+  # call node itself would reach past a literal `do ... end` block.
+  def argument_list_end(node, block_pass)
+    return node.closing_loc.end_offset if node.closing_loc
+
+    (block_pass || node.arguments).end_offset
+  end
+end