evilution 1.3.0 → 1.5.0

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) ->
@@ -19,6 +20,14 @@ require_relative "redefinition_recovery"
 # RedefinitionRecovery stays as a safety net for cases the neutralizer's
 # allowlist heuristic misses. Returns nil on success or a failure-shaped
 # hash on any error.
+#
+# A mutated source that raises while it is evaluated never reaches the tests.
+# When the original still evaluates right after it, the mutation is what broke
+# the load, and the failure is marked `load_crashed`: the mutant is detected,
+# as one that crashes a test is. When the original fails too, or there is none
+# to compare with, the failure says nothing about the mutant and stays an
+# error. A syntax error is never the mutant's doing in that sense: it means
+# the mutation was not valid Ruby to begin with.
 class Evilution::Integration::Loading::MutationApplier
   def initialize(syntax_validator: Evilution::Integration::Loading::SyntaxValidator.new,
                  constant_pinner: Evilution::Integration::Loading::ConstantPinner.new,
@@ -42,11 +51,45 @@ class Evilution::Integration::Loading::MutationApplier
   rescue SyntaxError => e
     failure_result(e, "syntax error in mutated source: #{e.message}")
   rescue ScriptError, StandardError => e
-    failure_result(e, "#{e.class}: #{e.message}")
+    load_failure_result(mutation, e)
+  end
+
+  # Evaluates the mutation's restore_source: the original file. 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)
+    evaluate_original(mutation)
+  rescue ScriptError, StandardError => e
+    Evilution::Diagnostic.warn("[evilution] could not restore #{mutation.file_path}: #{e.class}: #{e.message}")
   end
 
   private
 
+  # Whether there was an original to evaluate.
+  def evaluate_original(mutation)
+    source = mutation.respond_to?(:restore_source) ? mutation.restore_source : nil
+    return false unless source
+
+    @concern_state_cleaner.call(mutation.file_path)
+    @source_evaluator.call(source, mutation.file_path)
+    true
+  end
+
+  def original_loads?(mutation)
+    evaluate_original(mutation)
+  rescue ScriptError, StandardError
+    false
+  end
+
+  def load_failure_result(mutation, error)
+    message = "#{error.class}: #{error.message}"
+    return failure_result(error, message) unless original_loads?(mutation)
+
+    failure_result(error, "load failed: #{message}").merge(load_crashed: true)
+  end
+
   def resolve_eval_target(mutation)
     return mutation.eval_source if mutation.respond_to?(:eval_source)
 

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

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require_relative "../loading"
+
+# The methods a class defined itself, held while a concern's hook block is run
+# on it a second time.
+#
+# The first time, the block ran when the class took the concern, and whatever
+# the class went on to define under the same name replaced the block's method.
+# Run again, the block would put its own back in that place: code that is dead
+# for the class would come alive, and its tests would fail whatever the mutant.
+#
+# A method counts as the class's own when it was not written in the block's
+# file. One that is found written there afterwards was replaced by the block,
+# and is put back. A class that defines such a method in the concern's own file
+# cannot be told apart and is not protected.
+class Evilution::Integration::Loading::OwnMethods
+  # Called through UnboundMethods: a class may define any of these for its
+  # own purposes.
+  PUBLIC = Module.instance_method(:public_instance_methods)
+  PROTECTED = Module.instance_method(:protected_instance_methods)
+  PRIVATE = Module.instance_method(:private_instance_methods)
+  LOOKUP = Module.instance_method(:instance_method)
+  DEFINED = Module.instance_method(:method_defined?)
+  PRIVATELY_DEFINED = Module.instance_method(:private_method_defined?)
+  DEFINE = Module.instance_method(:define_method)
+  SINGLETON_CLASS = Kernel.instance_method(:singleton_class)
+  VISIBILITIES = { public: PUBLIC, protected: PROTECTED, private: PRIVATE }.freeze
+  SETTERS = VISIBILITIES.keys.to_h { |visibility| [visibility, Module.instance_method(visibility)] }.freeze
+  private_constant :PUBLIC, :PROTECTED, :PRIVATE, :LOOKUP, :DEFINED, :PRIVATELY_DEFINED, :DEFINE, :SINGLETON_CLASS,
+                   :VISIBILITIES, :SETTERS
+
+  Kept = Struct.new(:owner, :name, :definition, :visibility)
+  private_constant :Kept
+
+  # Runs the block, then puts back the methods of `klass` that the code of
+  # `file` replaced meanwhile -- also when the block raises.
+  def self.keeping(klass, file)
+    own = new(klass, file)
+    begin
+      yield
+    ensure
+      own.put_back
+    end
+  end
+
+  def initialize(klass, file)
+    @file = file
+    @kept = [klass, SINGLETON_CLASS.bind_call(klass)].flat_map { |owner| own_methods_of(owner) }
+  end
+
+  def put_back
+    @kept.each { |kept| restore(kept) if replaced?(kept) }
+  end
+
+  private
+
+  def own_methods_of(owner)
+    VISIBILITIES.flat_map do |visibility, list|
+      list.bind_call(owner, false).filter_map do |name|
+        definition = LOOKUP.bind_call(owner, name)
+        Kept.new(owner, name, definition, visibility) unless written_in_file?(definition)
+      end
+    end
+  end
+
+  def written_in_file?(definition)
+    location = definition.source_location
+    !location.nil? && location.first == @file
+  end
+
+  # A method the block removed stays removed.
+  def replaced?(kept)
+    return false unless defined_on?(kept.owner, kept.name)
+
+    written_in_file?(LOOKUP.bind_call(kept.owner, kept.name))
+  end
+
+  def defined_on?(owner, name)
+    DEFINED.bind_call(owner, name) || PRIVATELY_DEFINED.bind_call(owner, name)
+  end
+
+  def restore(kept)
+    DEFINE.bind_call(kept.owner, kept.name, kept.definition)
+    SETTERS.fetch(kept.visibility).bind_call(kept.owner, kept.name)
+  end
+end

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

@@ -24,6 +24,7 @@ class Evilution::Integration::Loading::RedefinitionRecovery
 
   def initialize(constant_names: Evilution::AST::ConstantNames.new)
     @constant_names = constant_names
+    @warned_messages = Set.new
   end
 
   def call(source, &block)
@@ -73,10 +74,8 @@ class Evilution::Integration::Loading::RedefinitionRecovery
   end
 
   def warn_once_for(error)
-    return if @warned_messages&.include?(error.message)
+    return unless @warned_messages.add?(error.message)
 
-    @warned_messages ||= []
-    @warned_messages << error.message
     $stderr.write(
       "[evilution] swallowed idempotency violation on re-eval: " \
       "#{error.class}: #{error.message}. " \

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

@@ -2,6 +2,7 @@
 
 require_relative "../loading"
 require_relative "reeval_warning_filter"
+require_relative "superseded_modules"
 
 # Evaluate source with __FILE__ set to the absolute original path so that
 # `require_relative` and `__dir__` resolve against the real source tree, where
@@ -13,13 +14,19 @@ require_relative "reeval_warning_filter"
 # between this eval path and a plain `require` of the same file is that we
 # substitute the mutated bytes — the privilege level is identical.
 class Evilution::Integration::Loading::SourceEvaluator
+  def initialize(superseded_modules: Evilution::Integration::Loading::SupersededModules.new)
+    @superseded_modules = superseded_modules
+  end
+
   def call(source, file_path)
     # When the isolator has chdir'd into a per-mutation sandbox (EV-wqxu /
     # 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)
-    Evilution::Integration::Loading::ReevalWarningFilter.suppress do
-      eval(source, TOPLEVEL_BINDING, absolute, 1)
+    @superseded_modules.track(absolute) do
+      Evilution::Integration::Loading::ReevalWarningFilter.suppress do
+        eval(source, TOPLEVEL_BINDING, absolute, 1)
+      end
     end
   end
 end

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

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require_relative "../loading"
+
+# Empties the anonymous modules an earlier evaluation of a file left behind.
+#
+# A file can install a module it never names:
+#
+#   handler = Module.new { def const_missing(name) = ... }
+#   Object.extend(handler)
+#
+# Evaluating the file again builds a new module and extends with it again, and
+# Ruby has no way to take the old one off. Under in-process isolation the file
+# is evaluated for every mutation and every restore, so the modules pile up on
+# their host, and a `super` in the mutation under test runs the code of every
+# mutation before it. Its tests then fail on a predecessor's bug, and the
+# mutation is reported killed. Fork isolation never sees this: a child holds
+# one mutation.
+#
+# A module cannot be taken off, but its methods can be removed, and method
+# lookup passes through a module that has none. So the modules created while a
+# file is evaluated are remembered, and emptied when the same file is evaluated
+# next.
+#
+# Two limits keep this to what the new evaluation really replaces. Only
+# modules are emptied, not anonymous classes, whose instances may be held
+# elsewhere. And only methods written in the file itself are removed: a module
+# some library built on the file's behalf holds methods written in the
+# library, which evaluating the file again does not define anew.
+class Evilution::Integration::Loading::SupersededModules
+  @registry = {}
+
+  class << self
+    # Created modules by file, for the process: the evaluations of one file
+    # are not all made through the same instance.
+    attr_reader :registry
+  end
+
+  MODULE_NAME = Module.instance_method(:name)
+  INSTANCE_OF = Kernel.instance_method(:instance_of?)
+  private_constant :MODULE_NAME, :INSTANCE_OF
+
+  def initialize(registry: self.class.registry)
+    @registry = registry
+  end
+
+  # Evaluates the block as an evaluation of `file_path`. The modules of the
+  # evaluation before are emptied first, so that the new one starts from what
+  # a fresh process would hold; the modules this one creates are remembered
+  # whether or not it completes.
+  #
+  # A fork child holds one mutation and ends with it, so there is nothing for
+  # it to empty later, and walking the heap of a process just forked is dear:
+  # every page touched has to be mapped first. It evaluates and no more.
+  def track(file_path)
+    return yield if Evilution.single_mutation_process?
+
+    retire(file_path)
+    known = anonymous_modules
+    yield
+  ensure
+    remember(file_path, known) if known
+  end
+
+  private
+
+  # Nothing is kept for a file whose evaluation created none, which is most
+  # files: an entry is only worth carrying when there is a module to empty.
+  def remember(file_path, known)
+    created = anonymous_modules.reject { |mod| known.key?(mod) }.keys
+    @registry[file_path] = created unless created.empty?
+  end
+
+  def retire(file_path)
+    Array(@registry.delete(file_path)).each { |mod| empty(mod, file_path) }
+  end
+
+  def empty(mod, file_path)
+    return if mod.frozen?
+
+    own = mod.instance_methods(false) + mod.private_instance_methods(false)
+    own.each { |name| mod.send(:remove_method, name) if written_in?(mod.instance_method(name), file_path) }
+  end
+
+  def written_in?(method, file_path)
+    location = method.source_location
+    !location.nil? && location.first == file_path
+  end
+
+  # No message is sent to the modules walked. ObjectSpace yields everything
+  # that is a Module, and some of it answers messages in its own way: a class
+  # may define `name`, `hash` or `==` for itself, and ActiveSupport's
+  # DeprecatedConstantProxy, a Module subclass, turns any message into a
+  # deprecation, which a project may have set to raise. Hence the identity
+  # keys and the methods bound from Module and Kernel.
+  def anonymous_modules
+    found = {}.compare_by_identity
+    ObjectSpace.each_object(Module) do |mod|
+      found[mod] = true if INSTANCE_OF.bind_call(mod, Module) && MODULE_NAME.bind_call(mod).nil?
+    end
+    found
+  end
+end

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

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
-require "prism"
 require_relative "../loading"
+require_relative "../../ast/syntax_check"
 
 class Evilution::Integration::Loading::SyntaxValidator
   ERROR_MESSAGE = "mutated source has syntax errors"
 
   def call(source)
-    return nil if Prism.parse(source).success?
+    return nil if Evilution::AST::SyntaxCheck.valid?(source)
 
     {
       passed: false,

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/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

data/lib/evilution/integration/minitest.rb

@@ -4,9 +4,12 @@ require "stringio"
 require_relative "base"
 require_relative "../diagnostic"
 require_relative "minitest_crash_detector"
+require_relative "known_failures"
 require_relative "loading/test_load_path"
+require_relative "loading/test_class_cache"
 require_relative "../spec_resolver"
 require_relative "../spec_selector"
+require_relative "../baseline"
 
 require_relative "../integration"
 
@@ -47,12 +50,22 @@ class Evilution::Integration::Minitest < Evilution::Integration::Base
     options = ::Minitest.process_args(["--seed", "0"])
     options[:io] = out
     reporter = ::Minitest::CompositeReporter.new
-    reporter << ::Minitest::SummaryReporter.new(out, options)
+    summary = ::Minitest::SummaryReporter.new(out, options)
+    reporter << summary
     initialize_minitest_state(reporter, options)
     reporter.start
     dispatch_minitest_suites(reporter, options)
     reporter.report
-    reporter.passed?
+    Evilution::Baseline::Report.build(
+      passed: reporter.passed?, failures: baseline_failures(summary), failed_ids: TestIds.failed(summary)
+    )
+  end
+
+  # The summary reporter keeps every result that did not pass, skips included.
+  def self.baseline_failures(summary)
+    summary.results.reject(&:skipped?).map do |result|
+      { id: TestIds.of(result), description: "", message: result.failure.message }
+    end
   end
 
   # Mirror Minitest.run's preamble: seed setup + plugin init. Without seeding
@@ -84,6 +97,12 @@ class Evilution::Integration::Minitest < Evilution::Integration::Base
     end
   end
 
+  # Shared by every instance: the canary and the mutation runs build their
+  # own, and a file loaded for one must not be loaded again for the other.
+  def self.test_classes
+    @test_classes ||= Evilution::Integration::Loading::TestClassCache.new { ::Minitest::Runnable.runnables.dup }
+  end
+
   def self.baseline_options
     {
       runner: baseline_runner,
@@ -92,8 +111,10 @@ class Evilution::Integration::Minitest < Evilution::Integration::Base
     }
   end
 
-  def initialize(test_files: nil, hooks: nil, fallback_to_full_suite: false, spec_selector: nil)
+  # known_failures: the ids of the tests the baseline saw failing (see TestIds).
+  def initialize(test_files: nil, hooks: nil, fallback_to_full_suite: false, spec_selector: nil, known_failures: [])
     @test_files = test_files
+    @known_failures = Evilution::Integration::KnownFailures.new(known_failures)
     @minitest_loaded = false
     @spec_selector = spec_selector || Evilution::SpecSelector.new(
       spec_resolver: Evilution::SpecResolver.new(test_dir: "test", test_suffix: "_test.rb", request_dir: "integration")
@@ -132,17 +153,27 @@ class Evilution::Integration::Minitest < Evilution::Integration::Base
   end
 
   def execute_minitest(mutation, files, command)
-    Evilution::Integration::Loading::TestLoadPath.add!(files)
-    files.each { |f| load(File.expand_path(f, Evilution.project_base_dir)) }
+    load_test_classes(files)
 
     detector = reset_crash_detector
     run = run_minitest(build_args(mutation), detector)
 
     return no_tests_ran_result(command) if run[:count].zero?
+    # Before the crash check: a test that was already failing may fail by
+    # raising now, and a crash in it is no more a kill than its failure was.
+    return known_failures_only_result(command) if @known_failures.only?(run[:failed_ids])
 
     build_minitest_result(run[:passed], command, detector)
   end
 
+  # Leaves Minitest with the test classes of these files and no others.
+  def load_test_classes(files)
+    Evilution::Integration::Loading::TestLoadPath.add!(files)
+    paths = files.map { |f| File.expand_path(f, Evilution.project_base_dir) }
+    classes = self.class.test_classes.fetch(paths) { |path| load(path) }
+    ::Minitest::Runnable.runnables.replace(classes)
+  end
+
   # Zero dispatched test methods means the run carries no signal — the result
   # is neither survived nor killed. Most common cause: the project's tests use
   # a framework other than Minitest (e.g. the test-unit gem, whose
@@ -160,6 +191,12 @@ class Evilution::Integration::Minitest < Evilution::Integration::Base
     }
   end
 
+  # Every test that failed was already failing in the baseline. Still a
+  # failed run, but flagged, so it is not taken for a kill.
+  def known_failures_only_result(command)
+    { passed: false, known_failures_only: true, test_command: command }
+  end
+
   def unresolved_result(mutation)
     {
       passed: false,
@@ -190,7 +227,7 @@ class Evilution::Integration::Minitest < Evilution::Integration::Base
     dispatch_minitest_suites(reporter, options)
     reporter.report
 
-    { passed: summary.passed?, count: minitest_method_count }
+    { passed: summary.passed?, count: minitest_method_count, failed_ids: TestIds.failed(summary) }
   end
 
   # Attach evilution's own reporters to the composite AFTER plugin init, and
@@ -293,3 +330,5 @@ class Evilution::Integration::Minitest < Evilution::Integration::Base
     end
   end
 end
+
+require_relative "minitest/test_ids"

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

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
+require "stringio"
 require_relative "../rspec"
+require_relative "../../baseline"
+require_relative "example_ids"
 
 class Evilution::Integration::RSpec::BaselineRunner
   def call(spec_file)
@@ -9,10 +12,51 @@ class Evilution::Integration::RSpec::BaselineRunner
     # FrameworkLoader#add_spec_load_path for rationale.
     spec_dir = File.expand_path("spec", Evilution.project_base_dir)
     $LOAD_PATH.unshift(spec_dir) unless $LOAD_PATH.include?(spec_dir)
-    ::RSpec.reset
+    reset_examples
+    output = StringIO.new
     status = ::RSpec::Core::Runner.run(
-      ["--format", "progress", "--no-color", "--order", "defined", spec_file]
+      ["--format", "progress", "--no-color", "--order", "defined", spec_file], output, output
     )
-    status.zero?
+    report(status.zero?, output.string)
+  end
+
+  private
+
+  # Examples are cleared, the configuration is kept: a helper loaded by
+  # --preload is not loaded again by the spec's own require, so an
+  # RSpec.configure block dropped here never comes back, and a spec relying on
+  # it goes red in the baseline alone.
+  def reset_examples
+    ::RSpec.respond_to?(:clear_examples) ? ::RSpec.clear_examples : ::RSpec.reset
+  end
+
+  # What RSpec printed is the only account of a failure outside any example --
+  # a file that does not load, a suite hook that raises.
+  def report(passed, output)
+    return Evilution::Baseline::Report.build(passed: true) if passed
+
+    failures = failed_examples
+    Evilution::Baseline::Report.build(
+      passed: false, failures: failures, error: failures.empty? ? output : nil,
+      failed_ids: Evilution::Integration::RSpec::ExampleIds.failed(::RSpec.world)
+    )
+  end
+
+  def failed_examples
+    world = ::RSpec.world
+    return [] unless world.respond_to?(:all_examples)
+
+    world.all_examples
+         .select { |example| example.execution_result.status == :failed }
+         .map { |example| failure(example) }
+  end
+
+  def failure(example)
+    exception = example.execution_result.exception
+    {
+      id: example.id,
+      description: example.full_description,
+      message: exception ? "#{exception.class}: #{exception.message}" : nil
+    }
   end
 end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "../rspec"
+
+# Names an example the same way wherever it runs.
+#
+# RSpec's own id starts with the spec file as it was given: `./spec/a_spec.rb`
+# from the project root, an absolute path from an isolated worker that has
+# changed directory. The baseline and a mutation run can therefore disagree
+# about the same example, so the path is made absolute and symlinks are
+# resolved before the position within the file is added.
+module Evilution::Integration::RSpec::ExampleIds
+  FAILED = :failed
+
+  def self.of(example)
+    metadata = example.metadata
+    "#{canonical(metadata[:rerun_file_path])}[#{metadata[:scoped_id]}]"
+  end
+
+  # The ids of the examples that failed in the run RSpec.world still holds.
+  def self.failed(world)
+    return [] unless world.respond_to?(:all_examples)
+
+    world.all_examples
+         .select { |example| example.execution_result.status == FAILED }
+         .map { |example| of(example) }
+  end
+
+  def self.canonical(path)
+    File.realpath(path)
+  rescue SystemCallError
+    File.expand_path(path)
+  end
+  private_class_method :canonical
+end

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

@@ -21,8 +21,13 @@ class Evilution::Integration::RSpec::ResultBuilder
     }
   end
 
-  def from_run(status, command, detector, examples_loaded: nil)
+  # known_failures_only: every example that failed was already failing in the
+  # baseline. Still a failed run, but flagged, so it is not taken for a kill.
+  def from_run(status, command, detector, examples_loaded: nil, known_failures_only: false)
     return { passed: true, test_command: command } if status.zero?
+    # Before the crash check: an example that was already failing may fail by
+    # raising now, and a crash in it is no more a kill than its failure was.
+    return { passed: false, known_failures_only: true, test_command: command } if known_failures_only
 
     if detector.only_crashes?
       classes = detector.unique_crash_classes

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "../state_guard"
+require_relative "../../rspec"
+
+# Drops the examples a run registers on RSpec::Core::AnonymousExampleGroup.
+#
+# Example#initialize appends every example to its group's `examples`. Most
+# groups are thrown away with the run, but AnonymousExampleGroup is a constant:
+# whatever lands there stays for the life of the process. A run with a suite
+# hook puts a SuiteHookContext there, and the reporter notifying a non-example
+# exception puts an Example there. Each holds that run's reporter, and the
+# reporter holds every example the run loaded, so one in-process run after
+# another retained them all, about 1 MB per mutation on the memory_check
+# fixture.
+#
+# Forked runs never leak this (the child dies), only the in-process path.
+class Evilution::Integration::RSpec::StateGuard::AnonymousExampleGroupExamples
+  def snapshot
+    examples&.length
+  end
+
+  def release(length)
+    return unless length
+
+    examples&.slice!(length..)
+  end
+
+  private
+
+  def examples
+    return nil unless defined?(::RSpec::Core::AnonymousExampleGroup)
+
+    ::RSpec::Core::AnonymousExampleGroup.examples
+  end
+end