branchproof 0.6.0 → 0.8.0

data/lib/branchproof/instrumenter.rb

@@ -1,27 +1,27 @@
 # frozen_string_literal: true
 
+require_relative "flow_instrumentation"
+
 module Branchproof
   # Applies the smallest possible source edits around inventoried expressions.
   # The edits are deliberately textual: Prism owns the ranges, while this class
   # never evaluates application code or introduces a Ruby scope.
   class Instrumenter
+    include FlowInstrumentation
+
     RUNTIME = "::Branchproof::Runtime"
 
     def rewrite(unit:)
       bytes = unit.fetch(:original_bytes).dup.force_encoding(Encoding::BINARY)
       reasons = Array(unit[:support_reasons])
-      unless supported_unit?(unit, reasons)
-        return result(bytes, diagnostics: [diagnostic("unsupported_source", reasons.join(", "))])
-      end
+      return result(bytes, diagnostics: [diagnostic("unsupported_source", reasons.join(", "))]) unless supported?(unit)
 
       decisions = Array(unit[:decisions]).select { |decision| supported?(decision) }
+      encloses, enclosed = build_enclosures(decisions)
       edits = decisions.filter_map do |decision|
-        next if decisions.any? do |outer|
-          outer != decision && contains?(outer[:byte_start], outer[:byte_length], decision[:byte_start],
-                                         decision[:byte_length])
-        end
+        next if enclosed[decision]
 
-        decision_edit(bytes, decision, decisions)
+        decision_edit(bytes, decision, encloses)
       end
       if decisions.any? && edits.empty?
         return result(bytes,
@@ -31,43 +31,54 @@ module Branchproof
 
       rewritten = apply_edits(bytes, edits)
       begin
-        RubyVM::InstructionSequence.compile(rewritten, unit[:absolute_path] || "(branchproof)",
-                                            unit[:real_path] || unit[:absolute_path] || "(branchproof)", 1)
+        iseq = RubyVM::InstructionSequence.compile(rewritten, unit[:absolute_path] || "(branchproof)",
+                                                   unit[:real_path] || unit[:absolute_path] || "(branchproof)", 1)
       rescue SyntaxError => e
-        return result(bytes, diagnostics: [diagnostic("invalid_rewrite", e.message)])
+        return result(rewritten, diagnostics: [diagnostic("invalid_rewrite", e.message)])
       end
-      result(rewritten.force_encoding(unit[:original_bytes].encoding), changed: rewritten != bytes)
+      result(rewritten.force_encoding(unit[:original_bytes].encoding), changed: edits.any?, iseq: iseq)
     end
 
     private
 
-    def supported_unit?(unit, _reasons)
-      status = unit[:support_status]
+    def supported?(record)
+      status = record[:support_status]
       status.nil? || status.to_s.casecmp("supported").zero?
     end
 
-    def supported?(decision)
-      status = decision[:support_status]
-      status.nil? || status.to_s.casecmp("supported").zero?
+    # Precompute, once, which decisions each decision encloses (and whether it is
+    # itself enclosed by any other), so rendering never re-scans the full decision
+    # list at every recursion level. Safe because `encloses_decision?` containment
+    # is transitive: if the encloses map for `decision` says it contains X, that
+    # holds true within any nested subset that already contains `decision`.
+    def build_enclosures(decisions)
+      encloses = {}.compare_by_identity
+      enclosed = {}.compare_by_identity
+      decisions.each do |outer|
+        contained = decisions.select { |inner| encloses_decision?(outer, inner) }
+        encloses[outer] = contained
+        contained.each { |inner| enclosed[inner] = true }
+      end
+      [encloses, enclosed]
     end
 
-    def decision_edit(bytes, decision, all_decisions)
+    def decision_edit(bytes, decision, encloses)
       start = decision[:byte_start]
       length = decision[:byte_length]
       return nil unless valid_range?(bytes, start, length)
 
-      nested = all_decisions.select do |candidate|
-        candidate != decision && contains?(start, length, candidate[:byte_start], candidate[:byte_length])
-      end
-      expression = render_range(bytes, start, length, decision, nested)
+      nested = encloses[decision] || []
+      expression = render_decision(bytes, decision, nested, encloses)
       {
         start: start,
         finish: start + length,
-        text: frame(decision[:id], expression)
+        text: expression
       }
     end
 
-    def render_range(bytes, start, length, decision, nested)
+    def render_range(bytes, decision, nested, encloses)
+      start = decision[:byte_start]
+      length = decision[:byte_length]
       conditions = Array(decision[:conditions]).sort_by { |condition| condition[:byte_start] }
       cursor = start
       chunks = []
@@ -77,37 +88,49 @@ module Branchproof
         next unless valid_range?(bytes, cstart, clen) && cstart >= start && cstart + clen <= start + length
 
         chunks << bytes.byteslice(cursor, cstart - cursor)
-        original = render_children(bytes, cstart, clen, nested)
+        original = render_children(bytes, cstart, clen, nested, encloses)
         chunks << condition_wrapper(decision[:id], condition[:index], original)
         cursor = cstart + clen
       end
-      chunks << render_children(bytes, cursor, length - (cursor - start), nested)
+      chunks << render_children(bytes, cursor, length - (cursor - start), nested, encloses)
       chunks.join
     end
 
-    def render_children(bytes, start, length, nested)
+    def render_children(bytes, start, length, nested, encloses)
       children = nested.select do |child|
         contains?(start, length, child[:byte_start], child[:byte_length])
       end
       children = children.reject do |child|
-        nested.any? do |candidate|
-          candidate != child && contains?(candidate[:byte_start], candidate[:byte_length], child[:byte_start],
-                                          child[:byte_length])
-        end
+        children.any? { |candidate| encloses_decision?(candidate, child) }
       end
       children.sort_by! { |child| -child[:byte_start] }
       output = bytes.byteslice(start, length)
       children.each do |child|
-        child_text = render_range(bytes, child[:byte_start], child[:byte_length], child, nested.reject do |item|
-          item.equal?(child)
-        end)
-        child_text = frame(child[:id], child_text)
+        descendants = encloses[child] || []
+        child_text = render_decision(bytes, child, descendants, encloses)
         offset = child[:byte_start] - start
         output[offset, child[:byte_length]] = child_text
       end
       output
     end
 
+    def encloses_decision?(outer, inner)
+      return false if outer.equal?(inner) || outer == inner
+      return false unless contains?(outer[:byte_start], outer[:byte_length], inner[:byte_start], inner[:byte_length])
+      return true unless outer[:byte_start] == inner[:byte_start] && outer[:byte_length] == inner[:byte_length]
+
+      (outer[:kind] || "boolean") == "boolean" && inner[:kind] != "boolean" && !inner[:kind].nil?
+    end
+
+    def render_decision(bytes, decision, nested, encloses)
+      if decision[:instrumentation]
+        render_flow(bytes, decision, nested, encloses)
+      else
+        expression = render_range(bytes, decision, nested, encloses)
+        frame(decision[:id], expression)
+      end
+    end
+
     def condition_wrapper(decision_id, index, expression)
       "#{RUNTIME}.condition(#{decision_id.inspect}, #{index}, (#{expression}))"
     end
@@ -118,10 +141,13 @@ module Branchproof
         "#{RUNTIME}.leave(#{decision_id.inspect}); end; end)"
     end
 
+    # Mutates `bytes` in place: it is already a fresh copy made at the top of
+    # rewrite, so there is no need to copy it again before splicing edits in.
     def apply_edits(bytes, edits)
-      edits.sort_by { |edit| -edit[:start] }.each_with_object(bytes.dup) do |edit, output|
-        output[edit[:start]...edit[:finish]] = edit[:text]
+      edits.sort_by { |edit| -edit[:start] }.each do |edit|
+        bytes[edit[:start]...edit[:finish]] = edit[:text]
       end
+      bytes
     end
 
     def valid_range?(bytes, start, length)
@@ -138,8 +164,8 @@ module Branchproof
       start.is_a?(Integer) && length.is_a?(Integer) && start >= 0 && length >= 0
     end
 
-    def result(bytes, changed: false, diagnostics: [])
-      { bytes: bytes, changed: changed, diagnostics: diagnostics }.freeze
+    def result(bytes, changed: false, diagnostics: [], iseq: nil)
+      { bytes: bytes, changed: changed, diagnostics: diagnostics, iseq: iseq }.freeze
     end
 
     def diagnostic(code, message)

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)
@@ -61,6 +59,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 +108,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 +137,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