ibex 0.1.0

data/lib/ibex/lalr/conflict.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Ibex
+  module LALR
+    # Applies yacc-compatible precedence and ordering rules to action candidates.
+    class ConflictResolver
+      # @rbs (IR::Grammar grammar) -> void
+      def initialize(grammar)
+        @grammar = grammar
+      end
+
+      # @rbs (Integer token_id, Array[IR::parser_action] candidates) -> [IR::parser_action?, Array[IR::conflict]]
+      def resolve(token_id, candidates)
+        actions = candidates.uniq
+        return [actions.first, Array.new(0)] if actions.length <= 1
+
+        accept = actions.find { |action| action[:type] == :accept }
+        return [accept, Array.new(0)] if accept
+
+        shift = actions.find { |action| action[:type] == :shift } #: IR::shift_action?
+        reductions = reduction_actions(actions)
+        chosen_reduce, conflicts = resolve_reductions(token_id, reductions)
+        all_conflicts = widen_conflicts(conflicts)
+        return [chosen_reduce, all_conflicts] unless shift
+        return [shift, all_conflicts] unless chosen_reduce
+
+        chosen, conflict = resolve_shift_reduce(token_id, shift, chosen_reduce)
+        [chosen, all_conflicts << conflict]
+      end
+
+      private
+
+      # @rbs (Array[IR::parser_action] actions) -> Array[IR::reduce_action]
+      def reduction_actions(actions)
+        reductions = [] #: Array[IR::reduce_action]
+        actions.each do |action|
+          next unless action[:type] == :reduce
+
+          reduction = action #: IR::reduce_action
+          reductions << reduction
+        end
+        reductions.sort_by { |action| action[:production] }
+      end
+
+      # @rbs (Array[IR::reduce_reduce_conflict] conflicts) -> Array[IR::conflict]
+      def widen_conflicts(conflicts)
+        conflicts.map(&:itself) #: Array[IR::conflict]
+      end
+
+      # @rbs (Integer token_id, Array[IR::reduce_action] reductions) ->
+      #   [IR::reduce_action?, Array[IR::reduce_reduce_conflict]]
+      def resolve_reductions(token_id, reductions)
+        return [nil, Array.new(0)] if reductions.empty?
+        return [reductions.first, Array.new(0)] if reductions.length == 1
+
+        chosen = reductions.first
+        conflict = { type: :reduce_reduce, symbol: token_name(token_id),
+                     reductions: reductions.map { |action| action[:production] },
+                     resolution: { by: :definition_order, chose: chosen[:production] } } #: IR::reduce_reduce_conflict
+        [chosen, [conflict]]
+      end
+
+      # @rbs (Integer token_id, IR::shift_action shift, IR::reduce_action reduction) ->
+      #   [IR::parser_action, IR::shift_reduce_conflict]
+      def resolve_shift_reduce(token_id, shift, reduction)
+        token_precedence = required_symbol_by_id(token_id).precedence
+        production_precedence = precedence_for_production(reduction[:production])
+        chosen, resolution = precedence_choice(shift, reduction, token_precedence, production_precedence)
+        conflict = { type: :shift_reduce, symbol: token_name(token_id), shift_to: shift[:state],
+                     reduce: reduction[:production], resolution: resolution } #: IR::shift_reduce_conflict
+        [chosen, conflict]
+      end
+
+      # @rbs (IR::shift_action shift, IR::reduce_action reduction, IR::precedence? token_precedence,
+      #   IR::precedence? production_precedence) -> [IR::parser_action, IR::conflict_resolution]
+      def precedence_choice(shift, reduction, token_precedence, production_precedence)
+        return [shift, { by: :default_shift, chose: :shift }] unless token_precedence && production_precedence
+
+        comparison = token_precedence[:level] <=> production_precedence[:level]
+        return [shift, { by: :precedence, chose: :shift }] if comparison.positive?
+        return [reduction, { by: :precedence, chose: :reduce }] if comparison.negative?
+
+        associativity_choice(shift, reduction, token_precedence[:associativity])
+      end
+
+      # @rbs (IR::shift_action shift, IR::reduce_action reduction, Symbol associativity) ->
+      #   [IR::parser_action, IR::conflict_resolution]
+      def associativity_choice(shift, reduction, associativity)
+        case associativity.to_sym
+        when :left then [reduction, { by: :associativity, associativity: :left, chose: :reduce }]
+        when :right then [shift, { by: :associativity, associativity: :right, chose: :shift }]
+        when :nonassoc then [{ type: :error }, { by: :associativity, associativity: :nonassoc, chose: :error }]
+        else raise Ibex::Error, "unknown associativity #{associativity.inspect}"
+        end
+      end
+
+      # @rbs (Integer production_id) -> IR::precedence?
+      def precedence_for_production(production_id)
+        production = @grammar.productions.fetch(production_id)
+        return required_symbol_by_id(production.precedence_override).precedence if production.precedence_override
+
+        production.rhs.reverse_each do |symbol_id|
+          grammar_symbol = required_symbol_by_id(symbol_id)
+          return grammar_symbol.precedence if grammar_symbol.terminal? && grammar_symbol.precedence
+        end
+        nil
+      end
+
+      # @rbs (Integer token_id) -> String
+      def token_name(token_id)
+        required_symbol_by_id(token_id).name
+      end
+
+      # @rbs (Integer id) -> IR::GrammarSymbol
+      def required_symbol_by_id(id)
+        @grammar.symbol_by_id(id) || raise(Ibex::Error, "missing grammar symbol id #{id}")
+      end
+    end
+  end
+end

data/lib/ibex/lalr/conflict_search.rb

@@ -0,0 +1,332 @@
+# frozen_string_literal: true
+
+module Ibex
+  module LALR
+    # Searches the parser state space for one input accepted through both sides of a conflict.
+    # rubocop:disable Metrics/ClassLength -- inline type contracts make the focused search implementation longer.
+    class ConflictSearch
+      include ConflictSearchLimits
+
+      DEFAULT_MAX_TOKENS = ConflictSearchLimits::DEFAULT_MAX_TOKENS #: Integer
+      DEFAULT_MAX_CONFIGURATIONS = ConflictSearchLimits::DEFAULT_MAX_CONFIGURATIONS #: Integer
+
+      Configuration = Struct.new(
+        :states, #: Array[Integer]
+        :nodes, #: Array[derivation_node]
+        keyword_init: true
+      )
+
+      # @rbs @automaton: IR::Automaton
+      # @rbs @grammar: IR::Grammar
+      # @rbs @state: IR::AutomatonState
+      # @rbs @conflict: IR::conflict
+      # @rbs @lookahead: Integer?
+      # @rbs @max_tokens: Integer
+      # @rbs @max_configurations: Integer
+      # @rbs @explored: Integer
+      # @rbs @input_tokens: Array[Integer]
+
+      # @rbs (IR::Automaton automaton, IR::AutomatonState state, IR::conflict conflict,
+      #   ?max_tokens: Integer, ?max_configurations: Integer) -> void
+      def initialize(automaton, state, conflict, max_tokens: DEFAULT_MAX_TOKENS,
+                     max_configurations: DEFAULT_MAX_CONFIGURATIONS)
+        ConflictSearchLimits.validate!(max_tokens: max_tokens, max_configurations: max_configurations)
+        @automaton = automaton
+        @grammar = automaton.grammar
+        @state = state
+        @conflict = conflict
+        @lookahead = @grammar.symbol(conflict[:symbol])&.id
+        @max_tokens = max_tokens
+        @max_configurations = max_configurations
+        @explored = 0
+        @input_tokens = @grammar.terminals.reject(&:reserved).sort_by(&:name).map(&:id)
+      end
+
+      # @rbs () -> search_result?
+      def call
+        return unless @lookahead
+
+        queue = [[configuration([0], Array.new(0)), Array.new(0)]] #: Array[[Configuration, Array[Integer]]]
+        visited = { [0] => true }
+        until queue.empty? || exhausted?
+          current, prefix = queue.shift
+          conflict_configurations(current).each do |candidate|
+            result = unify_from(candidate, prefix)
+            return result if result
+          end
+          enqueue_prefixes(queue, visited, current, prefix)
+        end
+        nil
+      end
+
+      private
+
+      # @rbs (Configuration current) -> Array[Configuration]
+      def conflict_configurations(current)
+        advance(current, required_lookahead, stop_at: @state.id, branch_conflicts: true)
+          .filter_map { |status, candidate| candidate if status == :conflict }
+      end
+
+      # @rbs (Array[[Configuration, Array[Integer]]] queue, Hash[Array[Integer], bool] visited,
+      #   Configuration current, Array[Integer] prefix) -> void
+      def enqueue_prefixes(queue, visited, current, prefix)
+        return unless room_for_token?(prefix, [])
+
+        @input_tokens.each do |token_id|
+          advance(current, token_id, branch_conflicts: true).each do |status, candidate|
+            next unless status == :shifted
+            next if visited[candidate.states]
+
+            visited[candidate.states] = true
+            queue << [candidate, prefix + [token_id]]
+          end
+        end
+      end
+
+      # @rbs (Configuration current, Array[Integer] prefix) -> search_result?
+      def unify_from(current, prefix)
+        return unless within_token_budget?(prefix, [])
+
+        conflict_actions.combination(2) do |left_action, right_action|
+          next unless left_action && right_action
+
+          left_results = advance(current, required_lookahead, forced_action: left_action, branch_conflicts: true)
+          right_results = advance(current, required_lookahead, forced_action: right_action, branch_conflicts: true)
+          left_results.product(right_results).each do |left, right|
+            result = search_common_suffix(left, right, prefix, left_action, right_action)
+            return result if result
+          end
+        end
+        nil
+      end
+
+      # @rbs (search_entry left, search_entry right, Array[Integer] prefix, IR::parser_action left_action,
+      #   IR::parser_action right_action) -> search_result?
+      def search_common_suffix(left, right, prefix, left_action, right_action)
+        return accepted_result(prefix, [], left, right, left_action, right_action) if accepted_pair?(left, right)
+        return unless shifted_pair?(left, right)
+
+        queue = [[left.last, right.last, Array.new(0)]] #: Array[[Configuration, Configuration, Array[Integer]]]
+        visited = { pair_key(left.last, right.last) => true }
+        until queue.empty? || exhausted?
+          left_config, right_config, suffix = queue.shift
+          accepted = accept_with_eof(left_config, right_config)
+          return accepted_result(prefix, suffix, accepted[0], accepted[1], left_action, right_action) if accepted
+          next unless room_for_token?(prefix, suffix)
+
+          enqueue_suffixes(queue, visited, left_config, right_config, suffix)
+        end
+        nil
+      end
+
+      # @rbs (Configuration left_config, Configuration right_config) -> [search_entry, search_entry]?
+      def accept_with_eof(left_config, right_config)
+        left = advance(left_config, 0, branch_conflicts: true).select { |entry| entry.first == :accepted }
+        right = advance(right_config, 0, branch_conflicts: true).select { |entry| entry.first == :accepted }
+        left.product(right).first
+      end
+
+      # @rbs (Array[[Configuration, Configuration, Array[Integer]]] queue,
+      #   Hash[[Array[Integer], Array[Integer]], bool] visited, Configuration left_config,
+      #   Configuration right_config, Array[Integer] suffix) -> void
+      def enqueue_suffixes(queue, visited, left_config, right_config, suffix)
+        @input_tokens.each do |token_id|
+          left = shifted_results(left_config, token_id)
+          right = shifted_results(right_config, token_id)
+          left.product(right).each do |left_candidate, right_candidate|
+            key = pair_key(left_candidate, right_candidate)
+            next if visited[key]
+
+            visited[key] = true
+            queue << [left_candidate, right_candidate, suffix + [token_id]]
+          end
+        end
+      end
+
+      # @rbs (Configuration current, Integer token_id) -> Array[Configuration]
+      def shifted_results(current, token_id)
+        advance(current, token_id, branch_conflicts: true)
+          .filter_map { |status, candidate| candidate if status == :shifted }
+      end
+
+      # @rbs (Array[Integer] prefix, Array[Integer] suffix, search_entry left, search_entry right,
+      #   IR::parser_action left_action, IR::parser_action right_action) -> search_result?
+      def accepted_result(prefix, suffix, left, right, left_action, right_action)
+        return unless within_token_budget?(prefix, suffix)
+
+        sentence = prefix.dup
+        lookahead = required_lookahead
+        sentence << lookahead unless lookahead.zero?
+        sentence.concat(suffix)
+        { sentence_ids: sentence, lookahead_index: prefix.length,
+          interpretations: [interpretation(left_action, left.last), interpretation(right_action, right.last)] }
+      end
+
+      # @rbs (IR::parser_action action, Configuration current) -> IR::interpretation
+      def interpretation(action, current)
+        details = { kind: action[:type], tree: current.nodes.last } #: IR::interpretation
+        if action[:type] == :shift
+          shift_action = action #: IR::shift_action
+          details[:state] = shift_action[:state]
+        elsif action[:type] == :reduce
+          reduce_action = action #: IR::reduce_action
+          details[:production] = reduce_action[:production]
+        end
+        details
+      end
+
+      # @rbs (search_entry left, search_entry right) -> bool
+      def accepted_pair?(left, right)
+        left.first == :accepted && right.first == :accepted
+      end
+
+      # @rbs (search_entry left, search_entry right) -> bool
+      def shifted_pair?(left, right)
+        left.first == :shifted && right.first == :shifted
+      end
+
+      # @rbs () -> Array[IR::parser_action]
+      def conflict_actions
+        case @conflict[:type]
+        when :shift_reduce
+          conflict = @conflict #: IR::shift_reduce_conflict
+          shift = { type: :shift, state: conflict[:shift_to] } #: IR::shift_action
+          reduce = { type: :reduce, production: conflict[:reduce] } #: IR::reduce_action
+          [shift, reduce]
+        when :reduce_reduce
+          conflict = @conflict #: IR::reduce_reduce_conflict
+          conflict[:reductions].map do |production|
+            { type: :reduce, production: production } #: IR::reduce_action
+          end
+        else
+          []
+        end
+      end
+
+      # @rbs (Configuration initial, Integer token_id, ?forced_action: IR::parser_action?, ?stop_at: Integer?,
+      #   ?branch_conflicts: bool) -> Array[search_entry]
+      def advance(initial, token_id, forced_action: nil, stop_at: nil, branch_conflicts: false)
+        queue = [[initial, forced_action]] #: Array[[Configuration, IR::parser_action?]]
+        visited = {} #: Hash[[Array[Integer], bool], bool]
+        results = [] #: Array[search_entry]
+        until queue.empty? || exhausted?
+          current, forced = queue.shift
+          if stop_at == current.states.last
+            results << [:conflict, current]
+            next
+          end
+
+          key = [current.states, !forced.nil?] #: [Array[Integer], bool]
+          next if visited[key]
+
+          visited[key] = true
+          count_configuration
+          actions_for(current.states.last, token_id, forced, branch_conflicts).each do |action|
+            apply_action(results, queue, current, action, token_id)
+          end
+        end
+        results
+      end
+
+      # @rbs (Integer state_id, Integer token_id, IR::parser_action? forced, bool branch_conflicts) ->
+      #   Array[IR::parser_action]
+      def actions_for(state_id, token_id, forced, branch_conflicts)
+        return [forced] if forced
+
+        state = @automaton.states.fetch(state_id)
+        actions = [state.actions[token_id] || state.default_action].compact
+        return actions unless branch_conflicts
+
+        token_name = symbol_name(token_id)
+        state.conflicts.each do |conflict|
+          next unless conflict[:symbol] == token_name
+
+          actions.concat(actions_from(conflict))
+        end
+        actions.uniq
+      end
+
+      # @rbs (IR::conflict conflict) -> Array[IR::parser_action]
+      def actions_from(conflict)
+        case conflict[:type]
+        when :shift_reduce
+          shift_reduce = conflict #: IR::shift_reduce_conflict
+          shift = { type: :shift, state: shift_reduce[:shift_to] } #: IR::shift_action
+          reduce = { type: :reduce, production: shift_reduce[:reduce] } #: IR::reduce_action
+          [shift, reduce]
+        when :reduce_reduce
+          reduce_reduce = conflict #: IR::reduce_reduce_conflict
+          reduce_reduce[:reductions].map do |production|
+            { type: :reduce, production: production } #: IR::reduce_action
+          end
+        else
+          []
+        end
+      end
+
+      # @rbs (Array[search_entry] results, Array[[Configuration, IR::parser_action?]] queue,
+      #   Configuration current, IR::parser_action action, Integer token_id) -> void
+      def apply_action(results, queue, current, action, token_id)
+        case action[:type]
+        when :shift
+          shift_action = action #: IR::shift_action
+          results << [:shifted, shift(current, shift_action[:state], token_id)]
+        when :reduce
+          reduce_action = action #: IR::reduce_action
+          reduced = reduce(current, reduce_action[:production])
+          queue << [reduced, nil] if reduced
+        when :accept
+          results << [:accepted, current]
+        end
+      end
+
+      # @rbs (Configuration current, Integer state_id, Integer token_id) -> Configuration
+      def shift(current, state_id, token_id)
+        symbol = symbol_name(token_id)
+        configuration(current.states + [state_id], current.nodes + [{ symbol: symbol, token: symbol }])
+      end
+
+      # @rbs (Configuration current, Integer production_id) -> Configuration?
+      def reduce(current, production_id)
+        production = @grammar.productions.fetch(production_id)
+        length = production.rhs.length
+        return if length >= current.states.length
+
+        states = current.states.take(current.states.length - length)
+        children = current.nodes.last(length)
+        nodes = current.nodes.take(current.nodes.length - length)
+        target = @automaton.states.fetch(states.last).gotos[production.lhs]
+        return unless target
+
+        symbol = symbol_name(production.lhs)
+        configuration(states + [target], nodes + [{ symbol: symbol, production: production_id, children: children }])
+      end
+
+      # @rbs (Array[Integer] states, Array[derivation_node] nodes) -> Configuration
+      def configuration(states, nodes) = Configuration.new(states: states.freeze, nodes: nodes.freeze)
+
+      # @rbs () -> Integer
+      def required_lookahead
+        @lookahead || raise(Ibex::Error, "missing conflict lookahead")
+      end
+
+      # @rbs (Integer id) -> String
+      def symbol_name(id)
+        symbol = @grammar.symbol_by_id(id) || raise(Ibex::Error, "missing grammar symbol id #{id}")
+        symbol.name
+      end
+
+      # @rbs (Configuration left, Configuration right) -> [Array[Integer], Array[Integer]]
+      def pair_key(left, right)
+        [left.states, right.states]
+      end
+
+      # @rbs () -> Integer
+      def count_configuration = (@explored += 1)
+
+      # @rbs () -> bool
+      def exhausted? = @explored >= @max_configurations
+    end
+    # rubocop:enable Metrics/ClassLength
+  end
+end

data/lib/ibex/lalr/conflict_search_limits.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Ibex
+  module LALR
+    # Validates search limits and measures sentences against the token budget.
+    module ConflictSearchLimits
+      DEFAULT_MAX_TOKENS = 32 #: Integer
+      DEFAULT_MAX_CONFIGURATIONS = 50_000 #: Integer
+
+      # @rbs (max_tokens: Integer, max_configurations: Integer) -> void
+      def self.validate!(max_tokens:, max_configurations:)
+        validate_limit!(:max_tokens, max_tokens)
+        validate_limit!(:max_configurations, max_configurations)
+      end
+
+      # @rbs (Symbol name, Integer value) -> Integer
+      def self.validate_limit!(name, value)
+        return value if value.is_a?(Integer) && value.positive?
+
+        raise ArgumentError, "#{name} must be a positive Integer"
+      end
+
+      private
+
+      # @rbs (Array[Integer] prefix, Array[Integer] suffix) -> bool
+      def within_token_budget?(prefix, suffix)
+        prefix.length + suffix.length + conflict_lookahead_length <= @max_tokens
+      end
+
+      # @rbs (Array[Integer] prefix, Array[Integer] suffix) -> bool
+      def room_for_token?(prefix, suffix)
+        prefix.length + suffix.length + conflict_lookahead_length < @max_tokens
+      end
+
+      # @rbs () -> Integer
+      def conflict_lookahead_length = @lookahead.zero? ? 0 : 1
+    end
+  end
+end

data/lib/ibex/lalr/counterexample.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module Ibex
+  module LALR
+    # Produces shortest-path conflict witnesses using Automaton IR only.
+    class Counterexample
+      DEFAULT_MAX_TOKENS = ConflictSearch::DEFAULT_MAX_TOKENS #: Integer
+      DEFAULT_MAX_CONFIGURATIONS = ConflictSearch::DEFAULT_MAX_CONFIGURATIONS #: Integer
+
+      # @rbs (IR::Automaton automaton, ?max_tokens: Integer, ?max_configurations: Integer) -> void
+      def initialize(automaton, max_tokens: DEFAULT_MAX_TOKENS, max_configurations: DEFAULT_MAX_CONFIGURATIONS)
+        ConflictSearchLimits.validate!(max_tokens: max_tokens, max_configurations: max_configurations)
+        @automaton = automaton
+        @grammar = automaton.grammar
+        @max_tokens = max_tokens
+        @max_configurations = max_configurations
+        @shortest_yields = compute_shortest_yields
+      end
+
+      # @rbs () -> Array[IR::counterexample]
+      def all
+        @automaton.states.flat_map do |state|
+          state.conflicts.map { |conflict| build_example(state, conflict) }
+        end
+      end
+
+      private
+
+      # @rbs (IR::AutomatonState state, IR::conflict conflict) -> IR::counterexample
+      def build_example(state, conflict)
+        unifying = ConflictSearch.new(
+          @automaton, state, conflict, max_tokens: @max_tokens, max_configurations: @max_configurations
+        ).call
+        return unifying_example(state, conflict, unifying) if unifying
+
+        reachability_example(state, conflict)
+      end
+
+      # @rbs (IR::AutomatonState state, IR::conflict conflict, Hash[Symbol, untyped] result) -> IR::counterexample
+      def unifying_example(state, conflict, result)
+        { state: state.id, type: conflict[:type], symbol_path: Array.new(0),
+          sentence: names(result[:sentence_ids]), lookahead_index: result[:lookahead_index], unifying: true,
+          interpretations: result[:interpretations] }
+      end
+
+      # @rbs (IR::AutomatonState state, IR::conflict conflict) -> IR::counterexample
+      def reachability_example(state, conflict)
+        path = shortest_state_path(state.id)
+        lookahead = @grammar.symbol(conflict[:symbol])
+        terminal_ids = path.flat_map { |symbol_id| @shortest_yields[symbol_id] || [] }
+        terminal_ids << lookahead.id if lookahead
+        { state: state.id, type: conflict[:type], symbol_path: names(path), sentence: names(terminal_ids),
+          lookahead_index: terminal_ids.length - 1, unifying: false, interpretations: interpretations(conflict) }
+      end
+
+      # @rbs (Integer target) -> Array[Integer]
+      def shortest_state_path(target)
+        queue = [[0, Array.new(0)]] #: Array[[Integer, Array[Integer]]]
+        visited = { 0 => true }
+        until queue.empty?
+          state_id, path = queue.shift
+          return path if state_id == target
+
+          @automaton.states.fetch(state_id).transitions.sort.each do |symbol_id, next_state|
+            next if visited[next_state]
+
+            visited[next_state] = true
+            queue << [next_state, path + [symbol_id]]
+          end
+        end
+        []
+      end
+
+      # @rbs () -> Hash[Integer, Array[Integer]]
+      def compute_shortest_yields
+        yields = @grammar.terminals.to_h { |terminal| [terminal.id, [terminal.id]] }
+        loop do
+          changed = false
+          @grammar.productions.each do |production|
+            candidate = production.rhs.flat_map { |id| yields[id] || [] }
+            next unless production.rhs.all? { |id| yields.key?(id) }
+            next unless better_yield?(candidate, yields[production.lhs])
+
+            yields[production.lhs] = candidate
+            changed = true
+          end
+          return yields unless changed
+        end
+      end
+
+      # @rbs (Array[Integer] candidate, Array[Integer]? current) -> bool
+      def better_yield?(candidate, current)
+        return true unless current
+        return candidate.length < current.length if candidate.length != current.length
+
+        comparison = names(candidate) <=> names(current)
+        comparison ? comparison.negative? : false
+      end
+
+      # @rbs (IR::conflict conflict) -> Array[IR::interpretation]
+      def interpretations(conflict)
+        case conflict[:type]
+        when :shift_reduce
+          shift_reduce = conflict #: IR::shift_reduce_conflict
+          [shift_interpretation(shift_reduce), reduce_interpretation(shift_reduce[:reduce])]
+        when :reduce_reduce
+          reduce_reduce = conflict #: IR::reduce_reduce_conflict
+          reduce_reduce[:reductions].map { |production_id| reduce_interpretation(production_id) }
+        else []
+        end
+      end
+
+      # @rbs (IR::shift_reduce_conflict conflict) -> IR::interpretation
+      def shift_interpretation(conflict)
+        { kind: :shift, state: conflict[:shift_to], tree: { token: conflict[:symbol] } }
+      end
+
+      # @rbs (Integer production_id) -> IR::interpretation
+      def reduce_interpretation(production_id)
+        production = @grammar.productions.fetch(production_id)
+        lhs = symbol_name(production.lhs)
+        rhs = names(production.rhs)
+        { kind: :reduce, production: production_id, tree: { symbol: lhs, children: rhs } }
+      end
+
+      # @rbs (Array[Integer] symbol_ids) -> Array[String]
+      def names(symbol_ids)
+        symbol_ids.map { |id| symbol_name(id) }
+      end
+
+      # @rbs (Integer id) -> String
+      def symbol_name(id)
+        symbol = @grammar.symbol_by_id(id) || raise(Ibex::Error, "missing grammar symbol id #{id}")
+        symbol.name
+      end
+    end
+  end
+end