simplecov 0.22.0 → 1.1.1

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

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require "coverage"
+require_relative "static_coverage_extractor"
+
 module SimpleCov
   #
   # Responsible for producing file coverage metrics.
@@ -8,22 +11,90 @@ module SimpleCov
   module_function
 
     #
-    # Simulate normal file coverage report on
-    # ruby 2.5 and return similar hash with lines and branches keys
+    # Simulate a file coverage report for a file that was tracked but never
+    # required. Returns the same hash shape as `Coverage.result` (lines,
+    # branches, methods).
+    #
+    # The line classification comes from `Coverage.line_stub` — the same
+    # classification the runtime would have produced if the file had been
+    # required — overlaid with SimpleCov's `# :nocov:` toggles and
+    # `# simplecov:disable line` directive ranges, which `Coverage` doesn't
+    # know about. This keeps "relevant lines" identical whether a file was
+    # loaded or just tracked, fixing the multi-line statement discrepancy
+    # in https://github.com/simplecov-ruby/simplecov/issues/654.
+    #
+    # Branches and methods are enumerated by static analysis (via
+    # `StaticCoverageExtractor`, which uses Prism). Earlier behavior left
+    # both as empty hashes, which made unloaded files invisible to the
+    # branch/method denominators while their lines DID count — so a
+    # `track_files`/`cover` glob that picked up files without specs
+    # silently inflated branch% relative to line%. See
+    # https://github.com/simplecov-ruby/simplecov/issues/1059. When Prism
+    # isn't loadable (Ruby < 3.3 without the prism gem) or the file
+    # 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.
     #
-    # Happens when a file wasn't required but still tracked.
+    # 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)
-      lines = File.foreach(absolute_path)
-
-      {
-        "lines" => LinesClassifier.new.classify(lines),
-        # we don't want to parse branches ourselves...
-        # requiring files can have side effects and we don't want to trigger that
-        "branches" => {}
-      }
+    def call(absolute_path, synthesize: true, lines: true)
+      source_lines = read_lines(absolute_path)
+      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) if synthesize) || empty
+
+      {"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 SystemCallError
+      []
+    end
+
+    # Combine `Coverage.line_stub` (which gets multi-line statements right)
+    # with `LinesClassifier` (which knows about `# :nocov:` toggles and
+    # `# simplecov:disable line` ranges). Returns nil — and the caller
+    # falls back to `LinesClassifier` alone — when `Coverage` can't read
+    # or parse the file, or when the runtime doesn't expose `line_stub`
+    # (JRuby and TruffleRuby).
+    def coverage_stub(path, source_lines)
+      return nil unless Coverage.respond_to?(:line_stub)
+
+      stub = Coverage.line_stub(path)
+      classifier_output = LinesClassifier.new.classify(source_lines)
+      stub.each_index { |idx| stub[idx] = nil if classifier_output[idx].nil? }
+      stub
+    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
 end

data/lib/simplecov/source_file/branch.rb

@@ -8,7 +8,6 @@ module SimpleCov
     class Branch
       attr_reader :start_line, :end_line, :coverage, :type
 
-      # rubocop:disable Metrics/ParameterLists
       def initialize(start_line:, end_line:, coverage:, inline:, type:)
         @start_line = start_line
         @end_line   = end_line
@@ -17,7 +16,6 @@ module SimpleCov
         @type       = type
         @skipped    = false
       end
-      # rubocop:enable Metrics/ParameterLists
 
       def inline?
         @inline
@@ -33,7 +31,7 @@ module SimpleCov
       end
 
       #
-      # Check if branche missed or not
+      # Check if branch missed or not
       #
       # @return [Boolean]
       #

data/lib/simplecov/source_file/branch_builder.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  class SourceFile
+    # Builds the `SourceFile::Branch` objects for a source file from
+    # the raw branch data Ruby's Coverage library reports. Applies the
+    # `ignore_branches :eval_generated` / `:implicit_else` filters and
+    # marks branches inside `# simplecov:disable` / `# :nocov:` chunks
+    # as skipped.
+    class BranchBuilder
+      def initialize(source_file)
+        @source_file = source_file
+      end
+
+      def call
+        coverage_branch_data = @source_file.coverage_data["branches"] || {}
+        branches = coverage_branch_data.flat_map do |condition, coverage_branches|
+          next [] if eval_generated_condition_to_ignore?(condition)
+
+          build_branches_from(condition, coverage_branches)
+        end
+
+        process_skipped(branches)
+      end
+
+    private
+
+      # Detect a Coverage-reported branch condition that originates from
+      # `eval`/`module_eval`/`class_eval`/`instance_eval` rather than from
+      # the file's literal source. Coverage attributes such branches to the
+      # caller's `__FILE__`/`__LINE__`, so a Rails `delegate :foo, to: :bar`
+      # call surfaces inside the source file as if there were branches at
+      # the `delegate` line. Prism never sees those branches in the static
+      # source, so a condition whose start_line isn't in the real-source
+      # branch set must be eval-generated. Only consulted when the user has
+      # opted in via `SimpleCov.ignore_branches :eval_generated`. See #1046.
+      def eval_generated_condition_to_ignore?(condition)
+        return false unless SimpleCov.ignored_branch?(:eval_generated)
+
+        positions = @source_file.real_source_positions
+        # simplecov:disable branch — nil branch fires only when Prism is unavailable
+        return false unless positions
+
+        # simplecov:enable branch
+
+        _type, _id, start_line, * = RubyDataParser.call(condition)
+        !positions[:branches].include?(start_line)
+      end
+
+      def build_branches_from(condition, branches)
+        # the format handed in from the coverage data is like this:
+        #
+        #     [:then, 4, 6, 6, 6, 10]
+        #
+        # which is [type, id, start_line, start_col, end_line, end_col]
+        _condition_type, _condition_id, *condition_range = RubyDataParser.call(condition)
+
+        branches.filter_map do |branch_data, hit_count|
+          build_branch(RubyDataParser.call(branch_data), hit_count, condition_range)
+        end
+      end
+
+      def build_branch(branch_data, hit_count, condition_range)
+        type, _id, start_line, start_col, end_line, end_col = branch_data
+        return nil if implicit_else_to_ignore?(type, [start_line, start_col, end_line, end_col], condition_range)
+
+        SourceFile::Branch.new(
+          start_line: start_line,
+          end_line: end_line,
+          coverage: hit_count,
+          inline: start_line == condition_range.first,
+          type: type
+        )
+      end
+
+      # Detect synthetic `:else` branches that Ruby's Coverage library reports
+      # for constructs with no literal `else` keyword in source (`case/in` /
+      # `case/when` without else, `||=`, `&&=`, `if`/`unless` without else,
+      # and the postfix `return if cond` shape). The signal is structural:
+      # a synthetic else reuses its parent condition's *full source range*
+      # (start_line, start_col, end_line, end_col all identical), while an
+      # explicit `else` arm carries a narrower range — its own keyword/body
+      # position rather than the whole conditional. Comparing the full range
+      # (not just `start_line`) is what distinguishes a ternary's explicit
+      # else on the same line as the condition — `arg == 42 ? :yes : :no`,
+      # where the else's columns differ from the parent's — from a postfix
+      # `return if cond` where the synthetic else inherits the full range.
+      # Only consulted when the user has opted in via
+      # `SimpleCov.ignore_branches :implicit_else`. See #1033.
+      def implicit_else_to_ignore?(type, branch_range, condition_range)
+        return false unless type == :else
+        return false unless SimpleCov.ignored_branch?(:implicit_else)
+
+        branch_range == condition_range
+      end
+
+      def process_skipped(branches)
+        chunks = @source_file.skip_chunks_for(:branch)
+        return branches if chunks.empty?
+
+        # A non-inline branch's source range starts on its arm body (e.g. the
+        # `:yes` line of `if cond / :yes / else / :no / end`), but `report_line`
+        # is the condition line above it — that's where the user sees the
+        # branch in the report and where they would naturally place an inline
+        # `# simplecov:disable branch` directive. Honour both.
+        branches.each do |branch|
+          branch.skipped! if chunks.any? { |chunk| branch.overlaps_with?(chunk) || chunk.include?(branch.report_line) }
+        end
+
+        branches
+      end
+    end
+  end
+end

data/lib/simplecov/source_file/builder_context.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  class SourceFile
+    # Helpers shared by the per-criterion builders (LineBuilder /
+    # BranchBuilder / MethodBuilder). Mixed into SourceFile so each
+    # builder can ask the file for its skip-chunk ranges and Prism-derived
+    # real source positions without duplicating the memoization.
+    module BuilderContext
+      # Skip-chunk lookup for the named criterion (`:line`, `:branch`,
+      # `:method`).
+      def skip_chunks_for(criterion)
+        (@skip_chunks ||= SkipChunks.new(filename, src)).for(criterion)
+      end
+
+      # Memoized set of real source positions (branch start lines, method
+      # name+line pairs) extracted via Prism. Returns nil when Prism is
+      # unavailable or parsing fails, signaling callers to keep every
+      # Coverage entry (no false drops). The `defined?` guard preserves a
+      # nil memoization across calls.
+      def real_source_positions
+        return @real_source_positions if defined?(@real_source_positions)
+
+        @real_source_positions = StaticCoverageExtractor.real_source_positions(src.join)
+      end
+    end
+  end
+end

data/lib/simplecov/source_file/line.rb

@@ -25,7 +25,9 @@ module SimpleCov
       def initialize(src, line_number, coverage)
         raise ArgumentError, "Only String accepted for source" unless src.is_a?(String)
         raise ArgumentError, "Only Integer accepted for line_number" unless line_number.is_a?(Integer)
-        raise ArgumentError, "Only Integer and nil accepted for coverage" unless coverage.is_a?(Integer) || coverage.nil?
+        unless coverage.is_a?(Integer) || coverage.nil?
+          raise ArgumentError, "Only Integer and nil accepted for coverage"
+        end
 
         @src         = src
         @line_number = line_number
@@ -35,12 +37,12 @@ module SimpleCov
 
       # Returns true if this is a line that should have been covered, but was not
       def missed?
-        !never? && !skipped? && coverage.zero?
+        !never? && !skipped? && coverage.to_i.zero?
       end
 
       # Returns true if this is a line that has been covered
       def covered?
-        !never? && !skipped? && coverage.positive?
+        !never? && !skipped? && coverage.to_i.positive?
       end
 
       # Returns true if this line is not relevant for coverage
@@ -65,7 +67,10 @@ module SimpleCov
         return "skipped" if skipped?
         return "never" if never?
         return "missed" if missed?
-        return "covered" if covered?
+
+        # simplecov:disable — defensive: covered? is the only state left after the three above
+        "covered" if covered?
+        # simplecov:enable
       end
     end
   end

data/lib/simplecov/source_file/line_builder.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  class SourceFile
+    # Builds the `SourceFile::Line` objects for a source file from the
+    # raw line-coverage array. Each line carries its source text, its
+    # 1-based line number, and the Coverage hit count (or nil for
+    # never-counted lines). Applies `# simplecov:disable` /
+    # `# :nocov:` block ranges via `skipped!`.
+    class LineBuilder
+      def initialize(source_file)
+        @source_file = source_file
+      end
+
+      def call
+        lines = build_lines
+        mark_skipped(lines, @source_file.skip_chunks_for(:line))
+        lines
+      end
+
+    private
+
+      # When `:line` coverage is disabled, the Ruby Coverage module
+      # doesn't emit "lines" data, so look up `nil` (never-counted) for
+      # every position. The source rows are still useful — e.g. for the
+      # HTML report's source view — even without per-line hits.
+      def build_lines
+        line_coverage = @source_file.coverage_data["lines"] || []
+        @source_file.src.map.with_index(1) do |src, i|
+          SourceFile::Line.new(src, i, line_coverage[i - 1])
+        end
+      end
+
+      # The array the lines are kept in is 0-based whereas the line
+      # numbers in the chunks are 1-based (more understandable elsewhere),
+      # so each range needs to be shifted down by one to slice into the
+      # `lines` array.
+      def mark_skipped(lines, chunks)
+        chunks.each { |chunk| lines[(chunk.begin - 1)..(chunk.end - 1)].each(&:skipped!) }
+      end
+    end
+  end
+end

data/lib/simplecov/source_file/method.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  class SourceFile
+    # Represents a single method detected in coverage data.
+    # Provides helpers similar to Branch for coverage status.
+    class Method
+      attr_reader :source_file, :coverage, :class_name, :method_name,
+                  :start_line, :start_col, :end_line, :end_col
+
+      def initialize(source_file, info, coverage)
+        @source_file = source_file
+        @class_name, @method_name, @start_line, @start_col, @end_line, @end_col = info
+        @coverage = coverage
+      end
+
+      def covered?
+        !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.empty?
+      end
+
+      # Flag the method as skipped directly, without going through its lines.
+      def skipped!
+        @skipped = true
+      end
+
+      def missed?
+        !skipped? && coverage.zero?
+      end
+
+      def lines
+        @lines ||= start_line && end_line ? source_file.lines[(start_line - 1)..(end_line - 1)] || [] : []
+      end
+
+      # Whether this method's source range intersects the given inclusive line range.
+      def overlaps_with?(line_range)
+        return false unless start_line && end_line
+
+        start_line <= line_range.end && end_line >= line_range.begin
+      end
+
+      def to_s
+        "#{class_name}##{method_name}"
+      end
+    end
+  end
+end

data/lib/simplecov/source_file/method_builder.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  class SourceFile
+    # Builds the `SourceFile::Method` objects for a source file from
+    # the raw method-coverage data. Applies the
+    # `ignore_methods :eval_generated` filter and marks methods inside
+    # `# simplecov:disable` / `# :nocov:` chunks as skipped.
+    class MethodBuilder
+      def initialize(source_file)
+        @source_file = source_file
+      end
+
+      def call
+        none = {} #: Hash[untyped, Integer]
+        raw_methods = @source_file.coverage_data.fetch("methods", none)
+        methods = raw_methods.filter_map do |info, hit_count|
+          info = RubyDataParser.call(info)
+          next if eval_generated_to_ignore?(info)
+
+          SourceFile::Method.new(@source_file, info, hit_count)
+        end
+
+        process_skipped(methods)
+      end
+
+    private
+
+      # See `BranchBuilder#eval_generated_condition_to_ignore?` for the
+      # rationale. Coverage reports an eval'd `def` at the eval caller's
+      # line and name, so a method whose `(name, start_line)` is absent
+      # from the real-source `def` set is eval-generated. Only consulted
+      # when the user has opted in via
+      # `SimpleCov.ignore_methods :eval_generated`. See #1046.
+      def eval_generated_to_ignore?(info)
+        return false unless SimpleCov.ignored_method?(:eval_generated)
+
+        positions = @source_file.real_source_positions
+        # simplecov:disable branch — nil branch fires only when Prism is unavailable
+        return false unless positions
+
+        # simplecov:enable branch
+
+        _class_name, name, start_line, * = info
+        !positions[:methods].include?([name, start_line])
+      end
+
+      def process_skipped(methods)
+        chunks = @source_file.skip_chunks_for(:method)
+        return methods if chunks.empty?
+
+        methods.each do |method|
+          method.skipped! if chunks.any? { |chunk| method.overlaps_with?(chunk) }
+        end
+
+        methods
+      end
+    end
+  end
+end

data/lib/simplecov/source_file/ruby_data_parser.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "ripper"
+
+module SimpleCov
+  class SourceFile
+    # `Coverage.result` reports condition and method keys as Ruby
+    # arrays. When the resultset is round-tripped through JSON those
+    # array keys become their stringified inspect form, so this parser
+    # walks the literal back into a real Array without using `eval` (see
+    # #801). The grammar covers symbols, strings, integers, unary minus,
+    # and constant paths — every shape Coverage ever emits.
+    module RubyDataParser
+    module_function
+
+      # 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)
+
+        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
+      # '["ClassName", :method1, 2, 2, 5, 5]' back into a Ruby array.
+      def parse_array_string(str)
+        # Try plain Ripper first; only pre-quote `#<...>` inspect segments
+        # if the input isn't already valid Ruby (otherwise we corrupt
+        # `"#<Class:Foo>"` strings that *are* valid Ruby literals — exactly
+        # the shape simplecov-on-simplecov method-coverage keys take).
+        sexp = Ripper.sexp(str) || Ripper.sexp(quote_inspected_class_segments(str))
+        # simplecov:disable — defensive: Ripper.sexp returning nil from both passes requires malformed input
+        array_node = sexp&.dig(1, 0)
+        # simplecov:enable
+        raise ArgumentError, "expected array literal: #{str.inspect}" unless array_node && array_node[0] == :array
+
+        Array(array_node[1]).map { |element| parse_element(element) }
+      end
+
+      def parse_element(node)
+        case node[0]
+        when :@int, :unary                 then parse_integer_node(node)
+        when :symbol_literal, :dyna_symbol then parse_symbol_node(node)
+        when :string_literal               then unescape_ruby(string_literal_text(node[1]))
+        when :var_ref                      then node.dig(1, 1) # `Foo`
+        when :const_path_ref               then "#{parse_element(node[1])}::#{node[2][1]}" # `Foo::Bar`
+        else
+          # simplecov:disable — defensive fallback for unexpected Ripper node shapes
+          raise ArgumentError, "unexpected element: #{node.inspect}"
+          # simplecov:enable
+        end
+      end
+
+      def parse_integer_node(node)
+        node[0] == :@int ? node[1].to_i : -node[2][1].to_i
+      end
+
+      def parse_symbol_node(node)
+        if node[0] == :symbol_literal
+          node.dig(1, 1, 1).to_sym
+        else
+          unescape_ruby(string_literal_text(node[1])).to_sym
+        end
+      end
+
+      # Concatenate the text fragments of a `:string_content` node. Ripper
+      # may emit zero, one, or many `:@tstring_content` children depending
+      # on the literal.
+      def string_literal_text(string_content)
+        Array(string_content[1..]).map { |child| child[1] }.join
+      end
+
+      # Undo the same backslash-prefix escapes the previous hand-rolled
+      # parser undid: `\X` → `X` for any X.
+      def unescape_ruby(raw)
+        raw.gsub(/\\(.)/) { ::Regexp.last_match(1) }
+      end
+
+      # 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. 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(/#<(?:[^<>]|\g<0>)*>/) { |segment| %("#{segment.gsub('"', '\\"')}") }
+      end
+    end
+  end
+end