Merge pull request #274 from epage/p1

feat(stream)!: Allow mutable iteration
winnow-rs · Jul 6, 2023 · 0625541 · 0625541
2 parents 6747a8d + 3ab6ce3
commit 0625541
Show file tree

Hide file tree

Showing 12 changed files with 146 additions and 145 deletions.
diff --git a/proptest-regressions/stream/tests.txt b/proptest-regressions/stream/tests.txt
@@ -0,0 +1,7 @@
+# Seeds for failure cases proptest has generated in the past. It is
+# automatically read and these particular cases re-run before any
+# novel cases are generated.
+#
+# It is recommended to check this file in to source control so that
+# everyone who runs the test benefits from these saved cases.
+cc dd80dcf3d84999d176d263e5de7ab8bd3c9b7d0b24fa74cb6004556677665b72 # shrinks to byte_len = 11, start = 0
diff --git a/src/ascii/mod.rs b/src/ascii/mod.rs
@@ -124,9 +124,9 @@ where
         c == '\r' || c == '\n'
     }) {
         None if PARTIAL && input.is_partial() => Err(ErrMode::Incomplete(Needed::Unknown)),
-        None => Ok(input.finish()),
+        None => Ok(input.peek_finish()),
         Some(offset) => {
-            let (new_input, res) = input.next_slice(offset);
+            let (new_input, res) = input.peek_slice(offset);
             let bytes = new_input.as_bstr();
             let nth = bytes[0];
             if nth == b'\r' {
@@ -935,7 +935,7 @@ where
                     if offset == 0 {
                         return Err(ErrMode::from_error_kind(input, ErrorKind::Slice));
                     } else {
-                        return Ok((input.next_slice(offset).0, value));
+                        return Ok((input.peek_slice(offset).0, value));
                     }
                 }
             }
@@ -944,7 +944,7 @@ where
         if <I as StreamIsPartial>::is_partial_supported() && input.is_partial() {
             Err(ErrMode::Incomplete(Needed::new(1)))
         } else {
-            Ok((input.finish().0, value))
+            Ok((input.peek_finish().0, value))
         }
     })
     .parse_next(input)
@@ -1100,7 +1100,7 @@ where
                     if offset == 0 {
                         return Err(ErrMode::from_error_kind(input, ErrorKind::Slice));
                     } else {
-                        return Ok((input.next_slice(offset).0, value));
+                        return Ok((input.peek_slice(offset).0, value));
                     }
                 }
             }
@@ -1109,7 +1109,7 @@ where
         if <I as StreamIsPartial>::is_partial_supported() && input.is_partial() {
             Err(ErrMode::Incomplete(Needed::new(1)))
         } else {
-            Ok((input.finish().0, value))
+            Ok((input.peek_finish().0, value))
         }
     })
     .parse_next(input)
@@ -1232,7 +1232,7 @@ where
             // Must be at least one digit
             return Err(ErrMode::from_error_kind(input, ErrorKind::Slice));
         }
-        let (remaining, parsed) = input.next_slice(offset);
+        let (remaining, parsed) = input.peek_slice(offset);
 
         let mut res = O::default();
         for c in parsed.as_bstr() {
@@ -1482,15 +1482,15 @@ where
                 } else if i2.eof_offset() == current_len {
                     let offset = i2.offset_from(&start);
                     input.reset(start);
-                    return Ok(input.next_slice(offset));
+                    return Ok(input.peek_slice(offset));
                 } else {
                     input = i2;
                 }
             }
             Err(ErrMode::Backtrack(_)) => {
-                if input.next_token().expect("eof_offset > 0").1.as_char() == control_char {
+                if input.peek_token().expect("eof_offset > 0").1.as_char() == control_char {
                     let next = control_char.len_utf8();
-                    let (i2, _) = escapable.parse_next(input.next_slice(next).0)?;
+                    let (i2, _) = escapable.parse_next(input.peek_slice(next).0)?;
                     if i2.eof_offset() == 0 {
                         return Err(ErrMode::Incomplete(Needed::Unknown));
                     } else {
@@ -1499,7 +1499,7 @@ where
                 } else {
                     let offset = input.offset_from(&start);
                     input.reset(start);
-                    return Ok(input.next_slice(offset));
+                    return Ok(input.peek_slice(offset));
                 }
             }
             Err(e) => {
@@ -1536,29 +1536,29 @@ where
                 // does not consume anything
                 if i2.eof_offset() == 0 {
                     input.reset(start);
-                    return Ok(input.finish());
+                    return Ok(input.peek_finish());
                 } else if i2.eof_offset() == current_len {
                     let offset = i2.offset_from(&start);
                     input.reset(start);
-                    return Ok(input.next_slice(offset));
+                    return Ok(input.peek_slice(offset));
                 } else {
                     input = i2;
                 }
             }
             Err(ErrMode::Backtrack(_)) => {
-                if input.next_token().expect("eof_offset > 0").1.as_char() == control_char {
+                if input.peek_token().expect("eof_offset > 0").1.as_char() == control_char {
                     let next = control_char.len_utf8();
-                    let (i2, _) = escapable.parse_next(input.next_slice(next).0)?;
+                    let (i2, _) = escapable.parse_next(input.peek_slice(next).0)?;
                     if i2.eof_offset() == 0 {
                         input.reset(start);
-                        return Ok(input.finish());
+                        return Ok(input.peek_finish());
                     } else {
                         input = i2;
                     }
                 } else {
                     let offset = input.offset_from(&start);
                     input.reset(start);
-                    return Ok(input.next_slice(offset));
+                    return Ok(input.peek_slice(offset));
                 }
             }
             Err(e) => {
@@ -1567,7 +1567,7 @@ where
         }
     }
 
-    Ok(input.finish())
+    Ok(input.peek_finish())
 }
 
 /// Matches a byte string with escaped characters.
@@ -1684,9 +1684,9 @@ where
                 }
             }
             Err(ErrMode::Backtrack(_)) => {
-                if input.next_token().expect("eof_offset > 0").1.as_char() == control_char {
+                if input.peek_token().expect("eof_offset > 0").1.as_char() == control_char {
                     let next = control_char.len_utf8();
-                    let (i2, o) = transform.parse_next(input.next_slice(next).0)?;
+                    let (i2, o) = transform.parse_next(input.peek_slice(next).0)?;
                     res.accumulate(o);
                     if i2.eof_offset() == 0 {
                         return Err(ErrMode::Incomplete(Needed::Unknown));
@@ -1727,20 +1727,20 @@ where
             Ok((i2, o)) => {
                 res.accumulate(o);
                 if i2.eof_offset() == 0 {
-                    return Ok((input.finish().0, res));
+                    return Ok((input.peek_finish().0, res));
                 } else if i2.eof_offset() == current_len {
                     return Ok((input, res));
                 } else {
                     input = i2;
                 }
             }
             Err(ErrMode::Backtrack(_)) => {
-                if input.next_token().expect("eof_offset > 0").1.as_char() == control_char {
+                if input.peek_token().expect("eof_offset > 0").1.as_char() == control_char {
                     let next = control_char.len_utf8();
-                    let (i2, o) = transform.parse_next(input.next_slice(next).0)?;
+                    let (i2, o) = transform.parse_next(input.peek_slice(next).0)?;
                     res.accumulate(o);
                     if i2.eof_offset() == 0 {
-                        return Ok((input.finish().0, res));
+                        return Ok((input.peek_finish().0, res));
                     } else {
                         input = i2;
                     }

diff --git a/src/binary/bits/mod.rs b/src/binary/bits/mod.rs
@@ -57,7 +57,7 @@ where
                 // The parser functions might already slice away all fully read bytes.
                 // That's why `offset / 8` isn't necessarily needed at all times.
                 let remaining_bytes_index = offset / 8 + if offset % 8 == 0 { 0 } else { 1 };
-                let (input, _) = rest.next_slice(remaining_bytes_index);
+                let (input, _) = rest.peek_slice(remaining_bytes_index);
                 Ok((input, result))
             }
             Err(ErrMode::Incomplete(n)) => Err(ErrMode::Incomplete(n.map(|u| u.get() / 8 + 1))),
@@ -105,9 +105,9 @@ where
 {
     trace("bytes", move |(input, offset): (I, usize)| {
         let (inner, _) = if offset % 8 != 0 {
-            input.next_slice(1 + offset / 8)
+            input.peek_slice(1 + offset / 8)
         } else {
-            input.next_slice(offset / 8)
+            input.peek_slice(offset / 8)
         };
         let i = (input, offset);
         match parser.parse_next(inner) {
@@ -221,7 +221,7 @@ where
                     offset = 0;
                 }
             }
-            let (input, _) = input.next_slice(cnt);
+            let (input, _) = input.peek_slice(cnt);
             Ok(((input, end_offset), acc))
         }
     }

diff --git a/src/binary/mod.rs b/src/binary/mod.rs
@@ -1266,7 +1266,7 @@ where
     I: StreamIsPartial,
     I: Stream<Token = u8>,
 {
-    input.next_token().ok_or_else(|| {
+    input.peek_token().ok_or_else(|| {
         if PARTIAL && input.is_partial() {
             ErrMode::Incomplete(Needed::new(1))
         } else {

diff --git a/src/combinator/core.rs b/src/combinator/core.rs
@@ -19,7 +19,7 @@ pub fn rest<I, E: ParseError<I>>(input: I) -> IResult<I, <I as Stream>::Slice, E
 where
     I: Stream,
 {
-    trace("rest", move |input: I| Ok(input.finish())).parse_next(input)
+    trace("rest", move |input: I| Ok(input.peek_finish())).parse_next(input)
 }
 
 /// Return the length of the remaining input.
@@ -176,7 +176,7 @@ where
 {
     trace("eof", move |input: I| {
         if input.eof_offset() == 0 {
-            Ok(input.next_slice(0))
+            Ok(input.peek_slice(0))
         } else {
             Err(ErrMode::from_error_kind(input, ErrorKind::Eof))
         }

diff --git a/src/combinator/parser.rs b/src/combinator/parser.rs
@@ -542,7 +542,7 @@ where
             Ok((mut input, _)) => {
                 let offset = input.offset_from(&checkpoint);
                 input.reset(checkpoint);
-                let (input, recognized) = input.next_slice(offset);
+                let (input, recognized) = input.peek_slice(offset);
                 Ok((input, recognized))
             }
             Err(e) => Err(e),
@@ -589,7 +589,7 @@ where
             Ok((mut input, result)) => {
                 let offset = input.offset_from(&checkpoint);
                 input.reset(checkpoint);
-                let (input, recognized) = input.next_slice(offset);
+                let (input, recognized) = input.peek_slice(offset);
                 Ok((input, (result, recognized)))
             }
             Err(e) => Err(e),

diff --git a/src/combinator/tests.rs b/src/combinator/tests.rs
@@ -561,7 +561,7 @@ fn alt_test() {
     }
 
     fn work(input: &[u8]) -> IResult<&[u8], &[u8], ErrorStr> {
-        Ok(input.finish())
+        Ok(input.peek_finish())
     }
 
     #[allow(unused_variables)]

diff --git a/src/parser.rs b/src/parser.rs
@@ -284,7 +284,7 @@ pub trait Parser<I, O, E> {
     /// let mut parser = separated_pair(alpha1.span(), ',', alpha1.span());
     ///
     /// assert_eq!(parser.parse(Located::new("abcd,efgh")), Ok((0..4, 5..9)));
-    /// assert_eq!(parser.parse_next(Located::new("abcd;")),Err(ErrMode::Backtrack(Error::new(Located::new("abcd;").next_slice(4).0, ErrorKind::Verify))));
+    /// assert_eq!(parser.parse_next(Located::new("abcd;")),Err(ErrMode::Backtrack(Error::new(Located::new("abcd;").peek_slice(4).0, ErrorKind::Verify))));
     /// ```
     fn span(self) -> Span<Self, I, O, E>
     where
@@ -323,7 +323,7 @@ pub trait Parser<I, O, E> {
     /// let mut consumed_parser = separated_pair(alpha1.value(1).with_span(), ',', alpha1.value(2).with_span());
     ///
     /// assert_eq!(consumed_parser.parse(Located::new("abcd,efgh")), Ok(((1, 0..4), (2, 5..9))));
-    /// assert_eq!(consumed_parser.parse_next(Located::new("abcd;")),Err(ErrMode::Backtrack(Error::new(Located::new("abcd;").next_slice(4).0, ErrorKind::Verify))));
+    /// assert_eq!(consumed_parser.parse_next(Located::new("abcd;")),Err(ErrMode::Backtrack(Error::new(Located::new("abcd;").peek_slice(4).0, ErrorKind::Verify))));
     ///
     /// // the second output (representing the consumed input)
     /// // should be the same as that of the `span` parser.