refactor(parser): Update signature for 'State::nest'

rinja_parser/src/lib.rs

@@ -666,13 +666,13 @@ impl<'a> State<'a> {
 
     fn nest<'b, T, F: Parser<&'b str, T, ErrorContext<'b>>>(
         &self,
-        i: &'b str,
+        i: &mut &'b str,
         mut callback: F,
-    ) -> InputParseResult<'b, T> {
+    ) -> ParseResult<'b, T> {
         let prev_level = self.level.get();
-        let (_, level) = prev_level.nest(i)?;
+        let (_, level) = prev_level.nest(*i)?;
         self.level.set(level);
-        let ret = callback.parse_peek(i);
+        let ret = callback.parse_next(i);
         self.level.set(prev_level);
         ret
     }

rinja_parser/src/node.rs

@@ -86,7 +86,7 @@ impl<'a> Node<'a> {
         }
 
         let start = i;
-        let (i, tag) = preceded(
+        let (mut i, tag) = preceded(
             |i: &mut _| s.tag_block_start(i),
             peek(preceded(
                 (opt(unpeek(Whitespace::parse)), take_till0(not_ws)),
@@ -113,7 +113,7 @@ impl<'a> Node<'a> {
             _ => return fail.parse_peek(start),
         };
 
-        let (i, node) = s.nest(i, unpeek(|i| func(i, s)))?;
+        let node = s.nest(&mut i, unpeek(|i| func(i, s)))?;
 
         let (i, closed) = cut_node(
             None,

rinja_parser/src/target.rs

@@ -28,7 +28,7 @@ impl<'a> Target<'a> {
     /// Parses multiple targets with `or` separating them
     pub(super) fn parse(i: &'a str, s: &State<'_>) -> InputParseResult<'a, Self> {
         separated1(
-            unpeek(|i| s.nest(i, unpeek(|i| Self::parse_one(i, s)))),
+            |i: &mut _| s.nest(i, unpeek(|i| Self::parse_one(i, s))),
             ws("or"),
         )
         .map(|v: Vec<_>| v)