branchproof 0.7.0 → 0.9.0

data/lib/branchproof/source.rb

@@ -4,11 +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
 
@@ -58,11 +70,13 @@ module Branchproof
     end
 
     def read_unit(path)
+      absolute_path = File.expand_path(path)
+      relative_path = relative(path)
       bytes = File.binread(path)
       parsed = Prism.parse(bytes)
       encoding = source_encoding(bytes, parsed)
-      source_id = Records.source_id(relative_path: relative(path), digest: Digest::SHA256.hexdigest(bytes),
-                                    encoding: encoding)
+      digest = Digest::SHA256.hexdigest(bytes)
+      source_id = Records.source_id(relative_path: relative_path, digest: digest, encoding: encoding)
       diagnostics = parsed.errors.map do |error|
         Records.diagnostic(code: "parse_error", severity: "error", message: error.message, source_id: source_id,
                            details: { byte_start: error.location.start_offset, byte_length: error.location.length })
@@ -78,11 +92,11 @@ module Branchproof
       file_reasons << "unsupported_data_section" if parsed.respond_to?(:data_loc) && parsed.data_loc
       file_reasons << "parse_error" unless parsed.errors.empty?
       decisions = parsed.value ? decisions_for(parsed.value, bytes, source_id, file_reasons, encoding) : []
-      Records.build(source_id: source_id, relative_path: relative(path), absolute_path: File.expand_path(path),
-                    real_path: File.realpath(path), digest: Digest::SHA256.hexdigest(bytes), encoding: encoding,
+      Records.build(source_id: source_id, relative_path: relative_path, absolute_path: absolute_path,
+                    real_path: File.realpath(path), digest: digest, encoding: encoding,
                     original_bytes: bytes, decisions: decisions, diagnostics: diagnostics)
     rescue SystemCallError => e
-      Records.build(source_id: nil, relative_path: relative(path), absolute_path: File.expand_path(path),
+      Records.build(source_id: nil, relative_path: relative_path, absolute_path: absolute_path,
                     real_path: nil, digest: nil, encoding: nil, original_bytes: nil, decisions: [],
                     diagnostics: [Records.diagnostic(code: "source_unreadable", severity: "error", message: e.message)])
     end
@@ -100,25 +114,56 @@ module Branchproof
       Encoding::UTF_8.name
     end
 
+    # Walks the whole program AST exactly once, sorting every node into the
+    # buckets the two classification phases below need. Phase one (decision
+    # and case-when nodes) must run to completion before phase two (bare
+    # boolean/pattern nodes) because phase two skips nodes phase one already
+    # inventoried via mark_semantic_boolean_nodes.
+    def collect_ast_nodes(program)
+      defined_ranges = []
+      guard_patterns = {}.compare_by_identity
+      phase_one_nodes = []
+      phase_two_nodes = []
+      flow_nodes = []
+      value_nodes = []
+
+      walk_skipping_defined_operands(program) do |node|
+        if node.is_a?(Prism::DefinedNode)
+          defined_ranges << node.location
+        elsif node.is_a?(Prism::InNode)
+          pattern = node.pattern
+          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) ||
+                                   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, value_nodes: value_nodes }
+    end
+
     def decisions_for(program, bytes, source_id, file_reasons = [], encoding = "UTF-8")
       specs = []
       inventoried_boolean_nodes = {}.compare_by_identity
-      defined_ranges = []
-      pattern_guard_nodes = pattern_guard_nodes_for(program)
+      collected = collect_ast_nodes(program)
+      defined_ranges = collected[:defined_ranges]
+      guard_patterns = collected[:guard_patterns]
 
-      walk(program) do |node|
-        defined_ranges << node.location if node.is_a?(Prism::DefinedNode)
+      collected[:phase_one_nodes].each do |node|
         if decision_node?(node)
           predicate = node.predicate
           next unless predicate
 
           predicate = unwrap_predicate(predicate)
-          context = pattern_guard_nodes[node] ? "pattern_guard" : decision_context(node, bytes)
+          context = guard_patterns[node] ? "pattern_guard" : decision_context(node, bytes)
           specs << { node: node, predicate: predicate, context: context }
           mark_semantic_boolean_nodes(predicate, inventoried_boolean_nodes)
-        elsif subjectless_case?(node)
-          when_nodes(node).each do |when_node|
-            when_predicates(when_node).each do |predicate|
+        else
+          conditions_for(node).each do |when_node|
+            conditions_for(when_node).each do |predicate|
               predicate = unwrap_predicate(predicate)
               specs << { node: when_node, predicate: predicate, context: "case_when" }
               mark_semantic_boolean_nodes(predicate, inventoried_boolean_nodes)
@@ -129,18 +174,19 @@ module Branchproof
 
       # Boolean expressions nested in an atomic expression (for example, a call
       # argument) are separate decisions when tree_for did not decompose them.
-      walk(program) do |node|
-        next unless boolean_node?(node) || node.is_a?(Prism::MatchPredicateNode)
+      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
 
@@ -158,42 +204,35 @@ 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)
+      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 flow_decisions_for(program, bytes, source_id, file_reasons = [], encoding = "UTF-8")
-      defined_ranges = []
-      walk(program) do |node|
-        defined_ranges << node.location if node.is_a?(Prism::DefinedNode)
-      end
+    def additional_decisions_for(_program, _bytes, _source_id, _file_reasons, _encoding, **_options)
+      []
+    end
 
-      super.map do |decision|
-        next decision unless range_within_defined_expression?(decision, defined_ranges)
+    def flow_decisions_for(program, bytes, source_id, file_reasons = [], encoding = "UTF-8",
+                           defined_ranges: nil, nodes: nil)
+      defined_ranges ||= collect_defined_ranges(program)
 
-        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 pattern_guard_nodes_for(program)
-      guards = {}.compare_by_identity
-      walk(program) do |node|
-        next unless node.is_a?(Prism::InNode)
-
-        pattern = node.pattern
-        guards[pattern] = true if pattern.is_a?(Prism::IfNode) || pattern.is_a?(Prism::UnlessNode)
-      end
-      guards
+    def collect_defined_ranges(program)
+      defined_ranges = []
+      walk(program) { |node| defined_ranges << node.location if node.is_a?(Prism::DefinedNode) }
+      defined_ranges
     end
 
     def range_within_defined_expression?(decision, defined_ranges)
       start_offset = decision[:byte_start]
-      end_offset = start_offset + decision[:byte_length]
-      defined_ranges.any? do |defined_location|
-        defined_location.start_offset <= start_offset && defined_location.end_offset >= end_offset
-      end
+      offsets_within_defined_expression?(start_offset, start_offset + decision[:byte_length], defined_ranges)
     end
 
     def walk(node, &block)
@@ -214,16 +253,7 @@ module Branchproof
       node.is_a?(Prism::CaseNode) && node.predicate.nil?
     end
 
-    def when_nodes(node)
-      conditions = node.conditions
-      if conditions.is_a?(Array)
-        conditions
-      else
-        (conditions.respond_to?(:body) ? conditions.body : [])
-      end
-    end
-
-    def when_predicates(node)
+    def conditions_for(node)
       conditions = node.conditions
       if conditions.is_a?(Array)
         conditions
@@ -249,6 +279,7 @@ module Branchproof
       context ||= decision_context(node, bytes)
       leaves = []
       tree = tree_for(predicate, bytes, leaves)
+      decision_constraint_safe = constraint_safe_expression?(predicate)
       start_offset = predicate.location.start_offset
       length = predicate.location.length
       opaque_ranges = leaves.filter_map { |leaf| leaf.delete(:_opaque_range) }
@@ -256,9 +287,16 @@ module Branchproof
         expression = text_value(leaf.delete(:_expression), "UTF-8")
         location = leaf.delete(:_location)
         literal_truth = leaf.delete(:_literal_truth)
-        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 = leaf.delete(:_constraint)
+        constraint_safe = leaf.delete(:_constraint_safe)
+        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)
@@ -287,9 +325,12 @@ module Branchproof
 
     def within_defined_expression?(node, defined_ranges)
       location = node.location
+      offsets_within_defined_expression?(location.start_offset, location.end_offset, defined_ranges)
+    end
+
+    def offsets_within_defined_expression?(start_offset, end_offset, defined_ranges)
       defined_ranges.any? do |defined_location|
-        defined_location.start_offset <= location.start_offset &&
-          defined_location.end_offset >= location.end_offset
+        defined_location.start_offset <= start_offset && defined_location.end_offset >= end_offset
       end
     end
 
@@ -300,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)
@@ -330,14 +371,40 @@ module Branchproof
       leaf = {
         _expression: bytes.byteslice(location.start_offset, location.length), _location: location,
         _literal_truth: literal_truth(node),
+        _constraint: (constraint = Constraints.for_node(node)),
+        _constraint_safe: safe_constraint_node?(constraint),
         _opaque_range: if node.is_a?(Prism::CallNode) && node.name == :!
                          { 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
 
+    # Source-derived comparisons are deliberately untrusted. Ruby permits
+    # mutation between leaves and user-defined operators, so only repeated
+    # truthiness reads of local variables in an entirely side-effect-free
+    # decision may be used by the table solver.
+    def constraint_safe_expression?(node)
+      node = unwrap_predicate(node)
+      case node
+      when Prism::AndNode, Prism::OrNode
+        constraint_safe_expression?(node.left) && constraint_safe_expression?(node.right)
+      when Prism::LocalVariableReadNode, Prism::TrueNode, Prism::FalseNode, Prism::NilNode,
+           Prism::IntegerNode, Prism::FloatNode, Prism::SymbolNode, Prism::StringNode
+        true
+      else
+        false
+      end
+    end
+
+    def safe_constraint_node?(constraint)
+      constraint && constraint[:operator] == "truthy" && constraint[:subject][:kind] == "local"
+    end
+
     def unary_not?(node)
       node.is_a?(Prism::CallNode) && node.name == :! && node.receiver && node.call_operator_loc.nil?
     end
@@ -351,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?("<<")
@@ -364,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.7.0"
+  VERSION = "0.9.0"
 end

data/lib/branchproof/worker.rb

@@ -14,12 +14,9 @@ module Branchproof
 
     def child_process(config_path)
       payload = JSON.parse(File.binread(config_path))
-      project = symbolize(payload.fetch("project", legacy_project))
+      project = symbolize(payload.fetch("project"))
       prepend_load_paths(project)
       inventory = symbolize(payload.fetch("inventory"))
-      Array(inventory[:source_units]).each do |unit|
-        unit[:original_bytes] = File.binread(unit[:absolute_path]) if unit[:absolute_path]
-      end
       limits = symbolize(payload.fetch("limits"))
       require "minitest"
       require "minitest/test"

data/lib/branchproof.rb

@@ -16,6 +16,8 @@ module Branchproof
   autoload :MinitestAdapter, "branchproof/minitest_adapter"
   autoload :Evidence, "branchproof/evidence"
   autoload :Analyzer, "branchproof/analyzer"
+  autoload :Constraints, "branchproof/constraints"
+  autoload :DecisionTable, "branchproof/decision_table"
   autoload :Minimizer, "branchproof/minimizer"
   autoload :Report, "branchproof/report"
   autoload :CoverageIndex, "branchproof/coverage_index"

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/instrumenter.rb, lib/branchproof/runtime_flow.rb, lib/branchproof/saved_report.rb, lib/branchproof/rails_support.rb, lib/branchproof/coverage_index.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>
@@ -17,13 +18,26 @@ Not documented.
 - [Branchproof/CLI.md](doc/Branchproof/CLI.md)
 - [Branchproof/Comparison.md](doc/Branchproof/Comparison.md)
 - [Branchproof/ComparisonReport.md](doc/Branchproof/ComparisonReport.md)
+- [Branchproof/Constraints/Solver.md](doc/Branchproof/Constraints/Solver.md)
+- [Branchproof/Constraints.md](doc/Branchproof/Constraints.md)
 - [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)
@@ -37,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)