rusa 0.1.0

data/sig/generated/rusa/analysis/conflict_resolver.rbs

@@ -0,0 +1,57 @@
+# Generated from lib/rusa/analysis/conflict_resolver.rb with RBS::Inline
+
+module Rusa
+  module Analysis
+    class ConflictReport
+      attr_reader state_id: Integer
+
+      attr_reader lookahead: Symbol
+
+      attr_reader existing_action: Shift | Reduce | Accept
+
+      attr_reader new_action: Shift | Reduce | Accept
+
+      attr_reader resolved_action: Shift | Reduce | Accept | nil
+
+      attr_reader message: String
+
+      # : (state_id: Integer, lookahead: Symbol, existing_action: Shift | Reduce | Accept, new_action: Shift | Reduce | Accept, resolved_action: Shift | Reduce | Accept | nil, message: String) -> void
+      def initialize: (state_id: Integer, lookahead: Symbol, existing_action: Shift | Reduce | Accept, new_action: Shift | Reduce | Accept, resolved_action: Shift | Reduce | Accept | nil, message: String) -> void
+    end
+
+    # ConflictResolver applies precedence and associativity rules to ACTION conflicts.
+    class ConflictResolver
+      # : (Shift | Reduce | Accept, Shift | Reduce | Accept, Symbol, Grammar::Grammar, state_id: Integer, productions_by_id: Hash[Integer?, Grammar::Production]) -> [Shift | Reduce | Accept | nil, ConflictReport]
+      def resolve: (Shift | Reduce | Accept, Shift | Reduce | Accept, Symbol, Grammar::Grammar, state_id: Integer, productions_by_id: Hash[Integer?, Grammar::Production]) -> [ Shift | Reduce | Accept | nil, ConflictReport ]
+
+      private
+
+      # : (Shift | Reduce | Accept, Shift | Reduce | Accept, Symbol, Grammar::Grammar, state_id: Integer, productions_by_id: Hash[Integer?, Grammar::Production]) -> ConflictReport
+      def build_report: (Shift | Reduce | Accept, Shift | Reduce | Accept, Symbol, Grammar::Grammar, state_id: Integer, productions_by_id: Hash[Integer?, Grammar::Production]) -> ConflictReport
+
+      # : (Shift, Reduce, Symbol, Grammar::Grammar, Hash[Integer?, Grammar::Production], Integer) -> ConflictReport
+      def resolve_shift_reduce: (Shift, Reduce, Symbol, Grammar::Grammar, Hash[Integer?, Grammar::Production], Integer) -> ConflictReport
+
+      # : (Shift, Reduce, Grammar::Precedence, Grammar::Precedence) -> [Shift | Reduce | nil, String]
+      def compare_precedences: (Shift, Reduce, Grammar::Precedence, Grammar::Precedence) -> [ Shift | Reduce | nil, String ]
+
+      # : (Reduce, Reduce, Symbol, Integer) -> ConflictReport
+      def resolve_reduce_reduce: (Reduce, Reduce, Symbol, Integer) -> ConflictReport
+
+      # : (Integer, Symbol, Shift | Reduce | Accept, Shift | Reduce | Accept) -> ConflictReport
+      def duplicate_action_report: (Integer, Symbol, Shift | Reduce | Accept, Shift | Reduce | Accept) -> ConflictReport
+
+      # : (Shift, Symbol) -> [Shift, String]
+      def default_shift_resolution: (Shift, Symbol) -> [ Shift, String ]
+
+      # : (Shift) -> [Shift, String]
+      def higher_token_precedence_result: (Shift) -> [ Shift, String ]
+
+      # : (Reduce) -> [Reduce, String]
+      def higher_production_precedence_result: (Reduce) -> [ Reduce, String ]
+
+      # : (state_id: Integer, lookahead: Symbol, existing_action: Shift | Reduce | Accept, new_action: Shift | Reduce | Accept, resolved_action: Shift | Reduce | Accept | nil, message: String) -> ConflictReport
+      def build_conflict_report: (state_id: Integer, lookahead: Symbol, existing_action: Shift | Reduce | Accept, new_action: Shift | Reduce | Accept, resolved_action: Shift | Reduce | Accept | nil, message: String) -> ConflictReport
+    end
+  end
+end

data/sig/generated/rusa/analysis/first_follow.rbs

@@ -0,0 +1,33 @@
+# Generated from lib/rusa/analysis/first_follow.rb with RBS::Inline
+
+module Rusa
+  module Analysis
+    # FIRST/FOLLOW sets drive lookahead computation for parser construction.
+    class FirstFollow
+      EMPTY: ::Symbol
+
+      attr_reader first_sets: Hash[Symbol, Set[Symbol]]
+
+      attr_reader follow_sets: Hash[Symbol, Set[Symbol]]
+
+      # : (Grammar::Grammar) -> void
+      def initialize: (Grammar::Grammar) -> void
+
+      # : (Array[Symbol]) -> Set[Symbol]
+      def first_of_sequence: (Array[Symbol]) -> Set[Symbol]
+
+      private
+
+      attr_reader grammar: Grammar::Grammar
+
+      # : () -> void
+      def initialize_sets: () -> void
+
+      # : () -> void
+      def compute_first_sets: () -> void
+
+      # : () -> void
+      def compute_follow_sets: () -> void
+    end
+  end
+end

data/sig/generated/rusa/analysis/item.rbs

@@ -0,0 +1,35 @@
+# Generated from lib/rusa/analysis/item.rb with RBS::Inline
+
+module Rusa
+  module Analysis
+    # Item represents a single LR(0) production with a dot position.
+    class Item
+      attr_reader production: Grammar::Production
+
+      attr_reader dot: Integer
+
+      # : (Grammar::Production, ?Integer) -> void
+      def initialize: (Grammar::Production, ?Integer) -> void
+
+      # : () -> Symbol?
+      def next_symbol: () -> Symbol?
+
+      # : () -> Item
+      def advance: () -> Item
+
+      # : () -> bool
+      def reduce?: () -> bool
+
+      # : (Object) -> bool
+      def ==: (Object) -> bool
+
+      alias eql? ==
+
+      # : () -> Integer
+      def hash: () -> Integer
+
+      # : () -> String
+      def to_s: () -> String
+    end
+  end
+end

data/sig/generated/rusa/analysis/item_set.rbs

@@ -0,0 +1,31 @@
+# Generated from lib/rusa/analysis/item_set.rb with RBS::Inline
+
+module Rusa
+  module Analysis
+    # ItemSet is a parser state identified by its LR(0) kernel items.
+    class ItemSet
+      attr_reader id: Integer
+
+      attr_reader items: Set[Item]
+
+      attr_reader kernel_items: Set[Item]
+
+      # : (Integer, Enumerable[Item], Grammar::Grammar) -> void
+      def initialize: (Integer, Enumerable[Item], Grammar::Grammar) -> void
+
+      # : (Object) -> bool
+      def ==: (Object) -> bool
+
+      alias eql? ==
+
+      # : () -> Integer
+      def hash: () -> Integer
+
+      # : () -> String
+      def to_s: () -> String
+
+      # : (Enumerable[Item], Grammar::Grammar) -> Set[Item]
+      def self.closure: (Enumerable[Item], Grammar::Grammar) -> Set[Item]
+    end
+  end
+end

data/sig/generated/rusa/analysis/lalr_table.rbs

@@ -0,0 +1,182 @@
+# Generated from lib/rusa/analysis/lalr_table.rb with RBS::Inline
+
+module Rusa
+  module Analysis
+    # LALRTable merges canonical LR(1) states with the same LR(0) core.
+    class LALRTable
+      class LR1Item
+        attr_reader production: Grammar::Production
+
+        attr_reader dot: Integer
+
+        attr_reader lookahead: Symbol
+
+        # : (Grammar::Production, Integer, Symbol) -> void
+        def initialize: (Grammar::Production, Integer, Symbol) -> void
+
+        # : () -> Symbol?
+        def next_symbol: () -> Symbol?
+
+        # : () -> LR1Item
+        def advance: () -> LR1Item
+
+        # : () -> bool
+        def reduce?: () -> bool
+
+        # : () -> [Integer?, Integer]
+        def core: () -> [ Integer?, Integer ]
+
+        # : (Object) -> bool
+        def ==: (Object) -> bool
+
+        alias eql? ==
+
+        # : () -> Integer
+        def hash: () -> Integer
+      end
+
+      class MergedItem
+        attr_reader production: Grammar::Production
+
+        attr_reader dot: Integer
+
+        attr_reader lookaheads: Set[Symbol]
+
+        # : (Grammar::Production, Integer, Set[Symbol]) -> void
+        def initialize: (Grammar::Production, Integer, Set[Symbol]) -> void
+
+        # : () -> Symbol?
+        def next_symbol: () -> Symbol?
+
+        # : () -> bool
+        def reduce?: () -> bool
+
+        # : () -> [Integer?, Integer]
+        def core: () -> [ Integer?, Integer ]
+      end
+
+      class MergedState
+        attr_reader id: Integer
+
+        attr_reader items: Array[MergedItem]
+
+        # : (Integer, Array[MergedItem]) -> void
+        def initialize: (Integer, Array[MergedItem]) -> void
+      end
+
+      attr_reader action_table: Hash[Integer, Hash[Symbol, Shift | Reduce | Accept]]
+
+      attr_reader goto_table: Hash[Integer, Hash[Symbol, Integer]]
+
+      attr_reader conflicts: Array[ConflictReport]
+
+      attr_reader states: Array[MergedState]
+
+      attr_reader transitions: Hash[Integer, Hash[Symbol, Integer]]
+
+      # : (Grammar::Grammar, ?first_follow: FirstFollow) -> void
+      def initialize: (Grammar::Grammar, ?first_follow: FirstFollow) -> void
+
+      # : () -> String
+      def report: () -> String
+
+      private
+
+      attr_reader grammar: Grammar::Grammar
+
+      attr_reader first_follow: FirstFollow
+
+      attr_reader resolver: ConflictResolver
+
+      # : () -> void
+      def build_tables: () -> void
+
+      # : () -> [Array[Set[LR1Item]], Hash[Integer, Hash[Symbol, Integer]]]
+      def build_canonical_automaton: () -> [ Array[Set[LR1Item]], Hash[Integer, Hash[Symbol, Integer]] ]
+
+      # : (Enumerable[LR1Item]) -> Set[LR1Item]
+      def lr1_closure: (Enumerable[LR1Item]) -> Set[LR1Item]
+
+      # : (Enumerable[LR1Item]) -> Array[Array[Integer | nil | Symbol]]
+      def lr1_state_key: (Enumerable[LR1Item]) -> Array[Array[Integer | nil | Symbol]]
+
+      # : (Array[Set[LR1Item]], Hash[Integer, Hash[Symbol, Integer]]) -> void
+      def merge_states: (Array[Set[LR1Item]], Hash[Integer, Hash[Symbol, Integer]]) -> void
+
+      # : (Enumerable[LR1Item]) -> Array[Array[Integer?]]
+      def lr0_core_key: (Enumerable[LR1Item]) -> Array[Array[Integer?]]
+
+      # : () -> void
+      def populate_tables: () -> void
+
+      # : (Integer, Symbol, Shift | Reduce | Accept, Hash[Integer?, Grammar::Production]) -> void
+      def add_action: (Integer, Symbol, Shift | Reduce | Accept, Hash[Integer?, Grammar::Production]) -> void
+
+      # : () -> Set[LR1Item]
+      def initial_lr1_state: () -> Set[LR1Item]
+
+      # : () -> Hash[Integer, Hash[Symbol, Integer]]
+      def empty_transition_table: () -> Hash[Integer, Hash[Symbol, Integer]]
+
+      # : (Array[Set[LR1Item]], Hash[Integer, Hash[Symbol, Integer]], Hash[Array[Array[Integer | nil | Symbol]], Integer], Array[Integer], Integer) -> void
+      def build_canonical_transitions_for: (Array[Set[LR1Item]], Hash[Integer, Hash[Symbol, Integer]], Hash[Array[Array[Integer | nil | Symbol]], Integer], Array[Integer], Integer) -> void
+
+      # : (Set[LR1Item]) -> Array[Symbol]
+      def next_symbols_for: (Set[LR1Item]) -> Array[Symbol]
+
+      # : (Set[LR1Item], Symbol) -> Set[LR1Item]
+      def target_state_for: (Set[LR1Item], Symbol) -> Set[LR1Item]
+
+      # : (Array[Set[LR1Item]], Hash[Array[Array[Integer | nil | Symbol]], Integer], Array[Integer], Set[LR1Item]) -> Integer
+      def register_state: (Array[Set[LR1Item]], Hash[Array[Array[Integer | nil | Symbol]], Integer], Array[Integer], Set[LR1Item]) -> Integer
+
+      # : (Set[LR1Item], LR1Item, Symbol) -> bool
+      def add_closure_items: (Set[LR1Item], LR1Item, Symbol) -> bool
+
+      # : (LR1Item) -> Set[Symbol]
+      def closure_lookaheads_for: (LR1Item) -> Set[Symbol]
+
+      # : (Array[Set[LR1Item]]) -> Hash[Array[Array[Integer?]], Array[Integer]]
+      def group_states_by_lr0_core: (Array[Set[LR1Item]]) -> Hash[Array[Array[Integer?]], Array[Integer]]
+
+      # : () -> Hash[Array[Array[Integer?]], Array[Integer]]
+      def grouped_state_index: () -> Hash[Array[Array[Integer?]], Array[Integer]]
+
+      # : (Array[Set[LR1Item]], Array[Integer], Hash[Integer, Integer], Integer) -> MergedState
+      def merge_state_group: (Array[Set[LR1Item]], Array[Integer], Hash[Integer, Integer], Integer) -> MergedState
+
+      # : (Hash[[Integer?, Integer], MergedItem], Set[LR1Item]) -> void
+      def merge_items_from_state: (Hash[[ Integer?, Integer ], MergedItem], Set[LR1Item]) -> void
+
+      # : (Hash[[Integer?, Integer], MergedItem]) -> Array[MergedItem]
+      def sorted_merged_items: (Hash[[ Integer?, Integer ], MergedItem]) -> Array[MergedItem]
+
+      # : (Hash[Integer, Hash[Symbol, Integer]], Hash[Integer, Integer]) -> void
+      def merge_transitions: (Hash[Integer, Hash[Symbol, Integer]], Hash[Integer, Integer]) -> void
+
+      # : () -> Hash[Integer?, Grammar::Production]
+      def index_productions_by_id: () -> Hash[Integer?, Grammar::Production]
+
+      # : (MergedState, Hash[Integer?, Grammar::Production]) -> void
+      def populate_actions_for: (MergedState, Hash[Integer?, Grammar::Production]) -> void
+
+      # : (Integer, Symbol, Hash[Integer?, Grammar::Production]) -> void
+      def add_shift_action: (Integer, Symbol, Hash[Integer?, Grammar::Production]) -> void
+
+      # : (Integer, MergedItem, Hash[Integer?, Grammar::Production]) -> void
+      def populate_reduce_actions: (Integer, MergedItem, Hash[Integer?, Grammar::Production]) -> void
+
+      # : (Integer, Hash[Integer?, Grammar::Production]) -> void
+      def add_accept_action: (Integer, Hash[Integer?, Grammar::Production]) -> void
+
+      # : (Integer, Symbol, MergedItem, Hash[Integer?, Grammar::Production]) -> void
+      def add_reduce_action: (Integer, Symbol, MergedItem, Hash[Integer?, Grammar::Production]) -> void
+
+      # : (MergedState) -> void
+      def populate_gotos_for: (MergedState) -> void
+
+      # : (ConflictReport) -> String
+      def conflict_message: (ConflictReport) -> String
+    end
+  end
+end

data/sig/generated/rusa/analysis/parse_action.rbs

@@ -0,0 +1,58 @@
+# Generated from lib/rusa/analysis/parse_action.rb with RBS::Inline
+
+module Rusa
+  module Analysis
+    # Parse actions populate ACTION tables.
+    class Shift
+      attr_reader state: Integer
+
+      # : (Integer) -> void
+      def initialize: (Integer) -> void
+
+      # : () -> [:shift, Integer]
+      def to_a: () -> [ :shift, Integer ]
+
+      # : (Object) -> bool
+      def ==: (Object) -> bool
+
+      alias eql? ==
+
+      # : () -> Integer
+      def hash: () -> Integer
+    end
+
+    class Reduce
+      attr_reader production_id: Integer?
+
+      # : (Integer?) -> void
+      def initialize: (Integer?) -> void
+
+      # : () -> [:reduce, Integer?]
+      def to_a: () -> [ :reduce, Integer? ]
+
+      # : (Object) -> bool
+      def ==: (Object) -> bool
+
+      alias eql? ==
+
+      # : () -> Integer
+      def hash: () -> Integer
+    end
+
+    class Accept
+      # : () -> void
+      def initialize: () -> void
+
+      # : () -> [:accept]
+      def to_a: () -> [ :accept ]
+
+      # : (Object) -> bool
+      def ==: (Object) -> bool
+
+      alias eql? ==
+
+      # : () -> Integer
+      def hash: () -> Integer
+    end
+  end
+end

data/sig/generated/rusa/cli.rbs

@@ -0,0 +1,68 @@
+# Generated from lib/rusa/cli.rb with RBS::Inline
+
+module Rusa
+  # CLI wires grammar loading, table generation, and code output.
+  class CLI
+    # : (Array[String]) -> Integer
+    def run: (Array[String]) -> Integer
+
+    private
+
+    # : (Array[String]) -> Integer
+    def generate: (Array[String]) -> Integer
+
+    # : (Array[String]) -> Integer
+    def report: (Array[String]) -> Integer
+
+    # : (Array[String]) -> Integer
+    def check: (Array[String]) -> Integer
+
+    # : (String) -> [Grammar::Grammar, Analysis::LALRTable]
+    def build: (String) -> [ Grammar::Grammar, Analysis::LALRTable ]
+
+    # : (String) -> Grammar::Grammar
+    def load_grammar: (String) -> Grammar::Grammar
+
+    # : (String) -> String
+    def default_output_path: (String) -> String
+
+    # : (String) -> String
+    def default_class_name: (String) -> String
+
+    # : () -> String
+    def usage: () -> String
+
+    # : (Array[String]) -> Hash[Symbol, bool | String]
+    def parse_generate_options: (Array[String]) -> Hash[Symbol, bool | String]
+
+    # : () -> Hash[Symbol, bool | String]
+    def default_generate_options: () -> Hash[Symbol, bool | String]
+
+    # : (Array[String]) -> String
+    def required_grammar_file: (Array[String]) -> String
+
+    # : (Hash[Symbol, bool | String], String) -> String
+    def generator_class_name: (Hash[Symbol, bool | String], String) -> String
+
+    # : (Hash[Symbol, bool | String], String) -> String
+    def output_path_for: (Hash[Symbol, bool | String], String) -> String
+
+    # : (Hash[Symbol, bool | String]) -> bool
+    def compact_option: (Hash[Symbol, bool | String]) -> bool
+
+    # : (Hash[Symbol, bool | String]) -> bool
+    def line_tracking_option: (Hash[Symbol, bool | String]) -> bool
+
+    # : (Hash[Symbol, bool | String]) -> bool
+    def verbose_option: (Hash[Symbol, bool | String]) -> bool
+
+    # : (String, Array[String]) -> void
+    def print_section: (String, Array[String]) -> void
+
+    # : (Analysis::LALRTable) -> Array[String]
+    def conflict_messages: (Analysis::LALRTable) -> Array[String]
+
+    # : (String) -> String
+    def classify: (String) -> String
+  end
+end

data/sig/generated/rusa/errors.rbs

@@ -0,0 +1,24 @@
+# Generated from lib/rusa/errors.rb with RBS::Inline
+
+module Rusa
+  class Error < StandardError
+  end
+
+  class GrammarError < Error
+  end
+
+  class DuplicateTokenError < GrammarError
+  end
+
+  class DuplicateRuleError < GrammarError
+  end
+
+  class UndefinedSymbolError < GrammarError
+  end
+
+  class NoStartSymbolError < GrammarError
+  end
+
+  class InvalidGrammarError < GrammarError
+  end
+end

data/sig/generated/rusa/generator/code_generator.rbs

@@ -0,0 +1,82 @@
+# Generated from lib/rusa/generator/code_generator.rb with RBS::Inline
+
+module Rusa
+  module Generator
+    # CodeGenerator emits a standalone Ruby parser class.
+    class CodeGenerator
+      TEMPLATE: ::String
+
+      # : (Grammar::Grammar, Analysis::LALRTable, ?class_name: String, ?compact: bool, ?line_tracking: bool) -> void
+      def initialize: (Grammar::Grammar, Analysis::LALRTable, ?class_name: String, ?compact: bool, ?line_tracking: bool) -> void
+
+      # : () -> String
+      def generate: () -> String
+
+      private
+
+      attr_reader grammar: Grammar::Grammar
+
+      attr_reader table: Analysis::LALRTable
+
+      attr_reader class_name: String
+
+      attr_reader compact: bool
+
+      attr_reader line_tracking: bool
+
+      # : () -> Hash[Symbol, String | bool]
+      def template_context: () -> Hash[Symbol, String | bool]
+
+      # : () -> String
+      def serialized_action_table: () -> String
+
+      # : () -> String
+      def serialized_productions: () -> String
+
+      # : () -> String
+      def serialized_tokens: () -> String
+
+      # : () -> String
+      def serialized_skip_patterns: () -> String
+
+      # : (Object) -> String
+      def serialized_plain_object: (Object) -> String
+
+      # : () -> Hash[Integer, Hash[Symbol, [:shift, Integer] | [:reduce, Integer?] | [:accept]]]
+      def action_table_payload: () -> Hash[Integer, Hash[Symbol, [ :shift, Integer ] | [ :reduce, Integer? ] | [ :accept ]]]
+
+      # : () -> Array[[Symbol, Integer]]
+      def production_payload: () -> Array[[ Symbol, Integer ]]
+
+      # : () -> Array[[Symbol, Regexp]]
+      def token_payload: () -> Array[[ Symbol, Regexp ]]
+
+      # : () -> Array[Regexp]
+      def skip_payload: () -> Array[Regexp]
+
+      # : (Object) -> String
+      def serialize: (Object) -> String
+
+      # : (Object) -> Object
+      def plain_object: (Object) -> Object
+
+      # : () -> Hash[Integer, Hash[Symbol, [:shift, Integer] | [:reduce, Integer?] | [:accept]]]
+      def action_table_index: () -> Hash[Integer, Hash[Symbol, [ :shift, Integer ] | [ :reduce, Integer? ] | [ :accept ]]]
+
+      # : () -> Array[Grammar::TerminalSymbol]
+      def token_terminals: () -> Array[Grammar::TerminalSymbol]
+
+      # : () -> String
+      def action_cases: () -> String
+
+      # : (Grammar::Production) -> String
+      def action_case_for: (Grammar::Production) -> String
+
+      # : (Grammar::Production) -> String
+      def action_body_for: (Grammar::Production) -> String
+
+      # : (String?) -> String?
+      def normalize_action_source: (String?) -> String?
+    end
+  end
+end

data/sig/generated/rusa/grammar/action_capture.rbs

@@ -0,0 +1,46 @@
+# Generated from lib/rusa/grammar/action_capture.rb with RBS::Inline
+
+module Rusa
+  module Grammar
+    # Captures Ruby block source so semantic actions can be emitted into generated parsers.
+    module ActionCapture
+      BLOCK_OPENERS: untyped
+
+      PUSH_TOKENS: untyped
+
+      POP_TOKENS: untyped
+
+      BLOCK_KEYWORDS: untyped
+
+      # : (Proc) -> String?
+      def self?.capture: (Proc) -> String?
+
+      # : (String) -> String?
+      def self?.extract_block: (String) -> String?
+
+      # : (Symbol, String) -> bool
+      def self?.block_opener?: (Symbol, String) -> bool
+
+      # : (Symbol, String) -> Symbol?
+      def self?.structural_event: (Symbol, String) -> Symbol?
+
+      # : (Symbol, String) -> [Symbol, String]
+      def self?.closing_token_for: (Symbol, String) -> [ Symbol, String ]
+
+      # : (String, [Integer, Integer]) -> Integer
+      def self?.offset_for: (String, [ Integer, Integer ]) -> Integer
+
+      # : (Array[[[Integer, Integer], Symbol, String, Ripper::Lexer::State]], Integer) -> Array[[[Integer, Integer], Symbol, String, Ripper::Lexer::State]]
+      def self?.block_tokens_from: (Array[[ [ Integer, Integer ], Symbol, String, Ripper::Lexer::State ]], Integer) -> Array[[ [ Integer, Integer ], Symbol, String, Ripper::Lexer::State ]]
+
+      # : (String) -> Array[Integer]
+      def self?.cached_line_offsets: (String) -> Array[Integer]
+
+      # : () -> Hash[Integer, Array[Integer]]
+      def self?.line_offsets_cache: () -> Hash[Integer, Array[Integer]]
+
+      # : (String) -> Array[Integer]
+      def self?.build_line_offsets: (String) -> Array[Integer]
+    end
+  end
+end

data/sig/generated/rusa/grammar/dsl.rbs

@@ -0,0 +1,62 @@
+# Generated from lib/rusa/grammar/dsl.rb with RBS::Inline
+
+module Rusa
+  module Grammar
+    # DSL evaluates the Ruby grammar definition and builds a Grammar object.
+    class DSL
+      attr_reader grammar: Grammar
+
+      # : () -> void
+      def initialize: () -> void
+
+      # : (Symbol | String, String | Regexp) -> TerminalSymbol
+      def token: (Symbol | String, String | Regexp) -> TerminalSymbol
+
+      # : (Regexp) -> Regexp
+      def skip: (Regexp) -> Regexp
+
+      # : (*Symbol | String) -> Array[Symbol | String]
+      def left: (*Symbol | String) -> Array[Symbol | String]
+
+      # : (*Symbol | String) -> Array[Symbol | String]
+      def right: (*Symbol | String) -> Array[Symbol | String]
+
+      # : (*Symbol | String) -> Array[Symbol | String]
+      def nonassoc: (*Symbol | String) -> Array[Symbol | String]
+
+      # : (Symbol | String) -> NonterminalSymbol
+      def start: (Symbol | String) -> NonterminalSymbol
+
+      # : (Symbol | String) { (self) [self: self] -> void } -> void
+      def rule: (Symbol | String) { (self) [self: self] -> void } -> void
+
+      # : (*Symbol | String) -> AltBuilder
+      # : (*Symbol | String) { (*Object) -> Object } -> AltBuilder
+      def alt: (*Symbol | String) -> AltBuilder
+             | (*Symbol | String) { (*Object) -> Object } -> AltBuilder
+
+      private
+
+      # : (Symbol, Array[Symbol | String]) -> Array[Symbol | String]
+      def register_precedence: (Symbol, Array[Symbol | String]) -> Array[Symbol | String]
+
+      # : (String | Regexp) -> Regexp
+      def normalize_token_pattern: (String | Regexp) -> Regexp
+
+      # : (Regexp) -> Regexp
+      def anchor_regexp: (Regexp) -> Regexp
+    end
+
+    # AltBuilder allows precedence and source overrides to be chained from alt.
+    class AltBuilder
+      # : (Production) -> void
+      def initialize: (Production) -> void
+
+      # : (Symbol | String) -> self
+      def prec: (Symbol | String) -> self
+
+      # : (String) -> self
+      def action: (String) -> self
+    end
+  end
+end