simplecov 1.0.2 → 1.1.0

data/lib/simplecov/result_merger.rb

@@ -2,7 +2,9 @@
 
 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/unloaded_files"
 
 module SimpleCov
   #
@@ -11,6 +13,8 @@ module SimpleCov
   # upon multiple test suites.
   #
   module ResultMerger
+    extend ResultsetRunIdentity
+
     class << self
       def resultset_path
         ResultsetStore.resultset_path
@@ -23,29 +27,58 @@ module SimpleCov
       end
 
       def merge_results(*file_paths, ignore_timeout: false)
-        # 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.
-        initial_memo = valid_results(file_paths.shift, ignore_timeout: ignore_timeout)
-
-        command_names, coverage = file_paths.reduce(initial_memo) do |memo, file_path|
-          merge_coverage(memo, valid_results(file_path, ignore_timeout: ignore_timeout))
-        end
+        # Tracked paths are collected as each resultset is parsed, so files are
+        # still read and discarded one at a time. See #1250.
+        tracked_files = Set.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)
+      end
 
-        create_result(command_names, coverage)
+      #
+      # 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.
+      #
+      # 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.
+      #
+      # `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
+      #
+      def absorb_results(file_paths, ignore_timeout: false, &on_parse)
+        Combine::CoverageAccumulator.fold(
+          file_paths.lazy.map { |file_path| valid_results(file_path, ignore_timeout: ignore_timeout, &on_parse) }
+        )
       end
 
-      def valid_results(file_path, ignore_timeout: false)
-        merge_valid_results(ResultsetFile.parse(file_path), ignore_timeout: ignore_timeout)
+      # Yields the surviving entries before they are reduced.
+      def valid_results(file_path, ignore_timeout: false, &on_parse)
+        merge_valid_results(ResultsetFile.parse(file_path), ignore_timeout: ignore_timeout, &on_parse)
       end
 
+      # Yields the entries that survived the merge timeout, so a caller that
+      # wants to observe what a resultset carried sees only what is being
+      # merged. An expired entry contributes nothing, tracked paths included.
       def merge_valid_results(results, ignore_timeout: false)
         results = drop_expired_results(results) unless ignore_timeout
+        yield results if block_given?
 
         command_plus_coverage = results.map do |command_name, data|
           [[command_name], LegacyFormatAdapter.call(data.fetch("coverage"))]
@@ -68,12 +101,9 @@ module SimpleCov
       end
 
       def warn_about_expired_results(expired_command_names)
-        # Subprocesses merge the resultset too (each forked worker calls
-        # `SimpleCov.result` to store its slice), and the default `at_fork`
-        # sets `print_errors false` for them. Without this guard the warning
-        # is emitted once per worker — N copies of the same message for an
-        # N-worker run. Gate on `print_errors` like every other SimpleCov
-        # warning so only the reporting process speaks up.
+        # 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.
         return unless SimpleCov.print_errors
 
         warn "[SimpleCov]: Excluded #{expired_command_names.size} result(s) older than " \
@@ -82,26 +112,29 @@ module SimpleCov
              "Increase SimpleCov.merge_timeout to include them."
       end
 
-      def create_result(command_names, coverage)
+      def create_result(command_names, coverage, tracked_files: Set.new)
         return nil unless coverage
 
         command_name = command_names.reject(&:empty?).sort.join(", ")
+        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(coverage, command_name: command_name, report: true)
+        SimpleCov::Result.new(
+          coverage,
+          command_name: command_name,
+          not_loaded_files: UnloadedFiles.never_executed(coverage) | injected,
+          tracked_files: tracked_files.to_a,
+          report: true
+        )
       end
 
       def merge_coverage(*results)
         return [[""], nil] if results.empty?
         return results.first if results.size == 1
 
-        results.reduce do |(memo_command, memo_coverage), (command, coverage)|
-          # timestamp is dropped here, which is intentional (we merge it, it gets a new time stamp as of now)
-          merged_coverage = Combine.combine(Combine::ResultsCombiner, memo_coverage, coverage)
-          [memo_command + command, merged_coverage]
-        end
+        Combine::CoverageAccumulator.fold(results)
       end
 
       #
@@ -109,8 +142,9 @@ module SimpleCov
       # 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
-        command_names, coverage = merge_valid_results(read_resultset)
-        create_result(command_names, coverage)
+        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)
       end
 
       def read_resultset
@@ -139,19 +173,12 @@ module SimpleCov
       # overwriting, so an empty parent-process result doesn't clobber the
       # subprocess's real data. See https://github.com/simplecov-ruby/simplecov/issues/581.
       def merged_entry(existing, incoming)
-        return incoming unless concurrent_runner_entry?(existing)
+        return incoming unless concurrent_runner_entry?(existing, incoming)
 
-        incoming.merge(
-          "coverage" => Combine.combine(Combine::ResultsCombiner, existing["coverage"], incoming["coverage"])
+        merged = incoming.merge(
+          "coverage" => Combine::ResultsCombiner.combine(existing["coverage"], incoming["coverage"])
         )
-      end
-
-      def concurrent_runner_entry?(entry)
-        return false unless entry.is_a?(Hash)
-
-        timestamp = entry["timestamp"]
-        process_start = SimpleCov.process_start_time
-        timestamp && process_start && timestamp.to_i >= process_start.to_i
+        UnloadedFiles.carry_tracked(merged, existing, incoming)
       end
 
       def synchronize_resultset(&)

data/lib/simplecov/result_processing.rb

@@ -13,13 +13,27 @@ module SimpleCov
     # so all results in all files specified will be merged. Pass
     # `ignore_timeout: false` to honor it.
     #
-    def collate(result_filenames, profile = nil, ignore_timeout: true, &)
+    # `processes:` above 1 fans the merge out across that many forked worker
+    # processes, for a collate big enough that reading and parsing the
+    # resultsets dominates it. The report is identical either way, not merely
+    # equivalent — the workers visit the resultsets in the order the
+    # single-process merge visits them — and one process never forks at all.
+    # The count is deliberately not clamped to the machine's core count nor
+    # gated on some minimum number of resultsets: how many processes a collate
+    # job can afford is the caller's call, not SimpleCov's. Anything below 1 is
+    # taken as 1, so a count computed from arithmetic that can reach zero needs
+    # no guarding. Defaults to `SIMPLECOV_CONCURRENCY`, or 1 when that is
+    # unset. See `SimpleCov::ParallelResultMerger`.
+    #
+    def collate(result_filenames, profile = nil, processes: ENV.fetch("SIMPLECOV_CONCURRENCY", 1).to_i,
+                ignore_timeout: true, &)
       raise ArgumentError, "There are no reports to be merged" if result_filenames.empty?
 
       initial_setup(profile, &)
 
       # Use the ResultMerger to produce a single, merged result, ready to use.
-      @result = ResultMerger.merge_and_store(*result_filenames, ignore_timeout: ignore_timeout)
+      @result = ParallelResultMerger.merge_and_store(*result_filenames, processes: [1, processes].max,
+                                                                        ignore_timeout: ignore_timeout)
 
       @collating_result = true
       run_exit_tasks!
@@ -28,24 +42,22 @@ module SimpleCov
     end
 
     #
-    # Returns the result for the current coverage run, merging it across test suites
-    # from cache using SimpleCov::ResultMerger if use_merging is activated (default)
+    # Returns the result for the current coverage run. With merging enabled,
+    # every process stores its own slice, but only the finalization owner reads
+    # and caches the merged result.
     #
     def result
       return @result if result?
 
       use_merging = merging
 
-      # Collect our coverage result. When merging is off there is no merge
-      # step, so this per-process result is the final one and reports any
-      # dropped source files; otherwise the merged result does the reporting.
-      process_coverage_result(report: !use_merging) if defined?(Coverage) && Coverage.running?
+      collect_own_coverage(standalone: !use_merging)
 
       # If we're using merging of results, store the current result
       # first (if there is one), then merge the results and return those
       if use_merging
         SimpleCov::ResultMerger.store_result(@result) if result?
-        return @result unless finalize_merge?
+        return @result unless merge_finalization_owner?
 
         wait_for_other_processes
         @result = SimpleCov::ResultMerger.merged_result
@@ -54,6 +66,16 @@ module SimpleCov
       @result
     end
 
+    # Build this process's slice of the coverage result. `standalone` is true
+    # when no merge step follows, which makes this the final result: it is the
+    # one that reports dropped source files, and the one that injects unloaded
+    # files. When a merge does follow, both jobs belong to the merged result.
+    def collect_own_coverage(standalone:)
+      return unless defined?(Coverage) && Coverage.running?
+
+      process_coverage_result(report: standalone, inject_unloaded: standalone)
+    end
+
     # Returns nil if the result has not been computed, otherwise the result.
     def result?
       defined?(@result) && @result
@@ -79,7 +101,7 @@ module SimpleCov
     # construction). Files matched by no group fall into the implicit
     # "Ungrouped" bucket.
     def grouped(files, groups: SimpleCov.groups)
-      return {} if groups.empty?
+      return {} if GroupNames.validate!(groups.keys).empty?
 
       grouped = groups.transform_values do |filter|
         SimpleCov::FileList.new(files.select { |source_file| filter.matches?(source_file) })
@@ -87,7 +109,7 @@ module SimpleCov
 
       in_group  = grouped_file_set(grouped)
       ungrouped = files.reject { |source_file| in_group.include?(source_file) }
-      grouped["Ungrouped"] = SimpleCov::FileList.new(ungrouped) if ungrouped.any?
+      grouped[GroupNames::UNGROUPED] = SimpleCov::FileList.new(ungrouped) if ungrouped.any?
 
       grouped
     end
@@ -115,6 +137,29 @@ module SimpleCov
       coverage.floor(2)
     end
 
+    # Add simulated coverage for each of `candidate_paths` the result doesn't
+    # already carry, and return it with the set of paths added.
+    #
+    # @api private — the seam `SimpleCov::ResultMerger` injects through. Public
+    # only because the merge runs in another object, on behalf of processes
+    # whose configuration it may not share, so it supplies the paths itself.
+    def inject_unloaded_files(result, candidate_paths, synthesize: nil, lines: nil)
+      return [result, Set.new] if candidate_paths.empty?
+
+      # Synthesizing branch and method tuples means parsing every tracked file
+      # that wasn't loaded, which is about half the cost of simulating one.
+      # Nothing reads those tuples when neither criterion is enabled —
+      # `Combine::CoverageAccumulator` only combines them per criterion, and the
+      # statistics drop them the same way — so skip the parse. The same goes
+      # for line data, which a branch-only or method-only run neither reports
+      # nor receives from `Coverage` for the files it loaded. See #1250.
+      UnloadedFileInjector.call(
+        result, candidate_paths,
+        synthesize: synthesize.nil? ? branch_coverage? || method_coverage? : synthesize,
+        lines: lines.nil? ? line_coverage? : lines
+      )
+    end
+
   private
 
     def initial_setup(profile, &block)
@@ -126,14 +171,15 @@ module SimpleCov
       grouped.values.each_with_object(Set.new) { |file_list, set| set.merge(file_list) }
     end
 
-    # Finds files that were to be tracked but were not loaded, and
-    # initializes their line-by-line coverage to zero (or nil for
-    # comments / whitespace).
-    def add_not_loaded_files(result)
-      globs = unloaded_file_discovery_globs
-      return [result, Set.new] if globs.empty?
-
-      inject_unloaded_files(result.dup, discover_unloaded_paths(globs))
+    # Every path this process was told to track, whether or not it loaded them.
+    # Recorded on the result (and from there into the resultset) so that a merge
+    # in another process can inject the ones nobody loaded without needing this
+    # process's `cover` / `track_files` configuration. A standalone `collate`
+    # never ran `SimpleCov.start` and so has none of its own. See #1250.
+    def tracked_file_paths
+      UnloadedFileInjector.discover(
+        unloaded_file_discovery_globs, root: root, reject: filters.select(&:path_only?)
+      )
     end
 
     # Globs to expand on disk when injecting unloaded files into the
@@ -144,36 +190,29 @@ module SimpleCov
       [tracked_files, *cover_globs].compact
     end
 
-    # Expand the given globs relative to SimpleCov.root, not Dir.pwd —
-    # test runners that chdir (or CI scripts that invoke the suite
-    # from a subdir) would otherwise silently miss the unloaded-file
-    # injection and produce a different file set per environment. See
-    # issue #1106.
-    def discover_unloaded_paths(globs)
-      globs.flat_map { |glob| Dir.glob(glob, base: root) }.uniq
-    end
-
-    def inject_unloaded_files(result, candidate_paths)
-      not_loaded_files = candidate_paths.each_with_object(Set.new) do |file, set|
-        absolute_path = File.expand_path(file, root)
-        next if result.key?(absolute_path)
-
-        result[absolute_path] = SimulateCoverage.call(absolute_path)
-        set << absolute_path
-      end
-
-      [result, not_loaded_files]
-    end
-
     # Run all the steps that handle processing the raw coverage result.
     # `report:` is true only when this slice is the final result (merging
     # off); with merging on the merged result reports dropped source files,
     # so the per-process slice stays quiet to avoid one warning per worker.
-    def process_coverage_result(report:)
+    #
+    # `inject_unloaded:` is likewise false when a merge step follows. Only the
+    # union of every process's loaded files says what was really never loaded,
+    # so injecting here means each worker simulates nearly the whole project
+    # and all but one of those passes is merged away. See #1250.
+    def process_coverage_result(report:, inject_unloaded: true)
       raw = SimpleCov::UselessResultsRemover.call(Coverage.result)
       adapted = SimpleCov::ResultAdapter.call(raw)
-      result, not_loaded_files = add_not_loaded_files(adapted)
-      @result = SimpleCov::Result.new(result, not_loaded_files: not_loaded_files, report: report)
+      # What this process was told to track and did not load. Subtracting what
+      # it loaded matters because `Result#to_hash` serializes coverage after
+      # filtering: a file this process loaded and then filtered out would
+      # otherwise be recorded as tracked while absent from the stored coverage,
+      # and the merge would simulate it back in as never-loaded. See #1250.
+      tracked = tracked_file_paths - adapted.keys
+      result, not_loaded = inject_unloaded ? inject_unloaded_files(adapted, tracked) : [adapted, Set.new]
+      @result = SimpleCov::Result.new(
+        result, not_loaded_files: not_loaded, tracked_files: tracked,
+                run_id: SimpleCov.run_id, worker_id: SimpleCov.worker_id, report: report
+      )
     end
   end
 end

data/lib/simplecov/run_identity.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module SimpleCov
+  # Identifies one test invocation and each top-level parallel worker within
+  # it. Forked subprocesses inherit both values from their parent worker.
+  module RunIdentity
+  module_function
+
+    # Returns the run id together with its provenance: `true` when the id
+    # alone proves same-run membership (explicitly configured, derived from
+    # parallel_tests' per-invocation pid file, or freshly random), `false`
+    # when it was inferred from the parent pid, which consecutive runs
+    # launched by the same long-lived parent process share.
+    def generate
+      explicit = ENV.fetch("SIMPLECOV_RUN_ID", nil)
+      return [explicit, true] if explicit && !explicit.empty?
+
+      pid_file = ENV.fetch("PARALLEL_PID_FILE", nil)
+      return ["parallel-tests:#{File.basename(pid_file)}", true] if pid_file && !pid_file.empty?
+
+      return ["parallel-parent:#{Process.ppid}", false] if SimpleCov::ParallelAdapters.current
+
+      [SecureRandom.uuid, true]
+    end
+
+    def worker_id
+      explicit = ENV.fetch("SIMPLECOV_WORKER_ID", nil)
+      return explicit if explicit && !explicit.empty?
+
+      number = ENV.fetch("TEST_ENV_NUMBER", nil)
+      return number.empty? ? "1" : number if number
+
+      Process.pid.to_s
+    end
+
+    # Whether the current run id alone proves same-run membership. Decided
+    # where the id is generated, never re-inferred from the id's shape, so
+    # an explicit SIMPLECOV_RUN_ID that happens to look like an inferred
+    # one is still trusted.
+    def authoritative?
+      materialize_current
+      @authoritative
+    end
+
+    def current
+      materialize_current
+      @current
+    end
+
+    def materialize_current
+      @current, @authoritative = generate unless defined?(@current)
+    end
+
+    def current_worker_id
+      @current_worker_id ||= worker_id
+    end
+
+    def prepare
+      SimpleCov::ParallelAdapters.current
+      SimpleCov.run_id
+      SimpleCov.worker_id
+    end
+
+    # Mixed into SimpleCov after ParallelAdapters has loaded.
+    module Accessors
+      def run_id
+        SimpleCov::RunIdentity.current
+      end
+
+      def worker_id
+        SimpleCov::RunIdentity.current_worker_id
+      end
+    end
+  end
+end

data/lib/simplecov/simulate_coverage.rb

@@ -33,25 +33,46 @@ module SimpleCov
     # can't be parsed, fall back to the old empty hashes — old behavior,
     # old tradeoff.
     #
+    # Pass `synthesize: false` to skip the static analysis and return the
+    # empty hashes directly. Callers use it when neither branch nor method
+    # coverage is enabled, since nothing will read the tuples and the Prism
+    # parse is about half the cost of simulating a file. See #1250.
+    #
+    # Pass `lines: false` to omit the `"lines"` key entirely, mirroring what
+    # `Coverage.result` reports for a file loaded under a branch-only or
+    # method-only run. Emitting zeroed lines there would make a simulated
+    # file indistinguishable from one a sibling process actually loaded once
+    # the two are merged.
+    #
     # @return [Hash]
     #
-    def call(absolute_path)
+    def call(absolute_path, synthesize: true, lines: true)
       source_lines = read_lines(absolute_path)
-      lines = coverage_stub(absolute_path, source_lines) ||
-              LinesClassifier.new.classify(source_lines)
+      simulated = synthesized_tuples(source_lines, synthesize)
+      return simulated unless lines
+
+      classified = coverage_stub(absolute_path, source_lines) ||
+                   LinesClassifier.new.classify(source_lines)
+      {"lines" => classified}.merge(simulated)
+    end
+
+    # The branch and method tuples for a file, or empty hashes when the static
+    # analysis is skipped (nothing enabled reads them) or unavailable (no Prism,
+    # or the file doesn't parse).
+    def synthesized_tuples(source_lines, synthesize)
       empty = {"branches" => {}, "methods" => {}} #: Hash[String, Hash[untyped, untyped]]
-      synthesized = StaticCoverageExtractor.call(source_lines.join) || empty
+      synthesized = (StaticCoverageExtractor.call(source_lines.join) if synthesize) || empty
 
-      {
-        "lines" => lines,
-        "branches" => synthesized["branches"],
-        "methods" => synthesized["methods"]
-      }
+      {"branches" => synthesized["branches"], "methods" => synthesized["methods"]}
     end
 
+    # SystemCallError, not just ENOENT: a `track_files` glob can sweep
+    # up an unreadable file or a directory named like a Ruby file
+    # (EACCES, EISDIR), and simulation must degrade to "empty file"
+    # rather than crash the merge or report step.
     def read_lines(path)
       File.readlines(path)
-    rescue Errno::ENOENT
+    rescue SystemCallError
       []
     end
 
@@ -68,7 +89,10 @@ module SimpleCov
       classifier_output = LinesClassifier.new.classify(source_lines)
       stub.each_index { |idx| stub[idx] = nil if classifier_output[idx].nil? }
       stub
-    rescue Errno::ENOENT, SyntaxError
+    rescue SystemCallError, SyntaxError
+      # SystemCallError for the same reason as read_lines above:
+      # line_stub reads the file itself, so EACCES/EISDIR surface here
+      # too.
       nil
     end
   end

data/lib/simplecov/source_file/method.rb

@@ -18,10 +18,16 @@ module SimpleCov
         !skipped? && coverage.positive?
       end
 
+      # Criterion-level skips (nocov chunks, `# simplecov:disable` /
+      # `# simplecov:disable method` regions) arrive via `skipped!` from
+      # MethodBuilder. Deliberately NOT derived from the lines' skip
+      # state: a line-only directive around a def must not remove the
+      # method from method totals. Without line info there is nothing to
+      # report against, so such a method stays skipped.
       def skipped?
         return @skipped if defined?(@skipped)
 
-        @skipped = lines.all?(&:skipped?)
+        @skipped = lines.empty?
       end
 
       # Flag the method as skipped directly, without going through its lines.

data/lib/simplecov/source_file/ruby_data_parser.rb

@@ -15,10 +15,28 @@ module SimpleCov
 
       # Tests use the real data structures (except for integration tests)
       # so no need to put them through here.
+      #
+      # String parses are memoized: `Combine::BranchesCombiner` and
+      # `Combine::MethodsCombiner` derive a merge identity from every key of
+      # both sides on every pairwise merge, so collating N resultsets parses
+      # each key string N-1 times — and Ripper dominates the wall time of a
+      # large collate.
+      # Key strings repeat across folds and within report building, while the
+      # set of unique keys is bounded by the project's branch and method
+      # count, so a permanent cache stays small. Cached arrays are frozen
+      # element-wise (String class names included, not just the tuple):
+      # every caller destructures without mutating, and sharing one array
+      # across callers must stay that way. The cache key needs no such
+      # care — `Hash#[]=` dups and freezes String keys on its own.
       def call(structure)
         return structure if structure.is_a?(Array)
 
-        parse_array_string(structure.to_s)
+        string = structure.to_s
+        parse_cache[string] ||= parse_array_string(string).each(&:freeze).freeze
+      end
+
+      def parse_cache
+        @parse_cache ||= {} #: Hash[String, untyped]
       end
 
       # Parse a string like '[:if, 0, 3, 4, 3, 21]' or
@@ -79,9 +97,13 @@ module SimpleCov
       # Method coverage keys can contain inspect-format class references
       # like `#<Class:Foo>` or `#<Class:0x...>`, which aren't valid Ruby
       # syntax. Wrap them in quotes so Ripper can parse the surrounding
-      # array literal; downstream we treat them as opaque strings.
+      # array literal; downstream we treat them as opaque strings. The
+      # pattern recurses because singleton methods on instances nest one
+      # inspect segment inside another (`#<Class:#<Object:0x...>>`), and
+      # stopping at the first `>` leaves a dangling `>` that fails both
+      # Ripper passes and crashes the merge.
       def quote_inspected_class_segments(str)
-        str.gsub(/#<[^>]*>/) { |segment| %("#{segment.gsub('"', '\\"')}") }
+        str.gsub(/#<(?:[^<>]|\g<0>)*>/) { |segment| %("#{segment.gsub('"', '\\"')}") }
       end
     end
   end

data/lib/simplecov/source_file/skip_chunks.rb

@@ -22,19 +22,16 @@ module SimpleCov
         @src = src
       end
 
-      # `:method` ignores nocov chunks (Ruby's Coverage doesn't tie
-      # method entries to line ranges); `:line` / `:branch` honor both
-      # the nocov chunks and the per-criterion directive ranges.
+      # Every criterion honors the deprecated all-criteria `# :nocov:`
+      # chunks plus its own per-criterion directive ranges. Methods
+      # included: they carry a source range, and nocov has always meant
+      # "exclude everything here".
       def for(criterion)
-        if criterion == :method
-          directive_chunks.fetch(:method)
-        else
-          nocov_chunks + directive_chunks.fetch(criterion)
-        end
+        nocov_chunks + directive_chunks.fetch(criterion)
       end
 
-      # no_cov_chunks is zero indexed to work directly with the array
-      # holding the lines.
+      # Ranges of 1-based line numbers (see `with_index(1)` below);
+      # consumers subtract 1 to index into the zero-based lines array.
       def nocov_chunks
         @nocov_chunks ||= build_nocov_chunks
       end