lrama 0.6.0 → 0.6.2

data/lib/lrama/states/item.rb

@@ -5,7 +5,7 @@ module Lrama
     class Item < Struct.new(:rule, :position, keyword_init: true)
       # Optimization for States#setup_state
       def hash
-        [rule.id, position].hash
+        [rule_id, position].hash
       end
 
       def rule_id
@@ -17,27 +17,31 @@ module Lrama
       end
 
       def number_of_rest_symbols
-        rule.rhs.count - position
+        rhs.count - position
       end
 
       def lhs
         rule.lhs
       end
 
+      def rhs
+        rule.rhs
+      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 +49,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 +57,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 +69,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,9 +102,9 @@ 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"
 

data/lib/lrama/version.rb

@@ -1,3 +1,3 @@
 module Lrama
-  VERSION = "0.6.0".freeze
+  VERSION = "0.6.2".freeze
 end

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" "{"
@@ -205,8 +206,8 @@ rule
 
   rule_declaration: "%rule" IDENTIFIER "(" rule_args ")" ":" rule_rhs_list
                       {
-                        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)
                       }
 
   rule_args: IDENTIFIER { result = [val[0]] }
@@ -226,12 +227,12 @@ rule
   rule_rhs: /* empty */
             {
               reset_precs
-              result = Grammar::ParameterizingRuleRhsBuilder.new
+              result = Grammar::ParameterizingRule::Rhs.new
             }
           | "%empty"
             {
               reset_precs
-              result = Grammar::ParameterizingRuleRhsBuilder.new
+              result = Grammar::ParameterizingRule::Rhs.new
             }
           | rule_rhs symbol named_ref_opt
             {
@@ -408,19 +409,17 @@ rule
          }
      | rhs symbol parameterizing_suffix tag_opt
          {
-           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
          }
      | rhs IDENTIFIER "(" parameterizing_args ")" tag_opt
          {
-           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
          }
@@ -453,12 +452,14 @@ 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]) }
+                     | symbol parameterizing_suffix { result = [Lrama::Lexer::Token::InstantiateRule.new(s_value: val[1].s_value, location: @lexer.location, args: val[0])] }
+                     | IDENTIFIER "(" parameterizing_args ")" { result = [Lrama::Lexer::Token::InstantiateRule.new(s_value: val[0].s_value, location: @lexer.location, args: val[2])] }
 
   named_ref_opt: # empty
                | '[' IDENTIFIER ']' { result = val[1].s_value }
@@ -514,8 +515,6 @@ def parse
     @precedence_number = 0
     reset_precs
     do_parse
-    @grammar.prepare
-    @grammar.validate!
     @grammar
   end
 end

data/sig/lrama/grammar/binding.rbs

@@ -0,0 +1,16 @@
+module Lrama
+  class Grammar
+    class Binding
+      attr_reader actual_args: Array[Lexer::Token]
+      attr_reader count: Integer
+
+      @rule_name: String
+      @required_parameters_count: Integer
+      @parameters: Array[Lexer::Token]
+      @parameter_to_arg: untyped
+
+      def initialize: (Grammar::ParameterizingRule::Rule parameterizing_rule, Array[Lexer::Token] actual_args) -> void
+      def resolve_symbol: (Lexer::Token symbol) -> Lexer::Token
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Lrama
+  class Grammar
+    class ParameterizingRule
+      class Resolver
+        attr_accessor created_lhs_list: Array[Lexer::Token]
+
+        @rules: Array[Grammar::ParameterizingRule::Rule]
+
+        def initialize: () -> void
+        def add_parameterizing_rule: (Grammar::ParameterizingRule::Rule rule) -> void
+        def defined?: (Lexer::Token::InstantiateRule token) -> bool
+        def find: (Lexer::Token::InstantiateRule token) -> Grammar::ParameterizingRule::Rule?
+        def created_lhs: (String lhs_s_value) -> Lexer::Token?
+
+        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
+end

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

@@ -0,0 +1,13 @@
+module Lrama
+  class Grammar
+    class ParameterizingRule
+      class Rhs
+        attr_reader symbols: Array[untyped]
+        attr_reader user_code: Lexer::Token::UserCode?
+        attr_reader precedence_sym: Lexer::Token?
+
+        def initialize: () -> void
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module Lrama
+  class Grammar
+    class ParameterizingRule
+      class Rule
+        attr_reader name: String
+        attr_reader parameters: Array[Lexer::Token]
+        attr_reader rhs_list: Array[Grammar::ParameterizingRule::Rhs]
+        attr_reader required_parameters_count: Integer
+
+        def initialize: (String name, Array[Lexer::Token] parameters, Array[Grammar::ParameterizingRule::Rhs] rhs_list) -> void
+      end
+    end
+  end
+end

data/sig/lrama/grammar/parameterizing_rule.rbs

@@ -1,10 +1,6 @@
 module Lrama
   class Grammar
     class ParameterizingRule
-      attr_accessor rules: Array[Rule]
-      attr_accessor token: Lexer::Token
-
-      def initialize: (?untyped rules, Lexer::Token token) -> void
     end
   end
 end

data/sig/lrama/grammar/percent_code.rbs

@@ -1,10 +1,10 @@
 module Lrama
   class Grammar
     class PercentCode
-      attr_reader id: Lexer::Token::Ident
-      attr_reader code: Lexer::Token::UserCode
+      attr_reader name: String
+      attr_reader code: String
 
-      def initialize: (Lexer::Token::Ident id, Lexer::Token::UserCode code) -> void
+      def initialize: (String name, String code) -> void
     end
   end
 end

data/sig/lrama/grammar/rule_builder.rbs

@@ -2,8 +2,8 @@ module Lrama
   class Grammar
     class RuleBuilder
       attr_accessor lhs: Lexer::Token
-      attr_accessor lhs_tag: untyped
       attr_accessor line: Integer?
+      attr_reader lhs_tag: Lexer::Token::Tag?
       attr_reader rhs: Array[Lexer::Token]
       attr_reader user_code: Lexer::Token::UserCode?
       attr_reader precedence_sym: Lexer::Token?
@@ -13,18 +13,20 @@ module Lrama
       @position_in_original_rule_rhs: Integer?
       @skip_preprocess_references: bool
       @user_code: Lexer::Token::UserCode?
+      @rule_builders_for_parameterizing_rules: Array[RuleBuilder]
       @rule_builders_for_derived_rules: Array[RuleBuilder]
       @rules: Array[Rule]
       @replaced_rhs: Array[Lexer::Token]
       @parameterizing_rules: Array[Rule]
+      @old_parameterizing_rules: Array[Rule]
       @midrule_action_rules: Array[Rule]
 
-      def initialize: (Counter rule_counter, Counter midrule_action_counter, ?Integer position_in_original_rule_rhs, ?skip_preprocess_references: bool) -> void
+      def initialize: (Counter rule_counter, Counter midrule_action_counter, ?Integer position_in_original_rule_rhs, ?lhs_tag: Lexer::Token::Tag?, ?skip_preprocess_references: bool) -> void
       def add_rhs: (Lexer::Token rhs) -> void
-      def user_code=: (Lexer::Token::UserCode user_code) -> void
-      def precedence_sym=: (Lexer::Token user_code) -> void
+      def user_code=: (Lexer::Token::UserCode? user_code) -> void
+      def precedence_sym=: (Lexer::Token? precedence_sym) -> void
       def complete_input: () -> void
-      def setup_rules: (Grammar::ParameterizingRuleResolver parameterizing_resolver) -> void
+      def setup_rules: (Grammar::ParameterizingRule::Resolver parameterizing_rule_resolver) -> void
       def rules: () -> Array[Rule]
 
       private
@@ -32,7 +34,8 @@ module Lrama
       def freeze_rhs: () -> void
       def preprocess_references: () -> void
       def build_rules: () -> void
-      def process_rhs: (Grammar::ParameterizingRuleResolver parameterizing_resolver) -> void
+      def process_rhs: (Grammar::ParameterizingRule::Resolver parameterizing_rule_resolver) -> void
+      def lhs_s_value: (Lexer::Token::InstantiateRule token, Grammar::Binding bindings) -> String
       def numberize_references: () -> void
       def flush_user_code: () -> void
     end

data/sig/lrama/lexer/token/instantiate_rule.rbs

@@ -2,10 +2,12 @@ module Lrama
   class Lexer
     class Token
       class InstantiateRule < Token
-        attr_accessor args: Array[Lexer::Token]
+        attr_reader args: Array[Lexer::Token]
+        attr_reader lhs_tag: Lexer::Token::Tag?
 
-        def initialize: (s_value: String, ?alias_name: String, ?location: Location, ?args: Array[Lexer::Token]) -> void
+        def initialize: (s_value: String, ?alias_name: String, ?location: Location, ?args: Array[Lexer::Token], ?lhs_tag: Lexer::Token::Tag?) -> void
         def rule_name: () -> String
+        def args_count: () -> Integer
       end
     end
   end

data/sig/lrama/lexer/token.rbs

@@ -17,6 +17,7 @@ module Lrama
       def last_column: () -> Integer
       alias line first_line
       alias column first_column
+      def invalid_ref: (Lrama::Grammar::Reference ref, String message) -> bot
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lrama
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.6.2
 platform: ruby
 authors:
 - Yuichiro Kaneko
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-12-25 00:00:00.000000000 Z
+date: 2024-01-27 00:00:00.000000000 Z
 dependencies: []
 description: LALR (1) parser generator written by Ruby
 email:
@@ -48,6 +48,7 @@ files:
 - lib/lrama/digraph.rb
 - lib/lrama/grammar.rb
 - lib/lrama/grammar/auxiliary.rb
+- lib/lrama/grammar/binding.rb
 - lib/lrama/grammar/code.rb
 - lib/lrama/grammar/code/initial_action_code.rb
 - lib/lrama/grammar/code/no_reference_code.rb
@@ -56,22 +57,16 @@ files:
 - lib/lrama/grammar/counter.rb
 - lib/lrama/grammar/error_token.rb
 - lib/lrama/grammar/parameterizing_rule.rb
-- lib/lrama/grammar/parameterizing_rule_builder.rb
-- lib/lrama/grammar/parameterizing_rule_resolver.rb
-- lib/lrama/grammar/parameterizing_rule_rhs_builder.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/parameterizing_rule/resolver.rb
+- lib/lrama/grammar/parameterizing_rule/rhs.rb
+- lib/lrama/grammar/parameterizing_rule/rule.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/type.rb
 - lib/lrama/grammar/union.rb
@@ -112,21 +107,15 @@ files:
 - sig/lrama/bitmap.rbs
 - sig/lrama/digraph.rbs
 - sig/lrama/grammar.rbs
+- sig/lrama/grammar/binding.rbs
 - sig/lrama/grammar/code.rbs
 - sig/lrama/grammar/code/printer_code.rbs
 - sig/lrama/grammar/counter.rbs
 - sig/lrama/grammar/error_token.rbs
 - sig/lrama/grammar/parameterizing_rule.rbs
-- sig/lrama/grammar/parameterizing_rule_builder.rbs
-- sig/lrama/grammar/parameterizing_rule_resolver.rbs
-- sig/lrama/grammar/parameterizing_rule_rhs_builder.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/parameterizing_rule/resolver.rbs
+- sig/lrama/grammar/parameterizing_rule/rhs.rbs
+- sig/lrama/grammar/parameterizing_rule/rule.rbs
 - sig/lrama/grammar/percent_code.rbs
 - sig/lrama/grammar/precedence.rbs
 - sig/lrama/grammar/printer.rbs
@@ -168,7 +157,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.1
+rubygems_version: 3.5.3
 signing_key:
 specification_version: 4
 summary: LALR (1) parser generator written by Ruby

data/lib/lrama/grammar/parameterizing_rule_builder.rb

@@ -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

data/lib/lrama/grammar/parameterizing_rule_resolver.rb

@@ -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

data/lib/lrama/grammar/parameterizing_rule_rhs_builder.rb

@@ -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

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