1 files changed, 34 insertions, 39 deletions

diff --git a/vendor/gix-object/src/commit/ref_iter.rs b/vendor/gix-object/src/commit/ref_iter.rs
index 4401384ca..6f5604f2c 100644
--- a/vendor/gix-object/src/commit/ref_iter.rs
+++ b/vendor/gix-object/src/commit/ref_iter.rs
@@ -6,7 +6,7 @@ use winnow::{
     combinator::{alt, eof, opt, terminated},
     error::StrContext,
     prelude::*,
-    token::take_till1,
+    token::take_till,
 };
 
 use crate::{
@@ -154,44 +154,42 @@ fn missing_field() -> crate::decode::Error {
 
 impl<'a> CommitRefIter<'a> {
     #[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>), crate::decode::Error> {
+        let input = &mut i;
+        match Self::next_inner_(input, state) {
+            Ok(token) => Ok((*input, token)),
+            Err(err) => Err(crate::decode::Error::with_err(err, input)),
+        }
     }
 
     fn next_inner_(
-        mut i: &'a [u8],
+        input: &mut &'a [u8],
         state: &mut State,
-    ) -> Result<(&'a [u8], Token<'a>), winnow::error::ErrMode<crate::decode::ParseError>> {
+    ) -> Result<Token<'a>, winnow::error::ErrMode<crate::decode::ParseError>> {
         use State::*;
         Ok(match state {
             Tree => {
                 let tree = (|i: &mut _| parse::header_field(i, b"tree", parse::hex_hash))
                     .context(StrContext::Expected("tree <40 lowercase hex char>".into()))
-                    .parse_next(&mut i)?;
+                    .parse_next(input)?;
                 *state = State::Parents;
-                (
-                    i,
-                    Token::Tree {
-                        id: ObjectId::from_hex(tree).expect("parsing validation"),
-                    },
-                )
+                Token::Tree {
+                    id: ObjectId::from_hex(tree).expect("parsing validation"),
+                }
             }
             Parents => {
                 let parent = opt(|i: &mut _| parse::header_field(i, b"parent", parse::hex_hash))
                     .context(StrContext::Expected("commit <40 lowercase hex char>".into()))
-                    .parse_next(&mut i)?;
+                    .parse_next(input)?;
                 match parent {
-                    Some(parent) => (
-                        i,
-                        Token::Parent {
-                            id: ObjectId::from_hex(parent).expect("parsing validation"),
-                        },
-                    ),
+                    Some(parent) => Token::Parent {
+                        id: ObjectId::from_hex(parent).expect("parsing validation"),
+                    },
                     None => {
                         *state = State::Signature {
                             of: SignatureKind::Author,
                         };
-                        return Self::next_inner_(i, state);
+                        Self::next_inner_(input, state)?
                     }
                 }
             }
@@ -209,50 +207,47 @@ impl<'a> CommitRefIter<'a> {
                 };
                 let signature = (|i: &mut _| parse::header_field(i, field_name, parse::signature))
                     .context(StrContext::Expected(err_msg.into()))
-                    .parse_next(&mut i)?;
-                (
-                    i,
-                    match who {
-                        SignatureKind::Author => Token::Author { signature },
-                        SignatureKind::Committer => Token::Committer { signature },
-                    },
-                )
+                    .parse_next(input)?;
+                match who {
+                    SignatureKind::Author => Token::Author { signature },
+                    SignatureKind::Committer => Token::Committer { signature },
+                }
             }
             Encoding => {
-                let encoding = opt(|i: &mut _| parse::header_field(i, b"encoding", take_till1(NL)))
+                let encoding = opt(|i: &mut _| parse::header_field(i, b"encoding", take_till(1.., NL)))
                     .context(StrContext::Expected("encoding <encoding>".into()))
-                    .parse_next(&mut i)?;
+                    .parse_next(input)?;
                 *state = State::ExtraHeaders;
                 match encoding {
-                    Some(encoding) => (i, Token::Encoding(encoding.as_bstr())),
-                    None => return Self::next_inner_(i, state),
+                    Some(encoding) => Token::Encoding(encoding.as_bstr()),
+                    None => Self::next_inner_(input, state)?,
                 }
             }
             ExtraHeaders => {
                 let extra_header = opt(alt((
                     |i: &mut _| parse::any_header_field_multi_line(i).map(|(k, o)| (k.as_bstr(), Cow::Owned(o))),
                     |i: &mut _| {
-                        parse::any_header_field(i, take_till1(NL))
+                        parse::any_header_field(i, take_till(1.., NL))
                             .map(|(k, o)| (k.as_bstr(), Cow::Borrowed(o.as_bstr())))
                     },
                 )))
                 .context(StrContext::Expected("<field> <single-line|multi-line>".into()))
-                .parse_next(&mut i)?;
+                .parse_next(input)?;
                 match extra_header {
-                    Some(extra_header) => (i, Token::ExtraHeader(extra_header)),
+                    Some(extra_header) => Token::ExtraHeader(extra_header),
                     None => {
                         *state = State::Message;
-                        return Self::next_inner_(i, state);
+                        Self::next_inner_(input, state)?
                     }
                 }
             }
             Message => {
-                let message = terminated(decode::message, eof).parse_next(&mut i)?;
+                let message = terminated(decode::message, eof).parse_next(input)?;
                 debug_assert!(
-                    i.is_empty(),
+                    input.is_empty(),
                     "we should have consumed all data - otherwise iter may go forever"
                 );
-                return Ok((i, Token::Message(message)));
+                Token::Message(message)
             }
         })
     }