simplecov 0.22.0 → 1.3.0

data/lib/simplecov/static_coverage_extractor/condition_folding.rb

@@ -0,0 +1,155 @@
+# 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: 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 fold
+      # it replaced still differs on 3.3, where `__FILE__` folds.
+      FOLDS_SOURCE_FILE = Gem::Version.new(RUBY_VERSION) < Gem::Version.new("3.4")
+      # 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
+
+      # 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,
+        ::Prism::ImaginaryNode, ::Prism::SymbolNode, ::Prism::StringNode,
+        ::Prism::TrueNode, ::Prism::FalseNode, ::Prism::NilNode,
+        ::Prism::SourceLineNode, ::Prism::SourceEncodingNode, ::Prism::LambdaNode,
+        *(::Prism::SourceFileNode if FOLDS_SOURCE_FILE)
+      ].freeze
+      # simplecov:enable branch
+
+      FALSY_CONDITION_TYPES = [::Prism::FalseNode, ::Prism::NilNode].freeze
+
+      # 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
+
+      # A multi-statement paren condition (`if (1; 2)`) folds by its last
+      # expression only when every leading statement is eliminated when
+      # 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,
+        ::Prism::TrueNode, ::Prism::FalseNode, ::Prism::NilNode,
+        ::Prism::SourceLineNode, ::Prism::SourceFileNode, ::Prism::SourceEncodingNode, ::Prism::RegularExpressionNode
+      ].freeze
+
+      # 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::LocalVariableReadNode,
+        ::Prism::InstanceVariableReadNode, ::Prism::DefinedNode
+      ].freeze
+
+      private
+
+      # `visit` is nil-safe, so a missing arm just visits nothing.
+      def visit_folded_arms(verdict, truthy_arm, falsy_arm)
+        visit(verdict.equal?(:truthy) ? truthy_arm : falsy_arm)
+      end
+
+      # `: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.
+      #
+      # 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.instance_of?(type) }) ? :falsy : :truthy
+      end
+
+      # `unwrapped` differing from `node` is what says parentheses were seen
+      # through.
+      def foldable?(node, unwrapped)
+        return false unless STATIC_CONDITION_TYPES.any? { |type| unwrapped.instance_of?(type) }
+
+        unwrapped.equal?(node) || PAREN_OPAQUE_TYPES.none? { |type| unwrapped.instance_of?(type) }
+      end
+
+      # 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.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.instance_of?(Prism::StatementsNode)
+
+          statements = body.body
+          break unless statements.take(statements.size - 1).all? { |leading| eliminable_when_discarded?(leading) }
+
+          current = statements.last
+        end
+        current
+      end
+
+      def eliminable_when_discarded?(node)
+        return true if static_container_literal?(node)
+        return true if ELIMINABLE_READ_TYPES.any? { |type| node.instance_of?(type) }
+
+        node.instance_of?(Prism::ParenthesesNode) &&
+          node.body.instance_of?(Prism::StatementsNode) &&
+          node.body.body.all? { |statement| eliminable_when_discarded?(statement) }
+      end
+
+      def static_container_literal?(node)
+        return true if STATIC_LITERAL_LEAF_TYPES.any? { |type| node.instance_of?(type) }
+
+        static_container?(node)
+      end
+
+      def static_container?(node)
+        case node
+        when Prism::ArrayNode then static_array_literal?(node)
+        when Prism::HashNode then static_hash_literal?(node)
+        when Prism::RangeNode then static_range_literal?(node)
+        else false
+        end
+      end
+
+      def static_array_literal?(node)
+        node.elements.all? { |element| container_contents_eliminable?(element) }
+      end
+
+      def static_hash_literal?(node)
+        node.elements.all? do |element|
+          element.instance_of?(Prism::AssocNode) &&
+            container_contents_eliminable?(element.key) && container_contents_eliminable?(element.value)
+        end
+      end
+
+      def static_range_literal?(node)
+        [node.left, node.right].all? { |bound| bound.nil? || container_contents_eliminable?(bound) }
+      end
+
+      def container_contents_eliminable?(node)
+        CONTAINER_CONTENTS_NEED_STATIC_LITERALS ? static_container_literal?(node) : eliminable_when_discarded?(node)
+      end
+    end
+  end
+end

data/lib/simplecov/static_coverage_extractor/location_conventions.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+require_relative "prism_compat"
+
+module SimpleCov
+  module StaticCoverageExtractor
+    # The source ranges Ruby's Coverage assigns to branch conditions and arms,
+    # resolved from Prism nodes. Simulated entries only ever merge with real
+    # entries produced by the running Ruby, and CRuby 3.4 changed several of
+    # these conventions, so every resolver here emits whichever shape this
+    # Ruby's Coverage uses (#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.
+    #
+    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. 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
+
+      # Which arm of each conditional below runs is fixed by the running Ruby's
+      # version, so no single process can cover both sides.
+
+      # 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 unless LEGACY_COVERAGE_LOCATIONS && type.equal?(:if) && elsif_node?(node)
+
+        span(node, legacy_content_end(node))
+      end
+
+      def elsif_node?(node)
+        keyword = node.if_keyword_loc
+        !keyword.nil? && keyword.slice.eql?("elsif")
+      end
+
+      # 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.instance_of?(Prism::IfNode)
+          sub = PrismCompat.subsequent(tail)
+          break unless sub
+
+          tail = sub
+        end
+        return tail.statements || tail.predicate if tail.instance_of?(Prism::IfNode)
+
+        tail.statements || tail.else_keyword_loc
+      end
+
+      def if_like_then_location(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
+
+      # 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, 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
+
+      def empty_else_location(node, sub, type)
+        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
+
+      def case_arm_location(case_node, when_node, when_type)
+        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, legacy_case_tail_end(case_node, when_node))
+      end
+
+      # 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
+      end
+
+      def following_case_content(case_node, when_node)
+        clauses = case_node.conditions
+        # A when-clause's own location ends where its body ends (or at its
+        # 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] if else_statements
+        content
+      end
+
+      def else_arm_location(node)
+        else_clause = PrismCompat.else_clause(node)
+        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
+      end
+
+      def loop_body_location(node)
+        return legacy_do_while_body_location(node) if LEGACY_COVERAGE_LOCATIONS && begin_modifier_loop?(node)
+        return node.statements if node.statements
+        return point_at_end(node.predicate) if LEGACY_COVERAGE_LOCATIONS
+
+        node
+      end
+
+      # 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
+        inner = begin_node.statements
+        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, node.closing_loc || node.arguments || node.message_loc)
+      end
+
+      def span(from, to)
+        PointLocation.new(
+          start_line: from.start_line, start_column: from.start_column,
+          end_line: to.end_line, end_column: to.end_column
+        )
+      end
+
+      def point_at_end(location)
+        PointLocation.new(
+          start_line: location.end_line, start_column: location.end_column,
+          end_line: location.end_line, end_column: location.end_column
+        )
+      end
+
+      # 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.equal?(:if) unless LEGACY_COVERAGE_LOCATIONS
+
+        !value_position?(node)
+      end
+
+      # `@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
+    end
+  end
+end

data/lib/simplecov/static_coverage_extractor/method_collector.rb

@@ -0,0 +1,45 @@
+# 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. Module and Class are both namespaces here, since `Coverage` reports
+    # both as the constant.
+    module MethodCollector
+      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 or module, or `Object` at the top
+      # level, matching `Coverage`'s convention.
+      def visit_def_node(node)
+        class_name = @class_stack.last || "Object"
+        key = [class_name, node.name, node.start_line, node.start_column, node.end_line, node.end_column]
+        @methods[key] = 0
+        super
+      end
+
+      private
+
+      def constant_name(node)
+        return "<anonymous>" if node.nil?
+        return node.slice if node.respond_to?(:slice)
+
+        node.to_s
+      end
+
+      def with_class(name)
+        @class_stack.push(name)
+        yield
+      ensure
+        @class_stack.pop
+      end
+    end
+  end
+end

data/lib/simplecov/static_coverage_extractor/prism_compat.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  module StaticCoverageExtractor
+    # The Prism 1.3 accessor renames for the trailing clause of conditional
+    # nodes, resolved once at load so the per-node hot paths stay branch-free.
+    # Ruby 3.3's stdlib Prism predates the renames; 3.4+ and any installed prism
+    # gem post-date them, and reaching for the modern name on the old one raised
+    # NoMethodError inside the extractor, which `call` swallowed, silently
+    # falling back to no simulated data.
+    #
+    # This lives in its own file, required by every consumer, because the
+    # constants are referenced from several extractor files and defining them
+    # after those files were loaded worked only while the references happened at
+    # call time: a load-order trap for the next editor.
+    module PrismCompat
+      extend self
+
+      # simplecov:disable
+      IF_NODE_SUBSEQUENT_METHOD =
+        if Prism::IfNode.method_defined?(:subsequent)
+          :subsequent
+        else
+          :consequent
+        end
+
+      ELSE_CLAUSE_METHOD =
+        if Prism::CaseNode.method_defined?(:else_clause)
+          :else_clause
+        else
+          :consequent
+        end
+      # simplecov:enable
+
+      def subsequent(node)
+        node.instance_of?(Prism::IfNode) ? node.public_send(IF_NODE_SUBSEQUENT_METHOD) : else_clause(node)
+      end
+
+      # The rename hit `UnlessNode`, `CaseNode`, and `CaseMatchNode` together, so
+      # one constant probed off CaseNode covers all three.
+      def else_clause(node)
+        node.public_send(ELSE_CLAUSE_METHOD)
+      end
+    end
+  end
+end

data/lib/simplecov/static_coverage_extractor/value_position.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative "prism_compat"
+
+module SimpleCov
+  module StaticCoverageExtractor
+    # Ruby 3.3 value-position analysis for the extractor's legacy branch
+    # conventions (#1233). On 3.3 the source range Coverage assigns to an empty
+    # branch arm depends on whether its construct is in value position, where 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.
+    #
+    # "Value position" here 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, so `tail_children` names the constructs that forward
+    # tail position and everything else falls through to the void default.
+    module ValuePositions
+      extend self
+
+      # An identity set of the Prism nodes Coverage treats as being in value
+      # position. This pass runs natively only on legacy Rubies; elsewhere the
+      # specs drive it directly, pinned by the differential tuple-equivalence spec
+      # against real Coverage on 3.3.
+      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
+
+      # A method body is a tail context even when the `def` itself is not, since
+      # the method still returns its last expression, so it is included regardless
+      # of `in_value`. `case/in` is intentionally absent: its `in` arms and `else`
+      # both discard tail position.
+      def tail_children(node, in_value)
+        return [node.body] if node.instance_of?(Prism::DefNode)
+        return [] unless in_value
+
+        case node
+        when Prism::StatementsNode then [node.body.last]
+        when Prism::IfNode, Prism::UnlessNode then [node.statements, PrismCompat.subsequent(node)]
+        when Prism::CaseNode then [*node.conditions, PrismCompat.else_clause(node)]
+        when Prism::ElseNode, Prism::WhenNode, Prism::BeginNode, Prism::ProgramNode then [node.statements]
+        else []
+        end
+      end
+    end
+  end
+end

data/lib/simplecov/static_coverage_extractor/visitor.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require_relative "prism_compat"
+require_relative "condition_folding"
+require_relative "location_conventions"
+require_relative "method_collector"
+require_relative "value_position"
+
+module SimpleCov
+  module StaticCoverageExtractor
+    # Prism visitor that accumulates branch and method tuples in the shape
+    # Ruby's `Coverage` reports. Tuple ids are sequential across the file like
+    # `Coverage`'s, but the numbering order can differ. That's fine: the
+    # combiners intern on source span and the report output drops ids, so
+    # nothing downstream compares them.
+    class Visitor < Prism::Visitor
+      include MethodCollector
+      include LocationConventions
+      include ConditionFolding
+
+      attr_reader :branches, :methods
+
+      # Prism's Visitor is a stateless dispatch table whose initializer is
+      # Object's, so no mutation of the `super` call can be told apart. It
+      # stays for the day that stops being true.
+      # mutant:disable
+      def initialize
+        super
+        @branches = {}
+        @methods = {}
+        @next_id = 0
+        @class_stack = []
+        @value_positions = nil
+      end
+
+      # 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.
+      def visit_program_node(node)
+        @value_positions = ValuePositions.call(node) if LEGACY_COVERAGE_LOCATIONS
+        super
+      end
+
+      # `if` / `unless` / postfix / ternary all parse as IfNode (or UnlessNode).
+      # Both carry a `then` arm 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, and so do we.
+      #
+      # A folded condition emits no tuple, and only its live arm is descended
+      # into: the compiler eliminates the dead arm's entire subtree, so a branch
+      # or method nested there would be a phantom no loaded run can produce.
+      def visit_if_node(node)
+        verdict = folded_condition(node.predicate)
+        return visit_folded_arms(verdict, node.statements, PrismCompat.subsequent(node)) if verdict
+
+        emit_if_like(node, :if)
+        super
+      end
+
+      def visit_unless_node(node)
+        verdict = folded_condition(node.predicate)
+        return visit_folded_arms(verdict, PrismCompat.else_clause(node), node.statements) if verdict
+
+        emit_if_like(node, :unless)
+        super
+      end
+
+      def visit_call_node(node)
+        emit_safe_navigation(node) if node.respond_to?(:safe_navigation?) && node.safe_navigation?
+        super
+      end
+
+      # 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` and `x in pattern`. Ruby 3.3's
+      # Coverage reports these as a `:case` with an `:in` and an `:else` arm;
+      # 3.4 dropped them entirely, 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.
+      def visit_match_required_node(node)
+        emit_oneline_pattern(node, node) if LEGACY_COVERAGE_LOCATIONS
+        super
+      end
+
+      def visit_match_predicate_node(node)
+        emit_oneline_pattern(node, node.pattern) if LEGACY_COVERAGE_LOCATIONS
+        super
+      end
+
+      # A loop gets a single `:body` arm and no synthetic else.
+      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 but expose the trailing arm under
+      # different accessors, which `if_like_else_location` hides.
+      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
+
+      def emit_oneline_pattern(node, else_span)
+        @branches[build_tuple(:case, node)] = {
+          build_tuple(:in, node.pattern) => 0,
+          build_tuple(:else, else_span) => 0
+        }
+      end
+
+      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)] = arms
+      end
+
+      def emit_loop(node, type)
+        cond_tuple = build_tuple(type, node)
+        @branches[cond_tuple] = {build_tuple(:body, loop_body_location(node)) => 0}
+      end
+
+      # `span` is anything that answers the four position accessors: a location
+      # from LocationConventions, or the node itself where the range wanted is
+      # the node's own.
+      def build_tuple(type, span)
+        id = @next_id
+        @next_id += 1
+        [type, id, span.start_line, span.start_column, span.end_line, span.end_column]
+      end
+    end
+  end
+end