lrama 0.7.0 → 0.7.1

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

@@ -0,0 +1,131 @@
+# Generated from lib/lrama/grammar/symbols/resolver.rb with RBS::Inline
+
+module Lrama
+  class Grammar
+    class Symbols
+      class Resolver
+        interface _DelegatedMethods
+          def symbols: () -> Array[Grammar::Symbol]
+
+          def nterms: () -> Array[Grammar::Symbol]
+
+          def terms: () -> Array[Grammar::Symbol]
+
+          def add_nterm: (id: Lexer::Token::Base, ?alias_name: String?, ?tag: Lexer::Token::Tag?) -> Grammar::Symbol
+
+          def add_term: (id: Lexer::Token::Base, ?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::Base id) -> Grammar::Symbol
+
+          def token_to_symbol: (Lexer::Token::Base 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
+
+        @symbols: Array[Grammar::Symbol]?
+
+        @number: Integer
+
+        @used_numbers: Hash[Integer, bool]
+
+        attr_reader terms: Array[Grammar::Symbol]
+
+        attr_reader nterms: Array[Grammar::Symbol]
+
+        # @rbs () -> void
+        def initialize: () -> void
+
+        # @rbs () -> Array[Grammar::Symbol]
+        def symbols: () -> Array[Grammar::Symbol]
+
+        # @rbs () -> Array[Grammar::Symbol]
+        def sort_by_number!: () -> Array[Grammar::Symbol]
+
+        # @rbs (id: Lexer::Token::Base, ?alias_name: String?, ?tag: Lexer::Token::Tag?, ?token_id: Integer?, ?replace: bool) -> Grammar::Symbol
+        def add_term: (id: Lexer::Token::Base, ?alias_name: String?, ?tag: Lexer::Token::Tag?, ?token_id: Integer?, ?replace: bool) -> Grammar::Symbol
+
+        # @rbs (id: Lexer::Token::Base, ?alias_name: String?, ?tag: Lexer::Token::Tag?) -> Grammar::Symbol
+        def add_nterm: (id: Lexer::Token::Base, ?alias_name: String?, ?tag: Lexer::Token::Tag?) -> Grammar::Symbol
+
+        # @rbs (::String s_value) -> Grammar::Symbol?
+        def find_term_by_s_value: (::String s_value) -> Grammar::Symbol?
+
+        # @rbs (::String s_value) -> Grammar::Symbol?
+        def find_symbol_by_s_value: (::String s_value) -> Grammar::Symbol?
+
+        # @rbs (::String s_value) -> Grammar::Symbol
+        def find_symbol_by_s_value!: (::String s_value) -> Grammar::Symbol
+
+        # @rbs (Lexer::Token::Base id) -> Grammar::Symbol?
+        def find_symbol_by_id: (Lexer::Token::Base id) -> Grammar::Symbol?
+
+        # @rbs (Lexer::Token::Base id) -> Grammar::Symbol
+        def find_symbol_by_id!: (Lexer::Token::Base id) -> Grammar::Symbol
+
+        # @rbs (Integer token_id) -> Grammar::Symbol?
+        def find_symbol_by_token_id: (Integer token_id) -> Grammar::Symbol?
+
+        # @rbs (Integer number) -> Grammar::Symbol
+        def find_symbol_by_number!: (Integer number) -> Grammar::Symbol
+
+        # @rbs () -> void
+        def fill_symbol_number: () -> void
+
+        # @rbs (Array[Grammar::Type] types) -> void
+        def fill_nterm_type: (Array[Grammar::Type] types) -> void
+
+        # @rbs (Array[Grammar::Printer] printers) -> void
+        def fill_printer: (Array[Grammar::Printer] printers) -> void
+
+        # @rbs (Array[Destructor] destructors) -> (Array[Grammar::Symbol] | bot)
+        def fill_destructor: (Array[Destructor] destructors) -> (Array[Grammar::Symbol] | bot)
+
+        # @rbs (Array[Grammar::ErrorToken] error_tokens) -> void
+        def fill_error_token: (Array[Grammar::ErrorToken] error_tokens) -> void
+
+        # @rbs (Lexer::Token::Base token) -> Grammar::Symbol
+        def token_to_symbol: (Lexer::Token::Base token) -> Grammar::Symbol
+
+        # @rbs () -> void
+        def validate!: () -> void
+
+        private
+
+        # @rbs (Lexer::Token::Base id) -> Grammar::Symbol
+        def find_nterm_by_id!: (Lexer::Token::Base id) -> Grammar::Symbol
+
+        # @rbs () -> void
+        def fill_terms_number: () -> void
+
+        # @rbs () -> void
+        def fill_nterms_number: () -> void
+
+        # @rbs () -> Hash[Integer, bool]
+        def used_numbers: () -> Hash[Integer, bool]
+
+        # @rbs () -> void
+        def validate_number_uniqueness!: () -> void
+
+        # @rbs () -> void
+        def validate_alias_name_uniqueness!: () -> void
+
+        # @rbs () -> void
+        def validate_symbols!: () -> void
+      end
+    end
+  end
+end

data/sig/generated/lrama/grammar/type.rbs

@@ -0,0 +1,21 @@
+# Generated from lib/lrama/grammar/type.rb with RBS::Inline
+
+module Lrama
+  class Grammar
+    class Type
+      @id: Lexer::Token::Base
+
+      @tag: Lexer::Token::Tag
+
+      attr_reader id: Lexer::Token::Base
+
+      attr_reader tag: Lexer::Token::Tag
+
+      # @rbs (id: Lexer::Token::Base, tag: Lexer::Token::Tag) -> void
+      def initialize: (id: Lexer::Token::Base, tag: Lexer::Token::Tag) -> void
+
+      # @rbs (Grammar::Type other) -> bool
+      def ==: (Grammar::Type other) -> bool
+    end
+  end
+end

data/sig/generated/lrama/grammar/union.rbs

@@ -0,0 +1,17 @@
+# Generated from lib/lrama/grammar/union.rb with RBS::Inline
+
+module Lrama
+  class Grammar
+    class Union
+      attr_reader code: Grammar::Code::NoReferenceCode
+
+      attr_reader lineno: Integer
+
+      # @rbs (code: Grammar::Code::NoReferenceCode, lineno: Integer) -> void
+      def initialize: (code: Grammar::Code::NoReferenceCode, lineno: Integer) -> void
+
+      # @rbs () -> String
+      def braces_less_code: () -> String
+    end
+  end
+end

data/sig/generated/lrama/grammar.rbs

@@ -0,0 +1,289 @@
+# Generated from lib/lrama/grammar.rb with RBS::Inline
+
+module Lrama
+  # Grammar is the result of parsing an input grammar file
+  class Grammar
+    interface _DelegatedMethods
+      def rules: () -> Array[Rule]
+
+      def accept_symbol: () -> Grammar::Symbol
+
+      def eof_symbol: () -> Grammar::Symbol
+
+      def undef_symbol: () -> Grammar::Symbol
+
+      def precedences: () -> Array[Precedence]
+
+      # 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
+
+      def ielr_defined?: () -> bool
+    end
+
+    include Symbols::Resolver::_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]]
+
+    @parameterized_resolver: Parameterized::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
+
+    @define: Hash[String, String]
+
+    @required: bool
+
+    @union: Union
+
+    @precedences: Array[Precedence]
+
+    @start_nterm: Lrama::Lexer::Token::Base?
+
+    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_reader parameterized_resolver: Parameterized::Resolver
+
+    attr_reader precedences: Array[Precedence]
+
+    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::Base
+
+    attr_accessor before_reduce: Lexer::Token::Base
+
+    attr_accessor after_reduce: Lexer::Token::Base
+
+    attr_accessor after_shift_error_token: Lexer::Token::Base
+
+    attr_accessor after_pop_stack: Lexer::Token::Base
+
+    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
+
+    attr_accessor locations: bool
+
+    attr_accessor define: Hash[String, String]
+
+    attr_accessor required: bool
+
+    # @rbs (Counter rule_counter, bool locations, Hash[String, String] define) -> void
+    def initialize: (Counter rule_counter, bool locations, Hash[String, String] define) -> void
+
+    # @rbs (Counter rule_counter, Counter midrule_action_counter) -> RuleBuilder
+    def create_rule_builder: (Counter rule_counter, Counter midrule_action_counter) -> RuleBuilder
+
+    # @rbs (id: Lexer::Token::Base, code: Lexer::Token::UserCode) -> Array[PercentCode]
+    def add_percent_code: (id: Lexer::Token::Base, code: Lexer::Token::UserCode) -> Array[PercentCode]
+
+    # @rbs (ident_or_tags: Array[Lexer::Token::Ident|Lexer::Token::Tag], token_code: Lexer::Token::UserCode, lineno: Integer) -> Array[Destructor]
+    def add_destructor: (ident_or_tags: Array[Lexer::Token::Ident | Lexer::Token::Tag], token_code: Lexer::Token::UserCode, lineno: Integer) -> Array[Destructor]
+
+    # @rbs (ident_or_tags: Array[Lexer::Token::Ident|Lexer::Token::Tag], token_code: Lexer::Token::UserCode, lineno: Integer) -> Array[Printer]
+    def add_printer: (ident_or_tags: Array[Lexer::Token::Ident | Lexer::Token::Tag], token_code: Lexer::Token::UserCode, lineno: Integer) -> Array[Printer]
+
+    # @rbs (ident_or_tags: Array[Lexer::Token::Ident|Lexer::Token::Tag], token_code: Lexer::Token::UserCode, lineno: Integer) -> Array[ErrorToken]
+    def add_error_token: (ident_or_tags: Array[Lexer::Token::Ident | Lexer::Token::Tag], token_code: Lexer::Token::UserCode, lineno: Integer) -> Array[ErrorToken]
+
+    # @rbs (id: Lexer::Token::Base, tag: Lexer::Token::Tag) -> Array[Type]
+    def add_type: (id: Lexer::Token::Base, tag: Lexer::Token::Tag) -> Array[Type]
+
+    # @rbs (Grammar::Symbol sym, Integer precedence, String s_value, Integer lineno) -> Precedence
+    def add_nonassoc: (Grammar::Symbol sym, Integer precedence, String s_value, Integer lineno) -> Precedence
+
+    # @rbs (Grammar::Symbol sym, Integer precedence, String s_value, Integer lineno) -> Precedence
+    def add_left: (Grammar::Symbol sym, Integer precedence, String s_value, Integer lineno) -> Precedence
+
+    # @rbs (Grammar::Symbol sym, Integer precedence, String s_value, Integer lineno) -> Precedence
+    def add_right: (Grammar::Symbol sym, Integer precedence, String s_value, Integer lineno) -> Precedence
+
+    # @rbs (Grammar::Symbol sym, Integer precedence, String s_value, Integer lineno) -> Precedence
+    def add_precedence: (Grammar::Symbol sym, Integer precedence, String s_value, Integer lineno) -> Precedence
+
+    # @rbs (Lrama::Lexer::Token::Base id) -> Lrama::Lexer::Token::Base
+    def set_start_nterm: (Lrama::Lexer::Token::Base id) -> Lrama::Lexer::Token::Base
+
+    # @rbs (Grammar::Symbol sym, Precedence precedence) -> (Precedence | bot)
+    def set_precedence: (Grammar::Symbol sym, Precedence precedence) -> (Precedence | bot)
+
+    # @rbs (Grammar::Code::NoReferenceCode code, Integer lineno) -> Union
+    def set_union: (Grammar::Code::NoReferenceCode code, Integer lineno) -> Union
+
+    # @rbs (RuleBuilder builder) -> Array[RuleBuilder]
+    def add_rule_builder: (RuleBuilder builder) -> Array[RuleBuilder]
+
+    # @rbs (Parameterized::Rule rule) -> Array[Parameterized::Rule]
+    def add_parameterized_rule: (Parameterized::Rule rule) -> Array[Parameterized::Rule]
+
+    # @rbs () -> Array[Parameterized::Rule]
+    def parameterized_rules: () -> Array[Parameterized::Rule]
+
+    # @rbs (Array[Parameterized::Rule] rules) -> Array[Parameterized::Rule]
+    def prepend_parameterized_rules: (Array[Parameterized::Rule] rules) -> Array[Parameterized::Rule]
+
+    # @rbs (Integer prologue_first_lineno) -> Integer
+    def prologue_first_lineno=: (Integer prologue_first_lineno) -> Integer
+
+    # @rbs (String prologue) -> String
+    def prologue=: (String prologue) -> String
+
+    # @rbs (Integer epilogue_first_lineno) -> Integer
+    def epilogue_first_lineno=: (Integer epilogue_first_lineno) -> Integer
+
+    # @rbs (String epilogue) -> String
+    def epilogue=: (String epilogue) -> String
+
+    # @rbs () -> void
+    def prepare: () -> void
+
+    # TODO: More validation methods
+    #
+    # * Validation for no_declared_type_reference
+    #
+    # @rbs () -> void
+    def validate!: () -> void
+
+    # @rbs (Grammar::Symbol sym) -> Array[Rule]
+    def find_rules_by_symbol!: (Grammar::Symbol sym) -> Array[Rule]
+
+    # @rbs (Grammar::Symbol sym) -> Array[Rule]?
+    def find_rules_by_symbol: (Grammar::Symbol sym) -> Array[Rule]?
+
+    # @rbs (String s_value) -> Array[Rule]
+    def select_rules_by_s_value: (String s_value) -> Array[Rule]
+
+    # @rbs () -> Array[String]
+    def unique_rule_s_values: () -> Array[String]
+
+    # @rbs () -> bool
+    def ielr_defined?: () -> bool
+
+    private
+
+    # @rbs () -> void
+    def sort_precedence: () -> void
+
+    # @rbs () -> Array[Grammar::Symbol]
+    def compute_nullable: () -> Array[Grammar::Symbol]
+
+    # @rbs () -> Array[Grammar::Symbol]
+    def compute_first_set: () -> Array[Grammar::Symbol]
+
+    # @rbs () -> Array[RuleBuilder]
+    def setup_rules: () -> Array[RuleBuilder]
+
+    # @rbs () -> Grammar::Symbol
+    def append_special_symbols: () -> Grammar::Symbol
+
+    # @rbs () -> void
+    def resolve_inline_rules: () -> void
+
+    # @rbs () -> void
+    def normalize_rules: () -> void
+
+    # Add $accept rule to the top of rules
+    def add_accept_rule: () -> untyped
+
+    # Collect symbols from rules
+    #
+    # @rbs () -> void
+    def collect_symbols: () -> void
+
+    # @rbs () -> void
+    def set_lhs_and_rhs: () -> void
+
+    # Rule inherits precedence from the last term in RHS.
+    #
+    # https://www.gnu.org/software/bison/manual/html_node/How-Precedence.html
+    #
+    # @rbs () -> void
+    def fill_default_precedence: () -> void
+
+    # @rbs () -> Array[Grammar::Symbol]
+    def fill_symbols: () -> Array[Grammar::Symbol]
+
+    # @rbs () -> Array[Rule]
+    def fill_sym_to_rules: () -> Array[Rule]
+
+    # @rbs () -> void
+    def validate_no_precedence_for_nterm!: () -> void
+
+    # @rbs () -> void
+    def validate_rule_lhs_is_nterm!: () -> void
+
+    # # @rbs () -> void
+    def validate_duplicated_precedence!: () -> untyped
+
+    # @rbs () -> void
+    def set_locations: () -> void
+  end
+end

data/sig/generated/lrama/lexer/location.rbs

@@ -29,7 +29,7 @@ module Lrama
       def generate_error_message: (String error_message) -> String
 
       # @rbs () -> String
-      def line_with_carets: () -> String
+      def error_with_carets: () -> String
 
       private
 
@@ -37,10 +37,19 @@ module Lrama
       def path: () -> String
 
       # @rbs () -> String
-      def blanks: () -> String
+      def carets_line: () -> String
 
       # @rbs () -> String
-      def carets: () -> String
+      def leading_whitespace: () -> String
+
+      # @rbs () -> String
+      def highlight_marker: () -> String
+
+      # @rbs () -> String
+      def formatted_first_lineno: () -> String
+
+      # @rbs () -> String
+      def line_number_padding: () -> String
 
       # @rbs () -> String
       def text: () -> String

data/sig/generated/lrama/lexer/token/base.rbs

@@ -0,0 +1,53 @@
+# Generated from lib/lrama/lexer/token/base.rb with RBS::Inline
+
+module Lrama
+  class Lexer
+    module Token
+      class Base
+        attr_reader s_value: String
+
+        attr_reader location: Location
+
+        attr_accessor alias_name: String
+
+        attr_accessor referred: bool
+
+        attr_reader errors: Array[String]
+
+        # @rbs (s_value: String, ?alias_name: String, ?location: Location) -> void
+        def initialize: (s_value: String, ?alias_name: String, ?location: Location) -> void
+
+        # @rbs () -> String
+        def to_s: () -> String
+
+        # @rbs (String string) -> bool
+        def referred_by?: (String string) -> bool
+
+        # @rbs (Lexer::Token::Base other) -> bool
+        def ==: (Lexer::Token::Base other) -> bool
+
+        # @rbs () -> Integer
+        def first_line: () -> Integer
+
+        alias line first_line
+
+        # @rbs () -> Integer
+        def first_column: () -> Integer
+
+        alias column first_column
+
+        # @rbs () -> Integer
+        def last_line: () -> Integer
+
+        # @rbs () -> Integer
+        def last_column: () -> Integer
+
+        # @rbs (Lrama::Grammar::Reference ref, String message) -> bot
+        def invalid_ref: (Lrama::Grammar::Reference ref, String message) -> bot
+
+        # @rbs () -> bool
+        def validate: () -> bool
+      end
+    end
+  end
+end

data/sig/generated/lrama/lexer/token/char.rbs

@@ -2,8 +2,15 @@
 
 module Lrama
   class Lexer
-    class Token
-      class Char < Token
+    module Token
+      class Char < Base
+        # @rbs () -> void
+        def validate: () -> void
+
+        private
+
+        # @rbs () -> void
+        def validate_ascii_code_range: () -> void
       end
     end
   end

data/sig/generated/lrama/lexer/token/empty.rbs

@@ -0,0 +1,11 @@
+# Generated from lib/lrama/lexer/token/empty.rb with RBS::Inline
+
+module Lrama
+  class Lexer
+    module Token
+      class Empty < Base
+        def initialize: (?location: untyped) -> untyped
+      end
+    end
+  end
+end

data/sig/generated/lrama/lexer/token/ident.rbs

@@ -2,8 +2,8 @@
 
 module Lrama
   class Lexer
-    class Token
-      class Ident < Token
+    module Token
+      class Ident < Base
       end
     end
   end

data/sig/generated/lrama/lexer/token/instantiate_rule.rbs

@@ -2,14 +2,14 @@
 
 module Lrama
   class Lexer
-    class Token
-      class InstantiateRule < Token
-        attr_reader args: Array[Lexer::Token]
+    module Token
+      class InstantiateRule < Base
+        attr_reader args: Array[Lexer::Token::Base]
 
         attr_reader lhs_tag: Lexer::Token::Tag?
 
-        # @rbs (s_value: String, ?alias_name: String, ?location: Location, ?args: Array[Lexer::Token], ?lhs_tag: Lexer::Token::Tag?) -> void
-        def initialize: (s_value: String, ?alias_name: String, ?location: Location, ?args: Array[Lexer::Token], ?lhs_tag: Lexer::Token::Tag?) -> void
+        # @rbs (s_value: String, ?alias_name: String, ?location: Location, ?args: Array[Lexer::Token::Base], ?lhs_tag: Lexer::Token::Tag?) -> void
+        def initialize: (s_value: String, ?alias_name: String, ?location: Location, ?args: Array[Lexer::Token::Base], ?lhs_tag: Lexer::Token::Tag?) -> void
 
         # @rbs () -> String
         def rule_name: () -> String

data/sig/generated/lrama/lexer/token/int.rbs

@@ -0,0 +1,13 @@
+# Generated from lib/lrama/lexer/token/int.rb with RBS::Inline
+
+module Lrama
+  class Lexer
+    module Token
+      class Int < Base
+        def initialize: (s_value: Integer, ?alias_name: String, ?location: Location) -> void
+
+        def s_value: () -> Integer
+      end
+    end
+  end
+end

data/sig/generated/lrama/lexer/token/str.rbs

@@ -0,0 +1,10 @@
+# Generated from lib/lrama/lexer/token/str.rb with RBS::Inline
+
+module Lrama
+  class Lexer
+    module Token
+      class Str < Base
+      end
+    end
+  end
+end

data/sig/generated/lrama/lexer/token/tag.rbs

@@ -2,8 +2,8 @@
 
 module Lrama
   class Lexer
-    class Token
-      class Tag < Token
+    module Token
+      class Tag < Base
         # @rbs () -> String
         def member: () -> String
       end

data/sig/generated/lrama/lexer/token/token.rbs

@@ -0,0 +1,10 @@
+# Generated from lib/lrama/lexer/token/token.rb with RBS::Inline
+
+module Lrama
+  class Lexer
+    module Token
+      class Token < Base
+      end
+    end
+  end
+end

data/sig/generated/lrama/lexer/token/user_code.rbs

@@ -2,8 +2,8 @@
 
 module Lrama
   class Lexer
-    class Token
-      class UserCode < Token
+    module Token
+      class UserCode < Base
         attr_accessor tag: Lexer::Token::Tag
 
         # @rbs () -> Array[Lrama::Grammar::Reference]