mutineer 1.5.0 → 1.7.0

data/lib/mutineer/runner.rb

@@ -1,25 +1,22 @@
 # 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"
+require_relative "rails_run_env"
 
 module Mutineer
   # Orchestrates one mutation end-to-end: apply it textually, validate the
@@ -35,7 +32,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.
     #
@@ -47,6 +44,10 @@ module Mutineer
     # @return [Array(Mutineer::AggregateResult, Hash<String, String>, Hash)] aggregate,
     #   source map, and run extras.
     def self.execute(config)
+      # Rails reads PARALLEL_WORKERS when a test helper calls parallelize.
+      # Set it before any boot or child spawn, then put the caller's value back.
+      previous_parallel_workers = ENV["PARALLEL_WORKERS"]
+      RailsRunEnv.pin_process!
       operator_classes = MutatorRegistry.resolve(config.operators || MutatorRegistry::DEFAULT_NAMES)
 
       # External backend: run the suite as a subprocess in the app's own runtime.
@@ -59,6 +60,15 @@ module Mutineer
       # payloads (Prism), so branch before any in-process boot.
       return DaemonBackend.execute(config, operator_classes) if config.daemon
 
+      # 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. The first sweep runs before the boot: a
+      # file an older version left without the dot would stop Zeitwerk (#253).
+      dirs = JobPlan.source_dirs(config)
+      JobPlan.sweep_orphans(dirs)
+
       # Boot mode: require the boot file ONCE so the app env (e.g. Rails) is booted
       # in the parent and inherited by every fork. Do NOT manually require the
       # sources. Under Zeitwerk a manual require of an autoloadable file raises;
@@ -74,13 +84,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 +105,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 +114,17 @@ 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,
+          coverage_from: config.coverage_from && File.expand_path(config.coverage_from, config.project_root),
           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 +133,16 @@ 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 = filter_since(jobs, source_map, config) if config.since
+      jobs, ignored_results, source_map, extras = JobPlan.collect_jobs(config, operator_classes)
 
-      # 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)
+      jobs, ignored_results, extras[:unscoped_mutants] = JobPlan.scope_since(jobs, ignored_results, source_map, config)
 
       strategy = config.strategy
       # Fail-fast must be serial: a parallel stop_when fires on the first survivor
@@ -153,10 +168,13 @@ 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]
+    ensure
+      # A caller that set PARALLEL_WORKERS keeps that value after the run.
+      RailsRunEnv.restore_process!(previous_parallel_workers)
     end
 
     # A `--matrix` error that carries no {Kills} row (the worker crashed, or its
@@ -171,109 +189,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 +199,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 +215,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, ignored_results, extras[:unscoped_mutants] = JobPlan.scope_since(jobs, ignored_results, source_map, config)
 
         # 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 +265,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 +299,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 +324,10 @@ 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
+      # A :maybe mutant that cannot be placed stays no_coverage, as before #254.
+      return kind == :maybe ? Result.no_coverage : Result.unplaceable if subject&.unplaceable?(strategy)
 
       abs_tests = payload
 
@@ -574,7 +348,9 @@ 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)
+      result = JobPlan.load_verdict(result, source_file, mutation, subject, source, coverage_map)
+      JobPlan.selection_verdict(kind, result)
     end
 
     # Rewrites the test files of a result's {Kills} row relative to the project

data/lib/mutineer/statement_lines.rb

@@ -12,12 +12,17 @@ module Mutineer
     # @param def_node [Prism::DefNode] the method that holds the position.
     # @param source [String] the source text of the file.
     # @param offset [Integer] byte offset of the position.
+    # @param loose [Boolean] also return the lines when the position is in
+    #   code that runs only sometimes when the statement runs (the right side of
+    #   `a && b`, a branch, the body of `x if c`). The tests that ran the
+    #   statement then include every test that ran the position, but may not
+    #   have run it (#254).
     # @return [Array<Integer>] the lines of the statement, with the body of each
     #   heredoc in it. Empty when no statement in the body holds the position.
     #   A first or last line that holds other code is left out, because Ruby
     #   can count that line without the statement: the `def` line counts when
     #   the file loads, and `x if done; y(` counts when `y` does not run.
-    def self.for(def_node, source, offset)
+    def self.for(def_node, source, offset, loose: false)
       return [] unless def_node.body
 
       path = path_to(def_node.body, offset) || []
@@ -25,13 +30,15 @@ module Mutineer
       return [] unless index
 
       statement = path[index]
-      # Code that runs only sometimes inside the statement: the tests that ran
-      # the statement need not have run it.
-      return [] if path[index..].each_cons(2).any? { |parent, child| sometimes?(parent, child) }
+      unless loose
+        # Code that runs only sometimes inside the statement: the tests that ran
+        # the statement need not have run it.
+        return [] if path[index..].each_cons(2).any? { |parent, child| sometimes?(parent, child) }
 
-      # Ruby counts the line of `x while c` or `x if c` when it checks `c`,
-      # also when `x` never runs. The path is the modifier, its body, statement.
-      return [] if index >= 2 && modifier?(path[index - 2])
+        # Ruby counts the line of `x while c` or `x if c` when it checks `c`,
+        # also when `x` never runs. The path is the modifier, its body, statement.
+        return [] if index >= 2 && modifier?(path[index - 2])
+      end
 
       location = statement.location
       lines = (location.start_line..last_line(statement)).to_a
@@ -41,6 +48,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,18 @@ 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, or
+  # the `ClassMethods` of a concern's `class_methods` block (#252);
+  # `owner_unknown` is true when the class that owns the method cannot be named
+  # (an unassigned builder block, or a concern block whose class or module no
+  # constant names, such as an `included` block that runs in each includer),
+  # so the redefine strategy cannot load a mutant onto it. `hook_block` is true
+  # for a def anywhere inside a concern's `included` or `prepended` block, which
+  # ActiveSupport runs only when a class first includes the concern, so the
+  # reload strategy cannot load a mutant onto it either (#256).
+  Subject = Struct.new(:file, :namespace, :name, :singleton, :def_node, :lexical, :block_owner, :owner_unknown,
+                       :hook_block, keyword_init: true) do
     # Returns the fully-qualified subject name.
     #
     # @return [String] namespaced method name like `Billing::Invoice#total`.
@@ -24,6 +34,18 @@ module Mutineer
       lexical || namespace
     end
 
+    # True when the strategy cannot load a mutant of this method where the tests
+    # call it, so the mutant is not run. Redefine needs a named owner. Reload
+    # loads the whole file again, which redefines everything except what a
+    # concern's `included` or `prepended` block defines: that block does not run
+    # again in a class that already includes the concern.
+    #
+    # @param strategy [String] `"reload"` or `"redefine"`.
+    # @return [Boolean]
+    def unplaceable?(strategy)
+      strategy == "redefine" ? owner_unknown == true : hook_block == true
+    end
+
     # Returns the body location for the subject, if any.
     #
     # @return [Prism::Location, nil] body location or nil for empty methods.