Refactor Errors to track remaining Input

Author: epage

gix-object/src/commit/mod.rs

@@ -61,9 +61,11 @@ mod write;
 impl<'a> CommitRef<'a> {
     /// Deserialize a commit from the given `data` bytes while avoiding most allocations.
     pub fn from_bytes(mut data: &'a [u8]) -> Result<CommitRef<'a>, crate::decode::Error> {
-        decode::commit
-            .parse_next(&mut data)
-            .map_err(crate::decode::Error::with_err)
+        let input = &mut data;
+        match decode::commit.parse_next(input) {
+            Ok(tag) => Ok(tag),
+            Err(err) => Err(crate::decode::Error::with_err(err, input)),
+        }
     }
 }
 

gix-object/src/commit/ref_iter.rs

@@ -156,8 +156,10 @@ impl<'a> CommitRefIter<'a> {
     #[inline]
     fn next_inner(mut i: &'a [u8], state: &mut State) -> Result<(&'a [u8], Token<'a>), crate::decode::Error> {
         let input = &mut i;
-        let token = Self::next_inner_(input, state).map_err(crate::decode::Error::with_err)?;
-        Ok((input, token))
+        match Self::next_inner_(input, state) {
+            Ok(token) => Ok((*input, token)),
+            Err(err) => Err(crate::decode::Error::with_err(err, input)),
+        }
     }
 
     fn next_inner_(

gix-object/src/lib.rs

@@ -267,6 +267,7 @@ pub mod decode {
         pub(crate) fn empty_error() -> Error {
             Error {
                 inner: winnow::error::ContextError::new(),
+                remaining: Default::default(),
             }
         }
 
@@ -275,12 +276,15 @@ pub mod decode {
         pub struct Error {
             /// The actual error
             pub inner: ParseError,
+            /// Where the error occurred
+            pub remaining: Vec<u8>,
         }
 
         impl Error {
-            pub(crate) fn with_err(err: winnow::error::ErrMode<ParseError>) -> Self {
+            pub(crate) fn with_err(err: winnow::error::ErrMode<ParseError>, remaining: &[u8]) -> Self {
                 Self {
                     inner: err.into_inner().expect("we don't have streaming parsers"),
+                    remaining: remaining.to_owned(),
                 }
             }
         }
@@ -316,7 +320,7 @@ pub mod decode {
         }
 
         impl Error {
-            pub(crate) fn with_err(err: winnow::error::ErrMode<ParseError>) -> Self {
+            pub(crate) fn with_err(err: winnow::error::ErrMode<ParseError>, _remaining: &[u8]) -> Self {
                 Self {
                     inner: err.into_inner().expect("we don't have streaming parsers"),
                 }

gix-object/src/tag/mod.rs

@@ -13,9 +13,11 @@ pub mod ref_iter;
 impl<'a> TagRef<'a> {
     /// Deserialize a tag from `data`.
     pub fn from_bytes(mut data: &'a [u8]) -> Result<TagRef<'a>, crate::decode::Error> {
-        decode::git_tag
-            .parse_next(&mut data)
-            .map_err(crate::decode::Error::with_err)
+        let input = &mut data;
+        match decode::git_tag.parse_next(input) {
+            Ok(tag) => Ok(tag),
+            Err(err) => Err(crate::decode::Error::with_err(err, input)),
+        }
     }
     /// The object this tag points to as `Id`.
     pub fn target(&self) -> gix_hash::ObjectId {

gix-object/src/tag/ref_iter.rs

@@ -61,8 +61,10 @@ impl<'a> TagRefIter<'a> {
     #[inline]
     fn next_inner(mut i: &'a [u8], state: &mut State) -> Result<(&'a [u8], Token<'a>), crate::decode::Error> {
         let input = &mut i;
-        let token = Self::next_inner_(input, state).map_err(crate::decode::Error::with_err)?;
-        Ok((input, token))
+        match Self::next_inner_(input, state) {
+            Ok(token) => Ok((*input, token)),
+            Err(err) => Err(crate::decode::Error::with_err(err, input)),
+        }
     }
 
     fn next_inner_(

gix-object/src/tree/ref_iter.rs

@@ -16,9 +16,11 @@ impl<'a> TreeRefIter<'a> {
 impl<'a> TreeRef<'a> {
     /// Deserialize a Tree from `data`.
     pub fn from_bytes(mut data: &'a [u8]) -> Result<TreeRef<'a>, crate::decode::Error> {
-        decode::tree
-            .parse_next(&mut data)
-            .map_err(crate::decode::Error::with_err)
+        let input = &mut data;
+        match decode::tree.parse_next(input) {
+            Ok(tag) => Ok(tag),
+            Err(err) => Err(crate::decode::Error::with_err(err, input)),
+        }
     }
 
     /// Find an entry named `name` knowing if the entry is a directory or not, using a binary search.
@@ -75,6 +77,7 @@ impl<'a> Iterator for TreeRefIter<'a> {
                 #[allow(clippy::unit_arg)]
                 Some(Err(crate::decode::Error::with_err(
                     winnow::error::ErrMode::from_error_kind(&failing, winnow::error::ErrorKind::Verify),
+                    failing,
                 )))
             }
         }