simplecov 1.1.0 → 1.2.0

data/lib/simplecov/result_merger/legacy_format_adapter.rb

@@ -2,22 +2,18 @@
 
 module SimpleCov
   module ResultMerger
-    # We changed the format of the raw result data in simplecov, as people
-    # are likely to have "old" resultsets lying around (but not too old so
-    # that they're still considered we can adapt them). See
-    # https://github.com/simplecov-ruby/simplecov/pull/824#issuecomment-576049747
     module LegacyFormatAdapter
-    module_function
+      extend self
 
       def call(result)
         pre_0_18?(result) ? upgrade(result) : result
       end
 
-      # Pre-0.18 coverage data pointed from file directly to an array of
-      # line coverage rather than a `{"lines" => [...]}` hash.
+      # Pre-0.18 coverage data pointed from file directly to an array of line
+      # coverage rather than a `{"lines" => [...]}` hash.
       def pre_0_18?(result)
         _key, data = result.first
-        data.is_a?(Array)
+        data.instance_of?(Array)
       end
 
       def upgrade(result)

data/lib/simplecov/result_merger/resultset_file.rb

@@ -4,25 +4,22 @@ require "json"
 
 module SimpleCov
   module ResultMerger
-    # Read + parse a `.resultset.json` file with the same tolerance the
-    # historical `ResultMerger` had: a missing or empty file quietly
-    # returns `{}`, an unparseable one warns and returns `{}`, and parse
-    # success returns the decoded Hash with any malformed entries
-    # warned about and dropped.
+    # Read and parse a `.resultset.json` with the same tolerance the historical
+    # `ResultMerger` had: a missing or empty file quietly returns `{}`, an
+    # unparseable one warns and returns `{}`, and malformed entries inside a
+    # valid file are warned about and dropped.
     module ResultsetFile
-    module_function
+      extend self
 
       def parse(path)
         data = read(path)
         decode(data)
       end
 
-      # A missing or blank file quietly means "no results yet"; anything
-      # else — a 1-byte truncation included — flows through decode so
-      # corruption warns instead of silently vanishing (the old
-      # `length < 2` check swallowed exactly those). Read first and
-      # rescue rather than check exist? (racy against a concurrent
-      # clean).
+      # A missing or blank file quietly means "no results yet"; anything else, a
+      # 1-byte truncation included, flows through decode so corruption warns
+      # instead of silently vanishing. Read first and rescue rather than check
+      # exist?, which is racy against a concurrent clean.
       def read(path)
         data = File.read(path)
         return if data.match?(/\A\s*\z/)
@@ -32,37 +29,33 @@ module SimpleCov
         nil
       end
 
+      # Valid JSON need not be an object, but everything downstream iterates
+      # command => data pairs, so anything else gets the same tolerance as a parse
+      # failure. A "null" file has long meant an empty resultset.
       def decode(content)
         return {} unless content
 
         parsed = JSON.parse(content)
-        return {} if parsed.nil? # a "null" file has long meant an empty resultset
+        return {} if parsed.nil?
 
-        # Valid JSON need not be an object ("[1,2]" and "\"x\"" parse
-        # fine), but everything downstream iterates command => data
-        # pairs, so anything else would crash out of the middle of a
-        # merge. Same tolerance as a parse failure: warn and move on.
-        parsed.is_a?(Hash) ? drop_malformed_entries(parsed) : invalid_resultset
-      rescue StandardError
+        parsed.instance_of?(Hash) ? drop_malformed_entries(parsed) : invalid_resultset
+      rescue
         invalid_resultset
       end
 
-      # Each surviving entry must have the shape every consumer relies
-      # on: a Hash carrying a Numeric "timestamp" (the merge-timeout
-      # check) and a Hash "coverage" (the merge fold). A truncated or
-      # hand-edited entry would otherwise crash out of the middle of an
-      # at_exit merge, so it gets the same warn-and-move-on treatment
-      # as an unparseable file.
       def drop_malformed_entries(resultset)
         malformed, valid = resultset.partition { |_command_name, data| !well_formed_entry?(data) }
         return resultset if malformed.empty?
 
-        warn "[SimpleCov]: Warning! Ignoring malformed resultset entries: #{malformed.map(&:first).sort.join(', ')}"
+        warn "[SimpleCov]: Warning! Ignoring malformed resultset entries: #{malformed.map(&:first).sort.join(", ")}"
         valid.to_h
       end
 
+      # Every consumer relies on a Hash carrying a Numeric "timestamp" and a Hash
+      # "coverage". A truncated or hand-edited entry would otherwise crash out of
+      # the middle of an at_exit merge.
       def well_formed_entry?(data)
-        data.is_a?(Hash) && data["timestamp"].is_a?(Numeric) && data["coverage"].is_a?(Hash)
+        data.instance_of?(Hash) && data["timestamp"].is_a?(Numeric) && data["coverage"].instance_of?(Hash)
       end
 
       def invalid_resultset

data/lib/simplecov/result_merger/resultset_run_identity.rb

@@ -2,15 +2,14 @@
 
 module SimpleCov
   module ResultMerger
-    # Run/worker metadata queries used by resultset storage and parallel
-    # coordination. Kept separate from the coverage-folding implementation.
+    # Run and worker metadata queries used by resultset storage and parallel
+    # coordination.
     module ResultsetRunIdentity
-      # One namespaced identity per distinct worker that wrote to the
-      # current run: `[:worker, id]` for entries that carry a worker id,
-      # `[:legacy, command_name]` for fresh entries written without one
-      # (an old SimpleCov writing to the same resultset). Pairs rather
-      # than mangled strings, so a resultset mixing both kinds can never
-      # alias a real worker id to a synthesized legacy identity.
+      # One namespaced identity per distinct worker that wrote to the current run:
+      # `[:worker, id]` for entries carrying a worker id, `[:legacy, command_name]`
+      # for fresh entries written without one. Pairs rather than mangled strings,
+      # so a resultset mixing both kinds can never alias a real worker id to a
+      # synthesized legacy identity.
       def worker_identities_for_run(results, run_id, started_at)
         results.filter_map do |command_name, data|
           next unless current_run_entry?(data, run_id, started_at)
@@ -20,13 +19,16 @@ module SimpleCov
         end.uniq
       end
 
+      # `eql?` rather than `==`: run ids are strings, and value equality already
+      # answers false for the nil run id a caller with no identity of its own
+      # passes.
       def current_run_entry?(entry, run_id, started_at)
-        return false unless entry.is_a?(Hash)
+        return false unless entry.instance_of?(Hash)
 
         entry_run_id = entry["run_id"]
         return fresh_entry?(entry, started_at) unless entry_run_id
-        return false unless run_id && entry_run_id == run_id
-        return true if SimpleCov::RunIdentity.authoritative?
+        return false unless entry_run_id.eql?(run_id)
+        return true if RunIdentity.authoritative?
 
         fresh_entry?(entry, started_at)
       end
@@ -36,28 +38,24 @@ module SimpleCov
         timestamp.is_a?(Numeric) && started_at && timestamp >= started_at.to_f
       end
 
-      # Whether `entry` was written by a runner concurrent with this
-      # process: either it shares our run id (`current_run_entry?`), or it
-      # was written strictly after our process started. A mismatched run
-      # id must not defeat the timestamp check — a subprocess we shelled
-      # out to (fork+exec) generates its own random run id, and its
-      # freshly written entry is exactly the data issue #581 protects
-      # from being clobbered. Strict id matching is reserved for worker
-      # counting (`worker_identities_for_run`), where admitting a stale
-      # entry would end a sibling wait early.
+      # Either the entry shares our run id, or it was written strictly after our
+      # process started. A mismatched run id must not defeat the timestamp check: a
+      # subprocess we shelled out to generates its own random run id, and its
+      # freshly written entry is exactly the data #581 protects from being
+      # clobbered. Strict id matching is reserved for worker counting, where
+      # admitting a stale entry would end a sibling wait early.
       def concurrent_runner_entry?(entry, incoming = nil)
-        return false unless entry.is_a?(Hash)
+        return false unless entry.instance_of?(Hash)
 
-        incoming_run_id = incoming["run_id"] if incoming.is_a?(Hash)
+        incoming_run_id = incoming["run_id"] if incoming.instance_of?(Hash)
         started_at = SimpleCov.process_start_time
         return true if current_run_entry?(entry, incoming_run_id, started_at)
 
         written_after_start?(entry, started_at)
       end
 
-      # Strictly after, unlike `fresh_entry?`: an entry stamped at the
-      # exact instant we started is treated as leftover from a previous
-      # run, so a same-second stale entry is still overwritten.
+      # Strictly after, unlike `fresh_entry?`: an entry stamped at the exact
+      # instant we started is treated as leftover from a previous run.
       def written_after_start?(entry, started_at)
         timestamp = entry["timestamp"]
         timestamp.is_a?(Numeric) && started_at && timestamp > started_at.to_f

data/lib/simplecov/result_merger/resultset_store.rb

@@ -7,14 +7,11 @@ require_relative "../atomic_file"
 
 module SimpleCov
   module ResultMerger
-    # Reads and writes the persistent `.resultset.json` cache, including
-    # file-lock synchronization between processes and atomic temp-file
-    # renames so concurrent readers don't observe a truncated file.
     module ResultsetStore
       LOCK_MONITOR = Monitor.new
       private_constant :LOCK_MONITOR
 
-    module_function
+      extend self
 
       def resultset_path
         File.join(SimpleCov.coverage_path, ".resultset.json")
@@ -24,30 +21,42 @@ module SimpleCov
         File.join(SimpleCov.coverage_path, ".resultset.json.lock")
       end
 
-      # Compact JSON, not pretty-printed: this is a machine-read cache
-      # that every parallel worker rewrites wholesale, and on a large
-      # project pretty printing nearly doubles the bytes written, read
-      # back, and parsed on each of those store-merge round trips.
+      # Compact JSON, not pretty-printed: this is a machine-read cache that every
+      # parallel worker rewrites wholesale, and on a large project pretty printing
+      # nearly doubles the bytes written, read back, and parsed on each of those
+      # store-merge round trips.
       def write(resultset)
         AtomicFile.write(resultset_path, "#{JSON.generate(resultset)}\n")
       end
 
-      # Serialize threads before taking the process-wide file lock. Nested
-      # calls by the owning thread bypass flock so they cannot deadlock on a
-      # second descriptor for the same lock file.
+      # Threads are serialized before the process-wide file lock is taken. Nested
+      # calls by the owning thread bypass flock so they cannot deadlock on a second
+      # descriptor for the same lock file.
       def synchronize(&)
         return yield if LOCK_MONITOR.mon_owned?
 
         LOCK_MONITOR.synchronize { with_flock(&) }
       end
 
-      def with_flock
+      def with_flock(&)
         FileUtils.mkdir_p(SimpleCov.coverage_path)
-        File.open(writelock_path, "w+") do |f|
-          f.flock(File::LOCK_EX)
+        holding_writelock(&)
+      end
+
+      def holding_writelock
+        open_file(writelock_path, "w+") do |file|
+          file.flock(File::LOCK_EX)
           yield
         end
       end
+
+      # mutant:disable — Ruby 4.0 removed Kernel#open's leading-pipe
+      # command mode, so no test can tell `File.open` from `open` here
+      # any more. The explicit receiver is kept: on older rubies it is
+      # what refuses to run a lock path as a command.
+      def open_file(name, mode, &)
+        File.open(name, mode, &)
+      end
     end
   end
 end

data/lib/simplecov/result_merger/unloaded_files.rb

@@ -2,25 +2,21 @@
 
 module SimpleCov
   module ResultMerger
-    # The merge step's half of unloaded-file handling: the policy of when
-    # to inject and which criteria simulated files carry. The mechanism —
-    # expanding globs and simulating each file — is
-    # `SimpleCov::UnloadedFileInjector`, an easy name to confuse with this
-    # one.
+    # The merge step's half of unloaded-file handling: the policy of when to
+    # inject and which criteria simulated files carry. The mechanism, expanding
+    # globs and simulating each file, is `SimpleCov::UnloadedFileInjector`.
     #
     # Injection moved here from the individual processes because only the union
     # of what they all loaded says what was really never loaded. Doing it per
     # process meant N workers simulated the same file up to N times and the
-    # merge threw all but one away. See #1250.
+    # merge threw all but one away (#1250).
     module UnloadedFiles
-    module_function
+      extend self
 
-      # The union of what every contributing process was told to track. Absent
-      # from resultsets written before this was recorded, in which case those
-      # processes injected their own unloaded files and the data is already in
-      # the coverage hash.
       # A collector for the merge to hand `merge_valid_results`, gathering the
       # tracked paths of every resultset that survives the merge timeout.
+      # Absent from resultsets written before this was recorded, in which case
+      # those processes injected their own unloaded files already.
       def collector(into)
         ->(surviving) { into.merge(tracked_in(surviving)) }
       end
@@ -38,12 +34,11 @@ module SimpleCov
         tracked.empty? ? entry : entry.merge("tracked_files" => tracked)
       end
 
-      # Simulate each tracked file the merged coverage doesn't already carry.
+      # Simulates each tracked file the merged coverage doesn't already carry.
       # The paths come from the resultsets rather than this process's own
-      # configuration, which a standalone `collate` would not have: it never ran
-      # `SimpleCov.start`, so it has no `cover` glob to expand. Idempotent, so
-      # resultsets from an older SimpleCov (or from a `merging false` process)
-      # that already carry their unloaded files pass through untouched.
+      # configuration, which a standalone `collate` would not have. Idempotent,
+      # so resultsets that already carry their unloaded files pass through
+      # untouched.
       def inject(coverage, tracked_files)
         SimpleCov.inject_unloaded_files(
           coverage, tracked_files.to_a,
@@ -54,10 +49,10 @@ module SimpleCov
 
       # A simulated file should have the same shape as the files it is being
       # merged alongside, so the criteria come from the merged data rather than
-      # from this process's configuration, which is not necessarily the
-      # configuration any contributing process measured under: `simplecov merge`
-      # never ran `SimpleCov.start` at all. Giving injected files fewer tables
-      # than their neighbours is what inflates the percentage #1059 fixed.
+      # from this process's configuration, which is not necessarily what any
+      # contributing process measured under: `simplecov merge` never ran
+      # `SimpleCov.start` at all. Giving injected files fewer tables than their
+      # neighbours is what inflates the percentage #1059 fixed.
       #
       # Falls back to the configuration when there is nothing to be consistent
       # with, which is a merge of resultsets that carried no files.
@@ -77,25 +72,22 @@ module SimpleCov
       # Which files no contributing process ever loaded. Injection reports the
       # ones it added, but a file can also arrive already simulated from a
       # resultset this merge didn't inject into, so the merged line counts are
-      # still consulted, using the same signal
-      # `Combine::CoverageAccumulator` reconciles synthesized tuples on.
+      # still consulted.
       #
       # A file is judged only when it has a relevant line. A branch-only or
       # method-only run reports no line data at all for the files it loaded,
-      # and a loaded file with no executable lines (a comment-only constants
-      # stub, say) reports every line as `nil` — either would otherwise read
-      # as "never executed" and mark a genuinely loaded file not loaded,
-      # turning its branch and method coverage into #902's 0%.
-      # `SimulateCoverage` omits lines under those criteria too and gives a
-      # simulated file a `0` on every relevant line, so genuinely unloaded
-      # files still carry judgeable data, and a simulated file with none is
-      # already flagged by injection reporting it.
+      # and a loaded file with no executable lines reports every line as `nil`.
+      # Either would otherwise read as "never executed" and mark a genuinely
+      # loaded file not loaded, turning its branch and method coverage into
+      # #902's 0%.
       def never_executed(coverage)
         coverage.each_with_object(Set.new) do |(filename, file_coverage), set|
           counts = Array(file_coverage["lines"]) #: Array[Integer?]
-          next unless counts.any? { |count| !count.nil? }
+          # A line count is an Integer or nil, and every Integer is truthy, so a
+          # truthy element is exactly a relevant line.
+          next unless counts.any?
 
-          set << filename unless Combine::CoverageAccumulator.executed?(file_coverage["lines"])
+          set << filename unless Combine::CoverageAccumulator.executed?(counts)
         end
       end
     end

data/lib/simplecov/result_merger.rb

@@ -4,13 +4,13 @@ require_relative "result_merger/legacy_format_adapter"
 require_relative "result_merger/resultset_file"
 require_relative "result_merger/resultset_run_identity"
 require_relative "result_merger/resultset_store"
+require_relative "result_merger/contexts"
 require_relative "result_merger/unloaded_files"
 
 module SimpleCov
   #
-  # Singleton that is responsible for caching, loading and merging
-  # SimpleCov::Results into a single result for coverage analysis based
-  # upon multiple test suites.
+  # Caching, loading and merging `SimpleCov::Result`s into a single result for
+  # coverage analysis based upon multiple test suites.
   #
   module ResultMerger
     extend ResultsetRunIdentity
@@ -27,40 +27,40 @@ module SimpleCov
       end
 
       def merge_results(*file_paths, ignore_timeout: false)
-        # Tracked paths are collected as each resultset is parsed, so files are
-        # still read and discarded one at a time. See #1250.
+        # Tracked paths and test maps are collected as each resultset is parsed,
+        # so files are still read and discarded one at a time (#1250).
         tracked_files = Set.new
+        context_maps = ContextMap::Union.new
         command_names, coverage = absorb_results(file_paths, ignore_timeout: ignore_timeout,
-                                                 &UnloadedFiles.collector(tracked_files))
-        create_result(command_names, coverage, tracked_files: tracked_files)
+          &entry_collector(tracked_files, context_maps))
+        create_result(command_names, coverage, tracked_files: tracked_files, contexts: context_maps.map)
+      end
+
+      # One block over the entries each resultset contributes to the merge,
+      # feeding every merge-side accumulator in a single pass: the tracked
+      # paths and the per-test map union (#1250).
+      def entry_collector(tracked_files, context_maps)
+        collectors = [UnloadedFiles.collector(tracked_files), context_maps.collector]
+        ->(surviving) { collectors.each { |collector| collector.call(surviving) } }
       end
 
       #
       # Reads every resultset and folds it into one merged coverage, stopping
       # short of building a `SimpleCov::Result`.
       #
-      # It is intentional here that files are only read in and parsed one at a time.
-      #
-      # In big CI setups you might deal with 100s of CI jobs and each one producing Megabytes
-      # of data. Reading them all in easily produces Gigabytes of memory consumption which
-      # we want to avoid.
-      #
-      # For similar reasons a SimpleCov::Result is only created in the end as that'd create
-      # even more data especially when it also reads in all source files.
+      # Files are only read in and parsed one at a time on purpose. In big CI
+      # setups you might deal with 100s of jobs each producing megabytes of
+      # data, and reading them all in easily produces gigabytes of memory
+      # consumption. For the same reason a `Result` is only created at the end.
       #
       # One accumulator absorbs the whole run, rather than folding each file
-      # into the merged-so-far pairwise: the pairwise form rebuilt every
-      # file's coverage once per resultset, which is what made merging a
-      # large parallel run's results the dominant cost of `collate`.
-      # Absorbing is still one resultset at a time, so the memory ceiling
-      # above is unchanged.
+      # into the merged-so-far pairwise: the pairwise form rebuilt every file's
+      # coverage once per resultset, which is what made merging a large
+      # parallel run's results the dominant cost of `collate`.
       #
       # `file_paths` is only ever iterated, so a caller that wants to observe
-      # the merge as it goes can hand in any Enumerable — `benchmarks/collate`
-      # passes an Enumerator that reports progress — rather than reimplement
-      # this loop and risk timing something other than what ships.
-      #
-      # @return [Array] the command names and the merged coverage
+      # the merge as it goes can hand in any Enumerable. `benchmarks/collate`
+      # passes an Enumerator that reports progress.
       #
       def absorb_results(file_paths, ignore_timeout: false, &on_parse)
         Combine::CoverageAccumulator.fold(
@@ -84,7 +84,6 @@ module SimpleCov
           [[command_name], LegacyFormatAdapter.call(data.fetch("coverage"))]
         end
 
-        # one file itself _might_ include multiple test runs
         merge_coverage(*command_plus_coverage)
       end
 
@@ -101,50 +100,54 @@ module SimpleCov
       end
 
       def warn_about_expired_results(expired_command_names)
-        # Respect quiet configurations and keep this consistent with every
-        # other SimpleCov diagnostic. Ordinary parallel workers only store
-        # their own slice; the selected final process performs this merge.
+        # Ordinary parallel workers only store their own slice; the selected
+        # final process performs this merge.
         return unless SimpleCov.print_errors
 
         warn "[SimpleCov]: Excluded #{expired_command_names.size} result(s) older than " \
              "merge_timeout (#{SimpleCov.merge_timeout}s) from the merged report: " \
-             "#{expired_command_names.sort.join(', ')}. " \
+             "#{expired_command_names.sort.join(", ")}. " \
              "Increase SimpleCov.merge_timeout to include them."
       end
 
-      def create_result(command_names, coverage, tracked_files: Set.new)
+      # `tracked_files:` has no default: only the caller knows what the
+      # contributing processes were told to track, and quietly reading an
+      # omission as "nothing was tracked" would drop every never-loaded
+      # file from the merged report.
+      def create_result(command_names, coverage, tracked_files:, contexts: nil)
         return nil unless coverage
 
-        command_name = command_names.reject(&:empty?).sort.join(", ")
+        # Deduped: a CI matrix collates one resultset per worker, and joining
+        # every run's name verbatim rendered "RSpec" a hundred times over in the
+        # report footer (#1284).
+        distinct_names = command_names.reject(&:empty?).uniq.sort
         coverage, injected = UnloadedFiles.inject(coverage, tracked_files)
-        # The merged result is the authoritative one users actually see, so
-        # it's the one that warns about source files dropped because they no
-        # longer exist on disk (issue #980). The per-process slices built in
-        # `process_coverage_result` stay quiet to avoid one warning per worker.
-        SimpleCov::Result.new(
+        # The merged result is the authoritative one users actually see, so it's
+        # the one that warns about source files dropped because they no longer
+        # exist on disk (#980). The per-process slices stay quiet to avoid one
+        # warning per worker.
+        Result.new(
           coverage,
-          command_name: command_name,
+          command_name: distinct_names.join(", "), contexts: contexts, report: true,
           not_loaded_files: UnloadedFiles.never_executed(coverage) | injected,
-          tracked_files: tracked_files.to_a,
-          report: true
-        )
+          tracked_files: tracked_files
+        ).tap { |result| result.command_names = distinct_names }
       end
 
       def merge_coverage(*results)
         return [[""], nil] if results.empty?
-        return results.first if results.size == 1
 
-        Combine::CoverageAccumulator.fold(results)
+        # Destructured rather than counted: the single-result fast path then
+        # hands back the very result it checked for, not a second lookup.
+        only, *rest = results
+        rest.empty? ? only : Combine::CoverageAccumulator.fold(results)
       end
 
-      #
-      # Gets all SimpleCov::Results stored in resultset, merges them and produces a new
-      # SimpleCov::Result with merged coverage data and the command_name
-      # for the result consisting of a join on all source result's names
       def merged_result
         tracked_files = Set.new
-        command_names, coverage = merge_valid_results(read_resultset, &UnloadedFiles.collector(tracked_files))
-        create_result(command_names, coverage, tracked_files: tracked_files)
+        context_maps = ContextMap::Union.new
+        command_names, coverage = merge_valid_results(read_resultset, &entry_collector(tracked_files, context_maps))
+        create_result(command_names, coverage, tracked_files: tracked_files, contexts: context_maps.map)
       end
 
       def read_resultset
@@ -152,13 +155,11 @@ module SimpleCov
         ResultsetFile.decode(content)
       end
 
-      # Saves the given SimpleCov::Result in the resultset cache
-      def store_result(result) # rubocop:disable Naming/PredicateMethod
+      def store_result(result)
         synchronize_resultset do
-          # Ensure we have the latest, in case it was already cached
           new_resultset = read_resultset
 
-          # A single result only ever has one command_name, see `SimpleCov::Result#to_hash`
+          # A single result only ever has one command_name, see `Result#to_hash`.
           command_name, data = result.to_hash.first
           new_resultset[command_name] = merged_entry(new_resultset[command_name], data)
 
@@ -168,16 +169,16 @@ module SimpleCov
       end
 
       # If an entry with the same command_name was written AFTER our process
-      # started, a sibling test runner (typically a subprocess our parent
-      # process shelled out to) wrote it. Combine coverage data rather than
-      # overwriting, so an empty parent-process result doesn't clobber the
-      # subprocess's real data. See https://github.com/simplecov-ruby/simplecov/issues/581.
+      # started, a sibling test runner wrote it. Combine coverage data rather
+      # than overwriting, so an empty parent-process result doesn't clobber the
+      # subprocess's real data (#581).
       def merged_entry(existing, incoming)
         return incoming unless concurrent_runner_entry?(existing, incoming)
 
         merged = incoming.merge(
-          "coverage" => Combine::ResultsCombiner.combine(existing["coverage"], incoming["coverage"])
+          "coverage" => Combine::ResultsCombiner.combine(existing.fetch("coverage"), incoming.fetch("coverage"))
         )
+        merged = Contexts.carry(merged, existing, incoming)
         UnloadedFiles.carry_tracked(merged, existing, incoming)
       end