Upgrade nom crate from 7.0 to 8.0 version (#14)

- vendor shrank version of 4.2.0 `nom_locate` crate

Author: tyranron

CHANGELOG.md

@@ -14,7 +14,9 @@ All user visible changes to `cucumber-expressions` crate will be documented in t
 ### BC Breaks
 
 - Bumped up [MSRV] to 1.81 because for `#[expect]` attribute usage. ([e1bb9266])
+- Upgraded [`nom`] to 8.0 version. ([#14])
 
+[#14]: /../../pull/14
 [e1bb9266]: /../../commit/e1bb92668617432948ab0faa32232b67d6c530e7
 
 
@@ -117,6 +119,7 @@ All user visible changes to `cucumber-expressions` crate will be documented in t
 
 
 
+[`nom`]: https://docs.rs/nom
 [`regex`]: https://docs.rs/regex
 [`Regex`]: https://docs.rs/regex
 [`regex-syntax`]: https://docs.rs/regex-syntax

Cargo.toml

@@ -27,8 +27,8 @@ into-regex = ["dep:either", "dep:regex", "dep:regex-syntax"]
 
 [dependencies]
 derive_more = { version = "0.99.17", features = ["as_ref", "deref", "deref_mut", "display", "error", "from", "into"], default-features = false }
-nom = "7.0"
-nom_locate = "4.0"
+memchr = "2.3"
+nom = "8.0"
 
 # "into-regex" feature dependencies
 either = { version = "1.6", optional = true }

src/ast.rs

@@ -17,10 +17,9 @@
 //! [AST]: https://en.wikipedia.org/wiki/Abstract_syntax_tree
 
 use derive_more::{AsRef, Deref, DerefMut};
-use nom::{error::ErrorKind, Err, InputLength};
-use nom_locate::LocatedSpan;
+use nom::{error::ErrorKind, Err, Input};
 
-use crate::parse;
+use crate::{parse, vendor::nom_locate::LocatedSpan};
 
 /// [`str`] along with its location information in the original input.
 pub type Spanned<'s> = LocatedSpan<&'s str>;
@@ -112,7 +111,7 @@ pub type SingleAlternation<Input> = Vec<Alternative<Input>>;
 #[derive(AsRef, Clone, Debug, Deref, DerefMut, Eq, PartialEq)]
 pub struct Alternation<Input>(pub Vec<SingleAlternation<Input>>);
 
-impl<Input: InputLength> Alternation<Input> {
+impl<I: Input> Alternation<I> {
     /// Returns length of this [`Alternation`]'s span in the `Input`.
     pub(crate) fn span_len(&self) -> usize {
         self.0

src/combinator.rs

@@ -10,12 +10,9 @@
 
 //! Helper parser combinators.
 
-use std::ops::RangeFrom;
-
 use nom::{
     error::{ErrorKind, ParseError},
-    AsChar, Err, IResult, InputIter, InputLength, InputTake,
-    InputTakeAtPosition, Offset, Parser, Slice,
+    AsChar, Err, IResult, Input, Offset, Parser,
 };
 
 /// Applies the given `map` function to the `parser`'s [`IResult`] in case it
@@ -26,13 +23,13 @@ use nom::{
 /// [`Error`]: nom::Err::Error
 /// [`Failure`]: nom::Err::Failure
 /// [`verify()`]: nom::combinator::verify()
-pub(crate) fn map_err<I, O1, E: ParseError<I>, F, G>(
+pub(crate) fn map_err<I, F, G>(
     mut parser: F,
     mut map: G,
-) -> impl FnMut(I) -> IResult<I, O1, E>
+) -> impl FnMut(I) -> IResult<I, F::Output, F::Error>
 where
-    F: Parser<I, O1, E>,
-    G: FnMut(Err<E>) -> Err<E>,
+    F: Parser<I>,
+    G: FnMut(Err<F::Error>) -> Err<F::Error>,
 {
     move |input: I| parser.parse(input).map_err(&mut map)
 }
@@ -47,26 +44,19 @@ where
 ///    non-`escapable` `Input` or end of line.
 ///
 /// [`escaped()`]: nom::bytes::complete::escaped()
-pub(crate) fn escaped0<'a, Input, Error, F, G, O1, O2>(
+pub(crate) fn escaped0<'a, I, Error, F, G>(
     mut normal: F,
     control_char: char,
     mut escapable: G,
-) -> impl FnMut(Input) -> IResult<Input, Input, Error>
+) -> impl FnMut(I) -> IResult<I, I, Error>
 where
-    Input: Clone
-        + Offset
-        + InputLength
-        + InputTake
-        + InputTakeAtPosition
-        + Slice<RangeFrom<usize>>
-        + InputIter
-        + 'a,
-    <Input as InputIter>::Item: AsChar,
-    F: Parser<Input, O1, Error>,
-    G: Parser<Input, O2, Error>,
-    Error: ParseError<Input>,
+    I: Clone + Offset + Input + 'a,
+    <I as Input>::Item: AsChar,
+    F: Parser<I, Error = Error>,
+    G: Parser<I, Error = Error>,
+    Error: ParseError<I>,
 {
-    move |input: Input| {
+    move |input: I| {
         let mut i = input.clone();
         let mut consumed_nothing = false;
 
@@ -76,7 +66,7 @@ where
             match (normal.parse(i.clone()), consumed_nothing) {
                 (Ok((i2, _)), false) => {
                     if i2.input_len() == 0 {
-                        return Ok((input.slice(input.input_len()..), input));
+                        return Ok((input.take_from(input.input_len()), input));
                     }
                     if i2.input_len() == current_len {
                         consumed_nothing = true;
@@ -102,11 +92,11 @@ where
                                 ErrorKind::Escaped,
                             )));
                         }
-                        match escapable.parse(i.slice(next..)) {
+                        match escapable.parse(i.take_from(next)) {
                             Ok((i2, _)) => {
                                 if i2.input_len() == 0 {
                                     return Ok((
-                                        input.slice(input.input_len()..),
+                                        input.take_from(input.input_len()),
                                         input,
                                     ));
                                 }
@@ -133,7 +123,7 @@ where
             }
         }
 
-        Ok((input.slice(input.input_len()..), input))
+        Ok((input.take_from(input.input_len()), input))
     }
 }