branchproof 0.7.0 → 0.9.0

data/lib/branchproof/decision_table.rb

@@ -0,0 +1,377 @@
+# frozen_string_literal: true
+
+require_relative "records"
+require_relative "constraints"
+require_relative "limits"
+
+module Branchproof
+  # Derives the executable logical rules of a supported Boolean decision and
+  # overlays the runtime evidence that the existing Branchproof run captured.
+  #
+  # Rules come from the Boolean tree itself rather than from an exhaustive
+  # Cartesian expansion, so Ruby's short-circuit semantics are preserved: a
+  # condition the interpreter would skip becomes an explicit +dont_care+ value
+  # instead of two separate rules.
+  #
+  # Nothing here executes application code, and no additional test run is
+  # required: overlay consumes the vectors already recorded for the decision.
+  module DecisionTable
+    SCHEMA_VERSION = 1
+    CONSTRAINT_ANALYSIS_VERSION = Constraints::VERSION
+    TRUE_VALUE = "true"
+    FALSE_VALUE = "false"
+    DONT_CARE = "dont_care"
+    VALUE_LABELS = { TRUE_VALUE => "T", FALSE_VALUE => "F", DONT_CARE => "-" }.freeze
+    CONDITION_VALUES = [TRUE_VALUE, FALSE_VALUE, DONT_CARE].freeze
+    REACHABILITY_STATUSES = %w[observed unknown statically_impossible].freeze
+    COVERAGE_STATUSES = %w[covered missing excluded].freeze
+    TABLE_STATUSES = %w[calculated not_calculated].freeze
+    COVERAGE_SUMMARY_STATUSES = %w[covered partial unexecuted unsupported not_calculated].freeze
+    NOT_CALCULATED_REASONS = %w[
+      unsupported_decision decision_table_unavailable
+      decision_table_condition_limit_exceeded decision_table_rule_limit_exceeded
+    ].freeze
+    DEFAULT_MAX_CONDITIONS = Limits::DEFAULTS[:max_conditions_for_decision_table]
+    DEFAULT_MAX_RULES = Limits::DEFAULTS[:decision_table_rules_per_decision]
+
+    module_function
+
+    # Builds the reduced, runtime-overlaid table for one Boolean decision.
+    def build(decision:, vectors: [], limits: {}, reachability: true)
+      raise ArgumentError, "reachability must be a Boolean" unless [true, false].include?(reachability)
+
+      decision_id = fetch(decision, :id).to_s
+      reason = unavailable_reason(decision, limits)
+      return not_calculated(decision_id, reason) if reason
+
+      max_rules = limit(limits, :decision_table_rules_per_decision, DEFAULT_MAX_RULES)
+      paths = enumerate(fetch(decision, :tree), false, max_rules + 1)
+      return not_calculated(decision_id, "decision_table_rule_limit_exceeded") if paths.nil? || paths.length > max_rules
+
+      conditions = Array(fetch(decision, :conditions))
+      prepared_constraints = conditions.map do |condition|
+        raw = fetch(condition, :constraint)
+        raw = Constraints.symbolize(raw)
+        fetch(condition, :constraint_safe) == true && Constraints.usable?(raw) ? raw : nil
+      end
+      rules = paths.each_with_index.map do |path, index|
+        rule(decision_id, conditions, path, index, reachability: reachability,
+                                                   prepared_constraints: prepared_constraints)
+      end
+      overlay(decision_id: decision_id, rules: rules, vectors: Array(vectors), reachability: reachability,
+              indexed: unique_atom_indices?(fetch(decision, :tree)))
+    end
+
+    # Names why a decision carries no Boolean table, or nil when it carries one.
+    def unavailable_reason(decision, limits)
+      support = fetch(decision, :support_status).to_s
+      return "unsupported_decision" unless support.empty? || support.casecmp("supported").zero?
+
+      tree = fetch(decision, :tree)
+      return "decision_table_unavailable" if tree.nil?
+
+      conditions = Array(fetch(decision, :conditions)).length
+      return "decision_table_condition_limit_exceeded" if conditions >
+                                                          limit(limits, :max_conditions_for_decision_table,
+                                                                DEFAULT_MAX_CONDITIONS)
+      return "decision_table_unavailable" unless representable?(tree, conditions)
+
+      nil
+    end
+
+    # Only AND, OR, NOT, and atoms within the decision's own condition range are
+    # representable; anything else leaves the table uncalculated rather than
+    # producing a table that does not describe the decision.
+    def representable?(node, condition_count)
+      case fetch(node, :type).to_s
+      when "atom" then fetch(node, :index).is_a?(Integer) && (0...condition_count).cover?(fetch(node, :index))
+      when "not" then representable?(fetch(node, :child), condition_count)
+      when "and", "or"
+        representable?(fetch(node, :left), condition_count) &&
+          representable?(fetch(node, :right), condition_count)
+      else false
+      end
+    end
+
+    def unique_atom_indices?(node, seen = {})
+      case fetch(node, :type).to_s
+      when "atom"
+        index = fetch(node, :index)
+        return false if seen.key?(index)
+
+        seen[index] = true
+        true
+      when "not"
+        unique_atom_indices?(fetch(node, :child), seen)
+      when "and", "or"
+        unique_atom_indices?(fetch(node, :left), seen) && unique_atom_indices?(fetch(node, :right), seen)
+      else false
+      end
+    end
+
+    # Enumerates every short-circuit evaluation path of the Boolean tree.
+    #
+    # +prefer+ orders the paths deterministically: a conjunction lists its
+    # short-circuiting false path first, a disjunction its true path first, and
+    # a negation inverts the preference it inherits. Returns nil once the path
+    # count would exceed +budget+.
+    def enumerate(node, prefer, budget)
+      type = fetch(node, :type).to_s
+      case type
+      when "atom"
+        index = fetch(node, :index).to_i
+        (prefer ? [true, false] : [false, true]).map { |value| { assignments: { index => value }, value: value } }
+      when "not"
+        paths = enumerate(fetch(node, :child), !prefer, budget)
+        paths&.map { |path| { assignments: path[:assignments], value: !path[:value] } }
+      when "and", "or"
+        combine(node, type, budget)
+      end
+    end
+
+    def combine(node, type, budget)
+      short_circuit = type != "and"
+      left = enumerate(fetch(node, :left), short_circuit, budget)
+      return nil unless left
+
+      right = nil
+      paths = []
+      left.each do |path|
+        if path[:value] == short_circuit
+          paths << path
+          next
+        end
+        right ||= enumerate(fetch(node, :right), short_circuit, budget)
+        return nil unless right
+
+        right.each do |tail|
+          paths << { assignments: path[:assignments].merge(tail[:assignments]), value: tail[:value] }
+        end
+        return nil if paths.length > budget
+      end
+      paths.length > budget ? nil : paths
+    end
+
+    # rubocop:disable-next Metrics/ParameterLists
+    def rule(decision_id, conditions, path, index, reachability: true, prepared_constraints: nil)
+      values = Array.new(conditions.length, DONT_CARE)
+      path[:assignments].each do |condition_index, value|
+        values[condition_index] = value ? TRUE_VALUE : FALSE_VALUE if condition_index < values.length
+      end
+      outcome = path[:value] ? true : false
+      reachability_state, reason = if reachability
+                                     static_reachability(conditions, values, prepared_constraints: prepared_constraints)
+                                   else
+                                     ["unknown", nil]
+                                   end
+      { id: rule_id(decision_id, values, outcome), label: "R#{index + 1}", index: index,
+        conditions: values, outcome: outcome, reachability: reachability_state, reachability_reason: reason }
+    end
+
+    # Rule identity depends only on the decision, the normalized condition
+    # vector, the expected outcome, and the table schema version. It never
+    # depends on a test name, a runtime observation, or the Minitest seed.
+    def rule_id(decision_id, values, outcome)
+      Records.id(schema_version: SCHEMA_VERSION, decision_id: decision_id.to_s,
+                 conditions: values, outcome: outcome)
+    end
+
+    # Conservative static reachability: prove impossibility, or answer unknown.
+    def static_reachability(conditions, values, prepared_constraints: nil)
+      solver = Constraints::Solver.new
+      values.each_with_index do |value, index|
+        next if value == DONT_CARE
+
+        condition = conditions[index] || {}
+        truth = value == TRUE_VALUE
+        literal = fetch(condition, :literal_truth)
+        return %w[statically_impossible boolean_literal_conflict] if !literal.nil? && literal != truth
+
+        next unless fetch(condition, :constraint_safe) == true
+
+        prepared = prepared_constraints && prepared_constraints[index]
+        reason = if prepared
+                   solver.add_prepared(prepared, truth)
+                 else
+                   solver.add(fetch(condition, :constraint), truth)
+                 end
+        return ["statically_impossible", reason] if reason
+      end
+      ["unknown", nil]
+    end
+
+    def overlay(decision_id:, rules:, vectors:, reachability: true, indexed: false)
+      diagnostics = []
+      matches = indexed ? classify_vectors(rules, vectors) : generic_matches(rules, vectors)
+      overlaid = rules.each_with_index.map do |item, index|
+        overlay_rule_matches(decision_id, item, matches[index], diagnostics)
+      end
+      summary(decision_id: decision_id, rules: overlaid, diagnostics: diagnostics,
+              reachability_analyzed: reachability)
+    end
+
+    # Generated traces have nil in every skipped condition position. Their
+    # normalized vector is therefore an exact table key and can be classified
+    # without scanning every rule. Malformed or hand-built observations retain
+    # the historical matcher as a bounded compatibility fallback.
+    def classify_vectors(rules, vectors)
+      condition_count = rules.first ? Array(rules.first[:conditions]).length : 0
+      by_signature = {}
+      rules.each_with_index do |item, position|
+        (by_signature[signature(item[:conditions], item[:outcome])] ||= []) << position
+      end
+      matches = Array.new(rules.length) { [] }
+      vectors.each do |vector|
+        positions = fast_match_positions(vector, by_signature, condition_count)
+        if positions&.length == 1
+          matches[positions.first] << vector
+        else
+          rules.each_with_index do |item, position|
+            matches[position] << vector if matches?(item, vector)
+          end
+        end
+      end
+      matches
+    end
+
+    def generic_matches(rules, vectors)
+      matches = Array.new(rules.length) { [] }
+      rules.each_with_index do |rule, position|
+        vectors.each { |vector| matches[position] << vector if matches?(rule, vector) }
+      end
+      matches
+    end
+
+    def signature(values, outcome)
+      [outcome ? true : false, Array(values).map { |value| value == DONT_CARE ? nil : value == TRUE_VALUE }]
+    end
+
+    def fast_match_positions(vector, by_signature, condition_count)
+      values = Array(fetch(vector, :values))
+      valid_values = values.all? { |value| value.nil? || value == true || value == false }
+      return nil unless values.length >= condition_count && valid_values
+
+      normalized = values.first(condition_count).map do |value|
+        if value.nil?
+          DONT_CARE
+        elsif value
+          TRUE_VALUE
+        else
+          FALSE_VALUE
+        end
+      end
+      by_signature[signature(normalized, fetch(vector, :outcome))]
+    end
+
+    # Public compatibility wrapper: callers historically passed all vectors,
+    # so retain matcher filtering for direct calls.
+    def overlay_rule(decision_id, rule, vectors, diagnostics)
+      matched = Array(vectors).select { |vector| matches?(rule, vector) }
+      overlay_rule_matches(decision_id, rule, matched, diagnostics)
+    end
+
+    def overlay_rule_matches(decision_id, rule, matched, diagnostics)
+      observed = !matched.empty?
+      impossible = rule[:reachability] == "statically_impossible"
+      withdrawn = observed && impossible
+      if withdrawn
+        diagnostics << Records.diagnostic(
+          code: "constraint_model_conflict", severity: "warning",
+          message: "runtime evidence matched a statically impossible decision-table rule; " \
+                   "the impossibility claim is withdrawn",
+          decision_id: decision_id,
+          details: { rule_id: rule[:id], rule_label: rule[:label],
+                     reachability_reason: rule[:reachability_reason].to_s }
+        )
+      end
+      rule.merge(
+        coverage: if observed
+                    "covered"
+                  else
+                    (impossible ? "excluded" : "missing")
+                  end,
+        reachability: observed ? "observed" : rule[:reachability],
+        reachability_reason: observed ? nil : rule[:reachability_reason],
+        impossible_withdrawn: withdrawn,
+        withdrawn_reason: withdrawn ? rule[:reachability_reason] : nil,
+        tests: matched.flat_map { |vector| Array(fetch(vector, :test_ids)).map(&:to_s) }.uniq.sort,
+        vector_ids: matched.map { |vector| fetch(vector, :id).to_s }.uniq.sort,
+        unattributed_count: matched.sum { |vector| fetch(vector, :unattributed_count).to_i }
+      )
+    end
+
+    # A runtime observation matches a rule when every required condition value
+    # matches and the decision outcome matches. Conditions Ruby skipped may only
+    # line up with don't-care positions.
+    def matches?(rule, vector)
+      return false unless (fetch(vector, :outcome) ? true : false) == rule[:outcome]
+
+      values = Array(fetch(vector, :values))
+      rule[:conditions].each_with_index.all? do |required, index|
+        next true if required == DONT_CARE
+
+        values[index] == (required == TRUE_VALUE)
+      end
+    end
+
+    def summary(decision_id:, rules:, diagnostics:, reachability_analyzed: true)
+      generated = rules.length
+      impossible = rules.count { |rule| rule[:coverage] == "excluded" }
+      required = generated - impossible
+      covered = rules.count { |rule| rule[:coverage] == "covered" }
+      { status: "calculated", reason: nil, decision_id: decision_id,
+        schema_version: SCHEMA_VERSION, constraint_analysis_version: CONSTRAINT_ANALYSIS_VERSION,
+        rules: rules, generated_rules: generated, impossible_rules: impossible,
+        required_rules: required, covered_rules: covered, missing_rules: required - covered,
+        coverage_status: coverage_status(covered, required, generated),
+        percentage: percentage(covered, required), reachability_analyzed: reachability_analyzed,
+        diagnostics: diagnostics }
+    end
+
+    def coverage_status(covered, required, generated)
+      return "unexecuted" if generated.zero?
+      return "covered" if required.zero? || covered == required
+      return "unexecuted" if covered.zero?
+
+      "partial"
+    end
+
+    def not_calculated(decision_id, reason)
+      { status: "not_calculated", reason: reason, decision_id: decision_id,
+        schema_version: SCHEMA_VERSION, constraint_analysis_version: CONSTRAINT_ANALYSIS_VERSION,
+        rules: [], generated_rules: 0, impossible_rules: 0, required_rules: 0, covered_rules: 0,
+        missing_rules: 0,
+        coverage_status: reason == "unsupported_decision" ? "unsupported" : "not_calculated",
+        percentage: nil, reachability_analyzed: false, diagnostics: [] }
+    end
+
+    # The per-decision row the coverage ladder renders.
+    def coverage_entry(table)
+      { status: table[:coverage_status], table_status: table[:status], reason: table[:reason],
+        covered_rules: table[:covered_rules], required_rules: table[:required_rules],
+        generated_rules: table[:generated_rules], impossible_rules: table[:impossible_rules],
+        missing_rules: table[:missing_rules], percentage: table[:percentage],
+        reachability_analyzed: table[:reachability_analyzed] }
+    end
+
+    def unsupported_coverage_entry
+      coverage_entry(not_calculated(nil, "unsupported_decision"))
+    end
+
+    def percentage(covered, required)
+      required.zero? ? nil : (covered.to_f / required * 100).round(2)
+    end
+
+    def limit(limits, key, fallback)
+      value = fetch(limits, key)
+      value.is_a?(Integer) && value.positive? ? value : fallback
+    end
+
+    def fetch(record, key)
+      return nil unless record.respond_to?(:key?)
+      return record[key] if record.key?(key)
+
+      record[key.to_s]
+    end
+  end
+end

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