lrama 0.6.9 → 0.6.11

data/sig/lrama/counterexamples/production_path.rbs

@@ -0,0 +1,11 @@
+module Lrama
+  class Counterexamples
+    class ProductionPath < Path
+      def type: () -> :production
+
+      def transition?: () -> false
+
+      def production?: () -> true
+    end
+  end
+end

data/sig/lrama/counterexamples/start_path.rbs

@@ -0,0 +1,13 @@
+module Lrama
+  class Counterexamples
+    class StartPath < Path
+      def initialize: (StateItem to_state_item) -> void
+
+      def type: () -> :start
+
+      def transition?: () -> false
+
+      def production?: () -> false
+    end
+  end
+end

data/sig/lrama/counterexamples/state_item.rbs

@@ -0,0 +1,10 @@
+module Lrama
+  class Counterexamples
+    class StateItem
+     attr_accessor state: State
+     attr_accessor item: States::Item
+
+      def initialize: (State state, States::Item item) -> void
+    end
+  end
+end

data/sig/lrama/counterexamples/transition_path.rbs

@@ -0,0 +1,11 @@
+module Lrama
+  class Counterexamples
+    class TransitionPath < Path
+      def type: () -> :transition
+
+      def transition?: () -> true
+
+      def production?: () -> false
+    end
+  end
+end

data/sig/lrama/counterexamples/triple.rbs

@@ -0,0 +1,20 @@
+module Lrama
+  class Counterexamples
+    class Triple
+      attr_accessor s: State
+      attr_accessor itm: States::Item
+      attr_accessor l: Set[Grammar::Symbol]
+
+      alias state s
+      alias item itm
+      alias precise_lookahead_set l
+
+      def initialize: (State s, States::Item itm, Set[Grammar::Symbol] l) -> void
+
+      def state_item: () -> StateItem
+      def inspect: () -> ::String
+
+      alias to_s inspect
+    end
+  end
+end

data/sig/lrama/counterexamples.rbs

@@ -0,0 +1,29 @@
+module Lrama
+  class Counterexamples
+    @states: States
+    @transitions: Hash[[StateItem, Grammar::Symbol], StateItem]
+    @reverse_transitions: Hash[[StateItem, Grammar::Symbol], Set[StateItem]]
+    @productions: Hash[StateItem, Set[States::Item]]
+    @reverse_productions: Hash[[State, Grammar::Symbol], Set[States::Item]]
+
+    attr_reader transitions: Hash[[StateItem, Grammar::Symbol], StateItem]
+    attr_reader productions: Hash[StateItem, Set[States::Item]]
+
+    def initialize: (States states) -> void
+    def to_s: () -> "#<Counterexamples>"
+    alias inspect to_s
+    def compute: (State conflict_state) -> Array[Example]
+
+    private
+
+    def setup_transitions: () -> void
+    def setup_productions: () -> void
+    def shift_reduce_example: (State conflict_state, State::ShiftReduceConflict conflict) -> Example
+    def reduce_reduce_examples: (State conflict_state, State::ReduceReduceConflict conflict) -> Example
+    def find_shift_conflict_shortest_path: (::Array[StartPath|TransitionPath|ProductionPath]? reduce_path, State conflict_state, States::Item conflict_item) -> ::Array[StartPath|TransitionPath|ProductionPath]
+    def find_shift_conflict_shortest_state_items: (::Array[StartPath|TransitionPath|ProductionPath]? reduce_path, State conflict_state, States::Item conflict_item) -> Array[StateItem]
+    def build_paths_from_state_items: (Array[StateItem] state_items) -> ::Array[StartPath|TransitionPath|ProductionPath]
+    def shortest_path: (State conflict_state, States::Item conflict_reduce_item, Grammar::Symbol conflict_term) -> ::Array[StartPath|TransitionPath|ProductionPath]?
+    def follow_l: (States::Item item, Set[Grammar::Symbol] current_l) -> Set[Grammar::Symbol]
+  end
+end

data/sig/lrama/grammar/auxiliary.rbs

@@ -0,0 +1,10 @@
+module Lrama
+  class Grammar
+    class Auxiliary
+      attr_accessor prologue_first_lineno: Integer
+      attr_accessor prologue: String
+      attr_accessor epilogue_first_lineno: Integer
+      attr_accessor epilogue: String
+    end
+  end
+end

data/sig/lrama/grammar/binding.rbs

@@ -10,6 +10,10 @@ module Lrama
 
       def initialize: (Grammar::ParameterizingRule::Rule parameterizing_rule, Array[Lexer::Token] actual_args) -> void
       def resolve_symbol: (Lexer::Token symbol) -> Lexer::Token
+
+      private
+
+      def parameter_to_arg: (Lexer::Token symbol) -> Lexer::Token?
     end
   end
 end

data/sig/lrama/grammar/code/destructor_code.rbs

@@ -2,13 +2,12 @@ module Lrama
   class Grammar
     class Code
       class DestructorCode < Code
-        @tag: untyped
-        def initialize: (type: untyped, token_code: untyped, tag: untyped) -> void
+        @tag: Lexer::Token::Tag
+        def initialize: (type: ::Symbol, token_code: Grammar::Code, tag: Lexer::Token::Tag) -> void
 
         private
 
-        # ref: Lrama::Grammar::Code.token_code.references
-        def reference_to_c: (untyped ref) -> untyped
+        def reference_to_c: (Reference ref) -> (String | bot)
       end
     end
   end

data/sig/lrama/grammar/code/initial_action_code.rbs

@@ -0,0 +1,15 @@
+module Lrama
+  class Grammar
+    class Code
+      class InitialActionCode < Code
+        private
+
+        # * ($$) yylval
+        # * (@$) yylloc
+        # * ($1) error
+        # * (@1) error
+        def reference_to_c: (Reference ref) -> (String | bot)
+      end
+    end
+  end
+end

data/sig/lrama/grammar/code/no_reference_code.rbs

@@ -0,0 +1,15 @@
+module Lrama
+  class Grammar
+    class Code
+      class NoReferenceCode < Code
+        private
+
+        # * ($$) error
+        # * (@$) error
+        # * ($1) error
+        # * (@1) error
+        def reference_to_c: (Reference ref) -> bot
+      end
+    end
+  end
+end

data/sig/lrama/grammar/code/printer_code.rbs

@@ -2,13 +2,12 @@ module Lrama
   class Grammar
     class Code
       class PrinterCode < Code
-        @tag: untyped
-        def initialize: (type: untyped, token_code: untyped, tag: untyped) -> void
+        @tag: Lexer::Token::Tag
+        def initialize: (type: ::Symbol, token_code: Grammar::Code, tag: Lexer::Token::Tag) -> void
 
         private
 
-        # ref: Lrama::Grammar::Code.token_code.references
-        def reference_to_c: (untyped ref) -> untyped
+        def reference_to_c: (Reference ref) -> (String | bot)
       end
     end
   end

data/sig/lrama/grammar/code/rule_action.rbs

@@ -0,0 +1,19 @@
+module Lrama
+  class Grammar
+    class Code
+      class RuleAction < Code
+        @rule: Rule
+
+        def initialize: (type: ::Symbol, token_code: Grammar::Code, rule: Rule) -> void
+
+        private
+
+        def reference_to_c: (Reference ref) -> String
+        def position_in_rhs: () -> Integer
+        def rhs: () -> Array[Grammar::Symbol]
+        def lhs: () -> Grammar::Symbol
+        def raise_tag_not_found_error: (Reference ref) -> bot
+      end
+    end
+  end
+end

data/sig/lrama/grammar/code.rbs

@@ -3,8 +3,8 @@ module Lrama
     class Code
       extend Forwardable
 
-      attr_accessor type: Symbol
-      attr_accessor token_code: Lexer::Token::UserCode
+      attr_accessor type: ::Symbol
+      attr_accessor token_code: Grammar::Code
 
       # delegated
       def s_value: -> String
@@ -12,7 +12,7 @@ module Lrama
       def column: -> Integer
       def references: -> Array[Lrama::Grammar::Reference]
 
-      def initialize: (type: Symbol, token_code: Lexer::Token::UserCode) -> void
+      def initialize: (type: ::Symbol, token_code: Grammar::Code) -> void
 
       def translated_code: () -> String
 

data/sig/lrama/grammar/destructor.rbs

@@ -5,7 +5,9 @@ module Lrama
       attr_accessor token_code: Grammar::Code
       attr_accessor lineno: Integer
 
-      def translated_code: (Lexer::Token member) -> String
+      def initialize: (ident_or_tags: Array[Lexer::Token::Ident|Lexer::Token::Tag], token_code: Grammar::Code, lineno: Integer) -> void
+
+      def translated_code: (Lexer::Token::Tag tag) -> String
     end
   end
 end

data/sig/lrama/grammar/error_token.rbs

@@ -2,10 +2,12 @@ module Lrama
   class Grammar
     class ErrorToken
       attr_accessor ident_or_tags: Array[Lexer::Token::Ident | Lexer::Token::Tag]
-      attr_accessor token_code: Symbol
+      attr_accessor token_code: Grammar::Code
       attr_accessor lineno: Integer
 
-      def translated_code: (Lexer::Token? tag) -> String
+      def initialize: (?ident_or_tags: Array[Lexer::Token::Ident|Lexer::Token::Tag], ?token_code: Grammar::Code, ?lineno: Integer) -> void
+
+      def translated_code: (Lexer::Token::Tag tag) -> String
     end
   end
 end

data/sig/lrama/grammar/parameterizing_rule/resolver.rbs

@@ -2,12 +2,13 @@ module Lrama
   class Grammar
     class ParameterizingRule
       class Resolver
+        attr_accessor rules: Array[Grammar::ParameterizingRule::Rule]
         attr_accessor created_lhs_list: Array[Lexer::Token]
 
         @rules: Array[Grammar::ParameterizingRule::Rule]
 
         def initialize: () -> void
-        def add_parameterizing_rule: (Grammar::ParameterizingRule::Rule rule) -> void
+        def add_parameterizing_rule: (Grammar::ParameterizingRule::Rule rule) -> Array[Grammar::ParameterizingRule::Rule]
         def find_rule: (Lexer::Token::InstantiateRule token) -> Grammar::ParameterizingRule::Rule?
         def find_inline: (Lexer::Token token) -> Grammar::ParameterizingRule::Rule?
         def created_lhs: (String lhs_s_value) -> Lexer::Token?

data/sig/lrama/grammar/parameterizing_rule/rhs.rbs

@@ -4,7 +4,7 @@ module Lrama
       class Rhs
         attr_reader symbols: Array[untyped]
         attr_reader user_code: Lexer::Token::UserCode?
-        attr_reader precedence_sym: Lexer::Token?
+        attr_reader precedence_sym: Grammar::Symbol?
 
         def initialize: () -> void
         def resolve_user_code: (Grammar::Binding bindings) -> Lexer::Token::UserCode?

data/sig/lrama/grammar/precedence.rbs

@@ -2,9 +2,11 @@ module Lrama
   class Grammar
     class Precedence
       include Comparable
-      attr_accessor type: Symbol
+      attr_accessor type: ::Symbol
       attr_accessor precedence: Integer
 
+      def initialize: (?type: ::Symbol, ?precedence: Integer) -> void
+
       def <=>: (Precedence other) -> Integer
     end
   end

data/sig/lrama/grammar/printer.rbs

@@ -5,7 +5,9 @@ module Lrama
       attr_accessor token_code: Grammar::Code
       attr_accessor lineno: Integer
 
-      def translated_code: (Lexer::Token member) -> String
+      def initialize: (?ident_or_tags: Array[Lexer::Token::Ident|Lexer::Token::Tag], ?token_code: Grammar::Code, ?lineno: Integer) -> void
+
+      def translated_code: (Lexer::Token::Tag tag) -> String
     end
   end
 end

data/sig/lrama/grammar/rule.rbs

@@ -1,13 +1,45 @@
 module Lrama
   class Grammar
     class Rule
+      attr_accessor id: Integer
+      attr_accessor _lhs: Lexer::Token
+      attr_accessor lhs: Grammar::Symbol
+      attr_accessor lhs_tag: Lexer::Token::Tag?
+      attr_accessor _rhs: Array[Lexer::Token]
+      attr_accessor rhs: Array[Grammar::Symbol]
+      attr_accessor token_code: Grammar::Code?
+      attr_accessor position_in_original_rule_rhs: Integer
+      attr_accessor nullable: bool
+      attr_accessor precedence_sym: Grammar::Symbol?
+      attr_accessor lineno: Integer?
       attr_accessor original_rule: Rule
 
       def initialize: (
-        ?id: untyped, ?_lhs: untyped, ?lhs: untyped, ?lhs_tag: untyped, ?_rhs: untyped, ?rhs: untyped,
-        ?token_code: untyped, ?position_in_original_rule_rhs: untyped, ?nullable: untyped,
-        ?precedence_sym: untyped, ?lineno: untyped
+        ?id: Integer, ?_lhs: Lexer::Token, ?lhs: Lexer::Token, ?lhs_tag: Lexer::Token::Tag?, ?_rhs: Array[Lexer::Token], ?rhs: Array[Grammar::Symbol],
+        ?token_code: Lexer::Token::UserCode?, ?position_in_original_rule_rhs: Integer?, ?nullable: bool,
+        ?precedence_sym: Grammar::Symbol?, ?lineno: Integer?
       ) -> void
+
+      def display_name: () -> String
+
+      def as_comment: -> String
+
+      def empty_rule?: -> bool
+
+      def initial_rule?: -> bool
+
+      def precedence: -> Precedence?
+
+      def translated_code: -> String?
+
+      def with_actions: -> String
+
+      def contains_at_reference?: -> bool
+
+      interface _DelegatedMethods
+        def lhs: -> Grammar::Symbol
+        def rhs: -> Array[Grammar::Symbol]
+      end
     end
   end
 end

data/sig/lrama/grammar/rule_builder.rbs

@@ -6,28 +6,29 @@ module Lrama
       attr_reader lhs_tag: Lexer::Token::Tag?
       attr_reader rhs: Array[Lexer::Token]
       attr_reader user_code: Lexer::Token::UserCode?
-      attr_reader precedence_sym: Lexer::Token?
+      attr_reader precedence_sym: Grammar::Symbol?
 
       @rule_counter: Counter
       @midrule_action_counter: Counter
+      @parameterizing_rule_resolver: Grammar::ParameterizingRule::Resolver
       @position_in_original_rule_rhs: Integer?
       @skip_preprocess_references: bool
       @user_code: Lexer::Token::UserCode?
       @rule_builders_for_parameterizing_rules: Array[RuleBuilder]
       @rule_builders_for_derived_rules: Array[RuleBuilder]
-      @rule_builders_for_inline_rules: Array[RuleBuilder]
       @rules: Array[Rule]
       @replaced_rhs: Array[Lexer::Token]
       @parameterizing_rules: Array[Rule]
-      @inline_rules: Array[Rule]
       @midrule_action_rules: Array[Rule]
 
-      def initialize: (Counter rule_counter, Counter midrule_action_counter, ?Integer position_in_original_rule_rhs, ?lhs_tag: Lexer::Token::Tag?, ?skip_preprocess_references: bool) -> void
+      def initialize: (Counter rule_counter, Counter midrule_action_counter, Grammar::ParameterizingRule::Resolver parameterizing_rule_resolver, ?Integer position_in_original_rule_rhs, ?lhs_tag: Lexer::Token::Tag?, ?skip_preprocess_references: bool) -> void
       def add_rhs: (Lexer::Token rhs) -> void
+      def has_inline_rules?: -> bool
+      def resolve_inline_rules: -> Array[RuleBuilder]
       def user_code=: (Lexer::Token::UserCode? user_code) -> void
-      def precedence_sym=: (Lexer::Token? precedence_sym) -> void
+      def precedence_sym=: (Grammar::Symbol? precedence_sym) -> void
       def complete_input: () -> void
-      def setup_rules: (Grammar::ParameterizingRule::Resolver parameterizing_rule_resolver) -> void
+      def setup_rules: () -> void
       def rules: () -> Array[Rule]
 
       private
@@ -35,10 +36,10 @@ module Lrama
       def freeze_rhs: () -> void
       def preprocess_references: () -> void
       def build_rules: () -> void
-      def process_rhs: (Grammar::ParameterizingRule::Resolver parameterizing_rule_resolver) -> void
+      def process_rhs: () -> void
       def lhs_s_value: (Lexer::Token::InstantiateRule token, Grammar::Binding bindings) -> String
-      def resolve_inline: (Grammar::ParameterizingRule::Resolver parameterizing_rule_resolver) -> void
-      def resolve_inline_rhs: (RuleBuilder rule_builder, Grammar::ParameterizingRule::Rhs inline_rhs, Integer index) -> void
+      def resolve_inline: () -> void
+      def resolve_inline_rhs: (RuleBuilder rule_builder, Grammar::ParameterizingRule::Rhs inline_rhs, Integer index, ?Binding bindings) -> void
       def replace_inline_user_code: (Grammar::ParameterizingRule::Rhs inline_rhs, Integer index) -> Lexer::Token::UserCode?
       def numberize_references: () -> void
       def flush_user_code: () -> void

data/sig/lrama/grammar/symbol.rbs

@@ -4,7 +4,7 @@ module Lrama
       attr_accessor id: Lexer::Token
       attr_accessor alias_name: String?
       attr_accessor number: Integer
-      attr_accessor tag: Lexer::Token?
+      attr_accessor tag: Lexer::Token::Tag?
       attr_accessor term: bool
       attr_accessor token_id: Integer
       attr_accessor nullable: bool
@@ -13,12 +13,12 @@ module Lrama
       attr_accessor destructor: Destructor?
       attr_accessor error_token: ErrorToken
 
-      attr_accessor first_set: Set[Array[Symbol]]
+      attr_accessor first_set: Set[Grammar::Symbol]
       attr_accessor first_set_bitmap: Integer
-      attr_writer eof_symbol: Symbol
-      attr_writer error_symbol: Symbol
-      attr_writer undef_symbol: Symbol
-      attr_writer accept_symbol: Symbol
+      attr_writer eof_symbol: bool
+      attr_writer error_symbol: bool
+      attr_writer undef_symbol: bool
+      attr_writer accept_symbol: bool
 
       def initialize: (
           id: Lexer::Token, term: bool, ?alias_name: String?, ?number: Integer?, ?tag: Lexer::Token?,

data/sig/lrama/grammar/symbols/resolver.rbs

@@ -11,16 +11,17 @@ module Lrama
 
         def initialize: () -> void
         def symbols: () -> Array[Grammar::Symbol]
-        def sort_by_number!: () -> void
-        def add_term: (id: Lexer::Token, ?alias_name: String?, ?tag: Lexer::Token?, ?token_id: Integer?, ?replace: bool) -> Grammar::Symbol
-        def add_nterm: (id: Lexer::Token, ?alias_name: String?, ?tag: Lexer::Token?) -> Grammar::Symbol?
-        def find_symbol_by_s_value: (Grammar::Symbol s_value) -> Grammar::Symbol?
-        def find_symbol_by_s_value!: (Grammar::Symbol s_value) -> Grammar::Symbol
+        def sort_by_number!: () -> Array[Grammar::Symbol]
+        def add_term: (id: Lexer::Token, ?alias_name: String?, ?tag: Lexer::Token::Tag?, ?token_id: Integer?, ?replace: bool) -> Grammar::Symbol
+        def add_nterm: (id: Lexer::Token, ?alias_name: String?, ?tag: Lexer::Token::Tag?) -> Grammar::Symbol
+        def find_symbol_by_s_value: (::String s_value) -> Grammar::Symbol?
+        def find_symbol_by_s_value!: (::String s_value) -> Grammar::Symbol
         def find_symbol_by_id: (Lexer::Token id) -> Grammar::Symbol?
         def find_symbol_by_id!: (Lexer::Token id) -> Grammar::Symbol
         def find_symbol_by_token_id: (Integer token_id) -> Grammar::Symbol?
         def find_symbol_by_number!: (Integer number) -> Grammar::Symbol
         def fill_symbol_number: () -> void
+        def fill_destructor: (Array[Destructor] destructors) -> (Array[Grammar::Symbol] | bot)
         def fill_nterm_type: (Array[Grammar::Type] types) -> void
         def fill_printer: (Array[Grammar::Printer] printers) -> void
         def fill_error_token: (Array[Grammar::ErrorToken] error_tokens) -> void
@@ -36,6 +37,24 @@ module Lrama
         def validate_number_uniqueness!: () -> void
         def validate_alias_name_uniqueness!: () -> void
       end
+
+      interface _DelegatedMethods
+        def symbols: () -> Array[Grammar::Symbol]
+        def nterms: () -> Array[Grammar::Symbol]
+        def terms: () -> Array[Grammar::Symbol]
+        def add_nterm: (id: Lexer::Token, ?alias_name: String?, ?tag: Lexer::Token::Tag?) -> Grammar::Symbol
+        def add_term: (id: Lexer::Token, ?alias_name: String?, ?tag: Lexer::Token::Tag?, ?token_id: Integer?, ?replace: bool) -> Grammar::Symbol
+        def find_symbol_by_number!: (Integer number) -> Grammar::Symbol
+        def find_symbol_by_id!: (Lexer::Token id) -> Grammar::Symbol
+        def token_to_symbol: (Lexer::Token token) -> Grammar::Symbol
+        def find_symbol_by_s_value!: (::String s_value) -> Grammar::Symbol
+        def fill_nterm_type: (Array[Grammar::Type] types) -> void
+        def fill_symbol_number: () -> void
+        def fill_printer: (Array[Grammar::Printer] printers) -> void
+        def fill_destructor: (Array[Destructor] destructors) -> (Destructor | bot)
+        def fill_error_token: (Array[Grammar::ErrorToken] error_tokens) -> void
+        def sort_by_number!: () -> Array[Grammar::Symbol]
+      end
     end
   end
 end

data/sig/lrama/grammar/type.rbs

@@ -2,9 +2,9 @@ module Lrama
   class Grammar
     class Type
       attr_reader id: Lexer::Token
-      attr_reader tag: Lexer::Token
+      attr_reader tag: Lexer::Token::Tag
 
-      def initialize: (id: Lexer::Token, tag: Lexer::Token) -> void
+      def initialize: (id: Lexer::Token, tag: Lexer::Token::Tag) -> void
       def ==: (Grammar::Type other) -> bool
     end
   end

data/sig/lrama/grammar/union.rbs

@@ -0,0 +1,12 @@
+module Lrama
+  class Grammar
+    class Union
+      attr_accessor code: Grammar::Code::NoReferenceCode
+      attr_accessor lineno: Integer
+
+      def initialize: (code: Grammar::Code::NoReferenceCode, lineno: Integer) -> void
+
+      def braces_less_code: () -> String
+    end
+  end
+end

data/sig/lrama/grammar.rbs

@@ -1,5 +1,108 @@
 module Lrama
   class Grammar
-    def numberize_references: (Lexer::Token lhs, Array[Lexer::Token] rhs, Array[Reference]) -> void
+    include Symbols::_DelegatedMethods
+
+    @rule_counter: Counter
+    @percent_codes: Array[PercentCode]
+    @printers: Array[Printer]
+    @destructors: Array[Destructor]
+    @error_tokens: Array[ErrorToken]
+    @symbols_resolver: Symbols::Resolver
+    @types: Array[Type]
+    @rule_builders: Array[RuleBuilder]
+    @rules: Array[Rule]
+    @sym_to_rules: Hash[Integer, Array[Rule]]
+    @parameterizing_rule_resolver: ParameterizingRule::Resolver
+    @empty_symbol: Grammar::Symbol
+    @eof_symbol: Grammar::Symbol
+    @error_symbol: Grammar::Symbol
+    @undef_symbol: Grammar::Symbol
+    @accept_symbol: Grammar::Symbol
+    @aux: Auxiliary
+    @no_stdlib: bool
+    @locations: bool
+    @union: Union
+
+    extend Forwardable
+
+    attr_reader percent_codes: Array[PercentCode]
+    attr_reader eof_symbol: Grammar::Symbol
+    attr_reader error_symbol: Grammar::Symbol
+    attr_reader undef_symbol: Grammar::Symbol
+    attr_reader accept_symbol: Grammar::Symbol
+    attr_reader aux: Auxiliary
+    attr_accessor union: Union
+    attr_accessor expect: Integer
+    attr_accessor printers: Array[Printer]
+    attr_accessor error_tokens: Array[ErrorToken]
+    attr_accessor lex_param: String
+    attr_accessor parse_param: String
+    attr_accessor initial_action: Grammar::Code::InitialActionCode
+    attr_accessor after_shift: Lexer::Token
+    attr_accessor before_reduce: Lexer::Token
+    attr_accessor after_reduce: Lexer::Token
+    attr_accessor after_shift_error_token: Lexer::Token
+    attr_accessor after_pop_stack: Lexer::Token
+    attr_accessor symbols_resolver: Symbols::Resolver
+    attr_accessor types: Array[Type]
+    attr_accessor rules: Array[Rule]
+    attr_accessor rule_builders: Array[RuleBuilder]
+    attr_accessor sym_to_rules: Hash[Integer, Array[Rule]]
+    attr_accessor no_stdlib: bool
+
+    def initialize: (Counter rule_counter) -> void
+    def create_rule_builder: (Counter rule_counter, Counter midrule_action_counter) -> RuleBuilder
+    def add_percent_code: (id: Lexer::Token, code: Lexer::Token::UserCode) -> Array[PercentCode]
+    def add_destructor: (ident_or_tags: Array[Lexer::Token::Ident|Lexer::Token::Tag], token_code: Code, lineno: Integer) -> Array[Destructor]
+    def add_printer: (ident_or_tags: Array[Lexer::Token::Ident|Lexer::Token::Tag], token_code: Code, lineno: Integer) -> Array[Printer]
+    def add_error_token: (ident_or_tags: Array[Lexer::Token::Ident|Lexer::Token::Tag], token_code: Code, lineno: Integer) -> Array[ErrorToken]
+    def add_type: (id: Lexer::Token, tag: Lexer::Token::Tag) -> Array[Type]
+    def add_nonassoc: (Grammar::Symbol sym, Integer precedence) -> Precedence
+    def add_left: (Grammar::Symbol sym, Integer precedence) -> Precedence
+    def add_right: (Grammar::Symbol sym, Integer precedence) -> Precedence
+    def add_precedence: (Grammar::Symbol sym, Integer precedence) -> Precedence
+    def set_precedence: (Grammar::Symbol sym, Precedence precedence) -> (Precedence | bot)
+    def set_union: (Grammar::Code::NoReferenceCode code, Integer lineno) -> Union
+    def add_rule_builder: (RuleBuilder builder) -> Array[RuleBuilder]
+    def add_parameterizing_rule: (ParameterizingRule::Rule rule) -> Array[ParameterizingRule::Rule]
+    def parameterizing_rules: () -> Array[ParameterizingRule::Rule]
+    def insert_before_parameterizing_rules: (Array[ParameterizingRule::Rule] rules) -> Array[ParameterizingRule::Rule]
+    def prologue_first_lineno=: (Integer prologue_first_lineno) -> Integer
+    def prologue=: (String prologue) -> String
+    def epilogue_first_lineno=: (Integer epilogue_first_lineno) -> Integer
+    def epilogue=: (String epilogue) -> String
+    def prepare: () -> void
+    def validate!: () -> void
+    def find_rules_by_symbol!: (Grammar::Symbol sym) -> Array[Rule]
+    def find_rules_by_symbol: (Grammar::Symbol sym) -> Array[Rule]?
+
+    private
+
+    def compute_nullable: () -> Array[Grammar::Symbol]
+    def compute_first_set: () -> Array[Grammar::Symbol]
+    def resolve_inline_rules: () -> void
+    def setup_rules: () -> Array[RuleBuilder]
+    def append_special_symbols: () -> Grammar::Symbol
+    def normalize_rules: () -> Array[Rule]
+    def collect_symbols: () -> Array[Lexer::Token]
+    def set_lhs_and_rhs: () -> void
+    def fill_default_precedence: () -> void
+    def fill_symbols: () -> Array[Grammar::Symbol]
+    def fill_sym_to_rules: () -> Array[Rule]
+    def validate_rule_lhs_is_nterm!: () -> void
+    def set_locations: () -> void
+
+    interface _DelegatedMethods
+    def rules: () -> Array[Rule]
+    def accept_symbol: () -> Grammar::Symbol
+    def eof_symbol: () -> Grammar::Symbol
+    def undef_symbol: () -> Grammar::Symbol
+
+    # delegate to @symbols_resolver
+    def symbols: () -> Array[Grammar::Symbol]
+    def terms: () -> Array[Grammar::Symbol]
+    def nterms: () -> Array[Grammar::Symbol]
+    def find_symbol_by_s_value!: (::String s_value) -> Grammar::Symbol
+    end
   end
 end

data/sig/lrama/options.rbs

@@ -1,5 +1,5 @@
 module Lrama
- class Options
+  class Options
     attr_accessor skeleton: String
     attr_accessor header: bool
     attr_accessor header_file: String?
@@ -9,9 +9,10 @@ module Lrama
     attr_accessor grammar_file: String?
     attr_accessor trace_opts: Hash[Symbol, bool]?
     attr_accessor report_opts: Hash[Symbol, bool]?
+    attr_accessor diagnostic: bool
     attr_accessor y: IO
     attr_accessor debug: bool
 
     def initialize: () -> void
- end
+  end
 end