ibex 0.1.0 → 0.3.0

data/lib/ibex/codegen/explain.rb

@@ -0,0 +1,380 @@
+# frozen_string_literal: true
+
+require_relative "../lalr"
+require_relative "symbol_labels"
+
+module Ibex
+  module Codegen
+    # @rbs!
+    #   type explain_selection = {
+    #     state: IR::AutomatonState,
+    #     conflict: IR::conflict,
+    #     conflict_index: Integer
+    #   }
+    #
+    #   type explain_entry = {
+    #     state: IR::AutomatonState,
+    #     conflict: IR::conflict,
+    #     example: LALR::search_counterexample
+    #   }
+    #
+    #   type explain_token = { name: String, display_name: String?, label: String, ?query: String }
+    #   type explain_alternative = { kind: String, ?state: Integer, ?production: Integer }
+    #   type explain_search = {
+    #     status: String, explored: Integer, exhausted: bool, bounds: Hash[Symbol, Integer]
+    #   }
+    #   type explain_tree_node = {
+    #     ?symbol: explain_token, ?token: explain_token, ?production: Integer, ?children: Array[explain_tree]
+    #   }
+    #   type explain_tree = untyped
+    #   type explain_interpretation = Hash[Symbol, untyped]
+    #   type string_value = String | Integer | Symbol
+
+    # Renders a selected conflict explanation from Automaton IR and counterexamples.
+    # rubocop:disable Metrics/ClassLength -- inline contracts and two stable output formats stay near selection policy.
+    class Explain
+      SCHEMA_VERSION = 1 #: Integer
+
+      # @rbs (IR::Automaton automaton, ?state: Integer?, ?token: String?, ?max_tokens: Integer,
+      #   ?max_configurations: Integer) -> void
+      def initialize(automaton, state: nil, token: nil, max_tokens: LALR::Counterexample::DEFAULT_MAX_TOKENS,
+                     max_configurations: LALR::Counterexample::DEFAULT_MAX_CONFIGURATIONS)
+        @automaton = automaton
+        @grammar = automaton.grammar
+        @state_selector = state
+        @token_query = token
+        @max_tokens = max_tokens
+        @max_configurations = max_configurations
+        @labels = SymbolLabels.build(@grammar)
+        @token_selector = resolve_token(token)
+        validate_state!
+        @entries = select_entries
+      end
+
+      # @rbs () -> Hash[Symbol, Object?]
+      def to_h
+        entries = @entries #: Array[explain_entry]
+        automaton = @automaton #: IR::Automaton
+        unifying = entries.count { |entry| entry.fetch(:example).fetch(:unifying) }
+        inconclusive = entries.count { |entry| entry.fetch(:example).fetch(:inconclusive) }
+        {
+          ibex_explain: "conflicts",
+          schema_version: SCHEMA_VERSION,
+          algorithm: automaton.algorithm,
+          selectors: {
+            state: @state_selector,
+            token: @token_selector && token_reference(@token_selector, query: @token_query)
+          },
+          search: { max_tokens: @max_tokens, max_configurations: @max_configurations },
+          summary: {
+            matched_conflicts: entries.length,
+            unifying_counterexamples: unifying,
+            nonunifying_witnesses: entries.length - unifying - inconclusive,
+            inconclusive_searches: inconclusive
+          },
+          conflicts: entries.map { |entry| conflict_document(entry) }
+        }
+      end
+
+      # @rbs () -> String
+      def render_text
+        automaton = @automaton #: IR::Automaton
+        entries = @entries #: Array[explain_entry]
+        state_selector = @state_selector #: Integer?
+        token_selector = @token_selector #: IR::GrammarSymbol?
+        lines = [
+          "Ibex conflict explanation v#{SCHEMA_VERSION}",
+          "Algorithm: #{automaton.algorithm}",
+          "State selector: #{state_selector || 'all'}",
+          "Token selector: #{token_selector ? token_label(token_selector, query: @token_query) : 'all'}",
+          "Search budget: #{@max_tokens} tokens, #{@max_configurations} configurations",
+          "Matched conflicts: #{entries.length}",
+          ""
+        ]
+        if entries.empty?
+          lines << "No conflicts matched the selectors."
+        else
+          entries.each_with_index { |entry, index| append_conflict(lines, entry, index + 1) }
+        end
+        "#{lines.join("\n")}\n"
+      end
+
+      private
+
+      # @rbs (String? query) -> IR::GrammarSymbol?
+      def resolve_token(query)
+        return unless query
+
+        grammar = @grammar #: IR::Grammar
+        canonical = grammar.terminals.find { |symbol| symbol.name == query }
+        return canonical if canonical
+
+        displayed = grammar.terminals.select { |symbol| symbol.display_name == query }
+        return displayed.first if displayed.one?
+
+        if displayed.length > 1
+          names = displayed.map(&:name).sort.join(", ")
+          raise Ibex::Error, "(cli):1:1: token display name #{query.inspect} is ambiguous; use one of: #{names}"
+        end
+
+        raise Ibex::Error,
+              "(cli):1:1: unknown token #{query.inspect}; use a grammar token name or an exact display name"
+      end
+
+      # @rbs () -> void
+      def validate_state!
+        state_selector = @state_selector #: Integer?
+        automaton = @automaton #: IR::Automaton
+        return unless state_selector
+        return if state_selector >= 0 && automaton.states.any? { |state| state.id == state_selector }
+
+        raise Ibex::Error, "(cli):1:1: unknown automaton state #{state_selector}"
+      end
+
+      # @rbs () -> Array[explain_entry]
+      def select_entries
+        selections = selected_conflicts
+        return [] if selections.empty?
+
+        automaton = @automaton #: IR::Automaton
+        counterexamples = LALR::Counterexample.new(
+          automaton, max_tokens: @max_tokens, max_configurations: @max_configurations
+        )
+        selections.map do |selection|
+          state = selection.fetch(:state)
+          {
+            state: state,
+            conflict: selection.fetch(:conflict),
+            example: counterexamples.for_conflict(state.id, selection.fetch(:conflict_index))
+          }
+        end
+      end
+
+      # @rbs () -> Array[explain_selection]
+      def selected_conflicts
+        automaton = @automaton #: IR::Automaton
+        state_selector = @state_selector #: Integer?
+        token_selector = @token_selector #: IR::GrammarSymbol?
+        automaton.states.flat_map do |state|
+          state.conflicts.each_with_index.filter_map do |conflict, conflict_index|
+            next if state_selector && state.id != state_selector
+            next if token_selector && conflict[:symbol] != token_selector.name
+
+            { state: state, conflict: conflict, conflict_index: conflict_index }
+          end
+        end
+      end
+
+      # @rbs (explain_entry entry) -> Hash[Symbol, Object?]
+      def conflict_document(entry)
+        state = entry.fetch(:state)
+        conflict = entry.fetch(:conflict)
+        example = entry.fetch(:example)
+        document = {
+          state: state.id,
+          type: conflict.fetch(:type).to_s,
+          token: symbol_reference(conflict.fetch(:symbol)),
+          alternatives: conflict_alternatives(conflict),
+          resolution: string_values(conflict.fetch(:resolution)),
+          witness: {
+            kind: witness_kind(example),
+            sentence: example.fetch(:sentence).map { |name| symbol_reference(name) },
+            lookahead_index: example.fetch(:lookahead_index),
+            symbol_path: example.fetch(:symbol_path).map { |name| symbol_reference(name) },
+            search: search_document(example.fetch(:search)),
+            interpretations: example.fetch(:interpretations).map { |item| interpretation_document(item) }
+          }
+        } #: Hash[Symbol, Object?]
+        document[:midrule_origins] = conflict[:midrule_origins] if conflict[:midrule_origins]
+        document
+      end
+
+      # @rbs (LALR::search_counterexample example) -> String
+      def witness_kind(example)
+        return "unifying_counterexample" if example.fetch(:unifying)
+        return "inconclusive" if example.fetch(:inconclusive)
+
+        "nonunifying_witness"
+      end
+
+      # @rbs (LALR::search_outcome outcome) -> explain_search
+      def search_document(outcome)
+        {
+          status: outcome.fetch(:status).to_s,
+          explored: outcome.fetch(:explored),
+          exhausted: outcome.fetch(:exhausted),
+          bounds: outcome.fetch(:bounds)
+        }
+      end
+
+      # @rbs (IR::conflict conflict) -> Array[explain_alternative]
+      def conflict_alternatives(conflict)
+        case conflict[:type]
+        when :shift_reduce
+          shift = { kind: "shift", state: conflict.fetch(:shift_to) } # @type var shift: explain_alternative
+          reduce = { kind: "reduce", production: conflict.fetch(:reduce) } # @type var reduce: explain_alternative
+          [shift, reduce]
+        when :reduce_reduce
+          reduce_reduce = conflict #: IR::reduce_reduce_conflict
+          reduce_reduce[:reductions].map do |production|
+            { kind: "reduce", production: production }
+          end #: Array[explain_alternative]
+        else
+          []
+        end
+      end
+
+      # @rbs (IR::interpretation interpretation) -> explain_interpretation
+      def interpretation_document(interpretation)
+        kind = interpretation.fetch(:kind) #: Symbol
+        tree = interpretation.fetch(:tree) #: explain_tree
+        value = { kind: kind.to_s,
+                  tree: tree_document(tree) } # @type var value: explain_interpretation
+        value[:state] = interpretation[:state] if interpretation.key?(:state)
+        value[:production] = interpretation[:production] if interpretation.key?(:production)
+        value
+      end
+
+      # @rbs (explain_tree tree) -> explain_tree
+      def tree_document(tree)
+        return symbol_reference(tree.to_s) unless tree.is_a?(Hash)
+
+        node = tree #: explain_tree_node
+        value = {} # @type var value: explain_tree_node
+        value[:symbol] = symbol_reference(node[:symbol].to_s) if node[:symbol]
+        value[:token] = symbol_reference(node[:token].to_s) if node[:token]
+        value[:production] = node[:production] if node[:production]
+        value[:children] = node[:children].map { |child| tree_document(child) } if node[:children]
+        value
+      end
+
+      # @rbs (Hash[Symbol, string_value] value) -> Hash[Symbol, string_value]
+      def string_values(value)
+        values = value #: Hash[Symbol, string_value]
+        values.transform_values { |item| item.is_a?(Symbol) ? item.to_s : item }
+      end
+
+      # @rbs (String name) -> explain_token
+      def symbol_reference(name)
+        grammar = @grammar #: IR::Grammar
+        symbol = grammar.symbol(name)
+        return { name: name, display_name: nil, label: name } unless symbol
+
+        token_reference(symbol)
+      end
+
+      # @rbs (IR::GrammarSymbol symbol, ?query: String?) -> explain_token
+      def token_reference(symbol, query: nil)
+        labels = @labels #: Hash[Integer, String]
+        value = { name: symbol.name, display_name: symbol.display_name,
+                  label: labels.fetch(symbol.id, symbol.name) } # @type var value: explain_token
+        value[:query] = query if query
+        value
+      end
+
+      # @rbs (Array[String] lines, explain_entry entry, Integer number) -> void
+      def append_conflict(lines, entry, number)
+        state = entry.fetch(:state)
+        conflict = entry.fetch(:conflict)
+        example = entry.fetch(:example)
+        grammar = @grammar #: IR::Grammar
+        token = grammar.symbol(conflict.fetch(:symbol))
+        token_text = token ? token_label(token) : conflict.fetch(:symbol)
+        type = conflict.fetch(:type).to_s.tr("_", "/")
+        lines << "Conflict #{number}: state #{state.id}, #{type}, token #{token_text}"
+        append_midrule_origins(lines, conflict)
+        append_witness_steps(lines, state, conflict, example)
+        append_interpretations(lines, example)
+        if example.fetch(:inconclusive)
+          search = example.fetch(:search)
+          lines << "  Search exhausted after #{search.fetch(:explored)} configurations; classification is inconclusive."
+        elsif !example.fetch(:unifying)
+          lines << "  The search found no shared sentence within the configured budget; this witness is deterministic."
+        end
+        lines << ""
+      end
+
+      # @rbs (Array[String] lines, IR::conflict conflict) -> void
+      def append_midrule_origins(lines, conflict)
+        origins = conflict[:midrule_origins]
+        return unless origins
+
+        origins.each do |origin|
+          lines << "  Midrule action origin: #{origin.fetch(:file)}:#{origin.fetch(:line)}:#{origin.fetch(:column)}"
+        end
+      end
+
+      # @rbs (Array[String] lines, IR::AutomatonState state, IR::conflict conflict,
+      #   LALR::search_counterexample example) -> void
+      def append_witness_steps(lines, state, conflict, example)
+        lines << "  1. Reach state #{state.id} with the witness prefix."
+        sentence = example.fetch(:sentence).map { |name| display_name(name) }
+        sentence.insert(example.fetch(:lookahead_index), "•")
+        kind = case witness_kind(example)
+               when "unifying_counterexample" then "Unifying counterexample"
+               when "inconclusive" then "Inconclusive reachability witness"
+               else "Nonunifying reachability witness"
+               end
+        lines << "     #{kind}: #{sentence.join(' ')}"
+        lines << "  2. The lookahead permits these competing actions:"
+        conflict_alternatives(conflict).each { |alternative| lines << "     - #{alternative_text(alternative)}" }
+        resolution = conflict.fetch(:resolution)
+        lines << "  3. Resolution: #{resolution.fetch(:by)} chose #{resolution.fetch(:chose)}."
+      end
+
+      # @rbs (Array[String] lines, LALR::search_counterexample example) -> void
+      def append_interpretations(lines, example)
+        lines << "  Competing derivations:"
+        example.fetch(:interpretations).each_with_index do |interpretation, index|
+          lines << "    #{index + 1}. #{interpretation.fetch(:kind)}"
+          append_tree(lines, interpretation.fetch(:tree), "       ", "")
+        end
+      end
+
+      # @rbs (explain_alternative alternative) -> String
+      def alternative_text(alternative)
+        return "shift to state #{alternative.fetch(:state)}" if alternative.fetch(:kind) == "shift"
+
+        "reduce by production #{alternative.fetch(:production)}"
+      end
+
+      # @rbs (Array[String] lines, explain_tree tree, String prefix, String connector) -> void
+      def append_tree(lines, tree, prefix, connector)
+        unless tree.is_a?(Hash)
+          lines << "#{prefix}#{connector}#{display_name(tree.to_s)}"
+          return
+        end
+
+        node = tree #: explain_tree_node
+        name = node[:symbol] || node[:token]
+        production = node[:production] ? " (production #{node[:production]})" : ""
+        lines << "#{prefix}#{connector}#{display_name(name.to_s)}#{production}"
+        children = node.fetch(:children, [])
+        continuation = { "" => "", "|- " => "|  " }.fetch(connector, "   ")
+        child_prefix = "#{prefix}#{continuation}"
+        children.each_with_index do |child, index|
+          branch = index == children.length - 1 ? "`- " : "|- "
+          append_tree(lines, child, child_prefix, branch)
+        end
+      end
+
+      # @rbs (IR::GrammarSymbol symbol, ?query: String?) -> String
+      def token_label(symbol, query: nil)
+        label = if symbol.display_name && symbol.display_name != symbol.name
+                  "#{symbol.name} (display #{symbol.display_name.inspect})"
+                else
+                  symbol.name
+                end
+        query && query != symbol.name ? "#{label}, selected by #{query.inspect}" : label
+      end
+
+      # @rbs (String name) -> String
+      def display_name(name)
+        grammar = @grammar #: IR::Grammar
+        labels = @labels #: Hash[Integer, String]
+        grammar.symbol(name)&.then { |symbol| labels.fetch(symbol.id, symbol.name) } || name
+      end
+    end
+    # rubocop:enable Metrics/ClassLength
+  end
+end

data/lib/ibex/codegen/generated_action_abi.rb

@@ -0,0 +1,293 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require_relative "action_locations"
+
+module Ibex
+  module Codegen
+    # Selects the smallest generated semantic-action ABI that preserves the
+    # action's declared inputs.
+    # rubocop:disable Metrics/ModuleLength -- ABI proof and source rewriting must evolve together.
+    module GeneratedActionABI
+      # @rbs!
+      #   type ripper_token = [[Integer, Integer], Symbol, String, Integer]
+      #   type sexp_value = Symbol | String | Integer | nil | Array[sexp_value]
+
+      LEGACY_PARAMETERS = %w[
+        _values
+        _ibex_locations
+        _ibex_location_stack
+        _ibex_location
+        _ibex_lookahead_location
+      ].freeze #: Array[String]
+      SIMPLE_POSITIONAL_READ = /(?<![.\w@$])val\[\s*(\d+)\s*\]/ #: Regexp
+      SIMPLE_POSITIONAL_UNSAFE = %r{['"`#%/\\]|<<} #: Regexp
+      private_constant :LEGACY_PARAMETERS
+      private_constant :SIMPLE_POSITIONAL_READ, :SIMPLE_POSITIONAL_UNSAFE
+
+      # Keeps semantic-action analysis local to one code-generation run.
+      class Cache
+        # @rbs @values_only: Hash[Integer, bool]
+        # @rbs @borrowed_values: Hash[Integer, bool]
+        # @rbs @positional_actions: Hash[Integer, String?]
+
+        # @rbs () -> void
+        def initialize
+          @values_only = {}
+          @borrowed_values = {}
+          @positional_actions = {}
+        end
+
+        # @rbs (IR::Production production) -> bool
+        def values_only?(production)
+          @values_only.fetch(production.id) do
+            @values_only[production.id] = GeneratedActionABI.values_only?(production)
+          end
+        end
+
+        # @rbs (IR::Production production) -> bool
+        def borrowed_values?(production)
+          @borrowed_values.fetch(production.id) do
+            @borrowed_values[production.id] =
+              GeneratedActionABI.borrowed_values?(production, analysis: self)
+          end
+        end
+
+        # @rbs (IR::Production production) -> String?
+        def positional_action_source(production)
+          @positional_actions.fetch(production.id) do
+            @positional_actions[production.id] =
+              GeneratedActionABI.positional_action_source(production, analysis: self)
+          end
+        end
+
+        # @rbs (IR::Production production) -> bool
+        def positional_values?(production)
+          !positional_action_source(production).nil?
+        end
+      end
+
+      module_function
+
+      # @rbs (IR::Production production) -> bool
+      def values_only?(production)
+        return false if production.action&.composition
+
+        action = production.action
+        return true unless action
+        return false if action.context_length.positive?
+
+        maximum = production.rhs.length
+        locations = ActionLocations.new(action.code, maximum: maximum, location: action.location)
+        !locations.references? && !references_legacy_parameter?(action.code)
+      end
+
+      # The direct runtime can share one reduction-values array with an action
+      # and a hook installed by that action only when the action cannot mutate
+      # or retain the array itself. Element reads and parallel assignment copy
+      # values out without exposing the container.
+      # @rbs (IR::Production production, ?analysis: singleton(GeneratedActionABI) | Cache) -> bool
+      def borrowed_values?(production, analysis: self)
+        return false unless analysis.values_only?(production)
+
+        action = production.action
+        return false unless action
+
+        maximum = production.rhs.length
+        source = ActionLocations.new(action.code, maximum: maximum, location: action.location).rewrite
+        return true if simple_indexed_values_action?(source)
+
+        require "ripper"
+        syntax = Object.const_get(:Ripper).__send__(:sexp, source)
+        !syntax.nil? && read_only_value_references?(syntax)
+      end
+
+      # Return semantic source rewritten for zero-to-four positional RHS
+      # arguments, or nil when the values container remains observable.
+      # @rbs (IR::Production production, ?analysis: singleton(GeneratedActionABI) | Cache) -> String?
+      def positional_action_source(production, analysis: self)
+        return nil unless analysis.values_only?(production)
+        return nil unless production.rhs.length <= 4
+
+        action = production.action
+        return "" unless action
+        return nil unless analysis.borrowed_values?(production)
+
+        parameters = Array.new(production.rhs.length) { |index| "v#{index}" }
+        return nil if action.named_refs.any? { |reference| parameters.include?(reference[:name]) }
+
+        maximum = production.rhs.length
+        source = ActionLocations.new(action.code, maximum: maximum, location: action.location).rewrite
+        simple = fast_positional_action_source(source, parameters)
+        return simple unless simple.nil?
+
+        require "ripper"
+        tokens = Object.const_get(:Ripper).__send__(:lex, source)
+        return nil unless tokens.map { |_position, _event, token, _state| token }.join == source
+
+        rewrite_positional_values(tokens, parameters)
+      end
+
+      # @rbs (String source, Array[String] parameters) -> String?
+      def fast_positional_action_source(source, parameters)
+        simple = simple_positional_action_source(source, parameters)
+        return simple unless simple.nil?
+
+        simple_indexed_positional_action_source(source, parameters)
+      end
+      private_class_method :fast_positional_action_source
+
+      # @rbs (IR::Production production) -> bool
+      def positional_values?(production)
+        !positional_action_source(production).nil?
+      end
+
+      # Avoid loading a Ruby parser for the overwhelmingly common generated
+      # action shape. This accepts only a single result assignment (or a bare
+      # expression), simple numeric val reads, and no further assignment.
+      # Anything less obvious falls back to Ripper below.
+      # @rbs (String source) -> bool
+      def simple_indexed_values_action?(source)
+        body = source.strip
+        assignment = /\Aresult\s*=\s*(.*)\z/m.match(body)
+        body = (assignment[1] || "").strip if assignment
+        return false if body.empty? || body.match?(/(?<![=!<>])=(?!=|>)/)
+        return true unless body.match?(/\bval\b/)
+
+        without_reads = body.gsub(/\bval\[\s*\d+\s*\]/, "")
+        without_reads != body && !without_reads.match?(/\bval\b/)
+      end
+      private_class_method :simple_indexed_values_action?
+
+      # Keep the most common identity action off the Ripper load path. The
+      # whole-source match excludes strings, comments, receivers, and compound
+      # expressions before replacing the one direct read.
+      # @rbs (String source, Array[String] parameters) -> String?
+      def simple_positional_action_source(source, parameters)
+        match = /\A\s*(?:result\s*=\s*)?val\[\s*(\d+)\s*\]\s*\z/.match(source)
+        return nil unless match
+
+        parameter = parameters[Integer(match[1] || "", 10)]
+        source.sub(/\bval\[\s*\d+\s*\]/, parameter) if parameter
+      end
+      private_class_method :simple_positional_action_source
+
+      # Rewrite the common string/comment/regexp-free action shape without
+      # loading Ripper. The borrowed-values proof has already rejected writes
+      # and escaping uses of the values container.
+      # @rbs (String source, Array[String] parameters) -> String?
+      def simple_indexed_positional_action_source(source, parameters)
+        return nil if source.match?(SIMPLE_POSITIONAL_UNSAFE)
+        return nil if parameters.any? { |parameter| source.match?(/\b#{Regexp.escape(parameter)}\b/) }
+
+        valid = true
+        rewritten = source.gsub(SIMPLE_POSITIONAL_READ) do
+          parameter = parameters.fetch(Integer(Regexp.last_match(1) || "", 10), nil)
+          valid = false unless parameter
+          parameter || Regexp.last_match(0)
+        end
+        return nil unless valid
+        return nil if rewritten.match?(/\bval\b/)
+
+        rewritten
+      end
+      private_class_method :simple_indexed_positional_action_source
+
+      # @rbs (Array[ripper_token] tokens, Array[String] parameters) -> String?
+      def rewrite_positional_values(tokens, parameters)
+        result = [] #: Array[String]
+        index = 0
+        while index < tokens.length
+          _position, event, token, _state = tokens[index]
+          return nil if event == :on_ident && parameters.include?(token)
+
+          unless event == :on_ident && token == "val"
+            result << token
+            index += 1
+            next
+          end
+
+          reference = positional_value_reference(tokens, index, parameters)
+          if reference
+            result << reference.fetch(0)
+            index = reference.fetch(1)
+          elsif receiver_before_value?(tokens, index) || parameters.empty?
+            return nil
+          else
+            # borrowed_values? has already proven that a bare `val` occurs
+            # only as the right-hand side of parallel assignment.
+            result << parameters.join(", ")
+            index += 1
+          end
+        end
+        result.join
+      end
+      private_class_method :rewrite_positional_values
+
+      # @rbs (Array[ripper_token] tokens, Integer index, Array[String] parameters) -> [String, Integer]?
+      def positional_value_reference(tokens, index, parameters)
+        return nil if receiver_before_value?(tokens, index)
+
+        reference = tokens.slice(index + 1, 3)
+        return nil unless reference
+        return nil unless reference.map { |entry| entry[1] } == %i[on_lbracket on_int on_rbracket]
+
+        parameter = parameters[Integer(reference.fetch(1).fetch(2), 10)]
+        [parameter, index + 4] if parameter
+      rescue ArgumentError
+        nil
+      end
+      private_class_method :positional_value_reference
+
+      # @rbs (Array[ripper_token] tokens, Integer index) -> bool
+      def receiver_before_value?(tokens, index)
+        previous = tokens.first(index).reverse.find do |entry|
+          !%i[on_sp on_nl on_ignored_nl on_comment].include?(entry[1])
+        end
+        return false unless previous
+
+        previous[1] == :on_period || (previous[1] == :on_op && %w[&. ::].include?(previous[2]))
+      end
+      private_class_method :receiver_before_value?
+
+      # @rbs (String source) -> bool
+      def references_legacy_parameter?(source)
+        return false unless LEGACY_PARAMETERS.any? { |parameter| source.include?(parameter) }
+
+        require "ripper"
+        tokens = Object.const_get(:Ripper).__send__(:lex, source.gsub(/@(?:\$|\d+)/) { |match| "_" * match.bytesize })
+        tokens.any? do |_position, type, token, _state|
+          type == :on_ident && LEGACY_PARAMETERS.include?(token)
+        end
+      end
+      private_class_method :references_legacy_parameter?
+
+      # @rbs (sexp_value node, ?sexp_value parent, ?Integer? child_index) -> bool
+      def read_only_value_references?(node, parent = nil, child_index = nil)
+        return true unless node.is_a?(Array)
+        return safe_value_reference?(parent, child_index) if value_reference?(node)
+
+        node.each_with_index.all? do |child, index|
+          read_only_value_references?(child, node, index)
+        end
+      end
+      private_class_method :read_only_value_references?
+
+      # @rbs (untyped node) -> bool
+      def value_reference?(node)
+        node[0] == :vcall && node.dig(1, 0) == :@ident && node.dig(1, 1) == "val"
+      end
+      private_class_method :value_reference?
+
+      # @rbs (sexp_value? parent, Integer? child_index) -> bool
+      def safe_value_reference?(parent, child_index)
+        return false unless parent.is_a?(Array)
+
+        (parent[0] == :aref && child_index == 1) ||
+          (parent[0] == :massign && child_index == 2)
+      end
+      private_class_method :safe_value_reference?
+    end
+    # rubocop:enable Metrics/ModuleLength
+  end
+end