Allow named_ref on parameterized rule calls inside %rule

lib/lrama/grammar/binding.rb

@@ -30,6 +30,7 @@ def concatenated_args_str(token)
       def create_instantiate_rule(sym)
         Lrama::Lexer::Token::InstantiateRule.new(
           s_value: sym.s_value,
+          alias_name: sym.alias_name,
           location: sym.location,
           args: resolve_args(sym.args),
           lhs_tag: sym.lhs_tag

parser.y

@@ -270,11 +270,11 @@ rule
           builder.symbols << Lrama::Lexer::Token::InstantiateRule.new(s_value: val[2], location: @lexer.location, args: [val[1]])
           result = builder
         }
-    | rule_rhs IDENTIFIER "(" parameterized_args ")" TAG?
+    | rule_rhs IDENTIFIER "(" parameterized_args ")" named_ref? TAG?
         {
           on_action_error("intermediate %prec in a rule", val[1]) if @trailing_prec_seen
           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])
+          builder.symbols << Lrama::Lexer::Token::InstantiateRule.new(s_value: val[1].s_value, alias_name: val[5], location: @lexer.location, args: val[3], lhs_tag: val[6])
           result = builder
         }
     | rule_rhs action named_ref?

spec/fixtures/parameterized/user_defined/nested_rules_in_rhs_with_named_ref.y

@@ -0,0 +1,42 @@
+/*
+ * This is comment for this file.
+ */
+
+%{
+static int yylex(YYSTYPE *val, YYLTYPE *loc);
+static int yyerror(YYLTYPE *loc, const char *str);
+%}
+
+%union {
+    int i;
+}
+
+%token <i> number
+
+%rule option(X): /* empty */
+               | X
+               ;
+
+%rule pair(X, Y) <i>: option(X)[x] '+' option(Y)[y] { $$ = $x + $y; }
+                    ;
+
+%%
+
+program         : pair(number, number)
+                ;
+
+%%
+
+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

@@ -2661,6 +2661,79 @@
           end
         end
 
+        context "when nested rules in rhs with named ref" do
+          let(:path) { "parameterized/user_defined/nested_rules_in_rhs_with_named_ref.y" }
+
+          it "expands parameterized rules" do
+            expect(grammar.nterms.sort_by(&:number)).to match_symbols([
+              Sym.new(id: T::Ident.new(s_value: "$accept"), alias_name: nil, number: 5, tag: nil, term: false, token_id: 0, nullable: false),
+              Sym.new(id: T::Ident.new(s_value: "option_number"), alias_name: nil, number: 6, tag: nil, term: false, token_id: 1, nullable: true),
+              Sym.new(id: T::Ident.new(s_value: "pair_number_number"), alias_name: nil, number: 7, tag: T::Tag.new(s_value: "<i>"), term: false, token_id: 2, nullable: false),
+              Sym.new(id: T::Ident.new(s_value: "program"), alias_name: nil, number: 8, tag: nil, term: false, token_id: 3, nullable: false),
+            ])
+
+            expect(grammar.rules).to eq([
+              Rule.new(
+                id: 0,
+                lhs: grammar.find_symbol_by_s_value!("$accept"),
+                rhs: [
+                  grammar.find_symbol_by_s_value!("program"),
+                  grammar.find_symbol_by_s_value!("YYEOF"),
+                ],
+                token_code: nil,
+                nullable: false,
+                precedence_sym: grammar.find_symbol_by_s_value!("YYEOF"),
+                lineno: 25,
+              ),
+              Rule.new(
+                id: 1,
+                lhs: grammar.find_symbol_by_s_value!("option_number"),
+                rhs: [],
+                token_code: nil,
+                nullable: true,
+                precedence_sym: nil,
+                lineno: 25,
+              ),
+              Rule.new(
+                id: 2,
+                lhs: grammar.find_symbol_by_s_value!("option_number"),
+                rhs: [
+                  grammar.find_symbol_by_s_value!("number"),
+                ],
+                token_code: nil,
+                nullable: false,
+                precedence_sym: grammar.find_symbol_by_s_value!("number"),
+                lineno: 25,
+              ),
+              Rule.new(
+                id: 3,
+                lhs: grammar.find_symbol_by_s_value!("pair_number_number"),
+                rhs: [
+                  grammar.find_symbol_by_s_value!("option_number"),
+                  grammar.find_symbol_by_s_value!("'+'"),
+                  grammar.find_symbol_by_s_value!("option_number"),
+                ],
+                lhs_tag: T::Tag.new(s_value: "<i>"),
+                token_code: T::UserCode.new(s_value: " $$ = $x + $y; "),
+                nullable: false,
+                precedence_sym: grammar.find_symbol_by_s_value!("'+'"),
+                lineno: 25,
+              ),
+              Rule.new(
+                id: 4,
+                lhs: grammar.find_symbol_by_s_value!("program"),
+                rhs: [
+                  grammar.find_symbol_by_s_value!("pair_number_number"),
+                ],
+                token_code: nil,
+                nullable: false,
+                precedence_sym: nil,
+                lineno: 25,
+              ),
+            ])
+          end
+        end
+
         context "when recursive" do
           let(:path) { "parameterized/user_defined/recursive.y" }