evilution 1.2.0 → 1.4.0

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

@@ -2,6 +2,11 @@
 
 require "prism"
 require_relative "../loading"
+require_relative "../../ast/aasm_declaration"
+require_relative "../../ast/included_block"
+require_relative "../../ast/callback_declaration"
+require_relative "callback_redeclaration"
+require_relative "concern_redeclaration"
 
 # Strip non-idempotent class/module-body side-effect calls from a mutated
 # source before re-eval. Such calls (e.g. dry-monads `register_mixin`, plugin
@@ -13,7 +18,10 @@ 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 `()`.
+# A call spanning several lines leaves its line breaks behind, so the source
+# keeps its line count. 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 +33,17 @@ 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 = "()"
+
+  REDECLARATION = "::Evilution::Integration::Loading::ConcernRedeclaration"
+  GUARD = "#{REDECLARATION}.skipping? or ".freeze
+  REDECLARE = "; #{REDECLARATION}.call(self)".freeze
+  CALLBACKS = "::Evilution::Integration::Loading::CallbackRedeclaration"
+
   class << self
     attr_writer :preloaded_features
 
@@ -52,13 +71,33 @@ class Evilution::Integration::Loading::BodyCallNeutralizer
   # strips method definitions that subsequent sibling statements (alias, etc.)
   # depend on, producing cascading NameError. Callers that don't pass a path
   # get the legacy always-neutralize behavior.
-  def call(source, file_path: nil)
+  #
+  # `keep_offset` (optional) spares the one class-body call whose source
+  # contains that byte offset: a mutation inside a scope body only takes
+  # effect if the mutated file re-runs that `scope` call to replace it.
+  # When that call is an `aasm` machine, only the `event` or `state` holding
+  # the offset is spared inside its block: re-running one declaration replaces
+  # it, while re-running the whole machine would register its
+  # `after_all_transitions`-style callbacks a second time.
+  # When it is a concern's `included` block, the block is kept whole, since
+  # classes that include the concern later run all of it; every other call in
+  # it is guarded and the block is followed by a ConcernRedeclaration call,
+  # which re-declares the spared statement alone on the classes that include
+  # the concern already. Both are added on existing lines, so no line moves.
+  # An `aasm` machine inside such a block is treated the same way one level
+  # down: its other declarations are guarded, not blanked.
+  # When it is a callback declaration (`validate ... if: -> { }`), it is
+  # wrapped in a CallbackRedeclaration call, which puts what the re-run
+  # registers in the place of what the declaration registered before.
+  # `keep_lines` is where that was: the declaration's lines in the file as it
+  # was loaded.
+  def call(source, file_path: nil, keep_offset: nil, keep_lines: nil)
     return source if file_path && !preloaded?(file_path)
 
     result = Prism.parse(source)
     return source if result.failure?
 
-    edits = collect_edits(result.value)
+    edits = collect_edits(source, result.value, keep_offset, keep_lines)
     return source if edits.empty?
 
     apply_edits(source, edits)
@@ -70,26 +109,29 @@ class Evilution::Integration::Loading::BodyCallNeutralizer
     self.class.preloaded_features.include?(File.expand_path(file_path))
   end
 
-  def collect_edits(tree)
+  def collect_edits(source, tree, keep_offset, keep_lines)
     edits = []
-    walker = Walker.new(IDEMPOTENT_CALLS, edits)
+    walker = Walker.new(source, IDEMPOTENT_CALLS, edits, keep_offset, keep_lines)
     walker.visit(tree)
     edits
   end
 
   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"
+    edits.sort_by!(&:first).reverse_each do |start_offset, end_offset, replacement|
+      bytes[start_offset, end_offset - start_offset] = replacement.b
     end
     bytes.force_encoding(source.encoding)
   end
 
   class Walker < Prism::Visitor
-    def initialize(allowlist, edits)
+    def initialize(source, allowlist, edits, keep_offset, keep_lines)
       super()
+      @source = source
       @allowlist = allowlist
       @edits = edits
+      @keep_offset = keep_offset
+      @keep_lines = keep_lines
     end
 
     def visit_class_node(node)
@@ -118,14 +160,99 @@ class Evilution::Integration::Loading::BodyCallNeutralizer
       return unless body_node.is_a?(Prism::StatementsNode)
 
       body_node.body.each do |stmt|
-        next unless stmt.is_a?(Prism::CallNode)
-        next if @allowlist.include?(stmt.name)
-        next if stmt.receiver && !stmt.receiver.is_a?(Prism::SelfNode)
+        next unless neutralizable?(stmt)
+
+        edit = edit_for(stmt)
+        if kept?(edit)
+          scan_kept(stmt)
+        else
+          @edits << edit
+        end
+      end
+    end
+
+    def scan_kept(stmt)
+      scan_machine(stmt)
+      scan_included(stmt)
+      wrap_callbacks(stmt)
+    end
+
+    # A kept callback declaration runs inside a block handed to
+    # CallbackRedeclaration, opened and closed on the declaration's own lines.
+    def wrap_callbacks(stmt)
+      return unless @keep_lines && Evilution::AST::CallbackDeclaration.match?(stmt)
+
+      start_offset = stmt.location.start_offset
+      end_offset = stmt.location.end_offset
+      lines = "#{@keep_lines.first}..#{@keep_lines.last}"
+      @edits << [start_offset, start_offset, "#{CALLBACKS}.call(self, __FILE__, #{lines}) { "]
+      @edits << [end_offset, end_offset, " }"]
+    end
+
+    # A kept `included` block stays whole. Its other calls are guarded rather
+    # than blanked, and what follows it re-declares the spared one on the
+    # classes that include the concern already.
+    def scan_included(stmt)
+      block = Evilution::AST::IncludedBlock.of(stmt)
+      return unless block && block.body.is_a?(Prism::StatementsNode)
+
+      guard_others(block)
+      end_offset = stmt.location.end_offset
+      @edits << [end_offset, end_offset, REDECLARE]
+    end
 
-        @edits << [stmt.location.start_offset, replacement_end_offset(stmt)]
+    # Guards every call of a block but the one holding the offset. When that
+    # one is an `aasm` machine, its own declarations are guarded the same way
+    # rather than blanked: a class that includes the concern later needs the
+    # whole machine, and one that includes it already only the mutated event.
+    # When it is a callback declaration, it is wrapped as it would be in a
+    # class body: the block runs as the including class, so that is whose
+    # chains CallbackRedeclaration rebuilds.
+    def guard_others(block)
+      block.body.body.grep(Prism::CallNode).each do |call|
+        if kept?(edit_for(call))
+          machine = Evilution::AST::AasmDeclaration.machine_block(call)
+          guard_others(machine) if machine && machine.body.is_a?(Prism::StatementsNode)
+          wrap_callbacks(call)
+        else
+          start_offset = call.location.start_offset
+          @edits << [start_offset, start_offset, GUARD]
+        end
       end
     end
 
+    def neutralizable?(stmt)
+      return false unless stmt.is_a?(Prism::CallNode)
+      return false if @allowlist.include?(stmt.name)
+
+      stmt.receiver.nil? || stmt.receiver.is_a?(Prism::SelfNode)
+    end
+
+    # Inside a kept `aasm` block every call is a declaration of the machine,
+    # so all of them but the one holding the offset go.
+    def scan_machine(stmt)
+      block = Evilution::AST::AasmDeclaration.machine_block(stmt)
+      return unless block && block.body.is_a?(Prism::StatementsNode)
+
+      block.body.body.grep(Prism::CallNode).each do |declaration|
+        edit = edit_for(declaration)
+        @edits << edit unless kept?(edit)
+      end
+    end
+
+    # The lines a blanked call took up are kept as empty lines: everything
+    # after it then sits on the line it has in the file, which is where a proc
+    # created by this source says it was written.
+    def edit_for(call)
+      start_offset = call.location.start_offset
+      end_offset = replacement_end_offset(call)
+      [start_offset, end_offset, REPLACEMENT + ("\n" * @source.byteslice(start_offset...end_offset).count("\n"))]
+    end
+
+    def kept?((start_offset, end_offset, _replacement))
+      @keep_offset && @keep_offset >= start_offset && @keep_offset < end_offset
+    end
+
     # Prism CallNode location ends at the close of the call syntax (e.g. the
     # closing `)` or the `<<~MARKER` opener for a heredoc argument). It does
     # NOT include the heredoc body lines or the trailing terminator. Replacing

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

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+require_relative "../loading"
+
+# Runs a callback declaration again and puts what it registers where the
+# callbacks it registered before were.
+#
+# ActiveSupport::Callbacks does not replace on re-declaration. A callback
+# named by a symbol is dropped and added again at the end of its chain; one
+# that is a block or an object (a validator) is simply added, next to the
+# first. Either way a mutated `if:` would run in a chain that is no longer
+# the one the class was written with -- reordered, or with the unmutated
+# original still answering.
+#
+# So the chains are read before the declaration runs and rebuilt afterwards:
+# the callbacks this declaration registered last time give their place to the
+# new ones, and everything else stays where it was, including what subclasses
+# added themselves. See BodyCallNeutralizer for the source that calls this.
+#
+# "Last time" is the file's own load the first time round, and those
+# callbacks are recognised by where their procs were written (or by having
+# been dropped as duplicates). After that the module goes by what it
+# registered itself: a mutation can add or remove lines, so a proc created by
+# the mutated source may report a line that belongs to another declaration of
+# the real file.
+module Evilution::Integration::Loading::CallbackRedeclaration
+  CONDITIONS = %i[@if @unless].freeze
+  private_constant :CONDITIONS
+
+  # klass: the class whose body the declaration is written in. file, lines:
+  # where the declaration is in the file as it was loaded.
+  def self.call(klass, file, lines)
+    return yield unless klass.respond_to?(:__callbacks)
+
+    before = klass.__callbacks.transform_values(&:to_a)
+    result = yield
+    swaps = Settlement.new(klass, Origin.new(file, lines), registered).call(before)
+    swap_validators(klass, swaps)
+    result
+  end
+
+  # What earlier calls registered, by declaration:
+  # { [class, file, first line] => callbacks }.
+  def self.registered
+    @registered ||= {}
+  end
+
+  # `validates` also lists its validator for reflection (`Model.validators`),
+  # once per class; the old one is exchanged for the new there too.
+  def self.swap_validators(klass, swaps)
+    return unless klass.respond_to?(:_validators)
+
+    pairs = swaps.select { |old, new| old && new }.map { |old, new| [old.filter, new.filter] }
+    [klass, *descendants(klass)].each do |target|
+      target._validators.each_value do |validators|
+        pairs.each { |old, new| exchange(validators, old, new) }
+      end
+    end
+  end
+
+  def self.exchange(validators, old, new)
+    return unless validators.any? { |validator| validator.equal?(old) }
+
+    validators.reject! { |validator| validator.equal?(new) }
+    validators[validators.index { |validator| validator.equal?(old) }] = new
+  end
+
+  def self.descendants(klass)
+    klass.subclasses.flat_map { |subclass| [subclass, *descendants(subclass)] }
+  end
+
+  private_class_method :registered, :swap_validators, :exchange, :descendants
+
+  # Callbacks are told apart by identity throughout: two that compare equal
+  # are still two registrations.
+  module Identity
+    def self.member?(callbacks, callback)
+      callbacks.any? { |candidate| candidate.equal?(callback) }
+    end
+
+    def self.without(callbacks, others)
+      callbacks.reject { |callback| member?(others, callback) }
+    end
+  end
+  private_constant :Identity
+
+  # Rebuilds the chains of a class and its descendants after one declaration
+  # has run again.
+  class Settlement
+    def initialize(klass, origin, registered)
+      @klass = klass
+      @origin = origin
+      @registered = registered
+      @key = [klass, origin.file, origin.lines.first]
+    end
+
+    # before: { chain name => callbacks } as they were. Returns [old, new]
+    # callback pairs for what changed hands.
+    def call(before)
+      previous = @registered[@key]
+      mine = []
+      swaps = before.flat_map do |name, callbacks|
+        stale, fresh = settle(name, callbacks, previous)
+        mine.concat(fresh)
+        stale.zip(fresh)
+      end
+      @registered[@key] = mine unless mine.empty?
+      swaps
+    end
+
+    private
+
+    def settle(name, before, previous)
+      after = @klass.__callbacks[name].to_a
+      fresh = Identity.without(after, before)
+      return [[], []] if fresh.empty?
+
+      stale = before.select { |callback| stale?(callback, previous) || !Identity.member?(after, callback) }
+      order = reorder(before, stale, fresh)
+      @klass.send(:__update_callbacks, name) { |target, chain| rebuild(target, name, chain, order, after) }
+      [stale, fresh]
+    end
+
+    # What this declaration registered before: what an earlier call recorded
+    # or, the first time, what was written on its lines -- unless an earlier
+    # call for another declaration put it there.
+    def stale?(callback, previous)
+      return Identity.member?(previous, callback) if previous
+
+      @origin.declared?(callback) && !Identity.member?(@registered.values.flatten, callback)
+    end
+
+    # The new callbacks take the place of the first old one; with no old one
+    # to replace they stay where the declaration put them, at the end.
+    def reorder(before, stale, fresh)
+      return before + fresh if stale.empty?
+
+      before.flat_map do |callback|
+        next fresh if callback.equal?(stale.first)
+
+        Identity.member?(stale, callback) ? [] : [callback]
+      end
+    end
+
+    def rebuild(target, name, chain, order, after)
+      own = Identity.without(chain.to_a, after)
+      chain.clear
+      (order + own).each { |callback| chain.append(callback) }
+      target.send(:set_callbacks, name, chain)
+    end
+  end
+  private_constant :Settlement
+
+  # Where a declaration is written, and whether a callback came from there.
+  class Origin
+    attr_reader :file, :lines
+
+    def initialize(file, lines)
+      @file = canonical(file)
+      @lines = lines
+    end
+
+    def declared?(callback)
+      procs_of(callback).any? { |callable| here?(callable.source_location) }
+    end
+
+    private
+
+    def procs_of(callback)
+      conditions = CONDITIONS.flat_map { |ivar| Array(callback.instance_variable_get(ivar)) }
+      [callback.filter, *conditions].grep(Proc)
+    end
+
+    def here?(location)
+      !location.nil? && canonical(location.first) == @file && @lines.cover?(location.last)
+    end
+
+    # The same file may have been loaded through a symlinked path.
+    def canonical(path)
+      File.realpath(path)
+    rescue SystemCallError
+      File.expand_path(path)
+    end
+  end
+  private_constant :Origin
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative "../loading"
+
+# Re-declares one statement of a concern's `included` block on the classes
+# that already include the concern.
+#
+# A mutation inside `included do ... scope :published, -> { } ... end` has two
+# audiences. Classes that include the concern later run the whole block, so
+# registering the mutated block is enough for them. Classes that already
+# include it ran the original, and running the whole block on them again
+# would add its validations and callbacks a second time.
+#
+# So the source evilution evaluates guards every other call of the block with
+# `skipping?` and ends the block with `call(self)`: the block is run once more
+# on each existing includer with the guard up, and only the mutated
+# declaration takes effect there. See BodyCallNeutralizer.
+module Evilution::Integration::Loading::ConcernRedeclaration
+  KEY = :evilution_concern_redeclaration
+  INCLUDED_BLOCK = :@_included_block
+
+  # Called through UnboundMethods: ObjectSpace hands over every class in the
+  # VM, and one that defines `include?` or `superclass` of its own for its
+  # own purposes must not be asked that question.
+  INCLUDES = Module.instance_method(:include?)
+  SUPERCLASS = Class.instance_method(:superclass)
+  SINGLETON = Module.instance_method(:singleton_class?)
+  private_constant :KEY, :INCLUDED_BLOCK, :INCLUDES, :SUPERCLASS, :SINGLETON
+
+  def self.skipping?
+    Thread.current[KEY] == true
+  end
+
+  def self.call(concern)
+    return unless concern.instance_variable_defined?(INCLUDED_BLOCK)
+
+    block = concern.instance_variable_get(INCLUDED_BLOCK)
+    includers(concern).each { |klass| redeclare(klass, block) }
+  end
+
+  # The classes that include the concern themselves; a subclass inherits what
+  # its parent declares.
+  def self.includers(concern)
+    ObjectSpace.each_object(Class).select do |klass|
+      next false if SINGLETON.bind_call(klass) || !INCLUDES.bind_call(klass, concern)
+
+      parent = SUPERCLASS.bind_call(klass)
+      parent.nil? || !INCLUDES.bind_call(parent, concern)
+    end
+  end
+
+  def self.redeclare(klass, block)
+    previous = Thread.current[KEY]
+    Thread.current[KEY] = true
+    klass.class_eval(&block)
+  ensure
+    Thread.current[KEY] = previous
+  end
+
+  private_class_method :includers, :redeclare
+end

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

@@ -13,19 +13,23 @@ class Evilution::Integration::Loading::ConcernStateCleaner
 
   # 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.
+  # subclasses Module and undefines all of its instance methods, so asking it
+  # anything 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. So the module is never
+  # asked: `Concern === mod` is answered by Concern, and the ivars are reached
+  # through UnboundMethods, which bypass the object's own method table -- this
+  # holds for any method_missing-based wrapper, not just ActiveSupport's.
   # EV-v2rc / GH #1581.
-  SINGLETON_CLASS = Object.instance_method(:singleton_class)
+  #
+  # `===` also leaves the module as it found it. Asking for its
+  # singleton_class instead would create one for every module in the VM, each
+  # of them a module the next sweep has to visit and give a singleton class
+  # of its own; a long in-process run doubles its module count per mutation.
   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
+  private_constant :IVAR_DEFINED, :IVAR_GET, :REMOVE_IVAR
 
   def initialize(subpath_resolver: Evilution::LoadPath::SubpathResolver.new)
     @subpath_resolver = subpath_resolver
@@ -34,11 +38,14 @@ class Evilution::Integration::Loading::ConcernStateCleaner
   def call(file_path)
     return unless defined?(ActiveSupport::Concern)
 
-    absolute = File.expand_path(file_path)
-    subpath = @subpath_resolver.call(file_path)
+    # Anchored on the project, not Dir.pwd: an isolated worker has chdir'd
+    # into a per-mutation sandbox, where a relative path names nothing and no
+    # concern would ever match.
+    absolute = File.expand_path(file_path, Evilution.project_base_dir)
+    subpath = @subpath_resolver.call(absolute)
 
     ObjectSpace.each_object(Module) do |mod|
-      next unless SINGLETON_CLASS.bind_call(mod).ancestors.include?(ActiveSupport::Concern)
+      next unless ActiveSupport::Concern === mod # rubocop:disable Style/CaseEquality
 
       clear_concern_ivars(mod, absolute, subpath)
     end

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

@@ -6,6 +6,7 @@ require_relative "constant_pinner"
 require_relative "concern_state_cleaner"
 require_relative "source_evaluator"
 require_relative "redefinition_recovery"
+require_relative "../../diagnostic"
 
 # Composes the load-time pipeline that applies a mutation's new source to the
 # running VM: syntax-validate -> pin top-level constants (beats Zeitwerk) ->
@@ -45,6 +46,21 @@ class Evilution::Integration::Loading::MutationApplier
     failure_result(e, "#{e.class}: #{e.message}")
   end
 
+  # Evaluates the mutation's restore_source, if it has one. Runs after the
+  # tests: a failure here must not change the mutation's result, so it is
+  # reported and swallowed. Concern state is cleared first, as it is before
+  # applying: a concern ignores an `included` block handed to it twice from
+  # the same place, and would keep the mutated one.
+  def restore(mutation)
+    source = mutation.respond_to?(:restore_source) ? mutation.restore_source : nil
+    return unless source
+
+    @concern_state_cleaner.call(mutation.file_path)
+    @source_evaluator.call(source, mutation.file_path)
+  rescue ScriptError, StandardError => e
+    Evilution::Diagnostic.warn("[evilution] could not restore #{mutation.file_path}: #{e.class}: #{e.message}")
+  end
+
   private
 
   def resolve_eval_target(mutation)

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative "../loading"
+
+# Remembers which test classes each test file registered when it was loaded,
+# so a process that runs many mutations loads a test file once.
+#
+# Minitest and Test::Unit learn of a test class when it is first defined.
+# Loading its file again reopens the class and registers nothing, so the
+# second mutation run in a process would find no tests. The classes of the
+# first load are handed back instead.
+#
+# The block given to .new returns the classes registered so far; what a load
+# adds to them is taken to be that file's.
+class Evilution::Integration::Loading::TestClassCache
+  def initialize(&registered)
+    @registered = registered
+    @classes = {}
+    @partial = {}
+  end
+
+  # The classes the given files registered. Yields each file that has not
+  # been loaded yet; the block loads it.
+  def fetch(files, &)
+    files.flat_map { |file| @classes[file] ||= load_once(file, &) }.uniq
+  end
+
+  def clear
+    @classes.clear
+    @partial.clear
+  end
+
+  private
+
+  # A load that raises is tried again next time. Classes it defined before
+  # raising are already registered and will not register again, so they are
+  # kept for that next attempt.
+  def load_once(file)
+    before = @registered.call
+    yield file
+    @partial.fetch(file, []) | (@registered.call - before)
+  rescue ScriptError, StandardError
+    @partial[file] = @partial.fetch(file, []) | (@registered.call - before)
+    raise
+  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/test_ids.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "../minitest"
+
+# Names a Minitest test the same way in the baseline and in a mutation run:
+# its class and its method, `CalcTest#test_adds`.
+#
+# A test class without a name has only its method to go by, so two such
+# classes with a method of the same name are told apart by neither run.
+module Evilution::Integration::Minitest::TestIds
+  def self.of(result)
+    class_name = result.respond_to?(:class_name) ? result.class_name : result.class.name
+    "#{class_name}##{result.name}"
+  end
+
+  # The ids of the tests that failed, from the summary reporter of the run.
+  # It keeps every result that did not pass, skips included.
+  def self.failed(summary)
+    summary.results.reject(&:skipped?).map { |result| of(result) }
+  end
+end