evilution 1.3.0 → 1.5.0

data/lib/evilution/integration/base.rb

@@ -24,11 +24,21 @@ class Evilution::Integration::Base
     return load_error if load_error
 
     fire_hook(:mutation_insert_post, mutation: mutation, file_path: mutation.file_path)
-    run_tests(mutation)
+    Evilution.while_running_tests { run_tests(mutation) }
+  ensure
+    @mutation_applier.restore(mutation) unless restored_by_applier?(load_error)
   end
 
   private
 
+  # The applier evaluates the original to tell that a mutant broke the load of
+  # its file; after that the file is as it was, and need not be restored again.
+  def restored_by_applier?(load_error)
+    return false if load_error.nil?
+
+    load_error[:load_crashed] == true
+  end
+
   def ensure_framework_loaded
     raise NotImplementedError, "#{self.class}#ensure_framework_loaded must be implemented"
   end

data/lib/evilution/integration/known_failures.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "../integration"
+
+# The tests the baseline saw failing before any mutation ran, by the ids the
+# integration gives them.
+#
+# Such a test fails whatever the mutation is, so a mutation run in which
+# nothing else failed has no verdict. The question is asked in the process
+# that ran the tests: the names of everything that failed need not travel
+# back, only the answer.
+class Evilution::Integration::KnownFailures
+  def initialize(ids)
+    @ids = ids.to_set
+  end
+
+  def empty?
+    @ids.empty?
+  end
+
+  # Whether failed_ids names at least one test, and none the baseline did not
+  # already see failing.
+  def only?(failed_ids)
+    !failed_ids.empty? && failed_ids.all? { |id| @ids.include?(id) }
+  end
+end

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
@@ -14,8 +19,9 @@ require_relative "../loading"
 # 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 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.
+# 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
@@ -33,6 +39,12 @@ class Evilution::Integration::Loading::BodyCallNeutralizer
   # 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
+  REDECLARE_PREPENDED = "; #{REDECLARATION}.call(self, :prepended)".freeze
+  CALLBACKS = "::Evilution::Integration::Loading::CallbackRedeclaration"
+
   class << self
     attr_writer :preloaded_features
 
@@ -60,13 +72,35 @@ 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.
+  # A concern's `included` block is never blanked, whether or not it holds
+  # the offset: classes that include the concern later run all of it. Neither
+  # is its `prepended` block, for the classes that prepend it later.
+  # When it does hold the offset, 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)
@@ -78,26 +112,36 @@ 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] = REPLACEMENT
+    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)
+    CONSTANT_WRITES = [
+      Prism::ConstantWriteNode, Prism::ConstantPathWriteNode,
+      Prism::ConstantOperatorWriteNode, Prism::ConstantPathOperatorWriteNode,
+      Prism::ConstantOrWriteNode, Prism::ConstantPathOrWriteNode,
+      Prism::ConstantAndWriteNode, Prism::ConstantPathAndWriteNode
+    ].freeze
+
+    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)
@@ -126,14 +170,134 @@ 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)
+        elsif !registration_only?(stmt)
+          @edits << edit
+        end
+      end
+    end
+
+    # A concern's `included do ... end` runs nothing where it is written: it
+    # hands the block over for the classes that include the concern from then
+    # on. Blanked, it would leave the concern without one -- ConcernStateCleaner
+    # has just dropped the block it had -- and a class including the concern
+    # during the run would get none of its declarations. Left as written, it
+    # registers the same block again. `prepended do ... end` is the same hook
+    # for the classes that prepend the concern.
+    def registration_only?(stmt)
+      block = Evilution::AST::IncludedBlock.of(stmt) || Evilution::AST::IncludedBlock.prepended(stmt)
+      !block.nil?
+    end
 
-        @edits << [stmt.location.start_offset, replacement_end_offset(stmt)]
+    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. A kept `prepended` block is
+    # treated the same, for the classes that prepend it.
+    def scan_included(stmt)
+      redeclare_hook(stmt, Evilution::AST::IncludedBlock.of(stmt), REDECLARE)
+      redeclare_hook(stmt, Evilution::AST::IncludedBlock.prepended(stmt), REDECLARE_PREPENDED)
+    end
+
+    def redeclare_hook(stmt, block, redeclare)
+      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
+
+    # 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.
+    # A method defined in the block is guarded like a call, unless it holds
+    # the offset: defined again on a class that includes the concern already,
+    # it would replace what that class has since defined under the same name.
+    # So is a constant assigned there, which would lose what it has gathered
+    # since. A local variable is assigned again: the rest of the block reads it.
+    def guard_others(block)
+      block.body.body.each do |statement|
+        case statement
+        when Prism::CallNode then guard_call(statement)
+        when Prism::DefNode, *CONSTANT_WRITES then guard(statement) unless holds_offset?(statement)
+        end
       end
     end
 
+    def guard_call(call)
+      return guard(call) unless 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)
+    end
+
+    def guard(statement)
+      start_offset = statement.location.start_offset
+      @edits << [start_offset, start_offset, GUARD]
+    end
+
+    def holds_offset?(node)
+      kept?([node.location.start_offset, node.location.end_offset])
+    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,80 @@
+# frozen_string_literal: true
+
+require_relative "../loading"
+require_relative "own_methods"
+
+# Re-declares one statement of a concern's `included` block on the classes
+# that already include the concern, or of its `prepended` block on those that
+# prepend it.
+#
+# 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. What the block holds besides calls -- a
+# method definition, an assignment -- runs again as well, which is how a
+# mutated method of the block reaches those classes. A method the class has
+# defined itself over one of the block's is kept (OwnMethods). See
+# BodyCallNeutralizer.
+module Evilution::Integration::Loading::ConcernRedeclaration
+  KEY = :evilution_concern_redeclaration
+  BLOCKS = { included: :@_included_block, prepended: :@_prepended_block }.freeze
+
+  # 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?)
+  ANCESTORS = Module.instance_method(:ancestors)
+  private_constant :KEY, :BLOCKS, :INCLUDES, :SUPERCLASS, :SINGLETON, :ANCESTORS
+
+  def self.skipping?
+    Thread.current[KEY] == true
+  end
+
+  # `hook` names the block: `:included` or `:prepended`.
+  def self.call(concern, hook = :included)
+    ivar = BLOCKS.fetch(hook)
+    return unless concern.instance_variable_defined?(ivar)
+
+    block = concern.instance_variable_get(ivar)
+    takers(concern, prepended: hook == :prepended).each { |klass| redeclare(klass, block) }
+  end
+
+  # The classes that took the concern themselves, by including it or by
+  # prepending it; a subclass inherits what its parent declares.
+  def self.takers(concern, prepended:)
+    ObjectSpace.each_object(Class).select do |klass|
+      next false if SINGLETON.bind_call(klass) || !INCLUDES.bind_call(klass, concern)
+
+      parent = SUPERCLASS.bind_call(klass)
+      inherited = !parent.nil? && INCLUDES.bind_call(parent, concern)
+      !inherited && prepended?(klass, concern) == prepended
+    end
+  end
+
+  # A prepended module comes before the class in its ancestors, an included
+  # one after it.
+  def self.prepended?(klass, concern)
+    ancestors = ANCESTORS.bind_call(klass)
+    ancestors.index(concern) < ancestors.index(klass)
+  end
+
+  def self.redeclare(klass, block)
+    previous = Thread.current[KEY]
+    Thread.current[KEY] = true
+    Evilution::Integration::Loading::OwnMethods.keeping(klass, block.source_location.first) do
+      klass.class_eval(&block)
+    end
+  ensure
+    Thread.current[KEY] = previous
+  end
+
+  private_class_method :takers, :prepended?, :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
@@ -51,10 +58,10 @@ class Evilution::Integration::Loading::ConcernStateCleaner
       next unless IVAR_DEFINED.bind_call(mod, ivar)
 
       block = IVAR_GET.bind_call(mod, ivar)
-      block_file = block.source_location&.first
-      next unless block_file
+      location = block.source_location
+      next if location.nil?
 
-      expanded = File.expand_path(block_file)
+      expanded = File.expand_path(location.first)
       REMOVE_IVAR.bind_call(mod, ivar) if source_matches?(expanded, absolute, subpath)
     end
   end