Allow generic args when calling a rule

Fixes #396

Author: kevinmehall

peg-macros/analysis.rs

@@ -86,7 +86,7 @@ impl<'a> LeftRecursionVisitor<'a> {
     fn walk_expr(&mut self, this_expr: &SpannedExpr) -> bool {
         use self::Expr::*;
         match this_expr.expr {
-            RuleExpr(ref rule_ident, _) => {
+            RuleExpr(ref rule_ident, _, _) => {
                 let name = rule_ident.to_string();
 
                 if let Some(rule) = self.rules.get(&name) {
@@ -221,7 +221,7 @@ impl<'a> LoopNullabilityVisitor<'a> {
     fn walk_expr(&mut self, this_expr: &SpannedExpr) -> bool {
         use self::Expr::*;
         match this_expr.expr {
-            RuleExpr(ref rule_ident, _) => {
+            RuleExpr(ref rule_ident, _, _) => {
                 let name = rule_ident.to_string();
                 *self.rule_nullability.get(&name).unwrap_or(&false)
             }

peg-macros/ast.rs

@@ -74,7 +74,7 @@ pub struct SpannedExpr {
 pub enum Expr {
     LiteralExpr(Literal),
     PatternExpr(Group),
-    RuleExpr(Ident, Vec<RuleArg>),
+    RuleExpr(Ident, Option<TokenStream>, Vec<RuleArg>),
     MethodExpr(Ident, TokenStream),
     CustomExpr(Group),
     ChoiceExpr(Vec<SpannedExpr>),

peg-macros/grammar.rs

@@ -65,7 +65,7 @@ rule rust_type()
     / ("<" rust_type() ("as" rust_ty_path())? ">")? rust_ty_path()
 
 rule rust_ty_path()
-    = "::"? (IDENT() ("::"? ("<" (LIFETIME() / rust_type() / BRACE_GROUP() / LITERAL()) ++ "," ","? ">" / PAREN_GROUP() ("->" rust_type())?))?) ++ "::"
+    = "::"? (IDENT() ("::"? (rust_generic_args() / PAREN_GROUP() ("->" rust_type())?))?) ++ "::"
 
 rule rust_ty_params() -> Vec<TokenStream>
     = "<" p:($(rust_generic_param()) ++ ",") ","? ">" { p }
@@ -88,6 +88,9 @@ rule rust_ty_param_bound()
     / "?"? rust_for_lifetimes()? rust_ty_path()
     / "(" "?"? rust_for_lifetimes()? rust_ty_path() ")"
 
+rule rust_generic_args()
+    = "<" (LIFETIME() / rust_type() / BRACE_GROUP() / LITERAL()) ++ "," ","? ">"
+
 rule expression() -> SpannedExpr = choice()
 
 rule choice() -> SpannedExpr = sp:sp() s:sequence() ++ "/" {
@@ -140,8 +143,8 @@ rule primary() -> SpannedExpr
   / sp:sp() "position" "!" "(" ")" { PositionExpr.at(sp) }
   / sp:sp() "quiet" "!" "{" e:expression() "}" { QuietExpr(Box::new(e)).at(sp) }
   / sp:sp() "expected" "!" s:PAREN_GROUP() { FailExpr(s).at(sp) }
-  / &("_" / "__" / "___") sp:sp() name:IDENT() { RuleExpr(name, Vec::new()).at(sp) }
-  / sp:sp() name:IDENT() "(" args:(rule_arg() ** ",") ")" { RuleExpr(name, args).at(sp) }
+  / &("_" / "__" / "___") sp:sp() name:IDENT() { RuleExpr(name, None, Vec::new()).at(sp) }
+  / sp:sp() name:IDENT() generics:$("::" rust_generic_args())? "(" args:(rule_arg() ** ",") ")" { RuleExpr(name, generics, args).at(sp) }
   / sp:sp() l:LITERAL() { LiteralExpr(l).at(sp) }
   / sp:sp() p:BRACKET_GROUP() { PatternExpr(p).at(sp) }
   / "(" sp:sp() "@" ")" { MarkerExpr(true).at(sp) }

peg-macros/grammar.rustpeg

@@ -552,7 +552,7 @@ fn compile_expr(context: &Context, e: &SpannedExpr, result_used: bool) -> TokenS
             )
         }
 
-        RuleExpr(ref rule_name, ref rule_args)
+        RuleExpr(ref rule_name, ref generics, ref rule_args)
             if context.rules_from_args.contains(&rule_name.to_string()) =>
         {
             if !rule_args.is_empty() {
@@ -562,10 +562,17 @@ fn compile_expr(context: &Context, e: &SpannedExpr, result_used: bool) -> TokenS
                 );
             }
 
+            if generics.is_some() {
+                return report_error_expr(
+                    rule_name.span(),
+                    "rule closure cannot have generics".to_string()
+                );
+            }
+
             quote_spanned! { span=> #rule_name(__input, __state, __err_state, __pos) }
         }
 
-        RuleExpr(ref rule_name, ref rule_args) => {
+        RuleExpr(ref rule_name, ref generics, ref rule_args) => {
             let rule_name_str = rule_name.to_string();
 
             let rule_def = if let Some(rule_def) = context.rules.get(&rule_name_str) {
@@ -611,10 +618,10 @@ fn compile_expr(context: &Context, e: &SpannedExpr, result_used: bool) -> TokenS
                 .collect();
 
             if result_used {
-                quote_spanned! { span=> #func(__input, __state, __err_state, __pos #extra_args_call #(, #rule_args_call)*) }
+                quote_spanned! { span=> #func #generics (__input, __state, __err_state, __pos #extra_args_call #(, #rule_args_call)*) }
             } else {
                 quote_spanned! { span=>
-                    match #func(__input, __state, __err_state, __pos #extra_args_call #(, #rule_args_call)*){
+                    match #func #generics (__input, __state, __err_state, __pos #extra_args_call #(, #rule_args_call)*){
                         ::peg::RuleResult::Matched(pos, _) => ::peg::RuleResult::Matched(pos, ()),
                         ::peg::RuleResult::Failed => ::peg::RuleResult::Failed,
                     }

peg-macros/translate.rs

@@ -0,0 +1,10 @@
+peg::parser!( grammar test() for str {
+    rule number<T: std::str::FromStr>() -> T = s:$(['0'..='9']+) {? s.parse().or(Err("number")) }
+
+    pub rule numbers() -> (u8, i32)
+        = n1:number::<u8>() "," n2:number::<i32>() { (n1, n2) }
+});
+
+fn main() {
+    assert_eq!(test::numbers("42,1234"), Ok((42, 1234)));
+}