Resolve Winnow deprecations

Author: epage

gix-actor/src/signature/decode.rs

@@ -3,7 +3,7 @@ pub(crate) mod function {
     use bstr::ByteSlice;
     use gix_date::{time::Sign, OffsetInSeconds, SecondsSinceUnixEpoch, Time};
     use gix_utils::btoi::to_signed;
-    use winnow::error::{ErrMode, ErrorKind};
+    use winnow::error::ErrMode;
     use winnow::stream::Stream;
     use winnow::{
         combinator::{alt, opt, separated_pair, terminated},
@@ -18,7 +18,7 @@ pub(crate) mod function {
     /// Parse a signature from the bytes input `i` using `nom`.
     pub fn decode<'a, E: ParserError<&'a [u8]> + AddContext<&'a [u8], StrContext>>(
         i: &mut &'a [u8],
-    ) -> PResult<SignatureRef<'a>, E> {
+    ) -> ModalResult<SignatureRef<'a>, E> {
         separated_pair(
             identity,
             opt(b" "),
@@ -68,31 +68,29 @@ pub(crate) mod function {
     /// Parse an identity from the bytes input `i` (like `name <email>`) using `nom`.
     pub fn identity<'a, E: ParserError<&'a [u8]> + AddContext<&'a [u8], StrContext>>(
         i: &mut &'a [u8],
-    ) -> PResult<IdentityRef<'a>, E> {
+    ) -> ModalResult<IdentityRef<'a>, E> {
         let start = i.checkpoint();
         let eol_idx = i.find_byte(b'\n').unwrap_or(i.len());
-        let right_delim_idx =
-            i[..eol_idx]
-                .rfind_byte(b'>')
-                .ok_or(ErrMode::Cut(E::from_error_kind(i, ErrorKind::Eof).add_context(
-                    i,
-                    &start,
-                    StrContext::Label("Closing '>' not found"),
-                )))?;
+        let right_delim_idx = i[..eol_idx]
+            .rfind_byte(b'>')
+            .ok_or(ErrMode::Cut(E::from_input(i).add_context(
+                i,
+                &start,
+                StrContext::Label("Closing '>' not found"),
+            )))?;
         let i_name_and_email = &i[..right_delim_idx];
         let skip_from_right = i_name_and_email
             .iter()
             .rev()
             .take_while(|b| b.is_ascii_whitespace() || **b == b'>')
             .count();
-        let left_delim_idx =
-            i_name_and_email
-                .find_byte(b'<')
-                .ok_or(ErrMode::Cut(E::from_error_kind(i, ErrorKind::Eof).add_context(
-                    &i_name_and_email,
-                    &start,
-                    StrContext::Label("Opening '<' not found"),
-                )))?;
+        let left_delim_idx = i_name_and_email
+            .find_byte(b'<')
+            .ok_or(ErrMode::Cut(E::from_input(i).add_context(
+                &i_name_and_email,
+                &start,
+                StrContext::Label("Opening '<' not found"),
+            )))?;
         let skip_from_left = i[left_delim_idx..]
             .iter()
             .take_while(|b| b.is_ascii_whitespace() || **b == b'<')
@@ -102,7 +100,7 @@ pub(crate) mod function {
 
         let email = i
             .get(left_delim_idx + skip_from_left..right_delim_idx - skip_from_right)
-            .ok_or(ErrMode::Cut(E::from_error_kind(i, ErrorKind::Eof).add_context(
+            .ok_or(ErrMode::Cut(E::from_input(i).add_context(
                 &i_name_and_email,
                 &start,
                 StrContext::Label("Skipped parts run into each other"),
@@ -126,7 +124,7 @@ mod tests {
 
         fn decode<'i>(
             i: &mut &'i [u8],
-        ) -> PResult<SignatureRef<'i>, winnow::error::TreeError<&'i [u8], winnow::error::StrContext>> {
+        ) -> ModalResult<SignatureRef<'i>, winnow::error::TreeError<&'i [u8], winnow::error::StrContext>> {
             signature::decode.parse_next(i)
         }
 

gix-config/src/parse/nom/mod.rs

@@ -3,7 +3,7 @@ use std::borrow::Cow;
 use bstr::{BStr, ByteSlice};
 use winnow::{
     combinator::{alt, delimited, opt, preceded, repeat},
-    error::{ErrorKind, InputError as NomError, ParserError as _},
+    error::{InputError as NomError, ParserError as _},
     prelude::*,
     stream::{Offset as _, Stream as _},
     token::{one_of, take_till, take_while},
@@ -78,7 +78,7 @@ fn newlines_from(input: &[u8], start: winnow::stream::Checkpoint<&[u8], &[u8]>)
     start_input.next_slice(offset).iter().filter(|c| **c == b'\n').count()
 }
 
-fn comment<'i>(i: &mut &'i [u8]) -> PResult<Comment<'i>, NomError<&'i [u8]>> {
+fn comment<'i>(i: &mut &'i [u8]) -> ModalResult<Comment<'i>, NomError<&'i [u8]>> {
     (
         one_of([';', '#']),
         take_till(0.., |c| c == b'\n').map(|text: &[u8]| Cow::Borrowed(text.as_bstr())),
@@ -94,7 +94,7 @@ fn section<'i>(
     i: &mut &'i [u8],
     node: &mut ParseNode,
     dispatch: &mut dyn FnMut(Event<'i>),
-) -> PResult<(), NomError<&'i [u8]>> {
+) -> ModalResult<(), NomError<&'i [u8]>> {
     let start = i.checkpoint();
     let header = section_header(i).map_err(|e| {
         i.reset(&start);
@@ -129,7 +129,7 @@ fn section<'i>(
     Ok(())
 }
 
-fn section_header<'i>(i: &mut &'i [u8]) -> PResult<section::Header<'i>, NomError<&'i [u8]>> {
+fn section_header<'i>(i: &mut &'i [u8]) -> ModalResult<section::Header<'i>, NomError<&'i [u8]>> {
     // No spaces must be between section name and section start
     let name = preceded('[', take_while(1.., is_section_char).map(bstr::ByteSlice::as_bstr)).parse_next(i)?;
 
@@ -150,7 +150,7 @@ fn section_header<'i>(i: &mut &'i [u8]) -> PResult<section::Header<'i>, NomError
         };
 
         if header.name.is_empty() {
-            return Err(winnow::error::ErrMode::from_error_kind(i, ErrorKind::Fail));
+            return Err(winnow::error::ErrMode::from_input(i));
         }
         return Ok(header);
     }
@@ -169,7 +169,7 @@ fn is_section_char(c: u8) -> bool {
     c.is_ascii_alphanumeric() || c == b'-' || c == b'.'
 }
 
-fn sub_section<'i>(i: &mut &'i [u8]) -> PResult<Cow<'i, BStr>, NomError<&'i [u8]>> {
+fn sub_section<'i>(i: &mut &'i [u8]) -> ModalResult<Cow<'i, BStr>, NomError<&'i [u8]>> {
     let mut output = Cow::Borrowed(Default::default());
     if let Some(sub) = opt(subsection_subset).parse_next(i)? {
         output = Cow::Borrowed(sub.as_bstr());
@@ -181,15 +181,15 @@ fn sub_section<'i>(i: &mut &'i [u8]) -> PResult<Cow<'i, BStr>, NomError<&'i [u8]
     Ok(output)
 }
 
-fn subsection_subset<'i>(i: &mut &'i [u8]) -> PResult<&'i [u8], NomError<&'i [u8]>> {
+fn subsection_subset<'i>(i: &mut &'i [u8]) -> ModalResult<&'i [u8], NomError<&'i [u8]>> {
     alt((subsection_unescaped, subsection_escaped_char)).parse_next(i)
 }
 
-fn subsection_unescaped<'i>(i: &mut &'i [u8]) -> PResult<&'i [u8], NomError<&'i [u8]>> {
+fn subsection_unescaped<'i>(i: &mut &'i [u8]) -> ModalResult<&'i [u8], NomError<&'i [u8]>> {
     take_while(1.., is_subsection_unescaped_char).parse_next(i)
 }
 
-fn subsection_escaped_char<'i>(i: &mut &'i [u8]) -> PResult<&'i [u8], NomError<&'i [u8]>> {
+fn subsection_escaped_char<'i>(i: &mut &'i [u8]) -> ModalResult<&'i [u8], NomError<&'i [u8]>> {
     preceded('\\', one_of(is_subsection_escapable_char).take()).parse_next(i)
 }
 
@@ -205,7 +205,7 @@ fn key_value_pair<'i>(
     i: &mut &'i [u8],
     node: &mut ParseNode,
     dispatch: &mut dyn FnMut(Event<'i>),
-) -> PResult<(), NomError<&'i [u8]>> {
+) -> ModalResult<(), NomError<&'i [u8]>> {
     *node = ParseNode::Name;
     if let Some(name) = opt(config_name).parse_next(i)? {
         dispatch(Event::SectionValueName(section::ValueName(Cow::Borrowed(name))));
@@ -223,7 +223,7 @@ fn key_value_pair<'i>(
 
 /// Parses the config name of a config pair. Assumes the input has already been
 /// trimmed of any leading whitespace.
-fn config_name<'i>(i: &mut &'i [u8]) -> PResult<&'i BStr, NomError<&'i [u8]>> {
+fn config_name<'i>(i: &mut &'i [u8]) -> ModalResult<&'i BStr, NomError<&'i [u8]>> {
     (
         one_of(|c: u8| c.is_ascii_alphabetic()),
         take_while(0.., |c: u8| c.is_ascii_alphanumeric() || c == b'-'),
@@ -233,7 +233,7 @@ fn config_name<'i>(i: &mut &'i [u8]) -> PResult<&'i BStr, NomError<&'i [u8]>> {
         .parse_next(i)
 }
 
-fn config_value<'i>(i: &mut &'i [u8], dispatch: &mut dyn FnMut(Event<'i>)) -> PResult<(), NomError<&'i [u8]>> {
+fn config_value<'i>(i: &mut &'i [u8], dispatch: &mut dyn FnMut(Event<'i>)) -> ModalResult<(), NomError<&'i [u8]>> {
     if opt('=').parse_next(i)?.is_some() {
         dispatch(Event::KeyValueSeparator);
         if let Some(whitespace) = opt(take_spaces1).parse_next(i)? {
@@ -251,7 +251,7 @@ fn config_value<'i>(i: &mut &'i [u8], dispatch: &mut dyn FnMut(Event<'i>)) -> PR
 
 /// Handles parsing of known-to-be values. This function handles both single
 /// line values as well as values that are continuations.
-fn value_impl<'i>(i: &mut &'i [u8], dispatch: &mut dyn FnMut(Event<'i>)) -> PResult<(), NomError<&'i [u8]>> {
+fn value_impl<'i>(i: &mut &'i [u8], dispatch: &mut dyn FnMut(Event<'i>)) -> ModalResult<(), NomError<&'i [u8]>> {
     let start_checkpoint = i.checkpoint();
     let mut value_start_checkpoint = i.checkpoint();
     let mut value_end = None;
@@ -278,17 +278,17 @@ fn value_impl<'i>(i: &mut &'i [u8], dispatch: &mut dyn FnMut(Event<'i>)) -> PRes
                     let escape_index = escaped_index - 1;
                     let Some(mut c) = i.next_token() else {
                         i.reset(&start_checkpoint);
-                        return Err(winnow::error::ErrMode::from_error_kind(i, ErrorKind::Token));
+                        return Err(winnow::error::ErrMode::from_input(i));
                     };
                     let mut consumed = 1;
                     if c == b'\r' {
                         c = i.next_token().ok_or_else(|| {
                             i.reset(&start_checkpoint);
-                            winnow::error::ErrMode::from_error_kind(i, ErrorKind::Token)
+                            winnow::error::ErrMode::from_input(i)
                         })?;
                         if c != b'\n' {
                             i.reset(&start_checkpoint);
-                            return Err(winnow::error::ErrMode::from_error_kind(i, ErrorKind::Slice));
+                            return Err(winnow::error::ErrMode::from_input(i));
                         }
                         consumed += 1;
                     }
@@ -313,7 +313,7 @@ fn value_impl<'i>(i: &mut &'i [u8], dispatch: &mut dyn FnMut(Event<'i>)) -> PRes
                         b'n' | b't' | b'\\' | b'b' | b'"' => {}
                         _ => {
                             i.reset(&start_checkpoint);
-                            return Err(winnow::error::ErrMode::from_error_kind(i, ErrorKind::Token));
+                            return Err(winnow::error::ErrMode::from_input(i));
                         }
                     }
                 }
@@ -326,7 +326,7 @@ fn value_impl<'i>(i: &mut &'i [u8], dispatch: &mut dyn FnMut(Event<'i>)) -> PRes
     }
     if is_in_quotes {
         i.reset(&start_checkpoint);
-        return Err(winnow::error::ErrMode::from_error_kind(i, ErrorKind::Slice));
+        return Err(winnow::error::ErrMode::from_input(i));
     }
 
     let value_end = match value_end {
@@ -360,13 +360,13 @@ fn value_impl<'i>(i: &mut &'i [u8], dispatch: &mut dyn FnMut(Event<'i>)) -> PRes
     Ok(())
 }
 
-fn take_spaces1<'i>(i: &mut &'i [u8]) -> PResult<&'i BStr, NomError<&'i [u8]>> {
+fn take_spaces1<'i>(i: &mut &'i [u8]) -> ModalResult<&'i BStr, NomError<&'i [u8]>> {
     take_while(1.., winnow::stream::AsChar::is_space)
         .map(bstr::ByteSlice::as_bstr)
         .parse_next(i)
 }
 
-fn take_newlines1<'i>(i: &mut &'i [u8]) -> PResult<&'i BStr, NomError<&'i [u8]>> {
+fn take_newlines1<'i>(i: &mut &'i [u8]) -> ModalResult<&'i BStr, NomError<&'i [u8]>> {
     repeat(1..1024, alt(("\r\n", "\n")))
         .map(|()| ())
         .take()

gix-config/src/parse/nom/tests.rs

@@ -167,6 +167,8 @@ mod config_name {
 }
 
 mod section {
+    use winnow::error::InputError;
+
     use crate::parse::{
         error::ParseNode,
         tests::util::{
@@ -177,7 +179,10 @@ mod section {
         Event, Section,
     };
 
-    fn section<'a>(mut i: &'a [u8], node: &mut ParseNode) -> winnow::IResult<&'a [u8], Section<'a>> {
+    fn section<'a>(
+        mut i: &'a [u8],
+        node: &mut ParseNode,
+    ) -> winnow::ModalResult<(&'a [u8], Section<'a>), InputError<&'a [u8]>> {
         let mut header = None;
         let mut events = Vec::new();
         super::section(&mut i, node, &mut |e| match &header {
@@ -507,13 +512,17 @@ mod section {
 
 mod value_continuation {
     use bstr::ByteSlice;
+    use winnow::error::InputError;
 
     use crate::parse::{
         tests::util::{newline_custom_event, newline_event, value_done_event, value_not_done_event},
         Event,
     };
 
-    pub fn value_impl<'a>(mut i: &'a [u8], events: &mut Vec<Event<'a>>) -> winnow::IResult<&'a [u8], ()> {
+    pub fn value_impl<'a>(
+        mut i: &'a [u8],
+        events: &mut Vec<Event<'a>>,
+    ) -> winnow::ModalResult<(&'a [u8], ()), InputError<&'a [u8]>> {
         super::value_impl(&mut i, &mut |e| events.push(e)).map(|_| (i, ()))
     }
 
@@ -772,6 +781,8 @@ mod value_no_continuation {
 }
 
 mod key_value_pair {
+    use winnow::error::InputError;
+
     use crate::parse::{
         error::ParseNode,
         tests::util::{name_event, value_event, whitespace_event},
@@ -782,7 +793,7 @@ mod key_value_pair {
         mut i: &'a [u8],
         node: &mut ParseNode,
         events: &mut Vec<Event<'a>>,
-    ) -> winnow::IResult<&'a [u8], ()> {
+    ) -> winnow::ModalResult<(&'a [u8], ()), InputError<&'a [u8]>> {
         super::key_value_pair(&mut i, node, &mut |e| events.push(e)).map(|_| (i, ()))
     }
 

gix-object/src/commit/decode.rs

@@ -2,28 +2,26 @@ use std::borrow::Cow;
 
 use smallvec::SmallVec;
 use winnow::{
-    combinator::{alt, eof, opt, preceded, repeat, rest, terminated},
+    combinator::{alt, eof, opt, preceded, repeat, terminated},
     error::{AddContext, ParserError, StrContext},
     prelude::*,
     stream::Stream as _,
-    token::take_till,
+    token::{rest, take_till},
 };
 
 use crate::{parse, parse::NL, BStr, ByteSlice, CommitRef};
 
 pub fn message<'a, E: ParserError<&'a [u8]> + AddContext<&'a [u8], StrContext>>(
     i: &mut &'a [u8],
-) -> PResult<&'a BStr, E> {
+) -> ModalResult<&'a BStr, E> {
     if i.is_empty() {
         // newline + [message]
         let start = i.checkpoint();
-        return Err(
-            winnow::error::ErrMode::from_error_kind(i, winnow::error::ErrorKind::Eof).add_context(
-                i,
-                &start,
-                StrContext::Expected("newline + <message>".into()),
-            ),
-        );
+        return Err(winnow::error::ErrMode::from_input(i).add_context(
+            i,
+            &start,
+            StrContext::Expected("newline + <message>".into()),
+        ));
     }
     preceded(NL, rest.map(ByteSlice::as_bstr))
         .context(StrContext::Expected(
@@ -34,7 +32,7 @@ pub fn message<'a, E: ParserError<&'a [u8]> + AddContext<&'a [u8], StrContext>>(
 
 pub fn commit<'a, E: ParserError<&'a [u8]> + AddContext<&'a [u8], StrContext>>(
     i: &mut &'a [u8],
-) -> PResult<CommitRef<'a>, E> {
+) -> ModalResult<CommitRef<'a>, E> {
     (
         (|i: &mut _| parse::header_field(i, b"tree", parse::hex_hash))
             .context(StrContext::Expected("tree <40 lowercase hex char>".into())),

gix-object/src/commit/message/body.rs

@@ -1,10 +1,10 @@
 use std::ops::Deref;
 
 use winnow::{
-    combinator::{eof, rest, separated_pair, terminated},
-    error::{ErrorKind, ParserError},
+    combinator::{eof, separated_pair, terminated},
+    error::ParserError,
     prelude::*,
-    token::take_until,
+    token::{rest, take_until},
 };
 
 use crate::{
@@ -31,12 +31,12 @@ pub struct TrailerRef<'a> {
     pub value: &'a BStr,
 }
 
-fn parse_single_line_trailer<'a, E: ParserError<&'a [u8]>>(i: &mut &'a [u8]) -> PResult<(&'a BStr, &'a BStr), E> {
+fn parse_single_line_trailer<'a, E: ParserError<&'a [u8]>>(i: &mut &'a [u8]) -> ModalResult<(&'a BStr, &'a BStr), E> {
     *i = i.trim_end();
     let (token, value) = separated_pair(take_until(1.., b":".as_ref()), b": ", rest).parse_next(i)?;
 
     if token.trim_end().len() != token.len() || value.trim_start().len() != value.len() {
-        Err(winnow::error::ErrMode::from_error_kind(i, ErrorKind::Fail).cut())
+        Err(winnow::error::ErrMode::from_input(i).cut())
     } else {
         Ok((token.as_bstr(), value.as_bstr()))
     }