lrama 0.7.0 → 0.7.1

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

@@ -0,0 +1,63 @@
+# Generated from lib/lrama/grammar/code/rule_action.rb with RBS::Inline
+
+module Lrama
+  class Grammar
+    class Code
+      class RuleAction < Code
+        @rule: Rule
+
+        # @rbs (type: ::Symbol, token_code: Lexer::Token::UserCode, rule: Rule) -> void
+        def initialize: (type: ::Symbol, token_code: Lexer::Token::UserCode, rule: Rule) -> void
+
+        private
+
+        # * ($$) yyval
+        # * (@$) yyloc
+        # * ($:$) error
+        # * ($1) yyvsp[i]
+        # * (@1) yylsp[i]
+        # * ($:1) i - 1
+        #
+        #
+        # Consider a rule like
+        #
+        #   class: keyword_class { $1 } tSTRING { $2 + $3 } keyword_end { $class = $1 + $keyword_end }
+        #
+        # For the semantic action of original rule:
+        #
+        # "Rule"                class: keyword_class { $1 } tSTRING { $2 + $3 } keyword_end { $class = $1 + $keyword_end }
+        # "Position in grammar"                   $1     $2      $3          $4          $5
+        # "Index for yyvsp"                       -4     -3      -2          -1           0
+        # "$:n"                                  $:1    $:2     $:3         $:4         $:5
+        # "index of $:n"                          -5     -4      -3          -2          -1
+        #
+        #
+        # For the first midrule action:
+        #
+        # "Rule"                class: keyword_class { $1 } tSTRING { $2 + $3 } keyword_end { $class = $1 + $keyword_end }
+        # "Position in grammar"                   $1
+        # "Index for yyvsp"                        0
+        # "$:n"                                  $:1
+        #
+        # @rbs (Reference ref) -> String
+        def reference_to_c: (Reference ref) -> String
+
+        # @rbs () -> Integer
+        def position_in_rhs: () -> Integer
+
+        # If this is midrule action, RHS is an RHS of the original rule.
+        #
+        # @rbs () -> Array[Grammar::Symbol]
+        def rhs: () -> Array[Grammar::Symbol]
+
+        # Unlike `rhs`, LHS is always an LHS of the rule.
+        #
+        # @rbs () -> Grammar::Symbol
+        def lhs: () -> Grammar::Symbol
+
+        # @rbs (Reference ref) -> bot
+        def raise_tag_not_found_error: (Reference ref) -> bot
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# Generated from lib/lrama/grammar/code.rb with RBS::Inline
+
+module Lrama
+  class Grammar
+    class Code
+      # delegated
+      def s_value: () -> String
+
+      def line: () -> Integer
+
+      def column: () -> Integer
+
+      def references: () -> Array[Lrama::Grammar::Reference]
+
+      extend Forwardable
+
+      attr_reader type: ::Symbol
+
+      attr_reader token_code: Lexer::Token::UserCode
+
+      # @rbs (type: ::Symbol, token_code: Lexer::Token::UserCode) -> void
+      def initialize: (type: ::Symbol, token_code: Lexer::Token::UserCode) -> void
+
+      # @rbs (Code other) -> bool
+      def ==: (Code other) -> bool
+
+      # $$, $n, @$, @n are translated to C code
+      #
+      # @rbs () -> String
+      def translated_code: () -> String
+
+      private
+
+      # @rbs (Lrama::Grammar::Reference ref) -> bot
+      def reference_to_c: (Lrama::Grammar::Reference ref) -> bot
+    end
+  end
+end

data/sig/{lrama → generated/lrama}/grammar/counter.rbs

@@ -1,10 +1,14 @@
+# Generated from lib/lrama/grammar/counter.rb with RBS::Inline
+
 module Lrama
   class Grammar
     class Counter
       @number: Integer
 
+      # @rbs (Integer number) -> void
       def initialize: (Integer number) -> void
 
+      # @rbs () -> Integer
       def increment: () -> Integer
     end
   end

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

@@ -0,0 +1,19 @@
+# Generated from lib/lrama/grammar/destructor.rb with RBS::Inline
+
+module Lrama
+  class Grammar
+    class Destructor
+      attr_reader ident_or_tags: Array[Lexer::Token::Ident | Lexer::Token::Tag]
+
+      attr_reader token_code: Lexer::Token::UserCode
+
+      attr_reader lineno: Integer
+
+      # @rbs (ident_or_tags: Array[Lexer::Token::Ident|Lexer::Token::Tag], token_code: Lexer::Token::UserCode, lineno: Integer) -> void
+      def initialize: (ident_or_tags: Array[Lexer::Token::Ident | Lexer::Token::Tag], token_code: Lexer::Token::UserCode, lineno: Integer) -> void
+
+      # @rbs (Lexer::Token::Tag tag) -> String
+      def translated_code: (Lexer::Token::Tag tag) -> String
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# Generated from lib/lrama/grammar/error_token.rb with RBS::Inline
+
+module Lrama
+  class Grammar
+    class ErrorToken
+      attr_reader ident_or_tags: Array[Lexer::Token::Ident | Lexer::Token::Tag]
+
+      attr_reader token_code: Lexer::Token::UserCode
+
+      attr_reader lineno: Integer
+
+      # @rbs (ident_or_tags: Array[Lexer::Token::Ident|Lexer::Token::Tag], token_code: Lexer::Token::UserCode, lineno: Integer) -> void
+      def initialize: (ident_or_tags: Array[Lexer::Token::Ident | Lexer::Token::Tag], token_code: Lexer::Token::UserCode, lineno: Integer) -> void
+
+      # @rbs (Lexer::Token::Tag tag) -> String
+      def translated_code: (Lexer::Token::Tag tag) -> String
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# Generated from lib/lrama/grammar/inline/resolver.rb with RBS::Inline
+
+module Lrama
+  class Grammar
+    class Inline
+      class Resolver
+        # @rbs (Lrama::Grammar::RuleBuilder rule_builder) -> void
+        def initialize: (Lrama::Grammar::RuleBuilder rule_builder) -> void
+
+        # @rbs () -> Array[Lrama::Grammar::RuleBuilder]
+        def resolve: () -> Array[Lrama::Grammar::RuleBuilder]
+
+        private
+
+        # @rbs (Lrama::Grammar::Parameterized::Rhs rhs, Lrama::Lexer::Token token, Integer index, Lrama::Grammar::Parameterized::Rule rule) -> Lrama::Grammar::RuleBuilder
+        def build_rule: (Lrama::Grammar::Parameterized::Rhs rhs, Lrama::Lexer::Token token, Integer index, Lrama::Grammar::Parameterized::Rule rule) -> Lrama::Grammar::RuleBuilder
+
+        # @rbs (Lrama::Grammar::RuleBuilder builder, Lrama::Grammar::Parameterized::Rhs rhs, Integer index, Lrama::Lexer::Token token, Lrama::Grammar::Parameterized::Rule rule) -> void
+        def resolve_rhs: (Lrama::Grammar::RuleBuilder builder, Lrama::Grammar::Parameterized::Rhs rhs, Integer index, Lrama::Lexer::Token token, Lrama::Grammar::Parameterized::Rule rule) -> void
+
+        # @rbs (Lrama::Grammar::Parameterized::Rhs rhs, Integer index) -> Lrama::Lexer::Token::UserCode
+        def replace_user_code: (Lrama::Grammar::Parameterized::Rhs rhs, Integer index) -> Lrama::Lexer::Token::UserCode
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# Generated from lib/lrama/grammar/parameterized/resolver.rb with RBS::Inline
+
+module Lrama
+  class Grammar
+    class Parameterized
+      class Resolver
+        attr_accessor rules: Array[Rule]
+
+        attr_accessor created_lhs_list: Array[Lexer::Token::Base]
+
+        # @rbs () -> void
+        def initialize: () -> void
+
+        # @rbs (Rule rule) -> Array[Rule]
+        def add_rule: (Rule rule) -> Array[Rule]
+
+        # @rbs (Lexer::Token::InstantiateRule token) -> Rule?
+        def find_rule: (Lexer::Token::InstantiateRule token) -> Rule?
+
+        # @rbs (Lexer::Token::Base token) -> Rule?
+        def find_inline: (Lexer::Token::Base token) -> Rule?
+
+        # @rbs (String lhs_s_value) -> Lexer::Token::Base?
+        def created_lhs: (String lhs_s_value) -> Lexer::Token::Base?
+
+        # @rbs () -> Array[Rule]
+        def redefined_rules: () -> Array[Rule]
+
+        private
+
+        # @rbs (Array[Rule] rules, Lexer::Token::InstantiateRule token) -> Array[Rule]
+        def select_rules: (Array[Rule] rules, Lexer::Token::InstantiateRule token) -> Array[Rule]
+
+        # @rbs (Array[Rule] rules) -> Array[Rule]
+        def reject_inline_rules: (Array[Rule] rules) -> Array[Rule]
+
+        # @rbs (Array[Rule] rules, String rule_name) -> Array[Rule]
+        def select_rules_by_name: (Array[Rule] rules, String rule_name) -> Array[Rule]
+      end
+    end
+  end
+end

data/sig/generated/lrama/grammar/parameterized/rhs.rbs

@@ -0,0 +1,21 @@
+# Generated from lib/lrama/grammar/parameterized/rhs.rb with RBS::Inline
+
+module Lrama
+  class Grammar
+    class Parameterized
+      class Rhs
+        attr_accessor symbols: Array[Lexer::Token::Base]
+
+        attr_accessor user_code: Lexer::Token::UserCode?
+
+        attr_accessor precedence_sym: Grammar::Symbol?
+
+        # @rbs () -> void
+        def initialize: () -> void
+
+        # @rbs (Grammar::Binding bindings) -> Lexer::Token::UserCode?
+        def resolve_user_code: (Grammar::Binding bindings) -> Lexer::Token::UserCode?
+      end
+    end
+  end
+end

data/sig/generated/lrama/grammar/parameterized/rule.rbs

@@ -0,0 +1,28 @@
+# Generated from lib/lrama/grammar/parameterized/rule.rb with RBS::Inline
+
+module Lrama
+  class Grammar
+    class Parameterized
+      class Rule
+        attr_reader name: String
+
+        attr_reader parameters: Array[Lexer::Token::Base]
+
+        attr_reader rhs: Array[Rhs]
+
+        attr_reader required_parameters_count: Integer
+
+        attr_reader tag: Lexer::Token::Tag?
+
+        # @rbs (String name, Array[Lexer::Token::Base] parameters, Array[Rhs] rhs, tag: Lexer::Token::Tag?, is_inline: bool) -> void
+        def initialize: (String name, Array[Lexer::Token::Base] parameters, Array[Rhs] rhs, tag: Lexer::Token::Tag?, is_inline: bool) -> void
+
+        # @rbs () -> String
+        def to_s: () -> String
+
+        # @rbs () -> bool
+        def inline?: () -> bool
+      end
+    end
+  end
+end

data/sig/{lrama → generated/lrama}/grammar/percent_code.rbs

@@ -1,9 +1,17 @@
+# Generated from lib/lrama/grammar/percent_code.rb with RBS::Inline
+
 module Lrama
   class Grammar
     class PercentCode
+      @name: String
+
+      @code: String
+
       attr_reader name: String
+
       attr_reader code: String
 
+      # @rbs (String name, String code) -> void
       def initialize: (String name, String code) -> void
     end
   end

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

@@ -0,0 +1,45 @@
+# Generated from lib/lrama/grammar/precedence.rb with RBS::Inline
+
+module Lrama
+  class Grammar
+    class Precedence
+      include Comparable
+
+      type type_enum = :left | :right | :nonassoc | :precedence
+
+      attr_accessor type: type_enum
+
+      attr_accessor symbol: Grammar::Symbol
+
+      attr_accessor precedence: Integer
+
+      attr_accessor s_value: String
+
+      attr_accessor lineno: Integer
+
+      def initialize: (?type: type_enum, ?symbol: Grammar::Symbol, ?precedence: Integer, ?s_value: ::String, ?lineno: Integer) -> void
+
+      attr_reader used_by_lalr: Array[State::ResolvedConflict]
+
+      attr_reader used_by_ielr: Array[State::ResolvedConflict]
+
+      # @rbs (Precedence other) -> Integer
+      def <=>: (Precedence other) -> Integer
+
+      # @rbs (State::ResolvedConflict resolved_conflict) -> void
+      def mark_used_by_lalr: (State::ResolvedConflict resolved_conflict) -> void
+
+      # @rbs (State::ResolvedConflict resolved_conflict) -> void
+      def mark_used_by_ielr: (State::ResolvedConflict resolved_conflict) -> void
+
+      # @rbs () -> bool
+      def used_by?: () -> bool
+
+      # @rbs () -> bool
+      def used_by_lalr?: () -> bool
+
+      # @rbs () -> bool
+      def used_by_ielr?: () -> bool
+    end
+  end
+end

data/sig/{lrama/grammar/error_token.rbs → generated/lrama/grammar/printer.rbs}

@@ -1,12 +1,17 @@
+# Generated from lib/lrama/grammar/printer.rb with RBS::Inline
+
 module Lrama
   class Grammar
-    class ErrorToken
+    class Printer
       attr_accessor ident_or_tags: Array[Lexer::Token::Ident | Lexer::Token::Tag]
-      attr_accessor token_code: Grammar::Code
+
+      attr_accessor token_code: Lexer::Token::UserCode
+
       attr_accessor lineno: Integer
 
-      def initialize: (?ident_or_tags: Array[Lexer::Token::Ident|Lexer::Token::Tag], ?token_code: Grammar::Code, ?lineno: Integer) -> void
+      def initialize: (?ident_or_tags: Array[Lexer::Token::Ident | Lexer::Token::Tag], ?token_code: Lexer::Token::UserCode, ?lineno: Integer) -> void
 
+      # @rbs (Lexer::Token::Tag tag) -> String
       def translated_code: (Lexer::Token::Tag tag) -> String
     end
   end

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

@@ -0,0 +1,31 @@
+# Generated from lib/lrama/grammar/reference.rb with RBS::Inline
+
+module Lrama
+  class Grammar
+    # type: :dollar or :at
+    # name: String (e.g. $$, $foo, $expr.right)
+    # number: Integer (e.g. $1)
+    # index: Integer
+    # ex_tag: "$<tag>1" (Optional)
+    class Reference
+      attr_accessor type: ::Symbol
+
+      attr_accessor name: String
+
+      attr_accessor number: Integer
+
+      attr_accessor index: Integer
+
+      attr_accessor ex_tag: Lexer::Token::Base?
+
+      attr_accessor first_column: Integer
+
+      attr_accessor last_column: Integer
+
+      def initialize: (type: ::Symbol, first_column: Integer, last_column: Integer, ?name: String, ?number: Integer, ?index: Integer, ?ex_tag: Lexer::Token::Base?) -> void
+
+      # @rbs () -> (String|Integer)
+      def value: () -> (String | Integer)
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+# Generated from lib/lrama/grammar/rule.rb with RBS::Inline
+
+module Lrama
+  class Grammar
+    # _rhs holds original RHS element. Use rhs to refer to Symbol.
+    class Rule
+      interface _DelegatedMethods
+        def lhs: () -> Grammar::Symbol
+
+        def rhs: () -> Array[Grammar::Symbol]
+      end
+
+      attr_accessor id: Integer
+
+      attr_accessor _lhs: Lexer::Token::Base
+
+      attr_accessor lhs: Grammar::Symbol
+
+      attr_accessor lhs_tag: Lexer::Token::Tag?
+
+      attr_accessor _rhs: Array[Lexer::Token::Base]
+
+      attr_accessor rhs: Array[Grammar::Symbol]
+
+      attr_accessor token_code: Lexer::Token::UserCode?
+
+      attr_accessor position_in_original_rule_rhs: Integer
+
+      attr_accessor nullable: bool
+
+      attr_accessor precedence_sym: Grammar::Symbol?
+
+      attr_accessor lineno: Integer?
+
+      def initialize: (?id: Integer, ?_lhs: Lexer::Token::Base?, ?lhs: Lexer::Token::Base, ?lhs_tag: Lexer::Token::Tag?, ?_rhs: Array[Lexer::Token::Base], ?rhs: Array[Grammar::Symbol], ?token_code: Lexer::Token::UserCode?, ?position_in_original_rule_rhs: Integer?, ?nullable: bool, ?precedence_sym: Grammar::Symbol?, ?lineno: Integer?) -> void
+
+      attr_accessor original_rule: Rule
+
+      # @rbs (Rule other) -> bool
+      def ==: (Rule other) -> bool
+
+      # @rbs () -> String
+      def display_name: () -> String
+
+      # @rbs () -> String
+      def display_name_without_action: () -> String
+
+      # @rbs () -> (RailroadDiagrams::Skip | RailroadDiagrams::Sequence)
+      def to_diagrams: () -> (RailroadDiagrams::Skip | RailroadDiagrams::Sequence)
+
+      # Used by #user_actions
+      #
+      # @rbs () -> String
+      def as_comment: () -> String
+
+      # @rbs () -> String
+      def with_actions: () -> String
+
+      # opt_nl: ε     <-- empty_rule
+      #       | '\n'  <-- not empty_rule
+      #
+      # @rbs () -> bool
+      def empty_rule?: () -> bool
+
+      # @rbs () -> Precedence?
+      def precedence: () -> Precedence?
+
+      # @rbs () -> bool
+      def initial_rule?: () -> bool
+
+      # @rbs () -> String?
+      def translated_code: () -> String?
+
+      # @rbs () -> bool
+      def contains_at_reference?: () -> bool
+
+      private
+
+      # @rbs () -> Array[(RailroadDiagrams::Terminal | RailroadDiagrams::NonTerminal)]
+      def rhs_to_diagram: () -> Array[RailroadDiagrams::Terminal | RailroadDiagrams::NonTerminal]
+    end
+  end
+end

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

@@ -0,0 +1,91 @@
+# Generated from lib/lrama/grammar/rule_builder.rb with RBS::Inline
+
+module Lrama
+  class Grammar
+    class RuleBuilder
+      @position_in_original_rule_rhs: Integer?
+
+      @skip_preprocess_references: bool
+
+      @rules: Array[Rule]
+
+      @rule_builders_for_parameterized: Array[RuleBuilder]
+
+      @rule_builders_for_derived_rules: Array[RuleBuilder]
+
+      @parameterized_rules: Array[Rule]
+
+      @midrule_action_rules: Array[Rule]
+
+      @replaced_rhs: Array[Lexer::Token::Base]?
+
+      attr_accessor lhs: Lexer::Token::Base?
+
+      attr_accessor line: Integer?
+
+      attr_reader rule_counter: Counter
+
+      attr_reader midrule_action_counter: Counter
+
+      attr_reader parameterized_resolver: Grammar::Parameterized::Resolver
+
+      attr_reader lhs_tag: Lexer::Token::Tag?
+
+      attr_reader rhs: Array[Lexer::Token::Base]
+
+      attr_reader user_code: Lexer::Token::UserCode?
+
+      attr_reader precedence_sym: Grammar::Symbol?
+
+      # @rbs (Counter rule_counter, Counter midrule_action_counter, Grammar::Parameterized::Resolver parameterized_resolver, ?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::Parameterized::Resolver parameterized_resolver, ?Integer position_in_original_rule_rhs, ?lhs_tag: Lexer::Token::Tag?, ?skip_preprocess_references: bool) -> void
+
+      # @rbs (Lexer::Token::Base rhs) -> void
+      def add_rhs: (Lexer::Token::Base rhs) -> void
+
+      # @rbs (Lexer::Token::UserCode? user_code) -> void
+      def user_code=: (Lexer::Token::UserCode? user_code) -> void
+
+      # @rbs (Grammar::Symbol? precedence_sym) -> void
+      def precedence_sym=: (Grammar::Symbol? precedence_sym) -> void
+
+      # @rbs () -> void
+      def complete_input: () -> void
+
+      # @rbs () -> void
+      def setup_rules: () -> void
+
+      # @rbs () -> Array[Grammar::Rule]
+      def rules: () -> Array[Grammar::Rule]
+
+      # @rbs () -> bool
+      def has_inline_rules?: () -> bool
+
+      private
+
+      # @rbs () -> void
+      def freeze_rhs: () -> void
+
+      # @rbs () -> void
+      def preprocess_references: () -> void
+
+      # @rbs () -> void
+      def build_rules: () -> void
+
+      # rhs is a mixture of variety type of tokens like `Ident`, `InstantiateRule`, `UserCode` and so on.
+      # `#process_rhs` replaces some kind of tokens to `Ident` so that all `@replaced_rhs` are `Ident` or `Char`.
+      #
+      # @rbs () -> void
+      def process_rhs: () -> void
+
+      # @rbs () -> void
+      def resolve_inline_rules: () -> void
+
+      # @rbs () -> void
+      def numberize_references: () -> void
+
+      # @rbs () -> void
+      def flush_user_code: () -> void
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+# Generated from lib/lrama/grammar/symbol.rb with RBS::Inline
+
+module Lrama
+  class Grammar
+    class Symbol
+      attr_accessor id: Lexer::Token::Base
+
+      attr_accessor alias_name: String?
+
+      attr_reader number: Integer
+
+      attr_accessor number_bitmap: Bitmap::bitmap
+
+      attr_accessor tag: Lexer::Token::Tag?
+
+      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: Bitmap::bitmap
+
+      attr_reader term: bool
+
+      attr_writer eof_symbol: bool
+
+      attr_writer error_symbol: bool
+
+      attr_writer undef_symbol: bool
+
+      attr_writer accept_symbol: bool
+
+      # @rbs (id: Lexer::Token::Base, term: bool, ?alias_name: String?, ?number: Integer?, ?tag: Lexer::Token::Tag?,
+      #      ?token_id: Integer?, ?nullable: bool?, ?precedence: Precedence?, ?printer: Printer?) -> void
+      def initialize: (id: Lexer::Token::Base, term: bool, ?alias_name: String?, ?number: Integer?, ?tag: Lexer::Token::Tag?, ?token_id: Integer?, ?nullable: bool?, ?precedence: Precedence?, ?printer: Printer?) -> void
+
+      # @rbs (Integer) -> void
+      def number=: (Integer) -> void
+
+      # @rbs () -> bool
+      def term?: () -> bool
+
+      # @rbs () -> bool
+      def nterm?: () -> bool
+
+      # @rbs () -> bool
+      def eof_symbol?: () -> bool
+
+      # @rbs () -> bool
+      def error_symbol?: () -> bool
+
+      # @rbs () -> bool
+      def undef_symbol?: () -> bool
+
+      # @rbs () -> bool
+      def accept_symbol?: () -> bool
+
+      # @rbs () -> bool
+      def midrule?: () -> bool
+
+      # @rbs () -> String
+      def name: () -> String
+
+      # @rbs () -> String
+      def display_name: () -> String
+
+      # name for yysymbol_kind_t
+      #
+      # See: b4_symbol_kind_base
+      # @type var name: String
+      # @rbs () -> String
+      def enum_name: () -> String
+
+      # comment for yysymbol_kind_t
+      #
+      # @rbs () -> String?
+      def comment: () -> String?
+    end
+  end
+end