branchproof 0.8.0 → 0.10.0

data/lib/branchproof/cli.rb

@@ -33,10 +33,10 @@ module Branchproof
 
       inventory = build_inventory(options)
       evidence = empty_evidence(inventory, options)
-      baseline = if options[:tests].empty?
-                   { status: "INCOMPLETE", executed_tests: 0, failed_tests: 0, skipped_tests: 0, finalized: false }
-                 else
+      baseline = if run_worker?(options)
                    run_worker(options, inventory, evidence)
+                 else
+                   { status: "INCOMPLETE", executed_tests: 0, failed_tests: 0, skipped_tests: 0, finalized: false }
                  end
       if value(baseline, :evidence)
         merge_status = evidence.merge(snapshot: value(baseline, :evidence))
@@ -93,7 +93,7 @@ module Branchproof
     def help
       @stdout.write(<<~HELP)
         Usage:
-          branchproof analyze [SOURCE_GLOB ...] [--test TEST_GLOB] [--project auto|ruby|rails]
+          branchproof analyze [SOURCE_GLOB ...] [--test TEST_GLOB] [--project auto|ruby|rails] [--framework auto|minitest|rspec]
             [--view decisions|conditions|tests|decision-tables] [--level 1|2|3] [--missing-only]
             [--format terminal|json] [--output PATH] [--limits PATH] [--no-reachability] [-- RUNNER_ARGS]
           branchproof report SNAPSHOT [--view decisions|conditions|tests|decision-tables]
@@ -205,12 +205,24 @@ module Branchproof
         source = value(test, :source) || {}
         [value(test, :id), { relative_path: relative_path(value(source, :path), root), line: value(source, :line) }]
       end
-      { captured_at: Time.now.utc.iso8601, requested_level: options[:level], project_kind: options[:project][:kind],
+      project_metadata = value(baseline, :project) || options[:project]
+      selected_test_files = value(baseline, :selected_test_files)
+      test_files = selected_test_files || options[:tests]
+      metadata = {
+        captured_at: Time.now.utc.iso8601, requested_level: options[:level], project_kind: options[:project][:kind],
         project_root: root, source_patterns: options[:source_patterns].map { |path| relative_path(path, root) },
         test_patterns: options[:test_patterns].map { |path| relative_path(path, root) },
-        test_files: options[:tests].map { |path| relative_path(path, root) }, runner_args: options[:runner_args],
+        test_files: Array(test_files).map { |path| relative_path(path, root) }, runner_args: options[:runner_args],
         seed: value(baseline, :seed), limits: options[:limits], test_locations: locations,
-        reachability: options[:reachability] }
+        reachability: options[:reachability]
+      }
+      %i[selected_test_files selected_example_ids].each do |key|
+        metadata[key] = value(baseline, key) if value(baseline, key)
+      end
+      %i[framework framework_version rspec_rails_version rails_version].each do |key|
+        metadata[key] = value(project_metadata, key) if value(project_metadata, key)
+      end
+      metadata
     end
 
     def relative_path(path, root)
@@ -228,7 +240,7 @@ module Branchproof
       args = args[0...delimiter] if delimiter
       options = { level: 3, format: :terminal, output: nil, tests: [], source_paths: [], limits: Limits.default,
                   runner_args: runner_args, project: nil, missing_only: false, view: :decisions,
-                  reachability: true }
+                  reachability: true, project_mode: "auto", framework: "auto", explicit_tests: false }
       until args.empty?
         token = args.shift
         case token
@@ -255,11 +267,14 @@ module Branchproof
         when "--test"
           options[:tests] << args.shift
           raise ArgumentError, "--test requires a glob" if options[:tests].last.nil? || options[:tests].last.empty?
-        when "--project"
-          mode = args.shift
-          raise ArgumentError, "--project requires auto, ruby, or rails" if mode.nil? || mode.empty?
 
-          options[:project] = Project.new(root: Dir.pwd, mode: mode).to_h
+          options[:explicit_tests] = true
+        when "--framework"
+          options[:framework] = args.shift
+          raise ArgumentError, "--framework requires auto, minitest, or rspec" if options[:framework].nil? || options[:framework].empty?
+        when "--project"
+          options[:project_mode] = args.shift
+          raise ArgumentError, "--project requires auto, ruby, or rails" if options[:project_mode].nil? || options[:project_mode].empty?
         when "--limits"
           limits_path = args.shift
           raise ArgumentError, "--limits requires a readable JSON path" unless limits_path && File.file?(limits_path)
@@ -273,16 +288,16 @@ module Branchproof
           options[:source_paths] << token
         end
       end
+      options[:project] = Project.new(root: Dir.pwd, mode: options[:project_mode], framework: options[:framework]).to_h
       validate_view!(options)
       if options[:missing_only] && (options[:format] != :terminal || options[:level] == 1)
         raise ArgumentError, "--missing-only requires terminal format and level 2 or 3"
       end
 
-      options[:project] ||= Project.new(root: Dir.pwd, mode: "auto").to_h
       options[:source_paths] = default_sources if options[:source_paths].empty?
-      options[:tests] = default_tests if options[:tests].empty?
+      options[:tests] = default_tests(options[:project]) if options[:tests].empty?
       options[:source_patterns] = options[:source_paths].dup
-      options[:test_patterns] = argv.include?("--test") ? options[:tests].dup : %w[test/**/*_test.rb test/**/test_*.rb]
+      options[:test_patterns] = options[:explicit_tests] ? options[:tests].dup : options[:project][:test_patterns]
       options[:tests] = expand_paths(options[:tests], root: options[:project][:root])
       options
     end
@@ -315,18 +330,10 @@ module Branchproof
       begin
         directory = Dir.mktmpdir("branchproof-run-")
         config = File.join(directory, "request.json")
-        payload = {
-          inventory: inventory, limits: options[:limits], run_id: evidence.run_id,
-          test_files: options[:tests], runner_args: options[:runner_args], project: options[:project],
-          result_path: File.join(directory, "result.json"), marker_path: File.join(directory, "complete.marker")
-        }
+        payload = worker_payload(options, inventory, evidence, directory)
         File.binwrite(config, JSON.generate(normalize(payload)))
         script = "require 'branchproof'; exit(Branchproof::Worker.child_process(ARGV.fetch(0)).to_i)"
-        child_stdout, stderr, child_status = Open3.capture3(options[:project][:environment], RbConfig.ruby, "-I",
-                                                            File.expand_path("..", __dir__), "-e", script, config,
-                                                            chdir: options[:project][:root])
-        @stderr.write(child_stdout) unless child_stdout.to_s.empty?
-        @stderr.write(stderr) unless stderr.to_s.empty?
+        stderr, child_status = stream_worker(options, script, config)
         unless File.file?(payload[:marker_path]) && File.file?(payload[:result_path])
           return { status: "ERROR", executed_tests: 0, failed_tests: 0, skipped_tests: 0, finalized: false,
                    diagnostics: [{ code: "worker_incomplete", severity: "error", message: stderr.to_s.strip }] }
@@ -346,6 +353,30 @@ module Branchproof
         diagnostics: [{ code: "runner", severity: "error", message: e.message }] }
     end
 
+    def stream_worker(options, script, config)
+      diagnostic_output = +""
+      Open3.popen3(options[:project][:environment], RbConfig.ruby, "-I",
+                   File.expand_path("..", __dir__), "-e", script, config,
+                   chdir: options[:project][:root]) do |input, output, errors, child|
+        input.close
+        streams = [output, errors]
+        until streams.empty?
+          IO.select(streams).first.each do |stream|
+            chunk = stream.read_nonblock(16_384, exception: false)
+            if chunk.nil?
+              streams.delete(stream)
+            elsif chunk != :wait_readable
+              @stderr.write(chunk)
+              @stderr.flush if @stderr.respond_to?(:flush)
+              diagnostic_output << chunk
+              diagnostic_output = diagnostic_output.byteslice(-16_384, 16_384) if diagnostic_output.bytesize > 16_384
+            end
+          end
+        end
+        [diagnostic_output, child.value]
+      end
+    end
+
     def output_report(report, options)
       created = false
       if options[:output]
@@ -362,6 +393,19 @@ module Branchproof
       File.unlink(temporary) if created && temporary && File.file?(temporary)
     end
 
+    def run_worker?(options)
+      !options[:tests].empty? || options[:project][:framework].to_s == "rspec"
+    end
+
+    def worker_payload(options, inventory, evidence, directory)
+      {
+        inventory: inventory, limits: options[:limits], run_id: evidence.run_id,
+        test_files: options[:tests], runner_args: options[:runner_args], project: options[:project],
+        test_selection_explicit: options[:explicit_tests],
+        result_path: File.join(directory, "result.json"), marker_path: File.join(directory, "complete.marker")
+      }
+    end
+
     def report_string(report, format)
       buffer = StringIO.new
       report.write(io: buffer, format: format)
@@ -377,8 +421,9 @@ module Branchproof
       %w[lib/**/*.rb app/**/*.rb]
     end
 
-    def default_tests
-      candidates = Dir.glob("test/**/*_test.rb", base: Dir.pwd) + Dir.glob("test/**/test_*.rb", base: Dir.pwd)
+    def default_tests(project = nil)
+      project ||= Project.new(root: Dir.pwd, mode: "auto", framework: "auto").to_h
+      candidates = Array(project[:test_patterns]).flat_map { |pattern| Dir.glob(pattern, base: project[:root]) }
       candidates.map! { |path| File.expand_path(path, Dir.pwd) }
       candidates.reject { |path| default_test_excluded?(path) }.uniq.sort
     end
@@ -387,7 +432,8 @@ module Branchproof
       relative = Pathname.new(path).relative_path_from(Pathname.new(Dir.pwd)).to_s
       segments = relative.split(File::SEPARATOR)
       basename = File.basename(path)
-      basename == "test_helper.rb" || segments.include?("support") || segments.include?("fixtures")
+      %w[test_helper.rb spec_helper.rb rails_helper.rb].include?(basename) ||
+        segments.include?("support") || segments.include?("fixtures")
     end
 
     def expand_paths(paths, root: Dir.pwd)

data/lib/branchproof/comparison.rb

@@ -2,6 +2,7 @@
 
 # rubocop:disable Metrics/ClassLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
 require "json"
+require "pathname"
 
 module Branchproof
   # Compares two complete report documents without loading or executing the project.
@@ -369,9 +370,17 @@ module Branchproof
         tests = Array(value(value(document, :observations), :tests)).to_h { |test| [value(test, :id).to_s, test] }
         rows = index.tests.to_h { |test| [test[:id].to_s, test] }
         keys = tests.to_h do |id, test|
-          parts = %i[adapter class_name method_name].map { |key| value(test, key) }
-          parts << rows.dig(id, :relative_path)
-          [id, parts.all? { |part| part.is_a?(String) && !part.empty? } ? parts : nil]
+          adapter = value(test, :adapter).to_s
+          path = rows.dig(id, :relative_path)
+          key = if adapter.downcase == "rspec"
+                  example_id = value(test, :example_id).to_s
+                  # Scoped IDs are positional selectors, valid only within the same spec revision.
+                  [adapter, rspec_example_path(document, example_id) || path, rspec_scope(example_id),
+                   value(test, :name), path, value(test, :spec_digest), value(test, :source_digest)]
+                else
+                  [adapter, value(test, :class_name), value(test, :method_name), path]
+                end
+          [id, key.all? { |part| part.is_a?(String) && !part.empty? } ? key : nil]
         end
         results = Array(value(value(document, :analysis), :decisions)).flat_map do |decision|
           Array(value(decision, :condition_results))
@@ -447,6 +456,13 @@ module Branchproof
       if context(@before)[:test_keys].values.sort_by(&:to_s) != context(@after)[:test_keys].values.sort_by(&:to_s)
         changes << "test population differs"
       end
+      if [@before, @after].any? do |document|
+        context(document)[:tests].any? do |id, test|
+          value(test, :adapter).to_s.downcase == "rspec" && context(document)[:test_keys][id].nil?
+        end
+      end
+        changes << "RSpec example identity is uncertain: missing spec revision or selector evidence"
+      end
       changes << "Deltas describe observed runs; nondeterminism and external environment changes are not ruled out."
       changes
     end
@@ -454,9 +470,10 @@ module Branchproof
     def comparability_reasons(changed_paths)
       reasons = []
       reasons << "source files changed: #{changed_paths.sort.join(", ")}" unless changed_paths.empty?
-      %i[project_kind runner_args source_patterns test_patterns limits runtime].each do |key|
-        left = metadata(@before, key)
-        right = metadata(@after, key)
+      %i[project_kind framework framework_version rspec_rails_version runner_args source_patterns test_patterns limits
+         runtime].each do |key|
+        left = key == :framework ? comparison_framework(@before) : metadata(@before, key)
+        right = key == :framework ? comparison_framework(@after) : metadata(@after, key)
         if key == :runner_args
           left = comparable_runner_args(left)
           right = comparable_runner_args(right)
@@ -467,6 +484,35 @@ module Branchproof
       reasons
     end
 
+    def comparison_framework(document)
+      explicit = metadata(document, :framework)
+      return explicit unless explicit.nil? || explicit.to_s.empty?
+
+      adapters = Array(value(value(document, :observations), :tests)).filter_map do |test|
+        adapter = value(test, :adapter).to_s.downcase
+        adapter unless adapter.empty? || adapter == "unknown"
+      end.uniq
+      adapters.length == 1 ? adapters.first : nil
+    end
+
+    def rspec_scope(example_id)
+      match = example_id.to_s.match(/(\[[^\]]+\])\z/)
+      match && match[1]
+    end
+
+    def rspec_example_path(document, example_id)
+      path = example_id.to_s.sub(/\[[^\]]+\]\z/, "")
+      return nil if path.empty?
+      return path.sub(%r{\A\./}, "") unless path.start_with?("/")
+
+      root = value(value(document, :source_inventory), :root) || metadata(document, :project_root)
+      return nil unless root
+
+      Pathname.new(path).relative_path_from(Pathname.new(root.to_s)).to_s
+    rescue ArgumentError
+      nil
+    end
+
     def source_selection(document)
       value(value(document, :run_metadata), :source_patterns)
     end

data/lib/branchproof/decision_syntax.rb

@@ -117,7 +117,8 @@ module Branchproof
                                    encoding),
             range: byte_range(candidate.location, splat_node?(candidate) ? "splat" : nil),
             byte_start: candidate.location.start_offset,
-            byte_length: candidate.location.length
+            byte_length: candidate.location.length,
+            splat: splat_node?(candidate)
           }
         end
         branches << {
@@ -142,9 +143,6 @@ module Branchproof
                           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),
@@ -171,7 +169,6 @@ module Branchproof
         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),
@@ -233,16 +230,28 @@ module Branchproof
       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"] : []
+      safe_navigation = safe_navigation_assignment?(node)
+      reasons = []
       instrumentation = {
         type: "assignment",
         range: byte_range(node.location),
         rhs: byte_range(rhs.location),
         operator: operator,
         rhs_path: 1,
-        skipped_path: 0
+        skipped_path: 0,
+        receiver: safe_navigation && byte_range(node.receiver.location),
+        alternative_count: safe_navigation ? 3 : 2
       }
-      alternatives = if operator == "||="
+      alternatives = if safe_navigation
+                       skipped = operator == "||=" ? "LHS truthy; RHS skipped" : "LHS falsey; RHS skipped"
+                       executed = operator == "||=" ? "LHS falsey; RHS executed" : "LHS truthy; RHS executed"
+                       [{ expression: "receiver nil", byte_start: node.receiver.location.start_offset,
+                          byte_length: node.receiver.location.length },
+                        { expression: skipped, byte_start: node.location.start_offset,
+                          byte_length: node.location.length },
+                        { expression: executed, byte_start: node.location.start_offset,
+                          byte_length: node.location.length }]
+                     elsif 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,
@@ -253,7 +262,8 @@ module Branchproof
                         { 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]
+      [safe_navigation ? "multiway" : "implicit", assignment_context, alternatives,
+       instrumentation, unsupported_reasons(node, bytes) + reasons]
     end
 
     def rescue_details(node, bytes, encoding)

data/lib/branchproof/default_instrumentation.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+# Keep source-boundary and parameter-binding rules together for auditing.
+# rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/ModuleLength, Metrics/PerceivedComplexity
+
+module Branchproof
+  # Defaults stay inline in their original lexical scope. The owner decision
+  # makes body entry edits part of the same original AST edit tree as the
+  # parameter expression edits.
+  module DefaultInstrumentation
+    def rewrite(unit:)
+      decisions = Array(unit[:decisions])
+      defaults = decisions.select do |decision|
+        decision.dig(:instrumentation, :type) == "default" && supported?(decision)
+      end
+      return super unless defaults.any?
+
+      prepared = decisions.map do |decision|
+        next decision unless defaults.include?(decision)
+
+        instrumentation = decision[:instrumentation].merge(flag: default_flag(decision, unit[:original_bytes]))
+        decision.merge(instrumentation: instrumentation)
+      end
+      supported_ids = defaults.map { |decision| decision[:id] }
+      prepared_defaults = prepared.select do |decision|
+        decision.dig(:instrumentation, :type) == "default" && supported_ids.include?(decision[:id])
+      end
+      super(unit: unit.merge(decisions: owner_decisions(prepared, prepared_defaults)))
+    end
+
+    private
+
+    # An enclosing flow renderer can split a callable range at its own
+    # insertion point (for example an iteration callback inside a block). In
+    # that case the owner decision cannot be rendered as one child. Preserve
+    # the original offset by placing its supplied markers at the chunk that
+    # begins at the body entry.
+    def render_children(bytes, start, length, nested, encloses)
+      output = super
+      finish = start + length
+      crossing = nested.select do |child|
+        next false unless child.dig(:instrumentation, :type) == "default_owner"
+
+        owner = child.dig(:instrumentation, :owner)
+        owner && owner[:body_start] == start &&
+          (owner[:byte_start] < start || owner[:byte_start] + owner[:byte_length] > finish)
+      end
+      return output if crossing.empty?
+
+      marker = crossing.flat_map { |owner| owner_markers(owner, encloses[owner] || [], bytes) }.join
+      marker.empty? ? output : "#{marker}#{output}"
+    end
+
+    def encloses_decision?(outer, inner)
+      same_range = outer[:byte_start] == inner[:byte_start] && outer[:byte_length] == inner[:byte_length]
+      if same_range && inner.dig(:instrumentation, :type) == "default_owner"
+        return true unless outer.dig(:instrumentation, :type) == "default_owner"
+      elsif same_range && outer.dig(:instrumentation, :type) == "default_owner"
+        return false
+      end
+      super
+    end
+
+    def render_flow(bytes, decision, nested, encloses)
+      if decision.dig(:instrumentation, :type) == "default_owner"
+        return render_default_owner(bytes, decision, nested, encloses)
+      end
+      return super unless decision.dig(:instrumentation, :type) == "default"
+
+      value = decision.dig(:instrumentation, :value_range)
+      flag = decision.dig(:instrumentation, :flag) || default_flag(decision, bytes)
+      replacement = flow_replacement(bytes, value, nested, encloses) do |expression|
+        "(begin; #{flag} = true; #{self.class::RUNTIME}.default_binding(#{decision[:id].inspect}, 1); " \
+          "#{expression}; end)"
+      end
+      flow_fragments(bytes, decision, nested, [replacement], encloses)
+    end
+
+    def owner_decisions(decisions, defaults)
+      owners = defaults.group_by { |decision| decision.dig(:instrumentation, :owner) }
+      additions = owners.filter_map do |owner, grouped|
+        next unless owner
+
+        first = grouped.min_by { |decision| decision[:byte_start] }
+        next unless first
+
+        first.merge(
+          byte_start: owner[:byte_start], byte_length: owner[:byte_length],
+          expression: nil,
+          instrumentation: first[:instrumentation].merge(type: "default_owner")
+        )
+      end
+      (decisions + additions).sort_by { |decision| [decision[:byte_start], decision[:byte_length]] }
+    end
+
+    def render_default_owner(bytes, decision, nested, encloses)
+      owner = decision.dig(:instrumentation, :owner)
+      return super unless owner
+
+      bindings = nested.filter_map do |child|
+        next unless child.dig(:instrumentation, :type) == "default"
+        next unless child.dig(:instrumentation, :owner) == owner
+
+        [child.dig(:instrumentation, :flag) || default_flag(child, bytes), child[:id]]
+      end
+      marker = bindings.map do |flag, id|
+        "#{self.class::RUNTIME}.default_binding(#{id.inspect}, 0) unless #{flag}; "
+      end.join
+      return flow_fragments(bytes, decision, nested, [], encloses) if marker.empty?
+
+      start = owner[:body_start] || owner[:closing_start]
+      finish = (owner[:body_start] + owner[:body_length] if owner[:equal] && owner[:body_start] && owner[:body_length])
+      replacements = if finish
+                       [{ start: start, length: 0, text: "(begin; #{marker}" },
+                        { start: finish, length: 0, text: "; end)" }]
+                     else
+                       [{ start: start, length: 0, text: marker }]
+                     end
+      flow_fragments(bytes, decision, nested, replacements, encloses)
+    end
+
+    def owner_markers(owner, nested, bytes)
+      nested.filter_map do |child|
+        next unless child.dig(:instrumentation, :type) == "default"
+        next unless child.dig(:instrumentation, :owner) == owner.dig(:instrumentation, :owner)
+
+        flag = child.dig(:instrumentation, :flag) || default_flag(child, bytes)
+        "#{self.class::RUNTIME}.default_binding(#{child[:id].inspect}, 0) unless #{flag}; "
+      end
+    end
+
+    def default_flag(decision, bytes)
+      name = "__branchproof_default_#{decision[:id]}"
+      name += "_" while bytes.include?(name)
+      name
+    end
+  end
+end
+
+# rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/ModuleLength, Metrics/PerceivedComplexity

data/lib/branchproof/default_runtime.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Branchproof
+  # Binding events are immediate; no pending state survives a failed default.
+  module DefaultRuntime
+    def default_binding(decision_id, index)
+      enter(decision_id)
+      begin
+        flow_path(decision_id, index)
+      ensure
+        leave(decision_id)
+      end
+      nil
+    end
+  end
+end

data/lib/branchproof/default_syntax.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Branchproof
+  # Each optional parameter has an independent supplied/defaulted obligation.
+  module DefaultSyntax
+    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+
+    private
+
+    def flow_decision_node?(node)
+      @default_owner_by_node = {}.compare_by_identity if node.is_a?(Prism::ProgramNode)
+      register_default_owner(node) if default_owner_node?(node)
+      default_parameter_node?(node) || super
+    end
+
+    def flow_details(node, bytes, encoding)
+      return super unless default_parameter_node?(node)
+
+      value = node.value
+      alternatives = [
+        { expression: "#{node.name} supplied", byte_start: node.location.start_offset,
+          byte_length: node.location.length },
+        { expression: "#{node.name} default evaluated", byte_start: value.location.start_offset,
+          byte_length: value.location.length }
+      ]
+      owner = @default_owner_by_node && @default_owner_by_node[node]
+      metadata = { type: "default", value_range: byte_range(value.location) }
+      metadata[:owner] = owner if owner
+      ["implicit", "default_argument", alternatives, metadata, unsupported_reasons(node, bytes)]
+    end
+
+    def register_default_owner(owner)
+      @default_owner_by_node ||= {}.compare_by_identity
+      parameters = owner.parameters if owner.respond_to?(:parameters)
+      parameters = parameters.parameters if parameters.is_a?(Prism::BlockParametersNode)
+      return unless parameters.is_a?(Prism::ParametersNode)
+
+      details = default_owner_details(owner)
+      (Array(parameters.optionals) + Array(parameters.keywords)).each do |parameter|
+        next unless default_parameter_node?(parameter)
+
+        @default_owner_by_node[parameter] = details
+      end
+    end
+
+    def default_parameter_node?(node)
+      node.is_a?(Prism::OptionalParameterNode) || node.is_a?(Prism::OptionalKeywordParameterNode)
+    end
+
+    def default_owner_node?(node)
+      node.is_a?(Prism::DefNode) || node.is_a?(Prism::LambdaNode) || node.is_a?(Prism::BlockNode)
+    end
+
+    def default_owner_details(owner)
+      return nil unless owner
+
+      # Only endless `def name(...) = expr` has a body that can be wrapped as
+      # one expression. Lambda/block `closing_loc` values are delimiters, not
+      # endless-definition markers, and must stay on the statement path.
+      equal_loc = owner.is_a?(Prism::DefNode) && owner.equal_loc
+      closing = if owner.is_a?(Prism::DefNode)
+                  owner.end_keyword_loc
+                else
+                  owner.closing_loc
+                end
+      body_start, body_length = default_owner_body_span(owner, closing)
+      details = { byte_start: owner.location.start_offset, byte_length: owner.location.length,
+                  equal: equal_loc ? true : false, body_start: body_start,
+                  body_length: body_length, closing_start: closing&.start_offset }
+      details.freeze
+    end
+
+    # Prism represents a method-level `rescue`/`ensure` as an implicit
+    # BeginNode whose location covers the whole def. Its insertion point is
+    # the actual statements (or rescue/ensure clause), not the def keyword.
+    def default_owner_body_span(owner, closing)
+      body = owner.body
+      if body.is_a?(Prism::BeginNode) && body.begin_keyword_loc.nil?
+        statements = body.statements
+        start = implicit_begin_start(statements, body, closing)
+        finish = closing&.start_offset || (body.location.start_offset + body.location.length)
+        return [start, start && finish ? [finish - start, 0].max : nil]
+      end
+
+      [body&.location&.start_offset, body&.location&.length]
+    end
+
+    def implicit_begin_start(statements, body, closing)
+      [statements&.location&.start_offset, body.rescue_clause&.location&.start_offset,
+       body.ensure_clause&.location&.start_offset, closing&.start_offset].compact.first
+    end
+  end
+  # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+end