Lrama v0.6.1

23 files changed, 429 insertions, 348 deletions

diff --git a/tool/lrama/NEWS.md b/tool/lrama/NEWS.md
index 0af278fc06..c4a0f28f5b 100644
--- a/tool/lrama/NEWS.md
+++ b/tool/lrama/NEWS.md
@@ -1,5 +1,49 @@
 # NEWS for Lrama
 
+## Lrama 0.6.1 (2024-01-13)
+
+### Nested parameterizing rules
+
+Allow to pass an instantiated rule to other parameterizing rules.
+
+```
+%rule constant(X) : X
+              ;
+
+%rule option(Y) : /* empty */
+                | Y
+                ;
+
+%%
+
+program         : option(constant(number)) // Nested rule
+                ;
+%%
+```
+
+Allow to use nested parameterizing rules when define parameterizing rules.
+
+```
+%rule option(x) : /* empty */
+                | X
+                ;
+
+%rule double(Y) : Y Y
+                ;
+
+%rule double_opt(A) : option(double(A)) // Nested rule
+                    ;
+
+%%
+
+program         : double_opt(number)
+                ;
+
+%%
+```
+
+https://github.com/ruby/lrama/pull/337
+
 ## Lrama 0.6.0 (2023-12-25)
 
 ### User defined parameterizing rules
@@ -20,6 +64,8 @@ stmt: pair(ODD, EVEN) <num>
     ;
 ```
 
+https://github.com/ruby/lrama/pull/285
+
 ## Lrama 0.5.11 (2023-12-02)
 
 ### Type specification of parameterizing rules
diff --git a/tool/lrama/lib/lrama/command.rb b/tool/lrama/lib/lrama/command.rb
index b6b1fd2766..a39eed139b 100644
--- a/tool/lrama/lib/lrama/command.rb
+++ b/tool/lrama/lib/lrama/command.rb
@@ -1,14 +1,28 @@
 module Lrama
   class Command
     def run(argv)
-      options = OptionParser.new.parse(argv)
+      begin
+        options = OptionParser.new.parse(argv)
+      rescue => e
+        message = e.message
+        message = message.gsub(/.+/, "\e[1m\\&\e[m") if Exception.to_tty?
+        abort message
+      end
 
       Report::Duration.enable if options.trace_opts[:time]
 
       warning = Lrama::Warning.new
       text = options.y.read
       options.y.close if options.y != STDIN
-      grammar = Lrama::Parser.new(text, options.grammar_file, options.debug).parse
+      parser = Lrama::Parser.new(text, options.grammar_file, options.debug)
+      begin
+        grammar = parser.parse
+      rescue => e
+        raise e if options.debug
+        message = e.message
+        message = message.gsub(/.+/, "\e[1m\\&\e[m") if Exception.to_tty?
+        abort message
+      end
       states = Lrama::States.new(grammar, warning, trace_state: (options.trace_opts[:automaton] || options.trace_opts[:closure]))
       states.compute
       context = Lrama::Context.new(states)
@@ -39,7 +53,7 @@ module Lrama
       end
 
       if warning.has_error?
-        exit 1
+        exit false
       end
     end
   end
diff --git a/tool/lrama/lib/lrama/context.rb b/tool/lrama/lib/lrama/context.rb
index 895290a2bb..245c91a199 100644
--- a/tool/lrama/lib/lrama/context.rb
+++ b/tool/lrama/lib/lrama/context.rb
@@ -9,7 +9,7 @@ module Lrama
     BaseMin = -Float::INFINITY
 
     # TODO: It might be better to pass `states` to Output directly?
-    attr_reader :states
+    attr_reader :states, :yylast, :yypact_ninf, :yytable_ninf, :yydefact, :yydefgoto
 
     def initialize(states)
       @states = states
@@ -41,15 +41,11 @@ module Lrama
     def yyfinal
       @states.states.find do |state|
         state.items.find do |item|
-          item.rule.lhs.id.s_value == "$accept" && item.end_of_rule?
+          item.rule.lhs.accept_symbol? && item.end_of_rule?
         end
       end.id
     end
 
-    def yylast
-      @yylast
-    end
-
     # Number of terms
     def yyntokens
       @states.terms.count
@@ -119,30 +115,14 @@ module Lrama
       end
     end
 
-    def yypact_ninf
-      @yypact_ninf
-    end
-
-    def yytable_ninf
-      @yytable_ninf
-    end
-
     def yypact
       @base[0...yynstates]
     end
 
-    def yydefact
-      @yydefact
-    end
-
     def yypgoto
       @base[yynstates..-1]
     end
 
-    def yydefgoto
-      @yydefgoto
-    end
-
     def yytable
       @table
     end
diff --git a/tool/lrama/lib/lrama/grammar.rb b/tool/lrama/lib/lrama/grammar.rb
index 8fed581f6b..9c500b381d 100644
--- a/tool/lrama/lib/lrama/grammar.rb
+++ b/tool/lrama/lib/lrama/grammar.rb
@@ -1,4 +1,5 @@
 require "lrama/grammar/auxiliary"
+require "lrama/grammar/binding"
 require "lrama/grammar/code"
 require "lrama/grammar/counter"
 require "lrama/grammar/error_token"
@@ -8,9 +9,6 @@ require "lrama/grammar/printer"
 require "lrama/grammar/reference"
 require "lrama/grammar/rule"
 require "lrama/grammar/rule_builder"
-require "lrama/grammar/parameterizing_rule_builder"
-require "lrama/grammar/parameterizing_rule_resolver"
-require "lrama/grammar/parameterizing_rule_rhs_builder"
 require "lrama/grammar/parameterizing_rule"
 require "lrama/grammar/symbol"
 require "lrama/grammar/type"
@@ -40,7 +38,7 @@ module Lrama
       @rule_builders = []
       @rules = []
       @sym_to_rules = {}
-      @parameterizing_resolver = ParameterizingRuleResolver.new
+      @parameterizing_rule_resolver = ParameterizingRule::Resolver.new
       @empty_symbol = nil
       @eof_symbol = nil
       @error_symbol = nil
@@ -52,7 +50,7 @@ module Lrama
     end
 
     def add_percent_code(id:, code:)
-      @percent_codes << PercentCode.new(id, code)
+      @percent_codes << PercentCode.new(id.s_value, code.s_value)
     end
 
     def add_printer(ident_or_tags:, token_code:, lineno:)
@@ -134,8 +132,8 @@ module Lrama
       @rule_builders << builder
     end
 
-    def add_parameterizing_rule_builder(builder)
-      @parameterizing_resolver.add_parameterizing_rule_builder(builder)
+    def add_parameterizing_rule(rule)
+      @parameterizing_rule_resolver.add_parameterizing_rule(rule)
     end
 
     def prologue_first_lineno=(prologue_first_lineno)
@@ -171,7 +169,7 @@ module Lrama
 
     # TODO: More validation methods
     #
-    # * Validaiton for no_declared_type_reference
+    # * Validation for no_declared_type_reference
     def validate!
       validate_symbol_number_uniqueness!
       validate_symbol_alias_name_uniqueness!
@@ -319,7 +317,7 @@ module Lrama
 
     def setup_rules
       @rule_builders.each do |builder|
-        builder.setup_rules(@parameterizing_resolver)
+        builder.setup_rules(@parameterizing_rule_resolver)
       end
     end
 
diff --git a/tool/lrama/lib/lrama/grammar/binding.rb b/tool/lrama/lib/lrama/grammar/binding.rb
new file mode 100644
index 0000000000..e5ea3fb037
--- /dev/null
+++ b/tool/lrama/lib/lrama/grammar/binding.rb
@@ -0,0 +1,24 @@
+module Lrama
+  class Grammar
+    class Binding
+      attr_reader :actual_args, :count
+
+      def initialize(parameterizing_rule, actual_args)
+        @parameters = parameterizing_rule.parameters
+        @actual_args = actual_args
+        @parameter_to_arg = @parameters.zip(actual_args).map do |param, arg|
+          [param.s_value, arg]
+        end.to_h
+      end
+
+      def resolve_symbol(symbol)
+        if symbol.is_a?(Lexer::Token::InstantiateRule)
+          resolved_args = symbol.args.map { |arg| resolve_symbol(arg) }
+          Lrama::Lexer::Token::InstantiateRule.new(s_value: symbol.s_value, location: symbol.location, args: resolved_args, lhs_tag: symbol.lhs_tag)
+        else
+          @parameter_to_arg[symbol.s_value] || symbol
+        end
+      end
+    end
+  end
+end
diff --git a/tool/lrama/lib/lrama/grammar/code/rule_action.rb b/tool/lrama/lib/lrama/grammar/code/rule_action.rb
index 8a67b732e6..76169b91ed 100644
--- a/tool/lrama/lib/lrama/grammar/code/rule_action.rb
+++ b/tool/lrama/lib/lrama/grammar/code/rule_action.rb
@@ -22,7 +22,7 @@ module Lrama
         # 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                             $6
+        # "Position in grammar"                   $1     $2      $3          $4          $5
         # "Index for yyvsp"                       -4     -3      -2          -1           0
         #
         #
diff --git a/tool/lrama/lib/lrama/grammar/parameterizing_rule.rb b/tool/lrama/lib/lrama/grammar/parameterizing_rule.rb
index aa8865d53d..d371805f4b 100644
--- a/tool/lrama/lib/lrama/grammar/parameterizing_rule.rb
+++ b/tool/lrama/lib/lrama/grammar/parameterizing_rule.rb
@@ -1,6 +1,3 @@
-module Lrama
-  class Grammar
-    class ParameterizingRule < Struct.new(:rules, :token, keyword_init: true)
-    end
-  end
-end
+require_relative 'parameterizing_rule/resolver'
+require_relative 'parameterizing_rule/rhs'
+require_relative 'parameterizing_rule/rule'
diff --git a/tool/lrama/lib/lrama/grammar/parameterizing_rule/resolver.rb b/tool/lrama/lib/lrama/grammar/parameterizing_rule/resolver.rb
new file mode 100644
index 0000000000..f5de9d0bf3
--- /dev/null
+++ b/tool/lrama/lib/lrama/grammar/parameterizing_rule/resolver.rb
@@ -0,0 +1,39 @@
+module Lrama
+  class Grammar
+    class ParameterizingRule
+      class Resolver
+        attr_accessor :created_lhs_list
+
+        def initialize
+          @rules = []
+          @created_lhs_list = []
+        end
+
+        def add_parameterizing_rule(rule)
+          @rules << rule
+        end
+
+        def defined?(token)
+          !select_rules(token).empty?
+        end
+
+        def find(token)
+          select_rules(token).last
+        end
+
+        def created_lhs(lhs_s_value)
+          @created_lhs_list.select { |created_lhs| created_lhs.s_value == lhs_s_value }.last
+        end
+
+        private
+
+        def select_rules(token)
+          @rules.select do |rule|
+            rule.name == token.rule_name &&
+              rule.required_parameters_count == token.args_count
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/tool/lrama/lib/lrama/grammar/parameterizing_rule/rhs.rb b/tool/lrama/lib/lrama/grammar/parameterizing_rule/rhs.rb
new file mode 100644
index 0000000000..7f50be873c
--- /dev/null
+++ b/tool/lrama/lib/lrama/grammar/parameterizing_rule/rhs.rb
@@ -0,0 +1,15 @@
+module Lrama
+  class Grammar
+    class ParameterizingRule
+      class Rhs
+        attr_accessor :symbols, :user_code, :precedence_sym
+
+        def initialize
+          @symbols = []
+          @user_code = nil
+          @precedence_sym = nil
+        end
+      end
+    end
+  end
+end
diff --git a/tool/lrama/lib/lrama/grammar/parameterizing_rule/rule.rb b/tool/lrama/lib/lrama/grammar/parameterizing_rule/rule.rb
new file mode 100644
index 0000000000..9c1d46e4f5
--- /dev/null
+++ b/tool/lrama/lib/lrama/grammar/parameterizing_rule/rule.rb
@@ -0,0 +1,16 @@
+module Lrama
+  class Grammar
+    class ParameterizingRule
+      class Rule
+        attr_reader :name, :parameters, :rhs_list, :required_parameters_count
+
+        def initialize(name, parameters, rhs_list)
+          @name = name
+          @parameters = parameters
+          @rhs_list = rhs_list
+          @required_parameters_count = parameters.count
+        end
+      end
+    end
+  end
+end
diff --git a/tool/lrama/lib/lrama/grammar/parameterizing_rule_builder.rb b/tool/lrama/lib/lrama/grammar/parameterizing_rule_builder.rb
deleted file mode 100644
index 94566a80e1..0000000000
--- a/tool/lrama/lib/lrama/grammar/parameterizing_rule_builder.rb
+++ /dev/null
@@ -1,34 +0,0 @@
-module Lrama
-  class Grammar
-    class ParameterizingRuleBuilder
-      attr_reader :name, :parameters, :rhs
-
-      def initialize(name, parameters, rhs)
-        @name = name
-        @parameters = parameters
-        @rhs = rhs
-        @required_parameters_count = parameters.count
-      end
-
-      def build_rules(token, actual_args, rule_counter, lhs_tag, line, rule_builders)
-        validate_argument_number!(token)
-        lhs = lhs(actual_args)
-        @rhs.map do |rhs|
-          rhs.build_rules(token, actual_args, parameters, rule_counter, lhs, lhs_tag, line, rule_builders)
-        end.flatten
-      end
-
-      private
-
-      def validate_argument_number!(token)
-        unless @required_parameters_count == token.args.count
-          raise "Invalid number of arguments. expect: #{@required_parameters_count} actual: #{token.args.count}"
-        end
-      end
-
-      def lhs(actual_args)
-        Lrama::Lexer::Token::Ident.new(s_value: "#{name}_#{actual_args.map(&:s_value).join('_')}")
-      end
-    end
-  end
-end
diff --git a/tool/lrama/lib/lrama/grammar/parameterizing_rule_resolver.rb b/tool/lrama/lib/lrama/grammar/parameterizing_rule_resolver.rb
deleted file mode 100644
index 9d92a412ef..0000000000
--- a/tool/lrama/lib/lrama/grammar/parameterizing_rule_resolver.rb
+++ /dev/null
@@ -1,30 +0,0 @@
-module Lrama
-  class Grammar
-    class ParameterizingRuleResolver
-      def initialize
-        @parameterizing_rule_builders = []
-      end
-
-      def add_parameterizing_rule_builder(builder)
-        @parameterizing_rule_builders << builder
-      end
-
-      def defined?(name)
-        !rule_builders(name).empty?
-      end
-
-      def build_rules(token, rule_counter, lhs_tag, line)
-        builder = rule_builders(token.s_value).last
-        raise "Unknown parameterizing rule #{token.s_value} at line #{token.line}" unless builder
-
-        builder.build_rules(token, token.args, rule_counter, lhs_tag, line, @parameterizing_rule_builders)
-      end
-
-      private
-
-      def rule_builders(name)
-        @parameterizing_rule_builders.select { |builder| builder.name == name }
-      end
-    end
-  end
-end
diff --git a/tool/lrama/lib/lrama/grammar/parameterizing_rule_rhs_builder.rb b/tool/lrama/lib/lrama/grammar/parameterizing_rule_rhs_builder.rb
deleted file mode 100644
index 9d15fb1880..0000000000
--- a/tool/lrama/lib/lrama/grammar/parameterizing_rule_rhs_builder.rb
+++ /dev/null
@@ -1,53 +0,0 @@
-module Lrama
-  class Grammar
-    class ParameterizingRuleRhsBuilder
-      attr_accessor :symbols, :user_code, :precedence_sym
-
-      def initialize
-        @symbols = []
-        @user_code = nil
-        @precedence_sym = nil
-      end
-
-      def build_rules(token, actual_args, parameters, rule_counter, lhs, lhs_tag, line, rule_builders)
-        nested_rules = build_nested_rules(token, actual_args, parameters, rule_counter, lhs_tag, line, rule_builders)
-        rule = Rule.new(id: rule_counter.increment, _lhs: lhs, _rhs: rhs(token, actual_args, parameters, nested_rules.last), lhs_tag: lhs_tag, token_code: user_code, precedence_sym: precedence_sym, lineno: line)
-        ParameterizingRule.new(rules: nested_rules.map(&:rules) + [rule], token: lhs)
-      end
-
-      private
-
-      def build_nested_rules(token, actual_args, parameters, rule_counter, lhs_tag, line, rule_builders)
-        symbols.each_with_index.map do |sym, i|
-          next unless sym.is_a?(Lexer::Token::InstantiateRule)
-
-          builder = rule_builders.select { |builder| builder.name == sym.s_value }.last
-          raise "Unknown parameterizing rule #{token.s_value} at line #{token.line}" unless builder
-
-          builder.build_rules(sym, nested_actual_args(actual_args, parameters, i), rule_counter, lhs_tag, line, rule_builders)
-        end.flatten.compact
-      end
-
-      def nested_actual_args(actual_args, parameters, idx)
-        symbols[idx].args.map do |arg|
-          i = parameters.index { |parameter| parameter.s_value == arg.s_value }
-          i.nil? ? arg : actual_args[i]
-        end
-      end
-
-      def rhs(token, actual_args, parameters, nested_rule)
-        symbols.map do |sym|
-          if sym.is_a?(Lexer::Token::InstantiateRule)
-            sym.args.map do |arg|
-              idx = parameters.index { |parameter| parameter.s_value == arg.s_value }
-              idx.nil? ? sym : nested_rule&.token
-            end
-          else
-            idx = parameters.index { |parameter| parameter.s_value == sym.s_value }
-            idx.nil? ? sym : actual_args[idx]
-          end
-        end.flatten
-      end
-    end
-  end
-end
diff --git a/tool/lrama/lib/lrama/grammar/percent_code.rb b/tool/lrama/lib/lrama/grammar/percent_code.rb
index 5faa3a582b..8cbc5aef2c 100644
--- a/tool/lrama/lib/lrama/grammar/percent_code.rb
+++ b/tool/lrama/lib/lrama/grammar/percent_code.rb
@@ -1,10 +1,10 @@
 module Lrama
   class Grammar
     class PercentCode
-      attr_reader :id, :code
+      attr_reader :name, :code
 
-      def initialize(id, code)
-        @id = id
+      def initialize(name, code)
+        @name = name
         @code = code
       end
     end
diff --git a/tool/lrama/lib/lrama/grammar/rule_builder.rb b/tool/lrama/lib/lrama/grammar/rule_builder.rb
index c17a4048d8..757554f46d 100644
--- a/tool/lrama/lib/lrama/grammar/rule_builder.rb
+++ b/tool/lrama/lib/lrama/grammar/rule_builder.rb
@@ -3,21 +3,22 @@ require 'lrama/grammar/parameterizing_rules/builder'
 module Lrama
   class Grammar
     class RuleBuilder
-      attr_accessor :lhs, :lhs_tag, :line
-      attr_reader :rhs, :user_code, :precedence_sym
+      attr_accessor :lhs, :line
+      attr_reader :lhs_tag, :rhs, :user_code, :precedence_sym
 
-      def initialize(rule_counter, midrule_action_counter, position_in_original_rule_rhs = nil, skip_preprocess_references: false)
+      def initialize(rule_counter, midrule_action_counter, position_in_original_rule_rhs = nil, lhs_tag: nil, skip_preprocess_references: false)
         @rule_counter = rule_counter
         @midrule_action_counter = midrule_action_counter
         @position_in_original_rule_rhs = position_in_original_rule_rhs
         @skip_preprocess_references = skip_preprocess_references
 
         @lhs = nil
+        @lhs_tag = lhs_tag
         @rhs = []
-        @lhs_tag = nil
         @user_code = nil
         @precedence_sym = nil
         @line = nil
+        @rule_builders_for_parameterizing_rules = []
         @rule_builders_for_derived_rules = []
       end
 
@@ -33,7 +34,7 @@ module Lrama
 
       def user_code=(user_code)
         if !@line
-          @line = user_code.line
+          @line = user_code&.line
         end
 
         flush_user_code
@@ -51,14 +52,14 @@ module Lrama
         freeze_rhs
       end
 
-      def setup_rules(parameterizing_resolver)
+      def setup_rules(parameterizing_rule_resolver)
         preprocess_references unless @skip_preprocess_references
-        process_rhs(parameterizing_resolver)
+        process_rhs(parameterizing_rule_resolver)
         build_rules
       end
 
       def rules
-        @parameterizing_rules + @midrule_action_rules + @rules
+        @parameterizing_rules + @old_parameterizing_rules + @midrule_action_rules + @rules
       end
 
       private
@@ -75,10 +76,13 @@ module Lrama
         tokens = @replaced_rhs
 
         rule = Rule.new(
-          id: @rule_counter.increment, _lhs: lhs, _rhs: tokens, token_code: user_code,
+          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|
+          rule_builder.rules
+        end.flatten
         @midrule_action_rules = @rule_builders_for_derived_rules.map do |rule_builder|
           rule_builder.rules
         end.flatten
@@ -89,11 +93,11 @@ 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`.
-      def process_rhs(parameterizing_resolver)
+      def process_rhs(parameterizing_rule_resolver)
         return if @replaced_rhs
 
         @replaced_rhs = []
-        @parameterizing_rules = []
+        @old_parameterizing_rules = []
 
         rhs.each_with_index do |token, i|
           case token
@@ -102,26 +106,46 @@ module Lrama
           when Lrama::Lexer::Token::Ident
             @replaced_rhs << token
           when Lrama::Lexer::Token::InstantiateRule
-            if parameterizing_resolver.defined?(token.rule_name)
-              parameterizing = parameterizing_resolver.build_rules(token, @rule_counter, @lhs_tag, line)
-              @parameterizing_rules = @parameterizing_rules + parameterizing.map(&:rules).flatten
-              @replaced_rhs = @replaced_rhs + parameterizing.map(&:token).flatten.uniq
+            if parameterizing_rule_resolver.defined?(token)
+              parameterizing_rule = parameterizing_rule_resolver.find(token)
+              raise "Unexpected token. #{token}" unless parameterizing_rule
+
+              bindings = Binding.new(parameterizing_rule, token.args)
+              lhs_s_value = lhs_s_value(token, bindings)
+              if (created_lhs = parameterizing_rule_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, i, lhs_tag: token.lhs_tag, skip_preprocess_references: true)
+                  rule_builder.lhs = lhs_token
+                  r.symbols.each { |sym| rule_builder.add_rhs(bindings.resolve_symbol(sym)) }
+                  rule_builder.line = line
+                  rule_builder.user_code = r.user_code
+                  rule_builder.precedence_sym = r.precedence_sym
+                  rule_builder.complete_input
+                  rule_builder.setup_rules(parameterizing_rule_resolver)
+                  @rule_builders_for_parameterizing_rules << rule_builder
+                end
+              end
             else
               # TODO: Delete when the standard library will defined as a grammar file.
-              parameterizing = ParameterizingRules::Builder.new(token, @rule_counter, @lhs_tag, user_code, precedence_sym, line)
-              @parameterizing_rules = @parameterizing_rules + parameterizing.build
-              @replaced_rhs << parameterizing.build_token
+              parameterizing_rule = ParameterizingRules::Builder.new(token, @rule_counter, token.lhs_tag, user_code, precedence_sym, line)
+              @old_parameterizing_rules = @old_parameterizing_rules + parameterizing_rule.build
+              @replaced_rhs << parameterizing_rule.build_token
             end
           when Lrama::Lexer::Token::UserCode
             prefix = token.referred ? "@" : "$@"
             new_token = Lrama::Lexer::Token::Ident.new(s_value: prefix + @midrule_action_counter.increment.to_s)
             @replaced_rhs << new_token
 
-            rule_builder = RuleBuilder.new(@rule_counter, @midrule_action_counter, i, skip_preprocess_references: true)
+            rule_builder = RuleBuilder.new(@rule_counter, @midrule_action_counter, i, lhs_tag: lhs_tag, skip_preprocess_references: true)
             rule_builder.lhs = new_token
             rule_builder.user_code = token
             rule_builder.complete_input
-            rule_builder.setup_rules(parameterizing_resolver)
+            rule_builder.setup_rules(parameterizing_rule_resolver)
 
             @rule_builders_for_derived_rules << rule_builder
           else
@@ -130,6 +154,18 @@ module Lrama
         end
       end
 
+      def lhs_s_value(token, bindings)
+        s_values = token.args.map do |arg|
+          resolved = bindings.resolve_symbol(arg)
+          if resolved.is_a?(Lexer::Token::InstantiateRule)
+            [resolved.s_value, resolved.args.map(&:s_value)]
+          else
+            resolved.s_value
+          end
+        end
+        "#{token.rule_name}_#{s_values.join('_')}"
+      end
+
       def numberize_references
         # Bison n'th component is 1-origin
         (rhs + [user_code]).compact.each.with_index(1) do |token, i|
@@ -144,13 +180,11 @@ module Lrama
                 candidates = rhs.each_with_index.select {|token, i| token.referred_by?(ref_name) }
 
                 if candidates.size >= 2
-                  location = token.location.partial_location(ref.first_column, ref.last_column)
-                  raise location.generate_error_message("Referring symbol `#{ref_name}` is duplicated.")
+                  token.invalid_ref(ref, "Referring symbol `#{ref_name}` is duplicated.")
                 end
 
                 unless (referring_symbol = candidates.first)
-                  location = token.location.partial_location(ref.first_column, ref.last_column)
-                  raise location.generate_error_message("Referring symbol `#{ref_name}` is not found.")
+                  token.invalid_ref(ref, "Referring symbol `#{ref_name}` is not found.")
                 end
 
                 ref.index = referring_symbol[1] + 1
@@ -163,7 +197,7 @@ module Lrama
             if ref.index
               # TODO: Prohibit $0 even so Bison allows it?
               # See: https://www.gnu.org/software/bison/manual/html_node/Actions.html
-              raise "Can not refer following component. #{ref.index} >= #{i}. #{token}" if ref.index >= i
+              token.invalid_ref(ref, "Can not refer following component. #{ref.index} >= #{i}.") if ref.index >= i
               rhs[ref.index - 1].referred = true
             end
           end
diff --git a/tool/lrama/lib/lrama/grammar/type.rb b/tool/lrama/lib/lrama/grammar/type.rb
index 6861d9f846..6b4b0961a1 100644
--- a/tool/lrama/lib/lrama/grammar/type.rb
+++ b/tool/lrama/lib/lrama/grammar/type.rb
@@ -1,6 +1,18 @@
 module Lrama
   class Grammar
-    class Type < Struct.new(:id, :tag, keyword_init: true)
+    class Type
+      attr_reader :id, :tag
+
+      def initialize(id:, tag:)
+        @id = id
+        @tag = tag
+      end
+
+      def ==(other)
+        self.class == other.class &&
+        self.id == other.id &&
+        self.tag == other.tag
+      end
     end
   end
 end
diff --git a/tool/lrama/lib/lrama/lexer.rb b/tool/lrama/lib/lrama/lexer.rb
index 4f394a9815..746d50cee5 100644
--- a/tool/lrama/lib/lrama/lexer.rb
+++ b/tool/lrama/lib/lrama/lexer.rb
@@ -5,9 +5,8 @@ require "lrama/lexer/token"
 
 module Lrama
   class Lexer
-    attr_reader :head_line, :head_column
-    attr_accessor :status
-    attr_accessor :end_symbol
+    attr_reader :head_line, :head_column, :line
+    attr_accessor :status, :end_symbol
 
     SYMBOLS = ['%{', '%}', '%%', '{', '}', '\[', '\]', '\(', '\)', '\,', ':', '\|', ';']
     PERCENT_TOKENS = %w(
@@ -50,10 +49,6 @@ module Lrama
       end
     end
 
-    def line
-      @line
-    end
-
     def column
       @scanner.pos - @head
     end
diff --git a/tool/lrama/lib/lrama/lexer/grammar_file.rb b/tool/lrama/lib/lrama/lexer/grammar_file.rb
index 2200bcbf28..6be0767004 100644
--- a/tool/lrama/lib/lrama/lexer/grammar_file.rb
+++ b/tool/lrama/lib/lrama/lexer/grammar_file.rb
@@ -5,7 +5,7 @@ module Lrama
 
       def initialize(path, text)
         @path = path
-        @text = text
+        @text = text.freeze
       end
 
       def ==(other)
diff --git a/tool/lrama/lib/lrama/lexer/token.rb b/tool/lrama/lib/lrama/lexer/token.rb
index 22b798376a..5278e98725 100644
--- a/tool/lrama/lib/lrama/lexer/token.rb
+++ b/tool/lrama/lib/lrama/lexer/token.rb
@@ -46,6 +46,11 @@ module Lrama
       def last_column
         location.last_column
       end
+
+      def invalid_ref(ref, message)
+        location = self.location.partial_location(ref.first_column, ref.last_column)
+        raise location.generate_error_message(message)
+      end
     end
   end
 end
diff --git a/tool/lrama/lib/lrama/lexer/token/instantiate_rule.rb b/tool/lrama/lib/lrama/lexer/token/instantiate_rule.rb
index 9b703dd9d2..1c4d1095c8 100644
--- a/tool/lrama/lib/lrama/lexer/token/instantiate_rule.rb
+++ b/tool/lrama/lib/lrama/lexer/token/instantiate_rule.rb
@@ -2,16 +2,21 @@ module Lrama
   class Lexer
     class Token
       class InstantiateRule < Token
-        attr_accessor :args
+        attr_reader :args, :lhs_tag
 
-        def initialize(s_value:, alias_name: nil, location: nil, args: [])
+        def initialize(s_value:, alias_name: nil, location: nil, args: [], lhs_tag: nil)
           super s_value: s_value, alias_name: alias_name, location: location
           @args = args
+          @lhs_tag = lhs_tag
         end
 
         def rule_name
           s_value
         end
+
+        def args_count
+          args.count
+        end
       end
     end
   end
diff --git a/tool/lrama/lib/lrama/output.rb b/tool/lrama/lib/lrama/output.rb
index f672085097..936a3de8d1 100644
--- a/tool/lrama/lib/lrama/output.rb
+++ b/tool/lrama/lib/lrama/output.rb
@@ -352,9 +352,9 @@ module Lrama
     # b4_percent_code_get
     def percent_code(name)
       @grammar.percent_codes.select do |percent_code|
-        percent_code.id.s_value == name
+        percent_code.name == name
       end.map do |percent_code|
-        percent_code.code.s_value
+        percent_code.code
       end.join
     end
 
diff --git a/tool/lrama/lib/lrama/parser.rb b/tool/lrama/lib/lrama/parser.rb
index 797851e881..9434b18cc5 100644
--- a/tool/lrama/lib/lrama/parser.rb
+++ b/tool/lrama/lib/lrama/parser.rb
@@ -734,11 +734,11 @@ end
 ##### State transition tables begin ###
 
 racc_action_table = [
-    85,    44,    86,   145,   144,    67,    44,    44,   145,   187,
-    67,    67,    44,     6,   187,     7,    67,   147,   196,    44,
-   143,    43,   147,   188,    58,   163,   164,   165,   188,     3,
+    85,    44,    86,   145,   144,    67,    44,    44,   145,   188,
+    67,    67,    44,     6,   188,     7,    67,   147,   199,    44,
+   143,    43,   147,   189,    58,   163,   164,   165,   189,     3,
     44,    40,    43,     8,    67,    63,    34,    44,   148,    43,
-    41,    87,    40,   148,   189,    47,    44,    80,    43,   189,
+    41,    87,    40,   148,   190,    47,    44,    80,    43,   190,
     21,    23,    24,    25,    26,    27,    28,    29,    30,    31,
     47,    21,    23,    24,    25,    26,    27,    28,    29,    30,
     31,     9,    44,    47,    43,    13,    14,    15,    16,    17,
@@ -750,22 +750,23 @@ racc_action_table = [
     43,    43,    67,   173,    44,    44,    43,    43,    67,   173,
     44,    44,    43,    43,    67,   173,    44,    44,    43,    43,
     67,    67,    44,    44,    43,    43,    67,    67,    44,    44,
-    43,    43,    67,    67,    44,    44,    43,    43,    67,    67,
-    44,    44,    43,    43,    67,    67,   163,   164,   165,    83,
-    44,    44,    43,    43,   141,   190,   142,   191,   205,    54,
-   191,    55,    76,    77,    81,    83,    88,    88,    88,    90,
-    96,   100,   101,   104,   104,   104,   104,   107,   110,   111,
-   113,   115,   116,   117,   118,   119,   122,   126,   127,   128,
-   131,   132,   133,   135,   150,   152,   153,   154,   155,   156,
-   157,   158,   131,   160,   168,   169,   178,   182,   183,   185,
-   178,    83,   182,   201,   203,    83,   207,    83 ]
+    43,    43,    67,    67,    44,    44,   179,    43,    67,    67,
+    44,    44,   179,    43,    67,    67,    44,    44,   179,    43,
+    67,   163,   164,   165,    83,    44,   141,    43,   142,   192,
+    54,   193,   163,   164,   165,   208,   210,   193,   193,    55,
+    76,    77,    81,    83,    88,    88,    88,    90,    96,   100,
+   101,   104,   104,   104,   104,   107,   110,   111,   113,   115,
+   116,   117,   118,   119,   122,   126,   127,   128,   131,   132,
+   133,   135,   150,   152,   153,   154,   155,   156,   157,   158,
+   131,   160,   168,   169,   178,   183,   184,   186,   191,   178,
+    83,   183,   205,   207,    83,   212,    83 ]
 
 racc_action_check = [
     42,   130,    42,   130,   129,   130,   159,   177,   159,   177,
-   159,   177,   193,     2,   193,     2,   193,   130,   187,    26,
-   129,    26,   159,   177,    26,   187,   187,   187,   193,     1,
+   159,   177,   196,     2,   196,     2,   196,   130,   188,    26,
+   129,    26,   159,   177,    26,   188,   188,   188,   196,     1,
     27,     9,    27,     3,    27,    27,     7,    14,   130,    14,
-    13,    42,    35,   159,   177,    15,    57,    35,    57,   193,
+    13,    42,    35,   159,   177,    15,    57,    35,    57,   196,
      9,     9,     9,     9,     9,     9,     9,     9,     9,     9,
     16,    35,    35,    35,    35,    35,    35,    35,    35,    35,
     35,     4,    58,    17,    58,     4,     4,     4,     4,     4,
@@ -777,110 +778,113 @@ racc_action_check = [
    170,    98,   170,   170,   174,   104,   174,   104,   174,   174,
    175,   106,   175,   106,   175,   175,    62,    63,    62,    63,
     62,    63,   101,   103,   101,   103,   101,   103,   123,   148,
-   123,   148,   123,   148,   160,   189,   160,   189,   160,   189,
-   191,   196,   191,   196,   191,   196,   146,   146,   146,   146,
-   120,   124,   120,   124,   125,   179,   125,   179,   202,    24,
-   202,    25,    32,    33,    38,    39,    46,    48,    49,    50,
-    56,    60,    61,    68,    73,    74,    75,    76,    82,    83,
-    89,    91,    92,    93,    94,    95,    99,   107,   108,   109,
-   110,   111,   112,   114,   134,   136,   137,   138,   139,   140,
-   141,   142,   143,   145,   149,   151,   157,   162,   166,   176,
-   185,   186,   190,   192,   197,   201,   206,   207 ]
+   123,   148,   123,   148,   160,   190,   160,   190,   160,   190,
+   191,   193,   191,   193,   191,   193,   199,   120,   199,   120,
+   199,   146,   146,   146,   146,   124,   125,   124,   125,   180,
+    24,   180,   181,   181,   181,   202,   206,   202,   206,    25,
+    32,    33,    38,    39,    46,    48,    49,    50,    56,    60,
+    61,    68,    73,    74,    75,    76,    82,    83,    89,    91,
+    92,    93,    94,    95,    99,   107,   108,   109,   110,   111,
+   112,   114,   134,   136,   137,   138,   139,   140,   141,   142,
+   143,   145,   149,   151,   157,   162,   166,   176,   179,   186,
+   187,   192,   195,   200,   205,   211,   212 ]
 
 racc_action_pointer = [
    nil,    29,     3,    33,    62,   nil,   nil,    29,   nil,    27,
    nil,   nil,   nil,    34,    34,    26,    41,    54,    76,    63,
-   nil,    81,   nil,    88,   170,   172,    16,    27,    93,    94,
-   100,   101,   187,   191,   nil,    38,   nil,   nil,   172,   151,
-   nil,   nil,    -5,   nil,   nil,   nil,   177,   nil,   178,   179,
-   180,   nil,   nil,   nil,   nil,   nil,   192,    43,    69,   nil,
-   195,   194,   143,   144,   nil,   nil,   nil,   nil,   195,   108,
-   114,   nil,   nil,   196,   197,   198,   173,   nil,   nil,   nil,
-   nil,   nil,   172,   204,   nil,   nil,   nil,   nil,   nil,   208,
-   nil,   209,   210,   211,   212,   213,   120,   nil,   126,   209,
-   nil,   149,   nil,   150,   132,   nil,   138,   212,   207,   217,
-   181,   176,   220,   nil,   221,   nil,   nil,   nil,   nil,   nil,
-   177,   nil,   nil,   155,   178,   149,   nil,   nil,   nil,   -18,
-    -2,   nil,   nil,   nil,   204,   nil,   205,   206,   207,   208,
-   209,   194,   226,   193,   nil,   199,   135,   nil,   156,   214,
-   nil,   215,   nil,   nil,   107,   113,   119,   197,   nil,     3,
-   161,   nil,   229,   nil,   nil,   nil,   236,   nil,   nil,   nil,
-   125,   nil,   nil,   nil,   131,   137,   201,     4,   nil,   150,
-   nil,   nil,   nil,   nil,   nil,   201,   197,   -16,   nil,   162,
-   234,   167,   223,     9,   nil,   nil,   168,   242,   nil,   nil,
-   nil,   201,   153,   nil,   nil,   nil,   226,   203,   nil ]
+   nil,    81,   nil,    88,   171,   180,    16,    27,    93,    94,
+   100,   101,   195,   199,   nil,    38,   nil,   nil,   180,   159,
+   nil,   nil,    -5,   nil,   nil,   nil,   185,   nil,   186,   187,
+   188,   nil,   nil,   nil,   nil,   nil,   200,    43,    69,   nil,
+   203,   202,   143,   144,   nil,   nil,   nil,   nil,   203,   108,
+   114,   nil,   nil,   204,   205,   206,   181,   nil,   nil,   nil,
+   nil,   nil,   180,   212,   nil,   nil,   nil,   nil,   nil,   216,
+   nil,   217,   218,   219,   220,   221,   120,   nil,   126,   217,
+   nil,   149,   nil,   150,   132,   nil,   138,   220,   215,   225,
+   189,   184,   228,   nil,   229,   nil,   nil,   nil,   nil,   nil,
+   174,   nil,   nil,   155,   182,   151,   nil,   nil,   nil,   -18,
+    -2,   nil,   nil,   nil,   212,   nil,   213,   214,   215,   216,
+   217,   202,   234,   201,   nil,   207,   140,   nil,   156,   222,
+   nil,   223,   nil,   nil,   107,   113,   119,   205,   nil,     3,
+   161,   nil,   237,   nil,   nil,   nil,   244,   nil,   nil,   nil,
+   125,   nil,   nil,   nil,   131,   137,   209,     4,   nil,   214,
+   154,   151,   nil,   nil,   nil,   nil,   210,   206,   -16,   nil,
+   162,   167,   243,   168,   nil,   232,     9,   nil,   nil,   173,
+   251,   nil,   160,   nil,   nil,   210,   161,   nil,   nil,   nil,
+   nil,   235,   212,   nil ]
 
 racc_action_default = [
-    -2,  -128,    -8,  -128,  -128,    -3,    -4,  -128,   209,  -128,
-    -9,   -10,   -11,  -128,  -128,  -128,  -128,  -128,  -128,  -128,
-   -23,  -128,   -27,  -128,  -128,  -128,  -128,  -128,  -128,  -128,
-  -128,  -128,  -128,  -128,    -7,  -113,   -88,   -90,  -128,  -110,
-  -112,   -12,  -117,   -86,   -87,  -116,   -14,   -77,   -15,   -16,
-  -128,   -20,   -24,   -28,   -31,   -34,   -37,   -43,  -128,   -46,
-   -63,   -38,   -67,  -128,   -70,   -72,   -73,  -125,   -39,   -80,
-  -128,   -83,   -85,   -40,   -41,   -42,  -128,    -5,    -1,   -89,
-  -114,   -91,  -128,  -128,   -13,  -118,  -119,  -120,   -74,  -128,
-   -17,  -128,  -128,  -128,  -128,  -128,  -128,   -47,   -44,   -65,
-   -64,  -128,   -71,   -68,  -128,   -84,   -81,  -128,  -128,  -128,
-   -96,  -128,  -128,   -78,  -128,   -21,   -25,   -29,   -32,   -35,
-   -45,   -48,   -66,   -69,   -82,  -128,   -50,    -6,  -115,   -92,
-   -93,   -97,  -111,   -75,  -128,   -18,  -128,  -128,  -128,  -128,
-  -128,  -128,  -128,   -96,   -95,   -86,  -110,  -101,  -128,  -128,
-   -79,  -128,   -22,   -26,  -128,  -128,  -128,   -54,   -51,   -94,
-  -128,   -98,  -126,  -105,  -106,  -107,  -128,  -104,   -76,   -19,
-   -30,  -121,  -123,  -124,   -33,   -36,   -49,   -52,   -55,  -128,
-  -108,   -99,  -127,  -102,  -122,   -54,  -110,   -86,   -59,  -128,
-  -126,  -128,  -128,   -53,   -56,   -57,  -128,  -128,   -62,  -100,
-  -109,  -110,  -128,   -60,  -103,   -58,  -128,  -110,   -61 ]
+    -2,  -130,    -8,  -130,  -130,    -3,    -4,  -130,   214,  -130,
+    -9,   -10,   -11,  -130,  -130,  -130,  -130,  -130,  -130,  -130,
+   -23,  -130,   -27,  -130,  -130,  -130,  -130,  -130,  -130,  -130,
+  -130,  -130,  -130,  -130,    -7,  -115,   -88,   -90,  -130,  -112,
+  -114,   -12,  -119,   -86,   -87,  -118,   -14,   -77,   -15,   -16,
+  -130,   -20,   -24,   -28,   -31,   -34,   -37,   -43,  -130,   -46,
+   -63,   -38,   -67,  -130,   -70,   -72,   -73,  -127,   -39,   -80,
+  -130,   -83,   -85,   -40,   -41,   -42,  -130,    -5,    -1,   -89,
+  -116,   -91,  -130,  -130,   -13,  -120,  -121,  -122,   -74,  -130,
+   -17,  -130,  -130,  -130,  -130,  -130,  -130,   -47,   -44,   -65,
+   -64,  -130,   -71,   -68,  -130,   -84,   -81,  -130,  -130,  -130,
+   -96,  -130,  -130,   -78,  -130,   -21,   -25,   -29,   -32,   -35,
+   -45,   -48,   -66,   -69,   -82,  -130,   -50,    -6,  -117,   -92,
+   -93,   -97,  -113,   -75,  -130,   -18,  -130,  -130,  -130,  -130,
+  -130,  -130,  -130,   -96,   -95,   -86,  -112,  -101,  -130,  -130,
+   -79,  -130,   -22,   -26,  -130,  -130,  -130,   -54,   -51,   -94,
+  -130,   -98,  -128,  -105,  -106,  -107,  -130,  -104,   -76,   -19,
+   -30,  -123,  -125,  -126,   -33,   -36,   -49,   -52,   -55,   -86,
+  -130,  -108,   -99,  -129,  -102,  -124,   -54,  -112,   -86,   -59,
+  -130,  -130,  -128,  -130,  -110,  -130,   -53,   -56,   -57,  -130,
+  -130,   -62,  -130,  -100,  -109,  -112,  -130,   -60,  -111,  -103,
+   -58,  -130,  -112,   -61 ]
 
 racc_goto_table = [
-    64,    45,    57,    62,   105,    82,    97,   162,   106,   177,
-   179,     1,   181,    60,     2,    72,    72,    72,    72,   130,
-   184,     4,    35,    36,   184,   184,    68,    73,    74,    75,
-    46,    48,    49,    78,    98,   102,    64,   193,     5,   103,
-   199,   105,   124,    33,    60,    60,   202,    97,   195,    79,
-   108,    10,   159,   170,   174,   175,    72,    72,    11,   105,
-    12,    42,    84,   114,   151,    91,   136,    92,   137,    97,
-    93,   138,   120,    94,    64,   139,   102,   123,    95,   140,
-    56,    61,    99,    60,   121,    60,   125,   176,   197,   206,
-   112,    72,   149,    72,    89,   134,   102,   129,   166,   192,
-   109,   nil,   nil,   146,   nil,   nil,   nil,    60,   nil,   nil,
-   nil,    72,   161,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,   167,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,   146,   180,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   186,   nil,   194,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,   198,   nil,   200,   nil,   186,   204,   nil,   180,
-   nil,   nil,   nil,   208 ]
+    82,    62,    57,    45,    97,    64,   105,   162,   182,    36,
+   177,     1,     2,   180,   106,    60,     4,    72,    72,    72,
+    72,   130,   185,    46,    48,    49,   185,   185,    68,    73,
+    74,    75,    35,    78,    98,    79,     5,   103,   203,   196,
+   102,    64,   194,   105,   202,    97,    60,    60,   124,   198,
+    33,   108,   206,    10,   159,   170,   174,   175,    72,    72,
+    11,   105,    12,    42,    84,   114,   151,    97,    91,   136,
+    92,   137,   120,    93,   138,   123,    94,   139,    95,    64,
+   140,   102,    56,    61,    99,    60,   121,    60,   125,   176,
+   200,   211,   112,    72,   149,    72,    89,   134,   129,   166,
+   195,   102,   109,   nil,   nil,   nil,   nil,   161,   146,    60,
+   nil,   nil,   nil,    72,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   167,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   146,   181,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   197,   nil,
+   nil,   nil,   nil,   nil,   nil,   187,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   209,   nil,   201,   181,
+   nil,   204,   nil,   213,   187,   nil,   nil,   181 ]
 
 racc_goto_check = [
-    40,    34,    32,    46,    53,    41,    33,    42,    52,    39,
-    43,     1,    59,    34,     2,    34,    34,    34,    34,    58,
-    63,     3,     4,    54,    63,    63,    31,    31,    31,    31,
-    14,    14,    14,     5,    32,    40,    40,    39,     6,    46,
-    59,    53,    52,     7,    34,    34,    43,    33,    42,    54,
-     8,     9,    58,    20,    20,    20,    34,    34,    10,    53,
-    11,    12,    13,    15,    16,    17,    18,    21,    22,    33,
-    23,    24,    32,    25,    40,    26,    40,    46,    27,    28,
-    29,    30,    35,    34,    36,    34,    37,    38,    44,    45,
-    48,    34,    49,    34,    50,    51,    40,    57,    60,    61,
-    62,   nil,   nil,    40,   nil,   nil,   nil,    34,   nil,   nil,
-   nil,    34,    41,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,    40,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,    40,    40,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-    40,   nil,    41,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,    40,   nil,    40,   nil,    40,    41,   nil,    40,
-   nil,   nil,   nil,    41 ]
+    41,    46,    32,    34,    33,    40,    53,    42,    59,    54,
+    39,     1,     2,    43,    52,    34,     3,    34,    34,    34,
+    34,    58,    63,    14,    14,    14,    63,    63,    31,    31,
+    31,    31,     4,     5,    32,    54,     6,    46,    59,    39,
+    40,    40,    42,    53,    43,    33,    34,    34,    52,    42,
+     7,     8,    43,     9,    58,    20,    20,    20,    34,    34,
+    10,    53,    11,    12,    13,    15,    16,    33,    17,    18,
+    21,    22,    32,    23,    24,    46,    25,    26,    27,    40,
+    28,    40,    29,    30,    35,    34,    36,    34,    37,    38,
+    44,    45,    48,    34,    49,    34,    50,    51,    57,    60,
+    61,    40,    62,   nil,   nil,   nil,   nil,    41,    40,    34,
+   nil,   nil,   nil,    34,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,    40,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,    40,    40,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,    41,   nil,
+   nil,   nil,   nil,   nil,   nil,    40,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,    41,   nil,    40,    40,
+   nil,    40,   nil,    41,    40,   nil,   nil,    40 ]
 
 racc_goto_pointer = [
-   nil,    11,    14,    19,    13,    -2,    36,    37,   -27,    47,
-    54,    56,    47,    20,    15,   -27,   -71,    14,   -49,   nil,
-  -101,    15,   -48,    17,   -46,    19,   -43,    23,   -40,    54,
-    54,    -2,   -24,   -51,   -13,    22,   -15,   -21,   -70,  -148,
-   -27,   -34,  -139,  -150,  -100,  -114,   -24,   nil,     2,   -41,
-    47,   -18,   -62,   -65,    14,   nil,   nil,   -13,   -91,  -150,
-   -49,   -84,    20,  -150 ]
+   nil,    11,    12,    14,    23,    -2,    34,    44,   -26,    49,
+    56,    58,    49,    22,     8,   -25,   -69,    17,   -46,   nil,
+   -99,    18,   -45,    20,   -43,    22,   -41,    23,   -39,    56,
+    56,     0,   -24,   -53,   -11,    24,   -13,   -19,   -68,  -147,
+   -22,   -39,  -139,  -147,   -99,  -116,   -26,   nil,     4,   -39,
+    49,   -16,   -56,   -63,     0,   nil,   nil,   -12,   -89,  -154,
+   -48,   -84,    22,  -148 ]
 
 racc_goto_default = [
    nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
@@ -1002,28 +1006,30 @@ racc_reduce_table = [
   1, 89, :_reduce_none,
   1, 90, :_reduce_108,
   3, 90, :_reduce_109,
+  2, 90, :_reduce_110,
+  4, 90, :_reduce_111,
   0, 88, :_reduce_none,
-  3, 88, :_reduce_111,
+  3, 88, :_reduce_113,
   1, 103, :_reduce_none,
   0, 52, :_reduce_none,
-  0, 109, :_reduce_114,
-  3, 52, :_reduce_115,
+  0, 109, :_reduce_116,
+  3, 52, :_reduce_117,
   1, 59, :_reduce_none,
   0, 60, :_reduce_none,
   1, 60, :_reduce_none,
   1, 60, :_reduce_none,
   1, 60, :_reduce_none,
-  1, 67, :_reduce_121,
-  2, 67, :_reduce_122,
+  1, 67, :_reduce_123,
+  2, 67, :_reduce_124,
   1, 110, :_reduce_none,
   1, 110, :_reduce_none,
-  1, 94, :_reduce_125,
+  1, 94, :_reduce_127,
   0, 106, :_reduce_none,
   1, 106, :_reduce_none ]
 
-racc_reduce_n = 128
+racc_reduce_n = 130
 
-racc_shift_n = 209
+racc_shift_n = 214
 
 racc_token_table = {
   false => 0,
@@ -1568,8 +1574,8 @@ module_eval(<<'.,.,', 'parser.y', 203)
 
 module_eval(<<'.,.,', 'parser.y', 207)
   def _reduce_49(val, _values, result)
-                            builder = Grammar::ParameterizingRuleBuilder.new(val[1].s_value, val[3], val[6])
-                        @grammar.add_parameterizing_rule_builder(builder)
+                            rule = Grammar::ParameterizingRule::Rule.new(val[1].s_value, val[3], val[6])
+                        @grammar.add_parameterizing_rule(rule)
 
     result
   end
@@ -1610,7 +1616,7 @@ module_eval(<<'.,.,', 'parser.y', 221)
 module_eval(<<'.,.,', 'parser.y', 227)
   def _reduce_54(val, _values, result)
                   reset_precs
-              result = Grammar::ParameterizingRuleRhsBuilder.new
+              result = Grammar::ParameterizingRule::Rhs.new
 
     result
   end
@@ -1619,7 +1625,7 @@ module_eval(<<'.,.,', 'parser.y', 227)
 module_eval(<<'.,.,', 'parser.y', 232)
   def _reduce_55(val, _values, result)
                   reset_precs
-              result = Grammar::ParameterizingRuleRhsBuilder.new
+              result = Grammar::ParameterizingRule::Rhs.new
 
     result
   end
@@ -1933,10 +1939,9 @@ module_eval(<<'.,.,', 'parser.y', 402)
 
 module_eval(<<'.,.,', 'parser.y', 410)
   def _reduce_99(val, _values, result)
-               token = Lrama::Lexer::Token::InstantiateRule.new(s_value: val[2], location: @lexer.location, args: [val[1]])
+               token = Lrama::Lexer::Token::InstantiateRule.new(s_value: val[2], location: @lexer.location, args: [val[1]], lhs_tag: val[3])
            builder = val[0]
            builder.add_rhs(token)
-           builder.lhs_tag = val[3]
            builder.line = val[1].first_line
            result = builder
 
@@ -1944,12 +1949,11 @@ module_eval(<<'.,.,', 'parser.y', 410)
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 419)
+module_eval(<<'.,.,', 'parser.y', 418)
   def _reduce_100(val, _values, result)
-               token = Lrama::Lexer::Token::InstantiateRule.new(s_value: val[1].s_value, location: @lexer.location, args: val[3])
+               token = Lrama::Lexer::Token::InstantiateRule.new(s_value: val[1].s_value, location: @lexer.location, args: val[3], lhs_tag: val[5])
            builder = val[0]
            builder.add_rhs(token)
-           builder.lhs_tag = val[5]
            builder.line = val[1].first_line
            result = builder
 
@@ -1957,7 +1961,7 @@ module_eval(<<'.,.,', 'parser.y', 419)
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 428)
+module_eval(<<'.,.,', 'parser.y', 426)
   def _reduce_101(val, _values, result)
                if @prec_seen
              on_action_error("multiple User_code after %prec", val[0])  if @code_after_prec
@@ -1969,7 +1973,7 @@ module_eval(<<'.,.,', 'parser.y', 428)
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 436)
+module_eval(<<'.,.,', 'parser.y', 434)
   def _reduce_102(val, _values, result)
                end_c_declaration
 
@@ -1977,7 +1981,7 @@ module_eval(<<'.,.,', 'parser.y', 436)
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 440)
+module_eval(<<'.,.,', 'parser.y', 438)
   def _reduce_103(val, _values, result)
                user_code = val[3]
            user_code.alias_name = val[6]
@@ -1989,7 +1993,7 @@ module_eval(<<'.,.,', 'parser.y', 440)
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 448)
+module_eval(<<'.,.,', 'parser.y', 446)
   def _reduce_104(val, _values, result)
                sym = @grammar.find_symbol_by_id!(val[2])
            @prec_seen = true
@@ -2007,35 +2011,49 @@ module_eval(<<'.,.,', 'parser.y', 448)
 
 # reduce 107 omitted
 
-module_eval(<<'.,.,', 'parser.y', 459)
+module_eval(<<'.,.,', 'parser.y', 457)
   def _reduce_108(val, _values, result)
      result = [val[0]]
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 460)
+module_eval(<<'.,.,', 'parser.y', 458)
   def _reduce_109(val, _values, result)
      result = val[0].append(val[2])
     result
   end
 .,.,
 
-# reduce 110 omitted
+module_eval(<<'.,.,', 'parser.y', 459)
+  def _reduce_110(val, _values, result)
+     result = [Lrama::Lexer::Token::InstantiateRule.new(s_value: val[1].s_value, location: @lexer.location, args: val[0])]
+    result
+  end
+.,.,
 
-module_eval(<<'.,.,', 'parser.y', 463)
+module_eval(<<'.,.,', 'parser.y', 460)
   def _reduce_111(val, _values, result)
-     result = val[1].s_value
+     result = [Lrama::Lexer::Token::InstantiateRule.new(s_value: val[0].s_value, location: @lexer.location, args: val[2])]
     result
   end
 .,.,
 
 # reduce 112 omitted
 
-# reduce 113 omitted
+module_eval(<<'.,.,', 'parser.y', 463)
+  def _reduce_113(val, _values, result)
+     result = val[1].s_value
+    result
+  end
+.,.,
+
+# reduce 114 omitted
+
+# reduce 115 omitted
 
 module_eval(<<'.,.,', 'parser.y', 470)
-  def _reduce_114(val, _values, result)
+  def _reduce_116(val, _values, result)
                         begin_c_declaration('\Z')
                     @grammar.epilogue_first_lineno = @lexer.line + 1
 
@@ -2044,7 +2062,7 @@ module_eval(<<'.,.,', 'parser.y', 470)
 .,.,
 
 module_eval(<<'.,.,', 'parser.y', 475)
-  def _reduce_115(val, _values, result)
+  def _reduce_117(val, _values, result)
                         end_c_declaration
                     @grammar.epilogue = val[2].s_value
 
@@ -2052,44 +2070,44 @@ module_eval(<<'.,.,', 'parser.y', 475)
   end
 .,.,
 
-# reduce 116 omitted
-
-# reduce 117 omitted
-
 # reduce 118 omitted
 
 # reduce 119 omitted
 
 # reduce 120 omitted
 
+# reduce 121 omitted
+
+# reduce 122 omitted
+
 module_eval(<<'.,.,', 'parser.y', 486)
-  def _reduce_121(val, _values, result)
+  def _reduce_123(val, _values, result)
      result = [val[0]]
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'parser.y', 487)
-  def _reduce_122(val, _values, result)
+  def _reduce_124(val, _values, result)
      result = val[0].append(val[1])
     result
   end
 .,.,
 
-# reduce 123 omitted
+# reduce 125 omitted
 
-# reduce 124 omitted
+# reduce 126 omitted
 
 module_eval(<<'.,.,', 'parser.y', 492)
-  def _reduce_125(val, _values, result)
+  def _reduce_127(val, _values, result)
      result = Lrama::Lexer::Token::Ident.new(s_value: val[0])
     result
   end
 .,.,
 
-# reduce 126 omitted
+# reduce 128 omitted
 
-# reduce 127 omitted
+# reduce 129 omitted
 
 def _reduce_none(val, _values, result)
   val[0]
diff --git a/tool/lrama/lib/lrama/version.rb b/tool/lrama/lib/lrama/version.rb
index 8ec2c458a1..406939918c 100644
--- a/tool/lrama/lib/lrama/version.rb
+++ b/tool/lrama/lib/lrama/version.rb
@@ -1,3 +1,3 @@
 module Lrama
-  VERSION = "0.6.0".freeze
+  VERSION = "0.6.1".freeze
 end