simplecov 1.1.1 → 1.2.0

data/lib/simplecov/parallel_adapters.rb

@@ -5,81 +5,50 @@ require_relative "parallel_adapters/parallel_tests"
 require_relative "parallel_adapters/generic"
 
 module SimpleCov
-  # Registry + selection for parallel-test-runner adapters. An adapter
-  # answers a small fixed set of questions on SimpleCov's behalf:
+  # Registry and selection for parallel-test-runner adapters. An adapter
+  # answers a small fixed set of questions on SimpleCov's behalf: `active?`,
+  # `first_worker?`, `wait_for_siblings`, and `expected_worker_count`.
   #
-  #   - `active?` — are WE the runner in charge for this process?
-  #   - `first_worker?` — should this process do the final-result work?
-  #   - `wait_for_siblings` — block until siblings finish (optional)
-  #   - `expected_worker_count` — how many workers total
+  # `Base` provides safe no-op defaults. `ParallelTestsAdapter` wraps the
+  # grosser/parallel_tests gem; `GenericAdapter` is env-var-only detection for
+  # runners that follow the `TEST_ENV_NUMBER` convention without shipping a
+  # Ruby API (#1065, #1156).
   #
-  # `SimpleCov::ParallelAdapters::Base` provides safe no-op defaults; two
-  # adapters ship out of the box:
-  #
-  #   - `ParallelTestsAdapter` — wraps the grosser/parallel_tests gem
-  #     (precise sync + first-process detection via the gem's own API).
-  #   - `GenericAdapter` — env-var-only detection for runners that follow
-  #     the parallel_tests `TEST_ENV_NUMBER` convention but don't ship a
-  #     Ruby API (parallel_rspec, rspec-conductor 1.0.7+, custom CI
-  #     sharding, knapsack-style splitters). See
-  #     https://github.com/simplecov-ruby/simplecov/issues/1065 and
-  #     https://github.com/simplecov-ruby/simplecov/issues/1156.
-  #
-  # Users can plug in additional adapters:
-  #
-  #   SimpleCov::ParallelAdapters.register MyRunnerAdapter
-  #
-  # An adapter just needs to be a class responding to the four methods
-  # above. Subclass `SimpleCov::ParallelAdapters::Base` to inherit the
-  # no-op defaults and override only what you need (the contract methods
-  # are defined as class methods, so plain inheritance is what carries
-  # them through; `extend Base` won't pick them up).
+  # Users register their own with `ParallelAdapters.register MyAdapter`.
+  # Subclass `Base` to inherit the no-op defaults: the contract methods are
+  # class methods, so plain inheritance is what carries them through and
+  # `extend Base` won't pick them up.
   module ParallelAdapters
-  module_function
+    extend self
 
-    # Adapters in selection order. ParallelTestsAdapter first (most
-    # specific — uses the gem's own API when the gem is loaded); then
-    # GenericAdapter as the env-var fallback. User-registered adapters
-    # are prepended (#register puts new entries at the front) so
-    # downstream code can override the built-ins by registering a more
-    # specific match.
+    # ParallelTestsAdapter first (most specific: it uses the gem's own API when
+    # the gem is loaded), then GenericAdapter as the env-var fallback.
+    # User-registered adapters are prepended.
     def adapters
       @adapters ||= [ParallelTestsAdapter, GenericAdapter]
     end
 
-    # Register a custom adapter. Newly registered adapters are inserted
-    # at the front of the selection list so a custom adapter for a
-    # specific runner takes precedence over the built-in ParallelTests
-    # and Generic adapters.
-    #
-    #   class MyRunnerAdapter < SimpleCov::ParallelAdapters::Base
-    #     def self.active?       = ENV["MY_RUNNER_PID"]
-    #     def self.first_worker? = ENV["MY_RUNNER_PID"].to_i == 1
-    #     def self.expected_worker_count = ENV["MY_RUNNER_WORKERS"].to_i
-    #   end
-    #
-    #   SimpleCov::ParallelAdapters.register MyRunnerAdapter
+    # Newly registered adapters are inserted at the front of the selection
+    # list, so a custom adapter for a specific runner takes precedence over the
+    # built-ins.
     def register(adapter)
       reset_current!
       adapters.unshift(adapter) unless adapters.include?(adapter)
       adapter
     end
 
-    # The adapter SimpleCov should consult for this process — the first
-    # registered adapter whose `active?` returns true. Returns nil when
-    # no adapter is active (i.e., we're not running under any recognized
-    # parallel test runner), in which case the caller should treat the
-    # process as single-worker.
+    # The first registered adapter whose `active?` answers true, or nil when
+    # none is, in which case the caller treats the process as single-worker.
     def current
-      return @current if defined?(@current)
+      return @current if instance_variable_defined?(:@current)
 
       @current = adapters.find(&:active?)
     end
 
-    # Clear the memoized `current` selection. Primarily for tests that
-    # mutate env vars between examples; production runs are single-shot.
+    # Primarily for tests that mutate env vars between examples; production
+    # runs are single-shot.
     def reset_current!
-      remove_instance_variable(:@current) if defined?(@current)
+      remove_instance_variable(:@current) if instance_variable_defined?(:@current)
     end
   end
 end

data/lib/simplecov/parallel_coordination.rb

@@ -10,13 +10,12 @@ module SimpleCov
   class << self
     # @api private
     def final_result_process?
-      adapter = SimpleCov::ParallelAdapters.current
-      # No recognized parallel-test adapter. A subprocess forked while
-      # coverage was running is never the final reporter — the process that
-      # spawned it merges every slice and produces the report. Without this,
-      # fork-based runners that don't set TEST_ENV_NUMBER (e.g. Minitest's
-      # `parallelize`) have every worker produce the final report and its
-      # warnings. See issue #1171.
+      adapter = ParallelAdapters.current
+      # A subprocess forked while coverage was running is never the final
+      # reporter: the process that spawned it merges every slice and produces
+      # the report. Without this, fork-based runners that don't set
+      # TEST_ENV_NUMBER (Minitest's `parallelize`) have every worker produce
+      # the final report and its warnings (#1171).
       return !forked_subprocess? unless adapter
 
       adapter.first_worker?
@@ -24,53 +23,43 @@ module SimpleCov
 
     # @api private
     def wait_for_other_processes
-      adapter = SimpleCov::ParallelAdapters.current
+      adapter = ParallelAdapters.current
       return unless adapter && final_result_process?
 
-      # Native synchronization first (adapters that wrap a runner with a
-      # real "wait" primitive — parallel_tests'
-      # `wait_for_other_processes_to_finish` — implement this; adapters
-      # without a native API no-op and rely on the polling fallback below).
+      # Adapters that wrap a runner with a real "wait" primitive implement
+      # this; the rest no-op and rely on the polling fallback below.
       adapter.wait_for_siblings
 
       # The native wait can return before sibling at_exit handlers finish
-      # writing resultsets, and adapters without a native wait have
-      # nothing else. Either way, poll the resultset cache until all
-      # expected workers have reported or a timeout is reached. Capture
-      # the outcome so `ready_to_process_results?` can suppress min/max
-      # threshold checks against a partial total.
+      # writing resultsets, and adapters without a native wait have nothing
+      # else. Either way, poll the resultset cache until all expected workers
+      # have reported or a timeout is reached. The outcome is captured so
+      # threshold checks can be suppressed against a partial total.
       @parallel_results_complete =
         wait_for_parallel_results(adapter.expected_worker_count, native_wait: adapter.native_wait?)
     end
 
-    # @api private — true when every sibling reported its resultset
-    # before the wait deadline. Defaults to true outside a parallel
-    # run (when `wait_for_other_processes` is a no-op).
+    # @api private -- true when every sibling reported its resultset before the
+    # wait deadline. Defaults to true outside a parallel run.
     def parallel_results_complete?
-      defined?(@parallel_results_complete) ? @parallel_results_complete : true
+      instance_variable_defined?(:@parallel_results_complete) ? @parallel_results_complete : true
     end
 
-    # @api private — seconds the resultset count must hold steady, after a
+    # @api private -- seconds the resultset count must hold steady, after a
     # native wait, before we accept fewer than `expected` workers as final.
     PARALLEL_RESULTS_SETTLE = 0.5
     private_constant :PARALLEL_RESULTS_SETTLE
 
-    # @api private — returns true when the reporting worker has every
-    # resultset it's going to get, false on timeout. Single-process runs
-    # (expected <= 1) short-circuit to true with no waiting.
+    # @api private -- true when the reporting worker has every resultset it's
+    # going to get, false on timeout. Single-process runs short-circuit.
     #
-    # Normally we poll until `expected` (= PARALLEL_TEST_GROUPS) workers have
-    # reported or `SimpleCov.parallel_wait_timeout` elapses; raise that setting
-    # when a slow worker routinely finishes well after the others.
-    #
-    # When a native wait already confirmed every sibling PROCESS exited
-    # (`native_wait`), no further resultset will appear, so a count below
-    # `expected` just means some workers produced none — e.g. parallel_test
-    # groups that got no spec file on a machine with more cores than files.
-    # Once the count then holds steady for `PARALLEL_RESULTS_SETTLE` we accept
-    # it as final rather than blocking for the whole timeout. Without a native
-    # wait (GenericAdapter) we can't tell an idle worker from a slow one, so we
-    # keep waiting the full timeout.
+    # Normally we poll until `expected` workers have reported or
+    # `SimpleCov.parallel_wait_timeout` elapses. When a native wait already
+    # confirmed every sibling process exited, no further resultset will appear,
+    # so a count below `expected` just means some workers produced none, and
+    # once the count holds steady for `PARALLEL_RESULTS_SETTLE` we accept it as
+    # final. Without a native wait we can't tell an idle worker from a slow
+    # one, so we keep waiting the full timeout.
     def wait_for_parallel_results(expected, native_wait: false)
       return true unless expected > 1 # simplecov:disable branch — only false in real parallel runs
 
@@ -87,29 +76,30 @@ module SimpleCov
     end
 
     def current_parallel_worker_count
-      resultset = SimpleCov::ResultMerger.read_resultset
-      SimpleCov::ResultMerger.worker_identities_for_run(resultset, SimpleCov.run_id, SimpleCov.process_start_time).size
+      resultset = ResultMerger.read_resultset
+      ResultMerger.worker_identities_for_run(resultset, run_id, process_start_time).size
     end
 
-    # Track whether the resultset count has held steady (and positive) for
-    # `PARALLEL_RESULTS_SETTLE` seconds. `tracker` carries the last count and
-    # the time it last changed across poll iterations.
+    # `tracker` carries the last count and the time it last changed across poll
+    # iterations. Answered through an if/else rather than an early return
+    # because falling through after a climb would read the clock a second time
+    # and answer the same `false` anyway.
     def resultset_count_settled?(tracker, count)
-      if count > tracker[:count]
+      if count > tracker.fetch(:count)
         tracker[:count] = count
         tracker[:since] = monotonic_time
-        return false
+        false
+      else
+        count.positive? && (monotonic_time - tracker.fetch(:since)) >= PARALLEL_RESULTS_SETTLE
       end
-
-      count.positive? && (monotonic_time - tracker[:since]) >= PARALLEL_RESULTS_SETTLE
     end
 
     def monotonic_time
       Process.clock_gettime(Process::CLOCK_MONOTONIC)
     end
 
-    # @api private — true once the wait deadline has passed; warns on
-    # the first timeout so the user knows the merged total is partial.
+    # @api private -- warns on the first timeout so the user knows the merged
+    # total is partial.
     def parallel_wait_timed_out?(deadline, expected, seen)
       return false unless monotonic_time > deadline
 
@@ -121,7 +111,7 @@ module SimpleCov
     def warn_about_incomplete_parallel_results(expected, seen)
       return unless print_errors
 
-      warn SimpleCov::Color.colorize(
+      warn Color.colorize(
         "Only #{seen} of #{expected} parallel-test workers reported within " \
         "#{parallel_wait_timeout}s, so coverage totals are partial and minimum / " \
         "maximum coverage checks are skipped for this run. Increase " \

data/lib/simplecov/parallel_result_merger/worker_payload.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  module ParallelResultMerger
+    # What a worker ships back over its pipe: the `[command_names, coverage]` pair
+    # its slice folded to, the tracked paths the slice carried, and the slice's
+    # context-map union. Building and folding live together so the pipe format
+    # has one owner. The parent needs the union across every worker of the
+    # tracked paths, to know what nothing loaded, and of the maps, to judge the
+    # all-or-nothing rule over the whole run rather than per slice.
+    module WorkerPayload
+      extend self
+
+      def build(chunk, ignore_timeout:)
+        tracked_files = Set.new
+        context_maps = ContextMap::Union.new
+        pair = ResultMerger.absorb_results(chunk, ignore_timeout: ignore_timeout,
+          &ResultMerger.entry_collector(tracked_files, context_maps))
+        [pair, tracked_files.to_a, context_maps]
+      end
+
+      def absorb(payload, tracked_files, context_maps)
+        _pair, tracked, maps = payload
+        tracked_files.merge(tracked)
+        context_maps.absorb_union(maps)
+      end
+
+      def pair(payload)
+        payload.first
+      end
+    end
+  end
+end

data/lib/simplecov/parallel_result_merger.rb

@@ -1,35 +1,20 @@
 # frozen_string_literal: true
 
+require_relative "parallel_result_merger/worker_payload"
+
 module SimpleCov
   #
-  # Folds a list of resultset files into one merged coverage table across
-  # forked worker processes. Drives `SimpleCov.collate(..., processes: N)`.
-  #
-  # `ResultMerger.absorb_results` is a fold over N independent
-  # read-parse-combine steps, so it splits cleanly: each worker runs that
-  # same fold over a contiguous slice of the file list and ships the pair
-  # back over a pipe, and the parent combines the handful of per-worker
-  # pairs it gets back. Reading and parsing the shards — where a collate
-  # over a few hundred CI jobs spends most of its time — is what actually
-  # parallelises.
+  # `ResultMerger.absorb_results` fanned out across forked workers, driving
+  # `SimpleCov.collate(..., processes: N)`. Each worker folds a contiguous
+  # slice of the file list and ships the pair back over a pipe.
   #
-  # The slices are contiguous and merged back in order, so the fold visits
-  # the resultsets in the order the serial fold visits them and the merged
-  # result is identical to `SimpleCov.collate`'s, not merely equivalent.
-  #
-  # Every failure path returns nil rather than a partial merge, so the caller
-  # can redo the fold serially: reporting coverage for a subset of the
-  # resultsets would silently understate it.
+  # The slices are contiguous and merged back in order, so the fold visits the
+  # resultsets in the order the serial fold visits them and the merged result
+  # is identical to `SimpleCov.collate`'s, not merely equivalent.
   #
   module ParallelResultMerger
-  module_function
-
-    #
-    # `ResultMerger.merge_and_store` across `processes` forked workers. One
-    # worker hands straight back to `ResultMerger`, so the default `collate`
-    # takes exactly the path it always has and never reaches this module's
-    # machinery at all.
-    #
+    extend self
+
     def merge_and_store(*file_paths, processes:, ignore_timeout: false)
       return ResultMerger.merge_and_store(*file_paths, ignore_timeout: ignore_timeout) if processes < 2
 
@@ -38,176 +23,132 @@ module SimpleCov
       result
     end
 
-    #
-    # `ResultMerger.merge_results` across `processes` forked workers, merging
-    # in this process instead whenever the fan-out did not produce a complete
-    # merge — a runtime that cannot fork, nothing worth splitting, or a worker
-    # that died. The result is the same either way; only the time it took to
-    # get there differs.
-    #
     def merge_results(*file_paths, processes:, ignore_timeout: false)
       tracked_files = Set.new
+      context_maps = ContextMap::Union.new
       pair = absorb_results(file_paths, processes: processes, ignore_timeout: ignore_timeout,
-                                        tracked_files: tracked_files)
-      # A nil pair means nothing was fanned out at all, so the serial path
-      # is exactly `ResultMerger.merge_results` — delegate rather than
-      # re-implement its collector wiring.
+        tracked_files: tracked_files, context_maps: context_maps)
       return ResultMerger.merge_results(*file_paths, ignore_timeout: ignore_timeout) unless pair
 
       command_names, coverage = pair
-      ResultMerger.create_result(command_names, coverage, tracked_files: tracked_files)
+      ResultMerger.create_result(command_names, coverage, tracked_files: tracked_files, contexts: context_maps.map)
     end
 
-    #
-    # `ResultMerger.absorb_results` across at most `processes` forked
-    # workers: same arguments, same `[command_names, coverage]` return.
-    #
-    # The tracked paths a worker's slice carried come back with its payload
-    # rather than through a collector block, since the block a serial absorb
-    # takes would be mutating a Set in the wrong process.
-    #
-    # @return [Array(Array<String>, Hash), nil] the pair
-    #   `ResultMerger.create_result` consumes, or nil when the work could not
-    #   be fanned out and the caller should merge in this process instead.
-    #
-    def absorb_results(file_paths, processes:, ignore_timeout: false, tracked_files: Set.new)
-      # One worker folds the whole list anyway, and one file is a fold of
-      # one — in both cases the fork and the round trip are pure overhead.
+    # Answers nil when the work could not be fanned out and the caller should
+    # merge in this process instead. The tracked paths and context-map union a
+    # worker's slice carried come back with its payload rather than through a
+    # collector block, since that block would be mutating state in the wrong
+    # process.
+    def absorb_results(file_paths, processes:, ignore_timeout: false, tracked_files: Set.new,
+      context_maps: ContextMap::Union.new)
       return nil if processes < 2 || file_paths.size < 2
-      # The portable feature test, and the one the rest of the ecosystem uses.
-      # CRuby leaves `fork` undefined on Windows; JRuby and TruffleRuby cannot
-      # fork on the JVM and deliberately answer false here so libraries can
-      # detect that without rescuing an exception — TruffleRuby's compatibility
-      # guide names this as the correct check. They do still define
-      # `Kernel#fork` and raise `NotImplementedError` from it, so probing that
-      # instead would answer true and send them down the fan-out.
+      # JRuby cannot fork on the JVM and deliberately answers false here, but
+      # still defines `Kernel#fork` and raises `NotImplementedError` from it,
+      # so probing that instead would send it down the fan-out.
       return nil unless Process.respond_to?(:fork)
 
-      fan_out(chunk(file_paths, processes), ignore_timeout: ignore_timeout, tracked_files: tracked_files)
+      fan_out(chunk(file_paths, processes), ignore_timeout: ignore_timeout, tracked_files: tracked_files,
+        context_maps: context_maps)
     end
 
-    # Contiguous slices whose sizes differ by at most one, so no worker is
-    # left folding twice its share while the others idle. There are never
-    # more slices than files: asking for more processes than there are
-    # resultsets just gives one resultset per process.
     def chunk(file_paths, processes)
       groups = [processes, file_paths.size].min
       base, remainder = file_paths.size.divmod(groups)
       remaining = file_paths.dup
 
-      Array.new(groups) { |index| remaining.shift(base + (index < remainder ? 1 : 0)) }
+      Array.new(groups) { |index| remaining.shift(base + ((index < remainder) ? 1 : 0)) }
     end
 
-    # A `fork` that fails here raises, and is left to. `absorb_results` has
-    # already excluded the runtimes that never fork, so what remains is the OS
-    # refusing a process we expected to get — EAGAIN at RLIMIT_NPROC, ENOMEM
-    # under memory pressure. That says something is wrong with the machine
-    # rather than with the merge, and quietly absorbing it would hide it.
-    def fan_out(chunks, ignore_timeout:, tracked_files: Set.new)
+    # A `fork` that fails here raises, and is left to: the runtimes that never
+    # fork are already excluded, so what remains is the OS refusing a process
+    # we expected to get, which says something is wrong with the machine rather
+    # than with the merge.
+    def fan_out(chunks, ignore_timeout:, tracked_files:, context_maps:)
       workers = spawn_workers(chunks, ignore_timeout: ignore_timeout)
-      payloads = collect(workers)
+      payloads = collect_payloads(workers)
       return nil unless payloads
 
-      payloads.each { |(_pair, tracked)| tracked_files.merge(tracked) }
-      ResultMerger.merge_coverage(*payloads.map(&:first))
+      payloads.each { |payload| WorkerPayload.absorb(payload, tracked_files, context_maps) }
+      ResultMerger.merge_coverage(*payloads.map { |payload| WorkerPayload.pair(payload) })
     end
 
     def spawn_workers(chunks, ignore_timeout:)
       workers = [] #: Array[Hash[Symbol, untyped]]
-
       chunks.each do |chunk|
         workers << spawn_worker(chunk, ignore_timeout: ignore_timeout)
-      rescue StandardError
+      rescue
         abandon(workers)
         raise
       end
-
       workers
     end
 
     def abandon(workers)
       workers.each do |worker|
-        worker[:reader].close
-        succeeded?(worker[:pid])
+        worker.fetch(:reader).close
+        succeeded?(worker.fetch(:pid))
       end
     end
 
-    # `fork` itself can fail (EAGAIN under a process limit). The caller
-    # cleans up the workers it knows about, but this pipe is ours: the
-    # parent's writer end always closes, and the reader closes too when
-    # no child was spawned to feed it. Steep cannot type body locals
-    # inside an ensure, hence the ignore markers; the safe navigation
-    # keeps the cleanup well-defined when `IO.pipe` itself raised.
+    # The caller cleans up the workers it knows about, but this pipe is ours.
+    # The safe navigation keeps the cleanup well-defined when `IO.pipe` itself
+    # raised, and Steep cannot type body locals inside an ensure.
     def spawn_worker(chunk, ignore_timeout:)
       reader, writer = IO.pipe
       pid = fork { run_in_child(reader, writer, chunk, ignore_timeout) }
       {pid: pid, reader: reader}
     ensure
-      # steep:ignore:start
+      # @type var writer: IO?
+      # @type var reader: IO?
+      # @type var pid: Integer?
       writer&.close
       reader&.close unless pid
-      # steep:ignore:end
     end
 
-    # Everything the child does. `exit!` rather than `exit` because it must
-    # never fall through to the collating process's inherited `at_exit`
-    # handlers — SimpleCov's own report generation included.
+    # `exit!` rather than `exit` because the child must never fall through to
+    # the collating process's inherited `at_exit` handlers, SimpleCov's own
+    # report generation included.
     def run_in_child(reader, writer, chunk, ignore_timeout)
       reader.close
       exit!(run_worker(chunk, writer, ignore_timeout: ignore_timeout))
     end
 
-    # The body of a worker: merge the slice, ship it back, and report the exit
-    # status the child should terminate with. Kept free of the exit itself so
-    # it can be exercised in-process.
-    #
-    # The slice's tracked paths travel with the pair because the parent needs
-    # the union across every worker to know what nothing loaded.
+    # Kept free of the exit itself so it can be exercised in-process.
     def run_worker(chunk, writer, ignore_timeout:)
-      tracked_files = Set.new
-      pair = ResultMerger.absorb_results(chunk, ignore_timeout: ignore_timeout,
-                                         &ResultMerger::UnloadedFiles.collector(tracked_files))
-      Marshal.dump([pair, tracked_files.to_a], writer)
+      Marshal.dump(WorkerPayload.build(chunk, ignore_timeout: ignore_timeout), writer)
       writer.close
       0
-    rescue StandardError => e
-      warn "[SimpleCov]: parallel merge worker failed: #{e.class}: #{e.message}" if SimpleCov.print_errors
+    rescue => e
+      warn "[SimpleCov]: parallel merge worker failed: #{e.class}: #{e}" if SimpleCov.print_errors
       1
     end
 
-    # Deserializes on a thread per worker so every pipe is drained while the
-    # workers are still writing. A payload larger than the pipe buffer would
-    # otherwise block its worker mid-write, and the parent would block
-    # reaping a worker that can never finish.
-    #
-    # Returns nil if any worker failed, so the caller can fall back to the
-    # serial fold rather than report a subset of the resultsets as the whole.
-    def collect(workers)
+    # Answers nil if any worker failed, so the caller redoes the fold serially
+    # rather than report a subset of the resultsets as the whole.
+    def collect_payloads(workers)
       payloads = drain(workers)
-      failed = workers.count { |worker| !succeeded?(worker[:pid]) }
-      return payloads if failed.zero? && payloads.all?
+      failed = workers.count { |worker| !succeeded?(worker.fetch(:pid)) }
+      return warn_about_failed_workers(failed, workers.size) unless failed.zero? && payloads.all?
 
-      warn_about_failed_workers(failed, workers.size)
-      nil
+      payloads
     ensure
-      workers.each { |worker| worker[:reader].close }
+      workers.each { |worker| worker.fetch(:reader).close }
     end
 
+    # A thread per worker, so every pipe is drained while the workers are still
+    # writing. A payload larger than the pipe buffer would otherwise block its
+    # worker mid-write, and the parent would block reaping a worker that can
+    # never finish.
     def drain(workers)
-      workers.map { |worker| Thread.new { read_payload(worker[:reader]) } }.map(&:value)
+      workers.map { |worker| Thread.new { read_payload(worker.fetch(:reader)) } }.map(&:value)
     end
 
     def read_payload(reader)
-      # The writer is a fork of this very process and the pipe never leaves
-      # it, so this is our own data coming back through our own kernel
-      # buffer, not input. A worker that died mid-write leaves the stream
-      # truncated, which Marshal reports by raising rather than returning.
-      # RBS types `Marshal.load`'s source as `_Source`, which IO satisfies
-      # structurally but not nominally.
-      # steep:ignore:start
+      # The writer is a fork of this very process and the pipe never leaves it,
+      # so this is our own data coming back through our own kernel buffer, not
+      # input.
       Marshal.load(reader) # rubocop:disable Security/MarshalLoad
-      # steep:ignore:end
-    rescue StandardError
+    rescue
       nil
     end
 
@@ -215,7 +156,7 @@ module SimpleCov
       _pid, status = Process.wait2(pid)
       status.success?
     rescue SystemCallError
-      # Errno::ECHILD — nothing left to reap, so there is no status to judge
+      # Errno::ECHILD: nothing left to reap, so there is no status to judge
       # this worker's slice by and we have to assume it did not finish.
       false
     end

data/lib/simplecov/process.rb

@@ -1,53 +1,35 @@
 # frozen_string_literal: true
 
-# Hooks `Process._fork` (Ruby 3.1+) so child processes inherit SimpleCov's
-# coverage tracking when `SimpleCov.enable_for_subprocesses?` is set.
-#
-# `Process._fork` is the official extension point: `Kernel#fork`,
-# `Process.fork`, `IO.popen("-")`, and similar all funnel through it.
-# Hooking `_fork` (instead of redefining `Process.fork`) composes
-# correctly with other libraries doing the same — they each prepend
-# their own module and chain via `super`.
-
-# Reopened here for the fork-related at_exit plumbing that only matters
-# when subprocess support is loaded.
 module SimpleCov
   class << self
     # Forked children inherit at_exit state that is wrong for them:
-    # @at_exit_hook_installed may describe a hook the parent already
-    # consumed before forking (Minitest autorun runs the suite inside the
-    # parent's at_exit, after SimpleCov's own hook has fired), and
-    # external_at_exit may point at a Minitest.after_run deferral that is
-    # pid-pinned to the parent. Reset both so the at_fork proc's
-    # SimpleCov.start installs a fresh hook that actually fires at child
-    # exit. See issue #1227.
+    # @at_exit_hook_installed may describe a hook the parent already consumed
+    # before forking (Minitest autorun runs the suite inside the parent's
+    # at_exit), and external_at_exit may point at a Minitest.after_run deferral
+    # that is pid-pinned to the parent. Resetting both is what lets the at_fork
+    # proc's `SimpleCov.start` install a hook that actually fires (#1227).
     def reset_inherited_at_exit_state!
       @at_exit_hook_installed = false
       self.external_at_exit = false
     end
   end
 
-  # Prepended onto Process's singleton class so every fork — direct or
-  # via Kernel#fork / IO.popen — re-runs SimpleCov's at_fork callback in
-  # the child.
+  # Prepended onto Process's singleton class so every fork re-runs SimpleCov's
+  # at_fork callback in the child. `Process._fork` is the official extension
+  # point: `Kernel#fork`, `Process.fork`, and `IO.popen("-")` all funnel
+  # through it, and prepending composes with other libraries doing the same.
   module ProcessForkHook
+    # The next serial is assigned in the parent, before the fork, so the child
+    # inherits its own stable ordinal via copy-on-write, and the child is marked
+    # here independent of whatever custom at_fork block the user installed so
+    # `final_result_process?` can keep forked workers from each producing the
+    # final report (#1171, #1227).
     def _fork
       active = defined?(SimpleCov) && Coverage.running?
-      # Assign the next serial in the PARENT, before the fork, so the child
-      # inherits its own stable ordinal via copy-on-write. The default
-      # at_fork uses it (instead of the child pid) to name the subprocess's
-      # result, keeping that name identical across runs. See issue #1171.
       SimpleCov.next_subprocess_serial! if active
       pid = super
       if pid.zero? && active
-        # Mark the child here, independent of whatever custom at_fork block
-        # the user installed, so `final_result_process?` can keep forked
-        # workers from each producing the final report. See issue #1171.
         SimpleCov.mark_forked_subprocess!
-        # Without this, a child forked under Minitest autorun measures
-        # coverage and then silently discards it: every inherited exit
-        # route is dead in the child (see the method's comment). A custom
-        # at_fork runs afterwards and can still override. See issue #1227.
         SimpleCov.reset_inherited_at_exit_state!
         SimpleCov.at_fork.call(::Process.pid)
       end