Change only support for postfix if format

```
%rule defined_rule(X, condition): X { $$ = $1; } %if(condition)
                                ;
```

Author: ydah

lib/lrama/grammar.rb

@@ -32,7 +32,7 @@ class Grammar
                   :after_shift, :before_reduce, :after_reduce, :after_shift_error_token, :after_pop_stack,
                   :symbols_resolver, :types,
                   :rules, :rule_builders,
-                  :sym_to_rules, :no_stdlib, :if_count
+                  :sym_to_rules, :no_stdlib
 
     def_delegators "@symbols_resolver", :symbols, :nterms, :terms, :add_nterm, :add_term,
                                         :find_symbol_by_number!, :find_symbol_by_id!, :token_to_symbol,
@@ -60,7 +60,6 @@ def initialize(rule_counter)
       @accept_symbol = nil
       @aux = Auxiliary.new
       @no_stdlib = false
-      @if_count = 0
 
       append_special_symbols
     end
@@ -174,10 +173,6 @@ def find_rules_by_symbol(sym)
       @sym_to_rules[sym.number]
     end
 
-    def initialize_if_count
-      @if_count = 0
-    end
-
     private
 
     def compute_nullable

lib/lrama/grammar/parameterizing_rule/rhs.rb

@@ -18,25 +18,6 @@ def skip?(bindings)
           last_sym.is_a?(Lexer::Token::ControlSyntax) && last_sym.if? && last_sym.false?
         end
 
-        def resolve_symbols(bindings)
-          is_skip = []
-          @symbols.map do |sym|
-            resolved = bindings.resolve_symbol(sym)
-            if resolved.is_a?(Lexer::Token::ControlSyntax)
-              if resolved.if?
-                is_skip.push(resolved.false?)
-              elsif resolved.endif?
-                is_skip.pop
-              else
-                raise "Unexpected control syntax: #{resolved.condition_value}"
-              end
-              nil
-            else
-              resolved unless is_skip.last
-            end
-          end.compact
-        end
-
         def resolve_user_code(bindings)
           return unless user_code
 

lib/lrama/grammar/rule_builder.rb

@@ -152,9 +152,7 @@ def process_rhs
                 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.resolve_symbols(bindings).each do |sym|
-                  rule_builder.add_rhs(sym)
-                end
+                r.symbols.each { |sym| rule_builder.add_rhs(bindings.resolve_symbol(sym)) }
                 rule_builder.line = line
                 rule_builder.precedence_sym = r.precedence_sym
                 rule_builder.user_code = r.resolve_user_code(bindings)
@@ -176,6 +174,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,7 +41,6 @@ class Lexer
       %no-stdlib
       %inline
       %if
-      %endif
       %true
       %false
     )

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

@@ -13,10 +13,6 @@ def if?
           s_value == '%if'
         end
 
-        def endif?
-          s_value == '%endif'
-        end
-
         def true?
           !!@condition&.s_value
         end

lib/lrama/parser.rb

@@ -243,7 +243,6 @@ rule
                       {
                         rule = Grammar::ParameterizingRule::Rule.new(val[2].s_value, [], val[4], is_inline: true)
                         @grammar.add_parameterizing_rule(rule)
-                        @grammar.initialize_if_count
                       }
                     | "%rule" "%inline" IDENTIFIER "(" rule_args ")" ":" rule_rhs_list
                       {
@@ -327,15 +326,6 @@ rule
             {
               builder = val[0]
               builder.symbols << Lrama::Lexer::Token::ControlSyntax.new(s_value: val[1], location: @lexer.location, condition: val[3])
-              @grammar.if_count += 1
-              result = builder
-            }
-          | rule_rhs "%endif"
-            {
-              on_action_error("no %if before %endif", val[0]) if @grammar.if_count == 0
-              builder = val[0]
-              builder.symbols << Lrama::Lexer::Token::ControlSyntax.new(s_value: val[1], location: @lexer.location)
-              @grammar.if_count -= 1
               result = builder
             }
 

parser.y

@@ -8,7 +8,6 @@ module Lrama
 
         def initialize: () -> void
         def skip?: (Grammar::Binding bindings) -> bool
-        def resolve_symbols: (Grammar::Binding bindings) -> Array[untyped]
         def resolve_user_code: (Grammar::Binding bindings) -> Lexer::Token::UserCode?
       end
     end

sig/lrama/grammar/parameterizing_rule/rhs.rbs

@@ -6,7 +6,6 @@ module Lrama
 
         def initialize: (s_value: String, location: Location, ?condition: Lexer::Token::Ident?) -> void
         def if?: () -> bool
-        def endif?: () -> bool
         def true?: () -> bool
         def false?: () -> bool
         def condition_value: () -> String?