ibex 0.1.0 → 0.3.0

data/sig/ibex/ir.rbs

@@ -2,15 +2,53 @@
 
 module Ibex
   module IR
+    type serialized_value = untyped
+
     type location = { file: String, line: Integer, column: Integer }
 
     type precedence = { associativity: Symbol, level: Integer }
 
     type named_ref = { name: String, index: Integer }
 
+    type byte_span = { start: Integer, end: Integer }
+
+    type source_provenance = { file: String?, root: String?, byte_span: byte_span? }
+
+    type parser_parameter = { name: String, semantic_type: String? }
+
+    type value_printer = { symbol: String, code: String, loc: location }
+
+    type recovery_policy = { sync_tokens: Array[String], on_error_reduce: Array[Array[String]] }
+
+    type grammar_test = { expectation: :accept | :reject, source: String, loc: location }
+
+    type node_annotation = { name: String, fields: Array[String], loc: location }
+
+    type lexer_warning = { type: :redos, rule: Integer, loc: location }
+
+    type lexer_rule_document_value = Integer | String | Symbol | nil | location
+
+    type lexer_document_value = String | Integer | Array[String] | Array[Hash[Symbol, lexer_rule_document_value]] | Array[lexer_warning] | source_provenance?
+
+    type parameter_expansion = { rule: String, arguments: Array[String] }
+
+    type inline_expansion = { rule: String }
+
+    type production_expansion = { parameter: parameter_expansion?, inline: inline_expansion?, include_chain: Array[source_provenance] }
+
+    type action_fragment = { kind: :rule | :inline, source: source_provenance? }
+
+    type action_composition_step = { kind: :rule | :inline, rule: String?, code: String?, loc: location, named_refs: Array[named_ref], context_length: Integer, inputs: Array[Integer], stack_inputs: Array[Integer], lookahead: Integer?, result_var: bool, result_type: String? }
+
+    type action_composition_plan = { version: Integer, physical: Integer, steps: Array[action_composition_step] }
+
+    type action_composition = { strategy: String, fragments: Array[action_fragment], ?plan: action_composition_plan }
+
     type user_code_chunks = Hash[String, Array[UserCodeChunk]]
 
-    type grammar_options = { result_var: bool, omit_action_call: bool }
+    type grammar_options = { result_var: bool, omit_action_call: bool, ?cst: bool }
+
+    type grammar_mode = :default | :extended
 
     type grammar_warning = { type: Symbol, ?symbol: String, ?production: Integer, ?original: Integer, loc: location? }
 
@@ -28,15 +66,17 @@ module Ibex
 
     type conflict_resolution = { by: Symbol, chose: Symbol | Integer, ?associativity: Symbol }
 
-    type shift_reduce_conflict = { type: :shift_reduce, symbol: String, shift_to: Integer, reduce: Integer, resolution: conflict_resolution }
+    type shift_reduce_conflict = { type: :shift_reduce, symbol: String, shift_to: Integer, reduce: Integer, resolution: conflict_resolution, ?midrule_origins: Array[location], ?entries: Array[String], ?composite: bool }
 
-    type reduce_reduce_conflict = { type: :reduce_reduce, symbol: String, reductions: Array[Integer], resolution: conflict_resolution }
+    type reduce_reduce_conflict = { type: :reduce_reduce, symbol: String, reductions: Array[Integer], resolution: conflict_resolution, ?midrule_origins: Array[location], ?entries: Array[String], ?composite: bool }
 
     type conflict = shift_reduce_conflict | reduce_reduce_conflict
 
-    type conflict_summary = { sr: Integer, resolved_sr: Integer, rr: Integer, expected_sr: Integer, expectation_met: bool }
+    type conflict_summary = { sr: Integer, resolved_sr: Integer, rr: Integer, expected_sr: Integer, expectation_met: bool, ?expected_rr: Integer, ?rr_expectation_met: bool }
+
+    type derivation_node = { symbol: String, ?token: String, ?production: Integer, ?children: Array[derivation_node] }
 
-    type interpretation = Hash[Symbol, untyped]
+    type interpretation = { kind: Symbol, tree: derivation_node?, ?state: Integer, ?production: Integer }
 
     type counterexample = { state: Integer, type: Symbol, symbol_path: Array[String], sentence: Array[String], lookahead_index: Integer, unifying: bool, interpretations: Array[interpretation] }
   end

data/sig/ibex/lalr/build_metrics.rbs

@@ -0,0 +1,60 @@
+# Generated from lib/ibex/lalr/build_metrics.rb with RBS::Inline
+
+module Ibex
+  module LALR
+    # Optional measurements are kept explicit for schema stability.
+    # rubocop:disable Metrics/ParameterLists
+    # Immutable structural measurements from one automaton build. These counts
+    # are intended for diagnostics and benchmarks, not parser behavior.
+    class BuildMetrics
+      attr_reader construction_states: Integer
+
+      attr_reader canonical_states: Integer?
+
+      attr_reader final_states: Integer
+
+      attr_reader strategy: Symbol
+
+      attr_reader lr0_states: Integer?
+
+      attr_reader lr0_items: Integer?
+
+      attr_reader canonical_items: Integer?
+
+      attr_reader final_items: Integer?
+
+      attr_reader final_lookahead_items: Integer?
+
+      attr_reader propagation_edges: Integer?
+
+      attr_reader ielr_initial_partitions: Integer?
+
+      attr_reader ielr_final_partitions: Integer?
+
+      attr_reader ielr_annotations: Integer?
+
+      attr_reader ielr_annotated_states: Integer?
+
+      attr_reader ielr_inadequacies: Integer?
+
+      attr_reader ielr_split_stable_discarded: Integer?
+
+      attr_reader ielr_lalr_states: Integer?
+
+      attr_reader ielr_split_states: Integer?
+
+      attr_reader ielr_unreachable_removed: Integer?
+
+      attr_reader ielr_remergeable_candidates: Integer?
+
+      # @rbs (construction_states: Integer, canonical_states: Integer?, final_states: Integer, strategy: Symbol,
+      #   ?lr0_states: Integer?, ?lr0_items: Integer?, ?canonical_items: Integer?, ?final_items: Integer?,
+      #   ?final_lookahead_items: Integer?, ?propagation_edges: Integer?, ?ielr_initial_partitions: Integer?,
+      #   ?ielr_final_partitions: Integer?, ?ielr_annotations: Integer?, ?ielr_annotated_states: Integer?,
+      #   ?ielr_inadequacies: Integer?, ?ielr_split_stable_discarded: Integer?, ?ielr_lalr_states: Integer?,
+      #   ?ielr_split_states: Integer?, ?ielr_unreachable_removed: Integer?,
+      #   ?ielr_remergeable_candidates: Integer?) -> void
+      def initialize: (construction_states: Integer, canonical_states: Integer?, final_states: Integer, strategy: Symbol, ?lr0_states: Integer?, ?lr0_items: Integer?, ?canonical_items: Integer?, ?final_items: Integer?, ?final_lookahead_items: Integer?, ?propagation_edges: Integer?, ?ielr_initial_partitions: Integer?, ?ielr_final_partitions: Integer?, ?ielr_annotations: Integer?, ?ielr_annotated_states: Integer?, ?ielr_inadequacies: Integer?, ?ielr_split_stable_discarded: Integer?, ?ielr_lalr_states: Integer?, ?ielr_split_states: Integer?, ?ielr_unreachable_removed: Integer?, ?ielr_remergeable_candidates: Integer?) -> void
+    end
+  end
+end

data/sig/ibex/lalr/builder.rbs

@@ -2,30 +2,100 @@
 
 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: Integer
 
       ALGORITHMS: Array[Symbol]
 
-      @resolver: ConflictResolver
+      LALR_STRATEGIES: Array[Symbol]
 
-      @productions_by_lhs: Hash[Integer, Array[IR::Production]]
+      IELR_STRATEGIES: Array[Symbol]
 
-      @sets: Analysis::Sets
+      @grammar: IR::Grammar
 
       @algorithm: Symbol
 
-      @grammar: IR::Grammar
+      @lalr_strategy: Symbol
+
+      @ielr_strategy: Symbol
+
+      @sets: Analysis::Sets
+
+      @productions_by_lhs: Hash[Integer, Array[IR::Production]]
+
+      @resolver: ConflictResolver
+
+      @metrics: BuildMetrics?
+
+      @start_names: Array[String]
+
+      @entry_isolation: bool
+
+      @attribute_entries: bool
 
-      # @rbs (IR::Grammar grammar, ?algorithm: Symbol | String) -> void
-      def initialize: (IR::Grammar grammar, ?algorithm: Symbol | String) -> void
+      @profile: bool
+
+      @remove_unreachable: bool
+
+      @canonical_suffix_lookahead_cache: Hash[Integer, Hash[Integer, Hash[Integer, Array[Integer]]]]
+
+      @canonical_item_cache: Hash[Integer, Array[Array[lr_item?]?]]?
+
+      @canonical_key_radices: [ Integer, Integer, Integer ]?
+
+      attr_reader metrics: BuildMetrics?
+
+      # @rbs (IR::Grammar grammar, ?algorithm: Symbol | String, ?lalr_strategy: Symbol | String,
+      #   ?ielr_strategy: Symbol | String,
+      #   ?entry_isolation: bool, ?starts: Array[String]?, ?attribute_entries: bool, ?profile: bool,
+      #   ?remove_unreachable: bool) -> void
+      def initialize: (IR::Grammar grammar, ?algorithm: Symbol | String, ?lalr_strategy: Symbol | String, ?ielr_strategy: Symbol | String, ?entry_isolation: bool, ?starts: Array[String]?, ?attribute_entries: bool, ?profile: bool, ?remove_unreachable: bool) -> void
 
       # @rbs () -> IR::Automaton
       def build: () -> IR::Automaton
 
       private
 
+      # @rbs (states: Array[IR::AutomatonState], conflict_summary: IR::conflict_summary,
+      #   entry_states: Hash[String, Integer]) -> IR::Automaton
+      def build_output_automaton: (states: Array[IR::AutomatonState], conflict_summary: IR::conflict_summary, entry_states: Hash[String, Integer]) -> IR::Automaton
+
+      # @rbs (Array[IR::AutomatonState] states) -> IR::conflict_summary
+      def conflict_summary: (Array[IR::AutomatonState] states) -> IR::conflict_summary
+
+      # @rbs () -> [Array[packed_items], transitions, build_collection]
+      def automaton_collection: () -> [ Array[packed_items], transitions, build_collection ]
+
+      # @rbs () -> [Array[packed_items], transitions, build_collection]
+      def ielr_collection: () -> [ Array[packed_items], transitions, build_collection ]
+
+      # @rbs () -> [Array[packed_items], transitions, build_collection]
+      def ielr_direct_collection: () -> [ Array[packed_items], transitions, build_collection ]
+
+      # @rbs () -> [Array[packed_items], transitions, build_collection]
+      def canonical_lr1_collection: () -> [ Array[packed_items], transitions, build_collection ]
+
+      # @rbs (Symbol strategy) -> [Array[packed_items], transitions, build_collection]
+      def merged_canonical_collection: (Symbol strategy) -> [ Array[packed_items], transitions, build_collection ]
+
+      # @rbs () -> untyped
+      def direct_collection: () -> untyped
+
+      # @rbs (Array[item_set] states, strategy: Symbol) -> build_collection
+      def canonical_profile: (Array[item_set] states, strategy: Symbol) -> build_collection
+
+      # @rbs (Array[packed_items] items) -> [Integer?, Integer?]
+      def profiled_final_item_counts: (Array[packed_items] items) -> [ Integer?, Integer? ]
+
+      # @rbs (build_collection collection, Integer final_states, Integer? final_items,
+      #   Integer? final_lookahead_items) -> BuildMetrics
+      def build_metrics: (build_collection collection, Integer final_states, Integer? final_items, Integer? final_lookahead_items) -> BuildMetrics
+
+      # @rbs () -> String
+      def algorithm_name: () -> String
+
       # @rbs () -> [Array[item_set], transitions]
       def canonical_collection: () -> [ Array[item_set], transitions ]
 
@@ -35,21 +105,21 @@ module Ibex
       # @rbs (Array[Integer] suffix, Integer inherited) -> Array[Integer]
       def suffix_lookaheads: (Array[Integer] suffix, Integer inherited) -> Array[Integer]
 
+      # @rbs (Integer production_id, Integer dot, Integer inherited) -> Array[Integer]
+      def canonical_suffix_lookaheads: (Integer production_id, Integer dot, Integer inherited) -> Array[Integer]
+
+      # @rbs (Integer production_id, Integer dot, Integer lookahead) -> lr_item
+      def canonical_item: (Integer production_id, Integer dot, Integer lookahead) -> lr_item
+
       # @rbs (item_set items, Array[lr_item] queue, lr_item item) -> void
       def enqueue_item: (item_set items, Array[lr_item] queue, lr_item item) -> void
 
-      # @rbs (item_set items) -> Array[Integer]
-      def next_symbols: (item_set items) -> Array[Integer]
-
-      # @rbs (item_set items, Integer symbol_id) -> item_set
-      def go_to: (item_set items, Integer symbol_id) -> item_set
+      # @rbs (item_set items) -> Hash[Integer, item_set]
+      def shifted_kernels: (item_set items) -> Hash[Integer, item_set]
 
       # @rbs (Array[item_set] states, transitions transitions) -> [Array[packed_items], transitions]
       def merge_lalr: (Array[item_set] states, transitions transitions) -> [ Array[packed_items], transitions ]
 
-      # @rbs (Array[item_set] canonical_states, transitions canonical_transitions) -> [Array[packed_items], transitions]
-      def automaton_items: (Array[item_set] canonical_states, transitions canonical_transitions) -> [ Array[packed_items], transitions ]
-
       # @rbs (Array[item_set] states) -> Array[packed_items]
       def pack_canonical_items: (Array[item_set] states) -> Array[packed_items]
 
@@ -65,6 +135,11 @@ module Ibex
       # @rbs (Integer state_id, Array[IR::AutomatonItem] items, Hash[Integer, Integer] transitions) -> IR::AutomatonState
       def build_state: (Integer state_id, Array[IR::AutomatonItem] items, Hash[Integer, Integer] transitions) -> IR::AutomatonState
 
+      # Conflict hashes are produced locally immediately before this boundary.
+      # Both conflict variants carry the same optional midrule provenance field.
+      # @rbs (IR::conflict conflict) -> IR::conflict
+      def attribute_midrule_conflict: (IR::conflict conflict) -> IR::conflict
+
       # @rbs (Array[IR::AutomatonItem] items, Hash[Integer, Array[IR::parser_action]] candidates) -> void
       def add_completed_actions: (Array[IR::AutomatonItem] items, Hash[Integer, Array[IR::parser_action]] candidates) -> void
 
@@ -75,11 +150,67 @@ module Ibex
       # @rbs (Integer production_id) -> Array[Integer]
       def rhs_for: (Integer production_id) -> Array[Integer]
 
-      # @rbs (item_set items) -> Array[item_core]
-      def core_key: (item_set items) -> Array[item_core]
+      # @rbs () -> [Integer, Integer, Integer]
+      def canonical_key_radices: () -> [ Integer, Integer, Integer ]
+
+      # @rbs (item_set items) -> Array[Integer]
+      def core_key: (item_set items) -> Array[Integer]
+
+      # @rbs (item_set items) -> Array[Integer]
+      def item_key: (item_set items) -> Array[Integer]
+
+      # @rbs (String name) -> Integer
+      def augmented_production: (String name) -> Integer
+
+      # @rbs (Integer production_id) -> String
+      def start_name_for_augmented: (Integer production_id) -> String
+
+      # @rbs (Array[packed_items] items) -> Hash[String, Integer]
+      def entry_states_for: (Array[packed_items] items) -> Hash[String, Integer]
+
+      # @rbs () -> IR::Automaton
+      def build_isolated_automaton: () -> IR::Automaton
+
+      # @rbs (Array[[String, IR::Automaton, BuildMetrics]] entries, Integer construction_states,
+      #   Integer? canonical_states, Integer final_states) -> BuildMetrics
+      def isolated_metrics: (Array[[ String, IR::Automaton, BuildMetrics ]] entries, Integer construction_states, Integer? canonical_states, Integer final_states) -> BuildMetrics
+
+      # @rbs (Array[[String, IR::Automaton, BuildMetrics]] entries, Symbol method) -> Integer?
+      def sum_optional_metric: (Array[[ String, IR::Automaton, BuildMetrics ]] entries, Symbol method) -> Integer?
+
+      # @rbs () -> Integer
+      def output_schema_version: () -> Integer
+
+      # @rbs () -> String?
+      def output_entry_construction: () -> String?
+
+      # @rbs (String name) -> [String, IR::Automaton, BuildMetrics]
+      def isolated_entry: (String name) -> [ String, IR::Automaton, BuildMetrics ]
+
+      # @rbs (IR::AutomatonState state, Integer offset, String entry) -> IR::AutomatonState
+      def offset_state: (IR::AutomatonState state, Integer offset, String entry) -> IR::AutomatonState
+
+      # @rbs (IR::parser_action action, Integer offset) -> IR::parser_action
+      def offset_action: (IR::parser_action action, Integer offset) -> IR::parser_action
+
+      # @rbs (IR::parser_action? action, Integer offset) -> IR::parser_action?
+      def offset_default_action: (IR::parser_action? action, Integer offset) -> IR::parser_action?
+
+      # @rbs (IR::conflict conflict, Integer offset, String entry) -> IR::conflict
+      def offset_conflict: (IR::conflict conflict, Integer offset, String entry) -> IR::conflict
+
+      # @rbs (Array[IR::AutomatonState] states, Hash[String, Integer] entry_states) ->
+      #   Array[IR::AutomatonState]
+      def attribute_entry_conflicts: (Array[IR::AutomatonState] states, Hash[String, Integer] entry_states) -> Array[IR::AutomatonState]
+
+      # @rbs (Array[IR::AutomatonState] states, Hash[String, Integer] entry_states) -> Array[Array[String]]
+      def entry_reachability: (Array[IR::AutomatonState] states, Hash[String, Integer] entry_states) -> Array[Array[String]]
+
+      # @rbs () -> Set[conflict_fingerprint]
+      def isolated_conflict_fingerprints: () -> Set[conflict_fingerprint]
 
-      # @rbs (item_set items) -> Array[lr_item]
-      def item_key: (item_set items) -> Array[lr_item]
+      # @rbs (IR::conflict conflict) -> conflict_fingerprint
+      def conflict_fingerprint: (IR::conflict conflict) -> conflict_fingerprint
     end
   end
 end

data/sig/ibex/lalr/conflict_search.rbs

@@ -20,6 +20,8 @@ module Ibex
                     | ({ ?states: Array[Integer], ?nodes: Array[derivation_node] }) -> instance
       end
 
+      @initial_state: Integer
+
       @input_tokens: Array[Integer]
 
       @explored: Integer
@@ -38,15 +40,23 @@ module Ibex
 
       @automaton: IR::Automaton
 
+      attr_reader explored: Integer
+
       # @rbs (IR::Automaton automaton, IR::AutomatonState state, IR::conflict conflict,
       #   ?max_tokens: Integer, ?max_configurations: Integer) -> void
       def initialize: (IR::Automaton automaton, IR::AutomatonState state, IR::conflict conflict, ?max_tokens: Integer, ?max_configurations: Integer) -> void
 
-      # @rbs () -> search_result?
-      def call: () -> search_result?
+      # @rbs () -> search_outcome
+      def call: () -> search_outcome
+
+      # @rbs () -> bool
+      def exhausted?: () -> bool
 
       private
 
+      # @rbs (:found | :not_found | :exhausted status, ?search_result? result) -> search_outcome
+      def outcome: (:found | :not_found | :exhausted status, ?search_result? result) -> search_outcome
+
       # @rbs (Configuration current) -> Array[Configuration]
       def conflict_configurations: (Configuration current) -> Array[Configuration]
 
@@ -123,9 +133,6 @@ module Ibex
 
       # @rbs () -> Integer
       def count_configuration: () -> Integer
-
-      # @rbs () -> bool
-      def exhausted?: () -> bool
     end
   end
 end

data/sig/ibex/lalr/counterexample.rbs

@@ -11,22 +11,26 @@ module Ibex
       # @rbs (IR::Automaton automaton, ?max_tokens: Integer, ?max_configurations: Integer) -> void
       def initialize: (IR::Automaton automaton, ?max_tokens: Integer, ?max_configurations: Integer) -> void
 
-      # @rbs () -> Array[IR::counterexample]
-      def all: () -> Array[IR::counterexample]
+      # @rbs () -> Array[search_counterexample]
+      def all: () -> Array[search_counterexample]
+
+      # @rbs (Integer state_id, Integer conflict_index) -> search_counterexample
+      def for_conflict: (Integer state_id, Integer conflict_index) -> search_counterexample
 
       private
 
-      # @rbs (IR::AutomatonState state, IR::conflict conflict) -> IR::counterexample
-      def build_example: (IR::AutomatonState state, IR::conflict conflict) -> IR::counterexample
+      # @rbs (IR::AutomatonState state, IR::conflict conflict) -> search_counterexample
+      def build_example: (IR::AutomatonState state, IR::conflict conflict) -> search_counterexample
 
-      # @rbs (IR::AutomatonState state, IR::conflict conflict, Hash[Symbol, untyped] result) -> IR::counterexample
-      def unifying_example: (IR::AutomatonState state, IR::conflict conflict, Hash[Symbol, untyped] result) -> IR::counterexample
+      # @rbs (IR::AutomatonState state, IR::conflict conflict, search_outcome outcome,
+      #   search_result result) -> search_counterexample
+      def unifying_example: (IR::AutomatonState state, IR::conflict conflict, search_outcome outcome, search_result result) -> search_counterexample
 
-      # @rbs (IR::AutomatonState state, IR::conflict conflict) -> IR::counterexample
-      def reachability_example: (IR::AutomatonState state, IR::conflict conflict) -> IR::counterexample
+      # @rbs (IR::AutomatonState state, IR::conflict conflict, search_outcome outcome) -> search_counterexample
+      def reachability_example: (IR::AutomatonState state, IR::conflict conflict, search_outcome outcome) -> search_counterexample
 
-      # @rbs (Integer target) -> Array[Integer]
-      def shortest_state_path: (Integer target) -> Array[Integer]
+      # @rbs (Integer target, IR::conflict conflict) -> Array[Integer]
+      def shortest_state_path: (Integer target, IR::conflict conflict) -> Array[Integer]
 
       # @rbs () -> Hash[Integer, Array[Integer]]
       def compute_shortest_yields: () -> Hash[Integer, Array[Integer]]
@@ -37,11 +41,13 @@ module Ibex
       # @rbs (IR::conflict conflict) -> Array[IR::interpretation]
       def interpretations: (IR::conflict conflict) -> Array[IR::interpretation]
 
-      # @rbs (IR::shift_reduce_conflict conflict) -> IR::interpretation
-      def shift_interpretation: (IR::shift_reduce_conflict conflict) -> IR::interpretation
+      # The compact counterexample tree intentionally uses a lightweight shape
+      # whose children are symbol names rather than recursively expanded nodes.
+      # @rbs (IR::shift_reduce_conflict conflict) -> untyped
+      def shift_interpretation: (IR::shift_reduce_conflict conflict) -> untyped
 
-      # @rbs (Integer production_id) -> IR::interpretation
-      def reduce_interpretation: (Integer production_id) -> IR::interpretation
+      # @rbs (Integer production_id) -> untyped
+      def reduce_interpretation: (Integer production_id) -> untyped
 
       # @rbs (Array[Integer] symbol_ids) -> Array[String]
       def names: (Array[Integer] symbol_ids) -> Array[String]

data/sig/ibex/lalr/direct_lookaheads.rbs

@@ -0,0 +1,93 @@
+# Generated from lib/ibex/lalr/direct_lookaheads.rb with RBS::Inline
+
+module Ibex
+  module LALR
+    # Builds an LR(0) collection and propagates LALR(1) lookaheads directly
+    # over item occurrences. Canonical LR(1) states are never materialized.
+    class DirectLookaheads
+      AUGMENTED_PRODUCTION: Integer
+
+      EMPTY_PRODUCTIONS: Array[IR::Production]
+
+      EMPTY_NODES: Array[Integer]
+
+      attr_reader lr0_state_count: Integer?
+
+      attr_reader lr0_item_count: Integer?
+
+      attr_reader propagation_edge_count: Integer?
+
+      attr_reader states: Array[core_set]
+
+      attr_reader transitions: transitions
+
+      # @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 ]
+
+      # @rbs (core_set seed) -> core_set
+      def closure: (core_set seed) -> core_set
+
+      # @rbs (core_set items) -> Hash[Integer, core_set]
+      def shifted_kernels: (core_set items) -> Hash[Integer, core_set]
+
+      # @rbs (Array[core_set] states) -> Array[packed_items]
+      def empty_lookaheads: (Array[core_set] states) -> Array[packed_items]
+
+      # @rbs (Array[core_set] states, transitions transitions, Array[packed_items] lookaheads) ->
+      #   Hash[Integer, Array[Integer]]
+      def propagation_graph: (Array[core_set] states, transitions transitions, Array[packed_items] lookaheads) -> Hash[Integer, Array[Integer]]
+
+      # @rbs (Hash[Integer, Array[Integer]] 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[Integer, Array[Integer]] 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, Integer node) -> Set[Integer]
+      def node_set: (Array[packed_items] lookaheads, Integer 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]
+
+      # @rbs (Integer production_id) -> Array[Integer]
+      def rhs_for: (Integer production_id) -> Array[Integer]
+
+      # @rbs (Integer production_id, Integer rhs_length) -> Array[item_core]
+      def item_cores_for: (Integer production_id, Integer rhs_length) -> Array[item_core]
+
+      # @rbs (Integer production_id, Integer dot) -> item_core
+      def item_core: (Integer production_id, Integer dot) -> 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