ibex 0.1.0 → 0.3.0

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[IR::lexer_warning] warnings) -> void
+    def normalize_lexer_state: (Frontend::AST::LexerState definition, Array[String] states, Array[IR::LexerRule] rules, Array[IR::lexer_warning] warnings) -> void
+
+    # @rbs (Frontend::AST::LexerRule definition, String state, Integer id,
+    #   Array[IR::lexer_warning] warnings) -> IR::LexerRule
+    def normalize_lexer_rule: (Frontend::AST::LexerRule definition, String state, Integer id, Array[IR::lexer_warning] 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,33 @@
+# 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 (NormalizeParameters::parameter_frame frame,
+    #   Frontend::AST::Optional | Frontend::AST::Star | Frontend::AST::Plus item) -> void
+    def lower_parameter_suffix: (NormalizeParameters::parameter_frame frame, Frontend::AST::Optional | Frontend::AST::Star | Frontend::AST::Plus item) -> void
+
+    # @rbs (NormalizeParameters::parameter_frame frame,
+    #   Frontend::AST::Optional | Frontend::AST::Star | Frontend::AST::Plus item) -> void
+    def finish_parameter_suffix: (NormalizeParameters::parameter_frame frame, Frontend::AST::Optional | Frontend::AST::Star | Frontend::AST::Plus item) -> void
+
+    # @rbs (NormalizeParameters::parameter_frame frame, Frontend::AST::SeparatedList item) -> void
+    def lower_parameter_separated_list: (NormalizeParameters::parameter_frame frame, Frontend::AST::SeparatedList item) -> void
+
+    # @rbs (NormalizeParameters::parameter_frame frame, Frontend::AST::SeparatedList item) -> void
+    def finish_parameter_separated_list: (NormalizeParameters::parameter_frame frame, Frontend::AST::SeparatedList item) -> void
+
+    # @rbs (NormalizeParameters::parameter_frame frame, Frontend::AST::Group item) -> void
+    def lower_parameter_group: (NormalizeParameters::parameter_frame frame, Frontend::AST::Group item) -> void
+
+    # @rbs (NormalizeParameters::parameter_frame frame, String helper, Frontend::AST::Group item,
+    #   Array[Frontend::AST::item] alternative) -> void
+    def start_parameter_group_alternative: (NormalizeParameters::parameter_frame frame, String helper, Frontend::AST::Group item, Array[Frontend::AST::item] alternative) -> void
+
+    # @rbs (NormalizeParameters::parameter_frame frame, String helper,
+    #   Frontend::AST::Group item, Integer length) -> void
+    def finish_parameter_group_alternative: (NormalizeParameters::parameter_frame 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 (NormalizeParameters::parameter_frame frame) -> void
+    def advance_parameter_alternative: (NormalizeParameters::parameter_frame frame) -> void
+
+    # @rbs (NormalizeParameters::parameter_frame frame) { () -> void } -> void
+    def with_parameter_frame_context: (NormalizeParameters::parameter_frame frame) { () -> void } -> void
+
+    # @rbs (NormalizeParameters::parameter_frame frame) -> bool
+    def parameter_items_remaining?: (NormalizeParameters::parameter_frame frame) -> bool
+
+    # @rbs (NormalizeParameters::parameter_frame frame) -> void
+    def start_parameter_item: (NormalizeParameters::parameter_frame frame) -> void
+
+    # @rbs (NormalizeParameters::parameter_frame frame, NormalizeParameters::parameter_operation operation) -> void
+    def process_parameter_operation: (NormalizeParameters::parameter_frame frame, NormalizeParameters::parameter_operation operation) -> void
+
+    # @rbs (NormalizeParameters::parameter_frame frame, Frontend::AST::item item) -> void
+    def lower_parameter_item: (NormalizeParameters::parameter_frame frame, Frontend::AST::item item) -> void
+
+    # @rbs (NormalizeParameters::parameter_frame frame, Frontend::AST::ParameterizedReference item) -> void
+    def lower_parameter_call: (NormalizeParameters::parameter_frame frame, Frontend::AST::ParameterizedReference item) -> void
+
+    # @rbs (NormalizeParameters::parameter_frame frame, Frontend::AST::item item) -> void
+    def finish_parameter_item: (NormalizeParameters::parameter_frame frame, Frontend::AST::item item) -> void
+
+    # @rbs (NormalizeParameters::parameter_frame frame) -> void
+    def finish_parameter_alternative: (NormalizeParameters::parameter_frame 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,51 @@
+# Generated from lib/ibex/normalize/parameters.rb with RBS::Inline
+
+module Ibex
+  # Iterative, hygienic specialization of validated parameterized user rules.
+  # rubocop:disable Metrics/ModuleLength -- parameter-frame transitions are kept together for auditability.
+  module NormalizeParameters
+    type parameter_operation = [ :item | :finish_item, Frontend::AST::item ] | [ :value, String ] | [ :finish_suffix, Frontend::AST::Optional | Frontend::AST::Star | Frontend::AST::Plus ] | [ :finish_separated, Frontend::AST::SeparatedList ] | [ :group_alternative, String, Frontend::AST::Group, Array[Frontend::AST::item] ] | [ :finish_group_alternative, String, Frontend::AST::Group, Integer ]
+
+    type parameter_frame = { reference: Frontend::AST::ParameterizedReference, arguments: Array[Frontend::AST::item], helper: String, bindings: Hash[String, Frontend::AST::item], rendered_arguments: Array[String], templates: Array[Frontend::AST::Rule], template_index: Integer, alternative_index: Integer, current: [ Frontend::AST::Rule, Frontend::AST::Rule, Frontend::AST::Alternative ]?, item_index: Integer, rhs: Array[String], named_refs: Array[IR::named_ref], operations: Array[parameter_operation], values: Array[String] }
+
+    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) ->
+    #   NormalizeParameters::parameter_frame
+    def parameter_frame: (Frontend::AST::ParameterizedReference reference, String helper, Array[Frontend::AST::item] arguments, Array[String] rendered_arguments) -> NormalizeParameters::parameter_frame
+
+    # @rbs () -> void
+    def drain_parameter_worklist: () -> void
+
+    # @rbs (NormalizeParameters::parameter_frame frame) -> bool
+    def prepare_parameter_alternative?: (NormalizeParameters::parameter_frame frame) -> bool
+
+    # @rbs (NormalizeParameters::parameter_frame frame, Frontend::AST::Rule template, Integer index) -> void
+    def prepare_parameter_alternative_entry: (NormalizeParameters::parameter_frame frame, Frontend::AST::Rule template, Integer index) -> void
+
+    # @rbs (NormalizeParameters::parameter_frame frame) -> void
+    def clear_parameter_alternative: (NormalizeParameters::parameter_frame frame) -> void
+  end
+end

data/sig/ibex/normalize/parser_configuration.rbs

@@ -0,0 +1,23 @@
+# Generated from lib/ibex/normalize/parser_configuration.rb with RBS::Inline
+
+module Ibex
+  # Converts a root parser declaration into the explicit current Grammar IR contract.
+  module NormalizeParserConfiguration
+    private
+
+    # @rbs (Frontend::AST::ParserConfiguration declaration) -> void
+    def read_parser_configuration: (Frontend::AST::ParserConfiguration declaration) -> void
+
+    # @rbs () -> IR::ParserContract?
+    def normalized_parser_contract: () -> IR::ParserContract?
+
+    # @rbs (Frontend::AST::ParserSetting setting) -> Hash[Symbol, Object?]
+    def validated_parser_setting_definition: (Frontend::AST::ParserSetting setting) -> Hash[Symbol, Object?]
+
+    # @rbs (Frontend::AST::ParserConfiguration declaration) -> void
+    def validate_isolated_entries: (Frontend::AST::ParserConfiguration declaration) -> void
+
+    # @rbs (Frontend::AST::ParserSetting setting) -> Location
+    def parser_setting_location: (Frontend::AST::ParserSetting setting) -> Location
+  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,147 @@ module Ibex
   class Normalizer
     include NormalizeDeclarations
 
+    include NormalizeParserConfiguration
+
+    include NormalizeGrammarBuilder
+
+    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]
+    @parser_configuration: Frontend::AST::ParserConfiguration?
 
-    @warnings: Array[IR::grammar_warning]
+    @lexer_declaration: Frontend::AST::Lexer?
 
-    @helper_sequence: Integer
+    @grammar_tests: Array[IR::grammar_test]
 
-    @declared_tokens: Hash[String, IR::location]
+    @on_error_reduce_groups: Array[Array[String]]
 
-    @precedence: Hash[String, IR::precedence]
+    @recovery_sync_tokens: Array[String]
 
-    @precedence_locations: Hash[String, IR::location]
+    @value_printers: Hash[String, IR::value_printer]
 
-    @options: IR::grammar_options
+    @parser_parameters: Array[IR::parser_parameter]
+
+    @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]
+
+    @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[NormalizeParameters::parameter_frame]
+
+    @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]
+
+    @precedence: Hash[String, IR::precedence]
+
+    @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, Object value) -> void
+    def validate_positive_limit!: (Symbol name, Object value) -> void
+
     # @rbs () -> void
     def intern_reserved_symbols: () -> void
 
@@ -60,8 +155,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 +200,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

data/sig/ibex/racc_migration/checker.rbs

@@ -0,0 +1,36 @@
+# Generated from lib/ibex/racc_migration/checker.rb with RBS::Inline
+
+module Ibex
+  module RaccMigration
+    # Checks syntax, normalization, superclass, and runtime-coupling hazards.
+    # Semantic action code is treated as opaque data and never executed.
+    class Checker
+      RACC_REQUIRE: Regexp
+
+      RACC_CONSTANT: Regexp
+
+      # @rbs (String source, file: String) -> Report
+      def check: (String source, file: String) -> Report
+
+      private
+
+      # @rbs (Frontend::Diagnostic diagnostic) -> Finding
+      def syntax_finding: (Frontend::Diagnostic diagnostic) -> Finding
+
+      # @rbs (Frontend::AST::Root ast) -> Array[Finding]
+      def superclass_findings: (Frontend::AST::Root ast) -> Array[Finding]
+
+      # @rbs (Frontend::AST::Root ast) -> Array[Finding]
+      def user_code_findings: (Frontend::AST::Root ast) -> Array[Finding]
+
+      # @rbs (Frontend::AST::Root ast) -> Array[Finding]
+      def normalization_findings: (Frontend::AST::Root ast) -> Array[Finding]
+
+      # @rbs (String message, Frontend::Location fallback) -> [Frontend::Location, String]
+      def error_location: (String message, Frontend::Location fallback) -> [ Frontend::Location, String ]
+
+      # @rbs (Array[Finding] findings) -> Array[Finding]
+      def sort_findings: (Array[Finding] findings) -> Array[Finding]
+    end
+  end
+end

data/sig/ibex/racc_migration/harness.rbs

@@ -0,0 +1,16 @@
+# Generated from lib/ibex/racc_migration/harness.rb with RBS::Inline
+
+module Ibex
+  module RaccMigration
+    # Emits, but never executes, a subprocess-separated differential harness.
+    class Harness
+      CLASS_NAME: Regexp
+
+      # @rbs (String class_name) -> String
+      def self.generate: (String class_name) -> String
+
+      # @rbs () -> String
+      def self.template: () -> String
+    end
+  end
+end

data/sig/ibex/racc_migration/report.rbs

@@ -0,0 +1,55 @@
+# Generated from lib/ibex/racc_migration/report.rb with RBS::Inline
+
+module Ibex
+  module RaccMigration
+    type json_value = String | Integer | Float | bool | nil | Array[json_value] | Hash[String, json_value]
+
+    # One immutable migration compatibility observation.
+    class Finding
+      SEVERITIES: Array[Symbol]
+
+      attr_reader code: String
+
+      attr_reader severity: Symbol
+
+      attr_reader message: String
+
+      attr_reader location: Frontend::Location?
+
+      attr_reader suggestion: String
+
+      # @rbs (code: String, severity: Symbol, message: String, location: Frontend::Location?,
+      #   suggestion: String) -> void
+      def initialize: (code: String, severity: Symbol, message: String, location: Frontend::Location?, suggestion: String) -> void
+
+      # @rbs () -> Hash[String, json_value]
+      def to_h: () -> Hash[String, json_value]
+    end
+
+    # Versioned result of checking one grammar without executing its code.
+    class Report
+      SCHEMA_VERSION: Integer
+
+      attr_reader file: String
+
+      attr_reader class_name: String?
+
+      attr_reader findings: Array[Finding]
+
+      # @rbs (file: String, class_name: String?, findings: Array[Finding]) -> void
+      def initialize: (file: String, class_name: String?, findings: Array[Finding]) -> void
+
+      # @rbs () -> bool
+      def compatible?: () -> bool
+
+      # @rbs () -> Hash[String, json_value]
+      def to_h: () -> Hash[String, json_value]
+
+      # @rbs (*Object?) -> String
+      def to_json: (*Object?) -> String
+
+      # @rbs () -> String
+      def to_text: () -> String
+    end
+  end
+end

data/sig/ibex/racc_migration.rbs

@@ -0,0 +1,8 @@
+# Generated from lib/ibex/racc_migration.rb with RBS::Inline
+
+module Ibex
+  # Static checks and explicitly generated differential tooling for migration
+  # from racc grammar files.
+  module RaccMigration
+  end
+end