ibex 0.1.0 → 0.3.0

data/lib/ibex/lalr/ielr/split_stability.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+# steep:ignore:start
+
+require_relative "bits"
+
+module Ibex
+  module LALR
+    module IELR
+      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      module SplitStability
+        MAX_ENUMERATED_POTENTIALS = 12
+
+        module_function
+
+        # @rbs (Annotation) -> bool
+        def simple?(annotation)
+          annotation.matrix.all? { |row| row.nil? || row.zero? }
+        end
+
+        # @rbs (Annotation, ConflictResolver) -> bool
+        def split_stable?(annotation, resolver)
+          return true if simple?(annotation)
+
+          contributions = annotation.inadequacy.contributions
+          kept = contributions.each_index.reject { |index| annotation.matrix[index]&.zero? }
+          return true if kept.empty?
+
+          potential = kept.reject { |index| annotation.matrix[index].nil? }
+          return false if potential.length > MAX_ENUMERATED_POTENTIALS
+
+          base = resolve(resolver, annotation.inadequacy.token, kept.map { |index| contributions[index] })
+          subsets(potential).all? do |removed|
+            remaining = kept.reject { |index| removed.include?(index) }
+            remaining.empty? || resolve(resolver, annotation.inadequacy.token,
+                                        remaining.map { |index| contributions[index] }) == base
+          end
+        end
+
+        # @rbs (ConflictResolver, Integer, Array[Object]) -> Object?
+        def resolve(resolver, token, contributions)
+          actions = contributions.map do |kind, production_id|
+            case kind
+            when :shift then { type: :shift, state: 0 }
+            when :reduce then { type: :reduce, production: production_id }
+            when :accept then { type: :accept }
+            when :error then { type: :error }
+            else raise Ibex::Error, "unknown IELR contribution #{kind.inspect}"
+            end
+          end
+          action, = resolver.resolve(token, actions)
+          normalize(action)
+        end
+
+        # @rbs (Object?) -> Object?
+        def normalize(action)
+          return nil unless action
+          return [:shift] if action[:type] == :shift
+          return [:reduce, action[:production]] if action[:type] == :reduce
+          return [:accept] if action[:type] == :accept
+          return [:error] if action[:type] == :error
+
+          action
+        end
+
+        # @rbs (Array[Integer]) -> Array[Array[Integer]]
+        def subsets(values)
+          (0...(1 << values.length)).map do |bits|
+            values.each_index.filter_map { |index| values.fetch(index) if bits.anybits?(1 << index) }
+          end
+        end
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+    end
+  end
+end
+# steep:ignore:end

data/lib/ibex/lalr/ielr/split_state.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Ibex
+  module LALR
+    module IELR
+      # @rbs skip
+      SplitState = Struct.new(:core, :transitions, :lalr_isocore, keyword_init: true)
+
+      # @rbs!
+      #   class SplitState < Struct[Array[item_core] | Array[[Integer, Integer]] | Integer]
+      #     attr_accessor core: Array[item_core]
+      #     attr_accessor transitions: Array[[Integer, Integer]]
+      #     attr_accessor lalr_isocore: Integer
+      #     def self.new: (core: Array[item_core], transitions: Array[[Integer, Integer]],
+      #       lalr_isocore: Integer) -> instance
+      #   end
+    end
+  end
+end

data/lib/ibex/lalr/ielr/state_splitter.rb

@@ -0,0 +1,258 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+# steep:ignore:start
+
+require "set"
+require_relative "bits"
+require_relative "split_state"
+require_relative "annotator"
+require_relative "split_stability"
+
+module Ibex
+  module LALR
+    module IELR
+      # Splits LR(0) isocores only where an inadequacy would change the
+      # resolved action.  New states copy their transition arrays; no mutable
+      # transition table is shared between isocores.
+      class StateSplitter
+        attr_reader :annotations #: Array[Array[Annotation]]
+        attr_reader :states #: Array[SplitState]
+        attr_reader :lalr_isocores #: Array[Integer]
+        attr_reader :split_states #: Integer
+        attr_reader :inadequacies #: Array[Array[Inadequacy]]
+        attr_reader :split_stable_discarded #: Integer
+
+        # @rbs (IR::Grammar grammar, Array[core_set] states, transitions transitions,
+        #   Array[packed_items] items, GotoFollows goto_follows, ?resolver: ConflictResolver?) -> void
+        # rubocop:disable Metrics/AbcSize -- initialization wires the phase tables once.
+        def initialize(grammar, states, transitions, items, goto_follows, resolver: nil)
+          @grammar = grammar
+          @base_states = states
+          @base_transitions = transitions
+          @base_items = items
+          @goto_follows = goto_follows
+          @resolver = resolver || ConflictResolver.new(grammar)
+          @kernel_cores = states.map { |state| kernel_items(state) }
+          annotator = Annotator.new(grammar, states, transitions, items, goto_follows, resolver: @resolver)
+          @annotations = annotator.build
+          @inadequacies = annotator.inadequacies
+          @split_stable_discarded = annotator.split_stable_discarded
+          @item_lookaheads = annotator.item_lookaheads
+          @states = states.each_with_index.map do |_state, state_id|
+            SplitState.new(core: @kernel_cores.fetch(state_id),
+                           transitions: transitions.fetch(state_id).sort_by(&:first).map(&:dup),
+                           lalr_isocore: state_id)
+          end
+          @lalr_isocores = states.each_index.to_a
+          @isocore_nexts = states.each_index.to_a
+          @lookaheads_recomputed = Array.new(states.length, false)
+          @lookahead_sets = states.each_with_index.map do |_state, state_id|
+            @kernel_cores.fetch(state_id).each_index.map do |index|
+              @item_lookaheads.fetch(state_id, index)
+            end
+          end
+          @filters = {}
+          @split_states = 0
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        # @rbs () -> [Array[packed_items], transitions]
+        def build
+          state_id = 0
+          while state_id < @states.length
+            @states.fetch(state_id).transitions.each_index do |index|
+              target = @states.fetch(state_id).transitions.fetch(index).fetch(1)
+              compute_state(state_id, target, index)
+            end
+            state_id += 1
+          end
+          [pack_items, packed_transitions]
+        end
+
+        private
+
+        # @rbs (Integer from_id, Integer to_id, Integer transition_index) -> void
+        def compute_state(from_id, to_id, transition_index)
+          incoming = propagate_lookaheads(from_id, to_id)
+          target = to_id
+          found = false
+          loop do
+            if compatible?(target, incoming)
+              found = true
+              break
+            end
+            break if @isocore_nexts.fetch(target) == to_id
+
+            target = @isocore_nexts.fetch(target)
+          end
+
+          if !found
+            target = append_isocore(target, incoming)
+          elsif !@lookaheads_recomputed.fetch(target)
+            raise Ibex::Error, "IELR target changed before initial lookahead computation" unless target == to_id
+
+            @lookahead_sets[target] = incoming
+            @lookaheads_recomputed[target] = true
+          else
+            merge_lookaheads(target, incoming)
+          end
+          @states.fetch(from_id).transitions.fetch(transition_index)[1] = target
+        end
+
+        # @rbs (Integer from_id, Integer to_id) -> Array[Integer]
+        def propagate_lookaheads(from_id, to_id)
+          filters = lookahead_set_filters(to_id)
+          @kernel_cores.fetch(to_id).each_with_index.map do |(production_id, dot), index|
+            bits = if dot > 1
+                     previous = kernel_index_of(from_id, production_id, dot - 1)
+                     previous ? @lookahead_sets.fetch(from_id).fetch(previous) : 0
+                   elsif dot == 1
+                     compute_goto_follow_set(from_id, lhs_for(production_id))
+                   else
+                     raise Ibex::Error, "IELR transition produced a dot-zero kernel"
+                   end
+            bits & filters.fetch(index)
+          end
+        end
+
+        # @rbs (Integer state_id, Integer nonterminal_id) -> Integer
+        def compute_goto_follow_set(state_id, nonterminal_id)
+          goto_id = @goto_follows.goto_for(@lalr_isocores.fetch(state_id), nonterminal_id)
+          raise Ibex::Error, "missing GOTO for #{nonterminal_id} from #{state_id}" unless goto_id
+
+          bits = @goto_follows.always_follows.fetch(goto_id)
+          Bits.each_set_bit(@goto_follows.follow_kernel_items.fetch(goto_id)) do |index|
+            bits |= @lookahead_sets.fetch(state_id).fetch(index)
+          end
+          bits
+        end
+
+        # @rbs (Integer state_id) -> Array[Integer]
+        def lookahead_set_filters(state_id)
+          core_id = @lalr_isocores.fetch(state_id)
+          return @filters.fetch(core_id) if @filters.key?(core_id)
+
+          filters = Array.new(@kernel_cores.fetch(core_id).length, 0)
+          @annotations.fetch(core_id).each do |annotation|
+            token_bit = 1 << annotation.inadequacy.token
+            annotation.matrix.each do |row|
+              next if row.nil?
+
+              Bits.each_set_bit(row) { |index| filters[index] |= token_bit }
+            end
+          end
+          @filters[core_id] = filters
+        end
+
+        # @rbs (Integer state_id, Array[Integer]) -> bool
+        def compatible?(state_id, incoming)
+          return true unless @lookaheads_recomputed.fetch(state_id)
+
+          @annotations.fetch(@lalr_isocores.fetch(state_id)).all? do |annotation|
+            current = dominant_contribution(annotation, @lookahead_sets.fetch(state_id))
+            next true unless current
+
+            candidate = dominant_contribution(annotation, incoming)
+            !candidate || current == candidate
+          end
+        end
+
+        # @rbs (Annotation, Array[Integer]) -> Object?
+        def dominant_contribution(annotation, lookaheads)
+          token_bit = 1 << annotation.inadequacy.token
+          selected = annotation.inadequacy.contributions.each_index.select do |index|
+            row = annotation.matrix.fetch(index)
+            row.nil? || Bits.each_set_bit(row).any? { |kernel| lookaheads.fetch(kernel).anybits?(token_bit) }
+          end
+          return nil if selected.empty?
+
+          contributions = selected.map { |index| annotation.inadequacy.contributions.fetch(index) }
+          SplitStability.resolve(@resolver, annotation.inadequacy.token, contributions)
+        end
+
+        # @rbs (Integer after_id, Array[Integer]) -> Integer
+        def append_isocore(after_id, lookaheads)
+          source = @states.fetch(after_id)
+          @states << SplitState.new(
+            core: source.core.dup,
+            transitions: source.transitions.map(&:dup),
+            lalr_isocore: @lalr_isocores.fetch(after_id)
+          )
+          appended = @states.length - 1
+          @lalr_isocores << @lalr_isocores.fetch(after_id)
+          @isocore_nexts << @isocore_nexts.fetch(after_id)
+          @isocore_nexts[after_id] = appended
+          @lookaheads_recomputed << true
+          @lookahead_sets << lookaheads
+          @split_states += 1
+          appended
+        end
+
+        # @rbs (Integer state_id, Array[Integer]) -> void
+        def merge_lookaheads(state_id, incoming)
+          changed = false
+          incoming.each_with_index do |bits, index|
+            added = bits & ~@lookahead_sets.fetch(state_id).fetch(index)
+            next if added.zero?
+
+            @lookahead_sets.fetch(state_id)[index] |= added
+            changed = true
+          end
+          return unless changed
+
+          @states.fetch(state_id).transitions.each_index do |index|
+            target = @states.fetch(state_id).transitions.fetch(index).fetch(1)
+            break unless @lookaheads_recomputed.fetch(target)
+
+            compute_state(state_id, target, index)
+          end
+        end
+
+        # @rbs () -> Array[packed_items]
+        def pack_items
+          @states.each_with_index.map do |state, state_id|
+            packed = Hash.new { |hash, key| hash[key] = Set.new }
+            @base_items.fetch(state.lalr_isocore).each do |core, values|
+              packed[core].merge(values)
+            end
+            state.core.each_with_index do |core, index|
+              packed[core] = Set.new(Bits.each_set_bit(@lookahead_sets.fetch(state_id).fetch(index)).to_a)
+            end
+            packed
+          end
+        end
+
+        # @rbs () -> transitions
+        def packed_transitions
+          @states.map { |state| state.transitions.to_h { |symbol, target| [symbol, target] } }
+        end
+
+        # @rbs (core_set items) -> Array[item_core]
+        def kernel_items(items)
+          items.select { |production_id, dot| production_id.negative? || dot.positive? }.to_a.sort
+        end
+
+        # @rbs (Integer state_id, Integer production_id, Integer dot) -> Integer?
+        def kernel_index_of(state_id, production_id, dot)
+          @kernel_cores.fetch(@lalr_isocores.fetch(state_id)).index([production_id, dot])
+        end
+
+        # @rbs (Integer production_id) -> Integer
+        def lhs_for(production_id)
+          return @grammar.symbol(@grammar.starts.fetch(-production_id - 1)).id if production_id.negative?
+
+          @grammar.productions.fetch(production_id).lhs
+        end
+
+        # @rbs (Integer production_id) -> Array[Integer]
+        def rhs_for(production_id)
+          return [lhs_for(production_id)] if production_id.negative?
+
+          @grammar.productions.fetch(production_id).rhs
+        end
+      end
+    end
+  end
+end
+# steep:ignore:end

data/lib/ibex/lalr/ielr_partition.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require "set"
+
+module Ibex
+  module LALR
+    # Deterministically merges compatible canonical LR(1) states and splits
+    # partitions until their outgoing transitions are congruent.
+    class IELRPartition
+      # @rbs! type contribution_action = [:shift] | [:reduce, Integer] | [:accept]
+
+      AUGMENTED_PRODUCTION = -1 #: Integer
+
+      # @rbs @grammar: IR::Grammar
+      # @rbs @states: Array[item_set]
+      # @rbs @transitions: transitions
+      # @rbs @contributions: Array[Hash[Integer, Set[contribution_action]]]
+      # @rbs @initial_partition_count: Integer?
+      # @rbs @final_partition_count: Integer?
+      # @rbs @profile: bool
+
+      attr_reader :initial_partition_count #: Integer?
+      attr_reader :final_partition_count #: Integer?
+
+      # @rbs (IR::Grammar grammar, Array[item_set] states, transitions transitions, ?profile: bool) -> void
+      def initialize(grammar, states, transitions, profile: false)
+        @grammar = grammar
+        @states = states
+        @transitions = transitions
+        @contributions = Array.new(states.length) { |state_id| action_contributions(state_id) }
+        @initial_partition_count = nil
+        @final_partition_count = nil
+        @profile = profile
+      end
+
+      # @rbs () -> [Array[packed_items], transitions]
+      def build
+        partitions = initial_partitions
+        @initial_partition_count = partitions.length if @profile
+        partitions = refine_transitions(partitions)
+        @final_partition_count = partitions.length if @profile
+        indexes = partition_indexes(partitions)
+        items = partitions.map { |members| merge_items(members) }
+        transitions = partitions.map do |members|
+          @transitions.fetch(members.first).to_h do |symbol_id, target|
+            [symbol_id, indexes.fetch(target)]
+          end
+        end
+        [items, transitions]
+      end
+
+      private
+
+      # @rbs () -> Array[state_partition]
+      def initial_partitions
+        cores = {} #: Hash[Array[item_core], Array[Integer]]
+        @states.each_with_index do |items, state_id|
+          cores[core_key(items)] ||= []
+          cores.fetch(core_key(items)) << state_id
+        end
+        cores.values.flat_map { |members| compatible_partitions(members) }
+      end
+
+      # @rbs (Array[Integer] members) -> Array[state_partition]
+      def compatible_partitions(members)
+        partitions = [] #: Array[state_partition]
+        members.each do |state_id|
+          partition = partitions.find { |candidate| compatible?(candidate + [state_id]) }
+          partition ? partition << state_id : partitions << [state_id]
+        end
+        partitions
+      end
+
+      # A canonical member may gain an action only where it previously had no
+      # action. Every nonempty member cell must equal the merged cell.
+      # @rbs (state_partition members) -> bool
+      def compatible?(members)
+        merged = Hash.new { |hash, key| hash[key] = Set.new } #: Hash[Integer, Set[contribution_action]]
+        members.each do |state_id|
+          @contributions.fetch(state_id).each { |token_id, actions| merged[token_id].merge(actions) }
+        end
+        merged.all? do |token_id, actions|
+          members.all? do |state_id|
+            member_actions = @contributions.fetch(state_id)[token_id]
+            member_actions.nil? || member_actions.empty? || member_actions == actions
+          end
+        end
+      end
+
+      # @rbs (Array[state_partition] partitions) -> Array[state_partition]
+      def refine_transitions(partitions)
+        loop do
+          indexes = partition_indexes(partitions)
+          refined = partitions.flat_map do |members|
+            members.group_by { |state_id| transition_signature(state_id, indexes) }.values
+          end
+          return partitions if refined == partitions
+
+          partitions = refined
+        end
+      end
+
+      # @rbs (Integer state_id, Hash[Integer, Integer] indexes) -> Array[[Integer, Integer]]
+      def transition_signature(state_id, indexes)
+        @transitions.fetch(state_id).map do |symbol_id, target|
+          [symbol_id, indexes.fetch(target)] #: [Integer, Integer]
+        end.sort
+      end
+
+      # @rbs (Array[state_partition] partitions) -> Hash[Integer, Integer]
+      def partition_indexes(partitions)
+        indexes = {} #: Hash[Integer, Integer]
+        partitions.each_with_index do |members, partition_id|
+          members.each { |state_id| indexes[state_id] = partition_id }
+        end
+        indexes
+      end
+
+      # @rbs (state_partition members) -> packed_items
+      def merge_items(members)
+        merged = Hash.new { |hash, key| hash[key] = Set.new } #: packed_items
+        members.each do |state_id|
+          @states.fetch(state_id).each do |production_id, dot, lookahead|
+            merged[[production_id, dot]] << lookahead
+          end
+        end
+        merged
+      end
+
+      # @rbs (Integer state_id) -> Hash[Integer, Set[contribution_action]]
+      def action_contributions(state_id)
+        actions = Hash.new { |hash, key| hash[key] = Set.new } #: Hash[Integer, Set[contribution_action]]
+        @transitions.fetch(state_id).each_key do |symbol_id|
+          symbol = @grammar.symbol_by_id(symbol_id)
+          actions[symbol_id] << [:shift] if symbol&.terminal?
+        end
+        @states.fetch(state_id).each do |production_id, dot, lookahead|
+          next unless dot == rhs_for(production_id).length
+
+          action = production_id.negative? ? [:accept] : [:reduce, production_id] #: contribution_action
+          actions[lookahead] << action
+        end
+        actions
+      end
+
+      # @rbs (Integer production_id) -> Array[Integer]
+      def rhs_for(production_id)
+        if production_id.negative?
+          name = @grammar.starts.fetch(-production_id - 1)
+          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]
+      def core_key(items)
+        items.map do |production_id, dot, _lookahead|
+          [production_id, dot] #: item_core
+        end.uniq.sort
+      end
+    end
+  end
+end

data/lib/ibex/lalr/inadequacy_report.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+# steep:ignore:start
+
+require "json"
+require_relative "../verify/action_correspondence"
+
+module Ibex
+  module LALR
+    # @rbs! type report_value = String | Symbol | Integer | bool | nil | IR::parser_action |
+    #   Array[report_value] | Hash[Symbol, report_value]
+
+    # Diagnostic-only report for canonical-vs-LALR action differences.  It is
+    # intentionally separate from normal construction because it enumerates a
+    # canonical LR(1) reference.
+    class InadequacyReport
+      # @rbs (IR::Automaton canonical, IR::Automaton target, ?max_pairs: Integer) -> void
+      def initialize(canonical, target, max_pairs: nil)
+        @canonical = canonical
+        @target = target
+        @max_pairs = max_pairs
+      end
+
+      # @rbs () -> Hash[Symbol, report_value]
+      def to_h
+        result = Verify::ActionCorrespondence.new(@canonical, @target, max_pairs: @max_pairs).verify
+        {
+          algorithm: @target.algorithm,
+          canonical_algorithm: @canonical.algorithm,
+          explored_pairs: result.explored,
+          truncated: result.truncated,
+          differences: result.differences.map do |difference|
+            {
+              kind: difference.kind, canonical_state: difference.canonical_state,
+              target_state: difference.target_state, symbol: difference.symbol,
+              canonical: difference.canonical, target: difference.target
+            }
+          end
+        }
+      end
+
+      # @rbs () -> String
+      def to_json(*)
+        "#{JSON.pretty_generate(to_h)}\n"
+      end
+    end
+  end
+end
+# steep:ignore:end

data/lib/ibex/lalr/lookahead_propagation.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+# steep:ignore:start
+
+require "set"
+
+module Ibex
+  module LALR
+    # Recomputes item lookaheads on an already-built LR(0) automaton.  This is
+    # Phase 4 of direct IELR and is also useful as an independent cross-check
+    # for DirectLookaheads.
+    class LookaheadPropagation
+      EMPTY = Array.new(0).freeze #: Array[Integer]
+
+      attr_reader :propagation_edge_count #: Integer
+
+      # @rbs (IR::Grammar grammar, Analysis::Sets sets, Array[core_set] states, transitions transitions,
+      #   seeds: Array[[Integer, item_core, Integer]]) -> Array[packed_items]
+      def initialize(grammar, sets, states, transitions, seeds:)
+        @grammar = grammar
+        @sets = sets
+        @states = states
+        @transitions = transitions
+        @seeds = seeds
+        @productions_by_lhs = grammar.productions.group_by(&:lhs)
+      end
+
+      # @rbs () -> Array[packed_items]
+      def build
+        lookaheads = @states.map { |items| items.to_h { |item| [item, Set.new] } }
+        edges = Hash.new { |hash, key| hash[key] = [] }
+        @states.each_with_index do |items, state_id|
+          items.each do |production_id, dot|
+            add_transition(edges, state_id, production_id, dot)
+            add_closure(edges, lookaheads, state_id, production_id, dot)
+          end
+        end
+        @seeds.each { |state_id, item, token| lookaheads.fetch(state_id).fetch(item) << token }
+        @propagation_edge_count = edges.values.sum(&:length)
+        propagate(lookaheads, edges)
+        lookaheads
+      end
+
+      private
+
+      # @rbs (Hash[Object, Array[Object]], Integer, Integer, Integer) -> void
+      def add_transition(edges, state_id, production_id, dot)
+        symbol_id = rhs_for(production_id)[dot]
+        return unless symbol_id
+
+        target = @transitions.fetch(state_id).fetch(symbol_id)
+        edges[[state_id, production_id, dot]] << [target, production_id, dot + 1]
+      end
+
+      # @rbs (Hash[Object, Array[Object]], Array[packed_items], Integer, Integer, Integer) -> void
+      def add_closure(edges, lookaheads, state_id, production_id, dot)
+        rhs = rhs_for(production_id)
+        symbol = @grammar.symbol_by_id(rhs[dot])
+        return unless symbol&.nonterminal?
+
+        suffix = rhs.drop(dot + 1)
+        spontaneous = terminal_ids(@sets.first_of_sequence(suffix))
+        @productions_by_lhs.fetch(symbol.id, []).each do |production|
+          item = [production.id, 0].freeze
+          lookaheads.fetch(state_id).fetch(item).merge(spontaneous)
+          edges[[state_id, production_id, dot]] << [state_id, production.id, 0] if
+            @sets.sequence_nullable?(suffix)
+        end
+      end
+
+      # @rbs (Array[packed_items], Hash[Object, Array[Object]]) -> void
+      def propagate(lookaheads, edges)
+        queue = @seeds.map { |state_id, (production_id, dot), _token| [state_id, production_id, dot] }
+        queue.concat(lookaheads.each_with_index.flat_map do |items, state_id|
+          items.filter_map { |(production_id, dot), values| [state_id, production_id, dot] unless values.empty? }
+        end)
+        queued = queue.to_h { |node| [node, true] }
+        cursor = 0
+        while cursor < queue.length
+          source = queue.fetch(cursor)
+          cursor += 1
+          queued.delete(source)
+          source_set = lookaheads.fetch(source[0]).fetch([source[1], source[2]])
+          edges.fetch(source, EMPTY).each do |target|
+            target_set = lookaheads.fetch(target[0]).fetch([target[1], target[2]])
+            previous_size = target_set.size
+            target_set.merge(source_set)
+            next if target_set.size == previous_size || queued[target]
+
+            queue << target
+            queued[target] = true
+          end
+        end
+      end
+
+      # @rbs (Integer bits) -> Array[Integer]
+      def terminal_ids(bits)
+        @grammar.terminals.filter_map { |terminal| terminal.id if bits.anybits?(1 << terminal.id) }
+      end
+
+      # @rbs (Integer production_id) -> Array[Integer]
+      def rhs_for(production_id)
+        return [@grammar.symbol(@grammar.starts.fetch(-production_id - 1)).id] if production_id.negative?
+
+        @grammar.productions.fetch(production_id).rhs
+      end
+    end
+  end
+end
+# steep:ignore:end