simplecov 0.22.0 → 1.0.2

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

@@ -0,0 +1,247 @@
+# 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 issues #1226 / #1233.
+    #
+    # rubocop:disable Metrics/ModuleLength -- one cohesive home for the
+    # per-construct, per-Ruby-version Coverage location conventions;
+    # splitting it would scatter closely-related resolvers.
+    module LocationConventions
+      LEGACY_COVERAGE_LOCATIONS = Gem::Version.new(RUBY_VERSION) < Gem::Version.new("3.4")
+
+      # A zero-width stand-in for Prism locations, for the arms Coverage
+      # anchors to a point rather than a range.
+      PointLocation = Data.define(:start_line, :start_column, :end_line, :end_column)
+
+    private
+
+      # simplecov:disable
+      # Which arm of each conditional below runs is fixed by the running
+      # Ruby's version, so no single process can cover both sides, and
+      # the legacy-only helpers are unreachable on modern Rubies (and
+      # vice versa). The "runtime tuple equivalence" spec exercises this
+      # module against real Coverage output on every CI Ruby.
+
+      # The range Coverage assigns to an if-like node itself. Modern
+      # CRuby uses the node's full source range for every form; 3.2/3.3
+      # end an `elsif` clause's range at its last content instead of the
+      # shared `end` keyword the clause doesn't own.
+      def if_like_location(node, type)
+        return node.location unless LEGACY_COVERAGE_LOCATIONS && type == :if && elsif_node?(node)
+
+        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; with an empty then body the arm collapses to a zero-width
+      # point at the predicate's end — always on a modern `if`, and on
+      # legacy Rubies only when the construct is in void position (a
+      # trailing statement discards its value). In value (tail) position,
+      # legacy Rubies and `unless` fall back to the node's range.
+      def if_like_then_location(node, type)
+        return node.statements.location if node.statements
+        return point_at_end(node.predicate.location) if empty_arm_collapses?(node, type)
+
+        if_like_location(node, type)
+      end
+
+      # Resolve the source range Coverage attributes to a real-or-synthetic
+      # `:else` arm of an if-like construct. IfNode uses
+      # `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 = 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
+        # (which is what created phantom unmergeable arms).
+        return if_like_location(sub, :if) if sub.is_a?(::Prism::IfNode)
+        return sub.statements.location if sub.statements
+
+        empty_else_location(node, sub, type)
+      end
+
+      # Location of an empty explicit `else`: a modern `if` uses the
+      # else..end span; a legacy Ruby in void position collapses to a point
+      # at the `else` keyword's end; otherwise (legacy value position, or
+      # `unless`) it uses the condition's range.
+      def empty_else_location(node, sub, type)
+        return sub.location if !LEGACY_COVERAGE_LOCATIONS && type == :if
+        return point_at_end(sub.else_keyword_loc) if LEGACY_COVERAGE_LOCATIONS && !value_position?(node)
+
+        if_like_location(node, type)
+      end
+
+      # Arm location for a when/in clause: its body statements, or — when
+      # the body is empty — the clause's own range on modern Rubies, a
+      # point at the pattern's end for a legacy `in`, and for a legacy
+      # `when` a point at the clause's end in void position or the tail
+      # convention (keyword through the case's remaining content) in value.
+      def case_arm_location(case_node, when_node, when_type)
+        return when_node.statements.location if when_node.statements
+        return when_node.location unless LEGACY_COVERAGE_LOCATIONS
+        return point_at_end(when_node.pattern.location) if when_type == :in
+        return point_at_end(when_node.location) unless value_position?(case_node)
+
+        legacy_when_value_location(case_node, when_node)
+      end
+
+      def legacy_when_value_location(case_node, when_node)
+        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
+        # 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
+      # `: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 = 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)
+
+        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/method_collector.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  module StaticCoverageExtractor
+    # Visitor mixin that collects method tuples and tracks the lexical
+    # class / module nesting that names them, in the shape Ruby's
+    # `Coverage` reports methods. Mixed into `Visitor`, it shares that
+    # visitor's `@methods` / `@class_stack` state and keeps the
+    # method-collection concern separate from branch extraction.
+    module MethodCollector
+      # Track class/module nesting so method tuples carry the lexical
+      # class name. Module + Class are both treated as namespaces here
+      # since `Coverage` reports both as the constant.
+      def visit_class_node(node)
+        with_class(constant_name(node.constant_path)) { super }
+      end
+
+      def visit_module_node(node)
+        with_class(constant_name(node.constant_path)) { super }
+      end
+
+      # `def name(...)` and `def self.name(...)` both produce DefNode.
+      # The class context is the surrounding lexical class/module (or
+      # `Object` at the top level, matching `Coverage`'s convention).
+      def visit_def_node(node)
+        loc = node.location
+        class_name = @class_stack.last || "Object"
+        key = [class_name, node.name, loc.start_line, loc.start_column, loc.end_line, loc.end_column]
+        @methods[key] = 0
+        super
+      end
+
+    private
+
+      # Render a constant path (e.g., `Foo::Bar`) as its source-form
+      # string. Defensive nil / to_s fallbacks: ClassNode and ModuleNode
+      # always carry a constant_path in practice.
+      # simplecov:disable
+      def constant_name(node)
+        return "<anonymous>" if node.nil?
+        return node.slice if node.respond_to?(:slice)
+
+        node.to_s
+      end
+      # simplecov:enable
+
+      def with_class(name)
+        @class_stack.push(name)
+        yield
+      ensure
+        @class_stack.pop
+      end
+    end
+  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

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+require_relative "condition_folding"
+require_relative "location_conventions"
+require_relative "method_collector"
+require_relative "value_position"
+
+module SimpleCov
+  module StaticCoverageExtractor
+    # `Prism::IfNode#subsequent` was renamed from `consequent` in Prism
+    # 1.3 (Dec 2024). Ruby 3.3's stdlib still ships an older Prism that
+    # only exposes `consequent`; 3.4+ and any project that's done
+    # `gem install prism` exposes `subsequent`. Resolve the method name
+    # ONCE here so the per-node hot path stays branch-free. The
+    # not-taken arm on whichever Prism version we're on can't be
+    # exercised by our own dogfood (we only run on one Prism at a time).
+    # simplecov:disable
+    IF_NODE_SUBSEQUENT_METHOD =
+      if ::Prism::IfNode.method_defined?(:subsequent)
+        :subsequent
+      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
+    # shape Ruby's `Coverage` reports. Tuple ids are sequential across
+    # the file — `Coverage` uses sequential ids too, so this matches the
+    # conventional shape. Only defined when Prism is loadable;
+    # `StaticCoverageExtractor.available?` is the runtime gate.
+    class Visitor < ::Prism::Visitor
+      # 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
+      # Which literal `if`/`unless`/ternary conditions the compiler folds
+      # away (so we emit no branch for them).
+      include ConditionFolding
+
+      attr_reader :branches, :methods
+
+      def initialize
+        super
+        @branches = {}
+        @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
+      # as IfNode (or UnlessNode). Both carry a `then` arm (the
+      # statements body) and an optional `subsequent` (an ElseNode for
+      # `else`, another IfNode for `elsif`). When the subsequent is
+      # 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) unless static_condition?(node.predicate)
+        super
+      end
+
+      def visit_unless_node(node)
+        emit_if_like(node, :unless) unless static_condition?(node.predicate)
+        super
+      end
+
+      def visit_call_node(node)
+        emit_safe_navigation(node) if node.respond_to?(:safe_navigation?) && node.safe_navigation?
+        super
+      end
+
+      # `case`/`when` and `case`/`in` (pattern matching) parse as CaseNode
+      # and CaseMatchNode respectively. When there's no explicit `else`,
+      # Coverage synthesizes one at the case's range.
+      def visit_case_node(node)
+        emit_case_like(node, :when)
+        super
+      end
+
+      def visit_case_match_node(node)
+        emit_case_like(node, :in)
+        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)
+        emit_loop(node, :while)
+        super
+      end
+
+      def visit_until_node(node)
+        emit_loop(node, :until)
+        super
+      end
+
+    private
+
+      # IfNode and UnlessNode share a shape (predicate + then body +
+      # 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 = 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
+        }
+      end
+
+      def emit_safe_navigation(node)
+        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]
+        end
+        arms[build_tuple(:else, else_arm_location(node))] = 0
+        @branches[build_tuple(:case, node.location)] = arms
+      end
+
+      def emit_loop(node, type)
+        cond_tuple = build_tuple(type, node.location)
+        @branches[cond_tuple] = {build_tuple(:body, loop_body_location(node)) => 0}
+      end
+
+      def build_tuple(type, location)
+        id = @next_id
+        @next_id += 1
+        [type, id, location.start_line, location.start_column, location.end_line, location.end_column]
+      end
+    end
+  end
+end