branchproof 0.6.0 → 0.7.0

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

data/lib/branchproof/focused_report.rb

@@ -23,7 +23,11 @@ module Branchproof
       completeness = fetch(@document, :completeness) || {}
       evidence = fetch(@document, :observations) || {}
       lines = ["Branchproof focused view: #{@view}", "Tests: #{fetch(baseline, :status) || "INCOMPLETE"}",
-               "Values: T=true, F=false, -=short-circuited"]
+               (if @index.alternatives.empty?
+                  "Values: T=true, F=false, -=short-circuited"
+                else
+                  "Values: Boolean T=true/F=false; flow T=selected, F=not-selected, -=skipped"
+                end)]
       if completeness.values.include?(false) || fetch(baseline, :status).to_s != "PASSED"
         lines << "Warning: failed or incomplete run; observations and proof evidence may be unavailable."
       end
@@ -35,7 +39,12 @@ module Branchproof
       lines << "Empty groups mean no recorded completed observation."
       lines << ""
       lines.concat(@coordinator.coverage_ladder_lines)
-      @view == :conditions ? render_conditions(lines) : render_tests(lines)
+      if @view == :conditions
+        render_conditions(lines)
+        render_alternatives(lines)
+      else
+        render_tests(lines)
+      end
       render_unowned(lines)
       render_unsupported(lines)
       Array(fetch(@document, :diagnostics)).each do |diagnostic|
@@ -53,6 +62,8 @@ module Branchproof
         lines << "Condition: #{row[:expression]}"
         lines << "Location: #{location(row[:relative_path], row[:line], unavailable: "condition line unavailable")}"
         lines << "Decision: #{row[:decision_expression]} (condition #{row[:index]})"
+        lines << "Kind: #{row[:kind]}"
+        lines << "Context: #{row[:context]}" unless row[:context].to_s.empty?
         status = if @level == 1 && !coverage_available?
                    "NOT CALCULATED"
                  else
@@ -106,16 +117,52 @@ module Branchproof
       end
     end
 
+    def render_alternatives(lines)
+      rows = @index.alternatives
+      rows = rows.select { |row| row[:missing] || row[:status].to_s != "covered" } if @missing_only && @level > 1
+      rows.each do |row|
+        lines << "Alternative #{row[:index]}: #{row[:expression]}"
+        lines << "Location: #{location(row[:relative_path], row[:line],
+                                       unavailable: "alternative location unavailable")}"
+        lines << "Decision: #{row[:decision_expression]} (alternative #{row[:index]})"
+        lines << "Kind: #{row[:kind]}"
+        lines << "Context: #{row[:context]}" unless row[:context].to_s.empty?
+        lines << "Selection: #{row[:status] || "NOT_CALCULATED"}"
+        lines << "MC/DC: N/A (not applicable)"
+        render_alternative_group(lines, "Selected by", row[:selected])
+        render_alternative_group(lines, "Not selected by", row[:not_selected])
+        render_alternative_group(lines, "Skipped in", row[:skipped])
+        if row[:missing]
+          lines << "  Missing alternative: #{row[:expression]}"
+          lines << "  Need selection of: #{row[:expression]}"
+        end
+        lines << ""
+      end
+      lines << "No missing alternatives" if @missing_only && rows.empty?
+    end
+
+    def render_alternative_group(lines, heading, evidence)
+      evidence ||= {}
+      ids = Array(evidence[:test_ids]).map { |id| test_label(id) }
+      ids << "unattributed" if evidence[:unattributed_count].to_i.positive?
+      lines << "  #{heading}: #{ids.empty? ? "none recorded" : ids.uniq.join(", ")}"
+    end
+
     def render_tests(lines)
       rows = @index.tests
       missing_ids = @index.conditions.reject { |row| row[:status].to_s.upcase == "PROVEN" }.map { |row| row[:id] }
-      rows.each { |row| render_test_row(lines, row, missing_ids) }
+      missing_alternative_ids = @index.alternatives.select { |row| row[:missing] || row[:status].to_s != "covered" }
+                                      .map { |row| row[:alternative_id] }
+      rows.each { |row| render_test_row(lines, row, missing_ids, missing_alternative_ids) }
     end
 
-    def render_test_row(lines, row, missing_ids)
+    def render_test_row(lines, row, missing_ids, missing_alternative_ids = [])
       observations = row[:observations]
       if @missing_only
-        observations = observations.select { |observation| missing_ids.include?(observation[:condition_id]) }
+        observations = observations.select do |observation|
+          missing_ids.include?(observation[:condition_id]) ||
+            missing_alternative_ids.include?(observation[:alternative_id])
+        end
         return if observations.empty?
       end
       lines << "Test: #{row[:name]}"
@@ -131,31 +178,51 @@ module Branchproof
         lines << "  No recorded completed condition observations"
         return
       end
-      observations.group_by { |observation| observation[:condition_id] }.each_value do |items|
+      grouped = observations.group_by { |observation| observation[:alternative_id] || observation[:condition_id] }
+      grouped.each_value do |items|
         observation = items.first
-        observed_values = items.map { |item| item[:value] }.uniq
-        label = observed_values.all?(&:nil?) ? "short-circuited-only" : "evaluated"
-        label += "; owns canonical witness evidence" if @level > 1 && items.any? { |item| item[:owns_witness] }
         phases = items.flat_map { |item| item[:phases] }.uniq.sort.join(", ")
-        signs = values(values: observed_values)
-        condition_location = location(observation[:relative_path], observation[:line],
-                                      unavailable: "condition line unavailable")
-        lines << "  #{observation[:expression]} (#{condition_location}): #{signs}; #{label}; " \
-                 "phases: #{phases}"
+        if observation[:alternative_id]
+          states = items.map { |item| item[:alternative_state] }.uniq.join(", ")
+          alternative_location = location(observation[:relative_path], observation[:line],
+                                          unavailable: "alternative location unavailable")
+          lines << "  Alternative #{observation[:alternative_id]}: #{observation[:expression]} " \
+                   "(#{alternative_location}): #{states}; phases: #{phases}"
+        else
+          observed_values = items.map { |item| item[:value] }.uniq
+          label = observed_values.all?(&:nil?) ? "short-circuited-only" : "evaluated"
+          label += "; owns canonical witness evidence" if @level > 1 && items.any? { |item| item[:owns_witness] }
+          signs = values(values: observed_values)
+          condition_location = location(observation[:relative_path], observation[:line],
+                                        unavailable: "condition line unavailable")
+          lines << "  #{observation[:expression]} (#{condition_location}): #{signs}; #{label}; " \
+                   "phases: #{phases}"
+        end
       end
     end
 
     def render_unowned(lines)
       rows = @index.conditions
       rows = rows.reject { |row| row[:status] == "PROVEN" } if @missing_only
-      { "Unexecuted conditions" => rows.select { |row| row[:unexecuted] },
-        "Unattributed evidence" => rows.select { |row| row[:unattributed].positive? } }.each do |heading, conditions|
+      groups = { "Unexecuted conditions" => rows.select { |row| row[:unexecuted] },
+                 "Unattributed evidence" => rows.select { |row| row[:unattributed].positive? } }
+      alternative_rows = @index.alternatives
+      alternative_rows = alternative_rows.reject { |row| row[:status].to_s == "covered" } if @missing_only
+      unless alternative_rows.empty?
+        groups["Unexecuted alternatives"] = alternative_rows.select do |row|
+          row[:selected][:observed] == false && row[:not_selected][:observed] == false
+        end
+        groups["Unattributed alternative evidence"] = alternative_rows.select do |row|
+          %i[selected not_selected skipped].any? { |state| row[state][:unattributed_count].to_i.positive? }
+        end
+      end
+      groups.each do |heading, conditions|
         next if conditions.empty?
 
         lines << "#{heading}:"
         conditions.each do |row|
-          lines << "  #{row[:expression]} (#{location(row[:relative_path], row[:line],
-                                                      unavailable: "condition line unavailable")})"
+          unavailable = row[:alternative_id] ? "alternative location unavailable" : "condition line unavailable"
+          lines << "  #{row[:expression]} (#{location(row[:relative_path], row[:line], unavailable: unavailable)})"
         end
       end
     end