simplecov 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 14c29bfd96c91bb39e5893969a5f35a320e0d3b23b3ae47161aabc21a182f69f
-  data.tar.gz: 2436a11c76e48df0df5c7432e1c1163f0bf36f9090e04d035017c99769e74b7d
+  metadata.gz: 1f159cd5427690b20f11c1e4a3f1a90c23c16f5f65e2043205bf132a5abc0218
+  data.tar.gz: d5a28a2c529ff2b59652bd0c1ba1f9d649c7c24fd02521905c6d2cbe6b1eeae3
 SHA512:
-  metadata.gz: 13bdde3f26f987d864caf3c2a861c479cac8e03c12fcf12752aad70b0ca55793e1dc529490d5ad9fc6250c780d6131fd78264ddaf0ca3158ae4cea5ffdb3b3b5
-  data.tar.gz: 21239f67622ae18b306783d6a355dd728247128ece00935601334b82f4f7f8948150768d0ac949c1db5c859c23187b4a9f568b7a45a49bf5a7a1ab40a8178951
+  metadata.gz: 792c138d327b5d305ebe273dfd5a97d70eb8104102557d5ae6452a26d5cc64e1db7720c3de5e2c556a78b22561c53778579909ddef7f4615e1c447f041fa921c
+  data.tar.gz: 9f6479ceabbd5f6fc24585a2134a0f4e1270dbd988922d4d387e5695055b811655999b3d95c2a9b31c960cf0c22aa884d5bf94eae93ca6fb97868bbec0de3aab

data/lib/simplecov/color.rb

@@ -34,7 +34,12 @@ module SimpleCov
     # doesn't get ANSI sequences. See the module-level comment for
     # precedence.
     def enabled?(stream = $stderr)
-      config = SimpleCov.color
+      # `SimpleCov.color` only exists once the full library is loaded.
+      # The standalone CLI (`exe/simplecov`) loads `simplecov/color`
+      # without `simplecov` itself to stay lightweight, so treat a
+      # missing config the same as its `:auto` default: fall through to
+      # the env vars and tty check below.
+      config = SimpleCov.color if SimpleCov.respond_to?(:color)
       return config if [true, false].include?(config)
       return false if env_set?("NO_COLOR")
       return true  if env_set?("FORCE_COLOR")

data/lib/simplecov/combine/files_combiner.rb

@@ -9,22 +9,62 @@ module SimpleCov
     module FilesCombiner
     module_function
 
+      empty_table = {} #: Hash[untyped, untyped]
+      EMPTY_TABLE = empty_table.freeze
+      private_constant :EMPTY_TABLE
+
+      # Branch/method tuples drawn from a simulated (never-loaded) file
+      # when the other side of the merge was actually executed.
+      NO_SYNTHESIZED = {"branches" => EMPTY_TABLE, "methods" => EMPTY_TABLE}.freeze
+
       #
       # Combines the results for 2 coverages of a file.
       #
       # @return [Hash]
       #
       def combine(coverage_a, coverage_b)
+        source_a, source_b = reconcile_synthesized(coverage_a, coverage_b)
+
         combination = {"lines" => Combine.combine(LinesCombiner, coverage_a["lines"], coverage_b["lines"])}
         if SimpleCov.branch_coverage?
-          combined_branches = Combine.combine(BranchesCombiner, coverage_a["branches"], coverage_b["branches"])
+          combined_branches = Combine.combine(BranchesCombiner, source_a["branches"], source_b["branches"])
           combination["branches"] = combined_branches || {}
         end
         if SimpleCov.method_coverage?
-          combination["methods"] = Combine.combine(MethodsCombiner, coverage_a["methods"], coverage_b["methods"])
+          combination["methods"] = Combine.combine(MethodsCombiner, source_a["methods"], source_b["methods"])
         end
         combination
       end
+
+      # When exactly one side of the merge was actually executed, its branch
+      # and method tuples are authoritative and the other side's are dropped.
+      # A simulated entry (SimulateCoverage backfills tracked-but-unloaded
+      # files) synthesizes those tuples statically, so a location that drifts
+      # from what Coverage emits would otherwise be unioned in by position
+      # and survive as a phantom, permanently-missed branch (see #1233). This
+      # contains any such drift to denominator inflation for files no process
+      # loaded, rather than a false miss on a covered file. Lines are never
+      # dropped: a simulated file's line shape is correct and carries the
+      # unloaded-file denominator (#1059).
+      #
+      # Returns the two coverages to draw branch/method tuples from, blanking
+      # the non-executed side only when the other side was executed. When
+      # both sides were executed (two real runs) or neither was (all
+      # simulated), both are returned unchanged and combine normally.
+      def reconcile_synthesized(coverage_a, coverage_b)
+        executed_a = executed?(coverage_a)
+        executed_b = executed?(coverage_b)
+        return [coverage_a, coverage_b] if executed_a == executed_b
+
+        executed_a ? [coverage_a, NO_SYNTHESIZED] : [NO_SYNTHESIZED, coverage_b]
+      end
+
+      # A file some process actually loaded has at least one executed line;
+      # a simulated (never-loaded) file's lines are all `nil` or `0`.
+      def executed?(coverage)
+        lines = Array(coverage["lines"]) #: Array[Integer?]
+        lines.any? { |count| count&.positive? }
+      end
     end
   end
 end

data/lib/simplecov/combine/methods_combiner.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../source_file/ruby_data_parser"
+
 module SimpleCov
   module Combine
     #
@@ -12,14 +14,35 @@ module SimpleCov
       #
       # Return merged methods or the existing methods if other is missing.
       #
-      # Method coverage is a flat hash mapping method identifiers to hit counts.
-      # Combining sums the hit counts for matching methods and preserves methods
-      # that only appear in one result.
+      # Method coverage maps `[class, name, start_line, start_col, end_line,
+      # end_col]` keys to hit counts. Keys are matched on their SOURCE
+      # identity — (name, location), ignoring the class element — because
+      # Ruby records one entry per receiver: the same `define_method` block
+      # defined onto different classes in different processes arrives with
+      # different (normalized) receivers for the same source method, and
+      # matching on the full key would keep both, letting a never-called
+      # receiver's 0 shadow a covered method after merge (issue #1234).
+      # Combining sums the hit counts for matching methods and preserves
+      # methods that only appear in one result.
       #
       # @return [Hash]
       #
       def combine(coverage_a, coverage_b)
-        coverage_a.merge(coverage_b) { |_key, a_count, b_count| a_count + b_count }
+        merged = {} #: Hash[untyped, [untyped, Integer]]
+        [coverage_a, coverage_b].each_with_object(merged) do |coverage, memo|
+          coverage.each do |key, count|
+            method_key = source_identity(key)
+            retained_key, existing = memo[method_key] || [key, 0]
+            memo[method_key] = [retained_key, existing + count]
+          end
+        end
+
+        merged.values.to_h
+      end
+
+      def source_identity(key)
+        _class_name, *identity = SourceFile::RubyDataParser.call(key)
+        identity
       end
     end
   end

data/lib/simplecov/result_adapter.rb

@@ -27,13 +27,14 @@ module SimpleCov
 
     # Pre-0.18 resultsets pointed each filename straight at a line-coverage
     # array; everything since uses the `{lines:, branches:, methods:}`
-    # shape. Newer entries also need their methods table massaged before
-    # downstream code merges across processes.
+    # shape. Newer entries also need their methods and branches tables
+    # massaged before downstream code reports or merges them.
     def adapt_one(file_name, cover_statistic)
       return {"lines" => cover_statistic} if cover_statistic.is_a?(Array)
 
       adapt_oneshot_lines_if_needed(file_name, cover_statistic)
       normalize_method_keys(cover_statistic)
+      aggregate_duplicated_branches(cover_statistic)
       cover_statistic
     end
 
@@ -59,20 +60,53 @@ module SimpleCov
     SINGLETON_WRAPPER_PATTERN = /\A#<Class:([A-Z_][\w:]*)>\z/
     private_constant :SINGLETON_WRAPPER_PATTERN
 
+    # Ruby's method coverage records one entry per RECEIVER, not per source
+    # location: a block handed to `define_method` / `define_singleton_method`
+    # from a shared code path (a module's `included` hook, a builder) yields
+    # a separate `[receiver, name, location]` entry for every class it's
+    # defined on, all pointing at the same source. A file-based report can
+    # only express "was the method at this location ever executed", so
+    # entries are aggregated by (name, location), summing hits — otherwise
+    # each receiver whose copy never ran shows as a phantom uncovered method
+    # on a line whose line coverage is 100% (issue #1234). The first entry's
+    # (normalized) receiver is kept for display.
     def normalize_method_keys(cover_statistic)
       methods = cover_statistic[:methods]
       return unless methods
 
-      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)
-                                  .sub(SINGLETON_WRAPPER_PATTERN, '\1')
-        # Keys may collide after normalization (anonymous classes sharing a
-        # method name, or singleton + instance forms of a module_function method).
-        normalized[normalized_key] = normalized.fetch(normalized_key, 0) + count
+      aggregated = {} #: Hash[untyped, [untyped, Integer]]
+      methods.each_with_object(aggregated) do |(key, count), memo|
+        identity = key[1..] #: Array[untyped]
+        retained_key, existing = memo[identity] || [normalize_method_key(key), 0]
+        memo[identity] = [retained_key, existing + count]
       end
+      cover_statistic[:methods] = aggregated.values.to_h
+    end
+
+    def normalize_method_key(key)
+      normalized_key = key.dup
+      normalized_key[0] = key[0].to_s
+                                .gsub(ADDRESS_PATTERN, ADDRESS_PLACEHOLDER)
+                                .sub(SINGLETON_WRAPPER_PATTERN, '\1')
+      normalized_key
+    end
+
+    # Ruby's eval coverage records a fresh set of branch entries for every
+    # COMPILE of an eval'd string: a template rendered through multiple view
+    # classes (e.g. hanami-view compiles each template once per view) yields
+    # several `[:if, id, location]` conditions at identical coordinates in
+    # the same file, each counting only the renders that flowed through that
+    # compile. Reported as-is they inflate the branch denominator and turn a
+    # side covered under a different compile into a phantom miss (issue
+    # #1235). Aggregate them by (type, location) — combining a branches hash
+    # with an empty one dedups within it, since BranchesCombiner keys arms
+    # on location identity. Regular (non-eval) source can never produce two
+    # conditions at the same location, so this is a no-op outside eval.
+    def aggregate_duplicated_branches(cover_statistic)
+      branches = cover_statistic[:branches]
+      return unless branches
+
+      cover_statistic[:branches] = Combine::BranchesCombiner.combine(branches, {})
     end
 
     def adapt_oneshot_lines_if_needed(file_name, cover_statistic)

data/lib/simplecov/static_coverage_extractor/condition_folding.rb

@@ -0,0 +1,49 @@
+# 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
+      # 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.
+      STATIC_CONDITION_TYPES = [
+        ::Prism::IntegerNode, ::Prism::FloatNode, ::Prism::RationalNode,
+        ::Prism::ImaginaryNode, ::Prism::SymbolNode, ::Prism::StringNode,
+        ::Prism::TrueNode, ::Prism::FalseNode, ::Prism::NilNode
+      ].freeze
+
+    private
+
+      # Parentheses are transparent to the fold (`if (1)` folds like
+      # `if 1`), so see through a single parenthesized expression. 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 static_condition?(node)
+        node = unwrap_parentheses(node)
+        STATIC_CONDITION_TYPES.any? { |type| node.is_a?(type) }
+      end
+
+      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.size == 1
+
+          current = body.body.first
+        end
+        current
+      end
+    end
+  end
+end

data/lib/simplecov/static_coverage_extractor/location_conventions.rb

@@ -6,7 +6,11 @@ module SimpleCov
     # 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.
+    # 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")
 
@@ -59,24 +63,27 @@ module SimpleCov
       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.
+      # 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 if_like_location(node, type) if LEGACY_COVERAGE_LOCATIONS || type != :if
+        return point_at_end(node.predicate.location) if empty_arm_collapses?(node, type)
 
-        point_at_end(node.predicate.location)
+        if_like_location(node, type)
       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).
+      # `subsequent` / `consequent` and UnlessNode `else_clause` /
+      # `consequent`, both depending on Prism version (resolved to
+      # `IF_NODE_SUBSEQUENT_METHOD` / `ELSE_CLAUSE_METHOD` at load time).
+      # 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
+        sub = if_like_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
@@ -84,23 +91,35 @@ module SimpleCov
         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.
+        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,
-      # 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).
+      # 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)
         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,
@@ -118,10 +137,13 @@ module SimpleCov
       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
+        # 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 = case_node.public_send(ELSE_CLAUSE_METHOD)&.statements
+        content << else_statements.location if else_statements
+        content
       end
 
       # Resolve the source range Coverage attributes to a synthetic-or-real
@@ -130,29 +152,96 @@ module SimpleCov
       # 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
+        else_clause = node.public_send(ELSE_CLAUSE_METHOD)
+        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)
 
-        LEGACY_COVERAGE_LOCATIONS ? node.location : node.else_clause.location
+        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)
+        end_loc = node.closing_loc || node.arguments&.location || node.message_loc
+        PointLocation.new(
+          start_line: node.location.start_line, start_column: node.location.start_column,
+          end_line: end_loc.end_line, end_column: end_loc.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
+
+      # The `else`/`elsif` clause of an if-like node, under whichever
+      # accessor this Prism version exposes (see the two *_METHOD
+      # constants).
+      def if_like_subsequent(node)
+        node.is_a?(::Prism::IfNode) ? node.public_send(IF_NODE_SUBSEQUENT_METHOD) : node.public_send(ELSE_CLAUSE_METHOD)
+      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/value_position.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  module StaticCoverageExtractor
+    # Ruby 3.3 value-position analysis for the extractor's legacy branch
+    # conventions (see LocationConventions and the #1233 audit).
+    #
+    # On Ruby 3.3, the source range Coverage assigns to an EMPTY branch arm
+    # depends on whether its construct is in value position — its result is
+    # the method's return value — or void position, where the result is
+    # discarded. Value position keeps the whole-construct range; void
+    # collapses the arm to a point at its header's end. Ruby 3.4 dropped the
+    # distinction, so this pass only runs on legacy Rubies.
+    #
+    # "Value position" here is narrower than general value-use: it is
+    # strictly method-return (tail) position. It reaches a node only through
+    # statement tails and `if`/`unless`/`when` arms. Assignments, blocks,
+    # lambdas, method arguments, `case/in` arms, and loop bodies all discard
+    # it (Coverage treats their empty arms as void). So `tail_children`
+    # names the constructs that forward tail position and everything else
+    # falls through to the void default.
+    module ValuePositions
+    module_function
+
+      # simplecov:disable
+      # This whole pass runs only on legacy Rubies (the modern dogfood
+      # never calls it), so its lines can't be covered on the CI Ruby that
+      # enforces 100%. Behavior is pinned instead by the differential
+      # tuple-equivalence spec, which runs against real Coverage on 3.3.
+
+      # An identity set (a `compare_by_identity` Hash used as a set) of the
+      # Prism nodes Coverage treats as being in value position.
+      def call(root)
+        positions = {} #: Hash[untyped, bool]
+        positions.compare_by_identity
+        mark(root, true, positions)
+        positions
+      end
+
+      def mark(node, in_value, positions)
+        return unless node.is_a?(::Prism::Node)
+
+        positions[node] = true if in_value
+        children = tail_children(node, in_value)
+        node.compact_child_nodes.each do |child|
+          mark(child, children.any? { |c| c.equal?(child) }, positions)
+        end
+      end
+
+      # The children of `node` that inherit its tail position; empty for the
+      # void default. A method body is a tail context even when the `def`
+      # itself is not (the method still returns its last expression), so it
+      # is included regardless of `in_value`.
+      def tail_children(node, in_value)
+        # A method body is a tail context even when the `def` is not.
+        return [node.body] if node.is_a?(::Prism::DefNode)
+        return [] unless in_value
+
+        case node
+        when ::Prism::StatementsNode then [node.body.last]
+        when ::Prism::IfNode, ::Prism::UnlessNode then [node.statements, subsequent(node)]
+        when ::Prism::CaseNode then [*node.conditions, else_clause(node)]
+        when ::Prism::ElseNode, ::Prism::WhenNode, ::Prism::BeginNode, ::Prism::ProgramNode then [node.statements]
+        else []
+        end
+      end
+
+      # The `else`/`elsif` clause of an if-like node, and the `else` clause
+      # of a case, under whichever accessor this Prism version exposes.
+      # `case/in` (CaseMatchNode) is intentionally not a tail construct: its
+      # `in` arms and `else` both discard tail position.
+      def subsequent(node)
+        node.is_a?(::Prism::IfNode) ? node.public_send(IF_NODE_SUBSEQUENT_METHOD) : else_clause(node)
+      end
+
+      def else_clause(node)
+        node.public_send(ELSE_CLAUSE_METHOD)
+      end
+      # simplecov:enable
+    end
+  end
+end

data/lib/simplecov/static_coverage_extractor/visitor.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
+require_relative "condition_folding"
 require_relative "location_conventions"
 require_relative "method_collector"
+require_relative "value_position"
 
 module SimpleCov
   module StaticCoverageExtractor
@@ -19,6 +21,22 @@ module SimpleCov
       else
         :consequent
       end
+
+    # The same Prism 1.3 rename hit the `else` accessor on `UnlessNode`,
+    # `CaseNode`, and `CaseMatchNode` (all three: `consequent` ->
+    # `else_clause`). Ruby 3.3's stdlib Prism (0.19) only exposes
+    # `consequent`, so reaching for `else_clause` there raised
+    # NoMethodError inside the extractor — `call` swallowed it and the
+    # whole file silently fell back to no simulated data for any
+    # `unless`/`else` or empty-arm `case`. Resolve the name once, like
+    # IF_NODE_SUBSEQUENT_METHOD. All three nodes renamed together, so one
+    # constant (probed off CaseNode) covers them.
+    ELSE_CLAUSE_METHOD =
+      if ::Prism::CaseNode.method_defined?(:else_clause)
+        :else_clause
+      else
+        :consequent
+      end
     # simplecov:enable
 
     # Prism visitor that accumulates branch and method tuples in the
@@ -33,6 +51,9 @@ module SimpleCov
       # Source-range resolution, including the per-Ruby-version Coverage
       # conventions. See issue #1226.
       include LocationConventions
+      # Which literal `if`/`unless`/ternary conditions the compiler folds
+      # away (so we emit no branch for them).
+      include ConditionFolding
 
       attr_reader :branches, :methods
 
@@ -42,6 +63,19 @@ module SimpleCov
         @methods = {}
         @next_id = 0
         @class_stack = []
+        @value_positions = nil
+      end
+
+      # Entry point for a parsed file. On legacy Rubies the location of an
+      # empty branch arm depends on whether its construct is in value
+      # (tail) position, so precompute that once for the whole tree before
+      # emitting anything. Modern Rubies don't need it (see
+      # LocationConventions), so the pass is skipped there.
+      def visit_program_node(node)
+        # simplecov:disable branch — legacy-only arm; unreachable on the modern dogfood Ruby
+        @value_positions = ValuePositions.call(node) if LEGACY_COVERAGE_LOCATIONS
+        # simplecov:enable branch
+        super
       end
 
       # `if` / `unless` / postfix-if / postfix-unless / ternary all parse
@@ -51,12 +85,12 @@ module SimpleCov
       # missing, Coverage synthesizes a `:else` arm attributed to the
       # whole condition's range — we do the same.
       def visit_if_node(node)
-        emit_if_like(node, :if)
+        emit_if_like(node, :if) unless static_condition?(node.predicate)
         super
       end
 
       def visit_unless_node(node)
-        emit_if_like(node, :unless)
+        emit_if_like(node, :unless) unless static_condition?(node.predicate)
         super
       end
 
@@ -78,6 +112,24 @@ module SimpleCov
         super
       end
 
+      # One-line pattern matching: `x => pattern` (MatchRequiredNode) and
+      # `x in pattern` (MatchPredicateNode). Ruby 3.3's Coverage reports
+      # these as a `:case` with an `:in` and an `:else` arm; 3.4 dropped
+      # them entirely (no branch), so this is legacy-only. The two forms
+      # differ only in where Coverage anchors the synthesized `:else`:
+      # `=>` uses the whole expression, `in` uses just the pattern.
+      # simplecov:disable branch — legacy-only arms; unreachable on the modern dogfood Ruby
+      def visit_match_required_node(node)
+        emit_oneline_pattern(node, node.location) if LEGACY_COVERAGE_LOCATIONS
+        super
+      end
+
+      def visit_match_predicate_node(node)
+        emit_oneline_pattern(node, node.pattern.location) if LEGACY_COVERAGE_LOCATIONS
+        super
+      end
+      # simplecov:enable branch
+
       # `while` / `until` loops get a single `:body` arm. No synthetic
       # else (the loop either runs the body or doesn't).
       def visit_while_node(node)
@@ -105,13 +157,22 @@ module SimpleCov
       end
 
       def emit_safe_navigation(node)
-        loc = node.location
+        loc = safe_navigation_location(node)
         @branches[build_tuple(:"&.", loc)] = {
           build_tuple(:then, loc) => 0,
           build_tuple(:else, loc) => 0
         }
       end
 
+      # simplecov:disable — legacy-only (3.4 emits no branch for one-line patterns)
+      def emit_oneline_pattern(node, else_location)
+        @branches[build_tuple(:case, node.location)] = {
+          build_tuple(:in, node.pattern.location) => 0,
+          build_tuple(:else, else_location) => 0
+        }
+      end
+      # simplecov:enable
+
       def emit_case_like(node, when_type)
         arms = node.conditions.to_h do |when_node|
           [build_tuple(when_type, case_arm_location(node, when_node, when_type)), 0]

data/lib/simplecov/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: simplecov
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors:
 - Erik Berlin
@@ -137,8 +137,10 @@ files:
 - lib/simplecov/source_file/source_loader.rb
 - lib/simplecov/source_file/statistics.rb
 - lib/simplecov/static_coverage_extractor.rb
+- lib/simplecov/static_coverage_extractor/condition_folding.rb
 - lib/simplecov/static_coverage_extractor/location_conventions.rb
 - lib/simplecov/static_coverage_extractor/method_collector.rb
+- lib/simplecov/static_coverage_extractor/value_position.rb
 - lib/simplecov/static_coverage_extractor/visitor.rb
 - lib/simplecov/useless_results_remover.rb
 - lib/simplecov/version.rb
@@ -152,9 +154,9 @@ licenses:
 metadata:
   bug_tracker_uri: https://github.com/simplecov-ruby/simplecov/issues
   changelog_uri: https://github.com/simplecov-ruby/simplecov/blob/main/CHANGELOG.md
-  documentation_uri: https://www.rubydoc.info/gems/simplecov/1.0.1
+  documentation_uri: https://www.rubydoc.info/gems/simplecov/1.0.2
   mailing_list_uri: https://groups.google.com/forum/#!forum/simplecov
-  source_code_uri: https://github.com/simplecov-ruby/simplecov/tree/v1.0.1
+  source_code_uri: https://github.com/simplecov-ruby/simplecov/tree/v1.0.2
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths: