ibex 0.1.0 → 0.2.0

data/lib/ibex/lalr/builder.rb

@@ -4,37 +4,85 @@ require "set"
 
 module Ibex
   module LALR
-    # Builds canonical LR(1) states and merges states with equal LR(0) cores.
+    # Builds deterministic SLR, direct LALR(1), or canonical LR(1) automata.
+    # rubocop:disable Metrics/ClassLength -- collection strategies share one action/conflict construction path.
     class Builder
       AUGMENTED_PRODUCTION = -1 #: Integer
 
-      ALGORITHMS = %i[slr lalr lr1].freeze #: Array[Symbol]
+      ALGORITHMS = %i[slr lalr ielr lr1].freeze #: Array[Symbol]
+      LALR_STRATEGIES = %i[direct canonical_merge].freeze #: Array[Symbol]
 
       # @rbs @grammar: IR::Grammar
       # @rbs @algorithm: Symbol
+      # @rbs @lalr_strategy: Symbol
       # @rbs @sets: Analysis::Sets
       # @rbs @productions_by_lhs: Hash[Integer, Array[IR::Production]]
       # @rbs @resolver: ConflictResolver
-
-      # @rbs (IR::Grammar grammar, ?algorithm: Symbol | String) -> void
-      def initialize(grammar, algorithm: :lalr)
+      # @rbs @metrics: BuildMetrics?
+      # @rbs @start_names: Array[String]
+      # @rbs @entry_isolation: bool
+      # @rbs @attribute_entries: bool
+      # @rbs @canonical_suffix_lookahead_cache: Hash[Integer, Hash[Integer, Hash[Integer, Array[Integer]]]]
+      # @rbs @canonical_item_cache: Hash[Integer, Array[Array[lr_item?]?]]?
+      # @rbs @canonical_key_radices: [Integer, Integer, Integer]?
+
+      attr_reader :metrics #: BuildMetrics?
+
+      # @rbs (IR::Grammar grammar, ?algorithm: Symbol | String, ?lalr_strategy: Symbol | String,
+      #   ?entry_isolation: bool, ?starts: Array[String]?, ?attribute_entries: bool) -> void
+      def initialize(grammar, algorithm: :lalr, lalr_strategy: :direct, entry_isolation: false,
+                     starts: nil, attribute_entries: true)
         unless ALGORITHMS.include?(algorithm.to_sym)
           raise ArgumentError, "unknown parser algorithm #{algorithm.inspect}"
         end
+        unless LALR_STRATEGIES.include?(lalr_strategy.to_sym)
+          raise ArgumentError, "unknown LALR construction strategy #{lalr_strategy.inspect}"
+        end
 
         @grammar = grammar
         @algorithm = algorithm.to_sym
+        @lalr_strategy = lalr_strategy.to_sym
         @sets = Analysis::Sets.new(grammar)
         @productions_by_lhs = grammar.productions.group_by(&:lhs)
         @resolver = ConflictResolver.new(grammar)
+        @metrics = nil
+        @canonical_suffix_lookahead_cache = {}
+        @canonical_item_cache = nil
+        @canonical_key_radices = nil
+        @start_names = starts || grammar.starts
+        if @start_names.empty? || (@start_names - grammar.starts).any?
+          raise ArgumentError, "starts must be a nonempty subset of grammar starts"
+        end
+
+        @entry_isolation = entry_isolation
+        @attribute_entries = attribute_entries
       end
 
       # @rbs () -> IR::Automaton
       def build
-        canonical_states, canonical_transitions = canonical_collection
-        merged_items, merged_transitions = automaton_items(canonical_states, canonical_transitions)
+        return build_isolated_automaton if @entry_isolation && @start_names.length > 1
+
+        merged_items, merged_transitions, construction_states, canonical_states, strategy = automaton_collection
         states = build_states(merged_items, merged_transitions)
+        states = OnErrorReductions.apply(@grammar, states)
         states = DefaultReductions.apply(states, terminal_ids: @grammar.terminals.map(&:id))
+        entry_states = entry_states_for(merged_items)
+        states = attribute_entry_conflicts(states, entry_states) if @attribute_entries && @start_names.length > 1
+        summary = conflict_summary(states)
+        @metrics = BuildMetrics.new(
+          construction_states: construction_states,
+          canonical_states: canonical_states,
+          final_states: states.length,
+          strategy: strategy
+        )
+        IR::Automaton.new(grammar: @grammar, states: states, conflict_summary: summary,
+                          algorithm: algorithm_name, entry_states: entry_states)
+      end
+
+      private
+
+      # @rbs (Array[IR::AutomatonState] states) -> IR::conflict_summary
+      def conflict_summary(states)
         conflicts = states.flat_map(&:conflicts)
         shift_reduce = conflicts.select { |item| item[:type] == :shift_reduce }
         counted_shift_reduce = shift_reduce.count { |item| item.dig(:resolution, :by) == :default_shift }
@@ -43,23 +91,69 @@ module Ibex
                     rr: conflicts.count { |item| item[:type] == :reduce_reduce },
                     expected_sr: @grammar.expect,
                     expectation_met: counted_shift_reduce == @grammar.expect } #: IR::conflict_summary
-        IR::Automaton.new(grammar: @grammar, states: states, conflict_summary: summary,
-                          algorithm: @algorithm == :lalr ? "lalr1" : @algorithm.to_s)
+        expected_rr = @grammar.expect_rr
+        if expected_rr
+          summary[:expected_rr] = expected_rr
+          summary[:rr_expectation_met] = summary[:rr] == expected_rr
+        end
+        summary
       end
 
-      private
+      # @rbs () -> [Array[packed_items], transitions, Integer, Integer?, Symbol]
+      def automaton_collection
+        if @algorithm == :ielr
+          states, transitions = canonical_collection
+          items, merged_transitions = IELRPartition.new(@grammar, states, transitions).build
+          return [items, merged_transitions, states.length, states.length, :ielr_partition]
+        end
+
+        if @algorithm == :lr1
+          states, transitions = canonical_collection
+          return [pack_canonical_items(states), transitions, states.length, states.length, :canonical_lr1]
+        end
+
+        if @lalr_strategy == :canonical_merge
+          states, transitions = canonical_collection
+          items, merged_transitions = merge_lalr(states, transitions)
+          apply_slr_lookaheads(items) if @algorithm == :slr
+          return [items, merged_transitions, states.length, states.length, :canonical_merge]
+        end
+
+        if @grammar.starts.length > 1
+          states, transitions = canonical_collection
+          items, merged_transitions = merge_lalr(states, transitions)
+          apply_slr_lookaheads(items) if @algorithm == :slr
+          return [items, merged_transitions, states.length, states.length, :canonical_merge_multi_entry]
+        end
+
+        items, transitions = DirectLookaheads.new(@grammar, @sets).build
+        apply_slr_lookaheads(items) if @algorithm == :slr
+        collection = [items, transitions, items.length, nil, :direct_lalr]
+        collection #: [Array[packed_items], transitions, Integer, Integer?, Symbol]
+      ensure
+        @canonical_item_cache = nil
+      end
+
+      # @rbs () -> String
+      def algorithm_name
+        { lalr: "lalr1", ielr: "ielr1" }.fetch(@algorithm, @algorithm.to_s)
+      end
 
       # @rbs () -> [Array[item_set], transitions]
       def canonical_collection
-        seed = Set[[AUGMENTED_PRODUCTION, 0, 0]] #: item_set
-        states = [closure(seed)]
+        states = @start_names.map do |name|
+          seed = Set[canonical_item(augmented_production(name), 0, 0)] #: item_set
+          closure(seed)
+        end
         transitions = [] #: transitions
-        indexes = { item_key(states.first) => 0 }
+        indexes = {} #: Hash[Array[Integer], Integer]
+        states.each_with_index { |items, index| indexes[item_key(items)] = index }
         cursor = 0
         while cursor < states.length
           transitions[cursor] = {}
-          next_symbols(states[cursor]).each do |symbol_id|
-            target = go_to(states[cursor], symbol_id)
+          kernels = shifted_kernels(states[cursor])
+          kernels.keys.sort.each do |symbol_id|
+            target = closure(kernels.fetch(symbol_id))
             key = item_key(target)
             target_id = indexes[key] ||= begin
               states << target
@@ -74,18 +168,27 @@ module Ibex
 
       # @rbs (item_set seed) -> item_set
       def closure(seed)
+        cache = (@canonical_item_cache ||= {}) #: Hash[Integer, Array[Array[lr_item?]?]]
         items = seed.dup
         queue = seed.to_a
-        until queue.empty?
-          production_id, dot, lookahead = queue.shift
+        cursor = 0
+        while cursor < queue.length
+          production_id, dot, lookahead = queue.fetch(cursor)
+          cursor += 1
           rhs = rhs_for(production_id)
           grammar_symbol = @grammar.symbol_by_id(rhs[dot])
           next unless grammar_symbol&.nonterminal?
 
-          lookaheads = suffix_lookaheads(rhs.drop(dot + 1), lookahead)
+          lookaheads = canonical_suffix_lookaheads(production_id, dot, lookahead)
           @productions_by_lhs.fetch(grammar_symbol.id, Array.new(0)).each do |production|
+            production_cache = (cache[production.id] ||= []) #: Array[Array[lr_item?]?]
+            item_cache = (production_cache[0] ||= []) #: Array[lr_item?]
             lookaheads.each do |token_id|
-              item = [production.id, 0, token_id] #: lr_item
+              item = item_cache[token_id]
+              unless item
+                item = [production.id, 0, token_id].freeze #: lr_item
+                item_cache[token_id] = item
+              end
               enqueue_item(items, queue, item)
             end
           end
@@ -100,32 +203,57 @@ module Ibex
         @grammar.terminals.filter_map { |terminal| terminal.id if bits.anybits?(1 << terminal.id) }
       end
 
-      # @rbs (item_set items, Array[lr_item] queue, lr_item item) -> void
-      def enqueue_item(items, queue, item)
-        return if items.include?(item)
+      # @rbs (Integer production_id, Integer dot, Integer inherited) -> Array[Integer]
+      def canonical_suffix_lookaheads(production_id, dot, inherited)
+        production_cache = (@canonical_suffix_lookahead_cache[production_id] ||= {})
+        inherited_cache = (production_cache[dot] ||= {})
+        return inherited_cache.fetch(inherited) if inherited_cache.key?(inherited)
 
-        items << item
-        queue << item
+        suffix = rhs_for(production_id).drop(dot + 1)
+        inherited_cache[inherited] = suffix_lookaheads(suffix, inherited).freeze
       end
 
-      # @rbs (item_set items) -> Array[Integer]
-      def next_symbols(items)
-        items.filter_map { |production_id, dot, _lookahead| rhs_for(production_id)[dot] }.uniq.sort
+      # @rbs (Integer production_id, Integer dot, Integer lookahead) -> lr_item
+      def canonical_item(production_id, dot, lookahead)
+        cache = (@canonical_item_cache ||= {}) #: Hash[Integer, Array[Array[lr_item?]?]]
+        production_cache = (cache[production_id] ||= []) #: Array[Array[lr_item?]?]
+        dot_cache = (production_cache[dot] ||= []) #: Array[lr_item?]
+        cached = dot_cache[lookahead]
+        return cached if cached
+
+        item = [production_id, dot, lookahead].freeze #: lr_item
+        dot_cache[lookahead] = item
       end
 
-      # @rbs (item_set items, Integer symbol_id) -> item_set
-      def go_to(items, symbol_id)
-        moved = items.filter_map do |production_id, dot, lookahead|
-          next unless rhs_for(production_id)[dot] == symbol_id
+      # @rbs (item_set items, Array[lr_item] queue, lr_item item) -> void
+      def enqueue_item(items, queue, item)
+        queue << item if items.add?(item)
+      end
 
-          [production_id, dot + 1, lookahead] #: lr_item
+      # @rbs (item_set items) -> Hash[Integer, item_set]
+      def shifted_kernels(items)
+        cache = (@canonical_item_cache ||= {}) #: Hash[Integer, Array[Array[lr_item?]?]]
+        kernels = {} #: Hash[Integer, item_set]
+        items.each do |production_id, dot, lookahead|
+          symbol_id = rhs_for(production_id)[dot]
+          next unless symbol_id
+
+          production_cache = (cache[production_id] ||= []) #: Array[Array[lr_item?]?]
+          shifted_dot = dot + 1
+          item_cache = (production_cache[shifted_dot] ||= []) #: Array[lr_item?]
+          item = item_cache[lookahead]
+          unless item
+            item = [production_id, shifted_dot, lookahead].freeze #: lr_item
+            item_cache[lookahead] = item
+          end
+          (kernels[symbol_id] ||= Set.new) << item
         end
-        closure(Set.new(moved))
+        kernels
       end
 
       # @rbs (Array[item_set] states, transitions transitions) -> [Array[packed_items], transitions]
       def merge_lalr(states, transitions)
-        groups = {} #: Hash[Array[item_core], Integer]
+        groups = {} #: Hash[Array[Integer], Integer]
         state_groups = states.map do |items|
           core = core_key(items)
           groups[core] ||= groups.length
@@ -145,15 +273,6 @@ module Ibex
         [merged, merged_transitions]
       end
 
-      # @rbs (Array[item_set] canonical_states, transitions canonical_transitions) -> [Array[packed_items], transitions]
-      def automaton_items(canonical_states, canonical_transitions)
-        return [pack_canonical_items(canonical_states), canonical_transitions] if @algorithm == :lr1
-
-        items, transitions = merge_lalr(canonical_states, canonical_transitions)
-        apply_slr_lookaheads(items) if @algorithm == :slr
-        [items, transitions]
-      end
-
       # @rbs (Array[item_set] states) -> Array[packed_items]
       def pack_canonical_items(states)
         states.map do |items|
@@ -176,7 +295,7 @@ module Ibex
 
       # @rbs (Integer production_id) -> Array[Integer]
       def slr_lookaheads(production_id)
-        return [0] if production_id == AUGMENTED_PRODUCTION
+        return [0] if production_id.negative?
 
         lhs = @grammar.productions.fetch(production_id).lhs
         bits = @sets.follow_bits.fetch(lhs)
@@ -187,7 +306,8 @@ module Ibex
       def build_states(merged_items, transitions)
         merged_items.each_with_index.map do |item_map, state_id|
           items = item_map.sort.map do |(production, dot), lookaheads|
-            IR::AutomatonItem.new(production: production, dot: dot, lookaheads: lookaheads.to_a)
+            visible_production = production.negative? ? AUGMENTED_PRODUCTION : production
+            IR::AutomatonItem.new(production: visible_production, dot: dot, lookaheads: lookaheads.to_a)
           end
           build_state(state_id, items, transitions[state_id])
         end
@@ -209,17 +329,36 @@ module Ibex
         end
         add_completed_actions(items, candidates)
         actions, conflicts = resolve_actions(candidates)
+        conflicts = conflicts.map { |conflict| attribute_midrule_conflict(conflict) }
         IR::AutomatonState.new(id: state_id, items: items, transitions: transitions, actions: actions,
                                gotos: gotos, conflicts: conflicts)
       end
 
+      # Conflict hashes are produced locally immediately before this boundary.
+      # Keeping the parameter untyped avoids duplicating both discriminated
+      # hash variants solely to add their common optional provenance field.
+      # @rbs (untyped conflict) -> IR::conflict
+      def attribute_midrule_conflict(conflict)
+        production_ids = if conflict[:type] == :shift_reduce
+                           [conflict[:reduce]]
+                         else
+                           conflict[:reductions]
+                         end
+        origins = production_ids.filter_map do |production_id|
+          production = @grammar.productions.fetch(production_id)
+          production.origin[:loc] if production.origin[:kind] == :inline_action
+        end
+        conflict[:midrule_origins] = origins.uniq unless origins.empty?
+        conflict
+      end
+
       # @rbs (Array[IR::AutomatonItem] items, Hash[Integer, Array[IR::parser_action]] candidates) -> void
       def add_completed_actions(items, candidates)
         items.each do |item|
           next unless item.dot == rhs_for(item.production).length
 
           item.lookaheads.each do |lookahead|
-            action = if item.production == AUGMENTED_PRODUCTION
+            action = if item.production.negative?
                        { type: :accept } #: IR::accept_action
                      else
                        { type: :reduce, production: item.production } #: IR::reduce_action
@@ -246,25 +385,213 @@ module Ibex
 
       # @rbs (Integer production_id) -> Array[Integer]
       def rhs_for(production_id)
-        if production_id == AUGMENTED_PRODUCTION
-          start = @grammar.symbol(@grammar.start) || raise(Ibex::Error, "missing start symbol")
+        if production_id.negative?
+          name = start_name_for_augmented(production_id)
+          start = @grammar.symbol(name) || raise(Ibex::Error, "missing start symbol #{name}")
           return [start.id]
         end
 
         @grammar.productions.fetch(production_id).rhs
       end
 
-      # @rbs (item_set items) -> Array[item_core]
+      # @rbs () -> [Integer, Integer, Integer]
+      def canonical_key_radices
+        cached = @canonical_key_radices
+        return cached if cached
+
+        longest_rhs = @grammar.productions.map { |production| production.rhs.length }.max || 0
+        highest_terminal_id = @grammar.terminals.map(&:id).max || 0
+        radices = [
+          @grammar.starts.length,
+          [longest_rhs, 1].max + 1,
+          highest_terminal_id + 1
+        ] #: [Integer, Integer, Integer]
+        @canonical_key_radices = radices.freeze
+      end
+
+      # @rbs (item_set items) -> Array[Integer]
       def core_key(items)
+        production_offset, dot_radix, = canonical_key_radices
         items.map do |production, dot, _lookahead|
-          [production, dot] #: item_core
+          ((production + production_offset) * dot_radix) + dot
         end.uniq.sort
       end
 
-      # @rbs (item_set items) -> Array[lr_item]
+      # @rbs (item_set items) -> Array[Integer]
       def item_key(items)
-        items.to_a.sort
+        production_offset, dot_radix, lookahead_radix = canonical_key_radices
+        items.map do |production, dot, lookahead|
+          core = ((production + production_offset) * dot_radix) + dot
+          (core * lookahead_radix) + lookahead
+        end.sort
+      end
+
+      # @rbs (String name) -> Integer
+      def augmented_production(name)
+        index = @grammar.starts.index(name)
+        raise Ibex::Error, "missing start symbol #{name}" unless index
+
+        AUGMENTED_PRODUCTION - index
+      end
+
+      # @rbs (Integer production_id) -> String
+      def start_name_for_augmented(production_id)
+        @grammar.starts.fetch(-production_id - 1)
+      end
+
+      # @rbs (Array[packed_items] items) -> Hash[String, Integer]
+      def entry_states_for(items)
+        @start_names.to_h do |name|
+          production = augmented_production(name)
+          state = items.index { |item_map| item_map.key?([production, 0]) }
+          raise Ibex::Error, "missing initial state for start symbol #{name}" unless state
+
+          [name, state]
+        end
+      end
+
+      # @rbs () -> IR::Automaton
+      def build_isolated_automaton
+        entries = @start_names.map { |name| isolated_entry(name) }
+        states = [] #: Array[IR::AutomatonState]
+        entry_states = {} #: Hash[String, Integer]
+        construction_states = 0
+        canonical_counts = [] #: Array[Integer?]
+        entries.each do |name, automaton, metrics|
+          offset = states.length
+          entry_states[name] = offset + automaton.entry_states.fetch(name)
+          states.concat(automaton.states.map { |state| offset_state(state, offset, name) })
+          construction_states += metrics.construction_states
+          canonical_counts << metrics.canonical_states
+        end
+        canonical_states = canonical_counts.compact.sum if canonical_counts.none?(&:nil?)
+        @metrics = BuildMetrics.new(
+          construction_states: construction_states,
+          canonical_states: canonical_states,
+          final_states: states.length,
+          strategy: :entry_isolation
+        )
+        IR::Automaton.new(
+          grammar: @grammar, states: states, conflict_summary: conflict_summary(states),
+          algorithm: algorithm_name, entry_states: entry_states
+        )
+      end
+
+      # @rbs (String name) -> [String, IR::Automaton, BuildMetrics]
+      def isolated_entry(name)
+        builder = self.class.new(
+          @grammar, algorithm: @algorithm, lalr_strategy: @lalr_strategy,
+                    starts: [name], attribute_entries: false
+        )
+        automaton = builder.build
+        metrics = builder.metrics
+        raise Ibex::Error, "missing build metrics for start symbol #{name}" unless metrics
+
+        [name, automaton, metrics]
+      end
+
+      # @rbs (IR::AutomatonState state, Integer offset, String entry) -> IR::AutomatonState
+      def offset_state(state, offset, entry)
+        actions = state.actions.transform_values { |action| offset_action(action, offset) }
+        conflicts = state.conflicts.map { |conflict| offset_conflict(conflict, offset, entry) }
+        IR::AutomatonState.new(
+          id: state.id + offset, items: state.items,
+          transitions: state.transitions.transform_values { |target| target + offset },
+          actions: actions, gotos: state.gotos.transform_values { |target| target + offset },
+          default_action: offset_default_action(state.default_action, offset), conflicts: conflicts
+        )
+      end
+
+      # @rbs (IR::parser_action action, Integer offset) -> IR::parser_action
+      def offset_action(action, offset)
+        return action unless action[:type] == :shift
+
+        shift = action #: IR::shift_action
+        { type: :shift, state: shift[:state] + offset }
+      end
+
+      # @rbs (IR::parser_action? action, Integer offset) -> IR::parser_action?
+      def offset_default_action(action, offset)
+        action && offset_action(action, offset)
+      end
+
+      # @rbs (IR::conflict conflict, Integer offset, String entry) -> IR::conflict
+      def offset_conflict(conflict, offset, entry)
+        if conflict[:type] == :shift_reduce
+          shift_reduce = conflict #: IR::shift_reduce_conflict
+          shifted = shift_reduce.dup #: IR::shift_reduce_conflict
+          shifted[:shift_to] = shift_reduce[:shift_to] + offset
+          shifted[:entries] = [entry]
+          return shifted
+        end
+
+        reduce_reduce = conflict #: IR::reduce_reduce_conflict
+        shifted = reduce_reduce.dup #: IR::reduce_reduce_conflict
+        shifted[:entries] = [entry]
+        shifted
+      end
+
+      # @rbs (Array[IR::AutomatonState] states, Hash[String, Integer] entry_states) ->
+      #   Array[IR::AutomatonState]
+      def attribute_entry_conflicts(states, entry_states)
+        reachability = entry_reachability(states, entry_states)
+        isolated = isolated_conflict_fingerprints
+        states.map do |state|
+          conflicts = state.conflicts.map do |conflict| # @type var conflict: IR::conflict
+            entries = @start_names.select { |name| reachability.fetch(state.id).include?(name) }
+            attributed = conflict.dup #: IR::conflict
+            attributed[:entries] = entries
+            attributed[:composite] = true unless isolated.include?(conflict_fingerprint(conflict))
+            attributed
+          end #: Array[IR::conflict]
+          IR::AutomatonState.new(
+            id: state.id, items: state.items, transitions: state.transitions, actions: state.actions,
+            gotos: state.gotos, default_action: state.default_action, conflicts: conflicts
+          )
+        end
+      end
+
+      # @rbs (Array[IR::AutomatonState] states, Hash[String, Integer] entry_states) -> Array[Array[String]]
+      def entry_reachability(states, entry_states)
+        reachable = Array.new(states.length) { [] } #: Array[Array[String]]
+        entry_states.each do |name, initial|
+          queue = [initial]
+          visited = {} #: Hash[Integer, bool]
+          until queue.empty?
+            state_id = queue.shift
+            next if visited[state_id]
+
+            visited[state_id] = true
+            reachable.fetch(state_id) << name
+            states.fetch(state_id).transitions.each_value { |target| queue << target }
+          end
+        end
+        reachable
+      end
+
+      # @rbs () -> Set[Array[untyped]]
+      def isolated_conflict_fingerprints
+        @start_names.each_with_object(Set.new) do |name, fingerprints|
+          isolated = self.class.new(
+            @grammar, algorithm: @algorithm, lalr_strategy: @lalr_strategy,
+                      starts: [name], attribute_entries: false
+          ).build
+          isolated.states.each do |state|
+            state.conflicts.each { |conflict| fingerprints << conflict_fingerprint(conflict) }
+          end
+        end
+      end
+
+      # @rbs (IR::conflict conflict) -> Array[untyped]
+      def conflict_fingerprint(conflict)
+        reductions = if conflict[:type] == :shift_reduce
+                       [conflict[:reduce]]
+                     else
+                       conflict[:reductions]
+                     end
+        [conflict[:type], conflict[:symbol], reductions]
       end
     end
+    # rubocop:enable Metrics/ClassLength
   end
 end

data/lib/ibex/lalr/conflict.rb

@@ -90,6 +90,7 @@ module Ibex
         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 }]
+        when :precedence then [shift, { by: :default_shift, chose: :shift }]
         else raise Ibex::Error, "unknown associativity #{associativity.inspect}"
         end
       end

data/lib/ibex/lalr/conflict_search.rb

@@ -25,6 +25,9 @@ module Ibex
       # @rbs @max_configurations: Integer
       # @rbs @explored: Integer
       # @rbs @input_tokens: Array[Integer]
+      # @rbs @initial_state: Integer
+
+      attr_reader :explored #: Integer
 
       # @rbs (IR::Automaton automaton, IR::AutomatonState state, IR::conflict conflict,
       #   ?max_tokens: Integer, ?max_configurations: Integer) -> void
@@ -40,14 +43,17 @@ module Ibex
         @max_configurations = max_configurations
         @explored = 0
         @input_tokens = @grammar.terminals.reject(&:reserved).sort_by(&:name).map(&:id)
+        entry = conflict[:entries]&.first || @grammar.start
+        @initial_state = automaton.entry_states.fetch(entry)
       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 }
+        initial = configuration([@initial_state], Array.new(0))
+        queue = [[initial, Array.new(0)]] #: Array[[Configuration, Array[Integer]]]
+        visited = { [@initial_state] => true }
         until queue.empty? || exhausted?
           current, prefix = queue.shift
           conflict_configurations(current).each do |candidate|
@@ -59,6 +65,9 @@ module Ibex
         nil
       end
 
+      # @rbs () -> bool
+      def exhausted? = @explored >= @max_configurations
+
       private
 
       # @rbs (Configuration current) -> Array[Configuration]
@@ -323,9 +332,6 @@ module Ibex
 
       # @rbs () -> Integer
       def count_configuration = (@explored += 1)
-
-      # @rbs () -> bool
-      def exhausted? = @explored >= @max_configurations
     end
     # rubocop:enable Metrics/ClassLength
   end

data/lib/ibex/lalr/counterexample.rb

@@ -24,6 +24,19 @@ module Ibex
         end
       end
 
+      # @rbs (Integer state_id, Integer conflict_index) -> IR::counterexample
+      def for_conflict(state_id, conflict_index)
+        state = @automaton.states.find { |candidate| candidate.id == state_id }
+        raise ArgumentError, "unknown automaton state #{state_id}" unless state
+
+        unless conflict_index.is_a?(Integer) && conflict_index >= 0 && conflict_index < state.conflicts.length
+          raise ArgumentError, "conflict index #{conflict_index.inspect} is invalid for automaton state #{state_id}"
+        end
+
+        conflict = state.conflicts.fetch(conflict_index)
+        build_example(state, conflict)
+      end
+
       private
 
       # @rbs (IR::AutomatonState state, IR::conflict conflict) -> IR::counterexample
@@ -45,7 +58,7 @@ module Ibex
 
       # @rbs (IR::AutomatonState state, IR::conflict conflict) -> IR::counterexample
       def reachability_example(state, conflict)
-        path = shortest_state_path(state.id)
+        path = shortest_state_path(state.id, conflict)
         lookahead = @grammar.symbol(conflict[:symbol])
         terminal_ids = path.flat_map { |symbol_id| @shortest_yields[symbol_id] || [] }
         terminal_ids << lookahead.id if lookahead
@@ -53,10 +66,12 @@ module Ibex
           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 }
+      # @rbs (Integer target, IR::conflict conflict) -> Array[Integer]
+      def shortest_state_path(target, conflict)
+        entry = conflict[:entries]&.first || @grammar.start
+        initial = @automaton.entry_states.fetch(entry)
+        queue = [[initial, Array.new(0)]] #: Array[[Integer, Array[Integer]]]
+        visited = { initial => true }
         until queue.empty?
           state_id, path = queue.shift
           return path if state_id == target