ibex 0.1.0 → 0.3.0

data/sig/ibex/lsp/symbol_occurrence.rbs

@@ -0,0 +1,31 @@
+# Generated from lib/ibex/lsp/symbol_occurrence.rb with RBS::Inline
+
+module Ibex
+  module LSP
+    type symbol_key = [ :symbol, String ] | [ :parameter, String, Integer, String ] | [ :include, String ]
+
+    type symbol_data_value = String | Symbol | Integer | bool | nil | Array[String] | Hash[Symbol, symbol_data_value]
+
+    type symbol_data = Hash[Symbol, symbol_data_value]
+
+    # A source-backed grammar symbol definition or reference.
+    class SymbolOccurrence < Struct[String | Symbol | symbol_key | Frontend::SourceSpan | symbol_data]
+      attr_accessor name(): String
+
+      attr_accessor kind(): Symbol
+
+      attr_accessor role(): Symbol
+
+      attr_accessor key(): symbol_key
+
+      attr_accessor path(): String
+
+      attr_accessor span(): Frontend::SourceSpan
+
+      attr_accessor data(): symbol_data
+
+      def self.new: (?name: String, ?kind: Symbol, ?role: Symbol, ?key: symbol_key, ?path: String, ?span: Frontend::SourceSpan, ?data: symbol_data) -> instance
+                  | ({ ?name: String, ?kind: Symbol, ?role: Symbol, ?key: symbol_key, ?path: String, ?span: Frontend::SourceSpan, ?data: symbol_data }) -> instance
+    end
+  end
+end

data/sig/ibex/lsp/transport.rbs

@@ -0,0 +1,47 @@
+# Generated from lib/ibex/lsp/transport.rb with RBS::Inline
+
+module Ibex
+  module LSP
+    # Reads and writes bounded LSP JSON-RPC messages over Content-Length framing.
+    class Transport
+      interface _Input
+        def read: (Integer length) -> String?
+
+        def readpartial: (Integer length) -> String
+      end
+
+      interface _Output
+        def write: (String value) -> Object?
+
+        def flush: () -> Object?
+      end
+
+      HEADER_SEPARATOR: ::String
+
+      # @rbs (_Input input, _Output output) -> void
+      def initialize: (_Input input, _Output output) -> void
+
+      # @rbs () -> LSP::lsp_object?
+      def read_message: () -> LSP::lsp_object?
+
+      # @rbs (LSP::lsp_object message) -> void
+      def write_message: (LSP::lsp_object message) -> void
+
+      private
+
+      # @rbs () -> String?
+      def read_header: () -> String?
+
+      # @rbs (String header) -> Integer
+      def content_length: (String header) -> Integer
+
+      # @rbs (Integer length) -> String
+      def read_bytes: (Integer length) -> String
+
+      # IO#read(length) may wait for the entire length on a live pipe. readpartial
+      # lets the stdio server process the bytes that are already available.
+      # @rbs (Integer length) -> String?
+      def read_chunk: (Integer length) -> String?
+    end
+  end
+end

data/sig/ibex/lsp/workspace.rbs

@@ -0,0 +1,42 @@
+# Generated from lib/ibex/lsp/workspace.rb with RBS::Inline
+
+module Ibex
+  module LSP
+    # Converts file URIs to canonical paths constrained to initialized workspace roots.
+    class Workspace
+      attr_reader roots: Array[String]
+
+      # @rbs (Array[String] root_uris, Frontend::SourceLoader loader) -> void
+      def initialize: (Array[String] root_uris, Frontend::SourceLoader loader) -> void
+
+      # @rbs (String uri, ?allow_missing: bool) -> String
+      def path: (String uri, ?allow_missing: bool) -> String
+
+      # @rbs (String path) -> String
+      def uri: (String path) -> String
+
+      # @rbs (String path) -> String?
+      def root_for: (String path) -> String?
+
+      private
+
+      # URI is a stdlib boundary whose implementation class varies by scheme.
+      # URI parsing returns a scheme-specific URI::Generic subclass.
+      # @rbs (String uri) -> URI::Generic
+      def parse_file_uri: (String uri) -> URI::Generic
+
+      # Ruby's URI::File may discard userinfo and port, so validate the raw authority first.
+      # @rbs (String uri) -> void
+      def validate_raw_authority!: (String uri) -> void
+
+      # @rbs (String uri) -> String
+      def canonical_root: (String uri) -> String
+
+      # @rbs (String encoded) -> String
+      def decode_path: (String encoded) -> String
+
+      # @rbs (String path, String root) -> bool
+      def inside?: (String path, String root) -> bool
+    end
+  end
+end

data/sig/ibex/lsp/workspace_analyzer.rbs

@@ -0,0 +1,69 @@
+# Generated from lib/ibex/lsp/workspace_analyzer.rb with RBS::Inline
+
+module Ibex
+  module LSP
+    # Parses workspace sources, discovers safe include closures, and renders diagnostics.
+    class WorkspaceAnalyzer
+      GLOB_CHARACTERS: Regexp
+
+      WINDOWS_ABSOLUTE: Regexp
+
+      type lsp_diagnostic = lsp_object
+
+      type analyzed_document = { source: String, document: Frontend::SourceDocument?, diagnostics: Array[lsp_diagnostic] }
+
+      # @rbs (Workspace workspace, Frontend::SourceLoader loader) -> void
+      def initialize: (Workspace workspace, Frontend::SourceLoader loader) -> void
+
+      # @rbs (String path) -> analyzed_document
+      def analyze: (String path) -> analyzed_document
+
+      # @rbs (String root) -> [Array[String], Hash[String, analyzed_document]]
+      def closure: (String root) -> [ Array[String], Hash[String, analyzed_document] ]
+
+      # @rbs (String root) -> [Frontend::Resolution?, Array[lsp_diagnostic]]
+      def resolve: (String root) -> [ Frontend::Resolution?, Array[lsp_diagnostic] ]
+
+      private
+
+      # @rbs (String path, String source) -> analyzed_document
+      def analyze_root: (String path, String source) -> analyzed_document
+
+      # @rbs (String path, String source) -> analyzed_document
+      def analyze_fragment: (String path, String source) -> analyzed_document
+
+      # @rbs (String source, String path) -> bool
+      def fragment_source?: (String source, String path) -> bool
+
+      # @rbs (Frontend::SourceDocument? document) -> Array[String]
+      def dependencies: (Frontend::SourceDocument? document) -> Array[String]
+
+      # @rbs (Frontend::AST::Include include_node) -> String
+      def canonical_include: (Frontend::AST::Include include_node) -> String
+
+      # @rbs (Frontend::AST::Include include_node) -> bot
+      def invalid_include: (Frontend::AST::Include include_node) -> bot
+
+      # @rbs (String message, String source, String fallback_path) -> lsp_diagnostic
+      def diagnostic: (String message, String source, String fallback_path) -> lsp_diagnostic
+
+      # @rbs (Frontend::Diagnostic diagnostic, String source) -> lsp_diagnostic
+      def frontend_diagnostic: (Frontend::Diagnostic diagnostic, String source) -> lsp_diagnostic
+
+      # @rbs (String message, String fallback_path) -> [String, Integer, Integer, String]
+      def diagnostic_parts: (String message, String fallback_path) -> [ String, Integer, Integer, String ]
+
+      # @rbs (String source, Integer line, Integer column) -> Hash[String, Hash[String, Integer]]
+      def diagnostic_range: (String source, Integer line, Integer column) -> Hash[String, Hash[String, Integer]]
+
+      # @rbs (String path) -> String
+      def readable_source: (String path) -> String
+
+      # @rbs (String message, String fallback) -> String
+      def file_for_error: (String message, String fallback) -> String
+
+      # @rbs (String message, String fallback) -> String
+      def source_for_error: (String message, String fallback) -> String
+    end
+  end
+end

data/sig/ibex/lsp.rbs

@@ -0,0 +1,7 @@
+# Generated from lib/ibex/lsp.rb with RBS::Inline
+
+module Ibex
+  # Language Server Protocol support for grammar workspaces.
+  module LSP
+  end
+end

data/sig/ibex/messages.rbs

@@ -0,0 +1,26 @@
+# Generated from lib/ibex/messages.rb with RBS::Inline
+
+module Ibex
+  # Immutable built-in diagnostic translations, separate from user E00xx
+  # sentence-keyed parser error catalogs.
+  module Messages
+    ROOT: String
+
+    LANGUAGES: Array[String]
+
+    # @rbs (String? requested) -> String
+    def self?.language: (String? requested) -> String
+
+    # @rbs (String id, ?language: String, **Object? values) -> String
+    def self?.translate: (String id, ?language: String, **Object? values) -> String
+
+    # @rbs (String id) -> bool
+    def self?.known?: (String id) -> bool
+
+    # @rbs (String language) -> Hash[String, String]
+    def self?.catalog: (String language) -> Hash[String, String]
+
+    # @rbs (String language) -> Hash[String, String]
+    def self?.load_catalog: (String language) -> Hash[String, String]
+  end
+end

data/sig/ibex/metrics.rbs

@@ -0,0 +1,50 @@
+# Generated from lib/ibex/metrics.rb with RBS::Inline
+
+module Ibex
+  # Deterministic structural metrics over normalized Grammar and Automaton IR.
+  class Metrics
+    type report_value = String | Integer | Float | Array[report_value] | Hash[Symbol, report_value]
+
+    # @rbs (IR::Automaton automaton) -> void
+    def initialize: (IR::Automaton automaton) -> void
+
+    # @rbs () -> Hash[Symbol, report_value]
+    def to_h: () -> Hash[Symbol, report_value]
+
+    private
+
+    # @rbs () -> Hash[Symbol, Integer]
+    def symbol_metrics: () -> Hash[Symbol, Integer]
+
+    # @rbs () -> Hash[Symbol, report_value]
+    def grammar_metrics: () -> Hash[Symbol, report_value]
+
+    # @rbs () -> Hash[Symbol, report_value]
+    def automaton_metrics: () -> Hash[Symbol, report_value]
+
+    # @rbs (Array[Integer] values) -> Float
+    def average: (Array[Integer] values) -> Float
+
+    # @rbs () -> Hash[Integer, Array[Integer]]
+    def dependency_graph: () -> Hash[Integer, Array[Integer]]
+
+    # @rbs () -> Hash[Integer, Set[Integer]]
+    def reachability: () -> Hash[Integer, Set[Integer]]
+
+    # @rbs () -> Array[Array[Integer]]
+    def recursion_components: () -> Array[Array[Integer]]
+
+    # @rbs () -> Array[Integer]
+    def recursive_nonterminal_ids: () -> Array[Integer]
+
+    # Longest path after collapsing mutually recursive nonterminals.
+    # @rbs () -> Integer
+    def recursion_component_depth: () -> Integer
+
+    # @rbs (Array[Set[Integer]] edges) -> Integer
+    def longest_dag_path: (Array[Set[Integer]] edges) -> Integer
+
+    # @rbs (Integer id) -> String
+    def symbol_name: (Integer id) -> String
+  end
+end

data/sig/ibex/normalize/declarations.rbs

@@ -11,6 +11,37 @@ module Ibex
     # @rbs (Frontend::AST::declaration declaration) -> void
     def read_declaration: (Frontend::AST::declaration declaration) -> void
 
+    # @rbs (Frontend::AST::Start declaration) -> void
+    def read_start_declaration: (Frontend::AST::Start declaration) -> void
+
+    # @rbs (Frontend::AST::symbol_metadata | Frontend::AST::Parameter | Frontend::AST::Printer declaration) -> void
+    def read_extended_declaration: (Frontend::AST::symbol_metadata | Frontend::AST::Parameter | Frontend::AST::Printer declaration) -> void
+
+    # @rbs (Frontend::AST::Printer declaration) -> void
+    def read_value_printer: (Frontend::AST::Printer declaration) -> void
+
+    # @rbs () -> void
+    def validate_value_printers: () -> void
+
+    # @rbs (Frontend::AST::Parameter declaration) -> void
+    def read_parser_parameter: (Frontend::AST::Parameter declaration) -> void
+
+    # @rbs (Frontend::AST::Tokens declaration) -> void
+    def read_tokens: (Frontend::AST::Tokens declaration) -> void
+
+    # @rbs (Frontend::AST::Options declaration) -> void
+    def read_options: (Frontend::AST::Options declaration) -> void
+
+    # @rbs (Frontend::AST::Convert declaration) -> void
+    def read_conversions: (Frontend::AST::Convert declaration) -> void
+
+    # @rbs (Frontend::AST::symbol_metadata declaration) -> void
+    def read_symbol_metadata_declaration: (Frontend::AST::symbol_metadata declaration) -> void
+
+    # @rbs (Frontend::AST::symbol_metadata declaration, Hash[String, String] values,
+    #   Hash[String, IR::location] locations, String label) -> void
+    def read_symbol_metadata: (Frontend::AST::symbol_metadata declaration, Hash[String, String] values, Hash[String, IR::location] locations, String label) -> void
+
     # @rbs (Frontend::AST::Precedence declaration) -> void
     def read_precedence: (Frontend::AST::Precedence declaration) -> void
 

data/sig/ibex/normalize/diagnostics.rbs

@@ -8,23 +8,32 @@ module Ibex
     # @rbs () -> void
     def validate_grammar: () -> void
 
+    # @rbs () -> void
+    def validate_symbol_metadata: () -> 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 () -> Hash[Integer, true]
+    def reachable_symbol_ids: () -> Hash[Integer, true]
 
     # @rbs () -> void
     def warn_unused_terminals: () -> void
 
+    # @rbs () -> void
+    def warn_unreachable_terminals: () -> void
+
+    # @rbs () -> void
+    def warn_unused_precedence: () -> void
+
     # @rbs () -> void
     def warn_empty_language: () -> void
 
-    # @rbs () -> Set[Integer]
-    def productive_terminal_ids: () -> Set[Integer]
+    # @rbs () -> Hash[Integer, true]
+    def productive_terminal_ids: () -> Hash[Integer, true]
 
     # @rbs (IR::GrammarSymbol grammar_symbol) -> bool
     def productive_terminal?: (IR::GrammarSymbol grammar_symbol) -> bool

data/sig/ibex/normalize/expander.rbs

@@ -11,6 +11,9 @@ module Ibex
     # @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::Alternative alternative) -> Array[Frontend::AST::item]
+    def normalized_alternative_items: (Frontend::AST::Alternative alternative) -> Array[Frontend::AST::item]
+
     # @rbs (Frontend::AST::item item) -> String
     def normalize_item: (Frontend::AST::item item) -> String
 
@@ -20,47 +23,50 @@ module Ibex
     # @rbs (Frontend::AST::Optional item) -> String
     def expand_optional: (Frontend::AST::Optional item) -> String
 
+    # @rbs (Frontend::AST::Optional item, String base) -> String
+    def build_optional: (Frontend::AST::Optional item, String base) -> String
+
     # @rbs (Frontend::AST::Star item) -> String
     def expand_star: (Frontend::AST::Star item) -> String
 
+    # @rbs (Frontend::AST::Star item, String base) -> String
+    def build_star: (Frontend::AST::Star item, String base) -> String
+
     # @rbs (Frontend::AST::Plus item) -> String
     def expand_plus: (Frontend::AST::Plus item) -> String
 
+    # @rbs (Frontend::AST::Plus item, String base) -> String
+    def build_plus: (Frontend::AST::Plus item, String base) -> String
+
     # @rbs (Frontend::AST::SeparatedList item) -> String
     def expand_separated_list: (Frontend::AST::SeparatedList item) -> String
 
+    # @rbs (Frontend::AST::SeparatedList item, String base, String separator) -> String
+    def build_separated_list: (Frontend::AST::SeparatedList item, String base, String separator) -> String
+
     # @rbs (Frontend::AST::Group item) -> String
     def expand_group: (Frontend::AST::Group item) -> String
 
+    # @rbs (String helper, Array[String] rhs, Frontend::AST::Group item) -> void
+    def add_group_production: (String helper, Array[String] rhs, Frontend::AST::Group item) -> void
+
     # @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 (Symbol kind, Frontend::AST::item item) -> Hash[Symbol, Object?]
+    def synthetic_origin: (Symbol kind, Frontend::AST::item item) -> Hash[Symbol, Object?]
 
     # @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
+    #   Hash[Symbol, untyped] origin, ?String? documentation, ?IR::node_annotation? node) -> void
+    def add_production: (String lhs_name, Array[String] rhs_names, IR::Action? action, String? precedence_name, Hash[Symbol, untyped] origin, ?String? documentation, ?IR::node_annotation? node) -> void
   end
 end

data/sig/ibex/normalize/expression.rbs

@@ -3,19 +3,21 @@
 module Ibex
   # Deterministically renders frontend EBNF items for production origin metadata.
   module NormalizeExpression
-    private def render_reference: (Frontend::AST::SymbolReference item) -> String
+    type pending_item = String | Frontend::AST::item
 
-    private def self.render_reference: (Frontend::AST::SymbolReference item) -> String
-
-    private def render_group: (Frontend::AST::Group item) -> String
+    # @rbs (Frontend::AST::item item) -> String
+    def self.render: (Frontend::AST::item item) -> String
 
-    private def self.render_group: (Frontend::AST::Group item) -> String
+    # @rbs (Array[pending_item] pending, Frontend::AST::item item) -> void
+    private def self.push_render_item: (Array[pending_item] pending, Frontend::AST::item item) -> void
 
-    private def render_separated_list: (Frontend::AST::SeparatedList item) -> String
+    # @rbs (Array[pending_item] pending, Frontend::AST::ParameterizedReference item) -> void
+    private def self.push_render_parameterized_reference: (Array[pending_item] pending, Frontend::AST::ParameterizedReference item) -> void
 
-    private def self.render_separated_list: (Frontend::AST::SeparatedList item) -> String
+    # @rbs (Array[pending_item] pending, Frontend::AST::Group item) -> void
+    private def self.push_render_group: (Array[pending_item] pending, Frontend::AST::Group item) -> void
 
-    # @rbs (Frontend::AST::item item) -> String
-    def self?.render: (Frontend::AST::item item) -> String
+    # @rbs (Array[pending_item] pending, Array[Frontend::AST::item] items, String separator) -> void
+    private def self.push_render_items: (Array[pending_item] pending, Array[Frontend::AST::item] items, String separator) -> void
   end
 end

data/sig/ibex/normalize/grammar_builder.rbs

@@ -0,0 +1,11 @@
+# Generated from lib/ibex/normalize/grammar_builder.rb with RBS::Inline
+
+module Ibex
+  # Builds the single current Grammar IR format for every normalized source.
+  module NormalizeGrammarBuilder
+    private
+
+    # @rbs (IR::ParserContract? parser_contract) -> IR::Grammar
+    def build_grammar: (IR::ParserContract? parser_contract) -> IR::Grammar
+  end
+end

data/sig/ibex/normalize/inline_expansion.rbs

@@ -0,0 +1,129 @@
+# 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
+    type inline_reference = [ :physical | :step, Integer ]
+
+    type inline_step = { kind: :inline | :rule, rule: String?, code: String?, loc: IR::location, named_refs: Array[IR::named_ref], context_length: Integer, inputs: Array[inline_reference], stack_inputs: Array[inline_reference], lookahead: Integer, result_var: bool, result_type: String? }
+
+    type inline_variant = { rhs: Array[Integer], steps: Array[inline_step], logical_refs: Array[inline_reference], output_ref: inline_reference?, inline_used: bool, inline_rule: String?, precedence_override: Integer?, precedence_contributes: bool, parameter: IR::parameter_expansion? }
+
+    type inline_frame = { production: IR::Production, symbol_id: Integer?, index: Integer, variant: inline_variant }
+
+    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[inline_variant]
+    def expand_inline_production: (IR::Production production, Hash[Integer, Array[IR::Production]] definitions) -> Array[inline_variant]
+
+    # @rbs (Array[inline_frame] frames, Hash[Integer, Array[IR::Production]] definitions,
+    #   Array[Array[inline_frame]] worklist, Array[inline_variant] variants,
+    #   IR::location? location) -> void
+    def drain_inline_expansion_frames: (Array[inline_frame] frames, Hash[Integer, Array[IR::Production]] definitions, Array[Array[inline_frame]] worklist, Array[inline_variant] variants, IR::location? location) -> void
+
+    # @rbs (Array[inline_frame] frames, Hash[Integer, Array[IR::Production]] definitions,
+    #   Array[Array[inline_frame]] worklist, Array[inline_variant] variants,
+    #   IR::location? location) -> bool
+    def advance_inline_expansion_frame?: (Array[inline_frame] frames, Hash[Integer, Array[IR::Production]] definitions, Array[Array[inline_frame]] worklist, Array[inline_variant] variants, IR::location? location) -> bool
+
+    # @rbs (Array[inline_frame] frames, Array[IR::Production] choices, Integer symbol_id,
+    #   Array[Array[inline_frame]] worklist) -> void
+    def schedule_inline_choice_branches: (Array[inline_frame] frames, Array[IR::Production] choices, Integer symbol_id, Array[Array[inline_frame]] worklist) -> void
+
+    # @rbs (Array[inline_frame] frames, Array[inline_variant] variants,
+    #   Array[Array[inline_frame]] worklist, IR::location? location) -> bool
+    def complete_inline_expansion_frame?: (Array[inline_frame] frames, Array[inline_variant] variants, Array[Array[inline_frame]] worklist, IR::location? location) -> bool
+
+    # @rbs (IR::Production production, Integer? symbol_id) -> inline_frame
+    def inline_expansion_frame: (IR::Production production, Integer? symbol_id) -> inline_frame
+
+    # @rbs (Array[inline_frame] frames) -> Array[inline_frame]
+    def clone_inline_expansion_frames: (Array[inline_frame] frames) -> Array[inline_frame]
+
+    # @rbs (IR::Production production) -> inline_variant
+    def empty_inline_variant: (IR::Production production) -> inline_variant
+
+    # @rbs (inline_variant variant, Integer symbol_id) -> inline_variant
+    def append_inline_symbol: (inline_variant variant, Integer symbol_id) -> inline_variant
+
+    # @rbs (inline_variant parent, inline_variant child) -> inline_variant
+    def combine_inline_variant: (inline_variant parent, inline_variant child) -> inline_variant
+
+    # @rbs (inline_variant parent, inline_variant child,
+    #   Integer physical_offset, Integer step_offset) -> Array[inline_step]
+    def combined_inline_steps: (inline_variant parent, inline_variant child, Integer physical_offset, Integer step_offset) -> Array[inline_step]
+
+    # The helper is shared by homogeneous integer and step arrays; callers
+    # assert the concrete element type at each use site.
+    # @rbs (Array[Object?] left, Array[Object?] right) -> Array[Object?]
+    def append_inline_array: (Array[Object?] left, Array[Object?] right) -> Array[Object?]
+
+    # @rbs (inline_variant parent, inline_variant child) -> Integer?
+    def combined_inline_precedence: (inline_variant parent, inline_variant child) -> Integer?
+
+    # @rbs (inline_variant parent, inline_variant child,
+    #   Integer physical_offset, Integer step_offset) -> Array[inline_step]
+    def remap_inline_steps: (inline_variant parent, inline_variant child, Integer physical_offset, Integer step_offset) -> Array[inline_step]
+
+    # @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 (inline_variant variant, IR::Production production) -> inline_variant
+    def finish_inline_precedence: (inline_variant variant, IR::Production production) -> inline_variant
+
+    # @rbs (inline_variant variant, IR::Production production, Integer symbol_id) -> inline_variant
+    def finish_inline_choice: (inline_variant variant, IR::Production production, Integer symbol_id) -> inline_variant
+
+    # @rbs (IR::Production production, Array[inline_reference] inputs, Integer lookahead,
+    #   :inline | :rule kind, String? rule) -> inline_step
+    def inline_action_step: (IR::Production production, Array[inline_reference] inputs, Integer lookahead, :inline | :rule kind, String? rule) -> inline_step
+
+    # @rbs (IR::Production production, inline_variant variant, Integer id) -> IR::Production
+    def composed_inline_production: (IR::Production production, inline_variant variant, Integer id) -> IR::Production
+
+    # @rbs (IR::Production production, Integer physical_length, Array[inline_step]) -> IR::Action
+    def composed_inline_action: (IR::Production production, Integer physical_length, Array[inline_step]) -> IR::Action
+
+    # @rbs (inline_step step, Integer physical_length) -> IR::action_composition_step
+    def composition_plan_step: (inline_step step, Integer physical_length) -> IR::action_composition_step
+
+    # @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, inline_variant variant) -> IR::production_expansion
+    def inline_production_expansion: (IR::Production production, inline_variant 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