lrama 0.6.1 → 0.6.3

data/lib/lrama/state.rb

@@ -29,8 +29,8 @@ module Lrama
     end
 
     def non_default_reduces
-      reduces.select do |reduce|
-        reduce.rule != @default_reduction_rule
+      reduces.reject do |reduce|
+        reduce.rule == @default_reduction_rule
       end
     end
 
@@ -105,8 +105,8 @@ module Lrama
     end
 
     def selected_term_transitions
-      term_transitions.select do |shift, next_state|
-        !shift.not_selected
+      term_transitions.reject do |shift, next_state|
+        shift.not_selected
       end
     end
 

data/lib/lrama/states/item.rb

@@ -1,11 +1,17 @@
 # TODO: Validate position is not over rule rhs
 
+require "forwardable"
+
 module Lrama
   class States
     class Item < Struct.new(:rule, :position, keyword_init: true)
+      extend Forwardable
+
+      def_delegators "rule", :lhs, :rhs
+
       # Optimization for States#setup_state
       def hash
-        [rule.id, position].hash
+        [rule_id, position].hash
       end
 
       def rule_id
@@ -17,27 +23,23 @@ module Lrama
       end
 
       def number_of_rest_symbols
-        rule.rhs.count - position
-      end
-
-      def lhs
-        rule.lhs
+        rhs.count - position
       end
 
       def next_sym
-        rule.rhs[position]
+        rhs[position]
       end
 
       def next_next_sym
-        rule.rhs[position + 1]
+        rhs[position + 1]
       end
 
       def previous_sym
-        rule.rhs[position - 1]
+        rhs[position - 1]
       end
 
       def end_of_rule?
-        rule.rhs.count == position
+        rhs.count == position
       end
 
       def beginning_of_rule?
@@ -45,7 +47,7 @@ module Lrama
       end
 
       def start_item?
-        rule.id == 0 && position == 0
+        rule.initial_rule? && beginning_of_rule?
       end
 
       def new_by_next_position
@@ -53,11 +55,11 @@ module Lrama
       end
 
       def symbols_before_dot
-        rule.rhs[0...position]
+        rhs[0...position]
       end
 
       def symbols_after_dot
-        rule.rhs[position..-1]
+        rhs[position..-1]
       end
 
       def to_s
@@ -65,14 +67,14 @@ module Lrama
       end
 
       def display_name
-        r = rule.rhs.map(&:display_name).insert(position, "•").join(" ")
-        "#{r}  (rule #{rule.id})"
+        r = rhs.map(&:display_name).insert(position, "•").join(" ")
+        "#{r}  (rule #{rule_id})"
       end
 
       # Right after position
       def display_rest
-        r = rule.rhs[position..-1].map(&:display_name).join(" ")
-        ". #{r}  (rule #{rule.id})"
+        r = rhs[position..-1].map(&:display_name).join(" ")
+        ". #{r}  (rule #{rule_id})"
       end
     end
   end

data/lib/lrama/states_reporter.rb

@@ -53,7 +53,7 @@ module Lrama
       last_lhs = nil
 
       @states.rules.each do |rule|
-        if rule.rhs.empty?
+        if rule.empty_rule?
           r = "ε"
         else
           r = rule.rhs.map(&:display_name).join(" ")
@@ -84,17 +84,15 @@ module Lrama
         last_lhs = nil
         list = itemsets ? state.items : state.kernels
         list.sort_by {|i| [i.rule_id, i.position] }.each do |item|
-          rule = item.rule
-          position = item.position
-          if rule.rhs.empty?
+          if item.empty_rule?
             r = "ε •"
           else
-            r = rule.rhs.map(&:display_name).insert(position, "•").join(" ")
+            r = item.rhs.map(&:display_name).insert(item.position, "•").join(" ")
           end
-          if rule.lhs == last_lhs
-            l = " " * rule.lhs.id.s_value.length + "|"
+          if item.lhs == last_lhs
+            l = " " * item.lhs.id.s_value.length + "|"
           else
-            l = rule.lhs.id.s_value + ":"
+            l = item.lhs.id.s_value + ":"
           end
           la = ""
           if lookaheads && item.end_of_rule?
@@ -104,15 +102,15 @@ module Lrama
               la = "  [#{look_ahead.map(&:display_name).join(", ")}]"
             end
           end
-          last_lhs = rule.lhs
+          last_lhs = item.lhs
 
-          io << sprintf("%5i %s %s%s\n", rule.id, l, r, la)
+          io << sprintf("%5i %s %s%s\n", item.rule_id, l, r, la)
         end
         io << "\n"
 
         # Report shifts
-        tmp = state.term_transitions.select do |shift, _|
-          !shift.not_selected
+        tmp = state.term_transitions.reject do |shift, _|
+          shift.not_selected
         end.map do |shift, next_state|
           [shift.next_sym, next_state.id]
         end

data/lib/lrama/version.rb

@@ -1,3 +1,3 @@
 module Lrama
-  VERSION = "0.6.1".freeze
+  VERSION = "0.6.3".freeze
 end

data/lrama.gemspec

@@ -16,6 +16,13 @@ Gem::Specification.new do |spec|
   spec.files = Dir.chdir(File.expand_path(__dir__)) do
     `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
   end
+
+  spec.metadata["homepage_uri"]      = spec.homepage
+  spec.metadata["source_code_uri"]   = spec.homepage
+  spec.metadata["documentation_uri"] = spec.homepage
+  spec.metadata["changelog_uri"]     = "#{spec.homepage}/releases"
+  spec.metadata["bug_tracker_uri"]   = "#{spec.homepage}/issues"
+
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]

data/parser.y

@@ -69,6 +69,7 @@ rule
                        {
                          @grammar.initial_action = Grammar::Code::InitialActionCode.new(type: :initial_action, token_code: val[3])
                        }
+                   | "%no-stdlib" { @grammar.no_stdlib = true }
                    | ";"
 
   grammar_declaration: "%union" "{"
@@ -128,6 +129,26 @@ rule
                              lineno: val[3].line
                            )
                          }
+                     | "%after-shift" IDENTIFIER
+                         {
+                           @grammar.after_shift = val[1]
+                         }
+                     | "%before-reduce" IDENTIFIER
+                         {
+                           @grammar.before_reduce = val[1]
+                         }
+                     | "%after-reduce" IDENTIFIER
+                         {
+                           @grammar.after_reduce = val[1]
+                         }
+                     | "%after-shift-error-token" IDENTIFIER
+                         {
+                           @grammar.after_shift_error_token = val[1]
+                         }
+                     | "%after-pop-stack" IDENTIFIER
+                         {
+                           @grammar.after_pop_stack = val[1]
+                         }
 
   symbol_declaration: "%token" token_declarations
                     | "%type" symbol_declarations
@@ -451,9 +472,9 @@ rule
            result = builder
          }
 
-  parameterizing_suffix: "?"
-                       | "+"
-                       | "*"
+  parameterizing_suffix: "?" { result = "option" }
+                       | "+" { result = "nonempty_list" }
+                       | "*" { result = "list" }
 
   parameterizing_args: symbol { result = [val[0]] }
                      | parameterizing_args ',' symbol { result = val[0].append(val[2]) }
@@ -514,8 +535,6 @@ def parse
     @precedence_number = 0
     reset_precs
     do_parse
-    @grammar.prepare
-    @grammar.validate!
     @grammar
   end
 end

data/sig/lrama/grammar/parameterizing_rule/resolver.rbs

@@ -15,6 +15,7 @@ module Lrama
         private
 
         def select_rules: (Lexer::Token::InstantiateRule token) -> Array[Grammar::ParameterizingRule::Rule]
+        def select_rules_by_name: (String rule_name) -> Array[Grammar::ParameterizingRule::Rule]
       end
     end
   end

data/sig/lrama/grammar/reference.rbs

@@ -3,6 +3,7 @@ module Lrama
     class Reference
       attr_accessor type: ::Symbol
       attr_accessor name: String
+      attr_accessor number: Integer
       attr_accessor index: Integer
       attr_accessor ex_tag: Lexer::Token?
       attr_accessor first_column: Integer
@@ -10,7 +11,7 @@ module Lrama
       attr_accessor position_in_rhs: Integer?
 
       def initialize: (
-        type: ::Symbol, ?name: String, ?index: Integer, ?ex_tag: Lexer::Token?,
+        type: ::Symbol, ?name: String, ?number: Integer, ?index: Integer, ?ex_tag: Lexer::Token?,
         first_column: Integer, last_column: Integer,
         ?position_in_rhs: Integer?
       ) -> void

data/sig/lrama/grammar/symbol.rbs

@@ -2,7 +2,7 @@ module Lrama
   class Grammar
     class Symbol
       attr_accessor id: Lexer::Token
-      attr_accessor alias_name: String
+      attr_accessor alias_name: String?
       attr_accessor number: Integer
       attr_accessor tag: Lexer::Token?
       attr_accessor term: bool
@@ -20,8 +20,8 @@ module Lrama
       attr_writer accept_symbol: Symbol
 
       def initialize: (
-          id: Lexer::Token, alias_name: String?, number: Integer?, tag: Lexer::Token?,
-          term: bool, token_id: Integer?, nullable: bool?, precedence: Precedence?, printer: Printer?) -> void
+          id: Lexer::Token, term: bool, ?alias_name: String?, ?number: Integer?, ?tag: Lexer::Token?,
+          ?token_id: Integer?, ?nullable: bool?, ?precedence: Precedence?, ?printer: Printer?) -> void
 
       def term?: () -> bool
       def nterm?: () -> bool
@@ -31,7 +31,7 @@ module Lrama
       def accept_symbol?: () -> bool
       def display_name: () -> String
       def enum_name: () -> String
-      def comment: () -> String
+      def comment: () -> String?
     end
   end
 end

data/sig/lrama/grammar/symbols/resolver.rbs

@@ -0,0 +1,41 @@
+module Lrama
+  class Grammar
+    class Symbols
+      class Resolver
+        attr_reader terms: Array[Grammar::Symbol]
+        attr_reader nterms: Array[Grammar::Symbol]
+
+        @symbols: Array[Grammar::Symbol]?
+        @number: Integer
+        @used_numbers: Hash[Integer, bool]
+
+        def initialize: () -> void
+        def symbols: () -> Array[Grammar::Symbol]
+        def sort_by_number!: () -> void
+        def add_term: (id: Lexer::Token, ?alias_name: String?, ?tag: Lexer::Token?, ?token_id: Integer?, ?replace: bool) -> Grammar::Symbol
+        def add_nterm: (id: Lexer::Token, ?alias_name: String?, ?tag: Lexer::Token?) -> Grammar::Symbol?
+        def find_symbol_by_s_value: (Grammar::Symbol s_value) -> Grammar::Symbol?
+        def find_symbol_by_s_value!: (Grammar::Symbol s_value) -> Grammar::Symbol
+        def find_symbol_by_id: (Lexer::Token id) -> Grammar::Symbol?
+        def find_symbol_by_id!: (Lexer::Token id) -> Grammar::Symbol
+        def find_symbol_by_token_id: (Integer token_id) -> Grammar::Symbol?
+        def find_symbol_by_number!: (Integer number) -> Grammar::Symbol
+        def fill_symbol_number: () -> void
+        def fill_nterm_type: (Array[Grammar::Type] types) -> void
+        def fill_printer: (Array[Grammar::Printer] printers) -> void
+        def fill_error_token: (Array[Grammar::ErrorToken] error_tokens) -> void
+        def token_to_symbol: (Lexer::Token token) -> Grammar::Symbol
+        def validate!: () -> void
+
+        private
+
+        def find_nterm_by_id!: (Lexer::Token id) -> Grammar::Symbol
+        def fill_terms_number: () -> void
+        def fill_nterms_number: () -> void
+        def used_numbers: () -> Hash[Integer, bool]
+        def validate_number_uniqueness!: () -> void
+        def validate_alias_name_uniqueness!: () -> void
+      end
+    end
+  end
+end

data/sig/lrama/grammar/type.rbs

@@ -0,0 +1,11 @@
+module Lrama
+  class Grammar
+    class Type
+      attr_reader id: Lexer::Token
+      attr_reader tag: Lexer::Token
+
+      def initialize: (id: Lexer::Token, tag: Lexer::Token) -> void
+      def ==: (Grammar::Type other) -> bool
+    end
+  end
+end

data/template/bison/yacc.c

@@ -1752,6 +1752,7 @@ yybackup:
   *++yyvsp = yylval;
   YY_IGNORE_MAYBE_UNINITIALIZED_END
   *++yylsp = yylloc;
+<%= output.after_shift_function("/* %after-shift code. */") %>
 
   /* Discard the shifted token.  */
   yychar = YYEMPTY;
@@ -1784,6 +1785,7 @@ yyreduce:
      unconditionally makes the parser a bit smaller, and it avoids a
      GCC warning that YYVAL may be used uninitialized.  */
   yyval = yyvsp[1-yylen];
+<%= output.before_reduce_function("/* %before-reduce function. */") %>
 
   /* Default location. */
   YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
@@ -1809,6 +1811,7 @@ yyreduce:
   YY_SYMBOL_PRINT ("-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc<%= output.user_args %>);
 
   YYPOPSTACK (yylen);
+<%= output.after_reduce_function("/* %after-reduce function. */") %>
   yylen = 0;
 
   *++yyvsp = yyval;
@@ -1910,6 +1913,7 @@ yyerrorlab:
   /* Do not reclaim the symbols of the rule whose action triggered
      this YYERROR.  */
   YYPOPSTACK (yylen);
+<%= output.after_pop_stack_function("yylen", "/* %after-pop-stack function. */") %>
   yylen = 0;
   YY_STACK_PRINT (yyss, yyssp<%= output.user_args %>);
   yystate = *yyssp;
@@ -1969,6 +1973,7 @@ yyerrlab1:
       yydestruct ("Error: popping",
                   YY_ACCESSING_SYMBOL (yystate), yyvsp, yylsp<%= output.user_args %>);
       YYPOPSTACK (1);
+<%= output.after_pop_stack_function(1, "/* %after-pop-stack function. */") %>
       yystate = *yyssp;
       YY_STACK_PRINT (yyss, yyssp<%= output.user_args %>);
     }
@@ -1983,6 +1988,7 @@ yyerrlab1:
 
   /* Shift the error token.  */
   YY_SYMBOL_PRINT ("Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp<%= output.user_args %>);
+<%= output.after_shift_error_token_function("/* %after-shift-error-token code. */") %>
 
   yystate = yyn;
   goto yynewstate;

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lrama
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.6.3
 platform: ruby
 authors:
 - Yuichiro Kaneko
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-01-13 00:00:00.000000000 Z
+date: 2024-02-14 00:00:00.000000000 Z
 dependencies: []
 description: LALR (1) parser generator written by Ruby
 email:
@@ -60,20 +60,16 @@ files:
 - lib/lrama/grammar/parameterizing_rule/resolver.rb
 - lib/lrama/grammar/parameterizing_rule/rhs.rb
 - lib/lrama/grammar/parameterizing_rule/rule.rb
-- lib/lrama/grammar/parameterizing_rules/builder.rb
-- lib/lrama/grammar/parameterizing_rules/builder/base.rb
-- lib/lrama/grammar/parameterizing_rules/builder/list.rb
-- lib/lrama/grammar/parameterizing_rules/builder/nonempty_list.rb
-- lib/lrama/grammar/parameterizing_rules/builder/option.rb
-- lib/lrama/grammar/parameterizing_rules/builder/separated_list.rb
-- lib/lrama/grammar/parameterizing_rules/builder/separated_nonempty_list.rb
 - lib/lrama/grammar/percent_code.rb
 - lib/lrama/grammar/precedence.rb
 - lib/lrama/grammar/printer.rb
 - lib/lrama/grammar/reference.rb
 - lib/lrama/grammar/rule.rb
 - lib/lrama/grammar/rule_builder.rb
+- lib/lrama/grammar/stdlib.y
 - lib/lrama/grammar/symbol.rb
+- lib/lrama/grammar/symbols.rb
+- lib/lrama/grammar/symbols/resolver.rb
 - lib/lrama/grammar/type.rb
 - lib/lrama/grammar/union.rb
 - lib/lrama/lexer.rb
@@ -122,13 +118,6 @@ files:
 - sig/lrama/grammar/parameterizing_rule/resolver.rbs
 - sig/lrama/grammar/parameterizing_rule/rhs.rbs
 - sig/lrama/grammar/parameterizing_rule/rule.rbs
-- sig/lrama/grammar/parameterizing_rules/builder.rbs
-- sig/lrama/grammar/parameterizing_rules/builder/base.rbs
-- sig/lrama/grammar/parameterizing_rules/builder/list.rbs
-- sig/lrama/grammar/parameterizing_rules/builder/nonempty_list.rbs
-- sig/lrama/grammar/parameterizing_rules/builder/option.rbs
-- sig/lrama/grammar/parameterizing_rules/builder/separated_list.rbs
-- sig/lrama/grammar/parameterizing_rules/builder/separated_nonempty_list.rbs
 - sig/lrama/grammar/percent_code.rbs
 - sig/lrama/grammar/precedence.rbs
 - sig/lrama/grammar/printer.rbs
@@ -136,6 +125,8 @@ files:
 - sig/lrama/grammar/rule.rbs
 - sig/lrama/grammar/rule_builder.rbs
 - sig/lrama/grammar/symbol.rbs
+- sig/lrama/grammar/symbols/resolver.rbs
+- sig/lrama/grammar/type.rbs
 - sig/lrama/lexer/grammar_file.rbs
 - sig/lrama/lexer/location.rbs
 - sig/lrama/lexer/token.rbs
@@ -154,7 +145,12 @@ files:
 homepage: https://github.com/ruby/lrama
 licenses:
 - GPL-3.0-or-later
-metadata: {}
+metadata:
+  homepage_uri: https://github.com/ruby/lrama
+  source_code_uri: https://github.com/ruby/lrama
+  documentation_uri: https://github.com/ruby/lrama
+  changelog_uri: https://github.com/ruby/lrama/releases
+  bug_tracker_uri: https://github.com/ruby/lrama/issues
 post_install_message:
 rdoc_options: []
 require_paths:

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

@@ -1,36 +0,0 @@
-module Lrama
-  class Grammar
-    class ParameterizingRules
-      class Builder
-        # Base class for parameterizing rules builder
-        class Base
-          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_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
-
-          def validate_argument_number!
-            unless @args.count == @expected_argument_num
-              raise "Invalid number of arguments. expect: #{@expected_argument_num} actual: #{@args.count}"
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,28 +0,0 @@
-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 = []
-            @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
-      end
-    end
-  end
-end

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

@@ -1,28 +0,0 @@
-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 = []
-            @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
-      end
-    end
-  end
-end

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

@@ -1,28 +0,0 @@
-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 = []
-            @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
-      end
-    end
-  end
-end

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

@@ -1,39 +0,0 @@
-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_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 = []
-            @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
-      end
-    end
-  end
-end