branchproof 0.8.0 → 0.9.0

data/lib/branchproof/source.rb

@@ -4,12 +4,23 @@ require "digest"
 require "pathname"
 require "prism"
 require_relative "decision_syntax"
+require_relative "iteration_syntax"
+require_relative "exception_syntax"
+require_relative "default_syntax"
+require_relative "value_syntax"
 require_relative "constraints"
 
 module Branchproof
   # Inventories supported condition and decision occurrences from Ruby files.
   class Source
     include DecisionSyntax
+    # Contextual syntax modules are layered after the baseline classifier so
+    # each can extend discovery without coupling this walker to every syntax
+    # family. Additional modules can follow the same seam.
+    include IterationSyntax
+    include ExceptionSyntax
+    prepend DefaultSyntax
+    prepend ValueSyntax
 
     attr_reader :root, :limits
 
@@ -114,8 +125,9 @@ module Branchproof
       phase_one_nodes = []
       phase_two_nodes = []
       flow_nodes = []
+      value_nodes = []
 
-      walk(program) do |node|
+      walk_skipping_defined_operands(program) do |node|
         if node.is_a?(Prism::DefinedNode)
           defined_ranges << node.location
         elsif node.is_a?(Prism::InNode)
@@ -123,12 +135,14 @@ module Branchproof
           guard_patterns[pattern] = true if pattern.is_a?(Prism::IfNode) || pattern.is_a?(Prism::UnlessNode)
         end
         phase_one_nodes << node if decision_node?(node) || subjectless_case?(node)
-        phase_two_nodes << node if boolean_node?(node) || node.is_a?(Prism::MatchPredicateNode)
+        phase_two_nodes << node if boolean_node?(node) || node.is_a?(Prism::MatchPredicateNode) ||
+                                   node.is_a?(Prism::DefinedNode)
         flow_nodes << node if flow_decision_node?(node)
+        value_nodes << node if respond_to?(:value_candidate_node?, true) && value_candidate_node?(node)
       end
 
       { defined_ranges: defined_ranges, guard_patterns: guard_patterns, phase_one_nodes: phase_one_nodes,
-        phase_two_nodes: phase_two_nodes, flow_nodes: flow_nodes }
+        phase_two_nodes: phase_two_nodes, flow_nodes: flow_nodes, value_nodes: value_nodes }
     end
 
     def decisions_for(program, bytes, source_id, file_reasons = [], encoding = "UTF-8")
@@ -162,15 +176,17 @@ module Branchproof
       # argument) are separate decisions when tree_for did not decompose them.
       collected[:phase_two_nodes].each do |node|
         next if inventoried_boolean_nodes[node]
-
-        additional_reasons = if within_defined_expression?(node, defined_ranges)
-                               ["unsupported_defined_expression"]
-                             else
-                               []
-                             end
-        context = node.is_a?(Prism::MatchPredicateNode) ? "pattern_in" : "short_circuit"
+        next if within_defined_expression?(node, defined_ranges) && !node.is_a?(Prism::DefinedNode)
+
+        context = if node.is_a?(Prism::MatchPredicateNode)
+                    "pattern_in"
+                  elsif node.is_a?(Prism::DefinedNode)
+                    "defined"
+                  else
+                    "short_circuit"
+                  end
         specs << { node: nil, predicate: node, context: context,
-                   additional_reasons: additional_reasons }
+                   additional_reasons: [] }
         mark_semantic_boolean_nodes(node, inventoried_boolean_nodes)
       end
 
@@ -188,22 +204,24 @@ module Branchproof
                        predicate: predicate, context: spec[:context],
                        additional_reasons: spec[:additional_reasons] || [])
       end
-      boolean_decisions + flow_decisions_for(program, bytes, source_id, file_reasons, encoding,
-                                             defined_ranges: defined_ranges, nodes: collected[:flow_nodes])
+      decisions = boolean_decisions + flow_decisions_for(program, bytes, source_id, file_reasons, encoding,
+                                                         defined_ranges: defined_ranges,
+                                                         nodes: collected[:flow_nodes])
+      decisions + additional_decisions_for(program, bytes, source_id, file_reasons, encoding,
+                                           collected: collected, decisions: decisions)
+    end
+
+    def additional_decisions_for(_program, _bytes, _source_id, _file_reasons, _encoding, **_options)
+      []
     end
 
     def flow_decisions_for(program, bytes, source_id, file_reasons = [], encoding = "UTF-8",
                            defined_ranges: nil, nodes: nil)
       defined_ranges ||= collect_defined_ranges(program)
 
-      super(program, bytes, source_id, file_reasons, encoding, nodes: nodes).map do |decision|
-        next decision unless range_within_defined_expression?(decision, defined_ranges)
-
-        decision.merge(
-          support_status: "UNSUPPORTED",
-          support_reasons: (Array(decision[:support_reasons]) + ["unsupported_defined_expression"]).uniq
-        )
-      end
+      nodes ||= collect_flow_decision_nodes(program)
+      nodes = nodes.reject { |node| within_defined_expression?(node, defined_ranges) }
+      super(program, bytes, source_id, file_reasons, encoding, nodes: nodes)
     end
 
     def collect_defined_ranges(program)
@@ -271,10 +289,14 @@ module Branchproof
         literal_truth = leaf.delete(:_literal_truth)
         constraint = leaf.delete(:_constraint)
         constraint_safe = leaf.delete(:_constraint_safe)
-        Records.build(id: nil, index: index, byte_start: location.start_offset, byte_length: location.length,
-                      line: location.start_line, column: location.start_column,
-                      expression: expression, literal_truth: literal_truth, coupling: "unknown",
-                      constraint: constraint, constraint_safe: decision_constraint_safe && constraint_safe == true)
+        contextual = leaf.delete(:_contextual)
+        condition = Records.build(id: nil, index: index, byte_start: location.start_offset,
+                                  byte_length: location.length,
+                                  line: location.start_line, column: location.start_column,
+                                  expression: expression, literal_truth: literal_truth, coupling: "unknown",
+                                  constraint: constraint,
+                                  constraint_safe: decision_constraint_safe && constraint_safe == true)
+        contextual ? condition.merge(contextual: contextual) : condition
       end
       decision_id = Records.decision_id(source_id: source_id, context: context, byte_start: start_offset,
                                         byte_length: length, tree: tree)
@@ -319,7 +341,7 @@ module Branchproof
         inventoried_boolean_nodes[node] = true
         mark_semantic_boolean_nodes(node.left, inventoried_boolean_nodes)
         mark_semantic_boolean_nodes(node.right, inventoried_boolean_nodes)
-      when Prism::MatchPredicateNode
+      when Prism::DefinedNode, Prism::MatchPredicateNode
         inventoried_boolean_nodes[node] = true
       when Prism::CallNode
         mark_semantic_boolean_nodes(node.receiver, inventoried_boolean_nodes) if unary_not?(node)
@@ -355,6 +377,9 @@ module Branchproof
                          { start: location.start_offset, length: location.length }
                        end
       }
+      leaf[:_contextual] = "implicit_regexp" if node.is_a?(Prism::MatchLastLineNode) ||
+                                                node.is_a?(Prism::InterpolatedMatchLastLineNode)
+      leaf[:_contextual] = "flip_flop" if node.is_a?(Prism::FlipFlopNode)
       leaves << leaf
       Records.build(type: :atom, index: leaves.length - 1)
     end
@@ -393,12 +418,7 @@ module Branchproof
 
     def unsupported_reasons(predicate, bytes)
       reasons = []
-      walk(predicate) do |node|
-        if node.is_a?(Prism::MatchLastLineNode) || node.is_a?(Prism::InterpolatedMatchLastLineNode)
-          reasons << "unsupported_implicit_regexp"
-        end
-        reasons << "unsupported_flip_flop" if node.is_a?(Prism::FlipFlopNode)
-        reasons << "unsupported_defined_expression" if node.is_a?(Prism::DefinedNode)
+      walk_skipping_defined_operands(predicate) do |node|
         reasons << "unsupported_heredoc" if node.respond_to?(:opening_loc) && node.opening_loc &&
                                             bytes.byteslice(node.opening_loc.start_offset,
                                                             node.opening_loc.length).start_with?("<<")
@@ -406,6 +426,13 @@ module Branchproof
       reasons
     end
 
+    def walk_skipping_defined_operands(node, &block)
+      yield node
+      return if node.is_a?(Prism::DefinedNode)
+
+      node.child_nodes.each { |child| walk_skipping_defined_operands(child, &block) if child }
+    end
+
     def unwrap_predicate(node)
       while node.is_a?(Prism::ParenthesesNode)
         statements = node.body

data/lib/branchproof/value_instrumentation.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Branchproof
+  # Source rewrite for value observations; it preserves the wrapped value.
+  module ValueInstrumentation
+    private
+
+    def render_flow(bytes, decision, nested, encloses)
+      return render_value(bytes, decision, nested, encloses) if decision.dig(:instrumentation, :type) == "value"
+
+      super
+    end
+
+    # rubocop:disable-next Metrics/MethodLength -- success and exception traces differ.
+    def render_value(bytes, decision, nested, encloses)
+      expression = render_children(bytes, decision[:byte_start], decision[:byte_length], nested, encloses)
+      metadata = decision.fetch(:instrumentation)
+      runtime = self.class::RUNTIME
+      id = decision.fetch(:id).inspect
+      domain = metadata.fetch(:domain).to_sym.inspect
+      count = decision.fetch(:alternatives).length
+      enter = "#{runtime}.enter(#{id}); #{runtime}.set_alternative_count(#{id}, #{count})"
+      if metadata.fetch(:domain).to_sym == :dispatch
+        "(begin; #{enter}; begin; " \
+          "(begin; #{runtime}.dispatch_path(#{id}, (#{expression}), false); end); " \
+          "rescue ::Exception; #{runtime}.dispatch_path(#{id}, nil, true); raise; " \
+          "ensure; #{runtime}.leave(#{id}); end; end)"
+      else
+        "(begin; #{enter}; begin; " \
+          "#{runtime}.value_path(#{id}, (#{expression}), #{domain}); " \
+          "ensure; #{runtime}.leave(#{id}); end; end)"
+      end
+    end
+  end
+end

data/lib/branchproof/value_runtime.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Branchproof
+  # Runtime mapping for value observations.
+  module ValueRuntime
+    # rubocop:disable Style/CaseEquality, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+    def comparison_index(value)
+      return 3 if nil.equal?(value)
+      return unless Integer === value || Float === value || Rational === value
+      return if Float === value && value.nan?
+      return 0 if value < 0 # rubocop:disable Style/NumericPredicate
+      return 1 if value == 0 # rubocop:disable Style/NumericPredicate
+      return 2 if value > 0 # rubocop:disable Style/NumericPredicate
+
+      nil
+    end
+    module_function :comparison_index
+    # rubocop:enable Style/CaseEquality, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+    def set_alternative_count(decision_id, count)
+      frame = current_frame(decision_id)
+      frame[:alternative_count] = count if frame
+      nil
+    end
+
+    # rubocop:disable-next Metrics/MethodLength -- trace state branches are explicit.
+    # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity -- domain dispatch mirrors the observable value contract.
+    def value_path(decision_id, value, domain)
+      frame = current_frame(decision_id)
+      return value unless frame
+      return value if frame[:finished]
+
+      index = case domain.to_sym
+              when :truthiness, :defined then value ? 1 : 0
+              when :lookup
+                if nil.equal?(value)
+                  2
+                elsif value
+                  0
+                else
+                  1
+                end
+              when :comparison then comparison_index(value)
+              when :dispatch then 0
+              end
+      if index
+        frame[:observations] = if frame.fetch(:alternative_count, index + 1) == 2
+                                 [[0, index.zero?], [1, index == 1]]
+                               else
+                                 (0..index).map { |position| [position, position == index] }
+                               end
+        frame[:outcome] = true
+        frame[:finished] = true
+      end
+      value
+    rescue NoMethodError, ArgumentError
+      # A user-defined <=> may return an incomparable object. Preserve it and
+      # leave the vector incomplete instead of inventing a domain bucket.
+      value
+    end
+
+    def dispatch_path(decision_id, value, raised)
+      frame = current_frame(decision_id)
+      return value unless frame
+
+      index = raised ? 1 : 0
+      frame[:observations] = [[0, index.zero?], [1, index == 1]]
+      frame[:outcome] = true
+      frame[:finished] = true
+      value
+    end
+  end
+end

data/lib/branchproof/value_syntax.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module Branchproof
+  # Inventory for expressions whose result is itself the observable value.
+  # This deliberately excludes control-flow predicates already owned by Source.
+  module ValueSyntax
+    BOOLEAN_OPERATORS = %i[== != < <= > >= === =~ !~].freeze
+    DISPATCH_METHODS = %i[public_send send __send__].freeze
+
+    # rubocop:disable-next Metrics/ParameterLists -- source seam mirrors Source#decisions_for.
+    def additional_decisions_for(program, bytes, source_id, file_reasons, encoding, decisions:, collected:)
+      occupied = decisions.each_with_object({}) do |decision, ranges|
+        ranges[range_key(decision[:byte_start], decision[:byte_length])] = true
+        Array(decision[:conditions]).each do |condition|
+          ranges[range_key(condition[:byte_start], condition[:byte_length])] = true
+        end
+      end
+      value_decisions_for(
+        program, bytes, source_id, nodes: collected.fetch(:value_nodes), occupied_ranges: occupied,
+                                   file_reasons: file_reasons, encoding: encoding
+      )
+    end
+
+    # `nodes:` is supplied by Source's fused AST walk. It remains optional for
+    # the standalone discovery API used by focused syntax tests.
+    # rubocop:disable-next Metrics/MethodLength, Metrics/ParameterLists -- source seam mirrors Source#decisions_for.
+    def value_decisions_for(program, bytes, source_id, nodes: nil, occupied_ranges: {}, file_reasons: [],
+                            encoding: "UTF-8")
+      occupied = occupied_ranges.transform_keys do |range|
+        range.is_a?(Array) ? range_key(*range) : range
+      end
+      decisions = []
+      each_value_node(program, nodes) do |node|
+        spec = value_spec(node)
+        next unless spec
+
+        key = range_key(node.location.start_offset, node.location.length)
+        next if occupied[key]
+
+        decisions << build_value_decision(node, spec, bytes, source_id, file_reasons, encoding)
+        occupied[key] = true
+      end
+      decisions
+    end
+
+    private
+
+    def value_candidate_node?(node)
+      !value_spec(node).nil?
+    end
+
+    def each_value_node(program, nodes, &)
+      return nodes.each(&) if nodes
+
+      walker = respond_to?(:walk_skipping_defined_operands, true) ? :walk_skipping_defined_operands : :walk
+      send(walker, program, &)
+    end
+
+    def range_key(start_offset, length)
+      (start_offset << 32) | length
+    end
+
+    # rubocop:disable-next Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+    def value_spec(node)
+      if Prism.const_defined?(:MatchWriteNode) && node.is_a?(Prism::MatchWriteNode)
+        return { context: "match_capture", domain: :truthiness, alternatives: %w[false true], type: "value" }
+      end
+      return nil unless node.is_a?(Prism::CallNode)
+
+      name = node.name.to_sym
+      if name == :<=>
+        return { context: "comparison", domain: :comparison, alternatives: %w[negative zero positive nil],
+                 type: "value" }
+      end
+      return { context: "lookup", domain: :lookup, alternatives: %w[truthy false nil], type: "value" } if name == :[]
+      if DISPATCH_METHODS.include?(name)
+        return { context: "dispatch", domain: :dispatch, alternatives: %w[success exception],
+                 type: "value" }
+      end
+      if BOOLEAN_OPERATORS.include?(name) || name.to_s.end_with?("?")
+        return { context: "predicate", domain: :truthiness, alternatives: %w[false true],
+                 type: "value" }
+      end
+
+      nil
+    end
+
+    # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/ParameterLists, Metrics/PerceivedComplexity -- record assembly is intentionally explicit.
+    def build_value_decision(node, spec, bytes, source_id, file_reasons, encoding)
+      location = node.location
+      expression = text_value(bytes.byteslice(location.start_offset, location.length), encoding)
+      alternatives = spec.fetch(:alternatives).each_with_index.map do |label, index|
+        { index: index, id: nil, expression: label, byte_start: location.start_offset, byte_length: location.length }
+      end
+      id = Records.decision_id(source_id: source_id, context: spec.fetch(:context),
+                               byte_start: location.start_offset, byte_length: location.length,
+                               tree: nil)
+      alternatives = alternatives.map { |item| item.merge(id: Records.condition_id(id, item.fetch(:index))) }
+      kind = alternatives.length == 2 ? "implicit" : "multiway"
+      reasons = Array(file_reasons)
+      reasons += Array(unsupported_reasons(node, bytes)) if respond_to?(:unsupported_reasons, true)
+      limit = @limits[:conditions_per_decision] if defined?(@limits) && @limits.respond_to?(:[])
+      reasons << "alternative_limit_exceeded" if limit && alternatives.length > limit
+      Records.build(id: id, source_id: source_id, kind: kind, context: spec.fetch(:context),
+                    byte_start: location.start_offset, byte_length: location.length,
+                    line: location.start_line, column: location.start_column,
+                    expression: expression, tree: nil, conditions: [],
+                    alternatives: alternatives, discovered_condition_count: 0,
+                    support_status: reasons.empty? ? "SUPPORTED" : "UNSUPPORTED",
+                    support_reasons: reasons.uniq, opaque_ranges: [],
+                    instrumentation: { type: "value", domain: spec.fetch(:domain) })
+    end
+  end
+end

data/lib/branchproof/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Branchproof
-  VERSION = "0.8.0"
+  VERSION = "0.9.0"
 end

data/llms.txt

@@ -2,10 +2,11 @@
 
 |  |  |
 | --- | --- |
-| **Defined in** | lib/branchproof.rb, lib/branchproof/cli.rb, lib/branchproof/limits.rb, lib/branchproof/loader.rb, lib/branchproof/report.rb, lib/branchproof/source.rb, lib/branchproof/worker.rb, lib/branchproof/project.rb, lib/branchproof/records.rb, lib/branchproof/runtime.rb, lib/branchproof/version.rb, lib/branchproof/analyzer.rb, lib/branchproof/evidence.rb, lib/branchproof/minimizer.rb, lib/branchproof/comparison.rb, lib/branchproof/constraints.rb, lib/branchproof/instrumenter.rb, lib/branchproof/runtime_flow.rb, lib/branchproof/saved_report.rb, lib/branchproof/rails_support.rb, lib/branchproof/coverage_index.rb, lib/branchproof/decision_table.rb, lib/branchproof/focused_report.rb, lib/branchproof/decision_syntax.rb, lib/branchproof/minitest_adapter.rb, lib/branchproof/comparison_report.rb, lib/branchproof/flow_instrumentation.rb |
+| **Defined in** | lib/branchproof.rb, lib/branchproof/cli.rb, lib/branchproof/limits.rb, lib/branchproof/loader.rb, lib/branchproof/report.rb, lib/branchproof/source.rb, lib/branchproof/worker.rb, lib/branchproof/project.rb, lib/branchproof/records.rb, lib/branchproof/runtime.rb, lib/branchproof/version.rb, lib/branchproof/analyzer.rb, lib/branchproof/evidence.rb, lib/branchproof/minimizer.rb, lib/branchproof/comparison.rb, lib/branchproof/constraints.rb, lib/branchproof/instrumenter.rb, lib/branchproof/runtime_flow.rb, lib/branchproof/saved_report.rb, lib/branchproof/value_syntax.rb, lib/branchproof/rails_support.rb, lib/branchproof/value_runtime.rb, lib/branchproof/coverage_index.rb, lib/branchproof/decision_table.rb, lib/branchproof/default_syntax.rb, lib/branchproof/focused_report.rb, lib/branchproof/decision_syntax.rb, lib/branchproof/default_runtime.rb, lib/branchproof/exception_syntax.rb, lib/branchproof/iteration_syntax.rb, lib/branchproof/minitest_adapter.rb, lib/branchproof/comparison_report.rb, lib/branchproof/exception_runtime.rb, lib/branchproof/iteration_runtime.rb, lib/branchproof/flow_instrumentation.rb, lib/branchproof/value_instrumentation.rb, lib/branchproof/default_instrumentation.rb, lib/branchproof/exception_instrumentation.rb, lib/branchproof/iteration_instrumentation.rb, lib/branchproof/extended_alternative_runtime.rb |
 
-Keep each bounded source rewrite together so its evaluation order can be
-audited. rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+Keep source-boundary and parameter-binding rules together for auditing.
+rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity,
+Metrics/MethodLength, Metrics/ModuleLength, Metrics/PerceivedComplexity
 
 ## Constants
 ### `VERSION` <a id="constant-VERSION"></a> <a id="VERSION-constant"></a>
@@ -22,11 +23,21 @@ Not documented.
 - [Branchproof/CoverageIndex.md](doc/Branchproof/CoverageIndex.md)
 - [Branchproof/DecisionSyntax.md](doc/Branchproof/DecisionSyntax.md)
 - [Branchproof/DecisionTable.md](doc/Branchproof/DecisionTable.md)
+- [Branchproof/DefaultInstrumentation.md](doc/Branchproof/DefaultInstrumentation.md)
+- [Branchproof/DefaultRuntime.md](doc/Branchproof/DefaultRuntime.md)
+- [Branchproof/DefaultSyntax.md](doc/Branchproof/DefaultSyntax.md)
 - [Branchproof/Error.md](doc/Branchproof/Error.md)
 - [Branchproof/Evidence.md](doc/Branchproof/Evidence.md)
+- [Branchproof/ExceptionInstrumentation.md](doc/Branchproof/ExceptionInstrumentation.md)
+- [Branchproof/ExceptionRuntime.md](doc/Branchproof/ExceptionRuntime.md)
+- [Branchproof/ExceptionSyntax.md](doc/Branchproof/ExceptionSyntax.md)
+- [Branchproof/ExtendedAlternativeRuntime.md](doc/Branchproof/ExtendedAlternativeRuntime.md)
 - [Branchproof/FlowInstrumentation.md](doc/Branchproof/FlowInstrumentation.md)
 - [Branchproof/FocusedReport.md](doc/Branchproof/FocusedReport.md)
 - [Branchproof/Instrumenter.md](doc/Branchproof/Instrumenter.md)
+- [Branchproof/IterationInstrumentation.md](doc/Branchproof/IterationInstrumentation.md)
+- [Branchproof/IterationRuntime.md](doc/Branchproof/IterationRuntime.md)
+- [Branchproof/IterationSyntax.md](doc/Branchproof/IterationSyntax.md)
 - [Branchproof/Limits.md](doc/Branchproof/Limits.md)
 - [Branchproof/Loader.md](doc/Branchproof/Loader.md)
 - [Branchproof/Minimizer.md](doc/Branchproof/Minimizer.md)
@@ -40,6 +51,9 @@ Not documented.
 - [Branchproof/RuntimeFlow.md](doc/Branchproof/RuntimeFlow.md)
 - [Branchproof/SavedReport.md](doc/Branchproof/SavedReport.md)
 - [Branchproof/Source.md](doc/Branchproof/Source.md)
+- [Branchproof/ValueInstrumentation.md](doc/Branchproof/ValueInstrumentation.md)
+- [Branchproof/ValueRuntime.md](doc/Branchproof/ValueRuntime.md)
+- [Branchproof/ValueSyntax.md](doc/Branchproof/ValueSyntax.md)
 - [Branchproof/Worker.md](doc/Branchproof/Worker.md)
 - [CHANGELOG.md](doc/CHANGELOG.md)
 - [README.md](doc/README.md)

data/sig/branchproof.rbs

@@ -68,6 +68,23 @@ module Branchproof
     def self.flow_path: (String decision_id, Integer index) -> nil
     def self.flow_finish: (String decision_id, untyped value, ?Integer? default_path) -> untyped
     def self.flow_receiver: (String decision_id, untyped receiver) -> untyped
+    def self.flow_assignment_receiver: (String decision_id, untyped receiver) -> untyped
+    def self.flow_assignment_path: (String decision_id, Integer index) -> nil
+    def self.flow_assignment_finish: (String decision_id, untyped value, ?Integer? default_path) -> untyped
+    def self.exception_enter: (String decision_id, Integer unhandled_index) -> nil
+    def self.exception_path: (String decision_id, Integer index) -> nil
+    def self.exception_value: (String decision_id, untyped value, Integer index) -> untyped
+    def self.exception_finish: (String decision_id, untyped value) -> untyped
+    def self.exception_unhandled: (String decision_id) -> nil
+    def self.exception_leave: (String decision_id) -> nil
+    def self.default_binding: (String decision_id, Integer index) -> nil
+    def self.set_alternative_count: (String decision_id, Integer count) -> nil
+    def self.value_path: (String decision_id, untyped value, Symbol domain) -> untyped
+    def self.dispatch_path: (String decision_id, untyped value, bool raised) -> untyped
+    def self.flow_iteration_begin: (String decision_id, untyped receiver, ?Integer alternative_count) -> untyped
+    def self.flow_iteration_callback: (String decision_id, ?Integer alternative_count) -> nil
+    def self.flow_iteration_finish: (String decision_id, untyped value, ?Integer? default_path) -> untyped
+    def self.flow_iteration_leave: (String decision_id) -> nil
     def self.context: (?test_id: String?, ?phase: String?) -> nil
     def self.snapshot: () -> record
     def self.diagnostics: () -> Array[record]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: branchproof
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.9.0
 platform: ruby
 authors:
 - Lucian Ghinda
@@ -75,11 +75,21 @@ files:
 - doc/Branchproof/CoverageIndex.md
 - doc/Branchproof/DecisionSyntax.md
 - doc/Branchproof/DecisionTable.md
+- doc/Branchproof/DefaultInstrumentation.md
+- doc/Branchproof/DefaultRuntime.md
+- doc/Branchproof/DefaultSyntax.md
 - doc/Branchproof/Error.md
 - doc/Branchproof/Evidence.md
+- doc/Branchproof/ExceptionInstrumentation.md
+- doc/Branchproof/ExceptionRuntime.md
+- doc/Branchproof/ExceptionSyntax.md
+- doc/Branchproof/ExtendedAlternativeRuntime.md
 - doc/Branchproof/FlowInstrumentation.md
 - doc/Branchproof/FocusedReport.md
 - doc/Branchproof/Instrumenter.md
+- doc/Branchproof/IterationInstrumentation.md
+- doc/Branchproof/IterationRuntime.md
+- doc/Branchproof/IterationSyntax.md
 - doc/Branchproof/Limits.md
 - doc/Branchproof/Loader.md
 - doc/Branchproof/Minimizer.md
@@ -93,6 +103,9 @@ files:
 - doc/Branchproof/RuntimeFlow.md
 - doc/Branchproof/SavedReport.md
 - doc/Branchproof/Source.md
+- doc/Branchproof/ValueInstrumentation.md
+- doc/Branchproof/ValueRuntime.md
+- doc/Branchproof/ValueSyntax.md
 - doc/Branchproof/Worker.md
 - doc/CHANGELOG.md
 - doc/README.md
@@ -107,10 +120,20 @@ files:
 - lib/branchproof/coverage_index.rb
 - lib/branchproof/decision_syntax.rb
 - lib/branchproof/decision_table.rb
+- lib/branchproof/default_instrumentation.rb
+- lib/branchproof/default_runtime.rb
+- lib/branchproof/default_syntax.rb
 - lib/branchproof/evidence.rb
+- lib/branchproof/exception_instrumentation.rb
+- lib/branchproof/exception_runtime.rb
+- lib/branchproof/exception_syntax.rb
+- lib/branchproof/extended_alternative_runtime.rb
 - lib/branchproof/flow_instrumentation.rb
 - lib/branchproof/focused_report.rb
 - lib/branchproof/instrumenter.rb
+- lib/branchproof/iteration_instrumentation.rb
+- lib/branchproof/iteration_runtime.rb
+- lib/branchproof/iteration_syntax.rb
 - lib/branchproof/limits.rb
 - lib/branchproof/loader.rb
 - lib/branchproof/minimizer.rb
@@ -123,6 +146,9 @@ files:
 - lib/branchproof/runtime_flow.rb
 - lib/branchproof/saved_report.rb
 - lib/branchproof/source.rb
+- lib/branchproof/value_instrumentation.rb
+- lib/branchproof/value_runtime.rb
+- lib/branchproof/value_syntax.rb
 - lib/branchproof/version.rb
 - lib/branchproof/worker.rb
 - lib/mcdc.rb