simplecov 0.22.0 → 1.1.1

data/lib/simplecov/parallel_result_merger.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+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.
+  #
+  # 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.
+  #
+  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.
+    #
+    def merge_and_store(*file_paths, processes:, ignore_timeout: false)
+      return ResultMerger.merge_and_store(*file_paths, ignore_timeout: ignore_timeout) if processes < 2
+
+      result = merge_results(*file_paths, processes: processes, ignore_timeout: ignore_timeout)
+      ResultMerger.store_result(result) if result
+      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
+      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.
+      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)
+    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.
+      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.
+      return nil unless Process.respond_to?(:fork)
+
+      fan_out(chunk(file_paths, processes), ignore_timeout: ignore_timeout, tracked_files: tracked_files)
+    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)) }
+    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)
+      workers = spawn_workers(chunks, ignore_timeout: ignore_timeout)
+      payloads = collect(workers)
+      return nil unless payloads
+
+      payloads.each { |(_pair, tracked)| tracked_files.merge(tracked) }
+      ResultMerger.merge_coverage(*payloads.map(&:first))
+    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
+        abandon(workers)
+        raise
+      end
+
+      workers
+    end
+
+    def abandon(workers)
+      workers.each do |worker|
+        worker[:reader].close
+        succeeded?(worker[: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.
+    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
+      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.
+    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.
+    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)
+      writer.close
+      0
+    rescue StandardError => e
+      warn "[SimpleCov]: parallel merge worker failed: #{e.class}: #{e.message}" 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)
+      payloads = drain(workers)
+      failed = workers.count { |worker| !succeeded?(worker[:pid]) }
+      return payloads if failed.zero? && payloads.all?
+
+      warn_about_failed_workers(failed, workers.size)
+      nil
+    ensure
+      workers.each { |worker| worker[:reader].close }
+    end
+
+    def drain(workers)
+      workers.map { |worker| Thread.new { read_payload(worker[: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
+      Marshal.load(reader) # rubocop:disable Security/MarshalLoad
+      # steep:ignore:end
+    rescue StandardError
+      nil
+    end
+
+    def succeeded?(pid)
+      _pid, status = Process.wait2(pid)
+      status.success?
+    rescue SystemCallError
+      # 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
+
+    def warn_about_failed_workers(failed, total)
+      return unless SimpleCov.print_errors
+
+      warn "[SimpleCov]: parallel merge did not complete (#{failed} of #{total} workers failed); " \
+           "merging the resultsets in this process instead."
+    end
+  end
+end

data/lib/simplecov/process.rb

@@ -1,19 +1,59 @@
 # frozen_string_literal: true
 
-module Process
+# 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
-    def fork_with_simplecov(&block)
-      if defined?(SimpleCov) && SimpleCov.running
-        fork_without_simplecov do
-          SimpleCov.at_fork.call(Process.pid)
-          block.call if block_given?
-        end
-      else
-        fork_without_simplecov(&block)
-      end
+    # 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.
+    def reset_inherited_at_exit_state!
+      @at_exit_hook_installed = false
+      self.external_at_exit = false
     end
+  end
 
-    alias fork_without_simplecov fork
-    alias fork fork_with_simplecov
+  # 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.
+  module ProcessForkHook
+    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
+      pid
+    end
   end
 end
+
+Process.singleton_class.prepend(SimpleCov::ProcessForkHook)

data/lib/simplecov/profiles/bundler_filter.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 SimpleCov.profiles.define "bundler_filter" do
-  add_filter "/vendor/bundle/"
+  skip "/vendor/bundle/"
 end

data/lib/simplecov/profiles/hidden_filter.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 SimpleCov.profiles.define "hidden_filter" do
-  add_filter %r{^/\..*}
+  skip(/\A\..*/)
 end

data/lib/simplecov/profiles/rails.rb

@@ -3,16 +3,30 @@
 SimpleCov.profiles.define "rails" do
   load_profile "test_frameworks"
 
-  add_filter %r{^/config/}
-  add_filter %r{^/db/}
+  skip %r{\Aconfig/}
+  skip %r{\Adb/}
 
-  add_group "Controllers", "app/controllers"
-  add_group "Channels", "app/channels"
-  add_group "Models", "app/models"
-  add_group "Mailers", "app/mailers"
-  add_group "Helpers", "app/helpers"
-  add_group "Jobs", %w[app/jobs app/workers]
-  add_group "Libraries", "lib/"
+  group "Controllers", "app/controllers"
+  group "Channels", "app/channels"
+  group "Models", "app/models"
+  group "Mailers", "app/mailers"
+  group "Helpers", "app/helpers"
+  group "Jobs", %w[app/jobs app/workers]
+  group "Libraries", "lib/"
 
-  track_files "{app,lib}/**/*.rb"
+  # Preserve the legacy `track_files` semantics (additive disk-discovery
+  # without restricting the report's universe): write the ivar directly
+  # so loading the profile doesn't emit the public-API deprecation. Users
+  # migrating their own configs should prefer `cover "{app,lib}/**/*.rb"`,
+  # which both injects unloaded files and scopes the report to the match
+  # set — usually the intended behavior for a Rails project.
+  @tracked_files = "{app,lib}/**/*.rb"
+
+  # `parallelize(workers: ...)` forks worker processes that each run a
+  # slice of the suite. Without subprocess support, the workers' coverage
+  # is dropped on the floor and the parent records 0% for everything they
+  # touched. Hooking `Process._fork` makes each worker re-call
+  # `SimpleCov.start` with a unique command_name so the resultsets merge
+  # correctly.
+  merge_subprocesses true
 end

data/lib/simplecov/profiles/root_filter.rb

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
 
 SimpleCov.profiles.define "root_filter" do
-  # Exclude all files outside of simplecov root
-  root_filter = nil
-  add_filter do |src|
-    root_filter ||= /\A#{Regexp.escape(SimpleCov.root + File::SEPARATOR)}/io
-    src.filename !~ root_filter
+  # Exclude all files outside of simplecov root. Shares the regex with
+  # SimpleCov::UselessResultsRemover so the root-prefix logic lives in one
+  # place; this profile is the user-facing entry point that tools like
+  # `SimpleCov.filtered` apply.
+  skip do |src|
+    src.filename !~ SimpleCov::UselessResultsRemover.root_regex
   end
 end

data/lib/simplecov/profiles/strict.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# A "no shortfalls allowed" profile: every coverage criterion is
+# enabled and held to 100%. Per
+# https://github.com/simplecov-ruby/simplecov/issues/1061, this lives as
+# an opt-in profile rather than the default — most projects can't
+# realistically start at 100% on day one — so a team that has paid down
+# the debt can flip the strict switch without re-typing the threshold
+# trio every time.
+#
+# JRuby gracefully degrades: `enable_coverage :branch` / `:method` are
+# accepted (they just add to the configured criteria set), but the
+# runtime can't actually measure them, so the corresponding stats never
+# materialize. `CoverageViolations` skips threshold lookups for
+# criteria not in the stats, so the `:branch` / `:method` clauses below
+# silently no-op on JRuby and only `:line` is enforced.
+#
+# `:eval` widens the universe of code held to 100% to include strings
+# passed through `Kernel#eval` (typically ERB templates, when the user
+# sets `ERB#filename=`). Guarded on `coverage_for_eval_supported?` so
+# the profile stays quiet on Ruby < 3.2, where `enable_coverage :eval`
+# would otherwise warn about the missing runtime support every time
+# the profile loads.
+SimpleCov.profiles.define "strict" do
+  enable_coverage :branch
+  enable_coverage :method
+  # simplecov:disable branch — dogfood runs on Ruby >= 3.2 only, so
+  # the else arm (eval coverage not supported) is unreachable from CI.
+  enable_coverage :eval if coverage_for_eval_supported?
+  # simplecov:enable
+  minimum_coverage line: 100, branch: 100, method: 100
+end

data/lib/simplecov/profiles/test_frameworks.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
 SimpleCov.profiles.define "test_frameworks" do
-  add_filter "/test/"
-  add_filter "/features/"
-  add_filter "/spec/"
-  add_filter "/autotest/"
+  skip %r{\A(test|features|spec|autotest)/}
 end

data/lib/simplecov/profiles.rb

@@ -17,7 +17,7 @@ module SimpleCov
     #
     def define(name, &blk)
       name = name.to_sym
-      raise "SimpleCov Profile '#{name}' is already defined" unless self[name].nil?
+      raise SimpleCov::ConfigurationError, "SimpleCov Profile '#{name}' is already defined" unless self[name].nil?
 
       self[name] = blk
     end
@@ -26,10 +26,39 @@ module SimpleCov
     # Applies the profile of given name on SimpleCov.configure
     #
     def load(name)
+      SimpleCov.configure(&fetch_proc(name))
+    end
+
+    #
+    # Returns the proc registered for the given profile name, autoloading
+    # bundled or plugin-gem profiles on first lookup. Raises if the profile
+    # cannot be located.
+    #
+    # Lookup order:
+    #   1. already registered via #define
+    #   2. require "simplecov/profiles/<name>"   (bundled profiles)
+    #   3. require "simplecov-profile-<name>"    (third-party plugin gems)
+    #
+    def fetch_proc(name)
       name = name.to_sym
-      raise "Could not find SimpleCov Profile called '#{name}'" unless key?(name)
+      autoload_profile(name) unless key?(name)
+      return self[name] if key?(name)
+
+      raise SimpleCov::ConfigurationError, "Could not find SimpleCov Profile called '#{name}'"
+    end
+
+  private
 
-      SimpleCov.configure(&self[name])
+    def autoload_profile(name)
+      require "simplecov/profiles/#{name}"
+    rescue LoadError
+      begin
+        # simplecov:disable — third-party gem fallback (no such gem in test env)
+        require "simplecov-profile-#{name}"
+        # simplecov:enable
+      rescue LoadError
+        # fall through; #fetch_proc raises the user-facing error
+      end
     end
   end
 end

data/lib/simplecov/report_deferral.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+# The clobber-prevention backstop: an empty process stands down instead
+# of formatting over a fresher report a sibling produced. Split from
+# exit_handling.rb, which orchestrates the at_exit flow that consults
+# this. See issue #581.
+module SimpleCov
+  class << self
+    # Returns true when our process has no coverage data to contribute
+    # (after the resultset merge) and a newer report already exists on
+    # disk. Typically fires when `SimpleCov.start` ran in a parent
+    # process that shelled out to the test runner. See issue #581.
+    def defer_to_existing_report?
+      return false unless existing_report_newer_than_us?
+
+      res = result
+      empty = res.nil? || res.files.empty?
+      warn_about_deferred_report if empty
+      empty
+    end
+
+    # `.last_run.json` only exists after fully successful runs, so alone
+    # it left the backstop inert when the child run failed — the case
+    # where clobbering its report hurts most. The report stamp is
+    # touched by every formatting process regardless of exit status. The
+    # rescue covers a file vanishing mid-at_exit (`rm -rf coverage`).
+    def existing_report_newer_than_us?
+      return false unless process_start_time
+
+      [SimpleCov::LastRun.last_run_path, SimpleCov::ReportStamp.path].any? do |path|
+        File.mtime(path) > process_start_time
+      rescue SystemCallError
+        false
+      end
+    end
+
+    def warn_about_deferred_report
+      return unless print_errors
+
+      ExitCodes.print_error SimpleCov::Color.colorize(
+        "Skipping SimpleCov report — this process tracked no application code and a newer " \
+        "report already exists at #{coverage_path}. This usually means SimpleCov.start ran in a " \
+        "parent process (e.g. a Rakefile or Rails' Bundler.require) that shelled out to the test " \
+        "runner. See https://github.com/simplecov-ruby/simplecov/issues/581.",
+        :yellow
+      )
+    end
+  end
+end

data/lib/simplecov/report_stamp.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module SimpleCov
+  # Touches coverage/.report_stamp whenever a report is formatted, no
+  # matter how the run ends. The clobber-prevention backstop
+  # (`SimpleCov.defer_to_existing_report?`) needs an on-disk signal that
+  # a fresher report exists, and `.last_run.json` can't be it alone:
+  # that file is only written after fully successful runs, which left
+  # the backstop inert exactly when the child run failed and its report
+  # mattered most.
+  module ReportStamp
+    class << self
+      def path
+        File.join(SimpleCov.coverage_path, ".report_stamp")
+      end
+
+      def touch
+        FileUtils.touch(path)
+      rescue SystemCallError
+        # A read-only or vanished coverage dir must not crash reporting;
+        # the stamp only powers the deferral heuristic.
+        nil
+      end
+    end
+  end
+end

data/lib/simplecov/result/missing_source_files_reporter.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+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.
+    class MissingSourceFilesReporter
+      def initialize(missing_paths, input_size:, 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)
+      end
+
+      def message
+        @every_entry_dropped ? all_missing_warning : partial_missing_warning
+      end
+
+    private
+
+      def all_missing_warning
+        "SimpleCov dropped all #{@missing_paths.size} source file(s) from the result — " \
+          "none of the paths in the resultset exist on this filesystem: " \
+          "#{summary}. If you're running `SimpleCov.collate`, the source " \
+          "files must be available at the same absolute paths as when the individual resultsets " \
+          "were generated."
+      end
+
+      def partial_missing_warning
+        "SimpleCov dropped #{@missing_paths.size} source file(s) from the result because " \
+          "they don't exist on this filesystem: #{summary}. They were " \
+          "tracked in the resultset but have since moved or been removed."
+      end
+
+      def summary
+        sample = @missing_paths.first(5).join(", ")
+        remaining = @missing_paths.size - 5
+        remaining.positive? ? "#{sample} (+#{remaining} more)" : sample
+      end
+    end
+  end
+end

data/lib/simplecov/result/source_file_builder.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+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
+
+      def initialize(original_result, not_loaded_files:)
+        @original_result = original_result
+        @not_loaded_files = not_loaded_files
+        @missing_source_files = []
+      end
+
+      def call
+        SimpleCov::FileList.new(
+          @original_result
+            .filter_map { |filename, coverage| build_source_file(filename, coverage) }
+            .sort_by(&:filename)
+        )
+      end
+
+    private
+
+      def build_source_file(filename, coverage)
+        unless File.file?(filename)
+          @missing_source_files << filename
+          return
+        end
+
+        SimpleCov::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.
+      def stringify_outer_keys(coverage)
+        coverage.transform_keys(&:to_s)
+      end
+    end
+  end
+end