ibex 0.1.0

data/sig/ibex/lalr/builder.rbs

@@ -0,0 +1,85 @@
+# Generated from lib/ibex/lalr/builder.rb with RBS::Inline
+
+module Ibex
+  module LALR
+    # Builds canonical LR(1) states and merges states with equal LR(0) cores.
+    class Builder
+      AUGMENTED_PRODUCTION: Integer
+
+      ALGORITHMS: Array[Symbol]
+
+      @resolver: ConflictResolver
+
+      @productions_by_lhs: Hash[Integer, Array[IR::Production]]
+
+      @sets: Analysis::Sets
+
+      @algorithm: Symbol
+
+      @grammar: IR::Grammar
+
+      # @rbs (IR::Grammar grammar, ?algorithm: Symbol | String) -> void
+      def initialize: (IR::Grammar grammar, ?algorithm: Symbol | String) -> void
+
+      # @rbs () -> IR::Automaton
+      def build: () -> IR::Automaton
+
+      private
+
+      # @rbs () -> [Array[item_set], transitions]
+      def canonical_collection: () -> [ Array[item_set], transitions ]
+
+      # @rbs (item_set seed) -> item_set
+      def closure: (item_set seed) -> item_set
+
+      # @rbs (Array[Integer] suffix, Integer inherited) -> Array[Integer]
+      def suffix_lookaheads: (Array[Integer] suffix, Integer inherited) -> Array[Integer]
+
+      # @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 (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]
+
+      # @rbs (Array[packed_items] states) -> void
+      def apply_slr_lookaheads: (Array[packed_items] states) -> void
+
+      # @rbs (Integer production_id) -> Array[Integer]
+      def slr_lookaheads: (Integer production_id) -> Array[Integer]
+
+      # @rbs (Array[packed_items] merged_items, transitions transitions) -> Array[IR::AutomatonState]
+      def build_states: (Array[packed_items] merged_items, transitions transitions) -> Array[IR::AutomatonState]
+
+      # @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
+
+      # @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
+
+      # @rbs (Hash[Integer, Array[IR::parser_action]] candidates) ->
+      #   [Hash[Integer, IR::parser_action], Array[IR::conflict]]
+      def resolve_actions: (Hash[Integer, Array[IR::parser_action]] candidates) -> [ Hash[Integer, IR::parser_action], Array[IR::conflict] ]
+
+      # @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 (item_set items) -> Array[lr_item]
+      def item_key: (item_set items) -> Array[lr_item]
+    end
+  end
+end

data/sig/ibex/lalr/conflict.rbs

@@ -0,0 +1,47 @@
+# Generated from lib/ibex/lalr/conflict.rb with RBS::Inline
+
+module Ibex
+  module LALR
+    # Applies yacc-compatible precedence and ordering rules to action candidates.
+    class ConflictResolver
+      # @rbs (IR::Grammar grammar) -> void
+      def initialize: (IR::Grammar grammar) -> void
+
+      # @rbs (Integer token_id, Array[IR::parser_action] candidates) -> [IR::parser_action?, Array[IR::conflict]]
+      def resolve: (Integer token_id, Array[IR::parser_action] candidates) -> [ IR::parser_action?, Array[IR::conflict] ]
+
+      private
+
+      # @rbs (Array[IR::parser_action] actions) -> Array[IR::reduce_action]
+      def reduction_actions: (Array[IR::parser_action] actions) -> Array[IR::reduce_action]
+
+      # @rbs (Array[IR::reduce_reduce_conflict] conflicts) -> Array[IR::conflict]
+      def widen_conflicts: (Array[IR::reduce_reduce_conflict] conflicts) -> Array[IR::conflict]
+
+      # @rbs (Integer token_id, Array[IR::reduce_action] reductions) ->
+      #   [IR::reduce_action?, Array[IR::reduce_reduce_conflict]]
+      def resolve_reductions: (Integer token_id, Array[IR::reduce_action] reductions) -> [ IR::reduce_action?, Array[IR::reduce_reduce_conflict] ]
+
+      # @rbs (Integer token_id, IR::shift_action shift, IR::reduce_action reduction) ->
+      #   [IR::parser_action, IR::shift_reduce_conflict]
+      def resolve_shift_reduce: (Integer token_id, IR::shift_action shift, IR::reduce_action reduction) -> [ IR::parser_action, IR::shift_reduce_conflict ]
+
+      # @rbs (IR::shift_action shift, IR::reduce_action reduction, IR::precedence? token_precedence,
+      #   IR::precedence? production_precedence) -> [IR::parser_action, IR::conflict_resolution]
+      def precedence_choice: (IR::shift_action shift, IR::reduce_action reduction, IR::precedence? token_precedence, IR::precedence? production_precedence) -> [ IR::parser_action, IR::conflict_resolution ]
+
+      # @rbs (IR::shift_action shift, IR::reduce_action reduction, Symbol associativity) ->
+      #   [IR::parser_action, IR::conflict_resolution]
+      def associativity_choice: (IR::shift_action shift, IR::reduce_action reduction, Symbol associativity) -> [ IR::parser_action, IR::conflict_resolution ]
+
+      # @rbs (Integer production_id) -> IR::precedence?
+      def precedence_for_production: (Integer production_id) -> IR::precedence?
+
+      # @rbs (Integer token_id) -> String
+      def token_name: (Integer token_id) -> String
+
+      # @rbs (Integer id) -> IR::GrammarSymbol
+      def required_symbol_by_id: (Integer id) -> IR::GrammarSymbol
+    end
+  end
+end

data/sig/ibex/lalr/conflict_search.rbs

@@ -0,0 +1,131 @@
+# Generated from lib/ibex/lalr/conflict_search.rb with RBS::Inline
+
+module Ibex
+  module LALR
+    # Searches the parser state space for one input accepted through both sides of a conflict.
+    # rubocop:disable Metrics/ClassLength -- inline type contracts make the focused search implementation longer.
+    class ConflictSearch
+      include ConflictSearchLimits
+
+      DEFAULT_MAX_TOKENS: Integer
+
+      DEFAULT_MAX_CONFIGURATIONS: Integer
+
+      class Configuration < Struct[Array[Integer] | Array[derivation_node]]
+        attr_accessor states(): Array[Integer]
+
+        attr_accessor nodes(): Array[derivation_node]
+
+        def self.new: (?states: Array[Integer], ?nodes: Array[derivation_node]) -> instance
+                    | ({ ?states: Array[Integer], ?nodes: Array[derivation_node] }) -> instance
+      end
+
+      @input_tokens: Array[Integer]
+
+      @explored: Integer
+
+      @max_configurations: Integer
+
+      @max_tokens: Integer
+
+      @lookahead: Integer?
+
+      @conflict: IR::conflict
+
+      @state: IR::AutomatonState
+
+      @grammar: IR::Grammar
+
+      @automaton: IR::Automaton
+
+      # @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?
+
+      private
+
+      # @rbs (Configuration current) -> Array[Configuration]
+      def conflict_configurations: (Configuration current) -> Array[Configuration]
+
+      # @rbs (Array[[Configuration, Array[Integer]]] queue, Hash[Array[Integer], bool] visited,
+      #   Configuration current, Array[Integer] prefix) -> void
+      def enqueue_prefixes: (Array[[ Configuration, Array[Integer] ]] queue, Hash[Array[Integer], bool] visited, Configuration current, Array[Integer] prefix) -> void
+
+      # @rbs (Configuration current, Array[Integer] prefix) -> search_result?
+      def unify_from: (Configuration current, Array[Integer] prefix) -> search_result?
+
+      # @rbs (search_entry left, search_entry right, Array[Integer] prefix, IR::parser_action left_action,
+      #   IR::parser_action right_action) -> search_result?
+      def search_common_suffix: (search_entry left, search_entry right, Array[Integer] prefix, IR::parser_action left_action, IR::parser_action right_action) -> search_result?
+
+      # @rbs (Configuration left_config, Configuration right_config) -> [search_entry, search_entry]?
+      def accept_with_eof: (Configuration left_config, Configuration right_config) -> [ search_entry, search_entry ]?
+
+      # @rbs (Array[[Configuration, Configuration, Array[Integer]]] queue,
+      #   Hash[[Array[Integer], Array[Integer]], bool] visited, Configuration left_config,
+      #   Configuration right_config, Array[Integer] suffix) -> void
+      def enqueue_suffixes: (Array[[ Configuration, Configuration, Array[Integer] ]] queue, Hash[[ Array[Integer], Array[Integer] ], bool] visited, Configuration left_config, Configuration right_config, Array[Integer] suffix) -> void
+
+      # @rbs (Configuration current, Integer token_id) -> Array[Configuration]
+      def shifted_results: (Configuration current, Integer token_id) -> Array[Configuration]
+
+      # @rbs (Array[Integer] prefix, Array[Integer] suffix, search_entry left, search_entry right,
+      #   IR::parser_action left_action, IR::parser_action right_action) -> search_result?
+      def accepted_result: (Array[Integer] prefix, Array[Integer] suffix, search_entry left, search_entry right, IR::parser_action left_action, IR::parser_action right_action) -> search_result?
+
+      # @rbs (IR::parser_action action, Configuration current) -> IR::interpretation
+      def interpretation: (IR::parser_action action, Configuration current) -> IR::interpretation
+
+      # @rbs (search_entry left, search_entry right) -> bool
+      def accepted_pair?: (search_entry left, search_entry right) -> bool
+
+      # @rbs (search_entry left, search_entry right) -> bool
+      def shifted_pair?: (search_entry left, search_entry right) -> bool
+
+      # @rbs () -> Array[IR::parser_action]
+      def conflict_actions: () -> Array[IR::parser_action]
+
+      # @rbs (Configuration initial, Integer token_id, ?forced_action: IR::parser_action?, ?stop_at: Integer?,
+      #   ?branch_conflicts: bool) -> Array[search_entry]
+      def advance: (Configuration initial, Integer token_id, ?forced_action: IR::parser_action?, ?stop_at: Integer?, ?branch_conflicts: bool) -> Array[search_entry]
+
+      # @rbs (Integer state_id, Integer token_id, IR::parser_action? forced, bool branch_conflicts) ->
+      #   Array[IR::parser_action]
+      def actions_for: (Integer state_id, Integer token_id, IR::parser_action? forced, bool branch_conflicts) -> Array[IR::parser_action]
+
+      # @rbs (IR::conflict conflict) -> Array[IR::parser_action]
+      def actions_from: (IR::conflict conflict) -> Array[IR::parser_action]
+
+      # @rbs (Array[search_entry] results, Array[[Configuration, IR::parser_action?]] queue,
+      #   Configuration current, IR::parser_action action, Integer token_id) -> void
+      def apply_action: (Array[search_entry] results, Array[[ Configuration, IR::parser_action? ]] queue, Configuration current, IR::parser_action action, Integer token_id) -> void
+
+      # @rbs (Configuration current, Integer state_id, Integer token_id) -> Configuration
+      def shift: (Configuration current, Integer state_id, Integer token_id) -> Configuration
+
+      # @rbs (Configuration current, Integer production_id) -> Configuration?
+      def reduce: (Configuration current, Integer production_id) -> Configuration?
+
+      # @rbs (Array[Integer] states, Array[derivation_node] nodes) -> Configuration
+      def configuration: (Array[Integer] states, Array[derivation_node] nodes) -> Configuration
+
+      # @rbs () -> Integer
+      def required_lookahead: () -> Integer
+
+      # @rbs (Integer id) -> String
+      def symbol_name: (Integer id) -> String
+
+      # @rbs (Configuration left, Configuration right) -> [Array[Integer], Array[Integer]]
+      def pair_key: (Configuration left, Configuration right) -> [ Array[Integer], Array[Integer] ]
+
+      # @rbs () -> Integer
+      def count_configuration: () -> Integer
+
+      # @rbs () -> bool
+      def exhausted?: () -> bool
+    end
+  end
+end

data/sig/ibex/lalr/conflict_search_limits.rbs

@@ -0,0 +1,29 @@
+# Generated from lib/ibex/lalr/conflict_search_limits.rb with RBS::Inline
+
+module Ibex
+  module LALR
+    # Validates search limits and measures sentences against the token budget.
+    module ConflictSearchLimits
+      DEFAULT_MAX_TOKENS: Integer
+
+      DEFAULT_MAX_CONFIGURATIONS: Integer
+
+      # @rbs (max_tokens: Integer, max_configurations: Integer) -> void
+      def self.validate!: (max_tokens: Integer, max_configurations: Integer) -> void
+
+      # @rbs (Symbol name, Integer value) -> Integer
+      def self.validate_limit!: (Symbol name, Integer value) -> Integer
+
+      private
+
+      # @rbs (Array[Integer] prefix, Array[Integer] suffix) -> bool
+      def within_token_budget?: (Array[Integer] prefix, Array[Integer] suffix) -> bool
+
+      # @rbs (Array[Integer] prefix, Array[Integer] suffix) -> bool
+      def room_for_token?: (Array[Integer] prefix, Array[Integer] suffix) -> bool
+
+      # @rbs () -> Integer
+      def conflict_lookahead_length: () -> Integer
+    end
+  end
+end

data/sig/ibex/lalr/counterexample.rbs

@@ -0,0 +1,53 @@
+# Generated from lib/ibex/lalr/counterexample.rb with RBS::Inline
+
+module Ibex
+  module LALR
+    # Produces shortest-path conflict witnesses using Automaton IR only.
+    class Counterexample
+      DEFAULT_MAX_TOKENS: Integer
+
+      DEFAULT_MAX_CONFIGURATIONS: Integer
+
+      # @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]
+
+      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, 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) -> IR::counterexample
+      def reachability_example: (IR::AutomatonState state, IR::conflict conflict) -> IR::counterexample
+
+      # @rbs (Integer target) -> Array[Integer]
+      def shortest_state_path: (Integer target) -> Array[Integer]
+
+      # @rbs () -> Hash[Integer, Array[Integer]]
+      def compute_shortest_yields: () -> Hash[Integer, Array[Integer]]
+
+      # @rbs (Array[Integer] candidate, Array[Integer]? current) -> bool
+      def better_yield?: (Array[Integer] candidate, Array[Integer]? current) -> bool
+
+      # @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
+
+      # @rbs (Integer production_id) -> IR::interpretation
+      def reduce_interpretation: (Integer production_id) -> IR::interpretation
+
+      # @rbs (Array[Integer] symbol_ids) -> Array[String]
+      def names: (Array[Integer] symbol_ids) -> Array[String]
+
+      # @rbs (Integer id) -> String
+      def symbol_name: (Integer id) -> String
+    end
+  end
+end

data/sig/ibex/lalr/default_reductions.rbs

@@ -0,0 +1,20 @@
+# Generated from lib/ibex/lalr/default_reductions.rb with RBS::Inline
+
+module Ibex
+  module LALR
+    # Selects size-reducing default actions without changing any terminal cell.
+    module DefaultReductions
+      private def select_default: (Hash[Integer, IR::parser_action] actions, Array[Integer] terminal_ids) -> IR::parser_action?
+
+      private def self.select_default: (Hash[Integer, IR::parser_action] actions, Array[Integer] terminal_ids) -> IR::parser_action?
+
+      ERROR_ACTION: IR::error_action
+
+      # @rbs (Array[IR::AutomatonState] states, terminal_ids: Array[Integer]) -> Array[IR::AutomatonState]
+      def self?.apply: (Array[IR::AutomatonState] states, terminal_ids: Array[Integer]) -> Array[IR::AutomatonState]
+
+      # @rbs (IR::AutomatonState state, terminal_ids: Array[Integer]) -> IR::AutomatonState
+      def self?.optimize: (IR::AutomatonState state, terminal_ids: Array[Integer]) -> IR::AutomatonState
+    end
+  end
+end

data/sig/ibex/lalr.rbs

@@ -0,0 +1,23 @@
+# Generated from lib/ibex/lalr.rb with RBS::Inline
+
+module Ibex
+  module LALR
+    type lr_item = [ Integer, Integer, Integer ]
+
+    type item_core = [ Integer, Integer ]
+
+    type item_set = Set[lr_item]
+
+    type packed_items = Hash[item_core, Set[Integer]]
+
+    type transitions = Array[Hash[Integer, Integer]]
+
+    type derivation_node = Hash[Symbol, untyped]
+
+    type search_status = :conflict | :shifted | :accepted
+
+    type search_entry = [ search_status, ConflictSearch::Configuration ]
+
+    type search_result = { sentence_ids: Array[Integer], lookahead_index: Integer, interpretations: Array[IR::interpretation] }
+  end
+end

data/sig/ibex/normalize/declarations.rbs

@@ -0,0 +1,20 @@
+# Generated from lib/ibex/normalize/declarations.rb with RBS::Inline
+
+module Ibex
+  # Declaration extraction used by Normalizer.
+  module NormalizeDeclarations
+    private
+
+    # @rbs () -> void
+    def read_declarations: () -> void
+
+    # @rbs (Frontend::AST::declaration declaration) -> void
+    def read_declaration: (Frontend::AST::declaration declaration) -> void
+
+    # @rbs (Frontend::AST::Precedence declaration) -> void
+    def read_precedence: (Frontend::AST::Precedence declaration) -> void
+
+    # @rbs (String name, Frontend::Location location) -> void
+    def read_option: (String name, Frontend::Location location) -> void
+  end
+end

data/sig/ibex/normalize/diagnostics.rbs

@@ -0,0 +1,32 @@
+# Generated from lib/ibex/normalize/diagnostics.rb with RBS::Inline
+
+module Ibex
+  # Static grammar diagnostics used by Normalizer.
+  module NormalizeDiagnostics
+    private
+
+    # @rbs () -> void
+    def validate_grammar: () -> void
+
+    # @rbs () -> void
+    def warn_duplicate_productions: () -> void
+
+    # @rbs () -> void
+    def warn_unreachable_nonterminals: () -> void
+
+    # @rbs () -> Set[Integer]
+    def reachable_symbol_ids: () -> Set[Integer]
+
+    # @rbs () -> void
+    def warn_unused_terminals: () -> void
+
+    # @rbs () -> void
+    def warn_empty_language: () -> void
+
+    # @rbs () -> Set[Integer]
+    def productive_terminal_ids: () -> Set[Integer]
+
+    # @rbs (IR::GrammarSymbol grammar_symbol) -> bool
+    def productive_terminal?: (IR::GrammarSymbol grammar_symbol) -> bool
+  end
+end

data/sig/ibex/normalize/expander.rbs

@@ -0,0 +1,66 @@
+# Generated from lib/ibex/normalize/expander.rb with RBS::Inline
+
+module Ibex
+  # Production and EBNF expansion used by Normalizer.
+  module NormalizeExpander
+    private
+
+    # @rbs () -> void
+    def normalize_user_productions: () -> void
+
+    # @rbs (Frontend::AST::Rule rule, Frontend::AST::Alternative alternative) -> void
+    def normalize_alternative: (Frontend::AST::Rule rule, Frontend::AST::Alternative alternative) -> void
+
+    # @rbs (Frontend::AST::item item) -> String
+    def normalize_item: (Frontend::AST::item item) -> String
+
+    # @rbs (Frontend::AST::InlineAction item, Integer context_length, Array[IR::named_ref] named_refs) -> String
+    def expand_inline_action: (Frontend::AST::InlineAction item, Integer context_length, Array[IR::named_ref] named_refs) -> String
+
+    # @rbs (Frontend::AST::Optional item) -> String
+    def expand_optional: (Frontend::AST::Optional item) -> String
+
+    # @rbs (Frontend::AST::Star item) -> String
+    def expand_star: (Frontend::AST::Star item) -> String
+
+    # @rbs (Frontend::AST::Plus item) -> String
+    def expand_plus: (Frontend::AST::Plus item) -> String
+
+    # @rbs (Frontend::AST::SeparatedList item) -> String
+    def expand_separated_list: (Frontend::AST::SeparatedList item) -> String
+
+    # @rbs (Frontend::AST::Group item) -> String
+    def expand_group: (Frontend::AST::Group item) -> String
+
+    # @rbs (Integer length) -> String
+    def group_value_expression: (Integer length) -> String
+
+    # @rbs (Frontend::AST::Group group) -> void
+    def reject_group_named_references: (Frontend::AST::Group group) -> void
+
+    # @rbs (Frontend::AST::item item) -> Frontend::AST::SymbolReference?
+    def named_reference_in: (Frontend::AST::item item) -> Frontend::AST::SymbolReference?
+
+    # @rbs (String kind, Frontend::Location location) -> String
+    def new_helper: (String kind, Frontend::Location location) -> String
+
+    # @rbs (String expression, Frontend::Location location) -> IR::Action
+    def synthetic_action: (String expression, Frontend::Location location) -> IR::Action
+
+    # @rbs (Symbol kind, Frontend::AST::item item) -> Hash[Symbol, untyped]
+    def synthetic_origin: (Symbol kind, Frontend::AST::item item) -> Hash[Symbol, untyped]
+
+    # @rbs (Frontend::AST::InlineAction? action, Array[IR::named_ref] named_refs) -> IR::Action?
+    def normalize_action: (Frontend::AST::InlineAction? action, Array[IR::named_ref] named_refs) -> IR::Action?
+
+    # @rbs (Frontend::AST::item item, Array[IR::named_ref] refs, Integer index) -> void
+    def add_named_reference: (Frontend::AST::item item, Array[IR::named_ref] refs, Integer index) -> void
+
+    # @rbs (Frontend::AST::item item) -> Frontend::AST::SymbolReference?
+    def unwrap_reference: (Frontend::AST::item item) -> Frontend::AST::SymbolReference?
+
+    # @rbs (String lhs_name, Array[String] rhs_names, IR::Action? action, String? precedence_name,
+    #   Hash[Symbol, untyped] origin) -> void
+    def add_production: (String lhs_name, Array[String] rhs_names, IR::Action? action, String? precedence_name, Hash[Symbol, untyped] origin) -> void
+  end
+end

data/sig/ibex/normalize/expression.rbs

@@ -0,0 +1,21 @@
+# Generated from lib/ibex/normalize/expression.rb with RBS::Inline
+
+module Ibex
+  # Deterministically renders frontend EBNF items for production origin metadata.
+  module NormalizeExpression
+    private def render_reference: (Frontend::AST::SymbolReference item) -> String
+
+    private def self.render_reference: (Frontend::AST::SymbolReference item) -> String
+
+    private def render_group: (Frontend::AST::Group item) -> String
+
+    private def self.render_group: (Frontend::AST::Group item) -> String
+
+    private def render_separated_list: (Frontend::AST::SeparatedList item) -> String
+
+    private def self.render_separated_list: (Frontend::AST::SeparatedList item) -> String
+
+    # @rbs (Frontend::AST::item item) -> String
+    def self?.render: (Frontend::AST::item item) -> String
+  end
+end

data/sig/ibex/normalize.rbs

@@ -0,0 +1,96 @@
+# Generated from lib/ibex/normalize.rb with RBS::Inline
+
+module Ibex
+  # Converts a frontend AST into immutable Grammar IR.
+  class Normalizer
+    include NormalizeDeclarations
+
+    include NormalizeExpander
+
+    include NormalizeDiagnostics
+
+    RESERVED_NAMES: Array[String]
+
+    @ast: Frontend::AST::Root
+
+    @mode: Symbol
+
+    @symbols: Array[IR::GrammarSymbol]
+
+    @symbols_by_name: Hash[String, IR::GrammarSymbol]
+
+    @productions: Array[IR::Production]
+
+    @warnings: Array[IR::grammar_warning]
+
+    @helper_sequence: Integer
+
+    @declared_tokens: Hash[String, IR::location]
+
+    @precedence: Hash[String, IR::precedence]
+
+    @precedence_locations: Hash[String, IR::location]
+
+    @options: IR::grammar_options
+
+    @expected_conflicts: Integer
+
+    @conversions: Hash[String, String]
+
+    @explicit_start: String?
+
+    @start_name: String
+
+    @start_location: Frontend::Location?
+
+    # @rbs (Frontend::AST::Root ast, ?mode: Symbol | String) -> void
+    def initialize: (Frontend::AST::Root ast, ?mode: Symbol | String) -> void
+
+    # @rbs () -> IR::Grammar
+    def normalize: () -> IR::Grammar
+
+    private
+
+    # @rbs () -> void
+    def intern_reserved_symbols: () -> void
+
+    # @rbs () -> void
+    def intern_declared_terminals: () -> void
+
+    # @rbs () -> void
+    def intern_user_nonterminals: () -> void
+
+    # @rbs (String name, Symbol kind, ?reserved: bool, ?location: IR::location?) -> IR::GrammarSymbol
+    def intern: (String name, Symbol kind, ?reserved: bool, ?location: IR::location?) -> IR::GrammarSymbol
+
+    # @rbs (String name) -> IR::GrammarSymbol?
+    def symbol: (String name) -> IR::GrammarSymbol?
+
+    # @rbs (String name) -> IR::GrammarSymbol
+    def required_symbol: (String name) -> IR::GrammarSymbol
+
+    # @rbs (Frontend::AST::SymbolReference reference) -> IR::GrammarSymbol
+    def symbol_for_reference: (Frontend::AST::SymbolReference reference) -> IR::GrammarSymbol
+
+    # @rbs (String name) -> bool
+    def nonterminal_name?: (String name) -> bool
+
+    # @rbs (Frontend::AST::SymbolReference reference) -> bot
+    def undefined_nonterminal: (Frontend::AST::SymbolReference reference) -> bot
+
+    # @rbs (Frontend::AST::SymbolReference reference) -> void
+    def warn_undeclared_terminal: (Frontend::AST::SymbolReference reference) -> void
+
+    # @rbs () -> Hash[String, String]
+    def normalized_user_code: () -> Hash[String, String]
+
+    # @rbs () -> IR::user_code_chunks
+    def normalized_user_code_chunks: () -> IR::user_code_chunks
+
+    # @rbs (Frontend::Location location, String message) -> bot
+    def fail_at: (Frontend::Location location, String message) -> bot
+
+    # @rbs (IR::location? location, String message) -> bot
+    def fail_hash: (IR::location? location, String message) -> bot
+  end
+end