parser: parse paths in generic arguments

rinja-rs · Jan 20, 2025 · a84cb78 · a84cb78
1 parent 4b15a6e
commit a84cb78
Show file tree

Hide file tree

Showing 4 changed files with 24 additions and 13 deletions.
diff --git a/rinja_derive/src/generator/expr.rs b/rinja_derive/src/generator/expr.rs
@@ -781,12 +781,12 @@ impl<'a> Generator<'a, '_> {
     }
 
     fn visit_ty_generic(&mut self, buf: &mut Buffer, generic: &WithSpan<'_, TyGenerics<'_>>) {
-        let TyGenerics { refs, ty, generics } = &**generic;
+        let TyGenerics { refs, path, args } = &**generic;
         for _ in 0..*refs {
             buf.write('&');
         }
-        buf.write(normalize_identifier(ty));
-        self.visit_ty_generics(buf, generics);
+        self.visit_path(buf, path);
+        self.visit_ty_generics(buf, args);
     }
 
     fn visit_index(

diff --git a/rinja_parser/src/expr.rs b/rinja_parser/src/expr.rs
@@ -12,8 +12,8 @@ use winnow::stream::Stream as _;
 use crate::node::CondTest;
 use crate::{
     CharLit, ErrorContext, Level, Num, ParseErr, ParseResult, PathOrIdentifier, Span, StrLit,
-    WithSpan, char_lit, filter, identifier, identifier_with_refs, keyword, num_lit,
-    path_or_identifier, skip_ws0, skip_ws1, str_lit, ws,
+    WithSpan, char_lit, filter, identifier, keyword, num_lit, path_or_identifier, skip_ws0,
+    skip_ws1, str_lit, ws,
 };
 
 macro_rules! expr_prec_layer {
@@ -742,18 +742,19 @@ impl<'a> Suffix<'a> {
 #[derive(Clone, Debug, PartialEq)]
 pub struct TyGenerics<'a> {
     pub refs: usize,
-    pub ty: &'a str,
-    pub generics: Vec<WithSpan<'a, TyGenerics<'a>>>,
+    pub path: Vec<&'a str>,
+    pub args: Vec<WithSpan<'a, TyGenerics<'a>>>,
 }
 
 impl<'i> TyGenerics<'i> {
     fn parse(i: &mut &'i str, level: Level<'_>) -> ParseResult<'i, WithSpan<'i, Self>> {
         let start = *i;
         (
-            ws(identifier_with_refs),
+            repeat(0.., ws('&')),
+            separated(1.., identifier, ws("::")),
             opt(|i: &mut _| Self::args(i, level)).map(|generics| generics.unwrap_or_default()),
         )
-            .map(|((refs, ty), generics)| WithSpan::new(TyGenerics { refs, ty, generics }, start))
+            .map(|(refs, path, args)| WithSpan::new(TyGenerics { refs, path, args }, start))
             .parse_next(i)
     }
 

diff --git a/rinja_parser/src/lib.rs b/rinja_parser/src/lib.rs
@@ -406,10 +406,6 @@ fn identifier<'i>(input: &mut &'i str) -> ParseResult<'i> {
     (start, opt(tail)).take().parse_next(input)
 }
 
-fn identifier_with_refs<'i>(input: &mut &'i str) -> ParseResult<'i, (usize, &'i str)> {
-    (repeat(0.., ws('&')), identifier).parse_next(input)
-}
-
 fn bool_lit<'i>(i: &mut &'i str) -> ParseResult<'i> {
     alt((keyword("false"), keyword("true"))).parse_next(i)
 }

diff --git a/rinja_parser/src/tests.rs b/rinja_parser/src/tests.rs
@@ -1213,4 +1213,18 @@ fn test_generics_parsing() {
         )
         .is_err()
     );
+
+    // With path and spaces
+    Ast::from_str("{{ a.b::<&&core::primitive::str>() }}", None, &Syntax::default()).unwrap();
+    Ast::from_str("{{ a.b ::<&&core::primitive::str>() }}", None, &Syntax::default()).unwrap();
+    Ast::from_str("{{ a.b:: <&&core::primitive::str>() }}", None, &Syntax::default()).unwrap();
+    Ast::from_str("{{ a.b::< &&core::primitive::str>() }}", None, &Syntax::default()).unwrap();
+    Ast::from_str("{{ a.b::<& &core::primitive::str>() }}", None, &Syntax::default()).unwrap();
+    Ast::from_str("{{ a.b::<&& core::primitive::str>() }}", None, &Syntax::default()).unwrap();
+    Ast::from_str("{{ a.b::<&&core ::primitive::str>() }}", None, &Syntax::default()).unwrap();
+    Ast::from_str("{{ a.b::<&&core:: primitive::str>() }}", None, &Syntax::default()).unwrap();
+    Ast::from_str("{{ a.b::<&&core::primitive ::str>() }}", None, &Syntax::default()).unwrap();
+    Ast::from_str("{{ a.b::<&&core::primitive:: str>() }}", None, &Syntax::default()).unwrap();
+    Ast::from_str("{{ a.b::<&&core::primitive::str >() }}", None, &Syntax::default()).unwrap();
+    Ast::from_str("{{ a.b::<&&core::primitive::str> () }}", None, &Syntax::default()).unwrap();
 }