ibex 0.1.0 → 0.2.0

data/sig/ibex/normalize/inline_expansion.rbs

@@ -0,0 +1,120 @@
+# Generated from lib/ibex/normalize/inline_expansion.rb with RBS::Inline
+
+module Ibex
+  # Deterministically substitutes inline-rule productions before LR construction.
+  # rubocop:disable Metrics/ModuleLength -- expansion, action plans, and id remapping share one invariant.
+  module NormalizeInlineExpansion
+    private
+
+    # @rbs () -> void
+    def expand_inline_rules: () -> void
+
+    # Explicit heap frames avoid tying grammar depth to the Ruby call stack.
+    # The single-definition path reuses its accumulated arrays, so a long
+    # acyclic chain remains linear in the size of its final action plan.
+    # @rbs (IR::Production production, Hash[Integer, Array[IR::Production]] definitions) ->
+    #   Array[Hash[Symbol, untyped]]
+    def expand_inline_production: (IR::Production production, Hash[Integer, Array[IR::Production]] definitions) -> Array[Hash[Symbol, untyped]]
+
+    # @rbs (Array[Hash[Symbol, untyped]] frames, Hash[Integer, Array[IR::Production]] definitions,
+    #   Array[Array[Hash[Symbol, untyped]]] worklist, Array[Hash[Symbol, untyped]] variants,
+    #   IR::location? location) -> void
+    def drain_inline_expansion_frames: (Array[Hash[Symbol, untyped]] frames, Hash[Integer, Array[IR::Production]] definitions, Array[Array[Hash[Symbol, untyped]]] worklist, Array[Hash[Symbol, untyped]] variants, IR::location? location) -> void
+
+    # @rbs (Array[Hash[Symbol, untyped]] frames, Hash[Integer, Array[IR::Production]] definitions,
+    #   Array[Array[Hash[Symbol, untyped]]] worklist, Array[Hash[Symbol, untyped]] variants,
+    #   IR::location? location) -> bool
+    def advance_inline_expansion_frame?: (Array[Hash[Symbol, untyped]] frames, Hash[Integer, Array[IR::Production]] definitions, Array[Array[Hash[Symbol, untyped]]] worklist, Array[Hash[Symbol, untyped]] variants, IR::location? location) -> bool
+
+    # @rbs (Array[Hash[Symbol, untyped]] frames, Array[IR::Production] choices, Integer symbol_id,
+    #   Array[Array[Hash[Symbol, untyped]]] worklist) -> void
+    def schedule_inline_choice_branches: (Array[Hash[Symbol, untyped]] frames, Array[IR::Production] choices, Integer symbol_id, Array[Array[Hash[Symbol, untyped]]] worklist) -> void
+
+    # @rbs (Array[Hash[Symbol, untyped]] frames, Array[Hash[Symbol, untyped]] variants,
+    #   Array[Array[Hash[Symbol, untyped]]] worklist, IR::location? location) -> bool
+    def complete_inline_expansion_frame?: (Array[Hash[Symbol, untyped]] frames, Array[Hash[Symbol, untyped]] variants, Array[Array[Hash[Symbol, untyped]]] worklist, IR::location? location) -> bool
+
+    # @rbs (IR::Production production, Integer? symbol_id) -> Hash[Symbol, untyped]
+    def inline_expansion_frame: (IR::Production production, Integer? symbol_id) -> Hash[Symbol, untyped]
+
+    # @rbs (Array[Hash[Symbol, untyped]] frames) -> Array[Hash[Symbol, untyped]]
+    def clone_inline_expansion_frames: (Array[Hash[Symbol, untyped]] frames) -> Array[Hash[Symbol, untyped]]
+
+    # @rbs (IR::Production production) -> Hash[Symbol, untyped]
+    def empty_inline_variant: (IR::Production production) -> Hash[Symbol, untyped]
+
+    # @rbs (Hash[Symbol, untyped] variant, Integer symbol_id) -> Hash[Symbol, untyped]
+    def append_inline_symbol: (Hash[Symbol, untyped] variant, Integer symbol_id) -> Hash[Symbol, untyped]
+
+    # @rbs (Hash[Symbol, untyped] parent, Hash[Symbol, untyped] child) -> Hash[Symbol, untyped]
+    def combine_inline_variant: (Hash[Symbol, untyped] parent, Hash[Symbol, untyped] child) -> Hash[Symbol, untyped]
+
+    # @rbs (Hash[Symbol, untyped] parent, Hash[Symbol, untyped] child,
+    #   Integer physical_offset, Integer step_offset) -> Array[Hash[Symbol, untyped]]
+    def combined_inline_steps: (Hash[Symbol, untyped] parent, Hash[Symbol, untyped] child, Integer physical_offset, Integer step_offset) -> Array[Hash[Symbol, untyped]]
+
+    # @rbs (Array[untyped] left, Array[untyped] right) -> Array[untyped]
+    def append_inline_array: (Array[untyped] left, Array[untyped] right) -> Array[untyped]
+
+    # @rbs (Hash[Symbol, untyped] parent, Hash[Symbol, untyped] child) -> Integer?
+    def combined_inline_precedence: (Hash[Symbol, untyped] parent, Hash[Symbol, untyped] child) -> Integer?
+
+    # @rbs (Hash[Symbol, untyped] parent, Hash[Symbol, untyped] child,
+    #   Integer physical_offset, Integer step_offset) -> Array[Hash[Symbol, untyped]]
+    def remap_inline_steps: (Hash[Symbol, untyped] parent, Hash[Symbol, untyped] child, Integer physical_offset, Integer step_offset) -> Array[Hash[Symbol, untyped]]
+
+    # @rbs (Array[Symbol | Integer] reference, Integer physical_offset, Integer step_offset) ->
+    #   Array[Symbol | Integer]
+    def remap_inline_reference: (Array[Symbol | Integer] reference, Integer physical_offset, Integer step_offset) -> Array[Symbol | Integer]
+
+    # @rbs (Hash[Symbol, untyped] variant, IR::Production production) -> Hash[Symbol, untyped]
+    def finish_inline_precedence: (Hash[Symbol, untyped] variant, IR::Production production) -> Hash[Symbol, untyped]
+
+    # @rbs (Hash[Symbol, untyped] variant, IR::Production production, Integer symbol_id) ->
+    #   Hash[Symbol, untyped]
+    def finish_inline_choice: (Hash[Symbol, untyped] variant, IR::Production production, Integer symbol_id) -> Hash[Symbol, untyped]
+
+    # @rbs (IR::Production production, Array[Array[Symbol | Integer]] inputs, Integer lookahead,
+    #   Symbol kind, String? rule) -> Hash[Symbol, untyped]
+    def inline_action_step: (IR::Production production, Array[Array[Symbol | Integer]] inputs, Integer lookahead, Symbol kind, String? rule) -> Hash[Symbol, untyped]
+
+    # @rbs (IR::Production production, Hash[Symbol, untyped] variant, Integer id) -> IR::Production
+    def composed_inline_production: (IR::Production production, Hash[Symbol, untyped] variant, Integer id) -> IR::Production
+
+    # @rbs (IR::Production production, Integer physical_length, Array[Hash[Symbol, untyped]]) -> IR::Action
+    def composed_inline_action: (IR::Production production, Integer physical_length, Array[Hash[Symbol, untyped]]) -> IR::Action
+
+    # @rbs (Hash[Symbol, untyped] step, Integer physical_length) -> Hash[Symbol, untyped]
+    def composition_plan_step: (Hash[Symbol, untyped] step, Integer physical_length) -> Hash[Symbol, untyped]
+
+    # @rbs (Array[Symbol | Integer] reference, Integer physical_length) -> Integer
+    def resolve_inline_reference: (Array[Symbol | Integer] reference, Integer physical_length) -> Integer
+
+    # @rbs (Integer rhs_length) -> String
+    def inline_implicit_code: (Integer rhs_length) -> String
+
+    # @rbs (IR::location location) -> IR::source_provenance
+    def inline_source_provenance: (IR::location location) -> IR::source_provenance
+
+    # @rbs (IR::Production production, Hash[Symbol, untyped] variant) -> IR::production_expansion
+    def inline_production_expansion: (IR::Production production, Hash[Symbol, untyped] variant) -> IR::production_expansion
+
+    # @rbs (IR::Production production, Integer id) -> IR::Production
+    def copy_inline_production: (IR::Production production, Integer id) -> IR::Production
+
+    # @rbs (IR::Production production) -> void
+    def charge_inline_expansion!: (IR::Production production) -> void
+
+    # @rbs (Integer count, IR::location? location) -> void
+    def enforce_inline_choice_limit!: (Integer count, IR::location? location) -> void
+
+    # @rbs (Array[IR::Production] productions) -> void
+    def rebuild_inline_symbols: (Array[IR::Production] productions) -> void
+
+    # @rbs (IR::GrammarSymbol definition, Integer id) -> IR::GrammarSymbol
+    def remap_inline_symbol: (IR::GrammarSymbol definition, Integer id) -> IR::GrammarSymbol
+
+    # @rbs (IR::Production production, Integer id, Hash[Integer, Integer] id_map) -> IR::Production
+    def remap_inline_production: (IR::Production production, Integer id, Hash[Integer, Integer] id_map) -> IR::Production
+  end
+end

data/sig/ibex/normalize/inline_validation.rbs

@@ -0,0 +1,40 @@
+# Generated from lib/ibex/normalize/inline_validation.rb with RBS::Inline
+
+module Ibex
+  # Static validation and collection for rules eliminated by inline expansion.
+  module NormalizeInlineValidation
+    private
+
+    # @rbs () -> void
+    def gather_inline_rules: () -> void
+
+    # @rbs () -> void
+    def validate_inline_terminal_collisions: () -> void
+
+    # @rbs () -> void
+    def validate_inline_start: () -> void
+
+    # @rbs () -> void
+    def validate_inline_cycles: () -> void
+
+    # A formal is live for cycle analysis only when substituting its actual can
+    # introduce a grammar reference. Calls propagate liveness through their
+    # callee's live positions until the finite formal set reaches a fixed point.
+    # @rbs () -> Hash[String, Set[Integer]]
+    def parameter_formal_liveness: () -> Hash[String, Set[Integer]]
+
+    # @rbs (Frontend::AST::item item, Array[String] formals,
+    #   Hash[String, Set[Integer]] liveness, Set[Integer] found) -> void
+    def collect_live_formals: (Frontend::AST::item item, Array[String] formals, Hash[String, Set[Integer]] liveness, Set[Integer] found) -> void
+
+    # Structural AST traversal necessarily branches once for each public item shape.
+    # rubocop:disable Metrics/CyclomaticComplexity
+    # @rbs (Frontend::AST::item item, Array[String] formals, Set[String] names,
+    #   Array[[String, Frontend::Location]] edges, Hash[String, Set[Integer]] liveness) -> void
+    def collect_inline_edges: (Frontend::AST::item item, Array[String] formals, Set[String] names, Array[[ String, Frontend::Location ]] edges, Hash[String, Set[Integer]] liveness) -> void
+
+    # @rbs (String name, Hash[String, Array[[String, Frontend::Location]]] graph,
+    #   Hash[String, Symbol] states) -> void
+    def visit_inline_cycle: (String name, Hash[String, Array[[ String, Frontend::Location ]]] graph, Hash[String, Symbol] states) -> void
+  end
+end

data/sig/ibex/normalize/lexer.rbs

@@ -0,0 +1,37 @@
+# Generated from lib/ibex/normalize/lexer.rb with RBS::Inline
+
+module Ibex
+  # Lexer declaration normalization and static safety checks.
+  module NormalizeLexer
+    private
+
+    # @rbs () -> IR::Lexer?
+    def normalize_lexer: () -> IR::Lexer?
+
+    # @rbs (Frontend::AST::LexerState definition, Array[String] states, Array[IR::LexerRule] rules,
+    #   Array[Hash[Symbol, untyped]] warnings) -> void
+    def normalize_lexer_state: (Frontend::AST::LexerState definition, Array[String] states, Array[IR::LexerRule] rules, Array[Hash[Symbol, untyped]] warnings) -> void
+
+    # @rbs (Frontend::AST::LexerRule definition, String state, Integer id,
+    #   Array[Hash[Symbol, untyped]] warnings) -> IR::LexerRule
+    def normalize_lexer_rule: (Frontend::AST::LexerRule definition, String state, Integer id, Array[Hash[Symbol, untyped]] warnings) -> IR::LexerRule
+
+    # @rbs (Frontend::AST::LexerRule definition) -> void
+    def validate_lexer_token: (Frontend::AST::LexerRule definition) -> void
+
+    # @rbs (Frontend::AST::LexerRule definition) -> void
+    def validate_lexer_action: (Frontend::AST::LexerRule definition) -> void
+
+    # @rbs (Frontend::AST::LexerRule definition) -> [String, String]
+    def normalize_lexer_pattern: (Frontend::AST::LexerRule definition) -> [ String, String ]
+
+    # @rbs (String raw, Frontend::Location location) -> String
+    def decode_lexer_literal: (String raw, Frontend::Location location) -> String
+
+    # @rbs (Frontend::AST::LexerRule definition, String source, String options) -> void
+    def validate_lexer_regexp: (Frontend::AST::LexerRule definition, String source, String options) -> void
+
+    # @rbs (String source) -> bool
+    def risky_lexer_pattern?: (String source) -> bool
+  end
+end

data/sig/ibex/normalize/named_references.rbs

@@ -0,0 +1,20 @@
+# Generated from lib/ibex/normalize/named_references.rb with RBS::Inline
+
+module Ibex
+  # Named-reference collection and validation shared by ordinary and parameterized items.
+  module NormalizeNamedReferences
+    private
+
+    # @rbs (Frontend::AST::Group group) -> void
+    def reject_group_named_references: (Frontend::AST::Group group) -> void
+
+    # @rbs (Frontend::AST::item item) -> (Frontend::AST::SymbolReference | Frontend::AST::ParameterizedReference)?
+    def named_reference_in: (Frontend::AST::item item) -> (Frontend::AST::SymbolReference | Frontend::AST::ParameterizedReference)?
+
+    # @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 | Frontend::AST::ParameterizedReference)?
+    def unwrap_reference: (Frontend::AST::item item) -> (Frontend::AST::SymbolReference | Frontend::AST::ParameterizedReference)?
+  end
+end

data/sig/ibex/normalize/nodes.rbs

@@ -0,0 +1,14 @@
+# Generated from lib/ibex/normalize/nodes.rb with RBS::Inline
+
+module Ibex
+  # Validation and normalization for generated AST node declarations.
+  module NormalizeNodes
+    private
+
+    # @rbs (Frontend::AST::Alternative alternative, Array[String] rhs) -> IR::node_annotation?
+    def normalize_node_annotation: (Frontend::AST::Alternative alternative, Array[String] rhs) -> IR::node_annotation?
+
+    # @rbs (Frontend::AST::NodeAnnotation annotation, Array[String] rhs) -> void
+    def validate_node_fields: (Frontend::AST::NodeAnnotation annotation, Array[String] rhs) -> void
+  end
+end

data/sig/ibex/normalize/parameter_ebnf_lowering.rbs

@@ -0,0 +1,32 @@
+# Generated from lib/ibex/normalize/parameter_ebnf_lowering.rb with RBS::Inline
+
+module Ibex
+  # Resumable EBNF lowering used inside specialized parameter alternatives.
+  module NormalizeParameterEbnfLowering
+    private
+
+    # @rbs (Hash[Symbol, untyped] frame,
+    #   Frontend::AST::Optional | Frontend::AST::Star | Frontend::AST::Plus item) -> void
+    def lower_parameter_suffix: (Hash[Symbol, untyped] frame, Frontend::AST::Optional | Frontend::AST::Star | Frontend::AST::Plus item) -> void
+
+    # @rbs (Hash[Symbol, untyped] frame,
+    #   Frontend::AST::Optional | Frontend::AST::Star | Frontend::AST::Plus item) -> void
+    def finish_parameter_suffix: (Hash[Symbol, untyped] frame, Frontend::AST::Optional | Frontend::AST::Star | Frontend::AST::Plus item) -> void
+
+    # @rbs (Hash[Symbol, untyped] frame, Frontend::AST::SeparatedList item) -> void
+    def lower_parameter_separated_list: (Hash[Symbol, untyped] frame, Frontend::AST::SeparatedList item) -> void
+
+    # @rbs (Hash[Symbol, untyped] frame, Frontend::AST::SeparatedList item) -> void
+    def finish_parameter_separated_list: (Hash[Symbol, untyped] frame, Frontend::AST::SeparatedList item) -> void
+
+    # @rbs (Hash[Symbol, untyped] frame, Frontend::AST::Group item) -> void
+    def lower_parameter_group: (Hash[Symbol, untyped] frame, Frontend::AST::Group item) -> void
+
+    # @rbs (Hash[Symbol, untyped] frame, String helper, Frontend::AST::Group item,
+    #   Array[Frontend::AST::item] alternative) -> void
+    def start_parameter_group_alternative: (Hash[Symbol, untyped] frame, String helper, Frontend::AST::Group item, Array[Frontend::AST::item] alternative) -> void
+
+    # @rbs (Hash[Symbol, untyped] frame, String helper, Frontend::AST::Group item, Integer length) -> void
+    def finish_parameter_group_alternative: (Hash[Symbol, untyped] frame, String helper, Frontend::AST::Group item, Integer length) -> void
+  end
+end

data/sig/ibex/normalize/parameter_lowering.rbs

@@ -0,0 +1,35 @@
+# Generated from lib/ibex/normalize/parameter_lowering.rb with RBS::Inline
+
+module Ibex
+  # Resumable, source-ordered lowering for specialized parameter alternatives.
+  module NormalizeParameterLowering
+    private
+
+    # @rbs (Hash[Symbol, untyped] frame) -> void
+    def advance_parameter_alternative: (Hash[Symbol, untyped] frame) -> void
+
+    # @rbs (Hash[Symbol, untyped] frame) { () -> void } -> void
+    def with_parameter_frame_context: (Hash[Symbol, untyped] frame) { () -> void } -> void
+
+    # @rbs (Hash[Symbol, untyped] frame) -> bool
+    def parameter_items_remaining?: (Hash[Symbol, untyped] frame) -> bool
+
+    # @rbs (Hash[Symbol, untyped] frame) -> void
+    def start_parameter_item: (Hash[Symbol, untyped] frame) -> void
+
+    # @rbs (Hash[Symbol, untyped] frame, Array[untyped] operation) -> void
+    def process_parameter_operation: (Hash[Symbol, untyped] frame, Array[untyped] operation) -> void
+
+    # @rbs (Hash[Symbol, untyped] frame, Frontend::AST::item item) -> void
+    def lower_parameter_item: (Hash[Symbol, untyped] frame, Frontend::AST::item item) -> void
+
+    # @rbs (Hash[Symbol, untyped] frame, Frontend::AST::ParameterizedReference item) -> void
+    def lower_parameter_call: (Hash[Symbol, untyped] frame, Frontend::AST::ParameterizedReference item) -> void
+
+    # @rbs (Hash[Symbol, untyped] frame, Frontend::AST::item item) -> void
+    def finish_parameter_item: (Hash[Symbol, untyped] frame, Frontend::AST::item item) -> void
+
+    # @rbs (Hash[Symbol, untyped] frame) -> void
+    def finish_parameter_alternative: (Hash[Symbol, untyped] frame) -> void
+  end
+end

data/sig/ibex/normalize/parameter_substitution.rbs

@@ -0,0 +1,42 @@
+# Generated from lib/ibex/normalize/parameter_substitution.rb with RBS::Inline
+
+module Ibex
+  # Structural, sharing-preserving substitution for parameterized user rules.
+  module NormalizeParameterSubstitution
+    private
+
+    # @rbs (Frontend::AST::Alternative alternative, Hash[String, Frontend::AST::item] bindings) ->
+    #   Frontend::AST::Alternative
+    def substitute_parameter_alternative: (Frontend::AST::Alternative alternative, Hash[String, Frontend::AST::item] bindings) -> Frontend::AST::Alternative
+
+    # @rbs (Frontend::AST::Alternative alternative, Hash[String, Frontend::AST::item] bindings) -> String?
+    def substitute_parameter_precedence: (Frontend::AST::Alternative alternative, Hash[String, Frontend::AST::item] bindings) -> String?
+
+    # @rbs (Frontend::AST::item item, Hash[String, Frontend::AST::item] bindings) -> Frontend::AST::item
+    def substitute_parameter_item: (Frontend::AST::item item, Hash[String, Frontend::AST::item] bindings) -> Frontend::AST::item
+
+    # @rbs (Frontend::AST::SymbolReference formal, Frontend::AST::item argument) -> Frontend::AST::item
+    def substitute_formal_reference: (Frontend::AST::SymbolReference formal, Frontend::AST::item argument) -> Frontend::AST::item
+
+    # @rbs (Frontend::AST::item item, ?Hash[String, Frontend::AST::item] bindings) -> Frontend::AST::item
+    def clone_parameter_item: (Frontend::AST::item item, ?Hash[String, Frontend::AST::item] bindings) -> Frontend::AST::item
+
+    # @rbs (Frontend::AST::SymbolReference item, Hash[String, Frontend::AST::item] bindings) -> Frontend::AST::item
+    def clone_parameter_symbol: (Frontend::AST::SymbolReference item, Hash[String, Frontend::AST::item] bindings) -> Frontend::AST::item
+
+    # @rbs (Frontend::AST::ParameterizedReference item, Hash[String, Frontend::AST::item] bindings) ->
+    #   Frontend::AST::ParameterizedReference
+    def clone_parameter_call: (Frontend::AST::ParameterizedReference item, Hash[String, Frontend::AST::item] bindings) -> Frontend::AST::ParameterizedReference
+
+    # @rbs (Frontend::AST::Group item, Hash[String, Frontend::AST::item] bindings) -> Frontend::AST::Group
+    def clone_parameter_group: (Frontend::AST::Group item, Hash[String, Frontend::AST::item] bindings) -> Frontend::AST::Group
+
+    # @rbs (Frontend::AST::Optional | Frontend::AST::Star | Frontend::AST::Plus item,
+    #   Hash[String, Frontend::AST::item] bindings) -> Frontend::AST::item
+    def clone_parameter_suffix: (Frontend::AST::Optional | Frontend::AST::Star | Frontend::AST::Plus item, Hash[String, Frontend::AST::item] bindings) -> Frontend::AST::item
+
+    # @rbs (Frontend::AST::SeparatedList item, Hash[String, Frontend::AST::item] bindings) ->
+    #   Frontend::AST::SeparatedList
+    def clone_parameter_separated_list: (Frontend::AST::SeparatedList item, Hash[String, Frontend::AST::item] bindings) -> Frontend::AST::SeparatedList
+  end
+end

data/sig/ibex/normalize/parameter_validation.rbs

@@ -0,0 +1,44 @@
+# Generated from lib/ibex/normalize/parameter_validation.rb with RBS::Inline
+
+module Ibex
+  # Static validation and collection of parameterized user rule definitions.
+  module NormalizeParameterValidation
+    private
+
+    # @rbs () -> void
+    def gather_parameter_templates: () -> void
+
+    # @rbs (Frontend::AST::Rule rule, Hash[String, Frontend::AST::Rule] plain_rules) -> void
+    def gather_parameterized_rule: (Frontend::AST::Rule rule, Hash[String, Frontend::AST::Rule] plain_rules) -> void
+
+    # @rbs (Frontend::AST::Rule rule) -> void
+    def validate_parameter_formals: (Frontend::AST::Rule rule) -> void
+
+    # @rbs (Frontend::AST::Rule rule) -> bot
+    def reject_mixed_parameterized_rule: (Frontend::AST::Rule rule) -> bot
+
+    # @rbs () -> void
+    def validate_parameter_terminal_collisions: () -> void
+
+    # @rbs (Frontend::AST::Rule rule) -> void
+    def validate_parameter_references: (Frontend::AST::Rule rule) -> void
+
+    # @rbs (Frontend::AST::item item, Array[String] formals, inside_argument: bool) -> void
+    def validate_parameter_item: (Frontend::AST::item item, Array[String] formals, inside_argument: bool) -> void
+
+    # @rbs (Frontend::AST::ParameterizedReference item, Array[String] formals, inside_argument: bool) -> void
+    def validate_parameterized_item: (Frontend::AST::ParameterizedReference item, Array[String] formals, inside_argument: bool) -> void
+
+    # @rbs (Frontend::AST::SymbolReference | Frontend::AST::ParameterizedReference item) -> bot
+    def reject_argument_named_reference: (Frontend::AST::SymbolReference | Frontend::AST::ParameterizedReference item) -> bot
+
+    # @rbs (Frontend::AST::ParameterizedReference reference) -> void
+    def validate_parameter_call: (Frontend::AST::ParameterizedReference reference) -> void
+
+    # @rbs (Frontend::AST::Rule rule) -> bool
+    def parameterized_rule?: (Frontend::AST::Rule rule) -> bool
+
+    # @rbs (String name) -> bool
+    def parameter_template?: (String name) -> bool
+  end
+end

data/sig/ibex/normalize/parameters.rbs

@@ -0,0 +1,46 @@
+# Generated from lib/ibex/normalize/parameters.rb with RBS::Inline
+
+module Ibex
+  # Iterative, hygienic specialization of validated parameterized user rules.
+  module NormalizeParameters
+    private
+
+    # @rbs (Frontend::AST::ParameterizedReference reference) -> String
+    def specialize_parameterized_reference: (Frontend::AST::ParameterizedReference reference) -> String
+
+    # @rbs (Frontend::AST::ParameterizedReference reference) -> [String, bool]
+    def schedule_parameter_specialization: (Frontend::AST::ParameterizedReference reference) -> [ String, bool ]
+
+    # @rbs (Frontend::AST::ParameterizedReference reference) -> void
+    def enforce_parameter_limits!: (Frontend::AST::ParameterizedReference reference) -> void
+
+    # A constructor-growing recursive call can create infinitely many distinct
+    # specializations. Calls whose arguments shrink or merely change are
+    # allowed; they may reach a memoized fixed point after finite expansion.
+    # @rbs (Array[Frontend::AST::item] candidates, Array[Frontend::AST::item] ancestors) -> bool
+    def growing_parameter_arguments?: (Array[Frontend::AST::item] candidates, Array[Frontend::AST::item] ancestors) -> bool
+
+    # @rbs (Frontend::AST::item candidate, String target) -> bool
+    def parameter_argument_contains?: (Frontend::AST::item candidate, String target) -> bool
+
+    # @rbs (Frontend::AST::ParameterizedReference reference) -> String
+    def new_parameter_helper: (Frontend::AST::ParameterizedReference reference) -> String
+
+    # @rbs (Frontend::AST::ParameterizedReference reference, String helper,
+    #   Array[Frontend::AST::item] arguments, Array[String] rendered_arguments) ->
+    #   Hash[Symbol, untyped]
+    def parameter_frame: (Frontend::AST::ParameterizedReference reference, String helper, Array[Frontend::AST::item] arguments, Array[String] rendered_arguments) -> Hash[Symbol, untyped]
+
+    # @rbs () -> void
+    def drain_parameter_worklist: () -> void
+
+    # @rbs (Hash[Symbol, untyped] frame) -> bool
+    def prepare_parameter_alternative?: (Hash[Symbol, untyped] frame) -> bool
+
+    # @rbs (Hash[Symbol, untyped] frame, Frontend::AST::Rule template, Integer index) -> void
+    def prepare_parameter_alternative_entry: (Hash[Symbol, untyped] frame, Frontend::AST::Rule template, Integer index) -> void
+
+    # @rbs (Hash[Symbol, untyped] frame) -> void
+    def clear_parameter_alternative: (Hash[Symbol, untyped] frame) -> void
+  end
+end

data/sig/ibex/normalize/recovery_declarations.rbs

@@ -0,0 +1,24 @@
+# Generated from lib/ibex/normalize/recovery_declarations.rb with RBS::Inline
+
+module Ibex
+  # Recovery declaration extraction and post-interning symbol validation.
+  module NormalizeRecoveryDeclarations
+    private
+
+    # @rbs (Frontend::AST::Start | Frontend::AST::Recovery | Frontend::AST::OnErrorReduce |
+    #   Frontend::AST::GrammarTest declaration) -> void
+    def read_parser_control_declaration: (Frontend::AST::Start | Frontend::AST::Recovery | Frontend::AST::OnErrorReduce | Frontend::AST::GrammarTest declaration) -> void
+
+    # @rbs (Frontend::AST::GrammarTest declaration) -> void
+    def read_grammar_test: (Frontend::AST::GrammarTest declaration) -> void
+
+    # @rbs (Frontend::AST::Recovery declaration) -> void
+    def read_recovery_declaration: (Frontend::AST::Recovery declaration) -> void
+
+    # @rbs (Frontend::AST::OnErrorReduce declaration) -> void
+    def read_on_error_reduce_declaration: (Frontend::AST::OnErrorReduce declaration) -> void
+
+    # @rbs () -> void
+    def validate_recovery_declarations: () -> void
+  end
+end

data/sig/ibex/normalize.rbs

@@ -5,52 +5,141 @@ module Ibex
   class Normalizer
     include NormalizeDeclarations
 
+    include NormalizeLexer
+
+    include NormalizeRecoveryDeclarations
+
+    include NormalizeParameterValidation
+
+    include NormalizeInlineValidation
+
+    include NormalizeParameterSubstitution
+
+    include NormalizeParameterEbnfLowering
+
+    include NormalizeParameterLowering
+
+    include NormalizeParameters
+
+    include NormalizeNamedReferences
+
+    include NormalizeNodes
+
     include NormalizeExpander
 
+    include NormalizeInlineExpansion
+
     include NormalizeDiagnostics
 
     RESERVED_NAMES: Array[String]
 
-    @ast: Frontend::AST::Root
+    RUBY_KEYWORDS: Array[String]
 
-    @mode: Symbol
+    DEFAULT_MAX_PARAMETER_SPECIALIZATIONS: ::Integer
 
-    @symbols: Array[IR::GrammarSymbol]
+    DEFAULT_MAX_INLINE_EXPANSIONS: ::Integer
 
-    @symbols_by_name: Hash[String, IR::GrammarSymbol]
+    @explicit_starts: Array[String]?
 
-    @productions: Array[IR::Production]
+    @lexer_declaration: Frontend::AST::Lexer?
 
-    @warnings: Array[IR::grammar_warning]
+    @grammar_tests: Array[IR::grammar_test]
 
-    @helper_sequence: Integer
+    @on_error_reduce_groups: Array[Array[String]]
 
-    @declared_tokens: Hash[String, IR::location]
+    @recovery_sync_tokens: Array[String]
 
-    @precedence: Hash[String, IR::precedence]
+    @value_printers: Hash[String, IR::value_printer]
 
-    @precedence_locations: Hash[String, IR::location]
+    @parser_parameters: Array[IR::parser_parameter]
 
-    @options: IR::grammar_options
+    @conversions: Hash[String, String]
+
+    @expected_rr_conflicts: Integer?
 
     @expected_conflicts: Integer
 
-    @conversions: Hash[String, String]
+    @options: IR::grammar_options
 
-    @explicit_start: String?
+    @semantic_type_locations: Hash[String, IR::location]
 
-    @start_name: String
+    @semantic_types: Hash[String, String]
+
+    @display_name_locations: Hash[String, IR::location]
+
+    @display_names: Hash[String, String]
+
+    @precedence_locations: Hash[String, IR::location]
+
+    @precedence: Hash[String, IR::precedence]
+
+    @node_shapes: Hash[String, Array[String]]
+
+    @inline_expansion_count: Integer
+
+    @max_inline_expansions: Integer
+
+    @inline_rule_by_symbol: Hash[Integer, String]
+
+    @inline_symbol_ids: Set[Integer]
+
+    @inline_rule_names: Set[String]
+
+    @rule_documentation: Hash[String, String]
+
+    @current_parameter_expansion: IR::parameter_expansion?
+
+    @max_parameter_specializations: Integer
+
+    @parameter_worklist_active: bool
+
+    @parameter_worklist: Array[Hash[Symbol, untyped]]
+
+    @parameter_specializations: Hash[[ String, Array[String] ], String]
+
+    @parameter_formals: Hash[String, Array[String]]
+
+    @parameter_templates: Hash[String, Array[Frontend::AST::Rule]]
 
     @start_location: Frontend::Location?
 
-    # @rbs (Frontend::AST::Root ast, ?mode: Symbol | String) -> void
-    def initialize: (Frontend::AST::Root ast, ?mode: Symbol | String) -> void
+    @start_name: String
+
+    @start_names: Array[String]
+
+    @declared_tokens: Hash[String, IR::location]
+
+    @helper_sequence: Integer
+
+    @warnings: Array[IR::grammar_warning]
+
+    @productions: Array[IR::Production]
+
+    @symbols_by_name: Hash[String, IR::GrammarSymbol]
+
+    @symbols: Array[IR::GrammarSymbol]
+
+    @mode: IR::grammar_mode
+
+    @current_include_chain: Array[IR::source_provenance]
+
+    @resolution: Frontend::Resolution?
+
+    @ast: Frontend::AST::Root
+
+    # @rbs (Frontend::AST::Root | Frontend::AST::Fragment | Frontend::Resolution input,
+    #   ?mode: Symbol | String, ?max_parameter_specializations: Integer,
+    #   ?max_inline_expansions: Integer) -> void
+    def initialize: (Frontend::AST::Root | Frontend::AST::Fragment | Frontend::Resolution input, ?mode: Symbol | String, ?max_parameter_specializations: Integer, ?max_inline_expansions: Integer) -> void
 
     # @rbs () -> IR::Grammar
     def normalize: () -> IR::Grammar
 
     private
 
+    # @rbs (Symbol name, untyped value) -> void
+    def validate_positive_limit!: (Symbol name, untyped value) -> void
+
     # @rbs () -> void
     def intern_reserved_symbols: () -> void
 
@@ -60,8 +149,21 @@ module Ibex
     # @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 () -> Array[String]
+    def normalized_start_names: () -> Array[String]
+
+    # @rbs (Frontend::AST::Rule rule) -> bool
+    def start_rule_candidate?: (Frontend::AST::Rule rule) -> bool
+
+    # @rbs (Frontend::AST::Rule rule) -> void
+    def intern_user_nonterminal: (Frontend::AST::Rule rule) -> void
+
+    # @rbs () -> Hash[String, String]
+    def validated_rule_documentation: () -> Hash[String, String]
+
+    # @rbs (String name, Symbol kind, ?reserved: bool, ?location: IR::location?,
+    #   ?documentation: String?, ?metadata_name: String?) -> IR::GrammarSymbol
+    def intern: (String name, Symbol kind, ?reserved: bool, ?location: IR::location?, ?documentation: String?, ?metadata_name: String?) -> IR::GrammarSymbol
 
     # @rbs (String name) -> IR::GrammarSymbol?
     def symbol: (String name) -> IR::GrammarSymbol?
@@ -92,5 +194,8 @@ module Ibex
 
     # @rbs (IR::location? location, String message) -> bot
     def fail_hash: (IR::location? location, String message) -> bot
+
+    # @rbs () -> IR::production_expansion?
+    def resolved_expansion: () -> IR::production_expansion?
   end
 end