fix(stream)!: Dont return input on peek_slice

src/stream/bstr.rs

@@ -107,6 +107,11 @@ impl<'i> Stream for &'i BStr {
         *self = BStr::from_bytes(next);
         slice
     }
+    #[inline(always)]
+    fn peek_slice(&self, offset: usize) -> Self::Slice {
+        let (slice, _next) = self.split_at(offset);
+        slice
+    }
 
     #[inline(always)]
     fn checkpoint(&self) -> Self::Checkpoint {

src/stream/bytes.rs

@@ -107,6 +107,11 @@ impl<'i> Stream for &'i Bytes {
         *self = Bytes::from_bytes(next);
         slice
     }
+    #[inline(always)]
+    fn peek_slice(&self, offset: usize) -> Self::Slice {
+        let (slice, _next) = self.split_at(offset);
+        slice
+    }
 
     #[inline(always)]
     fn checkpoint(&self) -> Self::Checkpoint {

src/stream/locating.rs

@@ -148,6 +148,10 @@ impl<I: Stream> Stream for LocatingSlice<I> {
     fn next_slice(&mut self, offset: usize) -> Self::Slice {
         self.input.next_slice(offset)
     }
+    #[inline(always)]
+    fn peek_slice(&self, offset: usize) -> Self::Slice {
+        self.input.peek_slice(offset)
+    }
 
     #[inline(always)]
     fn checkpoint(&self) -> Self::Checkpoint {

src/stream/mod.rs

@@ -187,15 +187,7 @@ pub trait Stream: Offset<<Self as Stream>::Checkpoint> + crate::lib::std::fmt::D
     ///
     fn next_slice(&mut self, offset: usize) -> Self::Slice;
     /// Split off a slice of tokens from the input
-    #[inline(always)]
-    fn peek_slice(&self, offset: usize) -> (Self, Self::Slice)
-    where
-        Self: Clone,
-    {
-        let mut peek = self.clone();
-        let slice = peek.next_slice(offset);
-        (peek, slice)
-    }
+    fn peek_slice(&self, offset: usize) -> Self::Slice;
 
     /// Advance to the end of the stream
     #[inline(always)]
@@ -208,7 +200,7 @@ pub trait Stream: Offset<<Self as Stream>::Checkpoint> + crate::lib::std::fmt::D
     where
         Self: Clone,
     {
-        self.peek_slice(self.eof_offset()).1
+        self.peek_slice(self.eof_offset())
     }
 
     /// Save the current parse location within the stream
@@ -281,6 +273,11 @@ where
         *self = next;
         slice
     }
+    #[inline(always)]
+    fn peek_slice(&self, offset: usize) -> Self::Slice {
+        let (slice, _next) = self.split_at(offset);
+        slice
+    }
 
     #[inline(always)]
     fn checkpoint(&self) -> Self::Checkpoint {
@@ -361,6 +358,11 @@ impl<'i> Stream for &'i str {
         *self = next;
         slice
     }
+    #[inline(always)]
+    fn peek_slice(&self, offset: usize) -> Self::Slice {
+        let (slice, _next) = self.split_at(offset);
+        slice
+    }
 
     #[inline(always)]
     fn checkpoint(&self) -> Self::Checkpoint {
@@ -443,6 +445,14 @@ where
         self.1 = end_offset;
         (s, start_offset, end_offset)
     }
+    #[inline(always)]
+    fn peek_slice(&self, offset: usize) -> Self::Slice {
+        let byte_offset = (offset + self.1) / 8;
+        let end_offset = (offset + self.1) % 8;
+        let s = self.0.peek_slice(byte_offset);
+        let start_offset = self.1;
+        (s, start_offset, end_offset)
+    }
 
     #[inline(always)]
     fn checkpoint(&self) -> Self::Checkpoint {

src/stream/partial.rs

@@ -185,6 +185,10 @@ impl<I: Stream> Stream for Partial<I> {
     fn next_slice(&mut self, offset: usize) -> Self::Slice {
         self.input.next_slice(offset)
     }
+    #[inline(always)]
+    fn peek_slice(&self, offset: usize) -> Self::Slice {
+        self.input.peek_slice(offset)
+    }
 
     #[inline(always)]
     fn checkpoint(&self) -> Self::Checkpoint {

src/stream/recoverable.rs

@@ -158,6 +158,10 @@ where
     fn next_slice(&mut self, offset: usize) -> Self::Slice {
         self.input.next_slice(offset)
     }
+    #[inline(always)]
+    fn peek_slice(&self, offset: usize) -> Self::Slice {
+        self.input.peek_slice(offset)
+    }
 
     #[inline(always)]
     fn checkpoint(&self) -> Self::Checkpoint {

src/stream/stateful.rs

@@ -136,6 +136,10 @@ impl<I: Stream, S: crate::lib::std::fmt::Debug> Stream for Stateful<I, S> {
     fn next_slice(&mut self, offset: usize) -> Self::Slice {
         self.input.next_slice(offset)
     }
+    #[inline(always)]
+    fn peek_slice(&self, offset: usize) -> Self::Slice {
+        self.input.peek_slice(offset)
+    }
 
     #[inline(always)]
     fn checkpoint(&self) -> Self::Checkpoint {

src/stream/tests.rs

@@ -67,8 +67,7 @@ fn test_bit_stream_empty() {
     let actual = i.offset_at(1);
     assert_eq!(actual, Err(Needed::new(1)));
 
-    let (actual_input, actual_slice) = i.peek_slice(0);
-    assert_eq!(actual_input, (&b""[..], 0));
+    let actual_slice = i.peek_slice(0);
     assert_eq!(actual_slice, (&b""[..], 0, 0));
 }
 
@@ -105,15 +104,15 @@ fn bit_stream_inner(byte_len: usize, start: usize) {
         let to_offset = curr_i.offset_from(&i);
         assert_eq!(curr_offset, to_offset);
 
-        let (slice_i, _) = i.peek_slice(curr_offset);
-        assert_eq!(curr_i, slice_i);
+        let actual_slice = i.peek_slice(curr_offset);
+        let expected_slice = i.clone().peek_slice(curr_offset);
+        assert_eq!(actual_slice, expected_slice);
 
         let at_offset = i.offset_at(curr_offset).unwrap();
         assert_eq!(curr_offset, at_offset);
 
         let eof_offset = curr_i.eof_offset();
-        let (next_eof_i, eof_slice) = curr_i.peek_slice(eof_offset);
-        assert_eq!(next_eof_i, (&b""[..], 0));
+        let eof_slice = curr_i.peek_slice(eof_offset);
         let eof_slice_i = (eof_slice.0, eof_slice.1);
         assert_eq!(eof_slice_i, curr_i);