Merge pull request #470 from epage/context

fix(error)!: Consistently pass Checkpoints around
winnow-rs · Feb 12, 2024 · d049ebd · d049ebd
2 parents c73f840 + 8cec29c
commit d049ebd
Show file tree

Hide file tree

Showing 13 changed files with 199 additions and 138 deletions.
diff --git a/examples/custom_error.rs b/examples/custom_error.rs
@@ -2,19 +2,20 @@ use winnow::error::ErrMode;
 use winnow::error::ErrorKind;
 use winnow::error::ParserError;
 use winnow::prelude::*;
+use winnow::stream::Stream;
 
 #[derive(Debug, PartialEq, Eq)]
 pub enum CustomError<I> {
     MyError,
     Nom(I, ErrorKind),
 }
 
-impl<I: Clone> ParserError<I> for CustomError<I> {
+impl<I: Stream + Clone> ParserError<I> for CustomError<I> {
     fn from_error_kind(input: &I, kind: ErrorKind) -> Self {
         CustomError::Nom(input.clone(), kind)
     }
 
-    fn append(self, _: &I, _: ErrorKind) -> Self {
+    fn append(self, _: &I, _: &<I as Stream>::Checkpoint, _: ErrorKind) -> Self {
         self
     }
 }

diff --git a/src/_tutorial/chapter_3.rs b/src/_tutorial/chapter_3.rs
@@ -124,17 +124,17 @@
 //!         return Ok(output);
 //!     }
 //!
-//!     input.reset(start);
+//!     input.reset(&start);
 //!     if let Ok(output) = ("0o", parse_oct_digits).parse_next(input) {
 //!         return Ok(output);
 //!     }
 //!
-//!     input.reset(start);
+//!     input.reset(&start);
 //!     if let Ok(output) = ("0d", parse_dec_digits).parse_next(input) {
 //!         return Ok(output);
 //!     }
 //!
-//!     input.reset(start);
+//!     input.reset(&start);
 //!     ("0x", parse_hex_digits).parse_next(input)
 //! }
 //!

diff --git a/src/ascii/mod.rs b/src/ascii/mod.rs
@@ -1498,7 +1498,7 @@ where
             Some(_) => {
                 if input.eof_offset() == current_len {
                     let offset = input.offset_from(&start);
-                    input.reset(start);
+                    input.reset(&start);
                     return Ok(input.next_slice(offset));
                 }
             }
@@ -1507,7 +1507,7 @@ where
                     let _ = escapable.parse_next(input)?;
                 } else {
                     let offset = input.offset_from(&start);
-                    input.reset(start);
+                    input.reset(&start);
                     return Ok(input.next_slice(offset));
                 }
             }
@@ -1540,7 +1540,7 @@ where
             Some(_) => {
                 if input.eof_offset() == current_len {
                     let offset = input.offset_from(&start);
-                    input.reset(start);
+                    input.reset(&start);
                     return Ok(input.next_slice(offset));
                 }
             }
@@ -1549,14 +1549,14 @@ where
                     let _ = escapable.parse_next(input)?;
                 } else {
                     let offset = input.offset_from(&start);
-                    input.reset(start);
+                    input.reset(&start);
                     return Ok(input.next_slice(offset));
                 }
             }
         }
     }
 
-    input.reset(start);
+    input.reset(&start);
     Ok(input.finish())
 }
 

diff --git a/src/binary/bits/mod.rs b/src/binary/bits/mod.rs
@@ -50,6 +50,7 @@ pub fn bits<I, O, E1, E2, P>(mut parser: P) -> impl Parser<I, O, E2>
 where
     E1: ParserError<(I, usize)> + ErrorConvert<E2>,
     E2: ParserError<I>,
+    (I, usize): Stream,
     I: Stream + Clone,
     P: Parser<(I, usize), O, E1>,
 {
@@ -320,7 +321,7 @@ where
             if pattern == o {
                 Ok(o)
             } else {
-                input.reset(start);
+                input.reset(&start);
                 Err(ErrMode::Backtrack(E::from_error_kind(
                     input,
                     ErrorKind::Tag,

diff --git a/src/combinator/branch.rs b/src/combinator/branch.rs
@@ -126,7 +126,7 @@ impl<const N: usize, I: Stream, O, E: ParserError<I>, P: Parser<I, O, E>> Alt<I,
 
         let start = input.checkpoint();
         for branch in self {
-            input.reset(start.clone());
+            input.reset(&start);
             match branch.parse_next(input) {
                 Err(ErrMode::Backtrack(e)) => {
                     error = match error {
@@ -139,7 +139,7 @@ impl<const N: usize, I: Stream, O, E: ParserError<I>, P: Parser<I, O, E>> Alt<I,
         }
 
         match error {
-            Some(e) => Err(ErrMode::Backtrack(e.append(input, ErrorKind::Alt))),
+            Some(e) => Err(ErrMode::Backtrack(e.append(input, &start, ErrorKind::Alt))),
             None => Err(ErrMode::assert(input, "`alt` needs at least one parser")),
         }
     }
@@ -204,7 +204,7 @@ macro_rules! succ (
 
 macro_rules! alt_trait_inner(
   ($it:tt, $self:expr, $input:expr, $start:ident, $err:expr, $head:ident $($id:ident)+) => ({
-    $input.reset($start.clone());
+    $input.reset(&$start);
     match $self.$it.parse_next($input) {
       Err(ErrMode::Backtrack(e)) => {
         let err = $err.or(e);
@@ -214,14 +214,14 @@ macro_rules! alt_trait_inner(
     }
   });
   ($it:tt, $self:expr, $input:expr, $start:ident, $err:expr, $head:ident) => ({
-    Err(ErrMode::Backtrack($err.append($input, ErrorKind::Alt)))
+    Err(ErrMode::Backtrack($err.append($input, &$start, ErrorKind::Alt)))
   });
 );
 
 alt_trait!(Alt2 Alt3 Alt4 Alt5 Alt6 Alt7 Alt8 Alt9 Alt10 Alt11 Alt12 Alt13 Alt14 Alt15 Alt16 Alt17 Alt18 Alt19 Alt20 Alt21 Alt22);
 
 // Manually implement Alt for (A,), the 1-tuple type
-impl<I, O, E: ParserError<I>, A: Parser<I, O, E>> Alt<I, O, E> for (A,) {
+impl<I: Stream, O, E: ParserError<I>, A: Parser<I, O, E>> Alt<I, O, E> for (A,) {
     fn choice(&mut self, input: &mut I) -> PResult<O, E> {
         self.0.parse_next(input)
     }
@@ -266,8 +266,8 @@ macro_rules! permutation_trait_impl(
           // or errored on the remaining input
           if let Some(err) = err {
             // There are remaining parsers, and all errored on the remaining input
-            input.reset(start.clone());
-            return Err(ErrMode::Backtrack(err.append(input, ErrorKind::Alt)));
+            input.reset(&start);
+            return Err(ErrMode::Backtrack(err.append(input, &start, ErrorKind::Alt)));
           }
 
           // All parsers were applied
@@ -284,7 +284,7 @@ macro_rules! permutation_trait_impl(
 macro_rules! permutation_trait_inner(
   ($it:tt, $self:expr, $input:ident, $start:ident, $res:expr, $err:expr, $head:ident $($id:ident)*) => (
     if $res.$it.is_none() {
-      $input.reset($start.clone());
+      $input.reset(&$start);
       match $self.$it.parse_next($input) {
         Ok(o) => {
           $res.$it = Some(o);

diff --git a/src/combinator/core.rs b/src/combinator/core.rs
@@ -79,7 +79,7 @@ where
         match f.parse_next(input) {
             Ok(o) => Ok(Some(o)),
             Err(ErrMode::Backtrack(_)) => {
-                input.reset(start);
+                input.reset(&start);
                 Ok(None)
             }
             Err(e) => Err(e),
@@ -148,7 +148,7 @@ where
     trace("peek", move |input: &mut I| {
         let start = input.checkpoint();
         let res = f.parse_next(input);
-        input.reset(start);
+        input.reset(&start);
         res
     })
 }
@@ -211,7 +211,7 @@ where
     trace("not", move |input: &mut I| {
         let start = input.checkpoint();
         let res = parser.parse_next(input);
-        input.reset(start);
+        input.reset(&start);
         match res {
             Ok(_) => Err(ErrMode::from_error_kind(input, ErrorKind::Not)),
             Err(ErrMode::Backtrack(_)) => Ok(()),
@@ -408,7 +408,7 @@ where
                     Some(o)
                 }
                 Err(ErrMode::Backtrack(_)) => {
-                    self.input.reset(start);
+                    self.input.reset(&start);
                     self.state = Some(State::Done);
                     None
                 }