simplecov 1.0.0 → 1.1.1

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

data/lib/simplecov/source_file/source_loader.rb

@@ -14,20 +14,30 @@ module SimpleCov
     module_function
 
       def call(filename)
-        lines = []
+        lines = [] #: Array[String]
         # The default encoding is UTF-8
         File.open(filename, "rb:UTF-8") do |file|
-          current_line = file.gets
+          current_line = scrub_invalid(file.gets)
 
-          if shebang?(current_line)
+          if current_line && shebang?(current_line)
             lines << current_line
-            current_line = file.gets
+            current_line = scrub_invalid(file.gets)
           end
 
           read_lines(file, lines, current_line)
         end
       end
 
+      # A line read as UTF-8 can still carry invalid bytes (a Latin-1
+      # source file without a magic comment, say). Replace them before
+      # any regex sees the line: the shebang and magic-comment checks
+      # would otherwise raise ArgumentError and take the report down.
+      def scrub_invalid(line)
+        return line if line.nil? || line.valid_encoding?
+
+        line.scrub
+      end
+
       def shebang?(line)
         SHEBANG_REGEX.match?(line)
       end
@@ -47,14 +57,20 @@ module SimpleCov
         end
       end
 
-      # invalid/undef replace are technically not really necessary but
-      # nice to have and work around a JRuby incompatibility. Setting
-      # these options on `file.set_encoding` doesn't seem to work
-      # properly, so it has to be done here.
+      # Guarantee every line leaves the loader as valid UTF-8, replacing
+      # what can't be represented: transcode non-UTF-8 lines (setting
+      # invalid/undef options on `file.set_encoding` doesn't work
+      # properly, and this also works around a JRuby incompatibility)
+      # and scrub UTF-8-tagged lines that carry invalid bytes, which
+      # would otherwise raise from every regex the classifier runs.
       def ensure_remove_undefs(file_lines)
         file_lines.each do |line|
           # simplecov:disable — defensive: only fires for non-UTF-8 source files
-          line.encode!("UTF-8", invalid: :replace, undef: :replace) unless line.encoding == Encoding::UTF_8
+          if line.encoding == Encoding::UTF_8
+            line.scrub! unless line.valid_encoding?
+          else
+            line.encode!("UTF-8", invalid: :replace, undef: :replace)
+          end
           # simplecov:enable
         end
       end

data/lib/simplecov/source_file/statistics.rb

@@ -22,35 +22,43 @@ module SimpleCov
     private
 
       def line_statistics
-        sf = @source_file
         {
-          line: CoverageStatistics.new(
-            total_strength: sf.lines.sum { |line| line.coverage.to_i },
-            covered: sf.covered_lines.size,
-            missed: sf.missed_lines.size,
-            omitted: sf.never_lines.size
+          line: coverage_statistics(
+            @source_file.covered_lines,
+            @source_file.missed_lines,
+            omitted: @source_file.never_lines.size
           )
         }
       end
 
+      # Files added via track_files but never loaded have no branch/method
+      # data. Report 0% instead of the empty-set default of 100% (see #902).
       def branch_statistics
         sf = @source_file
-        # Files added via track_files but never loaded/required have no
-        # branch data. Report 0% instead of misleading 100% (see #902).
-        if sf.not_loaded? && sf.covered_branches.empty? && sf.missed_branches.empty?
-          return {branch: CoverageStatistics.new(covered: 0, missed: 0, percent: 0.0)}
-        end
+        covered = sf.covered_branches
+        missed = sf.missed_branches
+        percent = 0.0 if sf.not_loaded? && covered.empty? && missed.empty?
 
-        {branch: CoverageStatistics.new(covered: sf.covered_branches.size, missed: sf.missed_branches.size)}
+        {branch: coverage_statistics(covered, missed, percent: percent)}
       end
 
       def method_statistics
         sf = @source_file
-        if sf.not_loaded? && sf.covered_methods.empty? && sf.missed_methods.empty?
-          return {method: CoverageStatistics.new(covered: 0, missed: 0, percent: 0.0)}
-        end
+        covered = sf.covered_methods
+        missed = sf.missed_methods
+        percent = 0.0 if sf.not_loaded? && covered.empty? && missed.empty?
+
+        {method: coverage_statistics(covered, missed, percent: percent)}
+      end
 
-        {method: CoverageStatistics.new(covered: sf.covered_methods.size, missed: sf.missed_methods.size)}
+      def coverage_statistics(covered, missed, omitted: 0, percent: nil)
+        CoverageStatistics.new(
+          total_strength: covered.sum { |item| item.coverage.to_i },
+          covered: covered.size,
+          missed: missed.size,
+          omitted: omitted,
+          percent: percent
+        )
       end
     end
   end

data/lib/simplecov/source_file.rb

@@ -51,8 +51,8 @@ module SimpleCov
     # returns the `{line:, branch:, method:}` Hash; pass a criterion symbol
     # (`:line` / `:branch` / `:method`) to get that one CoverageStatistics.
     def coverage_statistics(criterion = nil)
-      @coverage_statistics ||= Statistics.new(self).call
-      criterion ? @coverage_statistics[criterion] : @coverage_statistics
+      stats = (@coverage_statistics ||= Statistics.new(self).call)
+      criterion ? stats[criterion] : stats
     end
 
     # Returns all source lines for this file as instances of SimpleCov::SourceFile::Line,

data/lib/simplecov/static_coverage_extractor/condition_folding.rb

@@ -0,0 +1,239 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  module StaticCoverageExtractor
+    # Detects the `if` / `unless` / ternary conditions CRuby folds away.
+    # When a condition is a statically-known-truthy/falsy literal the
+    # compiler eliminates the dead arm and Coverage emits NO branch, so the
+    # extractor must not synthesize one either — otherwise the arm is a
+    # phantom that no loaded run can ever hit, the same unmergeable-tuple
+    # failure mode as #1226 / #1233.
+    module ConditionFolding
+      # CRuby 3.4 rebuilt the fold on the Prism compiler, and the
+      # parse.y-based fold it replaced differed in three observable ways,
+      # each pinned by the runtime tuple equivalence battery on CI:
+      # `__FILE__` folded on 3.2/3.3 but no longer does; parentheses were
+      # transparent for every literal on 3.2 (opacity starts at 3.3); and
+      # on 3.2 the dead arm's branch table entries survive the fold —
+      # parse.y instrumented branches before eliminating dead code — while
+      # its `def`s still never register.
+      FOLDS_SOURCE_FILE = Gem::Version.new(RUBY_VERSION) < Gem::Version.new("3.4")
+      PARENS_ALWAYS_TRANSPARENT = Gem::Version.new(RUBY_VERSION) < Gem::Version.new("3.3")
+      DEAD_ARM_BRANCHES_SURVIVE = PARENS_ALWAYS_TRANSPARENT
+      # Container literals in discarded position are eliminated from 3.3
+      # on, but the contents rule differs: 3.3's compile.c elides a
+      # container whose contents are merely effect-free (`[x]`, `[self]`),
+      # while the Prism compiler (3.4+) demands fully static literals
+      # (`[1]` goes, `[x]` stays). See `static_container_literal?`.
+      CONTAINER_CONTENTS_NEED_STATIC_LITERALS = !FOLDS_SOURCE_FILE
+
+      # Prism node types for the literals that fold. `while` / `until` do
+      # NOT fold (`while true` is a real branch), so only the if-like
+      # visitors consult this. Regexp and Range literals are excluded on
+      # purpose: as conditions they mean `=~ $_` / flip-flop, which
+      # Coverage does branch on. `[]`, `{}`, and interpolated strings do
+      # not fold either, and `->` folds while a `lambda` call does not —
+      # the compiler only folds what it can prove at compile time, and a
+      # method named `lambda` proves nothing.
+      # simplecov:disable branch — which arm runs is fixed by the running Ruby's version
+      STATIC_CONDITION_TYPES = [
+        ::Prism::IntegerNode, ::Prism::FloatNode, ::Prism::RationalNode,
+        ::Prism::ImaginaryNode, ::Prism::SymbolNode, ::Prism::StringNode,
+        ::Prism::TrueNode, ::Prism::FalseNode, ::Prism::NilNode,
+        ::Prism::SourceLineNode, ::Prism::SourceEncodingNode, ::Prism::LambdaNode,
+        *(::Prism::SourceFileNode if FOLDS_SOURCE_FILE)
+      ].freeze
+      # simplecov:enable branch
+
+      # The literals whose fold eliminates the *then* side: `if false` /
+      # `if nil` keep only the else arm. Every other folded literal is
+      # truthy and keeps only the then arm.
+      FALSY_CONDITION_TYPES = [::Prism::FalseNode, ::Prism::NilNode].freeze
+
+      # The literals whose fold does NOT see through parentheses: CRuby
+      # folds `if nil`, `if "x"`, and `if -> {}` but keeps a real branch
+      # for `if (nil)`, `if ("x")`, and `if (-> {})` — verified against
+      # Coverage, and pinned by the runtime tuple equivalence battery —
+      # while every other literal folds parenthesized or not. `__FILE__`
+      # is opaque like other strings on the Rubies that fold it at all.
+      # Consulted only when PARENS_ALWAYS_TRANSPARENT is false.
+      PAREN_OPAQUE_TYPES = [
+        ::Prism::NilNode, ::Prism::StringNode, ::Prism::LambdaNode, ::Prism::SourceFileNode
+      ].freeze
+
+      # The scalar literals the compiler treats as fully static: a
+      # multi-statement paren condition (`if (1; 2)`) folds by its last
+      # expression only when every leading statement is eliminated when
+      # discarded, and these — bare or composing an Array/Hash/Range —
+      # always are. Pinned against real Coverage on 3.2 through 4.0.
+      STATIC_LITERAL_LEAF_TYPES = [
+        ::Prism::IntegerNode, ::Prism::FloatNode, ::Prism::RationalNode,
+        ::Prism::ImaginaryNode, ::Prism::StringNode, ::Prism::SymbolNode,
+        ::Prism::TrueNode, ::Prism::FalseNode, ::Prism::NilNode,
+        ::Prism::SourceLineNode, ::Prism::SourceFileNode, ::Prism::SourceEncodingNode, ::Prism::RegularExpressionNode
+      ].freeze
+
+      # Non-literal reads that are also eliminated when discarded.
+      # `self` is eliminated by every supported compiler; local/ivar/
+      # defined? elimination arrived with the Prism-era compilers.
+      # Anything that can raise or run hooks (constants, globals, calls,
+      # writes) is never eliminated and keeps the branch real.
+      PRISM_ERA_ELIMINABLE_READS = [
+        ::Prism::LocalVariableReadNode, ::Prism::InstanceVariableReadNode, ::Prism::DefinedNode
+      ].freeze
+
+      # simplecov:disable branch — which arm runs is fixed by the running Ruby's version
+      ELIMINABLE_READ_TYPES = [
+        ::Prism::SelfNode,
+        *(PRISM_ERA_ELIMINABLE_READS unless PARENS_ALWAYS_TRANSPARENT)
+      ].freeze
+      # simplecov:enable branch
+
+    private
+
+      # A truthy verdict keeps the first arm live, a falsy one the
+      # second. `visit` is nil-safe, so a missing arm just visits
+      # nothing. On 3.2 the dead arm's branch table entries survive the
+      # fold (parse.y instrumented branches before eliminating dead
+      # code, even inside dead `def` bodies and lambdas) while its
+      # methods never register, so the dead arm is visited with method
+      # collection suppressed.
+      def visit_folded_arms(verdict, truthy_arm, falsy_arm)
+        live, dead = verdict == :truthy ? [truthy_arm, falsy_arm] : [falsy_arm, truthy_arm]
+        visit(live)
+        # simplecov:disable branch — the taken arm is fixed by the running Ruby's version
+        visit_dead_arm(dead) if DEAD_ARM_BRANCHES_SURVIVE
+        # simplecov:enable branch
+      end
+
+      # simplecov:disable — 3.2-only; unreachable on the modern dogfood Ruby
+      def visit_dead_arm(arm)
+        # Save/restore rather than set/clear: a fold nested inside this
+        # dead arm re-enters here (possibly with a nil arm) and must not
+        # clear suppression for the rest of the outer dead arm.
+        previous = @suppress_methods
+        begin
+          @suppress_methods = true
+          visit(arm)
+        ensure
+          @suppress_methods = previous
+        end
+      end
+      # simplecov:enable
+
+      # The compiler's verdict on a condition: `:truthy` or `:falsy` when
+      # it folds, nil when it doesn't. The verdict decides which arm
+      # survives — the compiler eliminates the other arm's entire subtree,
+      # so everything inside it (nested branches, methods) must go
+      # unvisited too, not just the folded condition's own tuple.
+      #
+      # Parentheses are transparent to the fold for most literals
+      # (`if (1)` folds like `if 1`) but not all — see
+      # PAREN_OPAQUE_TYPES. Compound forms (`!true`, `true || x`) are
+      # deliberately not folded: `!` never folds, and `||` / `&&`
+      # constant-propagation diverges across Ruby versions, so matching
+      # it would trade a rare, version-specific gain for real risk.
+      def folded_condition(node)
+        unwrapped = unwrap_parentheses(node)
+        return nil unless foldable?(node, unwrapped)
+
+        FALSY_CONDITION_TYPES.any? { |type| unwrapped.is_a?(type) } ? :falsy : :truthy
+      end
+
+      # A folding literal, minus the ones parentheses shield from the
+      # fold (`unwrapped` differing from `node` is what says parentheses
+      # were seen through).
+      def foldable?(node, unwrapped)
+        return false unless STATIC_CONDITION_TYPES.any? { |type| unwrapped.is_a?(type) }
+
+        # simplecov:disable — which of these lines runs is fixed by the
+        # running Ruby's version: on 3.2 the early return always fires and
+        # the opacity check below it is dead code, so it must be excluded
+        # from line coverage too, not only branch coverage.
+        return true if PARENS_ALWAYS_TRANSPARENT
+
+        unwrapped.equal?(node) || PAREN_OPAQUE_TYPES.none? { |type| unwrapped.is_a?(type) }
+        # simplecov:enable
+      end
+
+      # Parentheses are transparent to the fold, and a multi-statement
+      # body (`if (1; 2)`) folds by its LAST expression — but only when
+      # the compiler eliminates every leading statement. Stopping at
+      # multi-statement bodies synthesized a phantom then/else pair no
+      # real run can ever hit.
+      def unwrap_parentheses(node)
+        # @type var current: untyped
+        current = node
+        while current.is_a?(::Prism::ParenthesesNode)
+          body = current.body
+          break unless body.is_a?(::Prism::StatementsNode) && !body.body.empty?
+
+          statements = body.body
+          break unless statements.take(statements.size - 1).all? { |leading| eliminable_when_discarded?(leading) }
+
+          current = statements.last
+        end
+        current
+      end
+
+      # Whether the compiler compiles `node` to nothing when its value is
+      # discarded.
+      def eliminable_when_discarded?(node)
+        return true if static_container_literal?(node)
+        return true if ELIMINABLE_READ_TYPES.any? { |type| node.is_a?(type) }
+
+        node.is_a?(::Prism::ParenthesesNode) &&
+          node.body.is_a?(::Prism::StatementsNode) &&
+          node.body.body.all? { |statement| eliminable_when_discarded?(statement) }
+      end
+
+      # A scalar literal leaf, or an Array/Hash/Range whose contents pass
+      # the running compiler's contents rule (see
+      # CONTAINER_CONTENTS_NEED_STATIC_LITERALS). Container elimination
+      # only exists from 3.3 on.
+      def static_container_literal?(node)
+        return true if STATIC_LITERAL_LEAF_TYPES.any? { |type| node.is_a?(type) }
+        # simplecov:disable — which of these lines runs is fixed by the
+        # running Ruby's version: parse.y (3.2) never eliminates
+        # container literals, so there the early return always fires and
+        # the dispatch below is dead code.
+        return false if PARENS_ALWAYS_TRANSPARENT
+
+        static_container?(node)
+        # simplecov:enable
+      end
+
+      # The container dispatch, version-free: the predicate specs
+      # exercise it directly on every supported Ruby, 3.2 included.
+      def static_container?(node)
+        case node
+        when ::Prism::ArrayNode then static_array_literal?(node)
+        when ::Prism::HashNode  then static_hash_literal?(node)
+        when ::Prism::RangeNode then static_range_literal?(node)
+        else false
+        end
+      end
+
+      def static_array_literal?(node)
+        node.elements.all? { |element| container_contents_eliminable?(element) }
+      end
+
+      def static_hash_literal?(node)
+        node.elements.all? do |element|
+          element.is_a?(::Prism::AssocNode) &&
+            container_contents_eliminable?(element.key) && container_contents_eliminable?(element.value)
+        end
+      end
+
+      def static_range_literal?(node)
+        [node.left, node.right].all? { |bound| bound.nil? || container_contents_eliminable?(bound) }
+      end
+
+      def container_contents_eliminable?(node)
+        # simplecov:disable branch — which arm runs is fixed by the running Ruby's version
+        CONTAINER_CONTENTS_NEED_STATIC_LITERALS ? static_container_literal?(node) : eliminable_when_discarded?(node)
+        # simplecov:enable branch
+      end
+    end
+  end
+end

data/lib/simplecov/static_coverage_extractor/location_conventions.rb

@@ -0,0 +1,236 @@
+# frozen_string_literal: true
+
+require_relative "prism_compat"
+
+module SimpleCov
+  module StaticCoverageExtractor
+    # The source ranges Ruby's Coverage assigns to branch conditions and
+    # arms, resolved from Prism nodes. Simulated entries only ever merge
+    # with real entries produced by the running Ruby, and CRuby 3.4
+    # changed several of these conventions, so every resolver here emits
+    # whichever shape this Ruby's Coverage uses. See issues #1226 / #1233.
+    #
+    # rubocop:disable Metrics/ModuleLength -- one cohesive home for the
+    # per-construct, per-Ruby-version Coverage location conventions;
+    # splitting it would scatter closely-related resolvers.
+    module LocationConventions
+      LEGACY_COVERAGE_LOCATIONS = Gem::Version.new(RUBY_VERSION) < Gem::Version.new("3.4")
+
+      # A zero-width stand-in for Prism locations, for the arms Coverage
+      # anchors to a point rather than a range.
+      PointLocation = Data.define(:start_line, :start_column, :end_line, :end_column)
+
+    private
+
+      # simplecov:disable
+      # Which arm of each conditional below runs is fixed by the running
+      # Ruby's version, so no single process can cover both sides, and
+      # the legacy-only helpers are unreachable on modern Rubies (and
+      # vice versa). The "runtime tuple equivalence" spec exercises this
+      # module against real Coverage output on every CI Ruby.
+
+      # The range Coverage assigns to an if-like node itself. Modern
+      # CRuby uses the node's full source range for every form; 3.2/3.3
+      # end an `elsif` clause's range at its last content instead of the
+      # shared `end` keyword the clause doesn't own.
+      def if_like_location(node, type)
+        return node.location unless LEGACY_COVERAGE_LOCATIONS && type == :if && elsif_node?(node)
+
+        span(node.location, legacy_content_end(node))
+      end
+
+      def elsif_node?(node)
+        keyword = node.if_keyword_loc
+        !keyword.nil? && keyword.slice == "elsif"
+      end
+
+      # Where an if/elsif chain's content ends, for the legacy range
+      # convention: the deepest trailing clause's statements, or that
+      # clause's predicate / `else` keyword when its body is empty.
+      def legacy_content_end(node)
+        tail = node
+        while tail.is_a?(::Prism::IfNode)
+          sub = PrismCompat.subsequent(tail)
+          break unless sub
+
+          tail = sub
+        end
+        return (tail.statements || tail.predicate).location if tail.is_a?(::Prism::IfNode)
+
+        tail.statements ? tail.statements.location : tail.else_keyword_loc
+      end
+
+      # Location of the then arm. Coverage uses the body statements'
+      # range; with an empty then body the arm collapses to a zero-width
+      # point at the predicate's end — always on a modern `if`, and on
+      # legacy Rubies only when the construct is in void position (a
+      # trailing statement discards its value). In value (tail) position,
+      # legacy Rubies and `unless` fall back to the node's range.
+      def if_like_then_location(node, type)
+        return node.statements.location if node.statements
+        return point_at_end(node.predicate.location) if empty_arm_collapses?(node, type)
+
+        if_like_location(node, type)
+      end
+
+      # Resolve the source range Coverage attributes to a real-or-synthetic
+      # `:else` arm of an if-like construct (`PrismCompat` hides the
+      # per-Prism-version accessor split). When no else/elsif is present,
+      # the synthesized else inherits the condition's range (matches
+      # Coverage's convention).
+      def if_like_else_location(node, type)
+        sub = PrismCompat.subsequent(node)
+        return if_like_location(node, type) unless sub
+        # An `elsif` arrives as a nested IfNode. Coverage attributes the
+        # outer else arm to the clause's own range, not its then body
+        # (which is what created phantom unmergeable arms).
+        return if_like_location(sub, :if) if sub.is_a?(::Prism::IfNode)
+        return sub.statements.location if sub.statements
+
+        empty_else_location(node, sub, type)
+      end
+
+      # Location of an empty explicit `else`: a modern `if` uses the
+      # else..end span; a legacy Ruby in void position collapses to a point
+      # at the `else` keyword's end; otherwise (legacy value position, or
+      # `unless`) it uses the condition's range.
+      def empty_else_location(node, sub, type)
+        return sub.location if !LEGACY_COVERAGE_LOCATIONS && type == :if
+        return point_at_end(sub.else_keyword_loc) if LEGACY_COVERAGE_LOCATIONS && !value_position?(node)
+
+        if_like_location(node, type)
+      end
+
+      # Arm location for a when/in clause: its body statements, or — when
+      # the body is empty — the clause's own range on modern Rubies, a
+      # point at the pattern's end for a legacy `in`, and for a legacy
+      # `when` a point at the clause's end in void position or the tail
+      # convention (keyword through the case's remaining content) in value.
+      def case_arm_location(case_node, when_node, when_type)
+        return when_node.statements.location if when_node.statements
+        return when_node.location unless LEGACY_COVERAGE_LOCATIONS
+        return point_at_end(when_node.pattern.location) if when_type == :in
+        return point_at_end(when_node.location) unless value_position?(case_node)
+
+        legacy_when_value_location(case_node, when_node)
+      end
+
+      def legacy_when_value_location(case_node, when_node)
+        span(when_node.location, legacy_case_tail_end(case_node, when_node))
+      end
+
+      # The last body content in the case after `when_node`, falling
+      # back to the clause's final condition value.
+      def legacy_case_tail_end(case_node, when_node)
+        following_case_content(case_node, when_node).last ||
+          (when_node.conditions.last || when_node).location
+      end
+
+      def following_case_content(case_node, when_node)
+        clauses = case_node.conditions
+        index = clauses.index { |clause| clause.equal?(when_node) } || 0
+        # A when-clause's own location ends where its body ends (or at its
+        # condition when empty), so the whole clause extends the range
+        # through trailing EMPTY clauses that have no `statements`.
+        content = clauses.drop(index + 1).map(&:location)
+        else_statements = PrismCompat.else_clause(case_node)&.statements
+        content << else_statements.location if else_statements
+        content
+      end
+
+      # Resolve the source range Coverage attributes to a synthetic-or-real
+      # `:else` arm of a case construct: the body of an explicit else,
+      # the case's full range when no else is present, and — for an
+      # explicit else with an empty body — the else..end span on modern
+      # Rubies or the case's full range on legacy ones.
+      def else_arm_location(node)
+        else_clause = PrismCompat.else_clause(node)
+        return node.location unless else_clause
+        return else_clause.statements.location if else_clause.statements
+        return else_clause.location unless LEGACY_COVERAGE_LOCATIONS
+        # Empty explicit `else`: a point at the `else` keyword's end in void
+        # position, the whole case's range in value position.
+        return point_at_end(else_clause.else_keyword_loc) unless value_position?(node)
+
+        node.location
+      end
+
+      # An empty loop body falls back to the loop's range on modern
+      # Rubies and collapses to a point at the predicate's end on legacy
+      # ones.
+      def loop_body_location(node)
+        return legacy_do_while_body_location(node) if LEGACY_COVERAGE_LOCATIONS && begin_modifier_loop?(node)
+        return node.statements.location if node.statements
+        return point_at_end(node.predicate.location) if LEGACY_COVERAGE_LOCATIONS
+
+        node.location
+      end
+
+      # `begin ... end while/until cond` (the do-while form) parses as a
+      # while/until whose sole statement is the BeginNode. Modern Coverage
+      # attributes the body to that whole `begin ... end` span (which the
+      # generic `node.statements.location` already yields), but 3.3 uses
+      # the begin's inner statements instead — or a point at the end of
+      # the `begin` keyword when the body is empty.
+      def begin_modifier_loop?(node)
+        node.respond_to?(:begin_modifier?) && node.begin_modifier?
+      end
+
+      def legacy_do_while_body_location(node)
+        begin_node = node.statements.body.first
+        inner = begin_node.statements
+        inner ? inner.location : point_at_end(begin_node.begin_keyword_loc)
+      end
+
+      # Coverage's safe-navigation branch spans the receiver through the
+      # end of the call's arguments (or just the message when there are
+      # none), but never includes a trailing block: `x&.foo { ... }` and
+      # `x&.foo(1) { ... }` both end exactly where `x&.foo` / `x&.foo(1)`
+      # would without the block. `node.location` includes an attached
+      # block, so build the end position from `closing_loc` (closing
+      # paren) / `arguments` (paren-less args) / `message_loc` instead.
+      # This convention is the same on legacy and modern Rubies. See
+      # issue #1233.
+      def safe_navigation_location(node)
+        span(node.location, node.closing_loc || node.arguments&.location || node.message_loc)
+      end
+
+      # The range from `from`'s start through `to`'s end.
+      def span(from, to)
+        PointLocation.new(
+          start_line: from.start_line, start_column: from.start_column,
+          end_line: to.end_line, end_column: to.end_column
+        )
+      end
+
+      def point_at_end(location)
+        PointLocation.new(
+          start_line: location.end_line, start_column: location.end_column,
+          end_line: location.end_line, end_column: location.end_column
+        )
+      end
+
+      # Whether an empty then arm collapses to a point at the predicate's
+      # end. Modern Coverage does this for every `if` (but not `unless`);
+      # legacy Coverage does it only in void position, for both.
+      def empty_arm_collapses?(node, type)
+        return type == :if unless LEGACY_COVERAGE_LOCATIONS
+
+        !value_position?(node)
+      end
+
+      # Whether `node` sits in value (method-return) position, which on
+      # legacy Rubies keeps an empty arm's range instead of collapsing it
+      # to a point. `@value_positions` is computed once per parse by
+      # ValuePositions (only on legacy; nil elsewhere, which reads as
+      # "value" — the safe, pre-audit default).
+      def value_position?(node)
+        return true if @value_positions.nil?
+
+        @value_positions.key?(node)
+      end
+      # simplecov:enable
+    end
+    # rubocop:enable Metrics/ModuleLength
+  end
+end

data/lib/simplecov/static_coverage_extractor/method_collector.rb

@@ -22,7 +22,14 @@ module SimpleCov
       # `def name(...)` and `def self.name(...)` both produce DefNode.
       # The class context is the surrounding lexical class/module (or
       # `Object` at the top level, matching `Coverage`'s convention).
+      # Suppression covers 3.2's folded dead arms, where nested branches
+      # stay instrumented but a `def` never registers (see
+      # Visitor#visit_dead_arm).
       def visit_def_node(node)
+        # simplecov:disable branch — suppression is reachable on 3.2 only
+        return super if @suppress_methods
+
+        # simplecov:enable branch
         loc = node.location
         class_name = @class_stack.last || "Object"
         key = [class_name, node.name, loc.start_line, loc.start_column, loc.end_line, loc.end_column]