Add support for type specification in parameterizing rules

lib/lrama/grammar.rb

@@ -392,7 +392,7 @@ def normalize_rules
         end
 
         builder.parameterizing_rules.each do |rule|
-          add_nterm(id: rule._lhs)
+          add_nterm(id: rule._lhs, tag: rule.lhs_tag)
           @rules << rule
         end
 

lib/lrama/grammar/parameterizing_rules/builder.rb

@@ -21,10 +21,11 @@ class Builder
           separated_list: Lrama::Grammar::ParameterizingRules::Builder::SeparatedList,
         }
 
-        def initialize(token, rule_counter, user_code, precedence_sym, line)
+        def initialize(token, rule_counter, lhs_tag, user_code, precedence_sym, line)
           @token = token
           @key = token.s_value.to_sym
           @rule_counter = rule_counter
+          @lhs_tag = lhs_tag
           @user_code = user_code
           @precedence_sym = precedence_sym
           @line = line
@@ -46,7 +47,7 @@ def build_token
         def create_builder
           unless @builder
             validate_key!
-            @builder = RULES[@key].new(@token, @rule_counter, @user_code, @precedence_sym, @line)
+            @builder = RULES[@key].new(@token, @rule_counter, @lhs_tag, @user_code, @precedence_sym, @line)
           end
         end
 

lib/lrama/grammar/parameterizing_rules/builder/base.rb

@@ -6,10 +6,11 @@ class Builder
         class Base
           attr_reader :build_token
 
-          def initialize(token, rule_counter, user_code, precedence_sym, line)
+          def initialize(token, rule_counter, lhs_tag, user_code, precedence_sym, line)
             @args = token.args
             @token = @args.first
             @rule_counter = rule_counter
+            @lhs_tag = lhs_tag
             @user_code = user_code
             @precedence_sym = precedence_sym
             @line = line

lib/lrama/grammar/parameterizing_rules/builder/list.rb

@@ -17,8 +17,8 @@ def build
 
             rules = []
             @build_token = Lrama::Lexer::Token::Ident.new(s_value: "list_#{@token.s_value}")
-            rules << Rule.new(id: @rule_counter.increment, _lhs: @build_token, _rhs: [], token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
-            rules << Rule.new(id: @rule_counter.increment, _lhs: @build_token, _rhs: [@build_token, @token], token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
+            rules << Rule.new(id: @rule_counter.increment, _lhs: @build_token, _rhs: [], lhs_tag: @lhs_tag, token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
+            rules << Rule.new(id: @rule_counter.increment, _lhs: @build_token, _rhs: [@build_token, @token], lhs_tag: @lhs_tag, token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
             rules
           end
         end

lib/lrama/grammar/parameterizing_rules/builder/nonempty_list.rb

@@ -17,8 +17,8 @@ def build
 
             rules = []
             @build_token = Lrama::Lexer::Token::Ident.new(s_value: "nonempty_list_#{@token.s_value}")
-            rules << Rule.new(id: @rule_counter.increment, _lhs: @build_token, _rhs: [@token], token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
-            rules << Rule.new(id: @rule_counter.increment, _lhs: @build_token, _rhs: [@build_token, @token], token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
+            rules << Rule.new(id: @rule_counter.increment, _lhs: @build_token, _rhs: [@token], lhs_tag: @lhs_tag, token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
+            rules << Rule.new(id: @rule_counter.increment, _lhs: @build_token, _rhs: [@build_token, @token], lhs_tag: @lhs_tag, token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
             rules
           end
         end

lib/lrama/grammar/parameterizing_rules/builder/option.rb

@@ -17,8 +17,8 @@ def build
 
             rules = []
             @build_token = Lrama::Lexer::Token::Ident.new(s_value: "option_#{@token.s_value}")
-            rules << Rule.new(id: @rule_counter.increment, _lhs: @build_token, _rhs: [], token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
-            rules << Rule.new(id: @rule_counter.increment, _lhs: @build_token, _rhs: [@token], token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
+            rules << Rule.new(id: @rule_counter.increment, _lhs: @build_token, _rhs: [], lhs_tag: @lhs_tag, token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
+            rules << Rule.new(id: @rule_counter.increment, _lhs: @build_token, _rhs: [@token], lhs_tag: @lhs_tag, token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
             rules
           end
         end

lib/lrama/grammar/parameterizing_rules/builder/separated_list.rb

@@ -4,7 +4,7 @@ class ParameterizingRules
       class Builder
         # Builder for separated list of general parameterizing rules
         class SeparatedList < Base
-          def initialize(token, rule_counter, user_code, precedence_sym, line)
+          def initialize(token, rule_counter, lhs_tag, user_code, precedence_sym, line)
             super
             @separator = @args[0]
             @token = @args[1]
@@ -26,10 +26,10 @@ def build
             rules = []
             @build_token = Lrama::Lexer::Token::Ident.new(s_value: "separated_list_#{@token.s_value}")
             separated_nonempty_list_token = Lrama::Lexer::Token::Ident.new(s_value: "separated_nonempty_list_#{@token.s_value}")
-            rules << Rule.new(id: @rule_counter.increment, _lhs: @build_token, _rhs: [], token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
-            rules << Rule.new(id: @rule_counter.increment, _lhs: @build_token, _rhs: [separated_nonempty_list_token], token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
-            rules << Rule.new(id: @rule_counter.increment, _lhs: separated_nonempty_list_token, _rhs: [@token], token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
-            rules << Rule.new(id: @rule_counter.increment, _lhs: separated_nonempty_list_token, _rhs: [separated_nonempty_list_token, @separator, @token], token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
+            rules << Rule.new(id: @rule_counter.increment, _lhs: @build_token, _rhs: [], lhs_tag: @lhs_tag, token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
+            rules << Rule.new(id: @rule_counter.increment, _lhs: @build_token, _rhs: [separated_nonempty_list_token], lhs_tag: @lhs_tag, token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
+            rules << Rule.new(id: @rule_counter.increment, _lhs: separated_nonempty_list_token, _rhs: [@token], lhs_tag: @lhs_tag, token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
+            rules << Rule.new(id: @rule_counter.increment, _lhs: separated_nonempty_list_token, _rhs: [separated_nonempty_list_token, @separator, @token], lhs_tag: @lhs_tag, token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
             rules
           end
         end

lib/lrama/grammar/parameterizing_rules/builder/separated_nonempty_list.rb

@@ -4,7 +4,7 @@ class ParameterizingRules
       class Builder
         # Builder for separated nonempty list of general parameterizing rules
         class SeparatedNonemptyList < Base
-          def initialize(token, rule_counter, user_code, precedence_sym, line)
+          def initialize(token, rule_counter, lhs_tag, user_code, precedence_sym, line)
             super
             @separator = @args[0]
             @token = @args[1]
@@ -23,8 +23,8 @@ def build
 
             rules = []
             @build_token = Lrama::Lexer::Token::Ident.new(s_value: "separated_nonempty_list_#{@token.s_value}")
-            rules << Rule.new(id: @rule_counter.increment, _lhs: @build_token, _rhs: [@token], token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
-            rules << Rule.new(id: @rule_counter.increment, _lhs: @build_token, _rhs: [@build_token, @separator, @token], token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
+            rules << Rule.new(id: @rule_counter.increment, _lhs: @build_token, _rhs: [@token], lhs_tag: @lhs_tag, token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
+            rules << Rule.new(id: @rule_counter.increment, _lhs: @build_token, _rhs: [@build_token, @separator, @token], lhs_tag: @lhs_tag, token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
             rules
           end
         end

lib/lrama/grammar/rule.rb

@@ -1,12 +1,13 @@
 module Lrama
   class Grammar
     # _rhs holds original RHS element. Use rhs to refer to Symbol.
-    class Rule < Struct.new(:id, :_lhs, :lhs, :_rhs, :rhs, :token_code, :position_in_original_rule_rhs, :nullable, :precedence_sym, :lineno, keyword_init: true)
+    class Rule < Struct.new(:id, :_lhs, :lhs, :lhs_tag, :_rhs, :rhs, :token_code, :position_in_original_rule_rhs, :nullable, :precedence_sym, :lineno, keyword_init: true)
       attr_accessor :original_rule
 
       def ==(other)
         self.class == other.class &&
         self.lhs == other.lhs &&
+        self.lhs_tag == other.lhs_tag &&
         self.rhs == other.rhs &&
         self.token_code == other.token_code &&
         self.position_in_original_rule_rhs == other.position_in_original_rule_rhs &&

lib/lrama/grammar/rule_builder.rb

@@ -3,7 +3,7 @@
 module Lrama
   class Grammar
     class RuleBuilder
-      attr_accessor :lhs, :line
+      attr_accessor :lhs, :lhs_tag, :line
       attr_reader :rhs, :user_code, :precedence_sym
 
       def initialize(rule_counter, midrule_action_counter, position_in_original_rule_rhs = nil, skip_preprocess_references: false)
@@ -14,6 +14,7 @@ def initialize(rule_counter, midrule_action_counter, position_in_original_rule_r
 
         @lhs = nil
         @rhs = []
+        @lhs_tag = nil
         @user_code = nil
         @precedence_sym = nil
         @line = nil
@@ -109,7 +110,7 @@ def process_rhs
           when Lrama::Lexer::Token::Ident
             @replaced_rhs << token
           when Lrama::Lexer::Token::Parameterizing
-            parameterizing = ParameterizingRules::Builder.new(token, @rule_counter, user_code, precedence_sym, line)
+            parameterizing = ParameterizingRules::Builder.new(token, @rule_counter, @lhs_tag, user_code, precedence_sym, line)
             parameterizing.build.each do |r|
               @parameterizing_rules << r
             end