Remove From<winnow> for (small) step towards stable API

Author: epage

gix-object/src/commit/mod.rs

@@ -59,7 +59,7 @@ 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(&mut data).map_err(crate::decode::Error::from)
+        decode::commit(&mut data).map_err(crate::decode::Error::with_err)
     }
 }
 

gix-object/src/commit/ref_iter.rs

@@ -151,7 +151,15 @@ fn missing_field() -> crate::decode::Error {
 }
 
 impl<'a> CommitRefIter<'a> {
-    fn next_inner(mut i: &'a [u8], state: &mut State) -> Result<(&'a [u8], Token<'a>), crate::decode::Error> {
+    #[inline]
+    fn next_inner(i: &'a [u8], state: &mut State) -> Result<(&'a [u8], Token<'a>), crate::decode::Error> {
+        Self::next_inner_(i, state).map_err(crate::decode::Error::with_err)
+    }
+
+    fn next_inner_(
+        mut i: &'a [u8],
+        state: &mut State,
+    ) -> Result<(&'a [u8], Token<'a>), winnow::error::ErrMode<crate::decode::ParseError>> {
         use State::*;
         Ok(match state {
             Tree => {
@@ -181,7 +189,7 @@ impl<'a> CommitRefIter<'a> {
                         *state = State::Signature {
                             of: SignatureKind::Author,
                         };
-                        return Self::next_inner(i, state);
+                        return Self::next_inner_(i, state);
                     }
                 }
             }
@@ -215,7 +223,7 @@ impl<'a> CommitRefIter<'a> {
                 *state = State::ExtraHeaders;
                 match encoding {
                     Some(encoding) => (i, Token::Encoding(encoding.as_bstr())),
-                    None => return Self::next_inner(i, state),
+                    None => return Self::next_inner_(i, state),
                 }
             }
             ExtraHeaders => {
@@ -232,7 +240,7 @@ impl<'a> CommitRefIter<'a> {
                     Some(extra_header) => (i, Token::ExtraHeader(extra_header)),
                     None => {
                         *state = State::Message;
-                        return Self::next_inner(i, state);
+                        return Self::next_inner_(i, state);
                     }
                 }
             }

gix-object/src/lib.rs

@@ -274,10 +274,10 @@ pub mod decode {
             pub inner: ParseError,
         }
 
-        impl From<winnow::error::ErrMode<ParseError>> for Error {
-            fn from(v: winnow::error::ErrMode<ParseError>) -> Self {
-                Error {
-                    inner: v.into_inner().expect("we don't have streaming parsers"),
+        impl Error {
+            pub(crate) fn with_err(err: winnow::error::ErrMode<ParseError>) -> Self {
+                Self {
+                    inner: err.into_inner().expect("we don't have streaming parsers"),
                 }
             }
         }
@@ -306,10 +306,10 @@ pub mod decode {
             pub inner: ParseError,
         }
 
-        impl From<winnow::error::ErrMode<ParseError>> for Error {
-            fn from(v: winnow::error::ErrMode<ParseError>) -> Self {
-                Error {
-                    inner: v.into_inner().expect("we don't have streaming parsers"),
+        impl Error {
+            pub(crate) fn with_err(err: winnow::error::ErrMode<ParseError>) -> Self {
+                Self {
+                    inner: err.into_inner().expect("we don't have streaming parsers"),
                 }
             }
         }

gix-object/src/tag/mod.rs

@@ -11,7 +11,7 @@ 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(&mut data).map_err(crate::decode::Error::from)
+        decode::git_tag(&mut data).map_err(crate::decode::Error::with_err)
     }
     /// The object this tag points to as `Id`.
     pub fn target(&self) -> gix_hash::ObjectId {

gix-object/src/tag/ref_iter.rs

@@ -60,7 +60,15 @@ fn missing_field() -> crate::decode::Error {
 }
 
 impl<'a> TagRefIter<'a> {
-    fn next_inner(mut i: &'a [u8], state: &mut State) -> Result<(&'a [u8], Token<'a>), crate::decode::Error> {
+    #[inline]
+    fn next_inner(i: &'a [u8], state: &mut State) -> Result<(&'a [u8], Token<'a>), crate::decode::Error> {
+        Self::next_inner_(i, state).map_err(crate::decode::Error::with_err)
+    }
+
+    fn next_inner_(
+        mut i: &'a [u8],
+        state: &mut State,
+    ) -> Result<(&'a [u8], Token<'a>), winnow::error::ErrMode<crate::decode::ParseError>> {
         use State::*;
         Ok(match state {
             Target => {

gix-object/src/tree/ref_iter.rs

@@ -15,7 +15,7 @@ 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(&mut data).map_err(crate::decode::Error::from)
+        decode::tree(&mut data).map_err(crate::decode::Error::with_err)
     }
 
     /// Find an entry named `name` knowing if the entry is a directory or not, using a binary search.
@@ -70,11 +70,9 @@ impl<'a> Iterator for TreeRefIter<'a> {
                 self.data = &[];
                 let empty = &[] as &[u8];
                 #[allow(clippy::unit_arg)]
-                Some(Err(winnow::error::ErrMode::from_error_kind(
-                    &empty,
-                    winnow::error::ErrorKind::Verify,
-                )
-                .into()))
+                Some(Err(crate::decode::Error::with_err(
+                    winnow::error::ErrMode::from_error_kind(&empty, winnow::error::ErrorKind::Verify),
+                )))
             }
         }
     }