branchproof 0.8.0 → 0.10.0

data/lib/branchproof/rspec_adapter.rb

@@ -0,0 +1,423 @@
+# frozen_string_literal: true
+
+require_relative "records" unless defined?(Branchproof::Records)
+
+module Branchproof
+  # Bridges one serial RSpec run to Runtime lifecycle ownership.
+  class RSpecAdapter
+    # Identifies runner capabilities that cannot produce supported evidence.
+    class UnsupportedRunner < ArgumentError
+      def diagnostic_code = "unsupported_runner"
+    end
+
+    # Restores CLI directory discovery when RSpec runs inside the worker.
+    module DefaultDiscovery
+      def configure(configuration)
+        options[:files_or_directories_to_run] = [options[:default_path] || configuration.default_path].compact
+        super
+      end
+    end
+
+    # Rejects additional class-level runner entry points.
+    module ClassRunnerGuard
+      def run(*args, &)
+        RSpecAdapter.runner_adapter&.reject_execution!("nested or repeated RSpec runs are unsupported")
+        super
+      end
+    end
+
+    # Allows only the worker-owned native runner instance.
+    module RunnerGuard
+      def run(*args, &)
+        RSpecAdapter.runner_adapter&.enter_runner!(self)
+        super
+      end
+    end
+
+    # Assigns observation phases while the reporter owns test registration.
+    module ExampleLifecycle
+      def run(*args, &)
+        adapter = RSpecAdapter.active_adapter
+        return super unless adapter
+
+        adapter.send(:begin_example, self)
+        super
+      ensure
+        adapter&.send(:unattributed)
+      end
+
+      private
+
+      def run_before_example(*args, &)
+        adapter = RSpecAdapter.active_adapter
+        adapter&.send(:begin_attempt, self)
+        result = super
+        adapter&.send(:phase, self, "body")
+        result
+      end
+
+      def run_after_example(*args, &)
+        RSpecAdapter.active_adapter&.send(:phase, self, "teardown")
+        super
+      end
+    end
+
+    # Keeps group-level hooks outside individual example ownership.
+    module ContextLifecycle
+      def run_before_context_hooks(*args, &)
+        adapter = RSpecAdapter.active_adapter
+        return super unless adapter
+
+        adapter.send(:without_owner) { super }
+      end
+
+      def run_after_context_hooks(*args, &)
+        adapter = RSpecAdapter.active_adapter
+        return super unless adapter
+
+        adapter.send(:without_owner) { super }
+      end
+    end
+
+    class << self
+      attr_accessor :active_adapter, :runner_adapter
+    end
+
+    FORBIDDEN_OPTIONS = {
+      dry_run: "dry-run",
+      bisect: "bisect",
+      drb: "DRb",
+      runner: "custom runner"
+    }.freeze
+
+    attr_reader :tests, :late_execution_error
+
+    def initialize(runtime:)
+      @runtime = runtime
+      @tests = {}
+      @example_records = {}.compare_by_identity
+      @file_digests = {}
+      @running = false
+      @completed = false
+      @completion_started = false
+      @registered = false
+      @current_context = nil
+    end
+
+    # rubocop:disable-next Metrics/ParameterLists
+    def run(test_files:, runner_args:, on_complete:, before_load: nil, after_load: nil,
+            test_selection_explicit: false)
+      raise ArgumentError, "test_files must be an Array" unless test_files.is_a?(Array)
+      raise ArgumentError, "runner_args must be an Array" unless runner_args.is_a?(Array)
+      raise ArgumentError, "on_complete must respond to call" unless on_complete.respond_to?(:call)
+      raise UnsupportedRunner, "RSpec adapter cannot run more than once" if @running || @registered
+      raise UnsupportedRunner, "nested RSpec runs are unsupported" if self.class.active_adapter
+      raise UnsupportedRunner, "TEST_ENV_NUMBER is unsupported" if ENV.key?("TEST_ENV_NUMBER")
+
+      require "rspec/core"
+      require "rspec/core/runner"
+      unless Gem::Requirement.new("~> 3.13.0").satisfied_by?(Gem::Version.new(RSpec::Core::Version::STRING))
+        raise UnsupportedRunner, "unsupported RSpec version #{RSpec::Core::Version::STRING}; use 3.13.x"
+      end
+
+      RSpec::Core::Runner.disable_autorun!
+      options = RSpec::Core::ConfigurationOptions.new(runner_args)
+      configured_files = Array(options.options[:files_or_directories_to_run]).map(&:to_s)
+      if test_selection_explicit && configured_files.any?
+        raise ArgumentError, "explicit test selection conflicts with configured RSpec selectors"
+      end
+
+      options.options[:files_or_directories_to_run] = test_files.map(&:to_s) if test_selection_explicit
+      options.singleton_class.prepend(DefaultDiscovery) if !test_selection_explicit && configured_files.empty?
+      reject_options!(options)
+
+      @running = true
+
+      @registered = true
+      @completion_callback = on_complete
+      @unmatched_test_selection = test_selection_explicit && test_files.empty?
+      if @unmatched_test_selection
+        complete(status: 0, finalized: true)
+        return 0
+      end
+      self.class.active_adapter = self
+      self.class.runner_adapter = self
+      install_lifecycle_hooks
+      install_runner_guard
+      runner = RSpec::Core::Runner.new(options)
+      @native_runner = runner
+      adapter = self
+      runner.define_singleton_method(:setup) do |*setup_args|
+        super(*setup_args)
+        return if world.wants_to_quit
+
+        adapter.validate_runner!
+        after_load&.call
+        adapter.send(:install_reporter_listener, configuration.reporter)
+      end
+      before_load&.call
+      status = runner.run($stderr, $stdout)
+      capture_runner_state(runner)
+      complete(status: status, finalized: true)
+      status
+    rescue StandardError => e
+      raise unless @running
+      raise if @completion_started
+
+      @run_error = e
+      capture_runner_state(runner) if runner
+      status = 2
+      complete(status: status, finalized: false)
+      status
+    ensure
+      if self.class.active_adapter.equal?(self)
+        unattributed
+        self.class.active_adapter = nil
+      end
+      @running = false
+    end
+
+    def validate_runner!
+      return nil unless defined?(RSpec.configuration)
+
+      configuration = RSpec.configuration
+      reject_configuration!(configuration)
+      if configuration.respond_to?(:parallelize) && configuration.parallelize
+        raise UnsupportedRunner,
+              "parallel test scheduling is unsupported"
+      end
+
+      nil
+    end
+
+    def example_started(notification)
+      example = notification.example
+      record = test_record(example)
+      record[:status] = "running"
+      register_test(record)
+    end
+
+    def example_finished(notification)
+      example = notification.example
+      record = test_record(example)
+      record[:name] = example.full_description.to_s
+      record[:status] = status_for(example)
+      register_test(record)
+    end
+
+    def reject_execution!(message)
+      @run_error ||= UnsupportedRunner.new(message)
+      @late_execution_error = @run_error if @completion_started
+      raise @run_error
+    end
+
+    def enter_runner!(runner)
+      unless runner.equal?(@native_runner) && !@runner_entered
+        reject_execution!("nested or repeated RSpec runs are unsupported")
+      end
+      @runner_entered = true
+    end
+
+    private
+
+    def capture_runner_state(runner)
+      @selected_test_files = runner.configuration.loaded_spec_files.map { |path| File.expand_path(path.to_s) }
+      @selected_example_ids = runner.world.filtered_examples.values.flatten.map(&:id)
+      @seed = runner.configuration.seed
+      @non_example_failure = runner.world.non_example_failure
+    end
+
+    def reject_options!(options)
+      FORBIDDEN_OPTIONS.each do |key, label|
+        value = options.options[key]
+        next unless value && value != false && value != []
+
+        raise UnsupportedRunner, "#{label} is unsupported"
+      end
+    end
+
+    def reject_configuration!(configuration)
+      if configuration.respond_to?(:dry_run?) && configuration.dry_run?
+        raise UnsupportedRunner,
+              "dry-run is unsupported"
+      end
+      raise UnsupportedRunner, "bisect is unsupported" if configuration.respond_to?(:bisect) && configuration.bisect
+      raise UnsupportedRunner, "DRb is unsupported" if defined?(DRb) && RSpec::Core::Runner.send(:running_in_drb?)
+    end
+
+    def install_reporter_listener(reporter)
+      @defined_example_count = RSpec.world.filtered_examples.keys.sum { |group| group.examples.length }
+      listener = self
+      reporter.register_listener(listener, :example_started, :example_finished)
+    end
+
+    def install_runner_guard
+      return if RSpec::Core::Runner.singleton_class.instance_variable_defined?(:@branchproof_runner_guard)
+
+      RSpec::Core::Runner.singleton_class.prepend(ClassRunnerGuard)
+      RSpec::Core::Runner.prepend(RunnerGuard)
+      RSpec::Core::Runner.singleton_class.instance_variable_set(:@branchproof_runner_guard, true)
+    end
+
+    def install_lifecycle_hooks
+      return if RSpec::Core::Example.instance_variable_defined?(:@branchproof_lifecycle_hooks)
+
+      RSpec::Core::Example.prepend(ExampleLifecycle)
+      RSpec::Core::ExampleGroup.singleton_class.prepend(ContextLifecycle)
+      RSpec::Core::Example.instance_variable_set(:@branchproof_lifecycle_hooks, true)
+    end
+
+    def begin_example(example)
+      validate_runner!
+      seen = (@seen_examples ||= {}.compare_by_identity)
+      reject_execution!("repeated RSpec example attempts are unsupported") if seen[example]
+
+      seen[example] = true
+      phase(example, "setup")
+    rescue ArgumentError => e
+      reject_execution!(e.message)
+    end
+
+    def begin_attempt(example)
+      @attempts ||= {}
+      id = test_id(example)
+      if @attempts[id]
+        @run_error ||= UnsupportedRunner.new("repeated RSpec example attempts are unsupported")
+        raise @run_error
+      end
+      @attempts[id] = true
+    end
+
+    def without_owner
+      previous = @current_context
+      unattributed
+      yield
+    ensure
+      @current_context = previous
+      @runtime.context(test_id: previous&.first, phase: previous&.last || "unattributed")
+    end
+
+    def status_for(example)
+      result = example.execution_result
+      status = result.status&.to_sym
+      return "failed" if (result.respond_to?(:pending_fixed?) && result.pending_fixed?) ||
+                         (example.respond_to?(:pending?) && example.pending? && status == :failed)
+      return "failed" if status == :failed
+      return "skipped" if example.respond_to?(:skipped?) && example.skipped?
+      return "skipped" if status == :pending
+
+      status == :passed ? "passed" : "running"
+    end
+
+    def test_record(example)
+      @example_records[example] ||= begin
+        source = source_for(example)
+        id = Branchproof::Records.id(adapter: "rspec", example_id: example.id.to_s, source: source)
+        @tests[id] = {
+          id: id, adapter: "rspec", name: example.full_description.to_s,
+          example_id: example.id.to_s, class_name: nil, method_name: nil,
+          spec_digest: file_digest(example.id.to_s.sub(/\[[\d:]+\]\z/, "")),
+          source_digest: file_digest(source[:path]),
+          source: source, status: "running", phase_counts: {}
+        }
+      end
+    end
+
+    def test_id(example)
+      test_record(example)[:id]
+    end
+
+    def file_digest(path)
+      expanded = File.expand_path(path)
+      return @file_digests[expanded] if @file_digests.key?(expanded)
+
+      @file_digests[expanded] = File.file?(expanded) ? Digest::SHA256.file(expanded).hexdigest : nil
+    end
+
+    def source_for(example)
+      path = example.metadata[:absolute_file_path] || example.file_path
+      { path: File.expand_path(path.to_s), line: example.metadata[:line_number].to_i }
+    end
+
+    def phase(example, name)
+      id = test_id(example)
+      @current_context = [id, name]
+      @runtime.context(test_id: id, phase: name)
+    end
+
+    def unattributed
+      @current_context = nil
+      @runtime.context(test_id: nil, phase: "unattributed")
+    end
+
+    def register_test(test)
+      @runtime.register_test(test: test)
+    end
+
+    def complete(status:, finalized:)
+      return if @completed || @completion_started
+
+      @completion_started = true
+      apply_canonical_phase_counts
+      tests = @tests.values
+      failed = tests.count { |test| test[:status] == "failed" }
+      skipped = tests.count { |test| test[:status] == "skipped" }
+      diagnostics = completion_diagnostics(status)
+      errored = diagnostics.any? { |diagnostic| diagnostic[:severity] == "error" }
+      result = {
+        status: if errored
+                  "ERROR"
+                elsif tests.empty?
+                  "INCOMPLETE"
+                elsif failed.zero?
+                  "PASSED"
+                else
+                  "FAILED"
+                end,
+        executed_tests: tests.length, failed_tests: failed, skipped_tests: skipped,
+        exit_status: status.to_i, finalized: finalized && !errored, seed: @seed, diagnostics: diagnostics,
+        selected_test_files: @selected_test_files || [], selected_example_ids: @selected_example_ids || [], tests: tests
+      }
+      @completion_callback.call(result)
+      @completed = true
+    end
+
+    def completion_diagnostics(native_status)
+      if @run_error
+        code = if defined?(Branchproof::RailsSupport::Error) && @run_error.is_a?(Branchproof::RailsSupport::Error)
+                 "rails_boot"
+               elsif @run_error.respond_to?(:diagnostic_code)
+                 @run_error.diagnostic_code
+               else
+                 "rspec_run"
+               end
+        return [{ code: code, severity: "error", message: "#{@run_error.class}: #{@run_error.message}" }]
+      end
+      if @non_example_failure || @tests.values.any? { |test| test[:status] == "running" } ||
+         (native_status.to_i != 0 && @tests.values.none? { |test| test[:status] == "failed" })
+        return [{ code: "rspec_run", severity: "error",
+                  message: "RSpec failed outside examples; see runner output" }]
+      end
+
+      return [] unless @tests.empty?
+
+      code, message = if @unmatched_test_selection
+                        ["unmatched_test_selection", "No files matched --test; check the path or glob"]
+                      elsif @defined_example_count.to_i.positive?
+                        ["empty_example_selection",
+                         "RSpec filters selected zero examples; check tags, descriptions, and selectors"]
+                      else
+                        ["empty_suite", "RSpec discovered no examples; check the default path and configured patterns"]
+                      end
+      [{ code: code, severity: "warning", message: message }]
+    end
+
+    def apply_canonical_phase_counts
+      canonical_by_id = @runtime.test_phase_counts
+      @tests.each do |id, test|
+        counts = canonical_by_id[id]
+        test[:phase_counts] = counts unless counts.nil?
+      end
+    end
+  end
+end

data/lib/branchproof/runtime.rb

@@ -2,6 +2,11 @@
 
 require "securerandom"
 require_relative "runtime_flow"
+require_relative "extended_alternative_runtime"
+require_relative "exception_runtime"
+require_relative "default_runtime"
+require_relative "value_runtime"
+require_relative "iteration_runtime"
 
 module Branchproof
   # Process-local execution recorder. It deliberately never coerces or stores
@@ -9,6 +14,11 @@ module Branchproof
   # Captures condition evaluations while preserving application values.
   module Runtime
     extend RuntimeFlow
+    extend ExtendedAlternativeRuntime
+    extend ExceptionRuntime
+    extend DefaultRuntime
+    extend ValueRuntime
+    extend IterationRuntime
 
     FRAME_STATE_KEY = :branchproof_runtime_frame_state
 
@@ -97,6 +107,10 @@ module Branchproof
         nil
       end
 
+      def test_phase_counts
+        @evidence.test_phase_counts
+      end
+
       def snapshot
         if @evidence.respond_to?(:snapshot)
           result = @evidence.snapshot

data/lib/branchproof/saved_report.rb

@@ -638,7 +638,9 @@ module Branchproof
     end
 
     def validate_test(test)
-      %w[name class_name method_name source_path].each { |field| validate_string_field(test, field, nullable: true) }
+      %w[adapter name class_name method_name source_path example_id].each do |field|
+        validate_string_field(test, field, nullable: true)
+      end
       validate_integer_field(test, "line", nullable: true)
       phase_counts = test["phase_counts"]
       if phase_counts
@@ -726,7 +728,12 @@ module Branchproof
       string_fields.each do |field|
         fail_with("run_metadata #{field} must be a string") if metadata.key?(field) && !metadata[field].is_a?(String)
       end
-      array_fields = %w[source_patterns test_patterns test_files runner_args]
+      nullable_string_fields = %w[framework framework_version rspec_rails_version rails_version]
+      nullable_string_fields.each do |field|
+        fail_with("run_metadata #{field} must be a string") if metadata.key?(field) &&
+                                                               !metadata[field].nil? && !metadata[field].is_a?(String)
+      end
+      array_fields = %w[source_patterns test_patterns test_files runner_args selected_test_files selected_example_ids]
       array_fields.each do |field|
         if metadata.key?(field) && !strings?(metadata[field])
           fail_with("run_metadata #{field} must be an array of strings")

data/lib/branchproof/source.rb

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