chore: resolve winnow deprecations

jpgrayson · jpgrayson · commit f4e18de07601 · 2025-02-15T23:14:00.000-05:00
diff --git a/src/patch/parse/locator.rs b/src/patch/parse/locator.rs
@@ -5,7 +5,7 @@
 use winnow::{
     ascii::hex_digit1,
     combinator::{alt, opt, repeat},
-    PResult, Parser,
+    ModalResult, Parser,
 };
 
 use super::{
@@ -15,7 +15,7 @@ use super::{
 };
 use crate::patch::{PatchId, PatchLocator, PatchOffsetAtom, PatchOffsets};
 
-pub(in super::super) fn patch_locator(input: &mut &str) -> PResult<PatchLocator> {
+pub(in super::super) fn patch_locator(input: &mut &str) -> ModalResult<PatchLocator> {
     alt((
         patch_locator_name,
         patch_locator_from_last,
@@ -25,7 +25,7 @@ pub(in super::super) fn patch_locator(input: &mut &str) -> PResult<PatchLocator>
     .parse_next(input)
 }
 
-fn patch_locator_name(input: &mut &str) -> PResult<PatchLocator> {
+fn patch_locator_name(input: &mut &str) -> ModalResult<PatchLocator> {
     (patch_name, patch_offsets)
         .map(|(patchname, offsets)| PatchLocator {
             id: PatchId::Name(patchname),
@@ -34,7 +34,7 @@ fn patch_locator_name(input: &mut &str) -> PResult<PatchLocator> {
         .parse_next(input)
 }
 
-fn patch_locator_from_last(input: &mut &str) -> PResult<PatchLocator> {
+fn patch_locator_from_last(input: &mut &str) -> ModalResult<PatchLocator> {
     ('^', opt(nonplussed_int), patch_offsets)
         .map(|(_, below_last, offsets)| PatchLocator {
             id: PatchId::BelowLast(below_last),
@@ -43,7 +43,7 @@ fn patch_locator_from_last(input: &mut &str) -> PResult<PatchLocator> {
         .parse_next(input)
 }
 
-pub(in super::super) fn patch_locator_top(input: &mut &str) -> PResult<PatchLocator> {
+pub(in super::super) fn patch_locator_top(input: &mut &str) -> ModalResult<PatchLocator> {
     alt((
         ('@', patch_offsets).map(|(_, offsets)| PatchLocator {
             id: PatchId::Top,
@@ -57,7 +57,7 @@ pub(in super::super) fn patch_locator_top(input: &mut &str) -> PResult<PatchLoca
     .parse_next(input)
 }
 
-pub(in super::super) fn patch_locator_base(input: &mut &str) -> PResult<PatchLocator> {
+pub(in super::super) fn patch_locator_base(input: &mut &str) -> ModalResult<PatchLocator> {
     ("{base}", patch_offsets)
         .map(|(_, offsets)| PatchLocator {
             id: PatchId::Base,
@@ -66,48 +66,48 @@ pub(in super::super) fn patch_locator_base(input: &mut &str) -> PResult<PatchLoc
         .parse_next(input)
 }
 
-pub(in super::super) fn patch_offsets(input: &mut &str) -> PResult<PatchOffsets> {
+pub(in super::super) fn patch_offsets(input: &mut &str) -> ModalResult<PatchOffsets> {
     repeat::<_, _, Vec<PatchOffsetAtom>, _, _>(0.., patch_offset_atom)
         .take()
         .map(|s: &str| PatchOffsets(s.to_string()))
         .parse_next(input)
 }
 
-pub(in super::super) fn patch_offset_atoms(input: &mut &str) -> PResult<Vec<PatchOffsetAtom>> {
+pub(in super::super) fn patch_offset_atoms(input: &mut &str) -> ModalResult<Vec<PatchOffsetAtom>> {
     repeat(0.., patch_offset_atom).parse_next(input)
 }
 
-pub(in super::super) fn patch_offset_atom(input: &mut &str) -> PResult<PatchOffsetAtom> {
+pub(in super::super) fn patch_offset_atom(input: &mut &str) -> ModalResult<PatchOffsetAtom> {
     alt((patch_offset_atom_plus, patch_offset_atom_tilde)).parse_next(input)
 }
 
-fn patch_offset_atom_plus(input: &mut &str) -> PResult<PatchOffsetAtom> {
+fn patch_offset_atom_plus(input: &mut &str) -> ModalResult<PatchOffsetAtom> {
     ('+', opt(unsigned_int))
         .map(|(_, n)| PatchOffsetAtom::Plus(n))
         .parse_next(input)
 }
 
-fn patch_offset_atom_tilde(input: &mut &str) -> PResult<PatchOffsetAtom> {
+fn patch_offset_atom_tilde(input: &mut &str) -> ModalResult<PatchOffsetAtom> {
     ('~', opt(unsigned_int))
         .map(|(_, n)| PatchOffsetAtom::Tilde(n))
         .parse_next(input)
 }
 
 pub(in super::super) fn oid_prefix_offsets(
     input: &mut &str,
-) -> PResult<(gix::hash::Prefix, PatchOffsets)> {
+) -> ModalResult<(gix::hash::Prefix, PatchOffsets)> {
     (oid_prefix, patch_offsets).parse_next(input)
 }
 
-fn oid_prefix(input: &mut &str) -> PResult<gix::hash::Prefix> {
+fn oid_prefix(input: &mut &str) -> ModalResult<gix::hash::Prefix> {
     hex_digit1
         .try_map(gix::hash::Prefix::from_hex)
         .parse_next(input)
 }
 
 pub(in super::super) fn sign_number_offsets(
     input: &mut &str,
-) -> PResult<(Option<Sign>, Option<usize>, PatchOffsets)> {
+) -> ModalResult<(Option<Sign>, Option<usize>, PatchOffsets)> {
     alt((
         (negative_int, patch_offsets)
             .map(|(n, offsets)| (Some(Sign::Minus), Some(n.unsigned_abs()), offsets)),
diff --git a/src/patch/parse/name.rs b/src/patch/parse/name.rs
@@ -3,14 +3,14 @@
 //! Parsing support for [`PatchName`].
 
 use winnow::{
-    error::{ContextError, ErrMode, ErrorKind, ParserError},
+    error::{ContextError, ErrMode, ParserError},
     stream::Stream,
-    PResult,
+    ModalResult,
 };
 
 use crate::patch::PatchName;
 
-pub(super) fn patch_name(input: &mut &str) -> PResult<PatchName> {
+pub(super) fn patch_name(input: &mut &str) -> ModalResult<PatchName> {
     let mut iter = input.char_indices().peekable();
     let mut start_index = 0;
 
@@ -50,21 +50,12 @@ pub(super) fn patch_name(input: &mut &str) -> PResult<PatchName> {
     let name = input.next_slice(split_offset);
 
     if name.is_empty() {
-        Err(ErrMode::Backtrack(ContextError::from_error_kind(
-            input,
-            ErrorKind::Eof,
-        )))
+        Err(ErrMode::Backtrack(ContextError::from_input(input)))
     } else if name.ends_with(".lock") {
         // Names ending with ".lock" are invalid and there is no recovery.
-        Err(ErrMode::Cut(ContextError::from_error_kind(
-            input,
-            ErrorKind::Verify,
-        )))
+        Err(ErrMode::Cut(ContextError::from_input(input)))
     } else if name == "@" || name == "{base}" {
-        Err(ErrMode::Backtrack(ContextError::from_error_kind(
-            input,
-            ErrorKind::Verify,
-        )))
+        Err(ErrMode::Backtrack(ContextError::from_input(input)))
     } else {
         // This should be detected above.
         debug_assert!(!name.ends_with('.'));
diff --git a/src/patch/parse/numbers.rs b/src/patch/parse/numbers.rs
@@ -5,44 +5,44 @@
 use winnow::{
     ascii::digit1,
     combinator::{alt, opt},
-    PResult, Parser,
+    ModalResult, Parser,
 };
 
 use super::Sign;
 
 /// Parse a sign character, i.e. `-` or `+`.
-pub(super) fn sign(input: &mut &str) -> PResult<Sign> {
+pub(super) fn sign(input: &mut &str) -> ModalResult<Sign> {
     alt(('-'.map(|_| Sign::Minus), '+'.map(|_| Sign::Plus))).parse_next(input)
 }
 
 /// Parse unsigned int.
 ///
 /// Although the returned value is a [`usize`], it is validated as an [`isize`]. This
 /// ensures that potential sign conversions are more likely to succeed.
-pub(super) fn unsigned_int(input: &mut &str) -> PResult<usize> {
+pub(super) fn unsigned_int(input: &mut &str) -> ModalResult<usize> {
     digit1
         .try_map(|s: &str| s.parse::<isize>().map(|n| n as usize))
         .parse_next(input)
 }
 
 /// Parse a negative int. I.e. an int with a leading `-` sign.
-pub(super) fn negative_int(input: &mut &str) -> PResult<isize> {
+pub(super) fn negative_int(input: &mut &str) -> ModalResult<isize> {
     ('-', digit1)
         .take()
         .try_map(|s: &str| s.parse::<isize>())
         .parse_next(input)
 }
 
 /// Parse a positive int with a leading `+` sign.
-pub(super) fn plusative_int(input: &mut &str) -> PResult<isize> {
+pub(super) fn plusative_int(input: &mut &str) -> ModalResult<isize> {
     ('+', digit1)
         .take()
         .try_map(|s: &str| s.parse::<isize>())
         .parse_next(input)
 }
 
 /// Parse a signed int, but disallow an explicit `+` sign.
-pub(super) fn nonplussed_int(input: &mut &str) -> PResult<isize> {
+pub(super) fn nonplussed_int(input: &mut &str) -> ModalResult<isize> {
     (opt('-'), digit1)
         .take()
         .try_map(|s: &str| s.parse::<isize>())
diff --git a/src/patch/parse/range.rs b/src/patch/parse/range.rs
@@ -4,21 +4,21 @@
 
 use winnow::{
     combinator::{alt, opt, separated_pair},
-    PResult, Parser,
+    ModalResult, Parser,
 };
 
 use super::patch_locator;
 use crate::patch::{PatchRange, PatchRangeBounds};
 
-pub(in super::super) fn patch_range(input: &mut &str) -> PResult<PatchRange> {
+pub(in super::super) fn patch_range(input: &mut &str) -> ModalResult<PatchRange> {
     alt((
         patch_range_bounds.map(PatchRange::Range),
         patch_locator.map(PatchRange::Single),
     ))
     .parse_next(input)
 }
 
-pub(super) fn patch_range_bounds(input: &mut &str) -> PResult<PatchRangeBounds> {
+pub(super) fn patch_range_bounds(input: &mut &str) -> ModalResult<PatchRangeBounds> {
     separated_pair(opt(patch_locator), "..", opt(patch_locator))
         .map(|(begin, end)| PatchRangeBounds { begin, end })
         .parse_next(input)
diff --git a/src/patch/parse/revision.rs b/src/patch/parse/revision.rs
@@ -9,7 +9,7 @@ use winnow::{
     combinator::{alt, delimited, opt, preceded, repeat, terminated},
     stream::Stream,
     token::{none_of, one_of},
-    PResult, Parser,
+    ModalResult, Parser,
 };
 
 use super::{
@@ -20,7 +20,7 @@ use super::{
 };
 use crate::{branchloc::BranchLocator, wrap::partial_ref_name};
 
-pub(in super::super) fn range_revision_spec(input: &mut &str) -> PResult<RangeRevisionSpec> {
+pub(in super::super) fn range_revision_spec(input: &mut &str) -> ModalResult<RangeRevisionSpec> {
     alt((
         (branch_prefix, patch_range_bounds)
             .map(|(branch_loc, bounds)| RangeRevisionSpec::BranchRange { branch_loc, bounds }),
@@ -30,7 +30,7 @@ pub(in super::super) fn range_revision_spec(input: &mut &str) -> PResult<RangeRe
     .parse_next(input)
 }
 
-pub(in super::super) fn single_revision_spec(input: &mut &str) -> PResult<SingleRevisionSpec> {
+pub(in super::super) fn single_revision_spec(input: &mut &str) -> ModalResult<SingleRevisionSpec> {
     alt((
         (branch_prefix, patch_like_spec).map(|(branch_loc, patch_like)| {
             SingleRevisionSpec::Branch {
@@ -43,7 +43,7 @@ pub(in super::super) fn single_revision_spec(input: &mut &str) -> PResult<Single
     .parse_next(input)
 }
 
-fn branch_prefix(input: &mut &str) -> PResult<BranchLocator> {
+fn branch_prefix(input: &mut &str) -> ModalResult<BranchLocator> {
     terminated(branch_locator, ':').parse_next(input)
 }
 
@@ -58,7 +58,7 @@ impl std::fmt::Display for PrevCheckoutError {
 
 impl std::error::Error for PrevCheckoutError {}
 
-pub(crate) fn branch_locator(input: &mut &str) -> PResult<BranchLocator> {
+pub(crate) fn branch_locator(input: &mut &str) -> ModalResult<BranchLocator> {
     alt((
         delimited("@{-", digit1, "}")
             .try_map(|s: &str| s.parse::<usize>())
@@ -77,7 +77,7 @@ pub(crate) fn branch_locator(input: &mut &str) -> PResult<BranchLocator> {
     .parse_next(input)
 }
 
-fn patch_and_or_git_like_spec(input: &mut &str) -> PResult<SingleRevisionSpec> {
+fn patch_and_or_git_like_spec(input: &mut &str) -> ModalResult<SingleRevisionSpec> {
     use std::cmp::Ordering;
 
     let start_checkpoint = input.checkpoint();
@@ -111,20 +111,20 @@ fn patch_and_or_git_like_spec(input: &mut &str) -> PResult<SingleRevisionSpec> {
     }
 }
 
-pub(in super::super) fn patch_like_spec(input: &mut &str) -> PResult<PatchLikeSpec> {
+pub(in super::super) fn patch_like_spec(input: &mut &str) -> ModalResult<PatchLikeSpec> {
     (patch_locator, git_revision_suffix)
         .map(|(patch_loc, suffix)| PatchLikeSpec { patch_loc, suffix })
         .parse_next(input)
 }
 
-fn git_like_spec(input: &mut &str) -> PResult<String> {
+fn git_like_spec(input: &mut &str) -> ModalResult<String> {
     (partial_ref_name, git_revision_suffix)
         .take()
         .map(|s| s.to_string())
         .parse_next(input)
 }
 
-fn git_revision_suffix(input: &mut &str) -> PResult<GitRevisionSuffix> {
+fn git_revision_suffix(input: &mut &str) -> ModalResult<GitRevisionSuffix> {
     repeat::<_, _, Vec<&str>, _, _>(
         0..,
         alt((
@@ -139,23 +139,23 @@ fn git_revision_suffix(input: &mut &str) -> PResult<GitRevisionSuffix> {
     .map(|suffix: &str| GitRevisionSuffix(suffix.to_string()))
 }
 
-fn at_braced<'s>(input: &mut &'s str) -> PResult<&'s str> {
+fn at_braced<'s>(input: &mut &'s str) -> ModalResult<&'s str> {
     preceded('@', braced).parse_next(input)
 }
 
-fn caret_braced<'s>(input: &mut &'s str) -> PResult<&'s str> {
+fn caret_braced<'s>(input: &mut &'s str) -> ModalResult<&'s str> {
     preceded('^', braced).parse_next(input)
 }
 
-fn caret_number(input: &mut &str) -> PResult<Option<usize>> {
+fn caret_number(input: &mut &str) -> ModalResult<Option<usize>> {
     preceded('^', opt(unsigned_int)).parse_next(input)
 }
 
-pub(crate) fn tilde_number(input: &mut &str) -> PResult<Option<usize>> {
+pub(crate) fn tilde_number(input: &mut &str) -> ModalResult<Option<usize>> {
     preceded('~', opt(unsigned_int)).parse_next(input)
 }
 
-fn braced<'s>(input: &mut &'s str) -> PResult<&'s str> {
+fn braced<'s>(input: &mut &'s str) -> ModalResult<&'s str> {
     delimited(
         '{',
         take_escaped(none_of(['\\', '{', '}']), '\\', one_of(['\\', '{', '}'])),
diff --git a/src/wrap/partialrefname.rs b/src/wrap/partialrefname.rs
@@ -3,9 +3,9 @@
 use std::str::FromStr;
 
 use winnow::{
-    error::{ContextError, ErrMode, ErrorKind, ParserError},
+    error::{ContextError, ErrMode, ParserError},
     stream::Stream,
-    PResult, Parser,
+    ModalResult, Parser,
 };
 
 /// A partial git reference name.
@@ -53,7 +53,7 @@ impl FromStr for PartialRefName {
     }
 }
 
-pub(crate) fn partial_ref_name(input: &mut &str) -> PResult<PartialRefName> {
+pub(crate) fn partial_ref_name(input: &mut &str) -> ModalResult<PartialRefName> {
     let mut iter = input.iter_offsets().peekable();
     let mut start_index = 0;
     let mut prev = None;
@@ -101,22 +101,9 @@ pub(crate) fn partial_ref_name(input: &mut &str) -> PResult<PartialRefName> {
 
     let name = input.next_slice(split_offset);
 
-    if name.is_empty() {
-        Err(ErrMode::Backtrack(ContextError::from_error_kind(
-            input,
-            ErrorKind::Eof,
-        )))
-    } else if name == "-" {
-        Err(ErrMode::Backtrack(ContextError::from_error_kind(
-            input,
-            ErrorKind::Verify,
-        )))
-    } else if name.ends_with(".lock") {
+    if name.is_empty() || name == "-" || name.ends_with(".lock") {
         // Names ending with ".lock" are invalid and there is no recovery.
-        Err(ErrMode::Cut(ContextError::from_error_kind(
-            input,
-            ErrorKind::Verify,
-        )))
+        Err(ErrMode::Cut(ContextError::from_input(input)))
     } else {
         gix::refs::PartialName::try_from(name).expect("parser only allows valid names");
         Ok(PartialRefName(name.to_string()))
