lrama 0.7.0 → 0.7.1

data/sig/lrama/counterexamples/triple.rbs

@@ -1,20 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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/code/destructor_code.rbs

@@ -1,14 +0,0 @@
-module Lrama
-  class Grammar
-    class Code
-      class DestructorCode < Code
-        @tag: Lexer::Token::Tag
-        def initialize: (type: ::Symbol, token_code: Grammar::Code, tag: Lexer::Token::Tag) -> void
-
-        private
-
-        def reference_to_c: (Reference ref) -> (String | bot)
-      end
-    end
-  end
-end

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

@@ -1,14 +0,0 @@
-module Lrama
-  class Grammar
-    class Code
-      class PrinterCode < Code
-        @tag: Lexer::Token::Tag
-        def initialize: (type: ::Symbol, token_code: Grammar::Code, tag: Lexer::Token::Tag) -> void
-
-        private
-
-        def reference_to_c: (Reference ref) -> (String | bot)
-      end
-    end
-  end
-end

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

@@ -1,19 +0,0 @@
-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

@@ -1,24 +0,0 @@
-module Lrama
-  class Grammar
-    class Code
-      extend Forwardable
-
-      attr_accessor type: ::Symbol
-      attr_accessor token_code: Grammar::Code
-
-      # delegated
-      def s_value: -> String
-      def line: -> Integer
-      def column: -> Integer
-      def references: -> Array[Lrama::Grammar::Reference]
-
-      def initialize: (type: ::Symbol, token_code: Grammar::Code) -> void
-
-      def translated_code: () -> String
-
-      private
-
-      def reference_to_c: (untyped ref) -> untyped
-    end
-  end
-end

data/sig/lrama/grammar/destructor.rbs

@@ -1,13 +0,0 @@
-module Lrama
-  class Grammar
-    class Destructor
-      attr_accessor ident_or_tags: Array[Lexer::Token::Ident|Lexer::Token::Tag]
-      attr_accessor token_code: Grammar::Code
-      attr_accessor lineno: Integer
-
-      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

@@ -1,24 +0,0 @@
-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) -> 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?
-
-        private
-
-        def select_rules: (Array[Grammar::ParameterizingRule::Rule] rules, Lexer::Token::InstantiateRule token) -> Array[Grammar::ParameterizingRule::Rule]
-        def select_not_inline_rules: (Array[Grammar::ParameterizingRule::Rule] rules) -> Array[Grammar::ParameterizingRule::Rule]
-        def select_rules_by_name: (Array[Grammar::ParameterizingRule::Rule] rules, String rule_name) -> Array[Grammar::ParameterizingRule::Rule]
-      end
-    end
-  end
-end

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

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

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

@@ -1,16 +0,0 @@
-module Lrama
-  class Grammar
-    class ParameterizingRule
-      class Rule
-        attr_reader name: String
-        attr_reader parameters: Array[Lexer::Token]
-        attr_reader rhs_list: Array[Grammar::ParameterizingRule::Rhs]
-        attr_reader required_parameters_count: Integer
-        attr_reader tag: Lexer::Token::Tag?
-        attr_reader is_inline: bool
-
-        def initialize: (String name, Array[Lexer::Token] parameters, Array[Grammar::ParameterizingRule::Rhs] rhs_list, ?tag: Lexer::Token::Tag, ?is_inline: bool) -> void
-      end
-    end
-  end
-end

data/sig/lrama/grammar/parameterizing_rule.rbs

@@ -1,6 +0,0 @@
-module Lrama
-  class Grammar
-    class ParameterizingRule
-    end
-  end
-end

data/sig/lrama/grammar/precedence.rbs

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

data/sig/lrama/grammar/printer.rbs

@@ -1,13 +0,0 @@
-module Lrama
-  class Grammar
-    class Printer
-      attr_accessor ident_or_tags: Array[Lexer::Token::Ident|Lexer::Token::Tag]
-      attr_accessor token_code: Grammar::Code
-      attr_accessor lineno: Integer
-
-      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/reference.rbs

@@ -1,22 +0,0 @@
-module Lrama
-  class Grammar
-    class Reference
-      attr_accessor type: ::Symbol
-      attr_accessor name: String
-      attr_accessor number: Integer
-      attr_accessor index: Integer
-      attr_accessor ex_tag: Lexer::Token?
-      attr_accessor first_column: Integer
-      attr_accessor last_column: Integer
-      attr_accessor position_in_rhs: Integer?
-
-      def initialize: (
-        type: ::Symbol, ?name: String, ?number: Integer, ?index: Integer, ?ex_tag: Lexer::Token?,
-        first_column: Integer, last_column: Integer,
-        ?position_in_rhs: Integer?
-      ) -> void
-
-      def value: () -> (String|Integer)
-    end
-  end
-end

data/sig/lrama/grammar/rule.rbs

@@ -1,45 +0,0 @@
-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: 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

@@ -1,47 +0,0 @@
-module Lrama
-  class Grammar
-    class RuleBuilder
-      attr_accessor lhs: Lexer::Token
-      attr_accessor line: Integer?
-      attr_reader lhs_tag: Lexer::Token::Tag?
-      attr_reader rhs: Array[Lexer::Token]
-      attr_reader user_code: Lexer::Token::UserCode?
-      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]
-      @rules: Array[Rule]
-      @replaced_rhs: Array[Lexer::Token]
-      @parameterizing_rules: Array[Rule]
-      @midrule_action_rules: Array[Rule]
-
-      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=: (Grammar::Symbol? precedence_sym) -> void
-      def complete_input: () -> void
-      def setup_rules: () -> void
-      def rules: () -> Array[Rule]
-
-      private
-
-      def freeze_rhs: () -> void
-      def preprocess_references: () -> void
-      def build_rules: () -> void
-      def process_rhs: () -> 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
-    end
-  end
-end

data/sig/lrama/grammar/symbol.rbs

@@ -1,38 +0,0 @@
-module Lrama
-  class Grammar
-    class Symbol
-      attr_accessor id: Lexer::Token
-      attr_accessor alias_name: String?
-      attr_accessor number: Integer
-      attr_accessor tag: Lexer::Token::Tag?
-      attr_accessor term: bool
-      attr_accessor token_id: Integer
-      attr_accessor nullable: bool
-      attr_accessor precedence: Precedence?
-      attr_accessor printer: Printer?
-      attr_accessor destructor: Destructor?
-      attr_accessor error_token: ErrorToken
-
-      attr_accessor first_set: Set[Grammar::Symbol]
-      attr_accessor first_set_bitmap: Integer
-      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?,
-          ?token_id: Integer?, ?nullable: bool?, ?precedence: Precedence?, ?printer: Printer?) -> void
-
-      def term?: () -> bool
-      def nterm?: () -> bool
-      def eof_symbol?: () -> bool
-      def error_symbol?: () -> bool
-      def undef_symbol?: () -> bool
-      def accept_symbol?: () -> bool
-      def display_name: () -> String
-      def enum_name: () -> String
-      def comment: () -> String?
-    end
-  end
-end

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

@@ -1,60 +0,0 @@
-module Lrama
-  class Grammar
-    class Symbols
-      class Resolver
-        attr_reader terms: Array[Grammar::Symbol]
-        attr_reader nterms: Array[Grammar::Symbol]
-
-        @symbols: Array[Grammar::Symbol]?
-        @number: Integer
-        @used_numbers: Hash[Integer, bool]
-
-        def initialize: () -> void
-        def symbols: () -> Array[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
-        def token_to_symbol: (Lexer::Token token) -> Grammar::Symbol
-        def validate!: () -> void
-
-        private
-
-        def find_nterm_by_id!: (Lexer::Token id) -> Grammar::Symbol
-        def fill_terms_number: () -> void
-        def fill_nterms_number: () -> void
-        def used_numbers: () -> Hash[Integer, bool]
-        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

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

data/sig/lrama/grammar/union.rbs

@@ -1,12 +0,0 @@
-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,108 +0,0 @@
-module Lrama
-  class Grammar
-    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/report/duration.rbs

@@ -1,11 +0,0 @@
-module Lrama
-  class Report
-    module Duration
-      self.@_report_duration_enabled: bool | nil
-
-      def self.enable: -> void
-      def self.enabled?: -> bool
-      def report_duration: [T] (_ToS method_name) { -> T } -> T
-    end
-  end
-end

data/sig/lrama/report/profile.rbs

@@ -1,7 +0,0 @@
-module Lrama
-  class Report
-    module Profile
-      def self.report_profile: { -> void } -> StackProf::result
-    end
-  end
-end

data/sig/lrama/state/reduce.rbs

@@ -1,20 +0,0 @@
-module Lrama
-  class State
-    class Reduce
-      @item: States::Item
-      @look_ahead: Array[Grammar::Symbol]?
-      @not_selected_symbols: Array[Grammar::Symbol]
-
-      attr_reader item: States::Item
-      attr_reader look_ahead: Array[Grammar::Symbol]?
-      attr_reader not_selected_symbols: Array[Grammar::Symbol]
-      attr_accessor default_reduction: bool
-
-      def initialize: (States::Item item) -> void
-      def rule: -> Grammar::Rule
-      def look_ahead=: (Array[Grammar::Symbol] look_ahead) -> Array[Grammar::Symbol]
-      def add_not_selected_symbol: (Grammar::Symbol sym) -> Array[Grammar::Symbol]
-      def selected_look_ahead: () -> (::Array[Grammar::Symbol?])
-    end
-  end
-end

data/sig/lrama/state/reduce_reduce_conflict.rbs

@@ -1,13 +0,0 @@
-module Lrama
-  class State
-    class ReduceReduceConflict
-      attr_accessor symbols: Array[Grammar::Symbol]
-      attr_accessor reduce1: State::Reduce
-      attr_accessor reduce2: State::Reduce
-
-      def initialize: (?symbols: Array[Grammar::Symbol], ?reduce1: State::Reduce, ?reduce2: State::Reduce) -> void
-
-      def type: () -> :reduce_reduce
-    end
-  end
-end