lrama 0.5.10 → 0.5.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0097beb1eb7af4947e417b356a7e3c81c3002916f4a1b2940b2df196ee58f144'
-  data.tar.gz: 982c957cdb8c42d8b77210756046e35f395875bb527f32a66b3a82ff236cbe78
+  metadata.gz: '008f1a5df39b115123be84cb5e1edd379d88458bc95256b0e4fe4659481ceb51'
+  data.tar.gz: 02af30da8cf4cb2cad841f43b603433edafab09b0cf0e8993201c2e9aea12029
 SHA512:
-  metadata.gz: a4bbdebc7f100a1b26c801c3c153519e3fb11d34f6dc5001391302665e779905d95041781917af93b2dac64854f174630044e384465bd5606df40f9f878707b1
-  data.tar.gz: b46f8eb2dffa4df04563bbc8997a9efd06f5a70dcbc26e19f6301624aadf5bc416721045ecf6650b83ae64b9889689c8aeef078e9637e0a152a9ac204ab766de
+  metadata.gz: 12cf8b98035052e89f9060dd73ec2b32ad9c5bec2fe4076e6ee0416832039962cf973c7ca895b482f2f434500648638c01a717d67357aa055eccce851995adaf
+  data.tar.gz: a4cffc85bb5945a3d4d037c0eadee0df22e30236085e01f06bffe1646d0acafd09fdb606860752cdea9dbfdf45baa1fc8d244504b7a0ca29c37ab60f9a727367

data/.github/workflows/test.yaml

@@ -35,10 +35,30 @@ jobs:
         with:
           ruby-version: ${{ matrix.ruby }}
           bundler-cache: true
-      - run: choco install winflexbison
+      - run: choco install winflexbison || choco install winflexbison
       - run: win_flex --help
       - run: bundle install
       - run: bundle exec rspec
+  test-memory:
+    runs-on: ubuntu-20.04
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby: ['head']
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true
+      - run: |
+          sudo apt-get update -q
+          sudo apt-get install --no-install-recommends -q -y valgrind
+      - run: valgrind --version
+      - run: bundle install
+      - run: bundle exec rspec spec/lrama/integration_spec.rb
+        env:
+          ENABEL_VALGRIND: 'true'
   check-misc:
     runs-on: ubuntu-20.04
     strategy:
@@ -102,7 +122,7 @@ jobs:
       - run: mkdir -p tool/lrama
         working-directory: ../ruby
       - name: Copy Lrama to ruby/tool
-        run: cp -r LEGAL.md MIT exe lib template ../ruby/tool/lrama
+        run: cp -r LEGAL.md NEWS.md MIT exe lib template ../ruby/tool/lrama
         working-directory:
       - run: tree tool/lrama
         working-directory: ../ruby

data/LEGAL.md

@@ -7,5 +7,6 @@ mentioned below.
 
 These files are licensed under the GNU General Public License version 3 or later. See these files for more information.
 
+* template/bison/_yacc.h
 * template/bison/yacc.c
 * template/bison/yacc.h

data/NEWS.md

@@ -0,0 +1,167 @@
+# NEWS for Lrama
+
+## Lrama 0.5.11 (2023-12-02)
+
+### Type specification of parameterizing rules
+
+Allow to specify type of rules by specifying tag, `<i>` in below example.
+Tag is post-modification style.
+
+```
+%union {
+    int i;
+}
+
+%%
+
+program         : option(number) <i>
+                | number_alias? <i>
+                ;
+```
+
+https://github.com/ruby/lrama/pull/272
+
+
+## Lrama 0.5.10 (2023-11-18)
+
+### Parameterizing rules (option, nonempty_list, list)
+
+Support function call style parameterizing rules for `option`, `nonempty_list` and `list`.
+
+https://github.com/ruby/lrama/pull/197
+
+### Parameterizing rules (separated_list)
+
+Support `separated_list` and `separated_nonempty_list` parameterizing rules.
+
+```
+program: separated_list(',', number)
+
+// Expanded to
+
+program: separated_list_number
+separated_list_number: ε
+separated_list_number: separated_nonempty_list_number
+separated_nonempty_list_number: number
+separated_nonempty_list_number: separated_nonempty_list_number ',' number
+```
+
+```
+program: separated_nonempty_list(',', number)
+
+// Expanded to
+
+program: separated_nonempty_list_number
+separated_nonempty_list_number: number
+separated_nonempty_list_number: separated_nonempty_list_number ',' number
+```
+
+https://github.com/ruby/lrama/pull/204
+
+## Lrama 0.5.9 (2023-11-05)
+
+### Parameterizing rules (suffix)
+
+Parameterizing rules are template of rules.
+It's very common pattern to write "list" grammar rule like:
+
+```
+opt_args: /* none */
+        | args
+        ;
+
+args: arg
+    | args arg
+```
+
+Lrama supports these suffixes:
+
+* `?`: option
+* `+`: nonempty list
+* `*`: list
+
+Idea of Parameterizing rules comes from Menhir LR(1) parser generator (https://gallium.inria.fr/~fpottier/menhir/manual.html#sec32).
+
+https://github.com/ruby/lrama/pull/181
+
+## Lrama 0.5.7 (2023-10-23)
+
+### Racc parser
+
+Replace Lrama's parser from hand written parser to LR parser generated by Racc.
+Lrama uses `--embedded` option to generate LR parser because Racc is changed from default gem to bundled gem by Ruby 3.3 (https://github.com/ruby/lrama/pull/132).
+
+https://github.com/ruby/lrama/pull/62
+
+## Lrama 0.5.4 (2023-08-17)
+
+### Runtime configuration for error recovery
+
+Meke error recovery function configurable on runtime by two new macros.
+
+* `YYMAXREPAIR`: Expected to return max length of repair operations. `%parse-param` is passed to this function.
+* `YYERROR_RECOVERY_ENABLED`: Expected to return bool value to determine error recovery is enabled or not. `%parse-param` is passed to this function.
+
+https://github.com/ruby/lrama/pull/74
+
+## Lrama 0.5.3 (2023-08-05)
+
+### Error Recovery
+
+Support token insert base Error Recovery.
+`-e` option is needed to generate parser with error recovery functions.
+
+https://github.com/ruby/lrama/pull/44
+
+## Lrama 0.5.2 (2023-06-14)
+
+### Named References
+
+Instead of positional references like `$1` or `$$`,
+named references allow to access to symbol by name.
+
+```
+primary: k_class cpath superclass bodystmt k_end
+           {
+             $primary = new_class($cpath, $bodystmt, $superclass);
+           }
+```
+
+Alias name can be declared.
+
+```
+expr[result]: expr[ex-left] '+' expr[ex.right]
+                {
+                  $result = $[ex-left] + $[ex.right];
+                }
+```
+
+Bison supports this feature from 2.5.
+
+### Add parse params to some macros and functions
+
+`%parse-param` are added to these macros and functions to remove ytab.sed hack from Ruby.
+
+* `YY_LOCATION_PRINT`
+* `YY_SYMBOL_PRINT`
+* `yy_stack_print`
+* `YY_STACK_PRINT`
+* `YY_REDUCE_PRINT`
+* `yysyntax_error`
+
+https://github.com/ruby/lrama/pull/40
+
+See also: https://github.com/ruby/ruby/pull/7807
+
+## Lrama 0.5.0 (2023-05-17)
+
+### stdin mode
+
+When `-` is given as grammar file name, reads the grammar source from STDIN, and takes the next argument as the input file name. This mode helps pre-process a grammar source.
+
+https://github.com/ruby/lrama/pull/8
+
+## Lrama 0.4.0 (2023-05-13)
+
+This is the first version migrated to Ruby.
+This version generates "parse.c" compatible with Bison 3.8.2.

data/README.md

@@ -138,7 +138,7 @@ $ stackprof --d3-flamegraph tmp/stackprof-cpu-myapp.dump > tmp/flamegraph.html
 
 1. Update `Lrama::VERSION`
 2. Release as a gem by `rake release`
-3. Update Lrama in ruby/ruby by `cp -r LEGAL.md MIT exe lib template ruby/tool/lrama`
+3. Update Lrama in ruby/ruby by `cp -r LEGAL.md NEWS.md MIT exe lib template ruby/tool/lrama`
 4. Create new release on [GitHub](https://github.com/ruby/lrama/releases)
 
 ## License

data/Steepfile

@@ -4,24 +4,20 @@ target :lib do
   repo_path '.gem_rbs_collection/'
   signature "sig"
 
-  check "lib/lrama/bitmap.rb"
-  check "lib/lrama/digraph.rb"
-  check "lib/lrama/grammar/code.rb"
   check "lib/lrama/grammar/code/printer_code.rb"
+  check "lib/lrama/grammar/code.rb"
   check "lib/lrama/grammar/counter.rb"
+  check "lib/lrama/grammar/error_token.rb"
+  check "lib/lrama/grammar/parameterizing_rules"
   check "lib/lrama/grammar/percent_code.rb"
   check "lib/lrama/grammar/precedence.rb"
   check "lib/lrama/grammar/printer.rb"
   check "lib/lrama/grammar/reference.rb"
   check "lib/lrama/grammar/rule_builder.rb"
-  check "lib/lrama/lexer/token/char.rb"
-  check "lib/lrama/lexer/token/ident.rb"
-  check "lib/lrama/lexer/token/parameterizing.rb"
-  check "lib/lrama/lexer/token/tag.rb"
-  check "lib/lrama/lexer/token/user_code.rb"
-  check "lib/lrama/lexer/location.rb"
-  check "lib/lrama/lexer/token.rb"
-  check "lib/lrama/report/duration.rb"
-  check "lib/lrama/report/profile.rb"
+  check "lib/lrama/grammar/symbol.rb"
+  check "lib/lrama/lexer"
+  check "lib/lrama/report"
+  check "lib/lrama/bitmap.rb"
+  check "lib/lrama/digraph.rb"
   check "lib/lrama/warning.rb"
 end

data/lib/lrama/grammar/code/rule_action.rb

@@ -14,9 +14,23 @@ module Lrama
         # * ($1) yyvsp[i]
         # * (@1) yylsp[i]
         #
+        #
+        # 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                             $6
+        # "Index for yyvsp"                       -4     -3      -2          -1           0
+        #
+        #
+        # For the first midrule action:
+        #
         # "Rule"                class: keyword_class { $1 } tSTRING { $2 + $3 } keyword_end { $class = $1 + $keyword_end }
-        # "Position in grammar"                   $1    $2      $3          $4          $5                             $6
-        # "Index for yyvsp"                       -4    -3      -2          -1           0
+        # "Position in grammar"                   $1
+        # "Index for yyvsp"                        0
         def reference_to_c(ref)
           case
           when ref.type == :dollar && ref.name == "$" # $$
@@ -45,12 +59,14 @@ module Lrama
           @rule.position_in_original_rule_rhs || @rule.rhs.count
         end
 
+        # If this is midrule action, RHS is a RHS of the original rule.
         def rhs
           (@rule.original_rule || @rule).rhs
         end
 
+        # Unlike `rhs`, LHS is always a LHS of the rule.
         def lhs
-          (@rule.original_rule || @rule).lhs
+          @rule.lhs
         end
 
         def raise_tag_not_found_error(ref)

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

@@ -2,16 +2,24 @@ module Lrama
   class Grammar
     class ParameterizingRules
       class Builder
+        # Base class for parameterizing rules builder
         class Base
-          def initialize(token, rule_counter, lhs, user_code, precedence_sym, line)
+          attr_reader :build_token
+
+          def initialize(token, rule_counter, lhs_tag, user_code, precedence_sym, line)
             @args = token.args
             @token = @args.first
             @rule_counter = rule_counter
-            @lhs = lhs
+            @lhs_tag = lhs_tag
             @user_code = user_code
             @precedence_sym = precedence_sym
             @line = line
             @expected_argument_num = 1
+            @build_token = nil
+          end
+
+          def build
+            raise NotImplementedError
           end
 
           private

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

@@ -2,15 +2,23 @@ module Lrama
   class Grammar
     class ParameterizingRules
       class Builder
+        # Builder for list of general parameterizing rules
         class List < Base
+
+          # program: list(number)
+          #
+          # =>
+          #
+          # program: list_number
+          # list_number: ε
+          # list_number: list_number number
           def build
             validate_argument_number!
 
             rules = []
-            list_token = Lrama::Lexer::Token::Ident.new(s_value: "list_#{@token.s_value}")
-            rules << Rule.new(id: @rule_counter.increment, _lhs: @lhs, _rhs: [list_token], token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
-            rules << Rule.new(id: @rule_counter.increment, _lhs: list_token, _rhs: [], token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
-            rules << Rule.new(id: @rule_counter.increment, _lhs: list_token, _rhs: [list_token, @token], token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
+            @build_token = Lrama::Lexer::Token::Ident.new(s_value: "list_#{@token.s_value}")
+            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

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

@@ -2,15 +2,23 @@ module Lrama
   class Grammar
     class ParameterizingRules
       class Builder
+        # Builder for nonempty list of general parameterizing rules
         class NonemptyList < Base
+
+          # program: nonempty_list(number)
+          #
+          # =>
+          #
+          # program: nonempty_list_number
+          # nonempty_list_number: number
+          # nonempty_list_number: nonempty_list_number number
           def build
             validate_argument_number!
 
             rules = []
-            nonempty_list_token = Lrama::Lexer::Token::Ident.new(s_value: "nonempty_list_#{@token.s_value}")
-            rules << Rule.new(id: @rule_counter.increment, _lhs: @lhs, _rhs: [nonempty_list_token], token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
-            rules << Rule.new(id: @rule_counter.increment, _lhs: nonempty_list_token, _rhs: [@token], token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
-            rules << Rule.new(id: @rule_counter.increment, _lhs: nonempty_list_token, _rhs: [nonempty_list_token, @token], token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
+            @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], 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

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

@@ -2,15 +2,23 @@ module Lrama
   class Grammar
     class ParameterizingRules
       class Builder
+        # Builder for option of general parameterizing rules
         class Option < Base
+
+          # program: option(number)
+          #
+          # =>
+          #
+          # program: option_number
+          # option_number: ε
+          # option_number: number
           def build
             validate_argument_number!
 
             rules = []
-            option_token = Lrama::Lexer::Token::Ident.new(s_value: "option_#{@token.s_value}")
-            rules << Rule.new(id: @rule_counter.increment, _lhs: @lhs, _rhs: [option_token], token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
-            rules << Rule.new(id: @rule_counter.increment, _lhs: option_token, _rhs: [], token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
-            rules << Rule.new(id: @rule_counter.increment, _lhs: option_token, _rhs: [@token], token_code: @ser_code, precedence_sym: @precedence_sym, lineno: @line)
+            @build_token = Lrama::Lexer::Token::Ident.new(s_value: "option_#{@token.s_value}")
+            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

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

@@ -2,23 +2,34 @@ module Lrama
   class Grammar
     class ParameterizingRules
       class Builder
+        # Builder for separated list of general parameterizing rules
         class SeparatedList < Base
-          def initialize(token, rule_counter, lhs, user_code, precedence_sym, line)
+          def initialize(token, rule_counter, lhs_tag, user_code, precedence_sym, line)
             super
             @separator = @args[0]
             @token = @args[1]
             @expected_argument_num = 2
           end
 
+          # program: separated_list(',', number)
+          #
+          # =>
+          #
+          # program: separated_list_number
+          # separated_list_number: ε
+          # separated_list_number: separated_nonempty_list_number
+          # separated_nonempty_list_number: number
+          # separated_nonempty_list_number: separated_nonempty_list_number ',' number
           def build
             validate_argument_number!
 
             rules = []
-            separated_list_token = Lrama::Lexer::Token::Ident.new(s_value: "separated_list_#{@token.s_value}")
-            rules << Rule.new(id: @rule_counter.increment, _lhs: @lhs, _rhs: [separated_list_token], token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
-            rules << Rule.new(id: @rule_counter.increment, _lhs: separated_list_token, _rhs: [], token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
-            rules << Rule.new(id: @rule_counter.increment, _lhs: separated_list_token, _rhs: [@token], token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
-            rules << Rule.new(id: @rule_counter.increment, _lhs: separated_list_token, _rhs: [separated_list_token, @separator, @token], token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
+            @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: [], 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

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

@@ -2,22 +2,29 @@ module Lrama
   class Grammar
     class ParameterizingRules
       class Builder
+        # Builder for separated nonempty list of general parameterizing rules
         class SeparatedNonemptyList < Base
-          def initialize(token, rule_counter, lhs, user_code, precedence_sym, line)
+          def initialize(token, rule_counter, lhs_tag, user_code, precedence_sym, line)
             super
             @separator = @args[0]
             @token = @args[1]
             @expected_argument_num = 2
           end
 
+          # program: separated_nonempty_list(',', number)
+          #
+          # =>
+          #
+          # program: separated_nonempty_list_number
+          # separated_nonempty_list_number: number
+          # separated_nonempty_list_number: separated_nonempty_list_number ',' number
           def build
             validate_argument_number!
 
             rules = []
-            separated_list_token = Lrama::Lexer::Token::Ident.new(s_value: "separated_nonempty_list_#{@token.s_value}")
-            rules << Rule.new(id: @rule_counter.increment, _lhs: @lhs, _rhs: [separated_list_token], token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
-            rules << Rule.new(id: @rule_counter.increment, _lhs: separated_list_token, _rhs: [@token], token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
-            rules << Rule.new(id: @rule_counter.increment, _lhs: separated_list_token, _rhs: [separated_list_token, @separator, @token], token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
+            @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], 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

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

@@ -8,6 +8,7 @@ require 'lrama/grammar/parameterizing_rules/builder/separated_list'
 module Lrama
   class Grammar
     class ParameterizingRules
+      # Builder for parameterizing rules
       class Builder
         RULES = {
           option: Lrama::Grammar::ParameterizingRules::Builder::Option,
@@ -20,23 +21,39 @@ module Lrama
           separated_list: Lrama::Grammar::ParameterizingRules::Builder::SeparatedList,
         }
 
-        def initialize(token, rule_counter, lhs, 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 = lhs
+          @lhs_tag = lhs_tag
           @user_code = user_code
           @precedence_sym = precedence_sym
           @line = line
+          @builder = nil
         end
 
         def build
-          if RULES.key?(@key)
-            RULES[@key].new(@token, @rule_counter, @lhs, @user_code, @precedence_sym, @line).build
-          else
-            raise "Parameterizing rule does not exist. `#{@key}`"
+          create_builder
+          @builder.build
+        end
+
+        def build_token
+          create_builder
+          @builder.build_token
+        end
+
+        private
+
+        def create_builder
+          unless @builder
+            validate_key!
+            @builder = RULES[@key].new(@token, @rule_counter, @lhs_tag, @user_code, @precedence_sym, @line)
           end
         end
+
+        def validate_key!
+          raise "Parameterizing rule does not exist. `#{@key}`" unless RULES.key?(@key)
+        end
       end
     end
   end

data/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 &&

data/lib/lrama/grammar/rule_builder.rb

@@ -3,7 +3,7 @@ require 'lrama/grammar/parameterizing_rules/builder'
 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 @@ module Lrama
 
         @lhs = nil
         @rhs = []
+        @lhs_tag = nil
         @user_code = nil
         @precedence_sym = nil
         @line = nil
@@ -81,22 +82,16 @@ module Lrama
       def build_rules
         tokens = @replaced_rhs
 
-        # Expand Parameterizing rules
-        if tokens.any? {|r| r.is_a?(Lrama::Lexer::Token::Parameterizing) }
-          @rules = @parameterizing_rules
-          @midrule_action_rules = []
-        else
-          rule = Rule.new(
-            id: @rule_counter.increment, _lhs: lhs, _rhs: tokens, token_code: user_code,
-            position_in_original_rule_rhs: @position_in_original_rule_rhs, precedence_sym: precedence_sym, lineno: line
-          )
-          @rules = [rule]
-          @midrule_action_rules = @rule_builders_for_derived_rules.map do |rule_builder|
-            rule_builder.rules
-          end.flatten
-          @midrule_action_rules.each do |r|
-            r.original_rule = rule
-          end
+        rule = Rule.new(
+          id: @rule_counter.increment, _lhs: lhs, _rhs: tokens, token_code: user_code,
+          position_in_original_rule_rhs: @position_in_original_rule_rhs, precedence_sym: precedence_sym, lineno: line
+        )
+        @rules = [rule]
+        @midrule_action_rules = @rule_builders_for_derived_rules.map do |rule_builder|
+          rule_builder.rules
+        end.flatten
+        @midrule_action_rules.each do |r|
+          r.original_rule = rule
         end
       end
 
@@ -115,8 +110,11 @@ module Lrama
           when Lrama::Lexer::Token::Ident
             @replaced_rhs << token
           when Lrama::Lexer::Token::Parameterizing
-            @parameterizing_rules = ParameterizingRules::Builder.new(token, @rule_counter, lhs, user_code, precedence_sym, line).build
-            @replaced_rhs << token
+            parameterizing = ParameterizingRules::Builder.new(token, @rule_counter, @lhs_tag, user_code, precedence_sym, line)
+            parameterizing.build.each do |r|
+              @parameterizing_rules << r
+            end
+            @replaced_rhs << parameterizing.build_token
           when Lrama::Lexer::Token::UserCode
             prefix = token.referred ? "@" : "$@"
             new_token = Lrama::Lexer::Token::Ident.new(s_value: prefix + @midrule_action_counter.increment.to_s)