branchproof 0.8.0 → 0.10.0

data/lib/branchproof/evidence.rb

@@ -34,6 +34,7 @@ module Branchproof
       @run_payloads = {}
       @abort_counts = Hash.new(0)
       @diagnostics = []
+      @repetition_cache = {}
       @limited = false
       @attribution_complete = true
     end
@@ -55,6 +56,10 @@ module Branchproof
     end
 
     def record(execution:)
+      if (cached = cached_execution(execution))
+        return record_cached(cached)
+      end
+
       value = symbolize(execution)
       reason = validate_execution(value)
       return reject_record(reason) if reason
@@ -102,6 +107,8 @@ module Branchproof
         phase = value[:phase].to_s
         test[:phase_counts][phase] = test[:phase_counts].fetch(phase, 0) + 1
       end
+      cache_key = execution_cache_key(value)
+      @repetition_cache[cache_key[1]] = { key: cache_key, vector_id: vector_id }
       status("recorded", nil)
     rescue StandardError => e
       diagnose(diagnostic: { code: "record_failure", severity: "error", message: e.message })
@@ -113,6 +120,10 @@ module Branchproof
       nil
     end
 
+    def test_phase_counts
+      @tests.transform_values { |test| test[:phase_counts].dup.freeze }.freeze
+    end
+
     def snapshot
       deep_freeze(deep_dup({ schema_version: SCHEMA_VERSION, tool_version: TOOL_VERSION,
                              criterion_version: CRITERION_VERSION,
@@ -167,6 +178,7 @@ module Branchproof
       @abort_counts.merge!(incoming.fetch(:abort_counts, {})) { |_k, a, b| a.to_i + b.to_i }
       @limited ||= !incoming.dig(:completeness, :observation)
       @attribution_complete &&= incoming.dig(:completeness, :attribution) ? true : false
+      @repetition_cache.clear
       status("merged", nil)
     rescue StandardError => e
       restore_state(backup) if backup
@@ -518,7 +530,8 @@ module Branchproof
       { vectors: deep_dup(@vectors), tests: deep_dup(@tests), run_ids: @run_ids.dup,
         run_payloads: @run_payloads.dup, diagnostics: deep_dup(@diagnostics),
         abort_counts: @abort_counts.dup, limited: @limited, attribution_complete: @attribution_complete,
-        vector_counts_by_decision: @vector_counts_by_decision.dup, owner_associations_count: @owner_associations_count }
+        vector_counts_by_decision: @vector_counts_by_decision.dup, owner_associations_count: @owner_associations_count,
+        repetition_cache: deep_dup(@repetition_cache) }
     end
 
     def restore_state(state)
@@ -530,10 +543,83 @@ module Branchproof
       @abort_counts = state[:abort_counts]
       @vector_counts_by_decision = state[:vector_counts_by_decision]
       @owner_associations_count = state[:owner_associations_count]
+      @repetition_cache = state[:repetition_cache]
       @limited = state[:limited]
       @attribution_complete = state[:attribution_complete]
     end
 
+    def cached_execution(execution)
+      return nil unless execution.is_a?(Hash)
+
+      key = raw_execution_cache_key(execution)
+      return nil unless key
+
+      entry = @repetition_cache[key[1]]
+      return nil unless entry && entry[:key] == key
+
+      vector = @vectors[entry[:vector_id]]
+      return nil unless vector
+
+      [key, vector, raw_execution_attribution(execution)]
+    end
+
+    def record_cached(cached)
+      _key, vector, value = cached
+      vector[:count] += 1
+      if value[:test_id] && @tests.key?(value[:test_id].to_s)
+        test = @tests[value[:test_id].to_s]
+        phase = value[:phase].to_s
+        test[:phase_counts][phase] = test[:phase_counts].fetch(phase, 0) + 1
+      end
+      vector[:unattributed_count] += 1 unless value[:test_id]
+      status("recorded", nil)
+    end
+
+    def raw_execution_cache_key(execution)
+      required = %i[run_id decision_id test_id phase observations outcome status]
+      return nil unless required.all? { |key| execution.key?(key) || execution.key?(key.to_s) }
+
+      status = raw_value(execution, :status)
+      outcome = raw_value(execution, :outcome)
+      return nil unless status.to_s == "completed" && [true, false].include?(outcome)
+
+      observations = raw_value(execution, :observations)
+      return nil unless observations.is_a?(Array)
+
+      test_id = raw_value(execution, :test_id)
+      [raw_value(execution, :run_id).to_s, raw_value(execution, :decision_id).to_s,
+       test_id_marker(test_id), test_id&.to_s, raw_value(execution, :phase).to_s,
+       observations, outcome, status.to_s]
+    end
+
+    def execution_cache_key(value)
+      key = [copy_string(value[:run_id]), copy_string(value[:decision_id]), test_id_marker(value[:test_id]),
+             copy_string(value[:test_id]),
+             copy_string(value[:phase]), deep_dup(value[:observations]), value[:outcome], copy_string(value[:status])]
+      deep_freeze(key)
+    end
+
+    def raw_execution_attribution(execution)
+      { test_id: raw_value(execution, :test_id), phase: raw_value(execution, :phase) }
+    end
+
+    def copy_string(value)
+      value.nil? ? nil : value.to_s.dup
+    end
+
+    def test_id_marker(value)
+      return :nil if value.nil?
+      return :false_test_id if value == false
+
+      :present
+    end
+
+    def raw_value(hash, key)
+      return hash[key] if hash.key?(key)
+
+      hash[key.to_s]
+    end
+
     def deep_freeze(value)
       case value
       when Hash then value.each do |key, item|

data/lib/branchproof/exception_instrumentation.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity, Style/ConditionalAssignment
+
+require_relative "flow_instrumentation"
+
+module Branchproof
+  # Textual edits for native rescue control flow.  The edits only add calls at
+  # Ruby's own protected-region and handler boundaries; exception matching,
+  # `$!`, retry, ensure ordering, and nonlocal transfers remain Ruby-owned.
+  module ExceptionInstrumentation
+    private
+
+    def render_flow(bytes, decision, nested, encloses)
+      metadata = decision.fetch(:instrumentation)
+      return super unless %w[exception rescue_modifier].include?(metadata[:type])
+
+      if metadata[:type] == "exception"
+        render_exception_flow(bytes, decision, nested, encloses)
+      else
+        render_rescue_modifier_flow(bytes, decision, nested, encloses)
+      end
+    end
+
+    def render_exception_flow(bytes, decision, nested, encloses)
+      identifier = decision[:id].inspect
+      runtime = self.class::RUNTIME
+      metadata = decision.fetch(:instrumentation)
+      replacements = []
+      if metadata[:normal_insert_at] && !metadata[:normal_empty]
+        replacements << { start: metadata.fetch(:normal_insert_at), length: 0,
+                          text: "; #{runtime}.exception_path(#{identifier}, 0); " }
+      elsif metadata[:normal_transfer]
+        transfer = metadata.fetch(:normal_transfer)
+        if transfer[:arguments]
+          replacements << flow_replacement(bytes, transfer.fetch(:arguments), nested, encloses) do |arguments|
+            value = transfer[:argument_mode] == :array ? "[#{arguments}]" : "(#{arguments})"
+            "#{runtime}.exception_value(#{identifier}, #{value}, 0)"
+          end
+        else
+          replacements << { start: transfer.fetch(:insert_at), length: 0,
+                            text: "#{runtime}.exception_path(#{identifier}, 0); " }
+        end
+      elsif metadata[:normal_body] && metadata[:normal_body][:byte_length].positive?
+        replacements << flow_replacement(bytes, metadata.fetch(:normal_body), nested, encloses) do |body|
+          "#{runtime}.exception_value(#{identifier}, (begin; #{body}; end), 0)"
+        end
+      end
+      metadata.fetch(:clauses).each do |clause|
+        replacements << { start: clause.fetch(:insert_at), length: 0,
+                          text: "; #{runtime}.exception_path(#{identifier}, #{clause.fetch(:index)}); " }
+      end
+      if metadata[:implicit]
+        entry = "begin; #{runtime}.exception_enter(#{identifier}, #{metadata.fetch(:unhandled_index)}); begin; "
+        entry += "#{runtime}.exception_path(#{identifier}, 0); " if metadata[:normal_empty]
+        entry += metadata[:iteration_callback].fetch(:text) if metadata[:iteration_callback]
+        exit = "; end; rescue ::Exception; #{runtime}.exception_unhandled(#{identifier}); raise; ensure; " \
+               "#{runtime}.exception_leave(#{identifier}); end; "
+        replacements << { start: metadata.fetch(:entry_insert_at), length: 0, text: entry }
+        replacements << { start: metadata.fetch(:exit_insert_at), length: 0, text: exit }
+        flow_fragments(bytes, decision, nested, replacements, encloses)
+      else
+        expression = flow_fragments(bytes, decision, nested, replacements, encloses)
+        exception_frame(decision[:id], expression, metadata.fetch(:unhandled_index))
+      end
+    end
+
+    def render_rescue_modifier_flow(bytes, decision, nested, encloses)
+      identifier = decision[:id].inspect
+      runtime = self.class::RUNTIME
+      metadata = decision.fetch(:instrumentation)
+      lhs = metadata.fetch(:expression)
+      rhs = metadata.fetch(:rescue_expression)
+      replacements = [
+        flow_replacement(bytes, lhs, nested, encloses) do |expression|
+          "#{runtime}.exception_value(#{identifier}, (#{expression}), 0)"
+        end,
+        flow_replacement(bytes, rhs, nested, encloses) do |expression|
+          "(begin; #{runtime}.exception_path(#{identifier}, 1); (#{expression}); end)"
+        end
+      ]
+      exception_frame(decision[:id], flow_fragments(bytes, decision, nested, replacements, encloses),
+                      metadata.fetch(:unhandled_index))
+    end
+
+    def exception_frame(decision_id, expression, unhandled_index)
+      runtime = self.class::RUNTIME
+      "(begin; #{runtime}.exception_enter(#{decision_id.inspect}, #{unhandled_index}); begin; " \
+        "#{expression}; " \
+        "rescue ::Exception; #{runtime}.exception_unhandled(#{decision_id.inspect}); raise; ensure; " \
+        "#{runtime}.exception_leave(#{decision_id.inspect}); end; end)"
+    end
+  end
+end
+
+# rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity, Style/ConditionalAssignment

data/lib/branchproof/exception_runtime.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Branchproof
+  # Record native clause selection and escaping exceptions. Generated wrappers
+  # re-raise the same exception; nonlocal transfers remain aborted observations.
+  module ExceptionRuntime
+    def exception_enter(decision_id, unhandled_index)
+      enter(decision_id)
+      frame = current_frame(decision_id)
+      frame[:exception_unhandled_index] = unhandled_index if frame
+      nil
+    end
+
+    def exception_path(decision_id, index)
+      frame = current_frame(decision_id)
+      flow_select(decision_id, index) if frame && !frame[:finished]
+      nil
+    end
+
+    def exception_value(decision_id, value, index)
+      exception_path(decision_id, index)
+      value
+    end
+
+    def exception_finish(decision_id, value)
+      frame = current_frame(decision_id)
+      exception_path(decision_id, 0) if frame && !frame[:finished]
+      value
+    end
+
+    def exception_unhandled(decision_id)
+      frame = current_frame(decision_id)
+      exception_path(decision_id, frame[:exception_unhandled_index]) if frame && !frame[:finished]
+      nil
+    end
+
+    def exception_leave(decision_id)
+      leave(decision_id)
+    end
+  end
+end

data/lib/branchproof/exception_syntax.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity, Metrics/ModuleLength
+
+require "prism"
+
+module Branchproof
+  # Replaces unsupported standalone rescue-clause records with decisions for
+  # Ruby's enclosing protected region.  Ruby chooses a rescue clause as part
+  # of executing BeginNode; a RescueNode by itself is not executable syntax.
+  module ExceptionSyntax
+    private
+
+    def flow_decision_node?(node)
+      return true if exception_region_node?(node)
+      return false if node.is_a?(Prism::RescueNode)
+
+      super
+    end
+
+    def flow_details(node, bytes, encoding)
+      return exception_region_details(node, bytes, encoding) if exception_region_node?(node)
+
+      super
+    end
+
+    def exception_region_node?(node)
+      (node.is_a?(Prism::BeginNode) && (node.rescue_clause || node.ensure_clause)) ||
+        node.is_a?(Prism::RescueModifierNode)
+    end
+
+    def exception_region_details(node, bytes, encoding)
+      return rescue_modifier_details(node, bytes, encoding) if node.is_a?(Prism::RescueModifierNode)
+
+      clauses = []
+      clause = node.rescue_clause
+      while clause
+        clauses << clause
+        clause = clause.child_nodes.find { |child| child.is_a?(Prism::RescueNode) }
+      end
+
+      alternatives = [{ expression: "normal", byte_start: node.location.start_offset,
+                        byte_length: node.location.length }]
+      clauses.each do |clause_node|
+        alternatives << { expression: rescue_label(clause_node, bytes, encoding),
+                          byte_start: clause_node.location.start_offset,
+                          byte_length: clause_node.location.length }
+      end
+      alternatives << { expression: "unhandled", byte_start: node.location.start_offset,
+                        byte_length: node.location.length }
+
+      instrumentation = {
+        type: "exception",
+        range: byte_range(node.location),
+        normal_insert_at: exception_normal_insert_at(node),
+        normal_body: node.statements && byte_range(node.statements.location),
+        normal_transfer: exception_transfer_metadata(node.statements),
+        implicit: node.begin_keyword_loc.nil?,
+        normal_empty: node.begin_keyword_loc.nil? && exception_body_empty?(node),
+        entry_insert_at: node.begin_keyword_loc.nil? && exception_entry_insert_at(node),
+        exit_insert_at: node.begin_keyword_loc.nil? && node.end_keyword_loc&.start_offset,
+        clauses: clauses.each_with_index.map do |clause_node, index|
+          { index: index + 1, insert_at: exception_clause_insert_at(clause_node, node) }
+        end,
+        unhandled_index: alternatives.length - 1
+      }
+      reasons = unsupported_reasons(node, bytes)
+      ["exception", "rescue", alternatives, instrumentation, reasons]
+    end
+
+    def rescue_modifier_details(node, bytes, _encoding)
+      lhs = node.expression
+      rhs = node.rescue_expression
+      alternatives = [
+        { expression: "normal", byte_start: lhs.location.start_offset, byte_length: lhs.location.length },
+        { expression: "rescue", byte_start: rhs.location.start_offset, byte_length: rhs.location.length },
+        { expression: "unhandled", byte_start: node.location.start_offset, byte_length: node.location.length }
+      ]
+      instrumentation = {
+        type: "rescue_modifier",
+        range: byte_range(node.location),
+        expression: byte_range(lhs.location),
+        rescue_expression: byte_range(rhs.location),
+        normal_index: 0,
+        rescue_index: 1,
+        unhandled_index: 2
+      }
+      ["exception", "rescue", alternatives, instrumentation, unsupported_reasons(node, bytes)]
+    end
+
+    def rescue_label(clause, bytes, encoding)
+      exceptions = Array(clause.exceptions)
+      return "rescue" if exceptions.empty?
+
+      names = exceptions.map do |exception|
+        text_value(bytes.byteslice(exception.location.start_offset, exception.location.length), encoding)
+      end
+      "rescue #{names.join(", ")}"
+    end
+
+    def exception_clause_insert_at(clause, node)
+      return clause.statements.location.start_offset unless statements_empty?(clause.statements)
+
+      next_clause = clause.child_nodes.find { |child| child.is_a?(Prism::RescueNode) }
+      return next_clause.keyword_loc.start_offset if next_clause
+      return node.else_clause.else_keyword_loc.start_offset if node.else_clause
+      return node.ensure_clause.ensure_keyword_loc.start_offset if node.ensure_clause
+
+      node.end_keyword_loc.start_offset
+    end
+
+    def exception_else_insert_at(node)
+      clause = node.else_clause
+      return clause.statements.location.start_offset unless statements_empty?(clause.statements)
+
+      node.ensure_clause&.ensure_keyword_loc&.start_offset || node.end_keyword_loc.start_offset
+    end
+
+    def exception_transfer_metadata(statements)
+      transfer = statements && Array(statements.body).last
+      return nil unless transfer_node?(transfer)
+
+      arguments = transfer.respond_to?(:arguments) ? transfer.arguments : nil
+      argument_nodes = arguments && Array(arguments.arguments)
+      scalar_argument = argument_nodes&.length == 1 && !argument_nodes.first.is_a?(Prism::SplatNode)
+      argument_mode = if scalar_argument
+                        :scalar
+                      elsif argument_nodes&.any?
+                        :array
+                      end
+      { insert_at: transfer.location.start_offset,
+        arguments: argument_mode ? byte_range(arguments.location) : nil,
+        argument_mode: argument_mode }
+    end
+
+    def transfer_node?(node)
+      [Prism::ReturnNode, Prism::BreakNode, Prism::NextNode, Prism::RedoNode].any? { |klass| node.is_a?(klass) }
+    end
+
+    def exception_body_empty?(node)
+      node.statements.nil? || statements_empty?(node.statements)
+    end
+
+    def exception_normal_insert_at(node)
+      return exception_else_insert_at(node) if node.else_clause
+      return nil unless exception_body_empty?(node)
+
+      node.rescue_clause&.keyword_loc&.start_offset || node.ensure_clause&.ensure_keyword_loc&.start_offset
+    end
+
+    def exception_entry_insert_at(node)
+      node.statements&.location&.start_offset || exception_normal_insert_at(node) || node.end_keyword_loc.start_offset
+    end
+  end
+end
+
+# rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity, Metrics/ModuleLength

data/lib/branchproof/extended_alternative_runtime.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Branchproof
+  # Runtime hooks for decisions whose native evaluation has a third path.
+  # Runtime includes this module explicitly; it is kept separate so the
+  # ordinary two-path helpers remain unchanged.
+  module ExtendedAlternativeRuntime
+    def flow_assignment_receiver(decision_id, receiver)
+      flow_select(decision_id, 0) if nil.equal?(receiver)
+      receiver
+    end
+
+    def flow_assignment_path(decision_id, index)
+      flow_select(decision_id, index)
+    end
+
+    def flow_assignment_finish(decision_id, value, default_path = nil)
+      frame = current_frame(decision_id)
+      flow_select(decision_id, default_path) if frame && !frame[:finished] && !default_path.nil?
+      value
+    end
+  end
+end

data/lib/branchproof/flow_instrumentation.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # Keep each bounded source rewrite together so its evaluation order can be audited.
-# rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+# rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/ModuleLength
 
 module Branchproof
   # Source-location edits around Ruby's native matching and assignment operations.
@@ -19,11 +19,27 @@ module Branchproof
         flow_fragments(bytes, decision, nested, replacements, encloses)
       when "assignment"
         rhs = metadata.fetch(:rhs)
-        replacements = [flow_replacement(bytes, rhs, nested, encloses) do |expression|
-          "(begin; #{self.class::RUNTIME}.flow_path(#{decision[:id].inspect}, 1); (#{expression}); end)"
-        end]
+        identifier = decision[:id].inspect
+        replacements = []
+        if metadata[:receiver]
+          receiver = metadata.fetch(:receiver)
+          replacements << flow_replacement(bytes, receiver, nested, encloses) do |expression|
+            "#{self.class::RUNTIME}.flow_assignment_receiver(#{identifier}, (#{expression}))"
+          end
+          replacements << flow_replacement(bytes, rhs, nested, encloses) do |expression|
+            "(begin; #{self.class::RUNTIME}.flow_assignment_path(#{identifier}, 2); (#{expression}); end)"
+          end
+        else
+          replacements << flow_replacement(bytes, rhs, nested, encloses) do |expression|
+            "(begin; #{self.class::RUNTIME}.flow_path(#{identifier}, 1); (#{expression}); end)"
+          end
+        end
         expression = flow_fragments(bytes, decision, nested, replacements, encloses)
-        flow_frame(decision[:id], expression, default_path: 0)
+        if metadata[:receiver]
+          flow_assignment_frame(decision[:id], expression, default_path: 1)
+        else
+          flow_frame(decision[:id], expression, default_path: 0)
+        end
       when "case"
         render_case_flow(bytes, decision, nested, metadata, encloses)
       when "case_match"
@@ -38,7 +54,12 @@ module Branchproof
       runtime = self.class::RUNTIME
       replacements = metadata.fetch(:candidates).map do |candidate|
         flow_replacement(bytes, candidate, nested, encloses) do |expression|
-          "(begin; #{runtime}.flow_candidate(#{identifier}, #{candidate[:index]}); (#{expression}); end)"
+          if candidate[:splat]
+            splat_expression = expression.sub(/\A\*/, "")
+            "*(begin; #{runtime}.flow_candidate(#{identifier}, #{candidate[:index]}); (#{splat_expression}); end)"
+          else
+            "(begin; #{runtime}.flow_candidate(#{identifier}, #{candidate[:index]}); (#{expression}); end)"
+          end
         end
       end
       metadata.fetch(:branches).each do |branch|
@@ -101,7 +122,15 @@ module Branchproof
         "#{runtime}.flow_finish(#{decision_id.inspect}, (#{expression}), #{default_path.inspect}); ensure; " \
         "#{runtime}.leave(#{decision_id.inspect}); end; end)"
     end
+
+    def flow_assignment_frame(decision_id, expression, default_path: nil)
+      runtime = self.class::RUNTIME
+      "(begin; #{runtime}.enter(#{decision_id.inspect}); begin; " \
+        "#{runtime}.flow_assignment_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
+# rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/ModuleLength

data/lib/branchproof/focused_report.rb

@@ -238,6 +238,8 @@ module Branchproof
       lines << "Test: #{row[:name]}"
       lines << "Location: #{location(row[:relative_path], row[:line], unavailable: "location unavailable")}"
       lines << "Status: #{row[:status] || "unknown"}"
+      command = @coordinator.rerun_command(row[:id])
+      lines << "Rerun: #{command}" if command
       lines << "Phases: #{row[:phases].join(", ")}" unless row[:phases].empty?
       render_test_observations(lines, observations)
       lines << ""
@@ -341,6 +343,9 @@ module Branchproof
       return id.to_s unless test
 
       label = "#{test[:name]} (#{location(test[:relative_path], test[:line])})"
+      command = @coordinator.rerun_command(id)
+      return "#{label} (rerun: #{command})" if command
+
       duplicates = @test_name_counts[[test[:name], test[:relative_path], test[:line]]]
       duplicates > 1 ? "#{label} [#{id}]" : label
     end

data/lib/branchproof/instrumenter.rb

@@ -1,6 +1,10 @@
 # frozen_string_literal: true
 
 require_relative "flow_instrumentation"
+require_relative "iteration_instrumentation"
+require_relative "exception_instrumentation"
+require_relative "default_instrumentation"
+require_relative "value_instrumentation"
 
 module Branchproof
   # Applies the smallest possible source edits around inventoried expressions.
@@ -8,6 +12,10 @@ module Branchproof
   # never evaluates application code or introduces a Ruby scope.
   class Instrumenter
     include FlowInstrumentation
+    include IterationInstrumentation
+    include ExceptionInstrumentation
+    prepend DefaultInstrumentation
+    prepend ValueInstrumentation
 
     RUNTIME = "::Branchproof::Runtime"
 
@@ -54,8 +62,29 @@ module Branchproof
     def build_enclosures(decisions)
       encloses = {}.compare_by_identity
       enclosed = {}.compare_by_identity
-      decisions.each do |outer|
-        contained = decisions.select { |inner| encloses_decision?(outer, inner) }
+      indexed = decisions.each_index.group_by { |index| decisions[index][:byte_start] }
+      active = []
+      relations = Array.new(decisions.length) { [] }
+
+      indexed.sort_by { |start, _indices| start }.each do |start, indices|
+        active.reject! do |index|
+          decision = decisions[index]
+          decision[:byte_start] + decision[:byte_length] < start
+        end
+        active.concat(indices)
+        indices.each do |inner_index|
+          inner = decisions[inner_index]
+          active.each do |outer_index|
+            outer = decisions[outer_index]
+            next unless encloses_decision?(outer, inner)
+
+            relations[outer_index] << inner_index
+          end
+        end
+      end
+
+      decisions.each_with_index do |outer, outer_index|
+        contained = relations[outer_index].sort.map { |inner_index| decisions[inner_index] }
         encloses[outer] = contained
         contained.each { |inner| enclosed[inner] = true }
       end
@@ -89,7 +118,7 @@ module Branchproof
 
         chunks << bytes.byteslice(cursor, cstart - cursor)
         original = render_children(bytes, cstart, clen, nested, encloses)
-        chunks << condition_wrapper(decision[:id], condition[:index], original)
+        chunks << condition_wrapper(decision, condition, original)
         cursor = cstart + clen
       end
       chunks << render_children(bytes, cursor, length - (cursor - start), nested, encloses)
@@ -131,8 +160,24 @@ module Branchproof
       end
     end
 
-    def condition_wrapper(decision_id, index, expression)
-      "#{RUNTIME}.condition(#{decision_id.inspect}, #{index}, (#{expression}))"
+    def condition_wrapper(decision, condition, expression)
+      return "(begin; #{expression}; end)" if nonlocal_transfer?(expression)
+
+      identifier = decision[:id].inspect
+      index = condition[:index]
+      case condition[:contextual]
+      when "implicit_regexp", "flip_flop"
+        # These operations require Ruby's conditional context: a bare regexp
+        # implicitly matches $_ and a flip-flop retains its state across calls.
+        "(if (#{expression}) then #{RUNTIME}.condition(#{identifier}, #{index}, true) " \
+        "else #{RUNTIME}.condition(#{identifier}, #{index}, false) end)"
+      else
+        "#{RUNTIME}.condition(#{identifier}, #{index}, (#{expression}))"
+      end
+    end
+
+    def nonlocal_transfer?(expression)
+      expression.lstrip.match?(/\A(?:return|break|next|redo|retry)\b/n)
     end
 
     def frame(decision_id, expression)