branchproof 0.5.0 → 0.7.0

data/lib/branchproof/coverage_index.rb

@@ -7,7 +7,7 @@ require "pathname"
 module Branchproof
   # Derives condition- and test-oriented rows from one report document.
   class CoverageIndex
-    attr_reader :conditions, :tests
+    attr_reader :conditions, :alternatives, :tests
 
     def initialize(document:)
       @document = symbolize(document || {})
@@ -27,6 +27,7 @@ module Branchproof
         @tests_by_id[id] = (@tests_by_id[id] || {}).merge(test) unless id.empty?
       end
       @conditions = build_conditions.freeze
+      @alternatives = build_alternatives.freeze
       @tests = build_tests.freeze
     end
 
@@ -62,7 +63,7 @@ module Branchproof
             id: condition[:id], decision_id: decision[:id], index: condition[:index],
             expression: condition[:expression],
             line: condition[:line], column: condition[:column], relative_path: relative_path(source[:relative_path]),
-            decision_expression: decision[:expression],
+            decision_expression: decision[:expression], kind: decision_kind(decision), context: decision[:context],
             status: @document[:analysis] ? (result[:status] || "NOT_PROVEN") : "NOT CALCULATED",
             observed_true: test_ids(observations[true]), observed_false: test_ids(observations[false]),
             short_circuited: test_ids(observations[:short_circuited]),
@@ -80,12 +81,69 @@ module Branchproof
       end
     end
 
+    def build_alternatives
+      records(@inventory, :decisions).flat_map do |decision|
+        next [] if decision[:support_status].to_s == "UNSUPPORTED"
+        next [] if boolean_decision?(decision)
+
+        source = @source_units_by_id[decision[:source_id].to_s] || {}
+        coverage = symbolize(analysis_for(decision)[:coverage] || {})[:alternative] || {}
+        coverage_rows = records(coverage, :alternatives).to_h { |row| [row[:alternative_id].to_s, row] }
+        vectors = @vectors_by_decision[decision[:id].to_s] || []
+        records(decision, :alternatives).map do |alternative|
+          alternative = symbolize(alternative)
+          evidence = { selected: [], not_selected: [], skipped: [] }
+          vectors.each do |vector|
+            value = vector_values(vector)[alternative[:index].to_i]
+            state = if value.nil?
+                      :skipped
+                    else
+                      (value ? :selected : :not_selected)
+                    end
+            evidence[state] << vector
+          end
+          row = symbolize(coverage_rows[alternative[:id].to_s] || {})
+          {
+            id: alternative[:id], alternative_id: alternative[:id], decision_id: decision[:id],
+            index: alternative[:index], expression: alternative[:expression],
+            line: alternative[:line], column: alternative[:column],
+            relative_path: relative_path(source[:relative_path]),
+            decision_expression: decision[:expression], kind: decision_kind(decision),
+            context: decision[:context],
+            status: @document[:analysis] ? alternative_status(row, evidence) : "NOT CALCULATED",
+            selected: row[:selected] || evidence_bucket(evidence[:selected]),
+            not_selected: row[:not_selected] || evidence_bucket(evidence[:not_selected]),
+            skipped: row[:skipped] || evidence_bucket(evidence[:skipped]),
+            vectors: evidence, missing: missing_alternative?(coverage, alternative)
+          }
+        end
+      end
+    end
+
     def build_tests
       by_id = @tests_by_id.transform_values do |test|
         { id: test[:id], name: display_name(test), relative_path: test_location(test)[0], line: test_location(test)[1],
           status: test[:status], phases: Array(test[:phase_counts]).to_h.keys.sort,
           observations: [], owns_witness: false }
       end
+      @alternatives.each do |alternative|
+        alternative[:vectors].each do |kind, vectors|
+          vectors.each do |vector|
+            Array(vector[:test_ids]).each do |id|
+              row = by_id[id.to_s] ||= { id: id, name: id, relative_path: nil, line: nil, status: "unknown",
+                                         phases: [], observations: [], owns_witness: false }
+              phase_map = symbolize(vector[:phases_by_test] || {})
+              phases = phase_map[id.to_s] || phase_map[id.to_sym] || []
+              row[:phases] |= Array(phases).map(&:to_s)
+              row[:observations] << { alternative_id: alternative[:id], expression: alternative[:expression],
+                                      relative_path: alternative[:relative_path], line: alternative[:line],
+                                      value: kind == :skipped ? nil : (kind == :selected), kind: :alternative,
+                                      alternative_state: kind.to_s, phases: phases.map(&:to_s).sort,
+                                      owns_witness: false }
+            end
+          end
+        end
+      end
       @conditions.each do |condition|
         condition[:vectors].each do |kind, vectors|
           next if kind == :unattributed
@@ -118,6 +176,36 @@ module Branchproof
       @analysis_by_decision[decision[:id].to_s] || {}
     end
 
+    def boolean_decision?(decision)
+      decision_kind(decision) == "boolean"
+    end
+
+    def decision_kind(decision)
+      kind = decision[:kind].to_s
+      kind.empty? ? "boolean" : kind
+    end
+
+    def evidence_bucket(vectors)
+      evidence = vectors.map do |vector|
+        { vector_id: vector[:id].to_s, test_ids: Array(vector[:test_ids]).map(&:to_s).uniq.sort,
+          unattributed_count: vector[:unattributed_count].to_i }
+      end
+      { observed: !vectors.empty?, vector_ids: evidence.map { |item| item[:vector_id] }.uniq.sort,
+        test_ids: evidence.flat_map { |item| item[:test_ids] }.uniq.sort,
+        unattributed_count: evidence.sum { |item| item[:unattributed_count] } }
+    end
+
+    def missing_alternative?(coverage, alternative)
+      Array(coverage[:missing_alternatives]).map(&:to_s).include?(alternative[:id].to_s)
+    end
+
+    def alternative_status(row, evidence)
+      status = row[:status].to_s
+      return status unless status.empty?
+
+      evidence[:selected].empty? ? "unexecuted" : "covered"
+    end
+
     def supporting_set_for(decision_id)
       Array(@document[:minima] || @document["minima"]).filter_map do |minimum|
         minimum = symbolize(minimum)

data/lib/branchproof/decision_syntax.rb

@@ -0,0 +1,294 @@
+# frozen_string_literal: true
+
+module Branchproof
+  # Discovers control-flow expressions whose truth is not represented by an
+  # ordinary Prism IfNode.  The records intentionally contain byte ranges and
+  # scalar metadata only; Prism nodes must not escape the source pass.
+  module DecisionSyntax
+    OR_WRITE_NODE_NAMES = %w[
+      CallOrWriteNode ClassVariableOrWriteNode ConstantOrWriteNode
+      ConstantPathOrWriteNode GlobalVariableOrWriteNode IndexOrWriteNode
+      InstanceVariableOrWriteNode LocalVariableOrWriteNode
+    ].freeze
+
+    AND_WRITE_NODE_NAMES = %w[
+      CallAndWriteNode ClassVariableAndWriteNode ConstantAndWriteNode
+      ConstantPathAndWriteNode GlobalVariableAndWriteNode IndexAndWriteNode
+      InstanceVariableAndWriteNode LocalVariableAndWriteNode
+    ].freeze
+
+    def flow_decisions_for(program, bytes, source_id, file_reasons = [], encoding = "UTF-8")
+      nodes = []
+      walk(program) { |node| nodes << node if flow_decision_node?(node) }
+      nodes.sort_by { |node| [node.location.start_offset, node.location.length] }.map do |node|
+        build_flow_decision(node, bytes, source_id, file_reasons, encoding)
+      end
+    end
+
+    private
+
+    def flow_decision_node?(node)
+      return true if node.is_a?(Prism::CaseNode) && node.predicate
+      return true if node.is_a?(Prism::CaseMatchNode)
+      return true if node.is_a?(Prism::CallNode) && node.safe_navigation?
+      return true if assignment_node?(node)
+      return true if node.is_a?(Prism::RescueNode) || node.is_a?(Prism::RescueModifierNode)
+
+      false
+    end
+
+    def assignment_node?(node)
+      OR_WRITE_NODE_NAMES.include?(node.class.name.split("::").last) ||
+        AND_WRITE_NODE_NAMES.include?(node.class.name.split("::").last)
+    end
+
+    def build_flow_decision(node, bytes, source_id, file_reasons, encoding)
+      location = node.location
+      kind, context, alternatives, instrumentation, reasons = flow_details(node, bytes, encoding)
+      reasons = Array(file_reasons) + Array(reasons)
+      decision_id = Records.decision_id(source_id: source_id, context: context,
+                                        byte_start: location.start_offset, byte_length: location.length, tree: nil)
+      alternatives = alternatives.each_with_index.map do |alternative, index|
+        alternative.merge(index: index, id: Records.condition_id(decision_id, index))
+      end
+      limit = @limits[:conditions_per_decision] if defined?(@limits) && @limits.respond_to?(:[])
+      reasons << "alternative_limit_exceeded" if limit && alternatives.length > limit
+
+      Records.build(
+        id: decision_id,
+        source_id: source_id,
+        context: context,
+        kind: kind,
+        byte_start: location.start_offset,
+        byte_length: location.length,
+        line: location.start_line,
+        column: location.start_column,
+        expression: text_value(bytes.byteslice(location.start_offset, location.length), encoding),
+        tree: nil,
+        conditions: [],
+        alternatives: alternatives,
+        discovered_condition_count: 0,
+        support_status: reasons.empty? ? "SUPPORTED" : "UNSUPPORTED",
+        support_reasons: reasons.uniq,
+        opaque_ranges: [],
+        instrumentation: instrumentation
+      )
+    end
+
+    def flow_details(node, bytes, encoding)
+      case node
+      when Prism::CaseNode
+        case_details(node, bytes, encoding, kind: "multiway", context: "case")
+      when Prism::CaseMatchNode
+        case_match_details(node, bytes, encoding)
+      when Prism::CallNode
+        safe_navigation_details(node, bytes, encoding)
+      when Prism::RescueNode, Prism::RescueModifierNode
+        rescue_details(node, bytes, encoding)
+      else
+        assignment_details(node, bytes, encoding)
+      end
+    end
+
+    def case_details(node, bytes, encoding, kind:, context:)
+      conditions = node.conditions
+      candidates = []
+      branches = []
+      conditions.each_with_index do |branch, branch_index|
+        branch.conditions.each do |candidate|
+          candidates << {
+            expression: text_value(bytes.byteslice(candidate.location.start_offset, candidate.location.length),
+                                   encoding),
+            range: byte_range(candidate.location, splat_node?(candidate) ? "splat" : nil),
+            byte_start: candidate.location.start_offset,
+            byte_length: candidate.location.length
+          }
+        end
+        branches << {
+          index: branch_index,
+          insert_at: branch_insert_at(branch, conditions[branch_index + 1], node.else_clause, node.end_keyword_loc),
+          empty: statements_empty?(branch.statements)
+        }
+      end
+
+      else_clause = node.else_clause
+      else_index = candidates.length
+      candidates << if else_clause
+                      { expression: "else", range: byte_range(else_clause.else_keyword_loc),
+                        byte_start: else_clause.else_keyword_loc.start_offset,
+                        byte_length: else_clause.else_keyword_loc.length }
+                    else
+                      { expression: "no_match", range: nil, byte_start: node.end_keyword_loc&.start_offset,
+                        byte_length: 0 }
+                    end
+      else_metadata = if else_clause
+                        { insert_at: branch_insert_at(else_clause, nil, nil, node.end_keyword_loc), index: else_index,
+                          empty: statements_empty?(else_clause.statements) }
+                      end
+      reasons = unsupported_reasons(node, bytes)
+      reasons << "unsupported_case_splat" if candidates.any? do |candidate|
+        candidate[:range] && candidate[:range][:kind] == "splat"
+      end
+      instrumentation = {
+        type: "case",
+        range: byte_range(node.location),
+        predicate: node.predicate && byte_range(node.predicate.location),
+        candidates: candidates.reject { |candidate| candidate[:expression] == "else" || candidate[:range].nil? }
+                              .each_with_index.map { |candidate, index| candidate.merge(index: index) },
+        branches: branches,
+        else: else_metadata,
+        end_start: node.end_keyword_loc&.start_offset
+      }
+      alternatives = candidates.map do |candidate|
+        candidate.slice(:expression, :byte_start, :byte_length)
+      end
+      [kind, context, alternatives, instrumentation, reasons]
+    end
+
+    def case_match_details(node, bytes, encoding)
+      conditions = node.conditions
+      candidates = []
+      branches = []
+      reasons = []
+      conditions.each_with_index do |branch, branch_index|
+        pattern = branch.pattern
+        guarded = pattern.is_a?(Prism::IfNode) || pattern.is_a?(Prism::UnlessNode)
+        guard = guarded ? pattern.predicate : nil
+        pattern_node = guarded ? pattern.statements&.body&.first : pattern
+        reasons << "unsupported_pattern_guard" if guard
+        candidate_node = pattern_node || pattern
+        candidates << {
+          expression: text_value(bytes.byteslice(candidate_node.location.start_offset, candidate_node.location.length),
+                                 encoding),
+          range: byte_range(candidate_node.location),
+          byte_start: candidate_node.location.start_offset,
+          byte_length: candidate_node.location.length,
+          guard: guard && byte_range(guard.location)
+        }
+        branches << {
+          index: branch_index,
+          insert_at: branch_insert_at(branch, conditions[branch_index + 1], node.else_clause, node.end_keyword_loc),
+          empty: statements_empty?(branch.statements)
+        }
+      end
+      else_clause = node.else_clause
+      else_metadata = if else_clause
+                        { insert_at: branch_insert_at(else_clause, nil, nil, node.end_keyword_loc), index: nil,
+                          empty: statements_empty?(else_clause.statements) }
+                      end
+      instrumentation = {
+        type: "case_match",
+        range: byte_range(node.location),
+        predicate: node.predicate && byte_range(node.predicate.location),
+        candidates: candidates.reject { |candidate| candidate[:expression] == "else" || candidate[:range].nil? }
+                              .each_with_index.map { |candidate, index| candidate.merge(index: index) },
+        branches: branches,
+        else: else_metadata,
+        end_start: node.end_keyword_loc&.start_offset
+      }
+      if node.else_clause
+        else_location = node.else_clause.else_keyword_loc
+        candidates << { expression: "else", range: byte_range(else_location),
+                        byte_start: else_location.start_offset, byte_length: else_location.length }
+        else_index = candidates.length - 1
+        instrumentation[:else] = instrumentation[:else].merge(index: else_index)
+      end
+      alternatives = candidates.map { |candidate| candidate.slice(:expression, :byte_start, :byte_length) }
+      ["pattern", "case_in", alternatives, instrumentation, unsupported_reasons(node, bytes) + reasons]
+    end
+
+    def safe_navigation_details(node, bytes, _encoding)
+      receiver = node.receiver
+      instrumentation = {
+        type: "safe_navigation",
+        range: byte_range(node.location),
+        receiver: byte_range(receiver.location)
+      }
+      alternatives = [
+        { expression: "receiver nil", byte_start: receiver.location.start_offset,
+          byte_length: receiver.location.length },
+        { expression: "receiver non-nil", byte_start: receiver.location.start_offset,
+          byte_length: receiver.location.length }
+      ]
+      ["implicit", "safe_navigation", alternatives, instrumentation, unsupported_reasons(node, bytes)]
+    end
+
+    def assignment_details(node, bytes, _encoding)
+      rhs = node.value
+      operator = bytes.byteslice(node.operator_loc.start_offset, node.operator_loc.length)
+      assignment_context = operator == "||=" ? "or_assignment" : "and_assignment"
+      reasons = safe_navigation_assignment?(node) ? ["unsupported_assignment_target"] : []
+      instrumentation = {
+        type: "assignment",
+        range: byte_range(node.location),
+        rhs: byte_range(rhs.location),
+        operator: operator,
+        rhs_path: 1,
+        skipped_path: 0
+      }
+      alternatives = if operator == "||="
+                       [{ expression: "LHS truthy; RHS skipped", byte_start: node.location.start_offset,
+                          byte_length: node.location.length },
+                        { expression: "LHS falsey; RHS executed", byte_start: node.location.start_offset,
+                          byte_length: node.location.length }]
+                     else
+                       [{ expression: "LHS falsey; RHS skipped", byte_start: node.location.start_offset,
+                          byte_length: node.location.length },
+                        { expression: "LHS truthy; RHS executed", byte_start: node.location.start_offset,
+                          byte_length: node.location.length }]
+                     end
+      ["implicit", assignment_context, alternatives, instrumentation, unsupported_reasons(node, bytes) + reasons]
+    end
+
+    def rescue_details(node, bytes, encoding)
+      alternatives = if node.respond_to?(:exceptions)
+                       Array(node.exceptions).map do |exception|
+                         {
+                           expression: text_value(
+                             bytes.byteslice(exception.location.start_offset, exception.location.length), encoding
+                           ),
+                           byte_start: exception.location.start_offset,
+                           byte_length: exception.location.length
+                         }
+                       end
+                     else
+                       []
+                     end
+      instrumentation = { type: "rescue", range: byte_range(node.location) }
+      ["exception", "rescue", alternatives, instrumentation, ["unsupported_rescue_control_flow"]]
+    end
+
+    def branch_insert_at(branch, next_branch, else_clause, end_keyword_loc)
+      statements = branch.statements
+      return statements.location.start_offset unless statements_empty?(statements)
+
+      next_location = if next_branch
+                        next_branch.is_a?(Prism::InNode) ? next_branch.in_loc : next_branch.keyword_loc
+                      end
+      next_location&.start_offset || else_clause&.else_keyword_loc&.start_offset ||
+        end_keyword_loc&.start_offset || branch.location.end_offset
+    end
+
+    def statements_empty?(statements)
+      statements.nil? || Array(statements.body).empty?
+    end
+
+    def safe_navigation_assignment?(node)
+      return true if node.respond_to?(:safe_navigation?) && node.safe_navigation?
+
+      node.respond_to?(:call_operator_loc) && node.call_operator_loc&.slice == "&."
+    end
+
+    def splat_node?(node)
+      node.class.name.end_with?("SplatNode")
+    end
+
+    def byte_range(location, kind = nil)
+      return nil unless location
+
+      result = { byte_start: location.start_offset, byte_length: location.length }
+      result[:kind] = kind if kind
+      result
+    end
+  end
+end

data/lib/branchproof/evidence.rb

@@ -208,11 +208,11 @@ module Branchproof
       decision = decisions.find { |d| d[:id].to_s == value[:decision_id].to_s }
       return "unknown decision" unless decision
 
-      conditions = Array(decision[:conditions])
-      return "condition count exceeds limit" if conditions.length > @limits[:conditions_per_decision]
+      dimensions = alternative_decision?(decision) ? Array(decision[:alternatives]) : Array(decision[:conditions])
+      return "condition count exceeds limit" if !alternative_decision?(decision) && dimensions.length > @limits[:conditions_per_decision]
       return "invalid condition index" unless value[:observations].map(&:first).uniq == value[:observations].map(&:first) && value[:observations].all? do |index, _|
-        conditions.any? do |c|
-          c[:index].to_i == index
+        dimensions.any? do |dimension|
+          dimension[:index].to_i == index
         end
       end
       return "invalid trace" unless value[:status].to_s != "completed" || valid_trace?(decision, value[:observations],
@@ -222,6 +222,8 @@ module Branchproof
     end
 
     def valid_trace?(decision, observations, outcome)
+      return valid_alternative_trace?(decision, observations, outcome) if alternative_decision?(decision)
+
       tree = symbolize(decision[:tree])
       unless tree
         return observations.map(&:first) == observations.map(&:first).sort &&
@@ -245,6 +247,13 @@ module Branchproof
 
         return [pair[1], cursor + 1]
       end
+      if type == "not"
+        child = replay_tree(node.fetch(:child), observations, cursor)
+        return nil unless child
+
+        child_value, next_cursor = child
+        return [!child_value, next_cursor]
+      end
       left = replay_tree(node.fetch(:left), observations, cursor)
       return nil unless left
 
@@ -265,7 +274,7 @@ module Branchproof
     end
 
     def condition_values(decision_id, observations)
-      count = decision_conditions(decision_id).length
+      count = decision_dimension_count(decision_id)
       values = Array.new(count)
       observations.each { |index, value| values[index] = value }
       values
@@ -306,9 +315,13 @@ module Branchproof
 
     def condition_shapes
       decisions.to_h do |decision|
-        [decision[:id].to_s, { conditions: Array(decision[:conditions]).map do |condition|
-          symbolize(condition)
-        end, tree: symbolize(decision[:tree]) }]
+        shape = { conditions: Array(decision[:conditions]).map { |condition| symbolize(condition) },
+                  tree: symbolize(decision[:tree]) }
+        if alternative_decision?(decision)
+          shape[:kind] = decision[:kind].to_s
+          shape[:alternatives] = Array(decision[:alternatives]).map { |alternative| symbolize(alternative) }
+        end
+        [decision[:id].to_s, shape]
       end
     end
 
@@ -337,7 +350,9 @@ module Branchproof
 
         decision = decisions.find { |item| item[:id].to_s == vector[:decision_id].to_s }
         return "unknown decision" unless decision
-        return "invalid vector shape" unless vector[:values].length == Array(decision[:conditions]).length &&
+
+        expected_values = decision_dimension_count(decision)
+        return "invalid vector shape" unless vector[:values].length == expected_values &&
                                              vector[:values].all? { |item| item.nil? || item == true || item == false }
 
         expected = Branchproof::Records.id([vector[:decision_id].to_s, vector[:values], vector[:outcome] ? true : false])
@@ -375,6 +390,36 @@ module Branchproof
       nil
     end
 
+    def alternative_decision?(decision)
+      kind = decision[:kind].to_s
+      !kind.empty? && kind != "boolean"
+    end
+
+    def decision_dimension_count(decision_or_id)
+      decision = decision_or_id.is_a?(Hash) ? decision_or_id : decisions.find { |item| item[:id].to_s == decision_or_id.to_s }
+      return 0 unless decision
+
+      alternative_decision?(decision) ? Array(decision[:alternatives]).length : Array(decision[:conditions]).length
+    end
+
+    def valid_alternative_trace?(decision, observations, outcome)
+      return false unless outcome == true
+
+      alternatives = Array(decision[:alternatives])
+      expected = alternatives.length
+      return false unless expected.positive?
+      if decision[:kind].to_s == "implicit"
+        return expected == 2 && observations.length == 2 &&
+               observations.map(&:first) == [0, 1] && observations.map(&:last).count(true) == 1
+      end
+
+      return false unless observations.length.between?(1, expected)
+
+      observations.each_with_index.all? do |(index, value), position|
+        index == position && value == (position == observations.length - 1)
+      end
+    end
+
     def decisions = Array(fetch_value(@inventory, :decisions)).map { symbolize(_1) }
     def decision_conditions(id) = (decisions.find { |d| d[:id].to_s == id.to_s } || {}).fetch(:conditions, [])
     def vector_count(id) = @vectors.values.count { |v| v[:decision_id] == id.to_s }

data/lib/branchproof/flow_instrumentation.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+# Keep each bounded source rewrite together so its evaluation order can be audited.
+# rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+
+module Branchproof
+  # Source-location edits around Ruby's native matching and assignment operations.
+  module FlowInstrumentation
+    private
+
+    def render_flow(bytes, decision, nested)
+      metadata = decision.fetch(:instrumentation)
+      case metadata.fetch(:type)
+      when "safe_navigation"
+        receiver = metadata.fetch(:receiver)
+        replacements = [flow_replacement(bytes, receiver, nested) do |expression|
+          "#{self.class::RUNTIME}.flow_receiver(#{decision[:id].inspect}, (#{expression}))"
+        end]
+        flow_fragments(bytes, decision, nested, replacements)
+      when "assignment"
+        rhs = metadata.fetch(:rhs)
+        replacements = [flow_replacement(bytes, rhs, nested) do |expression|
+          "(begin; #{self.class::RUNTIME}.flow_path(#{decision[:id].inspect}, 1); (#{expression}); end)"
+        end]
+        expression = flow_fragments(bytes, decision, nested, replacements)
+        flow_frame(decision[:id], expression, default_path: 0)
+      when "case"
+        render_case_flow(bytes, decision, nested, metadata)
+      when "case_match"
+        render_pattern_flow(bytes, decision, nested, metadata)
+      else
+        raise ArgumentError, "unknown instrumentation type: #{metadata[:type]}"
+      end
+    end
+
+    def render_case_flow(bytes, decision, nested, metadata)
+      identifier = decision[:id].inspect
+      runtime = self.class::RUNTIME
+      replacements = metadata.fetch(:candidates).map do |candidate|
+        flow_replacement(bytes, candidate, nested) do |expression|
+          "(begin; #{runtime}.flow_candidate(#{identifier}, #{candidate[:index]}); (#{expression}); end)"
+        end
+      end
+      metadata.fetch(:branches).each do |branch|
+        suffix = branch[:empty] ? "nil; " : ""
+        replacements << { start: branch[:insert_at], length: 0,
+                          text: "; #{runtime}.flow_selected(#{identifier}); #{suffix}" }
+      end
+      if metadata[:else]
+        alternative = metadata[:else]
+        replacements << { start: alternative[:insert_at], length: 0,
+                          text: "; #{runtime}.flow_select(#{identifier}, #{alternative[:index]}); " }
+      else
+        index = decision.fetch(:alternatives).length - 1
+        replacements << { start: metadata.fetch(:end_start), length: 0,
+                          text: "else; #{runtime}.flow_select(#{identifier}, #{index}); nil; " }
+      end
+      flow_frame(decision[:id], flow_fragments(bytes, decision, nested, replacements))
+    end
+
+    def render_pattern_flow(bytes, decision, nested, metadata)
+      identifier = decision[:id].inspect
+      runtime = self.class::RUNTIME
+      replacements = metadata.fetch(:branches).map do |branch|
+        suffix = branch[:empty] ? "nil; " : ""
+        { start: branch[:insert_at], length: 0,
+          text: "; #{runtime}.flow_select(#{identifier}, #{branch[:index]}); #{suffix}" }
+      end
+      if metadata[:else]
+        alternative = metadata[:else]
+        replacements << { start: alternative[:insert_at], length: 0,
+                          text: "; #{runtime}.flow_select(#{identifier}, #{alternative[:index]}); " }
+      end
+      flow_frame(decision[:id], flow_fragments(bytes, decision, nested, replacements))
+    end
+
+    def flow_replacement(bytes, location, nested)
+      start = location.fetch(:byte_start)
+      length = location.fetch(:byte_length)
+      { start: start, length: length, text: yield(render_children(bytes, start, length, nested)) }
+    end
+
+    def flow_fragments(bytes, decision, nested, replacements)
+      cursor = decision.fetch(:byte_start)
+      finish = cursor + decision.fetch(:byte_length)
+      chunks = []
+      replacements.sort_by { |edit| [edit[:start], edit[:length]] }.each do |edit|
+        raise ArgumentError, "overlapping flow edits" if edit[:start] < cursor
+
+        chunks << render_children(bytes, cursor, edit[:start] - cursor, nested)
+        chunks << edit[:text]
+        cursor = edit[:start] + edit[:length]
+      end
+      chunks << render_children(bytes, cursor, finish - cursor, nested)
+      chunks.join
+    end
+
+    def flow_frame(decision_id, expression, default_path: nil)
+      runtime = self.class::RUNTIME
+      "(begin; #{runtime}.enter(#{decision_id.inspect}); begin; " \
+        "#{runtime}.flow_finish(#{decision_id.inspect}, (#{expression}), #{default_path.inspect}); ensure; " \
+        "#{runtime}.leave(#{decision_id.inspect}); end; end)"
+    end
+  end
+end
+
+# rubocop:enable Metrics/AbcSize, Metrics/MethodLength