Merge pull request #125 from Rawk/nom8

build: Upgrade nom to version 8

Author: 6d7a

Cargo.lock

@@ -33,7 +33,7 @@ cli = ["clap", "colored", "walkdir"]
 chrono = "0.4.41"
 clap = { version = "4.5.38", optional = true, features = ["derive"] }
 colored = { version = "2", optional = true }
-nom = { version = "7.1.3", default-features = false, features = ["alloc"] }
+nom = { version = "8.0", default-features = false, features = ["alloc"] }
 num = { version = "0.4", default-features = false }
 proc-macro2 = "1.0"
 quote = "1.0"

rasn-compiler/Cargo.toml

@@ -6,27 +6,22 @@
 
 use std::{
     fmt::Debug,
-    ops::RangeTo,
+    slice::SliceIndex,
     str::{CharIndices, Chars, FromStr},
 };
 
-use nom::{
-    AsBytes, Compare, ExtendInto, FindSubstring, FindToken, InputIter, InputLength, InputTake,
-    InputTakeAtPosition, Offset, ParseTo, Slice,
-};
-
-use crate::lexer::error::ParserResult;
+use nom::{AsBytes, Compare, ExtendInto, FindSubstring, FindToken, Offset, ParseTo, Parser};
 
 /// Informs `Input` of a context switch.
-pub fn context_boundary<'a, F, O: Debug>(
+pub fn context_boundary<'a, F>(
     mut inner: F,
-) -> impl FnMut(Input<'a>) -> ParserResult<'a, O>
+) -> impl Parser<Input<'a>, Output = F::Output, Error = F::Error>
 where
-    F: FnMut(Input<'a>) -> ParserResult<'a, O>,
+    F: Parser<Input<'a>>,
 {
-    move |mut input| {
+    move |mut input: Input<'a>| {
         input.reset_context();
-        inner(input)
+        inner.parse(input)
     }
 }
 
@@ -189,57 +184,9 @@ impl FindToken<char> for Input<'_> {
     }
 }
 
-impl<'a> InputIter for Input<'a> {
-    type Item = char;
-    type Iter = CharIndices<'a>;
-    type IterElem = Chars<'a>;
-
-    #[inline]
-    fn iter_indices(&self) -> Self::Iter {
-        self.inner.iter_indices()
-    }
-
-    #[inline]
-    fn iter_elements(&self) -> Self::IterElem {
-        self.inner.iter_elements()
-    }
-
-    #[inline]
-    fn position<P>(&self, predicate: P) -> Option<usize>
-    where
-        P: Fn(Self::Item) -> bool,
-    {
-        self.inner.position(predicate)
-    }
-
-    #[inline]
-    fn slice_index(&self, count: usize) -> Result<usize, nom::Needed> {
-        self.inner.slice_index(count)
-    }
-}
-
-impl InputLength for Input<'_> {
-    fn input_len(&self) -> usize {
-        self.inner.len()
-    }
-}
-
-impl InputTake for Input<'_> {
-    fn take(&self, count: usize) -> Self {
-        self.slice(..count)
-    }
-
-    fn take_split(&self, count: usize) -> (Self, Self) {
-        (self.slice(count..), self.slice(..count))
-    }
-}
-
-impl<'a, R> Slice<R> for Input<'a>
-where
-    &'a str: Slice<R> + Slice<RangeTo<usize>>,
-{
-    fn slice(&self, range: R) -> Self {
-        let inner = self.inner.slice(range);
+impl<'a> Input<'a> {
+    pub fn slice(&self, range: impl SliceIndex<str, Output = str>) -> Self {
+        let inner = &self.inner[range];
         let consumed_len = self.inner.offset(inner);
         if consumed_len == 0 {
             Input {
@@ -251,7 +198,7 @@ where
                 inner,
             }
         } else {
-            let consumed = self.inner.slice(..consumed_len);
+            let consumed = &self.inner[..consumed_len];
             let line_breaks = consumed.match_indices('\n');
             let last_line_break = line_breaks.clone().last();
             let column = if let Some(last) = last_line_break {
@@ -273,8 +220,10 @@ where
     }
 }
 
-impl InputTakeAtPosition for Input<'_> {
+impl<'a> nom::Input for Input<'a> {
     type Item = char;
+    type Iter = Chars<'a>;
+    type IterIndices = CharIndices<'a>;
 
     fn split_at_position<P, E: nom::error::ParseError<Self>>(
         &self,
@@ -317,6 +266,41 @@ impl InputTakeAtPosition for Input<'_> {
         }
     }
 
+    fn input_len(&self) -> usize {
+        self.inner.len()
+    }
+
+    fn take(&self, count: usize) -> Self {
+        self.slice(..count)
+    }
+
+    fn take_from(&self, index: usize) -> Self {
+        self.slice(index..)
+    }
+
+    fn take_split(&self, count: usize) -> (Self, Self) {
+        (self.slice(count..), self.slice(..count))
+    }
+
+    fn position<P>(&self, predicate: P) -> Option<usize>
+    where
+        P: Fn(Self::Item) -> bool,
+    {
+        self.inner.position(predicate)
+    }
+
+    fn iter_elements(&self) -> Self::Iter {
+        self.inner.iter_elements()
+    }
+
+    fn iter_indices(&self) -> Self::IterIndices {
+        self.inner.iter_indices()
+    }
+
+    fn slice_index(&self, count: usize) -> Result<usize, nom::Needed> {
+        self.inner.slice_index(count)
+    }
+
     fn split_at_position1_complete<P, E: nom::error::ParseError<Self>>(
         &self,
         predicate: P,

rasn-compiler/src/input.rs

@@ -5,6 +5,7 @@ use nom::{
     combinator::{map, opt},
     multi::{fold_many0, separated_list0},
     sequence::{delimited, pair, preceded},
+    Parser,
 };
 
 use crate::{input::Input, intermediate::*};
@@ -45,7 +46,8 @@ pub fn bit_string_value(input: Input<'_>) -> ParserResult<'_, ASN1Value> {
                 ASN1Value::BitStringNamedBits(named_bits.into_iter().map(String::from).collect())
             },
         ),
-    ))(input)
+    ))
+    .parse(input)
 }
 
 /// Tries to parse an ASN1 BIT STRING
@@ -63,7 +65,8 @@ pub fn bit_string(input: Input<'_>) -> ParserResult<'_, ASN1Type> {
             pair(opt(distinguished_values), opt(constraint)),
         ),
         |m| ASN1Type::BitString(m.into()),
-    )(input)
+    )
+    .parse(input)
 }
 
 #[cfg(test)]

rasn-compiler/src/lexer/bit_string.rs

@@ -3,6 +3,7 @@ use nom::{
     bytes::complete::tag,
     combinator::{into, map, opt, value},
     sequence::preceded,
+    Parser,
 };
 
 use crate::{
@@ -16,7 +17,8 @@ pub fn boolean_value(input: Input<'_>) -> ParserResult<'_, ASN1Value> {
     alt((
         value(ASN1Value::Boolean(true), skip_ws_and_comments(tag(TRUE))),
         value(ASN1Value::Boolean(false), skip_ws_and_comments(tag(FALSE))),
-    ))(input)
+    ))
+    .parse(input)
 }
 
 /// Tries to parse an ASN1 BOOLEAN
@@ -34,7 +36,8 @@ pub fn boolean(input: Input<'_>) -> ParserResult<'_, ASN1Type> {
             skip_ws_and_comments(opt(constraint)),
         ))),
         ASN1Type::Boolean,
-    )(input)
+    )
+    .parse(input)
 }
 
 #[cfg(test)]

rasn-compiler/src/lexer/boolean.rs

@@ -3,7 +3,8 @@ use nom::{
     bytes::complete::tag,
     character::complete::{char, u8},
     combinator::{map, map_res, opt},
-    sequence::{delimited, pair, terminated, tuple},
+    sequence::{delimited, pair, terminated},
+    Parser,
 };
 
 use crate::{input::Input, intermediate::*};
@@ -19,7 +20,8 @@ pub fn character_string_value(input: Input<'_>) -> ParserResult<'_, ASN1Value> {
     map(
         skip_ws_and_comments(alt((cstring, map(quadruple, |c| c.to_string())))),
         |m: String| ASN1Value::String(m),
-    )(input)
+    )
+    .parse(input)
 }
 
 /// Parses a ASN1 cstring
@@ -45,7 +47,8 @@ pub fn cstring(input: Input<'_>) -> ParserResult<'_, String> {
         // Replace any escaped quote with a single `"`
         // TODO: Remove whitespace around newlines in multiline strings.
         s.replace("\"\"", "\"")
-    })(input)
+    })
+    .parse(input)
 }
 
 /// Parses a string literal into its raw value.
@@ -56,7 +59,7 @@ pub fn cstring(input: Input<'_>) -> ParserResult<'_, String> {
 /// This is a raw string in the sense that it is the string slice as written
 /// in the source, including any indentation and double quotes (`""`).
 pub fn raw_string_literal(input: Input<'_>) -> ParserResult<'_, &'_ str> {
-    delimited(char('"'), take_until_and_not("\"", "\"\""), char('"'))(input)
+    delimited(char('"'), take_until_and_not("\"", "\"\""), char('"')).parse(input)
 }
 
 /// A ASN1 character value can be specified "by reference to a registration number in the ISO
@@ -77,12 +80,12 @@ pub fn raw_string_literal(input: Input<'_>) -> ParserResult<'_, &'_ str> {
 /// __Currently, the rasn compiler only supports group `0`__
 fn quadruple(input: Input<'_>) -> ParserResult<'_, char> {
     map_res(
-        in_braces(tuple((
+        in_braces((
             terminated(skip_ws(u8), skip_ws(char(COMMA))),
             terminated(skip_ws(u8), skip_ws(char(COMMA))),
             terminated(skip_ws(u8), skip_ws(char(COMMA))),
             skip_ws(u8),
-        ))),
+        )),
         |(group, plane, row, cell)| {
             if group > 0 {
                 Err(MiscError("Currently, only group 0 is supported."))
@@ -93,7 +96,8 @@ fn quadruple(input: Input<'_>) -> ParserResult<'_, char> {
                 ))
             }
         },
-    )(input.clone())
+    )
+    .parse(input)
 }
 
 /// Tries to parse an ASN1 Character String type
@@ -125,7 +129,8 @@ pub fn character_string(input: Input<'_>) -> ParserResult<'_, ASN1Type> {
             opt(constraint),
         ),
         |m| ASN1Type::CharacterString(m.into()),
-    )(input)
+    )
+    .parse(input)
 }
 
 #[cfg(test)]