ibex 0.2.0 → 0.4.0

data/sig/ibex/lalr/direct_lookaheads.rbs

@@ -9,34 +9,32 @@ module Ibex
 
       EMPTY_PRODUCTIONS: Array[IR::Production]
 
-      EMPTY_NODES: Array[lookahead_node]
+      EMPTY_NODES: Array[Integer]
 
-      @terminal_masks: Array[Integer]
+      attr_reader lr0_state_count: Integer?
 
-      @terminal_ids: Array[Integer]
+      attr_reader lr0_item_count: Integer?
 
-      @production_item_cores: Array[Array[item_core]]
+      attr_reader propagation_edge_count: Integer?
 
-      @augmented_item_cores: Array[item_core]
+      attr_reader states: Array[core_set]
 
-      @production_rhs: Array[Array[Integer]]
+      attr_reader transitions: transitions
 
-      @augmented_rhs: Array[Integer]
-
-      @productions_by_lhs: Hash[Integer, Array[IR::Production]]
-
-      @sets: Analysis::Sets
-
-      @grammar: IR::Grammar
-
-      # @rbs (IR::Grammar grammar, Analysis::Sets sets) -> void
-      def initialize: (IR::Grammar grammar, Analysis::Sets sets) -> void
+      # @rbs (IR::Grammar grammar, Analysis::Sets sets, ?starts: Array[String]?, ?profile: bool) -> void
+      def initialize: (IR::Grammar grammar, Analysis::Sets sets, ?starts: Array[String]?, ?profile: bool) -> void
 
       # @rbs () -> [Array[packed_items], transitions]
       def build: () -> [ Array[packed_items], transitions ]
 
+      # @rbs (Integer index) -> Integer
+      def augmented_production: (Integer index) -> Integer
+
       private
 
+      # @rbs () -> void
+      def initialize_item_encoding: () -> void
+
       # @rbs () -> [Array[core_set], transitions]
       def lr0_collection: () -> [ Array[core_set], transitions ]
 
@@ -50,22 +48,25 @@ module Ibex
       def empty_lookaheads: (Array[core_set] states) -> Array[packed_items]
 
       # @rbs (Array[core_set] states, transitions transitions, Array[packed_items] lookaheads) ->
-      #   Hash[lookahead_node, Array[lookahead_node]]
-      def propagation_graph: (Array[core_set] states, transitions transitions, Array[packed_items] lookaheads) -> Hash[lookahead_node, Array[lookahead_node]]
+      #   Hash[Integer, Array[Integer]]
+      def propagation_graph: (Array[core_set] states, transitions transitions, Array[packed_items] lookaheads) -> Hash[Integer, Array[Integer]]
 
-      # @rbs (Hash[lookahead_node, Array[lookahead_node]] edges, transitions transitions,
+      # @rbs (Hash[Integer, Array[Integer]] edges, transitions transitions,
       #   Integer state_id, Integer production_id, Integer dot) -> void
-      def add_transition_edge: (Hash[lookahead_node, Array[lookahead_node]] edges, transitions transitions, Integer state_id, Integer production_id, Integer dot) -> void
+      def add_transition_edge: (Hash[Integer, Array[Integer]] edges, transitions transitions, Integer state_id, Integer production_id, Integer dot) -> void
 
-      # @rbs (Hash[lookahead_node, Array[lookahead_node]] edges, Array[packed_items] lookaheads,
+      # @rbs (Hash[Integer, Array[Integer]] edges, Array[packed_items] lookaheads,
       #   Integer state_id, Integer production_id, Integer dot) -> void
-      def add_closure_relations: (Hash[lookahead_node, Array[lookahead_node]] edges, Array[packed_items] lookaheads, Integer state_id, Integer production_id, Integer dot) -> void
+      def add_closure_relations: (Hash[Integer, Array[Integer]] edges, Array[packed_items] lookaheads, Integer state_id, Integer production_id, Integer dot) -> void
+
+      # @rbs (Array[packed_items] lookaheads, Hash[Integer, Array[Integer]] edges) -> void
+      def propagate: (Array[packed_items] lookaheads, Hash[Integer, Array[Integer]] edges) -> void
 
-      # @rbs (Array[packed_items] lookaheads, Hash[lookahead_node, Array[lookahead_node]] edges) -> void
-      def propagate: (Array[packed_items] lookaheads, Hash[lookahead_node, Array[lookahead_node]] edges) -> void
+      # @rbs (Array[packed_items] lookaheads, Integer node) -> Set[Integer]
+      def node_set: (Array[packed_items] lookaheads, Integer node) -> Set[Integer]
 
-      # @rbs (Array[packed_items] lookaheads, lookahead_node node) -> Set[Integer]
-      def node_set: (Array[packed_items] lookaheads, lookahead_node node) -> Set[Integer]
+      # @rbs (Integer state_id, Integer production_id, Integer dot) -> Integer
+      def node_id: (Integer state_id, Integer production_id, Integer dot) -> Integer
 
       # @rbs (Integer bits) -> Array[Integer]
       def terminal_ids: (Integer bits) -> Array[Integer]
@@ -79,8 +80,14 @@ module Ibex
       # @rbs (Integer production_id, Integer dot) -> item_core
       def item_core: (Integer production_id, Integer dot) -> item_core
 
-      # @rbs (core_set items) -> Array[item_core]
-      def item_key: (core_set items) -> Array[item_core]
+      # @rbs (core_set items) -> Array[Integer]
+      def item_key: (core_set items) -> Array[Integer]
+
+      # @rbs (String name) -> Integer
+      def start_index: (String name) -> Integer
+
+      # @rbs () -> Array[String]
+      def grammar_starts: () -> Array[String]
     end
   end
 end

data/sig/ibex/lalr/goto_follows.rbs

@@ -0,0 +1,89 @@
+# Generated from lib/ibex/lalr/goto_follows.rb with RBS::Inline
+
+module Ibex
+  module LALR
+    # Computes DeRemer–Pennello goto-follow sets over an LR(0) collection.
+    # The three dependency closures are kept separately because IELR relies on
+    # the distinction between stable (successor/internal) and predecessor
+    # dependencies when a state is split.
+    class GotoFollows
+      @kernel_cores: Array[Array[item_core]]
+
+      @transitions: transitions
+
+      @states: Array[core_set]
+
+      @sets: Analysis::Sets
+
+      @grammar: IR::Grammar
+
+      attr_reader from_state: Array[Integer]
+
+      attr_reader to_state: Array[Integer]
+
+      attr_reader goto_index: Hash[[ Integer, Integer ], Integer]
+
+      attr_reader direct_reads: Array[Integer]
+
+      attr_reader successor_edges: Array[Array[Integer]]
+
+      attr_reader internal_edges: Array[Array[Integer]]
+
+      attr_reader includes_edges: Array[Array[Integer]]
+
+      attr_reader predecessors: Array[Array[Integer]]
+
+      attr_reader successor_follows: Array[Integer]
+
+      attr_reader always_follows: Array[Integer]
+
+      attr_reader goto_follows: Array[Integer]
+
+      attr_reader follow_kernel_items: Array[Integer]
+
+      attr_reader kernel_cores: Array[Array[item_core]]
+
+      # @rbs (IR::Grammar grammar, Analysis::Sets sets, Array[core_set] states, transitions transitions,
+      #   Array[Integer] start_states, ?start_names: Array[String]?) -> void
+      def initialize: (IR::Grammar grammar, Analysis::Sets sets, Array[core_set] states, transitions transitions, Array[Integer] start_states, ?start_names: Array[String]?) -> void
+
+      # @rbs (Integer state_id, Integer nonterminal_id) -> Integer?
+      def goto_for: (Integer state_id, Integer nonterminal_id) -> Integer?
+
+      # @rbs () -> Array[Hash[Integer, Integer]]
+      def reduction_lookaheads: () -> Array[Hash[Integer, Integer]]
+
+      private
+
+      # @rbs () -> void
+      def build_gotos: () -> void
+
+      # @rbs () -> void
+      def build_dependencies: () -> void
+
+      # @rbs () -> void
+      def build_follow_sets: () -> void
+
+      # @rbs (Array[Array[Integer]], Array[Array[Integer]]) -> Array[Array[Integer]]
+      def merged_edges: (Array[Array[Integer]], Array[Array[Integer]]) -> Array[Array[Integer]]
+
+      # @rbs (Integer goto_id) -> Integer
+      def compute_follow_kernel_items: (Integer goto_id) -> Integer
+
+      # @rbs (core_set items) -> Array[item_core]
+      def kernel_items: (core_set items) -> Array[item_core]
+
+      # @rbs (Integer goto_id) -> Integer
+      def symbol_for_goto: (Integer goto_id) -> Integer
+
+      # @rbs (Integer state_id, Array[Integer]) -> Integer?
+      def advance: (Integer state_id, Array[Integer]) -> Integer?
+
+      # @rbs (Integer production_id) -> Array[Integer]
+      def rhs_for: (Integer production_id) -> Array[Integer]
+
+      # @rbs () -> Integer
+      def eof_id: () -> Integer
+    end
+  end
+end

data/sig/ibex/lalr/ielr/annotator.rbs

@@ -0,0 +1,67 @@
+# Generated from lib/ibex/lalr/ielr/annotator.rb with RBS::Inline
+
+module Ibex
+  module LALR
+    module IELR
+      # Finds grammar-relative inadequacies and traces their possible
+      # manifestations through predecessor states.
+      class Annotator
+        attr_reader annotation_lists: Array[Array[Annotation]]
+
+        attr_reader inadequacies: Array[Array[Inadequacy]]
+
+        attr_reader item_lookaheads: ItemLookaheads
+
+        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
+        def initialize: (IR::Grammar grammar, Array[core_set] states, transitions transitions, Array[packed_items] items, GotoFollows goto_follows, ?resolver: ConflictResolver?) -> void
+
+        # @rbs () -> Array[Array[Annotation]]
+        def build: () -> Array[Array[Annotation]]
+
+        private
+
+        # @rbs (Integer state_id) -> Array[Inadequacy]
+        def build_inadequacies: (Integer state_id) -> Array[Inadequacy]
+
+        # @rbs (Integer state_id, Integer token_id) -> Array[[Symbol, Integer?]]
+        def contributions_for: (Integer state_id, Integer token_id) -> Array[[ Symbol, Integer? ]]
+
+        # @rbs (Integer state_id, Inadequacy inadequacy) -> Annotation
+        def annotate_manifestation: (Integer state_id, Inadequacy inadequacy) -> Annotation
+
+        # @rbs (Integer state_id, Integer successor_id, Annotation annotation) -> Annotation
+        def annotate_predecessor: (Integer state_id, Integer successor_id, Annotation annotation) -> Annotation
+
+        # @rbs (Integer state_id, Array[item_core], Integer, Integer) -> bool
+        def always_via_lhs?: (Integer state_id, Array[item_core], Integer, Integer) -> bool
+
+        # @rbs (Integer state_id, Array[item_core], Integer, Integer) -> Integer
+        def project_row: (Integer state_id, Array[item_core], Integer, Integer) -> Integer
+
+        # @rbs (Integer state_id, Integer production_id, Integer length) -> Integer
+        def completed_kernel_mask: (Integer state_id, Integer production_id, Integer length) -> Integer
+
+        # @rbs (Integer state_id, Integer lhs_id, Integer token_id) -> Integer?
+        def compute_lhs_contributions: (Integer state_id, Integer lhs_id, Integer token_id) -> Integer?
+
+        # @rbs (Integer state_id, Annotation annotation) -> bool
+        def register?: (Integer state_id, Annotation annotation) -> bool
+
+        # @rbs (Integer state_id, Integer production_id) -> Integer
+        def lhs_for: (Integer state_id, Integer production_id) -> Integer
+
+        # @rbs (Integer production_id) -> Array[Integer]
+        def rhs_for: (Integer production_id) -> Array[Integer]
+
+        # @rbs (core_set items) -> Array[item_core]
+        def kernel_items: (core_set items) -> Array[item_core]
+
+        # @rbs (Integer state_id, Integer production_id, Integer dot) -> Integer?
+        def kernel_index_of: (Integer state_id, Integer production_id, Integer dot) -> Integer?
+      end
+    end
+  end
+end

data/sig/ibex/lalr/ielr/bits.rbs

@@ -0,0 +1,14 @@
+# Generated from lib/ibex/lalr/ielr/bits.rb with RBS::Inline
+
+module Ibex
+  module LALR
+    module IELR
+      module Bits
+        # @rbs (Integer bits) { (Integer) -> void } -> void
+        # @rbs (Integer bits) -> Enumerator[Integer, void]
+        def self?.each_set_bit: (Integer bits) { (Integer) -> void } -> void
+                              | (Integer bits) -> Enumerator[Integer, void]
+      end
+    end
+  end
+end

data/sig/ibex/lalr/ielr/inadequacy.rbs

@@ -0,0 +1,24 @@
+# Generated from lib/ibex/lalr/ielr/inadequacy.rb with RBS::Inline
+
+module Ibex
+  module LALR
+    module IELR
+      type contribution = [ Symbol, Integer? ]
+
+      class Inadequacy < Struct[Integer | Array[contribution]]
+        attr_accessor state: Integer
+        attr_accessor token: Integer
+        attr_accessor contributions: Array[contribution]
+        attr_accessor id: Integer
+        def self.new: (state: Integer, token: Integer, contributions: Array[contribution], id: Integer) -> instance
+      end
+
+      class Annotation < Struct[Inadequacy | Array[Integer?]]
+        attr_accessor inadequacy: Inadequacy
+        attr_accessor matrix: Array[Integer?]
+        def self.new: (inadequacy: Inadequacy, matrix: Array[Integer?]) -> instance
+        def key: () -> [ Integer, Array[Integer?] ]
+      end
+    end
+  end
+end

data/sig/ibex/lalr/ielr/item_lookaheads.rbs

@@ -0,0 +1,35 @@
+# Generated from lib/ibex/lalr/ielr/item_lookaheads.rb with RBS::Inline
+
+module Ibex
+  module LALR
+    module IELR
+      # Lazily derives the lookahead of a kernel item from predecessor states
+      # and goto-follow sets.  Memoisation is important: predecessor paths can
+      # share exponentially many suffixes in a real grammar.
+      class ItemLookaheads
+        @memo: Hash[Integer, Integer]
+
+        # @rbs (IR::Grammar grammar, GotoFollows goto_follows, Array[Array[item_core]] kernel_cores,
+        #   Array[Array[Integer]] predecessors, ?start_states: Array[Integer]?) -> void
+        def initialize: (IR::Grammar grammar, GotoFollows goto_follows, Array[Array[item_core]] kernel_cores, Array[Array[Integer]] predecessors, ?start_states: Array[Integer]?) -> void
+
+        # @rbs (Integer state_id, Integer kernel_index) -> Integer
+        def fetch: (Integer state_id, Integer kernel_index) -> Integer
+
+        # @rbs () -> Integer
+        def size: () -> Integer
+
+        private
+
+        # @rbs (Integer state_id, Integer kernel_index) -> Integer
+        def compute: (Integer state_id, Integer kernel_index) -> Integer
+
+        # @rbs (Integer state_id, Integer production_id) -> Integer
+        def goto_follows_for: (Integer state_id, Integer production_id) -> Integer
+
+        # @rbs (Integer production_id) -> Integer
+        def start_seed: (Integer production_id) -> Integer
+      end
+    end
+  end
+end

data/sig/ibex/lalr/ielr/pipeline.rbs

@@ -0,0 +1,17 @@
+# Generated from lib/ibex/lalr/ielr/pipeline.rb with RBS::Inline
+
+module Ibex
+  module LALR
+    module IELR
+      # Coordinates the canonical-free direct IELR phases.  The returned
+      # profile deliberately reports canonical metrics as unavailable.
+      class Pipeline
+        # @rbs (IR::Grammar grammar, Analysis::Sets sets, ?starts: Array[String]?, ?profile: bool) -> void
+        def initialize: (IR::Grammar grammar, Analysis::Sets sets, ?starts: Array[String]?, ?profile: bool) -> void
+
+        # @rbs () -> [Array[packed_items], transitions, LALR::build_collection]
+        def build: () -> [ Array[packed_items], transitions, LALR::build_collection ]
+      end
+    end
+  end
+end

data/sig/ibex/lalr/ielr/split_stability.rbs

@@ -0,0 +1,27 @@
+# Generated from lib/ibex/lalr/ielr/split_stability.rb with RBS::Inline
+
+module Ibex
+  module LALR
+    module IELR
+      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      module SplitStability
+        MAX_ENUMERATED_POTENTIALS: ::Integer
+
+        # @rbs (Annotation) -> bool
+        def self?.simple?: (Annotation) -> bool
+
+        # @rbs (Annotation, ConflictResolver) -> bool
+        def self?.split_stable?: (Annotation, ConflictResolver) -> bool
+
+        # @rbs (ConflictResolver, Integer, Array[Object]) -> Object?
+        def self?.resolve: (ConflictResolver, Integer, Array[Object]) -> Object?
+
+        # @rbs (Object?) -> Object?
+        def self?.normalize: (Object?) -> Object?
+
+        # @rbs (Array[Integer]) -> Array[Array[Integer]]
+        def self?.subsets: (Array[Integer]) -> Array[Array[Integer]]
+      end
+    end
+  end
+end

data/sig/ibex/lalr/ielr/split_state.rbs

@@ -0,0 +1,14 @@
+# Generated from lib/ibex/lalr/ielr/split_state.rb with RBS::Inline
+
+module Ibex
+  module LALR
+    module IELR
+      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/sig/ibex/lalr/ielr/state_splitter.rbs

@@ -0,0 +1,76 @@
+# Generated from lib/ibex/lalr/ielr/state_splitter.rb with RBS::Inline
+
+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: (IR::Grammar grammar, Array[core_set] states, transitions transitions, Array[packed_items] items, GotoFollows goto_follows, ?resolver: ConflictResolver?) -> void
+
+        # @rbs () -> [Array[packed_items], transitions]
+        def build: () -> [ Array[packed_items], transitions ]
+
+        private
+
+        # @rbs (Integer from_id, Integer to_id, Integer transition_index) -> void
+        def compute_state: (Integer from_id, Integer to_id, Integer transition_index) -> void
+
+        # @rbs (Integer from_id, Integer to_id) -> Array[Integer]
+        def propagate_lookaheads: (Integer from_id, Integer to_id) -> Array[Integer]
+
+        # @rbs (Integer state_id, Integer nonterminal_id) -> Integer
+        def compute_goto_follow_set: (Integer state_id, Integer nonterminal_id) -> Integer
+
+        # @rbs (Integer state_id) -> Array[Integer]
+        def lookahead_set_filters: (Integer state_id) -> Array[Integer]
+
+        # @rbs (Integer state_id, Array[Integer]) -> bool
+        def compatible?: (Integer state_id, Array[Integer]) -> bool
+
+        # @rbs (Annotation, Array[Integer]) -> Object?
+        def dominant_contribution: (Annotation, Array[Integer]) -> Object?
+
+        # @rbs (Integer after_id, Array[Integer]) -> Integer
+        def append_isocore: (Integer after_id, Array[Integer]) -> Integer
+
+        # @rbs (Integer state_id, Array[Integer]) -> void
+        def merge_lookaheads: (Integer state_id, Array[Integer]) -> void
+
+        # @rbs () -> Array[packed_items]
+        def pack_items: () -> Array[packed_items]
+
+        # @rbs () -> transitions
+        def packed_transitions: () -> transitions
+
+        # @rbs (core_set items) -> Array[item_core]
+        def kernel_items: (core_set items) -> Array[item_core]
+
+        # @rbs (Integer state_id, Integer production_id, Integer dot) -> Integer?
+        def kernel_index_of: (Integer state_id, Integer production_id, Integer dot) -> Integer?
+
+        # @rbs (Integer production_id) -> Integer
+        def lhs_for: (Integer production_id) -> Integer
+
+        # @rbs (Integer production_id) -> Array[Integer]
+        def rhs_for: (Integer production_id) -> Array[Integer]
+      end
+    end
+  end
+end

data/sig/ibex/lalr/ielr_partition.rbs

@@ -5,9 +5,17 @@ module Ibex
     # Deterministically merges compatible canonical LR(1) states and splits
     # partitions until their outgoing transitions are congruent.
     class IELRPartition
+      type contribution_action = [ :shift ] | [ :reduce, Integer ] | [ :accept ]
+
       AUGMENTED_PRODUCTION: Integer
 
-      @contributions: Array[Hash[Integer, Set[Array[untyped]]]]
+      @profile: bool
+
+      @final_partition_count: Integer?
+
+      @initial_partition_count: Integer?
+
+      @contributions: Array[Hash[Integer, Set[contribution_action]]]
 
       @transitions: transitions
 
@@ -15,8 +23,12 @@ module Ibex
 
       @grammar: IR::Grammar
 
-      # @rbs (IR::Grammar grammar, Array[item_set] states, transitions transitions) -> void
-      def initialize: (IR::Grammar grammar, Array[item_set] states, transitions transitions) -> void
+      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: (IR::Grammar grammar, Array[item_set] states, transitions transitions, ?profile: bool) -> void
 
       # @rbs () -> [Array[packed_items], transitions]
       def build: () -> [ Array[packed_items], transitions ]
@@ -46,8 +58,8 @@ module Ibex
       # @rbs (state_partition members) -> packed_items
       def merge_items: (state_partition members) -> packed_items
 
-      # @rbs (Integer state_id) -> Hash[Integer, Set[Array[untyped]]]
-      def action_contributions: (Integer state_id) -> Hash[Integer, Set[Array[untyped]]]
+      # @rbs (Integer state_id) -> Hash[Integer, Set[contribution_action]]
+      def action_contributions: (Integer state_id) -> Hash[Integer, Set[contribution_action]]
 
       # @rbs (Integer production_id) -> Array[Integer]
       def rhs_for: (Integer production_id) -> Array[Integer]

data/sig/ibex/lalr/inadequacy_report.rbs

@@ -0,0 +1,21 @@
+# Generated from lib/ibex/lalr/inadequacy_report.rb with RBS::Inline
+
+module Ibex
+  module LALR
+    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: (IR::Automaton canonical, IR::Automaton target, ?max_pairs: Integer) -> void
+
+      # @rbs () -> Hash[Symbol, report_value]
+      def to_h: () -> Hash[Symbol, report_value]
+
+      # @rbs () -> String
+      def to_json: () -> String
+    end
+  end
+end

data/sig/ibex/lalr/lookahead_propagation.rbs

@@ -0,0 +1,38 @@
+# Generated from lib/ibex/lalr/lookahead_propagation.rb with RBS::Inline
+
+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[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: (IR::Grammar grammar, Analysis::Sets sets, Array[core_set] states, transitions transitions, seeds: Array[[ Integer, item_core, Integer ]]) -> Array[packed_items]
+
+      # @rbs () -> Array[packed_items]
+      def build: () -> Array[packed_items]
+
+      private
+
+      # @rbs (Hash[Object, Array[Object]], Integer, Integer, Integer) -> void
+      def add_transition: (Hash[Object, Array[Object]], Integer, Integer, Integer) -> void
+
+      # @rbs (Hash[Object, Array[Object]], Array[packed_items], Integer, Integer, Integer) -> void
+      def add_closure: (Hash[Object, Array[Object]], Array[packed_items], Integer, Integer, Integer) -> void
+
+      # @rbs (Array[packed_items], Hash[Object, Array[Object]]) -> void
+      def propagate: (Array[packed_items], Hash[Object, Array[Object]]) -> void
+
+      # @rbs (Integer bits) -> Array[Integer]
+      def terminal_ids: (Integer bits) -> Array[Integer]
+
+      # @rbs (Integer production_id) -> Array[Integer]
+      def rhs_for: (Integer production_id) -> Array[Integer]
+    end
+  end
+end

data/sig/ibex/lalr/lr0_collection.rbs

@@ -0,0 +1,50 @@
+# Generated from lib/ibex/lalr/lr0_collection.rb with RBS::Inline
+
+module Ibex
+  module LALR
+    # Constructs only the LR(0) core collection.  Keeping this separate from
+    # lookahead propagation makes the direct IELR phases reusable and gives
+    # them a stable, canonical-free input representation.
+    class LR0Collection
+      AUGMENTED_PRODUCTION: Integer
+
+      @grammar: IR::Grammar
+
+      @productions_by_lhs: Hash[Integer, Array[IR::Production]]
+
+      @starts: Array[String]
+
+      @augmented_rhs: Hash[Integer, Array[Integer]]
+
+      @production_rhs: Array[Array[Integer]]
+
+      @item_key_stride: Integer
+
+      # @rbs (IR::Grammar grammar, ?starts: Array[String]?) -> void
+      def initialize: (IR::Grammar grammar, ?starts: Array[String]?) -> void
+
+      # @rbs () -> [Array[core_set], transitions]
+      def build: () -> [ Array[core_set], transitions ]
+
+      # @rbs (Integer index) -> Integer
+      def augmented_production: (Integer index) -> Integer
+
+      # @rbs (Integer production_id) -> Array[Integer]
+      def rhs_for: (Integer production_id) -> Array[Integer]
+
+      # @rbs (Integer production_id) -> Integer
+      def lhs_for: (Integer production_id) -> Integer
+
+      # @rbs (core_set items) -> Hash[Integer, core_set]
+      def shifted_kernels: (core_set items) -> Hash[Integer, core_set]
+
+      private
+
+      # @rbs (core_set seed) -> core_set
+      def closure: (core_set seed) -> core_set
+
+      # @rbs (core_set items) -> Array[Integer]
+      def item_key: (core_set items) -> Array[Integer]
+    end
+  end
+end

data/sig/ibex/lalr/unreachable_states.rbs

@@ -0,0 +1,25 @@
+# Generated from lib/ibex/lalr/unreachable_states.rb with RBS::Inline
+
+module Ibex
+  module LALR
+    # Optional post-resolution compaction.  It is intentionally off by
+    # default because state numbers are part of diagnostics and golden output.
+    module UnreachableStates
+      # @rbs (Array[IR::AutomatonState] states, Array[Integer] start_states) ->
+      #   [Array[IR::AutomatonState], Hash[Integer, Integer]]
+      def self?.remove: (Array[IR::AutomatonState] states, Array[Integer] start_states) -> [ Array[IR::AutomatonState], Hash[Integer, Integer] ]
+
+      # @rbs (Array[IR::AutomatonState], Array[Integer]) -> Array[Integer]
+      def self?.reachable_states: (Array[IR::AutomatonState], Array[Integer]) -> Array[Integer]
+
+      # @rbs (Hash[Integer, Integer], Hash[Integer, Integer]) -> Hash[Integer, Integer]
+      def self?.remap_edges: (Hash[Integer, Integer], Hash[Integer, Integer]) -> Hash[Integer, Integer]
+
+      # @rbs (IR::parser_action?, Hash[Integer, Integer]) -> IR::parser_action?
+      def self?.remap_action: (IR::parser_action?, Hash[Integer, Integer]) -> IR::parser_action?
+
+      # @rbs (IR::conflict, Hash[Integer, Integer]) -> IR::conflict
+      def self?.remap_conflict: (IR::conflict, Hash[Integer, Integer]) -> IR::conflict
+    end
+  end
+end