mutineer 1.5.0 → 1.6.0

data/lib/mutineer/result.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Mutineer
-  # Immutable outcome of running one mutant. Eight distinct states:
+  # Immutable outcome of running one mutant. Ten distinct states:
   #   killed       - a test failed/errored, so the mutation was caught.
   #   survived     - every test passed, so the mutation went undetected.
   #   error        - the child crashed (unhandled exception): exit status 2.
@@ -13,6 +13,19 @@ module Mutineer
   #                  like no_coverage, but reported separately: it signals a
   #                  broken harness (a test that failed to run), not a genuine
   #                  coverage gap.
+  #   unplaceable  - under `--strategy redefine`, the method belongs to a class
+  #                  or module that cannot be named statically, so it has no
+  #                  owner to be loaded onto and is not run. Excluded from the
+  #                  denominator and, unlike uncapturable, from the
+  #                  no-verdict gate: nothing is broken. `--strategy reload`
+  #                  runs these mutants.
+  #   ran_at_load  - the mutated line ran while the app booted or its class
+  #                  loaded. That run happened before the mutant was applied,
+  #                  so a test can check a value the original code computed.
+  #                  A survivor on such a line, and a line that ran only at
+  #                  load, get this status; a kill stays killed. Excluded from
+  #                  the denominator and from the no-verdict gate, like
+  #                  unplaceable. `--test-command` verifies these mutants.
   #   ignored      - a known-equivalent mutant the user suppressed, via an
   #                  inline `# mutineer:disable-line` comment or a
   #                  `.mutineer.yml` `ignore:` id. A pre-fork classification
@@ -21,8 +34,9 @@ module Mutineer
   #
   # `error` and `skipped` are deliberately distinct: skipped is a pre-fork
   # validity failure (counted separately by the reporter), error is a runtime
-  # crash. Never conflate them via `details` string parsing. `no_coverage` and
-  # `uncapturable` are pre-fork selection results: both excluded from the score
+  # crash. Never conflate them via `details` string parsing. `no_coverage`,
+  # `uncapturable` and `unplaceable` are pre-fork results, and `ran_at_load` is
+  # pre-fork or a reclassified survivor: all excluded from the score
   # denominator.
   #
   # `subject`, `mutation`, and `id` are nil when the Result is built by
@@ -89,6 +103,16 @@ module Mutineer
     # @return [Mutineer::Result] uncapturable result.
     def self.uncapturable = new(status: :uncapturable, details: nil, subject: nil, mutation: nil, id: nil)
 
+    # Builds an unplaceable result.
+    #
+    # @return [Mutineer::Result] unplaceable result.
+    def self.unplaceable = new(status: :unplaceable, details: nil, subject: nil, mutation: nil, id: nil)
+
+    # Builds a ran_at_load result.
+    #
+    # @return [Mutineer::Result] ran-at-load result.
+    def self.ran_at_load = new(status: :ran_at_load, details: nil, subject: nil, mutation: nil, id: nil)
+
     # Builds an ignored result.
     #
     # @return [Mutineer::Result] ignored result.
@@ -108,6 +132,10 @@ module Mutineer
     def no_coverage?  = status == :no_coverage
     # @return [Boolean] true when the status is uncapturable.
     def uncapturable? = status == :uncapturable
+    # @return [Boolean] true when the status is unplaceable.
+    def unplaceable?  = status == :unplaceable
+    # @return [Boolean] true when the status is ran_at_load.
+    def ran_at_load?  = status == :ran_at_load
     # @return [Boolean] true when the status is ignored.
     def ignored?      = status == :ignored
 
@@ -130,7 +158,7 @@ module Mutineer
 
   # Aggregates a flat list of Results into counts, the mutation score, and the
   # surviving-mutant list. The score denominator is killed + survived ONLY:
-  # no-coverage, uncapturable, skipped (invalid), errored, timeout, and ignored
+  # no-coverage, uncapturable, unplaceable, ran-at-load, skipped (invalid), errored, timeout, and ignored
   # (equivalent-mutant suppression) are each excluded and surfaced separately,
   # so suppressing every survivor reaches 100%. An empty denominator yields a
   # nil score (rendered "N/A"), never 0.0, distinguishing "no testable mutants"
@@ -154,6 +182,10 @@ module Mutineer
     def no_coverage_count     = count(:no_coverage)
     # @return [Integer] uncapturable count.
     def uncapturable_count    = count(:uncapturable)
+    # @return [Integer] unplaceable count.
+    def unplaceable_count     = count(:unplaceable)
+    # @return [Integer] ran-at-load count.
+    def ran_at_load_count     = count(:ran_at_load)
     # @return [Integer] skipped-invalid count.
     def skipped_invalid_count = count(:skipped)
     # @return [Integer] errored count.

data/lib/mutineer/runner.rb

@@ -1,25 +1,21 @@
 # frozen_string_literal: true
 
-require "digest"
 require "pathname"
 require_relative "parser"
 require_relative "project"
 require_relative "result"
-require_relative "statement_lines"
 require_relative "isolation"
 require_relative "minitest_integration"
 require_relative "test_runners"
 require_relative "coverage_map"
-require_relative "changed_lines"
 require_relative "mutator_registry"
 require_relative "worker_pool"
 require_relative "progress"
-require_relative "mutant_id"
 require_relative "project_path"
 require_relative "file_swap"
 require_relative "external_backend"
 require_relative "daemon_backend"
-require "set"
+require_relative "job_plan"
 
 module Mutineer
   # Orchestrates one mutation end-to-end: apply it textually, validate the
@@ -35,7 +31,7 @@ module Mutineer
     # Full orchestration: resolve operators, discover subjects, build the
     # coverage map, run every mutation, and aggregate. Returns
     # [AggregateResult, source_map, extras], where extras is the hash
-    # {.collect_jobs} returns (`:legacy_ignore_matches`, `:id_map`), unchanged.
+    # {JobPlan.collect_jobs} returns (`:legacy_ignore_matches`, `:id_map`), unchanged.
     # The CLI then reports + applies the exit code; the integration test asserts
     # directly on the AggregateResult.
     #
@@ -74,13 +70,20 @@ module Mutineer
         # Coverage instruments only files loaded AFTER it starts. Start it BEFORE
         # the boot require so the entire app loaded during boot is instrumented;
         # forked children then measure each test's coverage delta against it.
+        # An earlier run in this process leaves Coverage suspended (see below).
+        # Coverage a host started is the host's: it is left running.
         require "coverage"
-        Coverage.start(lines: true) unless Coverage.running?
+        own_coverage = !Coverage.running?
+        case Coverage.state
+        when :idle then Coverage.start(lines: true, methods: true)
+        when :suspended then Coverage.resume
+        end
         require File.expand_path(config.boot, config.project_root)
       else
         config.sources.each { |f| require File.expand_path(f, config.project_root) }
       end
       config.require_paths.each { |f| require File.expand_path(f, config.project_root) }
+      preload_owners(config) if config.boot && config.strategy == "redefine"
 
       if config.boot
         # Rails/Minitest test files do `require "test_helper"`, which needs the
@@ -88,7 +91,7 @@ module Mutineer
         # file's helper root here in the parent so loading them in the fork
         # children (both coverage capture and per-mutant) resolves.
         boot_tests = config.tests.map { |t| File.expand_path(t, config.project_root) }
-        test_load_roots(boot_tests).each { |d| $LOAD_PATH.unshift(d) unless $LOAD_PATH.include?(d) }
+        JobPlan.test_load_roots(boot_tests).each { |d| $LOAD_PATH.unshift(d) unless $LOAD_PATH.include?(d) }
 
         # Boot mode now uses coverage selection too: capture each test's coverage
         # by forking the booted parent, then select covering tests per mutant.
@@ -97,12 +100,16 @@ module Mutineer
           cache_dir: File.expand_path(config.cache_dir, config.project_root), project_root: config.project_root,
           load_paths: config.load_paths, framework: config.framework,
           boot_path: File.expand_path(config.boot, config.project_root),
+          require_paths: config.require_paths, # loaded above; here only for the cache digest
           verbose: config.verbose,
           capture_timeout: config.capture_timeout || CoverageMap::DEFAULT_CAPTURE_TIMEOUT
         ).build_via_fork(after_fork: (config.rails ? -> { reconnect_active_record } : nil))
+        # Nothing reads Coverage once the map is built (cache hit or not), so
+        # stop paying for it in every mutant fork (#228).
+        Coverage.suspend if own_coverage && Coverage.running?
       else
         # As in boot mode, and with lib first as `rake test` does.
-        test_roots = test_load_roots(config.tests.map { |t| File.expand_path(t, config.project_root) })
+        test_roots = JobPlan.test_load_roots(config.tests.map { |t| File.expand_path(t, config.project_root) })
         libs = config.load_paths.map { |p| File.expand_path(p, config.project_root) }
         $LOAD_PATH.unshift(*(libs + test_roots).uniq.reject { |d| $LOAD_PATH.include?(d) })
         # Relative, so the cache digest does not depend on the checkout path.
@@ -111,23 +118,24 @@ module Mutineer
           source_paths: config.sources, test_paths: config.tests,
           cache_dir: File.expand_path(config.cache_dir, config.project_root), project_root: config.project_root,
           load_paths: config.load_paths + rel_roots, framework: config.framework,
+          require_paths: config.require_paths,
           capture_timeout: config.capture_timeout || CoverageMap::DEFAULT_CAPTURE_TIMEOUT
         ).build_or_load
       end
-      abort_if_unclean!(coverage_map)
+      JobPlan.abort_if_unclean!(coverage_map)
 
       # Collect every (subject, mutation) up front so the pool can fan them out.
-      jobs, ignored_results, source_map, extras = collect_jobs(config, operator_classes)
+      jobs, ignored_results, source_map, extras = JobPlan.collect_jobs(config, operator_classes)
 
-      jobs = filter_since(jobs, source_map, config) if config.since
+      jobs = JobPlan.filter_since(jobs, source_map, config) if config.since
 
       # Whole-file reload writes mutineer_mutant*.rb into each source dir (so
       # require_relative resolves). A SIGKILL'd child skips the tempfile's
       # ensure-unlink, orphaning it. `ensure` is unreliable vs SIGKILL, so the
       # PARENT sweeps each source dir before and after the run. Orphans are
       # impossible after a normal run.
-      dirs = source_dirs(config)
-      sweep_orphans(dirs)
+      dirs = JobPlan.source_dirs(config)
+      JobPlan.sweep_orphans(dirs)
 
       strategy = config.strategy
       # Fail-fast must be serial: a parallel stop_when fires on the first survivor
@@ -153,7 +161,7 @@ module Mutineer
             r&.with(subject: jobs[i][0], mutation: jobs[i][1], id: jobs[i][2])
           end)
         ensure
-          sweep_orphans(dirs)
+          JobPlan.sweep_orphans(dirs)
         end
 
       [AggregateResult.new(results + ignored_results), source_map, extras]
@@ -171,109 +179,6 @@ module Mutineer
       result.with(kills: Kills.new(killed_by: [], ran: [], complete: false))
     end
 
-    # Collect every (subject, mutation, id) up front so a backend can run them.
-    # A mutant the user marked known-equivalent (inline disable-line comment or
-    # .mutineer.yml ignore id) is classified :ignored here and NEVER run. It is
-    # removed from the killed+survived denominator so a strong file reaches 100%.
-    # The id is computed per subject (occurrence needs the full list), keyed on
-    # the file path relative to config.project_root, and carried on every job so
-    # the parent can reattach it after the run. Shared by the in-process,
-    # external, and daemon backends so job selection can never drift.
-    #
-    # Each mutant also gets its old-format id ({MutantId.legacy_for}), so an ignore
-    # entry stored before ids carried the path still suppresses it. Prints nothing:
-    # the extras hash returns, as data, `legacy_ignore_matches` (each old-format
-    # ignore entry that matched a mutant through its old-format id => one
-    # `{id:, file:, subject:}` hash per matched mutant, in collection order: its
-    # new id, its project-relative file and its subject's qualified name;
-    # recorded even when a new id is also listed, since the old entry still
-    # over-matches other files) and `id_map` (every new id => its old-format id).
-    #
-    # Subjects sharing a qualified name in one file (two owner-less `def index`
-    # in two DSL blocks) get a per-file ordinal in discovery order, so their ids
-    # differ; the first one's ordinal is 0 and leaves its id unchanged.
-    #
-    # @param config [Mutineer::Config] run configuration.
-    # @param operator_classes [Array<Class>] resolved operators.
-    # @return [Array(Array, Array<Result>, Hash<String,String>, Hash{Symbol => Hash})]
-    #   jobs, ignored, source_map, and extras (`:legacy_ignore_matches`, `:id_map`).
-    def self.collect_jobs(config, operator_classes)
-      source_map = {}
-      disabled_map = {}
-      id_paths = {}
-      # [file, qualified_name] => { declaration offset => ordinal }: keyed by the
-      # declaration, so the same file discovered twice (two path spellings) reuses
-      # its ordinal instead of minting a second id for the same mutant.
-      name_decls = Hash.new { |h, k| h[k] = {} }
-      ignore_set = config.ignore.to_set
-      jobs = []
-      ignored_results = []
-      legacy_ignore_matches = {}
-      id_map = {}
-      Project.discover(config.sources, only: config.only).each do |subject|
-        source = (source_map[subject.file] ||= File.read(subject.file))
-        disabled = (disabled_map[subject.file] ||= suppress_map(source, subject.file))
-        mutations = operator_classes.flat_map { |klass| klass.new.mutations_for(subject, source) }
-        id_path = (id_paths[subject.file] ||= ProjectPath.relative(subject.file, config.project_root))
-        decls = name_decls[[id_path, subject.qualified_name]]
-        ordinal = (decls[subject.def_node.location.start_offset] ||= decls.size)
-        ids = MutantId.for_subject(subject, source, mutations, path: id_path, subject_ordinal: ordinal)
-        legacy_ids = MutantId.legacy_for_subject(subject, source, mutations)
-        lines = mutations.map { |m| source.byteslice(0, m.start_offset).count("\n") + 1 }
-        keys = result_keys(mutations, source, lines)
-        # A repeat of an earlier edit on the same line is dropped (#159),
-        # separately among the run and the ignored mutants, so an ignored copy
-        # never hides a copy that should run. A dropped copy records nothing.
-        seen = { run: Set.new, ignored: Set.new }
-        mutations.each_with_index do |mutation, i|
-          id = ids[i]
-          legacy = legacy_ids[i]
-          ignored = suppressed?(mutation.operator, lines[i], [id, legacy], disabled, ignore_set)
-          next unless seen[ignored ? :ignored : :run].add?(keys[i])
-
-          id_map[id] = legacy
-          # An old entry still over-matches other files even when the new id is
-          # listed too, so every old-entry match is reported for migration.
-          if ignore_set.include?(legacy)
-            (legacy_ignore_matches[legacy] ||= []) << { id: id, file: id_path, subject: subject.qualified_name }
-          end
-          if ignored
-            ignored_results << Result.ignored.with(subject: subject, mutation: mutation, id: id)
-          else
-            jobs << [subject, mutation, id]
-          end
-        end
-      end
-      [jobs, ignored_results, source_map, { legacy_ignore_matches: legacy_ignore_matches, id_map: id_map }]
-    end
-
-    # One key per mutation; two mutations share a key exactly when they are
-    # the same operator on the same line and give the same mutated source (one
-    # edit, #159). The caller drops a repeat after ids are assigned. Only a
-    # group of same-operator, same-line mutations can repeat, so only those
-    # build a key from their text: the span from the group's earliest start to
-    # its latest end, digested. Every other mutation gets a key of its own.
-    #
-    # @param mutations [Array<Mutineer::Mutation>] one subject's mutations.
-    # @param source [String] the full, unmutated source.
-    # @param lines [Array<Integer>] each mutation's line.
-    # @return [Array<Object>] one key per mutation, in order.
-    def self.result_keys(mutations, source, lines)
-      keys = Array.new(mutations.size) { |i| i }
-      mutations.each_index.group_by { |i| [mutations[i].operator, lines[i]] }.each_value do |group|
-        next if group.size < 2
-
-        from = group.map { |i| mutations[i].start_offset }.min
-        to = group.map { |i| mutations[i].end_offset }.max
-        group.each do |i|
-          m = mutations[i]
-          span = "#{source.byteslice(from...m.start_offset)}#{m.replacement}#{source.byteslice(m.end_offset...to)}"
-          keys[i] = [m.operator, lines[i], Digest::SHA256.digest(span)]
-        end
-      end
-      keys
-    end
-
     # External backend orchestration. Runs each mutant's whole-file mutation on
     # disk (crash-safe swap) and executes the user's --test-command as a subprocess
     # in the app's own runtime. Serial by construction (one shared DB, no
@@ -284,7 +189,7 @@ module Mutineer
     # @param config [Mutineer::Config] run configuration (test_command set).
     # @param operator_classes [Array<Class>] resolved operators.
     # @return [Array(Mutineer::AggregateResult, Hash<String,String>, Hash)] aggregate,
-    #   source map, and the {.collect_jobs} extras.
+    #   source map, and the {JobPlan.collect_jobs} extras.
     def self.execute_external(config, operator_classes)
       abs_tests = config.tests.map { |t| File.expand_path(t, config.project_root) }
       sources   = config.sources.map { |s| FileSwap.canonical_path(File.expand_path(s, config.project_root)) }
@@ -300,8 +205,8 @@ module Mutineer
         # source. Heal first, then discover jobs from the clean tree.
         FileSwap.restore_orphans(dirs)
 
-        jobs, ignored_results, source_map, extras = collect_jobs(config, operator_classes)
-        jobs = filter_since(jobs, source_map, config) if config.since
+        jobs, ignored_results, source_map, extras = JobPlan.collect_jobs(config, operator_classes)
+        jobs = JobPlan.filter_since(jobs, source_map, config) if config.since
 
         # Nothing to mutate: return before the smoke check, which runs the whole
         # --test set to calibrate a timeout no mutant would use (#76).
@@ -350,146 +255,29 @@ module Mutineer
       end
     end
 
-    # Aborts the run when coverage capture saw a red unmutated suite. Scoring
-    # those results would treat existing assertion failures as killed mutants.
+    # Loads the class or module of every subject in the booted parent, before
+    # the boot coverage is read. Under redefine a child resolves the owner by
+    # name ({Isolation.nesting_keywords}), so a lazily loaded class (Zeitwerk,
+    # `autoload`) would run its class body there, with the original method,
+    # and that run would count as no load at all. Loading it here makes its
+    # class-body calls load lines, the same as an eager load. A constant that
+    # fails to load stays lazy.
     #
-    # @param coverage_map [Mutineer::CoverageMap] the built or loaded map.
+    # @param config [Mutineer::Config] run configuration.
     # @return [void]
-    # @raise [Mutineer::SmokeCheckError] when any captured test failed clean,
-    #   or when no test recorded coverage and a capture failed.
-    def self.abort_if_unclean!(coverage_map)
-      if coverage_map.map.empty? && coverage_map.failed_test_files.any?
-        raise SmokeCheckError, "no test recorded coverage, and capture failed for #{coverage_map.failed_test_files.join(', ')}"
-      end
-
-      files = coverage_map.failed_clean_tests
-      return if files.empty?
-
-      raise SmokeCheckError,
-            "the unmutated suite is not green (#{files.join(', ')}) — " \
-            "#{ExternalBackend.generic_env_hint}."
-    end
-
-    # Coverage-based test selection, shared by the in-process ({run}) and daemon
-    # paths so both narrow identically (score parity). Returns
-    # `[:run, abs_test_paths]` when some test covers the mutant's line, or
-    # `[:verdict, Result]` (no_coverage / uncapturable) when none do. A line
-    # Ruby does not count (a later line of a multi-line statement) uses the
-    # tests that ran the statement that holds it ({StatementLines}), unless the
-    # mutant sits in code of that statement that runs only sometimes.
-    #
-    # An empty selection is `:uncapturable` (not `:no_coverage`) when the
-    # mutant's enclosing method body got coverage from no *successful* capture but
-    # a sibling test failed to capture: the coverage was lost, not absent. Both are
-    # excluded from the score denominator, so this distinction is reporting-only
-    # and never changes the daemon-vs-in-process score.
-    #
-    # @param source_file [String] the mutated source file path.
-    # @param mutation [Mutineer::Mutation] the mutation (for its line offset).
-    # @param subject [Mutineer::Subject, nil] the subject (for its method body range).
-    # @param source [String] the original source text.
-    # @param coverage_map [Mutineer::CoverageMap] the built/loaded coverage map.
-    # @return [Array(Symbol, Object)] `[:run, Array<String>]` or `[:verdict, Result]`.
-    def self.coverage_selection(source_file, mutation, subject, source, coverage_map)
-      line   = source.byteslice(0, mutation.start_offset).count("\n") + 1
-      chosen = coverage_map.tests_for(source_file, line)
-      if chosen.empty? && subject
-        # A multi-line statement has a count on one of its lines only.
-        lines = StatementLines.for(subject.def_node, source, mutation.start_offset)
-        chosen = lines.flat_map { |l| coverage_map.tests_for(source_file, l) }.uniq
-      end
-      if chosen.empty?
-        # Method BODY range, not the whole def: the def/end lines are "covered" at
-        # class-load even when the body never runs (body_loc is the statements' span).
-        loc   = subject&.body_loc
-        range = loc ? (loc.start_line..loc.end_line) : (line..line)
-        return [:verdict, coverage_map.method_uncapturable?(source_file, range) ? Result.uncapturable : Result.no_coverage]
-      end
-
-      [:run, chosen.map { |t| File.expand_path(t, coverage_map.project_root) }]
-    end
-
-    # Map each line number to :all or a set of operator symbols, using
-    # inline `# mutineer:disable-line [ops]` markers (RuboCop semantics: the marker
-    # sits on the same physical line as the code it silences). A bare marker
-    # disables every operator on that line; `disable-line a, b` only the listed
-    # operators. Block-form disable/enable ranges are intentionally not supported.
-    # Only a real `#` comment counts: Prism lists the comments, so the marker
-    # text inside a string, heredoc or regex silences nothing (#158).
-    def self.suppress_map(source, file)
-      map = {}
-      Parser.comments(source).grep(Prism::InlineComment).each do |comment|
-        line = comment.location.start_line
-        next unless (m = comment.slice.match(/#\s*mutineer:disable-line(?:\s+([\w,\s]+))?/))
-
-        ops = m[1]&.split(",")&.map(&:strip)&.reject(&:empty?)
-        # Only spaces or commas after the marker (e.g. `disable-line  -- why`)
-        # is a bare marker, not an empty list that silences nothing.
-        ops = nil if ops&.empty?
-        unknown = ops.to_a.reject { |o| MutatorRegistry::ALL.key?(o) }
-        unknown.each do |o|
-          warn "mutineer: unknown operator #{o.inspect} in #{file}:#{line} " \
-               "(known: #{MutatorRegistry::ALL.keys.join(', ')}); write a reason after --"
-        end
-        map[line] = ops ? ops.map(&:to_sym).to_set : :all
-      end
-      map
-    end
-
-    # True when this mutant is suppressed: its line bears a disable-line marker
-    # (bare, or scoped to its operator), OR its new or old-format id is in the
-    # config ignore list. Checked at job-build time so a suppressed mutant is
-    # never forked.
-    #
-    # @param ids [Array<String>, String] the mutant's new id and its old-format
-    #   id, or a single id (the pre-#126 call shape).
-    def self.suppressed?(operator, line, ids, disabled, ignore_set)
-      return true if Array(ids).any? { |id| ignore_set.include?(id) }
-
-      case (entry = disabled[line])
-      when :all then true
-      when Set  then entry.include?(operator)
-      else false
-      end
-    end
-
-    # --since: keep only jobs whose mutation lands on a line changed since the git
-    # ref. Composes with coverage selection (it only narrows the job list; each
-    # surviving mutant still goes through Runner.run's coverage check). A file with
-    # no changed lines (absent from the diff) contributes no jobs. Line is computed
-    # exactly as Runner.run does, from the already-read source in source_map.
-    def self.filter_since(jobs, source_map, config)
-      changed = ChangedLines.for(ref: config.since, files: config.sources,
-                                 project_root: config.project_root)
-      jobs.select do |subject, mutation|
-        source = source_map[subject.file]
-        line = source.byteslice(0, mutation.start_offset).count("\n") + 1
-        abs = File.expand_path(subject.file, config.project_root)
-        changed.fetch(abs, []).include?(line)
+    def self.preload_owners(config)
+      Project.discover(config.sources, only: config.only).each do |subject|
+        next if subject.owner_unknown
+
+        Isolation.nesting_keywords(subject.lexical_namespace)
+        # The owner itself, as the child resolves it: a Class.new block owner
+        # has no lexical namespace.
+        Object.const_get(subject.namespace.join("::")) unless subject.namespace.empty?
+      rescue StandardError, ScriptError
+        nil
       end
     end
 
-    # For each test file, the directory to add to $LOAD_PATH so its
-    # `require "test_helper"` (or spec_helper) resolves: the nearest ancestor
-    # holding that helper, plus the file's own dir as a fallback.
-    def self.test_load_roots(test_files)
-      test_files.flat_map do |f|
-        dir = File.dirname(f)
-        root = nil
-        loop do
-          if File.exist?(File.join(dir, "test_helper.rb")) || File.exist?(File.join(dir, "spec_helper.rb"))
-            root = dir
-            break
-          end
-          parent = File.dirname(dir)
-          break if parent == dir
-
-          dir = parent
-        end
-        [root, File.dirname(f)].compact
-      end.uniq
-    end
-
     # When --rails is on and RAILS_ENV is unset, default it to "test" (and say so)
     # before the app boots. Otherwise it boots development and nothing is measured.
     # An explicitly-set RAILS_ENV is always respected.
@@ -501,32 +289,6 @@ module Mutineer
       warn "[mutineer] RAILS_ENV was unset; defaulting to 'test' for --rails."
     end
 
-    # The unique absolute directories holding the sources. Sweep target for both
-    # orphan mechanisms (in-process mutant tempfiles and external backup files),
-    # and shipped to the daemon via {DaemonBackend.boot_config} so it can sweep too.
-    # Shared so the path-expansion rule cannot drift between the paths.
-    #
-    # @param config [Mutineer::Config] run configuration.
-    # @return [Array<String>] unique absolute source directories.
-    def self.source_dirs(config)
-      config.sources.map { |f| File.dirname(File.expand_path(f, config.project_root)) }.uniq
-    end
-
-    # Removes stale mutant tempfiles from the given directories. The daemon writes a
-    # differently-named temp, so {DaemonBackend} passes its glob when it has to sweep
-    # tool-side (nothing boots on an empty run, so the daemon's own sweep never runs).
-    #
-    # @param dirs [Array<String>] directories to sweep.
-    # @param glob [String] filename pattern to remove.
-    # @return [void]
-    def self.sweep_orphans(dirs, glob = "mutineer_mutant*.rb")
-      dirs.each do |dir|
-        Dir.glob(File.join(dir, glob)).each do |f|
-          File.unlink(f) rescue nil # rubocop:disable Style/RescueModifier
-        end
-      end
-    end
-
     # Runs a single mutation through isolation.
     #
     # @param mutation [Mutineer::Mutation] mutation to run.
@@ -552,8 +314,9 @@ module Mutineer
       # no test exercises is :no_coverage (no fork); otherwise exactly the
       # covering test files run in the child. Shared with the daemon path so both
       # narrow identically (score parity).
-      kind, payload = coverage_selection(source_file, mutation, subject, source, coverage_map)
+      kind, payload = JobPlan.coverage_selection(source_file, mutation, subject, source, coverage_map)
       return payload if kind == :verdict
+      return Result.unplaceable if strategy == "redefine" && subject&.owner_unknown
 
       abs_tests = payload
 
@@ -574,7 +337,8 @@ module Mutineer
           TestRunners.for(framework).run(abs_tests, stop_at_first_failure: true)
         end
       end
-      relative_kills(result, coverage_map.project_root)
+      result = relative_kills(result, coverage_map.project_root)
+      JobPlan.load_verdict(result, source_file, mutation, subject, source, coverage_map)
     end
 
     # Rewrites the test files of a result's {Kills} row relative to the project

data/lib/mutineer/statement_lines.rb

@@ -41,6 +41,46 @@ module Mutineer
       lines
     end
 
+    # Whether the code at `offset` runs each time the method runs: it is in
+    # the first statement of the body, not in a statement nested in it or in
+    # a {NESTED} node (a block or loop body), and not in code that runs only
+    # sometimes ({sometimes?}, the body of `x if c`). The first statement in
+    # parentheses or `begin ... end` runs with them, so it counts
+    # ({grouped_first?}). Used for a method whose body shares the `def` line,
+    # where only the method's call count tells that the code ran (#209).
+    #
+    # @param def_node [Prism::DefNode] the method that holds the position.
+    # @param offset [Integer] byte offset of the position.
+    # @return [Boolean]
+    def self.runs_with_method?(def_node, offset)
+      first = def_node.body.is_a?(Prism::StatementsNode) && def_node.body.body.first
+      path = first && path_to(first, offset)
+      return false unless path
+
+      return false if path.drop(1).any? { |node| NESTED.any? { |klass| node.is_a?(klass) } }
+      return false if path[1]&.newline?
+
+      path.each_cons(3).none? { |grand, parent, node| node.newline? && !grouped_first?(grand, parent, node) } &&
+        path.each_cons(2).none? { |parent, child| sometimes?(parent, child) }
+    end
+
+    # Whether `node` is the first statement in parentheses or `begin ... end`,
+    # which runs each time they do.
+    #
+    # @param grand [Prism::Node] the parent of `parent`.
+    # @param parent [Prism::Node] the parent of `node`.
+    # @param node [Prism::Node]
+    # @return [Boolean]
+    def self.grouped_first?(grand, parent, node)
+      (grand.is_a?(Prism::ParenthesesNode) || grand.is_a?(Prism::BeginNode)) &&
+        parent.is_a?(Prism::StatementsNode) && parent.body.first.equal?(node)
+    end
+
+    # Nodes whose code can run any number of times, or not at all, when the
+    # statement that holds them runs.
+    NESTED = [Prism::BlockNode, Prism::LambdaNode, Prism::WhileNode, Prism::UntilNode, Prism::ForNode,
+              Prism::DefNode].freeze
+
     # Nodes whose code runs only when a branch, a match or an exception picks
     # it: a `when` or `in` clause (its condition or pattern), a `rescue` clause
     # (its class list), an `else` branch, parameters (their defaults) and

data/lib/mutineer/subject.rb

@@ -7,8 +7,12 @@ module Mutineer
   # because mutators walk the def node directly. `namespace` names the owner
   # (`module ::X` inside `Outer` owns into `X`); `lexical` is the class/module
   # chain as written (`["Outer", "::X"]`), which the redefine strategy needs to
-  # rebuild the same Module.nesting as a whole-file reload (#145).
-  Subject = Struct.new(:file, :namespace, :name, :singleton, :def_node, :lexical, keyword_init: true) do
+  # rebuild the same Module.nesting as a whole-file reload (#145). `block_owner`
+  # is the constant a `Data.define`-style block is assigned to, as written;
+  # `owner_unknown` is true when the class that block builds cannot be named,
+  # so the redefine strategy cannot load a mutant onto it.
+  Subject = Struct.new(:file, :namespace, :name, :singleton, :def_node, :lexical, :block_owner, :owner_unknown,
+                       keyword_init: true) do
     # Returns the fully-qualified subject name.
     #
     # @return [String] namespaced method name like `Billing::Invoice#total`.