simplecov 1.0.0 → 1.0.1

data/lib/simplecov/file_list.rb

@@ -27,8 +27,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 ||= compute_coverage_statistics
-      criterion ? @coverage_statistics[criterion] : @coverage_statistics
+      stats = (@coverage_statistics ||= compute_coverage_statistics)
+      criterion ? stats[criterion] : stats
     end
 
     def coverage_statistics_by_file
@@ -67,7 +67,11 @@ module SimpleCov
 
     # Finds the least covered file and returns that file's name
     def least_covered_file
-      min_by(&:covered_percent).filename
+      # `covered_percent` is nil only for an unmeasured criterion, and :line
+      # is always measured, so the `|| 0.0` arm never fires at runtime; it
+      # (and the cast) exist to satisfy min_by's Comparable requirement.
+      least_covered = min_by { |file| file.covered_percent || 0.0 }
+      (_ = least_covered).filename
     end
 
     # Returns the overall amount of relevant lines of code across all files in this list
@@ -137,7 +141,10 @@ module SimpleCov
     # enabled set so disabled criteria don't surface in totals, JSON,
     # or the HTML report.
     def compute_coverage_statistics_by_file
-      seed = enabled_criteria_for_reporting.to_h { |criterion| [criterion, []] }
+      seed = enabled_criteria_for_reporting.to_h do |criterion|
+        bucket = [] #: Array[CoverageStatistics]
+        [criterion, bucket]
+      end
       @files.each_with_object(seed) do |file, together|
         file.coverage_statistics.each do |criterion, stats|
           together[criterion] << stats if together.key?(criterion)
@@ -153,7 +160,7 @@ module SimpleCov
     # criterion is enabled; the JRuby-gated branch/method criteria are
     # reported when they pass their own engine-support check.
     def enabled_criteria_for_reporting
-      criteria = []
+      criteria = [] #: Array[SimpleCov::criterion]
       criteria << :line   if SimpleCov.coverage_criterion_enabled?(:line) ||
                              SimpleCov.coverage_criterion_enabled?(:oneshot_line)
       criteria << :branch if SimpleCov.branch_coverage?

data/lib/simplecov/formatter/base.rb

@@ -45,7 +45,8 @@ module SimpleCov
       # confusing than the absolute form. See issue #197.
       def displayable_output_path
         directory = relative_or_absolute_output_path
-        entry_point_filename ? File.join(directory, entry_point_filename) : directory
+        entry_point = entry_point_filename
+        entry_point ? File.join(directory, entry_point) : directory
       end
 
       def relative_or_absolute_output_path

data/lib/simplecov/formatter/html_formatter.rb

@@ -31,8 +31,10 @@ module SimpleCov
 
         copy_static_assets
         # stderr, not stdout: this is a status message, not the program's
-        # output. Keeps the line out of pipelines like `rspec -f json`.
-        warn output_message(result) unless @silent
+        # output. Keeps the line out of pipelines like `rspec -f json`. And
+        # $stderr.puts, not `warn`: a status line should not reach
+        # `Warning.warn` hooks or vanish under `-W0` (see #1225).
+        $stderr.puts output_message(result) unless @silent # rubocop:disable Style/StderrPuts
       end
 
       # Generate HTML from a pre-existing coverage.json file without
@@ -65,14 +67,18 @@ module SimpleCov
       #   from opening the existing path for writing.
       def atomic_write(dest, content)
         temp = "#{dest}.#{Process.pid}.#{rand(2**32).to_s(36)}"
-        File.binwrite(temp, content)
-        File.rename(temp, dest)
-      ensure
-        FileUtils.rm_f(temp)
+        begin
+          File.binwrite(temp, content)
+          File.rename(temp, dest)
+        ensure
+          FileUtils.rm_f(temp)
+        end
       end
 
       def public_dir
-        File.join(__dir__, "html_formatter/public/")
+        # `.to_s` collapses `__dir__`'s nil arm (only possible under eval,
+        # which can't happen for a file on disk) so the path is a String.
+        File.join(__dir__.to_s, "html_formatter/public/")
       end
     end
   end

data/lib/simplecov/formatter/json_formatter/errors_formatter.rb

@@ -42,14 +42,20 @@ module SimpleCov
         end
 
         def record_by_file(violation)
-          file_bucket = bucket(:minimum_coverage_by_file)[violation.fetch(:project_filename)] ||= {}
+          by_file = bucket(:minimum_coverage_by_file)
+          file_bucket = by_file[violation.fetch(:project_filename)] ||= {} #: Hash[untyped, untyped]
           file_bucket[key_for(violation)] = expected_actual(violation)
         end
 
         def format_minimum_by_group
           violations = SimpleCov::CoverageViolations.minimum_by_group(@result, SimpleCov.minimum_coverage_by_group)
+          return if violations.empty?
+
+          # `bucket` lazily creates the errors key, so only touch it when
+          # there is a violation to record.
+          by_group = bucket(:minimum_coverage_by_group)
           violations.each do |violation|
-            group_bucket = bucket(:minimum_coverage_by_group)[violation.fetch(:group_name)] ||= {}
+            group_bucket = by_group[violation.fetch(:group_name)] ||= {} #: Hash[untyped, untyped]
             group_bucket[key_for(violation)] = expected_actual(violation)
           end
         end
@@ -68,7 +74,7 @@ module SimpleCov
         end
 
         def bucket(name)
-          @errors[name] ||= {}
+          @errors[name] ||= {} #: Hash[untyped, untyped]
         end
 
         def key_for(violation)

data/lib/simplecov/formatter/json_formatter/result_hash_formatter.rb

@@ -95,7 +95,7 @@ module SimpleCov
         end
 
         def format_coverage_statistics(statistics)
-          result = {}
+          result = {} #: Hash[Symbol, untyped]
           result[:lines]    = format_line_statistic(statistics[:line])      if statistics[:line]
           result[:branches] = format_single_statistic(statistics[:branch])  if statistics[:branch]
           result[:methods]  = format_single_statistic(statistics[:method])  if statistics[:method]

data/lib/simplecov/formatter/json_formatter/source_file_formatter.rb

@@ -13,7 +13,7 @@ module SimpleCov
         end
 
         def call
-          result = @include_source ? format_source_code : {}
+          result = @include_source ? format_source_code : {} #: Hash[Symbol, untyped]
           result.merge!(line_coverage_section) if line_coverage_enabled?
           result.merge!(branch_coverage_section) if SimpleCov.branch_coverage?
           result.merge!(method_coverage_section) if SimpleCov.method_coverage?

data/lib/simplecov/formatter/json_formatter.rb

@@ -28,8 +28,10 @@ module SimpleCov
         warn_if_concurrent_overwrite(path, result)
         File.write(path, JSON.pretty_generate(self.class.build_hash(result)))
         # stderr, not stdout: this is a status message, not the program's
-        # output. Keeps the line out of pipelines like `rspec -f json`.
-        warn output_message(result) unless @silent
+        # output. Keeps the line out of pipelines like `rspec -f json`. And
+        # $stderr.puts, not `warn`: a status line should not reach
+        # `Warning.warn` hooks or vanish under `-W0` (see #1225).
+        $stderr.puts output_message(result) unless @silent # rubocop:disable Style/StderrPuts
       end
 
     private

data/lib/simplecov/formatter/multi_formatter.rb

@@ -12,16 +12,21 @@ module SimpleCov
           formatters.map do |formatter|
             formatter.new.format(result)
           rescue StandardError => e
-            warn("Formatter #{formatter} failed with #{e.class}: #{e.message} (#{e.backtrace.first})")
+            warn("Formatter #{formatter} failed with #{e.class}: #{e.message} (#{(_ = e.backtrace).first})")
             nil
           end
         end
       end
 
       def self.new(formatters = nil)
+        # Normalize eagerly and capture the list in the closure. Array()
+        # is pure for every accepted input shape (nil, single formatter,
+        # array, or another MultiFormatter class), so this is equivalent
+        # to the historical lazy per-instance memoization.
+        formatter_list = Array(formatters)
         Class.new do
           define_method :formatters do
-            @formatters ||= Array(formatters)
+            formatter_list
           end
           include InstanceMethods
         end

data/lib/simplecov/formatter/simple_formatter.rb

@@ -15,7 +15,9 @@ module SimpleCov
 
       def format_group(name, files)
         header = "Group: #{name}\n#{'=' * 40}\n"
-        body   = files.map { |file| "#{file.filename} (coverage: #{file.covered_percent.floor(2)}%)\n" }.join
+        # `covered_percent` is nilable across criteria, but line stats are
+        # always measured, so the no-argument call can't return nil here.
+        body   = files.map { |file| "#{file.filename} (coverage: #{(_ = file.covered_percent).floor(2)}%)\n" }.join
         "#{header}#{body}\n"
       end
     end

data/lib/simplecov/process.rb

@@ -9,7 +9,24 @@
 # correctly with other libraries doing the same — they each prepend
 # their own module and chain via `super`.
 
+# Reopened here for the fork-related at_exit plumbing that only matters
+# when subprocess support is loaded.
 module SimpleCov
+  class << self
+    # Forked children inherit at_exit state that is wrong for them:
+    # @at_exit_hook_installed may describe a hook the parent already
+    # consumed before forking (Minitest autorun runs the suite inside the
+    # parent's at_exit, after SimpleCov's own hook has fired), and
+    # external_at_exit may point at a Minitest.after_run deferral that is
+    # pid-pinned to the parent. Reset both so the at_fork proc's
+    # SimpleCov.start installs a fresh hook that actually fires at child
+    # exit. See issue #1227.
+    def reset_inherited_at_exit_state!
+      @at_exit_hook_installed = false
+      self.external_at_exit = false
+    end
+  end
+
   # Prepended onto Process's singleton class so every fork — direct or
   # via Kernel#fork / IO.popen — re-runs SimpleCov's at_fork callback in
   # the child.
@@ -27,6 +44,11 @@ module SimpleCov
         # the user installed, so `final_result_process?` can keep forked
         # workers from each producing the final report. See issue #1171.
         SimpleCov.mark_forked_subprocess!
+        # Without this, a child forked under Minitest autorun measures
+        # coverage and then silently discards it: every inherited exit
+        # route is dead in the child (see the method's comment). A custom
+        # at_fork runs afterwards and can still override. See issue #1227.
+        SimpleCov.reset_inherited_at_exit_state!
         SimpleCov.at_fork.call(::Process.pid)
       end
       pid

data/lib/simplecov/result_adapter.rb

@@ -63,7 +63,8 @@ module SimpleCov
       methods = cover_statistic[:methods]
       return unless methods
 
-      cover_statistic[:methods] = methods.each_with_object({}) do |(key, count), normalized|
+      normalized_methods = {} #: Hash[untyped, untyped]
+      cover_statistic[:methods] = methods.each_with_object(normalized_methods) do |(key, count), normalized|
         normalized_key = key.dup
         normalized_key[0] = key[0].to_s
                                   .gsub(ADDRESS_PATTERN, ADDRESS_PLACEHOLDER)

data/lib/simplecov/result_processing.rb

@@ -66,7 +66,7 @@ module SimpleCov
 
     # Applies the configured filters to the given array of SimpleCov::SourceFile items
     def filtered(files)
-      result = files.clone
+      result = files.to_a.dup
       filters.each do |filter|
         result = result.reject { |source_file| filter.matches?(source_file) }
       end
@@ -170,9 +170,9 @@ module SimpleCov
     # 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:)
-      @result = SimpleCov::UselessResultsRemover.call(Coverage.result)
-      @result = SimpleCov::ResultAdapter.call(@result)
-      result, not_loaded_files = add_not_loaded_files(@result)
+      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)
     end
   end

data/lib/simplecov/simulate_coverage.rb

@@ -39,8 +39,8 @@ module SimpleCov
       source_lines = read_lines(absolute_path)
       lines = coverage_stub(absolute_path, source_lines) ||
               LinesClassifier.new.classify(source_lines)
-      synthesized = StaticCoverageExtractor.call(source_lines.join) ||
-                    {"branches" => {}, "methods" => {}}
+      empty = {"branches" => {}, "methods" => {}} #: Hash[String, Hash[untyped, untyped]]
+      synthesized = StaticCoverageExtractor.call(source_lines.join) || empty
 
       {
         "lines" => lines,

data/lib/simplecov/source_file/line.rb

@@ -37,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

data/lib/simplecov/source_file/method.rb

@@ -34,7 +34,7 @@ module SimpleCov
       end
 
       def lines
-        @lines ||= start_line && end_line ? source_file.lines[(start_line - 1)..(end_line - 1)] : []
+        @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.

data/lib/simplecov/source_file/method_builder.rb

@@ -12,7 +12,9 @@ module SimpleCov
       end
 
       def call
-        methods = @source_file.coverage_data.fetch("methods", {}).filter_map do |info, hit_count|
+        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)
 

data/lib/simplecov/source_file/source_loader.rb

@@ -14,12 +14,12 @@ 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
 
-          if shebang?(current_line)
+          if current_line && shebang?(current_line)
             lines << current_line
             current_line = file.gets
           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/location_conventions.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+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 issue #1226.
+    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)
+
+        content_end = legacy_content_end(node)
+        PointLocation.new(
+          start_line: node.location.start_line, start_column: node.location.start_column,
+          end_line: content_end.end_line, end_column: content_end.end_column
+        )
+      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 = tail.public_send(IF_NODE_SUBSEQUENT_METHOD)
+          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; a modern (3.4+) `if` with an empty then body collapses the
+      # arm to a zero-width point at the predicate's end, while `unless`
+      # and legacy Rubies fall back to the node's range.
+      def if_like_then_location(node, type)
+        return node.statements.location if node.statements
+        return if_like_location(node, type) if LEGACY_COVERAGE_LOCATIONS || type != :if
+
+        point_at_end(node.predicate.location)
+      end
+
+      # Resolve the source range Coverage attributes to a real-or-synthetic
+      # `:else` arm of an if-like construct. IfNode uses
+      # `subsequent` / `consequent` depending on Prism version (resolved
+      # to `IF_NODE_SUBSEQUENT_METHOD` at load time); UnlessNode uses
+      # `else_clause`. When neither is present, the synthesized else
+      # inherits the condition's range (matches Coverage's convention).
+      def if_like_else_location(node, type)
+        sub = node.is_a?(::Prism::IfNode) ? node.public_send(IF_NODE_SUBSEQUENT_METHOD) : node.else_clause
+        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 explicit else: a modern `if` uses the else..end span,
+        # while `unless` and legacy Rubies use the condition's range.
+        return sub.location if !LEGACY_COVERAGE_LOCATIONS && type == :if
+
+        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,
+      # and on legacy Rubies a point at the pattern's end for `in`, or
+      # the keyword through the case's remaining trailing content for
+      # `when` (the same tail convention as legacy elsif ranges).
+      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
+
+        tail_end = legacy_case_tail_end(case_node, when_node)
+        PointLocation.new(
+          start_line: when_node.location.start_line, start_column: when_node.location.start_column,
+          end_line: tail_end.end_line, end_column: tail_end.end_column
+        )
+      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
+        bodies = clauses.drop(index + 1).filter_map { |clause| clause.statements&.location }
+        else_statements = case_node.else_clause&.statements
+        bodies << else_statements.location if else_statements
+        bodies
+      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)
+        return node.location unless node.else_clause
+        return node.else_clause.statements.location if node.else_clause.statements
+
+        LEGACY_COVERAGE_LOCATIONS ? node.location : node.else_clause.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 node.statements.location if node.statements
+        return point_at_end(node.predicate.location) if LEGACY_COVERAGE_LOCATIONS
+
+        node.location
+      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
+      # simplecov:enable
+    end
+  end
+end

data/lib/simplecov/static_coverage_extractor/visitor.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "location_conventions"
 require_relative "method_collector"
 
 module SimpleCov
@@ -29,6 +30,9 @@ module SimpleCov
       # Method tuples and the class/module nesting that names them are
       # collected by this mixin; this class focuses on branch extraction.
       include MethodCollector
+      # Source-range resolution, including the per-Ruby-version Coverage
+      # conventions. See issue #1226.
+      include LocationConventions
 
       attr_reader :branches, :methods
 
@@ -92,9 +96,9 @@ module SimpleCov
       # optional else/elsif) but expose the trailing arm under different
       # accessors. `if_like_else_location` hides that split.
       def emit_if_like(node, type)
-        then_loc = arm_location(node.statements, node.location)
-        else_loc = if_like_else_location(node)
-        @branches[build_tuple(type, node.location)] = {
+        then_loc = if_like_then_location(node, type)
+        else_loc = if_like_else_location(node, type)
+        @branches[build_tuple(type, if_like_location(node, type))] = {
           build_tuple(:then, then_loc) => 0,
           build_tuple(:else, else_loc) => 0
         }
@@ -108,58 +112,18 @@ module SimpleCov
         }
       end
 
-      # Resolve the source range Coverage attributes to a real-or-synthetic
-      # `:else` arm of an if-like construct. IfNode uses
-      # `subsequent` / `consequent` depending on Prism version (resolved
-      # to `IF_NODE_SUBSEQUENT_METHOD` at load time); UnlessNode uses
-      # `else_clause`. When neither is present, the synthesized else
-      # inherits the whole condition's range (matches Coverage's
-      # convention).
-      def if_like_else_location(node)
-        sub = node.is_a?(::Prism::IfNode) ? node.public_send(IF_NODE_SUBSEQUENT_METHOD) : node.else_clause
-        return node.location unless sub
-
-        arm_location(else_body_of(sub), sub.location)
-      end
-
       def emit_case_like(node, when_type)
         arms = node.conditions.to_h do |when_node|
-          loc = arm_location(when_node.statements, when_node.location)
-          [build_tuple(when_type, loc), 0]
+          [build_tuple(when_type, case_arm_location(node, when_node, when_type)), 0]
         end
         arms[build_tuple(:else, else_arm_location(node))] = 0
         @branches[build_tuple(:case, node.location)] = arms
       end
 
-      # Resolve the source range Coverage attributes to a synthetic-or-real
-      # `:else` arm of a case construct: the body of an explicit else,
-      # or the case's full range when no else is present.
-      def else_arm_location(node)
-        return node.location unless node.else_clause
-
-        arm_location(else_body_of(node.else_clause), node.else_clause.location)
-      end
-
       def emit_loop(node, type)
         cond_tuple = build_tuple(type, node.location)
-        body_loc = arm_location(node.statements, node.location)
-        @branches[cond_tuple] = {build_tuple(:body, body_loc) => 0}
-      end
-
-      # Body location for an arm. Prism's `statements` is a StatementsNode
-      # whose span covers the contained expressions; fall back to the
-      # parent when the arm body is empty (e.g., `if cond then end`).
-      def arm_location(statements, fallback_location)
-        statements&.location || fallback_location
-      end
-
-      # simplecov:disable branch
-      # The `else_node` fallback is defensive: every Prism node passed
-      # in here in practice responds to `:statements`.
-      def else_body_of(else_node)
-        else_node.respond_to?(:statements) ? else_node.statements : else_node
+        @branches[cond_tuple] = {build_tuple(:body, loop_body_location(node)) => 0}
       end
-      # simplecov:enable branch
 
       def build_tuple(type, location)
         id = @next_id

data/lib/simplecov/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SimpleCov
-  VERSION = "1.0.0"
+  VERSION = "1.0.1"
 end