simplecov 1.1.1 → 1.3.0

data/lib/simplecov/static_coverage_extractor/condition_folding.rb

@@ -2,39 +2,27 @@
 
 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.
+    # 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: the arm would be a phantom no loaded run
+    # can hit, the same unmergeable-tuple failure 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.
+      # CRuby 3.4 rebuilt the fold on the Prism compiler, and the parse.y fold
+      # it replaced still differs on 3.3, where `__FILE__` folds.
       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 literals in discarded position are eliminated from 3.3 on, but
+      # 3.3's compile.c elides a container whose contents are merely
+      # effect-free (`[x]`), while the Prism compiler demands fully static
+      # literals (`[1]` goes, `[x]` stays).
       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.
+      # 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: 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,
@@ -45,27 +33,18 @@ module SimpleCov
       ].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.
+      # CRuby folds `if nil`, `if "x"`, and `if -> {}` but keeps a real branch
+      # for `if (nil)`, `if ("x")`, and `if (-> {})`, while every other literal
+      # folds parenthesized or not.
       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
+      # 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.
+      # discarded, and these always are, bare or composing an Array/Hash/Range.
       STATIC_LITERAL_LEAF_TYPES = [
         ::Prism::IntegerNode, ::Prism::FloatNode, ::Prism::RationalNode,
         ::Prism::ImaginaryNode, ::Prism::StringNode, ::Prism::SymbolNode,
@@ -73,100 +52,53 @@ module SimpleCov
         ::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
+      # Non-literal reads that are also eliminated when discarded. Anything that
+      # can raise or run hooks is never eliminated and keeps the branch real.
       ELIMINABLE_READ_TYPES = [
-        ::Prism::SelfNode,
-        *(PRISM_ERA_ELIMINABLE_READS unless PARENS_ALWAYS_TRANSPARENT)
+        ::Prism::SelfNode, ::Prism::LocalVariableReadNode,
+        ::Prism::InstanceVariableReadNode, ::Prism::DefinedNode
       ].freeze
-      # simplecov:enable branch
 
-    private
+      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.
+      # `visit` is nil-safe, so a missing arm just visits nothing.
       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
+        visit(verdict.equal?(:truthy) ? truthy_arm : falsy_arm)
       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.
+      # `:truthy` or `:falsy` when the compiler folds, nil when it doesn't. The
+      # compiler eliminates the losing arm's entire subtree, so everything
+      # inside it must go unvisited too, not just the folded condition's 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.
+      # 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 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
+        (FALSY_CONDITION_TYPES.any? { |type| unwrapped.instance_of?(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).
+      # `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
+        return false unless STATIC_CONDITION_TYPES.any? { |type| unwrapped.instance_of?(type) }
 
-        unwrapped.equal?(node) || PAREN_OPAQUE_TYPES.none? { |type| unwrapped.is_a?(type) }
-        # simplecov:enable
+        unwrapped.equal?(node) || PAREN_OPAQUE_TYPES.none? { |type| unwrapped.instance_of?(type) }
       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.
+      # 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.
       def unwrap_parentheses(node)
         # @type var current: untyped
         current = node
-        while current.is_a?(::Prism::ParenthesesNode)
+        while current.instance_of?(Prism::ParenthesesNode)
+          # Empty parentheses carry no statements node at all, so a
+          # body that is one always holds at least one statement.
           body = current.body
-          break unless body.is_a?(::Prism::StatementsNode) && !body.body.empty?
+          break unless body.instance_of?(Prism::StatementsNode)
 
           statements = body.body
           break unless statements.take(statements.size - 1).all? { |leading| eliminable_when_discarded?(leading) }
@@ -176,40 +108,26 @@ module SimpleCov
         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) }
+        return true if ELIMINABLE_READ_TYPES.any? { |type| node.instance_of?(type) }
 
-        node.is_a?(::Prism::ParenthesesNode) &&
-          node.body.is_a?(::Prism::StatementsNode) &&
+        node.instance_of?(Prism::ParenthesesNode) &&
+          node.body.instance_of?(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
+        return true if STATIC_LITERAL_LEAF_TYPES.any? { |type| node.instance_of?(type) }
 
         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)
+        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
@@ -220,7 +138,7 @@ module SimpleCov
 
       def static_hash_literal?(node)
         node.elements.all? do |element|
-          element.is_a?(::Prism::AssocNode) &&
+          element.instance_of?(Prism::AssocNode) &&
             container_contents_eliminable?(element.key) && container_contents_eliminable?(element.value)
         end
       end
@@ -230,9 +148,7 @@ module SimpleCov
       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

data/lib/simplecov/static_coverage_extractor/location_conventions.rb

@@ -4,198 +4,158 @@ 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.
+    # 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 (#1226, #1233). The "runtime tuple equivalence" spec
+    # exercises the module against real Coverage output on every CI Ruby, and
+    # is the authority on what each resolver should answer.
     #
-    # 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.
+      # anchors to a point rather than a range. Resolvers answer whichever of a
+      # node, one of its locations, or this is nearest to hand: all three
+      # answer the four position accessors the emitted tuples are built from.
       PointLocation = Data.define(:start_line, :start_column, :end_line, :end_column)
 
-    private
+      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.
+      # Which arm of each conditional below runs is fixed by the running Ruby's
+      # version, so no single process can cover both sides.
 
-      # 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.
+      # 3.2/3.3 end an `elsif` clause's range at its last content rather than
+      # at 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)
+        return node unless LEGACY_COVERAGE_LOCATIONS && type.equal?(:if) && elsif_node?(node)
 
-        span(node.location, legacy_content_end(node))
+        span(node, legacy_content_end(node))
       end
 
       def elsif_node?(node)
         keyword = node.if_keyword_loc
-        !keyword.nil? && keyword.slice == "elsif"
+        !keyword.nil? && keyword.slice.eql?("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.
+      # 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)
+        while tail.instance_of?(Prism::IfNode)
           sub = PrismCompat.subsequent(tail)
           break unless sub
 
           tail = sub
         end
-        return (tail.statements || tail.predicate).location if tail.is_a?(::Prism::IfNode)
+        return tail.statements || tail.predicate if tail.instance_of?(Prism::IfNode)
 
-        tail.statements ? tail.statements.location : tail.else_keyword_loc
+        tail.statements || 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)
+        return node.statements if node.statements
+        return point_at_end(node.predicate) 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).
+      # With no else/elsif present, the synthesized else inherits the
+      # condition's range.
       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
+        # An `elsif` arrives as a nested IfNode, and 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.instance_of?(Prism::IfNode)
+        return sub.statements 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)
+        return sub if !LEGACY_COVERAGE_LOCATIONS && type.equal?(:if)
+        # Void position is a legacy distinction: a Ruby that does not need the
+        # value-position pass answers every node as value.
+        return point_at_end(sub.else_keyword_loc) unless 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)
+        return when_node.statements if when_node.statements
+        return when_node unless LEGACY_COVERAGE_LOCATIONS
+        return point_at_end(when_node.pattern) if when_type.equal?(:in)
+        return point_at_end(when_node) 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))
+        span(when_node, 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.
+      # Only a `when` reaches here, and a `when` always carries at least one
+      # condition, so the fallback is always available.
       def legacy_case_tail_end(case_node, when_node)
-        following_case_content(case_node, when_node).last ||
-          (when_node.conditions.last || when_node).location
+        following_case_content(case_node, when_node).last || when_node.conditions.last
       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)
+        # condition when empty), so the whole clause is what extends the range
+        # through trailing empty clauses that have no `statements`.
+        index = clauses.index { |clause| clause.equal?(when_node) }
+        content = clauses.drop(index + 1)
         else_statements = PrismCompat.else_clause(case_node)&.statements
-        content << else_statements.location if else_statements
+        content += [else_statements] 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 node unless else_clause
+        return else_clause.statements if else_clause.statements
+        return else_clause unless LEGACY_COVERAGE_LOCATIONS
         return point_at_end(else_clause.else_keyword_loc) unless value_position?(node)
 
-        node.location
+        node
       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
+        return node.statements if node.statements
+        return point_at_end(node.predicate) if LEGACY_COVERAGE_LOCATIONS
 
-        node.location
+        node
       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.
+      # The accessor arrived in Prism 0.25, and this gem supports older ones,
+      # where nothing answers the question.
       def begin_modifier_loop?(node)
         node.respond_to?(:begin_modifier?) && node.begin_modifier?
       end
 
+      # `begin ... end while cond` parses as a while whose sole statement is
+      # the BeginNode. Modern Coverage attributes the body to that whole
+      # `begin ... end` span, but 3.3 uses the begin's inner statements.
       def legacy_do_while_body_location(node)
-        begin_node = node.statements.body.first
+        begin_node, = node.statements.body
         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.
+        inner || 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 { ... }` ends exactly where
+      # `x&.foo` would. `node.location` would include the block (#1233).
       def safe_navigation_location(node)
-        span(node.location, node.closing_loc || node.arguments&.location || node.message_loc)
+        span(node, node.closing_loc || node.arguments || 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,
@@ -210,27 +170,22 @@ module SimpleCov
         )
       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.
+      # Modern Coverage collapses an empty then arm 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
+        return type.equal?(: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).
+      # `@value_positions` is computed once per parse by ValuePositions, and
+      # only on legacy Rubies. 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