simplecov 1.1.1 → 1.2.0

data/lib/simplecov/result/missing_source_files_reporter.rb

@@ -3,27 +3,26 @@
 module SimpleCov
   class Result
     # When a resultset references source files that don't exist on the local
-    # filesystem they're silently dropped — which produces an empty `0 / 0
-    # (100.00%)` report that looks like success but isn't. Emit a single
-    # warning summarizing the drop and, when every entry was lost, point at
-    # the typical cause (`SimpleCov.collate` invoked from a machine or path
-    # different from where the resultsets were generated). See #980.
+    # filesystem they're silently dropped, which produces an empty
+    # `0 / 0 (100.00%)` report that looks like success but isn't. This emits a
+    # single warning summarizing the drop and, when every entry was lost, points
+    # at the typical cause: `SimpleCov.collate` invoked from a machine or path
+    # different from where the resultsets were generated (#980).
     class MissingSourceFilesReporter
-      def initialize(missing_paths, input_size:, every_entry_dropped:)
+      def initialize(missing_paths, every_entry_dropped:)
         @missing_paths = missing_paths
-        @input_size = input_size
         @every_entry_dropped = every_entry_dropped
       end
 
       def warn!
-        warn SimpleCov::Color.colorize(message, :yellow)
+        warn Color.colorize(message, :yellow)
       end
 
       def message
         @every_entry_dropped ? all_missing_warning : partial_missing_warning
       end
 
-    private
+      private
 
       def all_missing_warning
         "SimpleCov dropped all #{@missing_paths.size} source file(s) from the result — " \

data/lib/simplecov/result/serialization.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  class Result
+    module Serialization
+      def to_hash
+        data = {"coverage" => coverage, "timestamp" => created_at.to_f} #: Hash[String, untyped]
+        data["run_id"] = run_id if run_id
+        data["worker_id"] = worker_id if worker_id
+        data["tracked_files"] = tracked_files unless tracked_files.empty?
+        append_contexts(data)
+        {command_name => data}
+      end
+
+      private
+
+      # Serialized whenever a map was recorded, even an empty one: for the merge,
+      # the key's presence is the signal that this result tracked tests, which is
+      # what lets it tell "tracked and covered nothing" from "never tracked". The
+      # map's files are restricted to this result's post-filter universe.
+      def append_contexts(data)
+        map = contexts
+        return unless map
+
+        data["contexts"] = map.to_h(only: context_filenames)
+      end
+
+      def context_filenames
+        Set.new(filenames)
+      end
+
+      # A live result's criterion keys are Symbols while entries parsed back from
+      # `.resultset.json` carry Strings, and the combiners read only String keys.
+      # Serializing with String keys is what lets a live result merged against a
+      # stored entry contribute its counts instead of being dropped.
+      def coverage
+        original_result.slice(*filenames).transform_values do |file_coverage|
+          file_coverage.transform_keys(&:to_s)
+        end
+      end
+    end
+  end
+end

data/lib/simplecov/result/source_file_builder.rb

@@ -2,10 +2,6 @@
 
 module SimpleCov
   class Result
-    # Constructs `SimpleCov::SourceFile` instances from a raw coverage
-    # hash, sorts them by filename, and surfaces filenames whose source
-    # is no longer present on disk so the caller can warn about the
-    # silent drop (see #980).
     class SourceFileBuilder
       attr_reader :missing_source_files
 
@@ -16,14 +12,14 @@ module SimpleCov
       end
 
       def call
-        SimpleCov::FileList.new(
+        FileList.new(
           @original_result
             .filter_map { |filename, coverage| build_source_file(filename, coverage) }
             .sort_by(&:filename)
         )
       end
 
-    private
+      private
 
       def build_source_file(filename, coverage)
         unless File.file?(filename)
@@ -31,18 +27,17 @@ module SimpleCov
           return
         end
 
-        SimpleCov::SourceFile.new(
+        SourceFile.new(
           filename,
           stringify_outer_keys(coverage),
           loaded: !@not_loaded_files.include?(filename)
         )
       end
 
-      # `Coverage.result` returns symbol keys (`:lines`, `:branches`,
-      # `:methods`); resultsets loaded from disk are already string-keyed.
-      # SourceFile reads with strings, and handles both Array and
-      # stringified-Array branch/method keys via `restore_ruby_data_structure`,
-      # so only the outer hash needs normalizing.
+      # `Coverage.result` returns symbol keys; resultsets loaded from disk are
+      # already string-keyed. SourceFile reads with strings and handles both Array
+      # and stringified-Array branch/method keys itself, so only the outer hash
+      # needs normalizing.
       def stringify_outer_keys(coverage)
         coverage.transform_keys(&:to_s)
       end

data/lib/simplecov/result.rb

@@ -2,210 +2,161 @@
 
 require "digest/sha1"
 require "forwardable"
+require_relative "result/filter_config"
 require_relative "result/missing_source_files_reporter"
+require_relative "result/serialization"
 require_relative "result/source_file_builder"
 
 module SimpleCov
   #
-  # A simplecov code coverage result, initialized from the Hash Ruby's built-in coverage
-  # library generates (Coverage.result).
+  # A code coverage result, initialized from the Hash Ruby's built-in coverage
+  # library generates.
   #
   class Result
     extend Forwardable
+    include Serialization
 
-    # Returns the original Coverage.result used for this instance of SimpleCov::Result
-    attr_reader :original_result
-    # Every path the producing process was told to track, loaded or not. Carried
-    # into the resultset so a merge elsewhere can inject the ones nobody loaded
-    # without needing that process's `cover` / `track_files` config. See #1250.
+    attr_reader :original_result, :files
+    # Every path the producing process was told to track, loaded or not.
+    # Carried into the resultset so a merge elsewhere can inject the ones
+    # nobody loaded without needing that process's config (#1250).
     attr_reader :tracked_files
-    # Invocation and top-level worker identities used only for parallel-result
-    # coordination. They do not change which fresh suites are merged.
+    # Used only for parallel-result coordination. They do not change which
+    # fresh suites are merged.
     attr_reader :run_id, :worker_id
-    # Returns all files that are applicable to this result (sans filters!) as instances of
-    # SimpleCov::SourceFile. Aliased as :source_files
-    attr_reader :files
-    alias source_files files
-    # Explicitly set the Time this result has been created
-    attr_writer :created_at
-    # Explicitly set the command name that was used for this coverage result. Defaults to SimpleCov.command_name
-    attr_writer :command_name
+    alias_method :source_files, :files
+    # The `ContextMap` recorded under `track_tests`, or nil when this result
+    # carries none: tracking was off, or a merge dropped the map because not
+    # every merged result recorded one.
+    attr_reader :contexts
+
+    # The distinct run names behind this result, set by a merge so presentation
+    # can say "A and N other runs" instead of reading the joined
+    # `command_name` aloud in full. Splitting that string back apart would
+    # misread a run name that itself contains a comma.
+    attr_writer :created_at, :command_name, :command_names
 
     def_delegators :files, :covered_percent, :covered_percentages, :least_covered_file, :covered_strength,
-                   :covered_lines, :missed_lines,
-                   :total_branches, :covered_branches, :missed_branches,
-                   :total_methods, :covered_methods, :missed_methods,
-                   :coverage_statistics, :coverage_statistics_by_file
+      :covered_lines, :missed_lines,
+      :total_branches, :covered_branches, :missed_branches,
+      :total_methods, :covered_methods, :missed_methods,
+      :coverage_statistics, :coverage_statistics_by_file
     def_delegator :files, :lines_of_code, :total_lines
 
-    # Bundles the filter and grouping configuration a Result applies to its
-    # source files after building them. Each field defaults to the SimpleCov
-    # singleton's configuration, so ordinary callers never construct one;
-    # tests pass a custom instance to opt out of (or extend) the project's
-    # filters or groups (e.g. `filters: []` to keep every file). Grouping the
-    # three together keeps Result#initialize's parameter list small.
-    class FilterConfig
-      attr_reader :filters, :cover_filters, :groups
-
-      def initialize(filters: SimpleCov.filters, cover_filters: SimpleCov.cover_filters, groups: SimpleCov.groups)
-        @filters = filters
-        @cover_filters = cover_filters
-        @groups = groups
-      end
-    end
-
-    # Initialize a new SimpleCov::Result from given Coverage.result (a Hash of filenames each containing an array of
-    # coverage data).
-    #
     # `filter_config` defaults to the SimpleCov singleton's filter / group
-    # configuration so existing call sites are unchanged. Pass a custom
-    # FilterConfig to opt out — useful for tests that build synthetic Results
-    # and don't want the project's filters or groups applied.
+    # configuration. Pass a custom FilterConfig to opt out, which is useful for
+    # tests that build synthetic Results.
+    #
+    # `tracked_files` accepts any collection that answers `to_a` (the merge
+    # passes a Set), and nil for a run that tracked nothing.
     def initialize(original_result, command_name: nil, created_at: nil, not_loaded_files: Set.new,
-                   tracked_files: [], run_id: nil, worker_id: nil, report: false, filter_config: FilterConfig.new)
+      tracked_files: nil, run_id: nil, worker_id: nil, contexts: nil, report: false,
+      filter_config: FilterConfig.new)
       @original_result = original_result.freeze
       @command_name = command_name
       @created_at = created_at
-      initialize_coordination_metadata(tracked_files, run_id, worker_id)
+      initialize_resultset_metadata(tracked_files, run_id, worker_id, contexts)
       @groups_config = filter_config.groups
       builder = SourceFileBuilder.new(original_result, not_loaded_files: not_loaded_files)
       @files = builder.call
-      warn_about_missing_source_files(builder.missing_source_files, original_result.size) if report
+      warn_about_missing_source_files(builder.missing_source_files) if report
       apply_cover_filters!(filter_config.cover_filters)
       apply_filters!(filter_config.filters)
     end
 
-    # Returns all filenames for source files contained in this result
     def filenames
       files.map(&:filename)
     end
 
-    # Returns the SimpleCov::SourceFile for the given path, or nil if no
-    # matching file is in this result. The path is resolved against
-    # SimpleCov.root, so callers can pass either an absolute path or a
-    # project-relative one.
+    # The path is resolved against SimpleCov.root, so callers can pass either
+    # an absolute path or a project-relative one.
     def source_file_for(path)
       target = File.expand_path(path, SimpleCov.root)
-      files.find { |file| file.filename == target }
+      files.find { |file| file.filename.eql?(target) }
     end
 
-    # Returns the {line:/branch:/method:} coverage_statistics hash for the
-    # given file path, or nil if no matching source file is in this
-    # result. See SimpleCov::Result#source_file_for for path resolution.
+    # Path resolution as in `source_file_for`.
     def coverage_for(path)
       source_file_for(path)&.coverage_statistics
     end
 
-    # Returns a Hash of groups for this result. Define groups using SimpleCov.group 'Models', 'app/models'
     def groups
       @groups ||= SimpleCov.grouped(files, groups: @groups_config)
     end
 
-    # Applies the configured SimpleCov.formatter on this result. Returns
-    # nil if formatting has been opted out of (`SimpleCov.formatter false`
-    # / `SimpleCov.formatters []`) — the cheap path for non-final
-    # processes in a parallel CI run, which only need their
-    # `.resultset.json` on disk. See #964.
+    # Returns nil if formatting has been opted out of (`SimpleCov.formatter
+    # false` / `SimpleCov.formatters []`), the cheap path for non-final
+    # processes in a parallel CI run, which only need their `.resultset.json`
+    # on disk (#964).
     def format!
       formatter = SimpleCov.formatter
       return nil if formatter.nil?
 
       formatted = Formatter.format(formatter, self)
       # Recorded regardless of how the run ends, so a parent process's
-      # clobber-prevention backstop can tell a report was produced even
-      # when this run's checks or tests failed (unlike .last_run.json,
-      # which only successful runs write).
-      SimpleCov::ReportStamp.touch
+      # clobber-prevention backstop can tell a report was produced even when
+      # this run's checks or tests failed, unlike .last_run.json.
+      ReportStamp.touch
       formatted
     end
 
-    # Defines when this result has been created. Defaults to Time.now
     def created_at
       @created_at ||= Time.now
     end
 
-    # The command name that launched this result.
-    # Delegated to SimpleCov.command_name if not set manually
     def command_name
       @command_name ||= SimpleCov.command_name
     end
 
-    # Returns a hash representation of this Result that can be used for marshalling it into JSON
-    def to_hash
-      data = {"coverage" => coverage, "timestamp" => created_at.to_f} #: Hash[String, untyped]
-      data["run_id"] = run_id if run_id
-      data["worker_id"] = worker_id if worker_id
-      # Omitted when empty so a run that tracks nothing writes the shape it
-      # always has, and so the key only appears where it carries information.
-      data["tracked_files"] = tracked_files unless tracked_files.empty?
-      {command_name => data}
+    def command_names
+      @command_names ||= [command_name]
     end
 
-    # Loads a SimpleCov::Result#to_hash dump
     def self.from_hash(hash)
       hash.map do |command_name, data|
-        new(data.fetch("coverage"), command_name: command_name, created_at: Time.at(data["timestamp"]),
-                                    tracked_files: data["tracked_files"] || [], run_id: data["run_id"],
-                                    worker_id: data["worker_id"])
+        new(data.fetch("coverage"), command_name: command_name, created_at: Time.at(data.fetch("timestamp")),
+          tracked_files: data["tracked_files"], run_id: data["run_id"],
+          worker_id: data["worker_id"], contexts: ContextMap.from_hash(data["contexts"]))
       end
     end
 
-  private
+    private
 
-    def initialize_coordination_metadata(tracked_files, run_id, worker_id)
+    def initialize_resultset_metadata(tracked_files, run_id, worker_id, contexts)
       @tracked_files = tracked_files.to_a
       @run_id = run_id
       @worker_id = worker_id
+      @contexts = contexts
     end
 
-    def warn_about_missing_source_files(missing, input_size)
+    def warn_about_missing_source_files(missing)
       return if missing.empty?
 
-      # Emit only from the process that writes the final report. The merged
-      # result is rebuilt in every parallel worker (each one stores its own
-      # slice), so without this gate the warning prints once per worker — this
-      # is the same signal SimpleCov uses to pick the process that runs the
-      # report and threshold checks. It's intentionally not gated on
-      # print_errors: the default at_fork sets print_errors false on workers,
-      # and in many parallel runners the final-report process is itself a
-      # worker, so a print_errors gate would suppress the one warning we want.
-      # See issues #980 and #1171.
+      # Emit only from the process that writes the final report: the merged
+      # result is rebuilt in every parallel worker, so without this gate the
+      # warning prints once per worker. Intentionally not gated on
+      # print_errors, because the default at_fork sets print_errors false on
+      # workers and in many parallel runners the final-report process is itself
+      # a worker (#980, #1171).
       return unless SimpleCov.final_result_process?
 
-      MissingSourceFilesReporter.new(
-        missing,
-        input_size: input_size,
-        every_entry_dropped: @files.empty? && missing.size == input_size
-      ).warn!
-    end
-
-    # A live result's criterion keys are Symbols (`:lines`, `:branches`),
-    # while entries parsed back from `.resultset.json` carry Strings, and
-    # the combiners read only String keys. Serialize with String keys so a
-    # live result merged against a stored entry contributes its counts
-    # instead of being silently dropped for every shared file.
-    def coverage
-      original_result.slice(*filenames).transform_values do |file_coverage|
-        file_coverage.transform_keys(&:to_s)
-      end
+      # Every built file survives (only the missing ones are dropped), so an
+      # empty file list is exactly the "nothing was found" case.
+      MissingSourceFilesReporter.new(missing, every_entry_dropped: @files.empty?).warn!
     end
 
-    # Applies the given filter chain to `@files`, dropping each source
-    # file that any filter matches.
     def apply_filters!(filters)
       filters.each do |filter|
-        @files = SimpleCov::FileList.new(@files.reject { |source_file| filter.matches?(source_file) })
+        @files = FileList.new(@files.reject { |source_file| filter.matches?(source_file) })
       end
     end
 
-    # When any `cover` matcher is configured, restrict `@files` to source
-    # files matching at least one of them. With no cover matchers configured
-    # this is a no-op, preserving the historical "everything required, then
-    # filtered" universe.
+    # With no cover matchers configured this is a no-op, preserving the
+    # historical "everything required, then filtered" universe.
     def apply_cover_filters!(cover_filters)
       return if cover_filters.empty?
 
-      @files = SimpleCov::FileList.new(
+      @files = FileList.new(
         @files.select { |source_file| cover_filters.any? { |filter| filter.matches?(source_file) } }
       )
     end

data/lib/simplecov/result_adapter.rb

@@ -3,9 +3,6 @@
 require "coverage"
 
 module SimpleCov
-  #
-  # Responsible for adapting the format of the coverage result whether it's default or with statistics
-  #
   class ResultAdapter
     attr_reader :result
 
@@ -25,14 +22,12 @@ module SimpleCov
       end
     end
 
-  private
+    private
 
     # Pre-0.18 resultsets pointed each filename straight at a line-coverage
-    # array; everything since uses the `{lines:, branches:, methods:}`
-    # shape. Newer entries also need their methods and branches tables
-    # massaged before downstream code reports or merges them.
+    # array; everything since uses the `{lines:, branches:, methods:}` shape.
     def adapt_one(file_name, cover_statistic)
-      return {"lines" => cover_statistic} if cover_statistic.is_a?(Array)
+      return {"lines" => cover_statistic} if cover_statistic.instance_of?(Array)
 
       adapt_oneshot_lines_if_needed(file_name, cover_statistic)
       normalize_method_keys(cover_statistic)
@@ -40,42 +35,33 @@ module SimpleCov
       cover_statistic
     end
 
-    # Normalize memory addresses in method coverage keys so that results
-    # from different processes can be merged. Anonymous class names like
-    # "#<Class:0x00007ff19ab24790>" get inconsistent addresses across runs.
-    # Address widths vary by runtime (32-bit hosts: 8 hex chars; 64-bit
-    # CRuby: 16; some JVM/TruffleRuby formats may differ), so match any
-    # length of hex digits and collapse to a single placeholder.
+    # Normalizes memory addresses in method coverage keys so results from
+    # different processes can be merged: anonymous class names like
+    # "#<Class:0x00007ff19ab24790>" get inconsistent addresses across runs, and
+    # address widths vary by runtime.
     ADDRESS_PATTERN = /0x\h+/
     private_constant :ADDRESS_PATTERN
 
     ADDRESS_PLACEHOLDER = "0x0"
     private_constant :ADDRESS_PLACEHOLDER
 
-    # Strip the `#<Class:Foo>` wrapper Ruby's Coverage adds to singleton-class
+    # Strips the `#<Class:Foo>` wrapper Ruby's Coverage adds to singleton-class
     # method keys. `module_function` and class methods get recorded both as
-    # singleton (`[#<Class:Foo>, :m, …]`) and instance/module (`[Foo, :m, …]`)
-    # entries pointing at the same source location; only one of the two is
-    # ever reachable at runtime, so we merge them. Only applies to named
-    # constants — anonymous-class addresses like `#<Class:0x0>` are left
-    # alone (handled by ADDRESS_PATTERN above).
+    # singleton and instance/module entries pointing at the same source
+    # location, and only one of the two is ever reachable at runtime. Only
+    # named constants: anonymous-class addresses are left to ADDRESS_PATTERN.
     SINGLETON_WRAPPER_PATTERN = /\A#<Class:([A-Z_][\w:]*)>\z/
     private_constant :SINGLETON_WRAPPER_PATTERN
 
-    # Ruby's method coverage records one entry per DEFINED METHOD, not per
-    # source location: a block handed to `define_method` /
-    # `define_singleton_method` from a shared code path yields a separate
-    # `[receiver, name, location]` entry for every class it's defined on
-    # (a module's `included` hook defining onto each descendant) AND for
-    # every name it's defined under (a builder looping `define_method key`
-    # over a container), all pointing at the same source. A file-based
-    # report can only express "was the method at this location ever
-    # executed", so entries are aggregated by location alone, summing
-    # hits — otherwise each receiver or name whose generated copy never
-    # ran shows as a phantom uncovered method on a line whose line
-    # coverage is 100%. Regular `def`s map one location to one name, so
-    # they are unaffected. The first entry's (normalized) key is kept for
-    # display. See issue #1234.
+    # Ruby's method coverage records one entry per defined method, not per
+    # source location: a block handed to `define_method` from a shared code
+    # path yields a separate `[receiver, name, location]` entry for every class
+    # it's defined on and every name it's defined under, all pointing at the
+    # same source. A file-based report can only express "was the method at this
+    # location ever executed", so entries are aggregated by location alone,
+    # summing hits. Otherwise each generated copy that never ran shows as a
+    # phantom uncovered method on a line whose line coverage is 100% (#1234).
+    # The first entry's normalized key is kept for display.
     def normalize_method_keys(cover_statistic)
       methods = cover_statistic[:methods]
       return unless methods
@@ -90,72 +76,74 @@ module SimpleCov
     end
 
     def normalize_method_key(key)
-      normalized_key = key.dup
-      normalized_key[0] = class_display_name(key[0])
-                          .gsub(ADDRESS_PATTERN, ADDRESS_PLACEHOLDER)
-                          .sub(SINGLETON_WRAPPER_PATTERN, '\1')
-      normalized_key
+      receiver, *rest = key
+      normalized_receiver = class_display_name(receiver)
+        .gsub(ADDRESS_PATTERN, ADDRESS_PLACEHOLDER)
+        .sub(SINGLETON_WRAPPER_PATTERN, '\1')
+      [normalized_receiver, *rest]
     end
 
-    # Rendering a class name can execute user code: a singleton class's
-    # `to_s` renders its attached object via `#inspect`, which a module can
-    # shadow with an incompatible signature (Liquid::Utils defines
+    # Rendering a class name can execute user code: a singleton class's `to_s`
+    # renders its attached object via `#inspect`, which a module can shadow
+    # with an incompatible signature (Liquid::Utils defines
     # `inspect(value, max_depth = 2)` as a module_function, so rendering
-    # `#<Class:Liquid::Utils>` raises ArgumentError). A coverage report
-    # must never crash the host suite over that, so on failure rebuild the
-    # singleton wrapper from `Module#name` via bound methods (which cannot
-    # be shadowed), falling back to the address form, which
-    # ADDRESS_PATTERN then normalizes. See issue #1236.
+    # `#<Class:Liquid::Utils>` raises ArgumentError). A coverage report must
+    # never crash the host suite over that (#1236).
     def class_display_name(klass)
       klass.to_s
-    rescue StandardError
+    rescue
       singleton_wrapper_name(klass) || Object.instance_method(:to_s).bind_call(klass)
     end
 
+    # `singleton_class?` is a Module method, so a receiver that is neither a
+    # class nor a module has to be turned away first. Anything that then
+    # answers `singleton_class?` truthily is a Class, so `attached_object`
+    # applies, reached through a bound method so shadowing cannot divert it.
     def singleton_wrapper_name(klass)
-      return nil unless klass.is_a?(Class) && klass.singleton_class?
+      return nil unless klass.is_a?(Module) && klass.singleton_class?
 
-      attached = klass.attached_object
-      # simplecov:disable branch — CRuby only reaches the rescue via a
-      # Module/Class attached object (instance singletons render from the
-      # class name chain without calling user inspect), so the non-Module
-      # arm is defensive.
+      attached = Class.instance_method(:attached_object).bind_call(klass)
       name = Module.instance_method(:name).bind_call(attached) if attached.is_a?(Module)
-      # simplecov:enable branch
       name && "#<Class:#{name}>"
     end
 
     # Ruby's eval coverage records a fresh set of branch entries for every
-    # COMPILE of an eval'd string: a template rendered through multiple view
-    # classes (e.g. hanami-view compiles each template once per view) yields
-    # several `[:if, id, location]` conditions at identical coordinates in
-    # the same file, each counting only the renders that flowed through that
+    # compile of an eval'd string: a template rendered through multiple view
+    # classes yields several `[:if, id, location]` conditions at identical
+    # coordinates, each counting only the renders that flowed through that
     # compile. Reported as-is they inflate the branch denominator and turn a
-    # side covered under a different compile into a phantom miss (issue
-    # #1235). Aggregate them by (type, location) — combining a branches hash
-    # with an empty one dedups within it, since BranchesCombiner keys arms
-    # on location identity. Regular (non-eval) source can never produce two
-    # conditions at the same location, so this is a no-op outside eval.
+    # side covered under a different compile into a phantom miss (#1235).
+    # Absorbing into an empty table dedups, since BranchesCombiner keys arms on
+    # location identity. Regular source can never produce two conditions at the
+    # same location, so this is a no-op outside eval.
     def aggregate_duplicated_branches(cover_statistic)
       branches = cover_statistic[:branches]
       return unless branches
 
-      cover_statistic[:branches] = Combine::BranchesCombiner.combine(branches, {})
+      combiner = Combine::BranchesCombiner
+      cover_statistic[:branches] = combiner.materialize(combiner.absorb({}, branches))
     end
 
     def adapt_oneshot_lines_if_needed(file_name, cover_statistic)
       return unless cover_statistic.key?(:oneshot_lines)
 
       oneshot_lines = cover_statistic.delete(:oneshot_lines)
-      line_stub     = build_line_stub(file_name, oneshot_lines)
+      line_stub = build_line_stub(file_name)
       oneshot_lines.each { |covered_line| line_stub[covered_line - 1] = 1 }
       cover_statistic[:lines] = line_stub
     end
 
-    def build_line_stub(file_name, oneshot_lines)
+    # A file that has vanished or no longer parses has no stub to build from,
+    # and neither does a runtime without `Coverage.line_stub` (TruffleRuby), so
+    # start from nothing: the assignments in `adapt_oneshot_lines_if_needed`
+    # grow the array to the highest covered line, which is as far as the
+    # oneshot data reaches anyway.
+    def build_line_stub(file_name)
+      return [] unless Coverage.respond_to?(:line_stub)
+
       Coverage.line_stub(file_name)
     rescue Errno::ENOENT, SyntaxError
-      Array.new(oneshot_lines.max || 0, nil)
+      []
     end
   end
 end

data/lib/simplecov/result_merger/contexts.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  module ResultMerger
+    module Contexts
+      extend self
+
+      # The same union-or-drop rule the cross-suite merge applies: the union when
+      # both sides recorded a map, no map at all when either did not, since a
+      # partial map would present one runner's tests as the pair's. `entry` starts
+      # as a copy of `incoming`, so the drop has to remove the key rather than
+      # merely decline to add it.
+      def carry(entry, existing, incoming)
+        ours = ContextMap.from_hash(existing["contexts"])
+        theirs = ContextMap.from_hash(incoming["contexts"])
+        return entry.except("contexts") unless ours && theirs
+
+        entry.merge("contexts" => ours.absorb(theirs).to_h)
+      end
+    end
+  end
+end