lrama 0.7.0 → 0.7.1

data/lib/lrama/grammar/rule_builder.rb

@@ -1,15 +1,38 @@
+# rbs_inline: enabled
 # frozen_string_literal: true
 
 module Lrama
   class Grammar
     class RuleBuilder
-      attr_accessor :lhs, :line
-      attr_reader :lhs_tag, :rhs, :user_code, :precedence_sym
-
-      def initialize(rule_counter, midrule_action_counter, parameterizing_rule_resolver, position_in_original_rule_rhs = nil, lhs_tag: nil, skip_preprocess_references: false)
+      # TODO: rbs-inline 0.11.0 doesn't support instance variables.
+      #       Move these type declarations above instance variable definitions, once it's supported.
+      #       see: https://github.com/soutaro/rbs-inline/pull/149
+      #
+      # @rbs!
+      #   @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(rule_counter, midrule_action_counter, parameterized_resolver, position_in_original_rule_rhs = nil, lhs_tag: nil, skip_preprocess_references: false)
         @rule_counter = rule_counter
         @midrule_action_counter = midrule_action_counter
-        @parameterizing_rule_resolver = parameterizing_rule_resolver
+        @parameterized_resolver = parameterized_resolver
         @position_in_original_rule_rhs = position_in_original_rule_rhs
         @skip_preprocess_references = skip_preprocess_references
 
@@ -20,12 +43,13 @@ module Lrama
         @precedence_sym = nil
         @line = nil
         @rules = []
-        @rule_builders_for_parameterizing_rules = []
+        @rule_builders_for_parameterized = []
         @rule_builders_for_derived_rules = []
-        @parameterizing_rules = []
+        @parameterized_rules = []
         @midrule_action_rules = []
       end
 
+      # @rbs (Lexer::Token::Base rhs) -> void
       def add_rhs(rhs)
         @line ||= rhs.line
 
@@ -34,6 +58,7 @@ module Lrama
         @rhs << rhs
       end
 
+      # @rbs (Lexer::Token::UserCode? user_code) -> void
       def user_code=(user_code)
         @line ||= user_code&.line
 
@@ -42,72 +67,59 @@ module Lrama
         @user_code = user_code
       end
 
+      # @rbs (Grammar::Symbol? precedence_sym) -> void
       def precedence_sym=(precedence_sym)
         flush_user_code
 
         @precedence_sym = precedence_sym
       end
 
+      # @rbs () -> void
       def complete_input
         freeze_rhs
       end
 
+      # @rbs () -> void
       def setup_rules
         preprocess_references unless @skip_preprocess_references
         process_rhs
+        resolve_inline_rules
         build_rules
       end
 
+      # @rbs () -> Array[Grammar::Rule]
       def rules
-        @parameterizing_rules + @midrule_action_rules + @rules
+        @parameterized_rules + @midrule_action_rules + @rules
       end
 
+      # @rbs () -> bool
       def has_inline_rules?
-        rhs.any? { |token| @parameterizing_rule_resolver.find_inline(token) }
-      end
-
-      def resolve_inline_rules
-        resolved_builders = [] #: Array[RuleBuilder]
-        rhs.each_with_index do |token, i|
-          if (inline_rule = @parameterizing_rule_resolver.find_inline(token))
-            inline_rule.rhs_list.each do |inline_rhs|
-              rule_builder = RuleBuilder.new(@rule_counter, @midrule_action_counter, @parameterizing_rule_resolver, lhs_tag: lhs_tag)
-              if token.is_a?(Lexer::Token::InstantiateRule)
-                resolve_inline_rhs(rule_builder, inline_rhs, i, Binding.new(inline_rule.parameters, token.args))
-              else
-                resolve_inline_rhs(rule_builder, inline_rhs, i)
-              end
-              rule_builder.lhs = lhs
-              rule_builder.line = line
-              rule_builder.precedence_sym = precedence_sym
-              rule_builder.user_code = replace_inline_user_code(inline_rhs, i)
-              resolved_builders << rule_builder
-            end
-            break
-          end
-        end
-        resolved_builders
+        rhs.any? { |token| @parameterized_resolver.find_inline(token) }
       end
 
       private
 
+      # @rbs () -> void
       def freeze_rhs
         @rhs.freeze
       end
 
+      # @rbs () -> void
       def preprocess_references
         numberize_references
       end
 
+      # @rbs () -> void
       def build_rules
-        tokens = @replaced_rhs
+        tokens = @replaced_rhs #: Array[Lexer::Token::Base]
+        return if tokens.any? { |t| @parameterized_resolver.find_inline(t) }
 
         rule = Rule.new(
           id: @rule_counter.increment, _lhs: lhs, _rhs: tokens, lhs_tag: lhs_tag, token_code: user_code,
           position_in_original_rule_rhs: @position_in_original_rule_rhs, precedence_sym: precedence_sym, lineno: line
         )
         @rules = [rule]
-        @parameterizing_rules = @rule_builders_for_parameterizing_rules.map do |rule_builder|
+        @parameterized_rules = @rule_builders_for_parameterized.map do |rule_builder|
           rule_builder.rules
         end.flatten
         @midrule_action_rules = @rule_builders_for_derived_rules.map do |rule_builder|
@@ -120,31 +132,33 @@ module Lrama
 
       # 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
         return if @replaced_rhs
 
-        @replaced_rhs = []
+        replaced_rhs = [] #: Array[Lexer::Token::Base]
 
         rhs.each_with_index do |token, i|
           case token
           when Lrama::Lexer::Token::Char
-            @replaced_rhs << token
+            replaced_rhs << token
           when Lrama::Lexer::Token::Ident
-            @replaced_rhs << token
+            replaced_rhs << token
           when Lrama::Lexer::Token::InstantiateRule
-            parameterizing_rule = @parameterizing_rule_resolver.find_rule(token)
-            raise "Unexpected token. #{token}" unless parameterizing_rule
+            parameterized_rule = @parameterized_resolver.find_rule(token)
+            raise "Unexpected token. #{token}" unless parameterized_rule
 
-            bindings = Binding.new(parameterizing_rule.parameters, token.args)
+            bindings = Binding.new(parameterized_rule.parameters, token.args)
             lhs_s_value = bindings.concatenated_args_str(token)
-            if (created_lhs = @parameterizing_rule_resolver.created_lhs(lhs_s_value))
-              @replaced_rhs << created_lhs
+            if (created_lhs = @parameterized_resolver.created_lhs(lhs_s_value))
+              replaced_rhs << created_lhs
             else
               lhs_token = Lrama::Lexer::Token::Ident.new(s_value: lhs_s_value, location: token.location)
-              @replaced_rhs << lhs_token
-              @parameterizing_rule_resolver.created_lhs_list << lhs_token
-              parameterizing_rule.rhs_list.each do |r|
-                rule_builder = RuleBuilder.new(@rule_counter, @midrule_action_counter, @parameterizing_rule_resolver, lhs_tag: token.lhs_tag || parameterizing_rule.tag)
+              replaced_rhs << lhs_token
+              @parameterized_resolver.created_lhs_list << lhs_token
+              parameterized_rule.rhs.each do |r|
+                rule_builder = RuleBuilder.new(@rule_counter, @midrule_action_counter, @parameterized_resolver, lhs_tag: token.lhs_tag || parameterized_rule.tag)
                 rule_builder.lhs = lhs_token
                 r.symbols.each { |sym| rule_builder.add_rhs(bindings.resolve_symbol(sym)) }
                 rule_builder.line = line
@@ -152,51 +166,48 @@ module Lrama
                 rule_builder.user_code = r.resolve_user_code(bindings)
                 rule_builder.complete_input
                 rule_builder.setup_rules
-                @rule_builders_for_parameterizing_rules << rule_builder
+                @rule_builders_for_parameterized << rule_builder
               end
             end
           when Lrama::Lexer::Token::UserCode
             prefix = token.referred ? "@" : "$@"
             tag = token.tag || lhs_tag
             new_token = Lrama::Lexer::Token::Ident.new(s_value: prefix + @midrule_action_counter.increment.to_s)
-            @replaced_rhs << new_token
+            replaced_rhs << new_token
 
-            rule_builder = RuleBuilder.new(@rule_counter, @midrule_action_counter, @parameterizing_rule_resolver, i, lhs_tag: tag, skip_preprocess_references: true)
+            rule_builder = RuleBuilder.new(@rule_counter, @midrule_action_counter, @parameterized_resolver, i, lhs_tag: tag, skip_preprocess_references: true)
             rule_builder.lhs = new_token
             rule_builder.user_code = token
             rule_builder.complete_input
             rule_builder.setup_rules
 
             @rule_builders_for_derived_rules << rule_builder
+          when Lrama::Lexer::Token::Empty
+            # Noop
           else
             raise "Unexpected token. #{token}"
           end
         end
-      end
 
-      def resolve_inline_rhs(rule_builder, inline_rhs, index, bindings = nil)
-        rhs.each_with_index do |token, i|
-          if index == i
-            inline_rhs.symbols.each { |sym| rule_builder.add_rhs(bindings.nil? ? sym : bindings.resolve_symbol(sym)) }
-          else
-            rule_builder.add_rhs(token)
-          end
-        end
+        @replaced_rhs = replaced_rhs
       end
 
-      def replace_inline_user_code(inline_rhs, index)
-        return user_code if inline_rhs.user_code.nil?
-        return user_code if user_code.nil?
-
-        code = user_code.s_value.gsub(/\$#{index + 1}/, inline_rhs.user_code.s_value)
-        user_code.references.each do |ref|
-          next if ref.index.nil? || ref.index <= index # nil is a case for `$$`
-          code = code.gsub(/\$#{ref.index}/, "$#{ref.index + (inline_rhs.symbols.count-1)}")
-          code = code.gsub(/@#{ref.index}/, "@#{ref.index + (inline_rhs.symbols.count-1)}")
+      # @rbs () -> void
+      def resolve_inline_rules
+        while @rule_builders_for_parameterized.any?(&:has_inline_rules?) do
+          @rule_builders_for_parameterized = @rule_builders_for_parameterized.flat_map do |rule_builder|
+            if rule_builder.has_inline_rules?
+              inlined_builders = Inline::Resolver.new(rule_builder).resolve
+              inlined_builders.each { |builder| builder.setup_rules }
+              inlined_builders
+            else
+              rule_builder
+            end
+          end
         end
-        Lrama::Lexer::Token::UserCode.new(s_value: code, location: user_code.location)
       end
 
+      # @rbs () -> void
       def numberize_references
         # Bison n'th component is 1-origin
         (rhs + [user_code]).compact.each.with_index(1) do |token, i|
@@ -209,7 +220,10 @@ module Lrama
               if ref_name == '$'
                 ref.name = '$'
               else
-                candidates = ([lhs] + rhs).each_with_index.select {|token, _i| token.referred_by?(ref_name) }
+                candidates = ([lhs] + rhs).each_with_index.select do |token, _i|
+                  # @type var token: Lexer::Token::Base
+                  token.referred_by?(ref_name)
+                end
 
                 if candidates.size >= 2
                   token.invalid_ref(ref, "Referring symbol `#{ref_name}` is duplicated.")
@@ -244,6 +258,7 @@ module Lrama
         end
       end
 
+      # @rbs () -> void
       def flush_user_code
         if (c = @user_code)
           @rhs << c

data/lib/lrama/grammar/stdlib.y

@@ -3,26 +3,43 @@
   stdlib.y
 
   This is lrama's standard library. It provides a number of
-  parameterizing rule definitions, such as options and lists,
+  parameterized rule definitions, such as options and lists,
   that should be useful in a number of situations.
 
 **********************************************************************/
 
+%%
+
 // -------------------------------------------------------------------
 // Options
 
 /*
- * program: option(number)
+ * program: option(X)
+ *
+ * =>
+ *
+ * program: option_X
+ * option_X: %empty
+ * option_X: X
+ */
+%rule option(X)
+                : /* empty */
+                | X
+                ;
+
+
+/*
+ * program: ioption(X)
  *
  * =>
  *
- * program: option_number
- * option_number: %empty
- * option_number: number
+ * program: %empty
+ * program: X
  */
-%rule option(X): /* empty */
-               | X
-               ;
+%rule %inline ioption(X)
+                : /* empty */
+                | X
+                ;
 
 // -------------------------------------------------------------------
 // Sequences
@@ -35,8 +52,9 @@
  * program: preceded_opening_X
  * preceded_opening_X: opening X
  */
-%rule preceded(opening, X): opening X { $$ = $2; }
-                          ;
+%rule preceded(opening, X)
+                : opening X { $$ = $2; }
+                ;
 
 /*
  * program: terminated(X, closing)
@@ -46,8 +64,9 @@
  * program: terminated_X_closing
  * terminated_X_closing: X closing
  */
-%rule terminated(X, closing): X closing { $$ = $1; }
-                            ;
+%rule terminated(X, closing)
+                : X closing { $$ = $1; }
+                ;
 
 /*
  * program: delimited(opening, X, closing)
@@ -57,66 +76,67 @@
  * program: delimited_opening_X_closing
  * delimited_opening_X_closing: opening X closing
  */
-%rule delimited(opening, X, closing): opening X closing { $$ = $2; }
-                                     ;
+%rule delimited(opening, X, closing)
+                : opening X closing { $$ = $2; }
+                ;
 
 // -------------------------------------------------------------------
 // Lists
 
 /*
- * program: list(number)
+ * program: list(X)
  *
  * =>
  *
- * program: list_number
- * list_number: %empty
- * list_number: list_number number
+ * program: list_X
+ * list_X: %empty
+ * list_X: list_X X
  */
-%rule list(X): /* empty */
-             | list(X) X
-             ;
+%rule list(X)
+                : /* empty */
+                | list(X) X
+                ;
 
 /*
- * program: nonempty_list(number)
+ * program: nonempty_list(X)
  *
  * =>
  *
- * program: nonempty_list_number
- * nonempty_list_number: number
- * nonempty_list_number: nonempty_list_number number
+ * program: nonempty_list_X
+ * nonempty_list_X: X
+ * nonempty_list_X: nonempty_list_X X
  */
-%rule nonempty_list(X): X
-                      | nonempty_list(X) X
-                      ;
+%rule nonempty_list(X)
+                : X
+                | nonempty_list(X) X
+                ;
 
 /*
- * program: separated_nonempty_list(comma, number)
+ * program: separated_nonempty_list(separator, X)
  *
  * =>
  *
- * program: separated_nonempty_list_comma_number
- * separated_nonempty_list_comma_number: number
- * separated_nonempty_list_comma_number: separated_nonempty_list_comma_number comma number
+ * program: separated_nonempty_list_separator_X
+ * separated_nonempty_list_separator_X: X
+ * separated_nonempty_list_separator_X: separated_nonempty_list_separator_X separator X
  */
-%rule separated_nonempty_list(separator, X): X
-                                           | separated_nonempty_list(separator, X) separator X
-                                           ;
+%rule separated_nonempty_list(separator, X)
+                : X
+                | separated_nonempty_list(separator, X) separator X
+                ;
 
 /*
- * program: separated_list(comma, number)
+ * program: separated_list(separator, X)
  *
  * =>
  *
- * program: separated_list_comma_number
- * separated_list_comma_number: option_separated_nonempty_list_comma_number
- * option_separated_nonempty_list_comma_number: %empty
- * option_separated_nonempty_list_comma_number: separated_nonempty_list_comma_number
- * separated_nonempty_list_comma_number: number
- * separated_nonempty_list_comma_number: comma separated_nonempty_list_comma_number number
+ * program: separated_list_separator_X
+ * separated_list_separator_X: option_separated_nonempty_list_separator_X
+ * option_separated_nonempty_list_separator_X: %empty
+ * option_separated_nonempty_list_separator_X: separated_nonempty_list_separator_X
+ * separated_nonempty_list_separator_X: X
+ * separated_nonempty_list_separator_X: separator separated_nonempty_list_separator_X X
  */
-%rule separated_list(separator, X): option(separated_nonempty_list(separator, X))
-                                  ;
-
-%%
-
-%union{};
+%rule separated_list(separator, X)
+                : option(separated_nonempty_list(separator, X))
+                ;

data/lib/lrama/grammar/symbol.rb

@@ -1,19 +1,35 @@
+# rbs_inline: enabled
 # frozen_string_literal: true
 
 # Symbol is both of nterm and term
 # `number` is both for nterm and term
 # `token_id` is tokentype for term, internal sequence number for nterm
 #
-# TODO: Add validation for ASCII code range for Token::Char
 
 module Lrama
   class Grammar
     class Symbol
-      attr_accessor :id, :alias_name, :tag, :number, :token_id, :nullable, :precedence,
-                    :printer, :destructor, :error_token, :first_set, :first_set_bitmap
-      attr_reader :term
-      attr_writer :eof_symbol, :error_symbol, :undef_symbol, :accept_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:, term:, alias_name: nil, number: nil, tag: nil, token_id: nil, nullable: nil, precedence: nil, printer: nil, destructor: nil)
         @id = id
         @alias_name = alias_name
@@ -27,77 +43,105 @@ module Lrama
         @destructor = destructor
       end
 
+      # @rbs (Integer) -> void
+      def number=(number)
+        @number = number
+        @number_bitmap = Bitmap::from_integer(number)
+      end
+
+      # @rbs () -> bool
       def term?
         term
       end
 
+      # @rbs () -> bool
       def nterm?
         !term
       end
 
+      # @rbs () -> bool
       def eof_symbol?
         !!@eof_symbol
       end
 
+      # @rbs () -> bool
       def error_symbol?
         !!@error_symbol
       end
 
+      # @rbs () -> bool
       def undef_symbol?
         !!@undef_symbol
       end
 
+      # @rbs () -> bool
       def accept_symbol?
         !!@accept_symbol
       end
 
+      # @rbs () -> bool
+      def midrule?
+        return false if term?
+
+        name.include?("$") || name.include?("@")
+      end
+
+      # @rbs () -> String
+      def name
+        id.s_value
+      end
+
+      # @rbs () -> String
       def display_name
-        alias_name || id.s_value
+        alias_name || name
       end
 
       # name for yysymbol_kind_t
       #
       # See: b4_symbol_kind_base
       # @type var name: String
+      # @rbs () -> String
       def enum_name
         case
         when accept_symbol?
-          name = "YYACCEPT"
+          res = "YYACCEPT"
         when eof_symbol?
-          name = "YYEOF"
+          res = "YYEOF"
         when term? && id.is_a?(Lrama::Lexer::Token::Char)
-          name = number.to_s + display_name
+          res = number.to_s + display_name
         when term? && id.is_a?(Lrama::Lexer::Token::Ident)
-          name = id.s_value
-        when nterm? && (id.s_value.include?("$") || id.s_value.include?("@"))
-          name = number.to_s + id.s_value
+          res = name
+        when midrule?
+          res = number.to_s + name
         when nterm?
-          name = id.s_value
+          res = name
         else
           raise "Unexpected #{self}"
         end
 
-        "YYSYMBOL_" + name.gsub(/\W+/, "_")
+        "YYSYMBOL_" + res.gsub(/\W+/, "_")
       end
 
       # comment for yysymbol_kind_t
+      #
+      # @rbs () -> String?
       def comment
         case
         when accept_symbol?
           # YYSYMBOL_YYACCEPT
-          id.s_value
+          name
         when eof_symbol?
           # YYEOF
           alias_name
         when (term? && 0 < token_id && token_id < 128)
           # YYSYMBOL_3_backslash_, YYSYMBOL_14_
-          alias_name || id.s_value
-        when id.s_value.include?("$") || id.s_value.include?("@")
+          display_name
+        when midrule?
           # YYSYMBOL_21_1
-          id.s_value
+          name
         else
           # YYSYMBOL_keyword_class, YYSYMBOL_strings_1
-          alias_name || id.s_value
+          display_name
         end
       end
     end