Intoroduce parameterizing rules with conditional statement

lib/lrama/grammar/binding.rb

@@ -17,6 +17,10 @@ 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)
+        elsif symbol.is_a?(Lexer::Token::ControlSyntax)
+          resolved = symbol.dup
+          resolved.condition = @parameter_to_arg[symbol.condition_value]
+          resolved
         else
           parameter_to_arg(symbol) || symbol
         end

lib/lrama/grammar/parameterizing_rule/rhs.rb

@@ -4,12 +4,20 @@ module Lrama
   class Grammar
     class ParameterizingRule
       class Rhs
-        attr_accessor :symbols, :user_code, :precedence_sym
+        attr_accessor :symbols, :user_code, :precedence_sym, :if_clause
 
         def initialize
           @symbols = []
           @user_code = nil
           @precedence_sym = nil
+          @if_clause = nil
+        end
+
+        def skip?(bindings)
+          return false unless @if_clause
+
+          resolved = bindings.resolve_symbol(@if_clause)
+          resolved.is_a?(Lexer::Token::ControlSyntax) && resolved.if? && resolved.false?
         end
 
         def resolve_user_code(bindings)

lib/lrama/grammar/rule_builder.rb

@@ -140,12 +140,14 @@ def process_rhs
             if (created_lhs = @parameterizing_rule_resolver.created_lhs(lhs_s_value))
               @replaced_rhs << created_lhs
             else
+              next if parameterizing_rule.rhs_list.all? { |r| r.skip?(bindings) }
               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, @parameterizing_rule_resolver, lhs_tag: token.lhs_tag || parameterizing_rule.tag)
                 rule_builder.lhs = lhs_token
+                next if r.skip?(bindings)
                 r.symbols.each { |sym| rule_builder.add_rhs(bindings.resolve_symbol(sym)) }
                 rule_builder.line = line
                 rule_builder.precedence_sym = r.precedence_sym
@@ -168,6 +170,8 @@ def process_rhs
             rule_builder.setup_rules
 
             @rule_builders_for_derived_rules << rule_builder
+          when Lrama::Lexer::Token::ControlSyntax
+            # NOP
           else
             raise "Unexpected token. #{token}"
           end

lib/lrama/lexer.rb

@@ -41,6 +41,9 @@ class Lexer
       %no-stdlib
       %inline
       %locations
+      %if
+      %true
+      %false
     ).freeze
 
     def initialize(grammar_file)

lib/lrama/lexer/token.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'token/char'
+require_relative 'token/control_syntax'
 require_relative 'token/ident'
 require_relative 'token/instantiate_rule'
 require_relative 'token/tag'

lib/lrama/lexer/token/control_syntax.rb

@@ -0,0 +1,30 @@
+module Lrama
+  class Lexer
+    class Token
+      class ControlSyntax < Token
+        attr_accessor :condition
+
+        def initialize(s_value:, location:, condition: nil)
+          @condition = condition
+          super(s_value: s_value, location: location)
+        end
+
+        def if?
+          s_value == '%if'
+        end
+
+        def true?
+          !!@condition&.s_value
+        end
+
+        def false?
+          !true?
+        end
+
+        def condition_value
+          @condition&.s_value
+        end
+      end
+    end
+  end
+end

parser.y

@@ -197,14 +197,16 @@ rule
   rule_args: IDENTIFIER { result = [val[0]] }
            | rule_args "," IDENTIFIER { result = val[0].append(val[2]) }
 
-  rule_rhs_list: rule_rhs
+  rule_rhs_list: rule_rhs if_clause?
                 {
                   builder = val[0]
+                  builder.if_clause = val[1]
                   result = [builder]
                 }
-          | rule_rhs_list "|" rule_rhs
+          | rule_rhs_list "|" rule_rhs if_clause?
                 {
                   builder = val[2]
+                  builder.if_clause = val[3]
                   result = val[0].append(builder)
                 }
 
@@ -227,7 +229,7 @@ rule
                 builder.symbols << Lrama::Lexer::Token::InstantiateRule.new(s_value: val[2], location: @lexer.location, args: [val[1]])
                 result = builder
               }
-          | rule_rhs IDENTIFIER "(" parameterizing_args ")" TAG?
+          | rule_rhs IDENTIFIER "(" parameterizing_rule_args ")" TAG?
               {
                 builder = val[0]
                 builder.symbols << Lrama::Lexer::Token::InstantiateRule.new(s_value: val[1].s_value, location: @lexer.location, args: val[3], lhs_tag: val[5])
@@ -250,6 +252,11 @@ rule
               result = builder
             }
 
+  if_clause: "%if" "(" IDENTIFIER ")"
+            {
+              result = Lrama::Lexer::Token::ControlSyntax.new(s_value: val[0], location: @lexer.location, condition: val[2])
+            }
+
   alias: # empty
        | string_as_id { result = val[0].s_value }
 
@@ -362,11 +369,22 @@ rule
                        | "+" { result = "nonempty_list" }
                        | "*" { result = "list" }
 
-  parameterizing_args: symbol { result = [val[0]] }
-                     | parameterizing_args ',' symbol { result = val[0].append(val[2]) }
+  parameterizing_rule_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])] }
+
+  parameterizing_args: symbol_or_bool { result = [val[0]] }
+                     | parameterizing_args ',' symbol_or_bool { 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])] }
 
+  symbol_or_bool: symbol
+                | bool
+
+  bool: "%true" { result = Lrama::Lexer::Token::Ident.new(s_value: true) }
+      | "%false" { result = Lrama::Lexer::Token::Ident.new(s_value: false) }
+
   midrule_action: "{"
                     {
                       if @prec_seen

sig/lrama/grammar/parameterizing_rule/rhs.rbs

@@ -7,6 +7,7 @@ module Lrama
         attr_reader precedence_sym: Grammar::Symbol?
 
         def initialize: () -> void
+        def skip?: (Grammar::Binding bindings) -> bool
         def resolve_user_code: (Grammar::Binding bindings) -> Lexer::Token::UserCode?
       end
     end

sig/lrama/lexer/token/control_syntax.rbs

@@ -0,0 +1,15 @@
+module Lrama
+  class Lexer
+    class Token
+      class ControlSyntax < Token
+        attr_accessor condition: Lexer::Token::Ident?
+
+        def initialize: (s_value: String, location: Location, ?condition: Lexer::Token::Ident?) -> void
+        def if?: () -> bool
+        def true?: () -> bool
+        def false?: () -> bool
+        def condition_value: () -> String?
+      end
+    end
+  end
+end

spec/fixtures/parameterizing_rules/user_defined/if.y

@@ -0,0 +1,43 @@
+/*
+ * This is comment for this file.
+ */
+
+%{
+// Prologue
+static int yylex(YYSTYPE *val, YYLTYPE *loc);
+static int yyerror(YYLTYPE *loc, const char *str);
+%}
+
+%union {
+    int i;
+}
+
+%token <i> number
+
+%rule defined_rule(X, condition): /* empty */
+                                | X { $$ = $1; } %if(condition)
+                                ;
+
+%%
+
+r_true        : defined_rule(number, %true)
+              ;
+
+r_false       : defined_rule(number, %false)
+              ;
+
+%%
+
+static int yylex(YYSTYPE *yylval, YYLTYPE *loc)
+{
+  return 0;
+}
+
+static int yyerror(YYLTYPE *loc, const char *str)
+{
+  return 0;
+}
+
+int main(int argc, char *argv[])
+{
+}

spec/lrama/parser_spec.rb

@@ -2334,6 +2334,86 @@
             ])
           end
         end
+
+        context "when if" do
+          let(:path) { "parameterizing_rules/user_defined/if.y" }
+
+          it "expands parameterizing rules" do
+            expect(grammar.nterms.sort_by(&:number)).to match_symbols([
+              Sym.new(id: T::Ident.new(s_value: "$accept"), alias_name: nil, number: 4, tag: nil, term: false, token_id: 0, nullable: false),
+              Sym.new(id: T::Ident.new(s_value: "defined_rule_number_true"), alias_name: nil, number: 5, tag: nil, term: false, token_id: 1, nullable: true),
+              Sym.new(id: T::Ident.new(s_value: "r_true"), alias_name: nil, number: 6, tag: nil, term: false, token_id: 2, nullable: true),
+              Sym.new(id: T::Ident.new(s_value: "defined_rule_number_false"), alias_name: nil, number: 7, tag: nil, term: false, token_id: 3, nullable: true),
+              Sym.new(id: T::Ident.new(s_value: "r_false"), alias_name: nil, number: 8, tag: nil, term: false, token_id: 4, nullable: true),
+            ])
+
+            expect(grammar.rules).to eq([
+              Rule.new(
+                id: 0,
+                lhs: grammar.find_symbol_by_s_value!("$accept"),
+                rhs: [
+                  grammar.find_symbol_by_s_value!("r_true"),
+                  grammar.find_symbol_by_s_value!("YYEOF"),
+                ],
+                token_code: nil,
+                nullable: false,
+                precedence_sym: grammar.find_symbol_by_s_value!("YYEOF"),
+                lineno: 23,
+              ),
+              Rule.new(
+                id: 1,
+                lhs: grammar.find_symbol_by_s_value!("defined_rule_number_true"),
+                rhs: [],
+                token_code: nil,
+                nullable: true,
+                precedence_sym: nil,
+                lineno: 23,
+              ),
+              Rule.new(
+                id: 2,
+                lhs: grammar.find_symbol_by_s_value!("defined_rule_number_true"),
+                rhs: [
+                  grammar.find_symbol_by_s_value!("number"),
+                ],
+                token_code: T::UserCode.new(s_value: " $$ = $1; "),
+                nullable: false,
+                precedence_sym: grammar.find_symbol_by_s_value!("number"),
+                lineno: 23,
+              ),
+              Rule.new(
+                id: 3,
+                lhs: grammar.find_symbol_by_s_value!("r_true"),
+                rhs: [
+                  grammar.find_symbol_by_s_value!("defined_rule_number_true"),
+                ],
+                token_code: nil,
+                nullable: true,
+                precedence_sym: nil,
+                lineno: 23,
+              ),
+              Rule.new(
+                id: 4,
+                lhs: grammar.find_symbol_by_s_value!("defined_rule_number_false"),
+                rhs: [],
+                token_code: nil,
+                nullable: true,
+                precedence_sym: nil,
+                lineno: 26,
+              ),
+              Rule.new(
+                id: 5,
+                lhs: grammar.find_symbol_by_s_value!("r_false"),
+                rhs: [
+                  grammar.find_symbol_by_s_value!("defined_rule_number_false")
+                ],
+                token_code: nil,
+                nullable: true,
+                precedence_sym: nil,
+                lineno: 26,
+              ),
+            ])
+          end
+        end
       end
 
       context 'when error case' do