branchproof 0.7.0 → 0.9.0

data/lib/branchproof/iteration_syntax.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Branchproof
+  # Observe entry into source-visible callback bodies, not library internals.
+  module IterationSyntax
+    ITERATORS = %i[each each_with_index times upto downto step map collect select filter reject filter_map
+                   find detect find_index take_while drop_while partition count all? any? none? one? fetch].freeze
+
+    private
+
+    def flow_decision_node?(node)
+      iteration_node?(node) || node.is_a?(Prism::MatchRequiredNode) || super
+    end
+
+    def iteration_node?(node)
+      node.is_a?(Prism::ForNode) ||
+        (node.is_a?(Prism::CallNode) && ITERATORS.include?(node.name) &&
+         node.block.is_a?(Prism::BlockNode) && !node.safe_navigation?)
+    end
+
+    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+    def flow_details(node, bytes, encoding)
+      if node.is_a?(Prism::MatchRequiredNode)
+        alternatives = %w[matched mismatch].map { |label| iteration_alternative(node, label) }
+        return ["pattern", "required_pattern", alternatives,
+                { type: "required_pattern", range: byte_range(node.location) }, unsupported_reasons(node, bytes)]
+      end
+      return super unless iteration_node?(node)
+
+      body = node.is_a?(Prism::ForNode) ? node.statements : node.block.body
+      closing = node.is_a?(Prism::ForNode) ? node.end_keyword_loc : node.block.closing_loc
+      lazy = node.is_a?(Prism::CallNode) && lazy_receiver?(node.receiver)
+      fallback = node.is_a?(Prism::CallNode) && node.name == :fetch
+      context = if lazy
+                  "lazy_callback"
+                else
+                  (fallback ? "fetch_fallback" : "iteration")
+                end
+      labels = if lazy
+                 ["callback entered"]
+               else
+                 (fallback ? ["value present", "fallback entered"] : %w[empty entered])
+               end
+      metadata = { type: "iteration", range: byte_range(node.location), lazy: lazy,
+                   insert_at: iteration_insert_at(body, closing),
+                   empty: body.nil? }
+      metadata[:receiver] = byte_range(node.receiver.location) if node.is_a?(Prism::CallNode) && node.receiver
+      [lazy ? "multiway" : "implicit", context, labels.map { |label| iteration_alternative(node, label) },
+       metadata, unsupported_reasons(node, bytes)]
+    end
+
+    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+
+    def lazy_receiver?(node)
+      node.is_a?(Prism::CallNode) && (node.name == :lazy || lazy_receiver?(node.receiver))
+    end
+
+    # Prism gives a block-level rescue/ensure BeginNode a location beginning at
+    # the `do` keyword. Inserting there would produce `call; callback; do`, so
+    # anchor the callback after the block parameters and before its statements.
+    def iteration_insert_at(body, closing)
+      return closing.start_offset unless body
+
+      if body.is_a?(Prism::BeginNode)
+        statements = body.statements
+        return statements.location.start_offset if statements&.location
+      end
+      body.location.start_offset
+    end
+
+    def iteration_alternative(node, label)
+      { expression: label, byte_start: node.location.start_offset, byte_length: node.location.length }
+    end
+  end
+end

data/lib/branchproof/limits.rb

@@ -6,6 +6,7 @@ module Branchproof
     KEYS = %i[
       conditions_per_decision vectors_per_decision owner_associations_per_run
       tests_per_run exact_candidates exact_search_nodes constraint_search_states
+      max_conditions_for_decision_table decision_table_rules_per_decision
     ].freeze
     DEFAULTS = {
       conditions_per_decision: 64,
@@ -14,7 +15,9 @@ module Branchproof
       tests_per_run: 50_000,
       exact_candidates: 32,
       exact_search_nodes: 100_000,
-      constraint_search_states: 10_000
+      constraint_search_states: 10_000,
+      max_conditions_for_decision_table: 12,
+      decision_table_rules_per_decision: 4096
     }.freeze
 
     module_function

data/lib/branchproof/loader.rb

@@ -5,8 +5,6 @@ require "digest"
 module Branchproof
   # Owns the process-local CRuby compilation hook when the VM exposes it.
   class Loader
-    STATUS_KEYS = %i[status reason].freeze
-
     def initialize(inventory:, instrumenter:)
       @inventory = inventory
       @instrumenter = instrumenter
@@ -41,7 +39,7 @@ module Branchproof
     def load_iseq(path)
       return nil unless @installed
 
-      unit = @units[canonical(path)]
+      unit = @units[path] || @units[canonical(path)]
       return nil unless unit
 
       bytes = File.binread(path)
@@ -49,7 +47,12 @@ module Branchproof
         add_diagnostic("source_drift", "selected source changed after inventory", unit[:source_id])
         return nil
       end
-      rewritten = @instrumenter.rewrite(unit: unit.merge(original_bytes: bytes))
+      begin
+        rewritten = @instrumenter.rewrite(unit: unit.merge(original_bytes: bytes))
+      rescue StandardError => e
+        add_diagnostic("rewrite_failure", "#{e.class}: #{e.message}", unit[:source_id], severity: "error")
+        return nil
+      end
       Array(rewritten[:diagnostics]).each do |diagnostic|
         add_diagnostic(diagnostic[:code], diagnostic[:message], unit[:source_id], severity: diagnostic[:severity])
       end
@@ -61,6 +64,8 @@ module Branchproof
         return nil
       end
 
+      return rewritten[:iseq] if reusable_iseq?(unit, rewritten)
+
       RubyVM::InstructionSequence.compile(
         rewritten[:bytes], unit[:real_path] || canonical(path), unit[:real_path] || canonical(path), 1,
         compile_options(unit)
@@ -108,13 +113,14 @@ module Branchproof
     end
 
     def preloaded_target?
-      @units.keys.any? { |path| $LOADED_FEATURES.any? { |feature| canonical(feature) == path } }
+      loaded = $LOADED_FEATURES.each_with_object(Set.new) { |feature, set| set << canonical(feature) }
+      @units.keys.any? { |path| loaded.include?(canonical(path)) }
     end
 
     def index_units(inventory)
       Array(inventory[:source_units]).each_with_object({}) do |unit, index|
-        path = unit[:absolute_path] || unit[:real_path]
-        index[canonical(path)] = unit if path
+        index[unit[:absolute_path]] = unit if unit[:absolute_path]
+        index[unit[:real_path]] = unit if unit[:real_path]
       end
     end
 
@@ -136,6 +142,17 @@ module Branchproof
       unit[:compile_options] || {}
     end
 
+    # The instrumenter already compiled the rewritten source once to validate it.
+    # Reuse that instruction sequence instead of compiling again, but only when
+    # it was built with the exact file/path/options this loader would use:
+    # real_path present and equal to absolute_path (so the instrumenter's file
+    # and path arguments match what we pass below), and no custom compile
+    # options (the instrumenter compiles without any).
+    def reusable_iseq?(unit, rewritten)
+      rewritten[:iseq] && compile_options(unit).empty? &&
+        unit[:real_path] && unit[:absolute_path] == unit[:real_path]
+    end
+
     def status(state, reason)
       { status: state.to_s, reason: reason&.to_s }.freeze
     end

data/lib/branchproof/minimizer.rb

@@ -140,15 +140,18 @@ module Branchproof
     end
 
     def greedy(ids, candidates, target)
+      positions = ids.each_with_index.to_h
       chosen = []
+      chosen_set = Set.new
       covered = Set.new
       until covered >= target
-        available = ids.reject { |candidate| chosen.include?(candidate) }
-        id = available.max_by { |candidate| [(candidates[candidate] - covered).length, -ids.index(candidate)] }
+        available = ids.reject { |candidate| chosen_set.include?(candidate) }
+        id = available.max_by { |candidate| [(candidates[candidate] - covered).length, -positions[candidate]] }
         break unless id
         break if (candidates[id] - covered).empty?
 
         chosen << id
+        chosen_set << id
         covered |= candidates[id]
       end
       chosen.sort.reverse_each do |candidate|
@@ -159,16 +162,20 @@ module Branchproof
       chosen.sort
     end
 
-    def result(objective, scope, target, selected, status, lower, visited, reasons, candidates = {})
-      necessary = candidates.keys.reject do |candidate|
-        others = candidates.reject { |key, _| key == candidate }.values.reduce(Set.new, :|)
-        covers?(others, target)
-      end
-      interchangeable = candidates.keys.select do |candidate|
-        candidates.fetch(candidate).intersect?(target) && candidates.reject do |key, _|
-          key == candidate
-        end.values.reduce(Set.new, :|) >= target
+    # For each target obligation, how many candidates cover it. An obligation
+    # covered by exactly one candidate makes that candidate irreplaceable.
+    def coverage_counts(candidates)
+      candidates.each_value.with_object(Hash.new(0)) do |signs, counts|
+        signs.each { |obligation| counts[obligation] += 1 }
       end
+    end
+
+    def result(objective, scope, target, selected, status, lower, visited, reasons, candidates = {})
+      counts = coverage_counts(candidates)
+      necessary = candidates.select { |_, signs| signs.any? { |obligation| counts[obligation] == 1 } }.keys
+      interchangeable = candidates.select do |_, signs|
+        !signs.empty? && signs.none? { |obligation| counts[obligation] == 1 }
+      end.keys
       { objective: objective, scope_decision_ids: scope,
         target_obligations: target.to_a.sort_by do |decision, index, sign|
           [decision.to_s, index.to_i, sign ? 1 : 0]
@@ -189,8 +196,6 @@ module Branchproof
       value&.to_i&.positive? ? value.to_i : default
     end
 
-    def covers?(set, target) = set >= target
-
     def value(vector, index) = (vector[:values] || vector["values"])[index]
     def id(record, key) = record[key].nil? ? record[key.to_s] : record[key]
     def records(record, key) = Array(id(record, key))

data/lib/branchproof/minitest_adapter.rb

@@ -13,10 +13,6 @@ module Branchproof
       @tests = {}
     end
 
-    def capabilities
-      { serial: true, phases: true }.freeze
-    end
-
     def run(test_files:, runner_args:, on_complete:, before_load: nil)
       raise ArgumentError, "test_files must be an Array" unless test_files.is_a?(Array)
       raise ArgumentError, "on_complete must respond to call" unless on_complete.respond_to?(:call)
@@ -158,12 +154,7 @@ module Branchproof
       record = @tests[test_id]
       return unless record
 
-      skipped = test.failures.any? do |failure|
-        (failure.respond_to?(:skipped?) && failure.skipped?) ||
-          (defined?(Minitest::Skip) && failure.respond_to?(:error) && failure.error.is_a?(Minitest::Skip)) ||
-          failure.class.name.to_s.include?("Skip")
-      end
-      record[:status] = if skipped
+      record[:status] = if test.skipped?
                           "skipped"
                         else
                           (test.failures.empty? ? "passed" : "failed")
@@ -182,17 +173,21 @@ module Branchproof
     end
 
     def test_id_for(test)
+      return test.instance_variable_get(:@branchproof_test_id) if test.instance_variable_defined?(:@branchproof_test_id)
+
       source = begin
         test.method(test.name).source_location
       rescue NameError
         nil
       end
-      if defined?(Branchproof::Records)
-        Branchproof::Records.id(adapter: "minitest", class_name: test.class.name, method_name: test.name,
-                                source: source)
-      else
-        "minitest:#{test.class}:#{test.name}:#{source}"
-      end
+      id = if defined?(Branchproof::Records)
+             Branchproof::Records.id(adapter: "minitest", class_name: test.class.name, method_name: test.name,
+                                     source: source)
+           else
+             "minitest:#{test.class}:#{test.name}:#{source}"
+           end
+      test.instance_variable_set(:@branchproof_test_id, id)
+      id
     end
 
     def register_test(test)

data/lib/branchproof/records.rb

@@ -43,6 +43,8 @@ module Branchproof
     end
 
     def deep_freeze(value)
+      return value if value.frozen?
+
       case value
       when Hash
         value.transform_values { |item| deep_freeze(item) }.freeze