Making the generated parsers more generic for re-use

marcdejonge · marcdejonge · commit beca77c6c6fd · 2025-01-06T19:14:41.000+01:00
- Improve support for variants with no fields
- Add many more nom functions for parsing numbers
diff --git a/examples/basic_enum_with_members.rs b/examples/basic_enum_with_members.rs
@@ -2,6 +2,7 @@
 //! The expected outcome of the nom expression should be a tuple with the same
 //! amount of parameters as the struct has.
 
+use nom::IResult;
 use nom_parse_macros::parse_from;
 use nom_parse_trait::ParseFrom;
 
@@ -15,10 +16,10 @@ enum SomeConfig {
 
 fn main() {
     let input = "32";
-    let number = SomeConfig::parse(input).unwrap().1;
-    println!("Parsed \"{}\" as {:?}", input, number);
+    let number: IResult<_, _> = SomeConfig::parse(input);
+    println!("Parsed \"{}\" as {:?}", input, number.unwrap().1);
 
     let input = "(32,34,46)";
-    let numbers = SomeConfig::parse(input).unwrap().1;
-    println!("Parsed \"{}\" as {:?}", input, numbers);
+    let numbers: IResult<_, _> = SomeConfig::parse(input);
+    println!("Parsed \"{}\" as {:?}", input, numbers.unwrap().1);
 }
diff --git a/examples/basic_struct_with_members.rs b/examples/basic_struct_with_members.rs
@@ -2,6 +2,7 @@
 //! The expected outcome of the nom expression should be a tuple with the same
 //! amount of parameters as the struct has.
 
+use nom::IResult;
 use nom_parse_macros::parse_from;
 use nom_parse_trait::ParseFrom;
 
@@ -14,6 +15,6 @@ struct NumberPair {
 
 fn main() {
     let input = "1 ,  2";
-    let pair = NumberPair::parse(input).unwrap();
-    println!("Parsed \"{}\" as {:?}", input, pair.1);
+    let pair: IResult<_, _> = NumberPair::parse(input);
+    println!("Parsed \"{}\" as {:?}", input, pair.unwrap().1);
 }
diff --git a/examples/derived_fields.rs b/examples/derived_fields.rs
@@ -2,6 +2,7 @@
 //! A derived field is not actually parsed, but derived from all of the other
 //! fields that are parsed.
 
+use nom::IResult;
 use nom_parse_macros::parse_from;
 use nom_parse_trait::ParseFrom;
 
@@ -16,6 +17,6 @@ struct NumberPair {
 
 fn main() {
     let input = "1 ,  2";
-    let pair = NumberPair::parse(input).unwrap();
-    println!("Parsed \"{}\" as {:?}", input, pair.1);
+    let pair: IResult<_, _> = NumberPair::parse(input);
+    println!("Parsed \"{}\" as {:?}", input, pair.unwrap().1);
 }
diff --git a/examples/use_matching_string.rs b/examples/use_matching_string.rs
@@ -2,6 +2,7 @@
 //! The {} gets replaced with a parser for the corresponding field. The rest of
 //! the characters are matched verbatim.
 
+use nom::IResult;
 use nom_parse_macros::parse_match;
 use nom_parse_trait::ParseFrom;
 
@@ -15,6 +16,6 @@ struct Vector3 {
 
 fn main() {
     let input = "(1,3,4)";
-    let pair = Vector3::parse(input).unwrap();
-    println!("Parsed \"{}\" as {:?}", input, pair.1);
+    let pair: IResult<_, _> = Vector3::parse(input);
+    println!("Parsed \"{}\" as {:?}", input, pair.unwrap().1);
 }
diff --git a/src/fields.rs b/src/fields.rs
@@ -139,7 +139,13 @@ impl Fields {
     pub fn create_instance_expr(&self, variant_name: Option<&Ident>) -> TokenStream {
         let all_names = self.get_all_names();
 
-        if let Some(name) = variant_name {
+        if all_names.is_empty() {
+            if let Some(name) = variant_name {
+                quote! { Self::#name }
+            } else {
+                quote! { Self }
+            }
+        } else if let Some(name) = variant_name {
             if self.is_named {
                 quote! { Self::#name { #(#all_names),* } }
             } else {
diff --git a/src/lib.rs b/src/lib.rs
@@ -40,25 +40,16 @@ fn generate_struct_parser(attrs: TokenStream, mut object: ItemStruct) -> TokenSt
     let expression_names = fields.get_expression_names();
     let derived_expressions = fields.get_derived_expressions();
     let create_expr = fields.create_instance_expr(None);
-    let where_clause = generate_where_clause();
 
-    let tokens = quote! {
-        #object
-
-        impl<I> nom_parse_trait::ParseFrom<I> for #name
-        #where_clause
-        {
-            fn parse(input: I) -> nom::IResult<I, Self> {
-                use nom::*;
-
-                let (input, (#(#expression_names),*)) = #expression.parse(input)?;
-                #(#derived_expressions)*
-                Ok((input, #create_expr))
-            }
-        }
-    };
-
-    tokens.into()
+    generate_parser(
+        object,
+        name,
+        quote! {
+            let (input, (#(#expression_names),*)) = #expression.parse(input)?;
+            #(#derived_expressions)*
+            Ok((input, #create_expr))
+        },
+    )
 }
 
 fn generate_enum_parser(mut object: ItemEnum) -> TokenStream {
@@ -107,35 +98,39 @@ fn generate_enum_parser(mut object: ItemEnum) -> TokenStream {
         );
         mapping_names.push(mapping_name.clone());
 
-        mappings.push(quote! {
-            let #mapping_name = nom::combinator::map(
-                #format_expr,
-                |(#(#expression_names),*): (#(#expression_types),*)| {
-                    #(#derived_expressions)*
-                    #create_expr
-                }
-            );
-        })
+        if expression_names.is_empty() {
+            // Parsing a variant without fields
+            mappings.push(quote! {
+                let #mapping_name = nom::combinator::map(
+                    #format_expr,
+                    |_| { #create_expr }
+                );
+            })
+        } else {
+            mappings.push(quote! {
+                let #mapping_name = nom::combinator::map(
+                    #format_expr,
+                    |(#(#expression_names),*): (#(#expression_types),*)| {
+                        #(#derived_expressions)*
+                        #create_expr
+                    }
+                );
+            })
+        }
     }
 
     let name = object.ident.clone();
 
-    let tokens = quote! {
-        #object
-
-        impl nom_parse_trait::ParseFrom<&str> for #name {
-            fn parse(input: &str) -> nom::IResult<&str, Self> {
-                use nom::*;
-
-                #(#mappings)*
-                nom::branch::alt((
-                    #(#mapping_names),*
-                )).parse(input)
-            }
-        }
-    };
-
-    tokens.into()
+    generate_parser(
+        object,
+        name,
+        quote! {
+            #(#mappings)*
+            nom::branch::alt((
+                #(#mapping_names),*
+            )).parse(input)
+        },
+    )
 }
 
 #[proc_macro_attribute]
@@ -148,36 +143,30 @@ pub fn parse_match(attrs: TokenStream, object: TokenStream) -> TokenStream {
         Err(e) => return e.to_compile_error().into(),
     };
     let name = object.ident.clone();
-    let where_clause = generate_where_clause();
 
     match parse_string_match(&fields, literal) {
         Ok(parts) => {
             let names: Vec<_> = fields.fields.iter().map(|field| field.get_name()).collect();
-            let tokens = quote! {
-                #object
-
-                impl<I> nom_parse_trait::ParseFrom<I> for #name
-                #where_clause
-                {
-                    fn parse(input: I) -> nom::IResult<I, Self> {
-                        use nom::*;
-
-                        let mut input = input;
-                        #(#parts)*
-                        Ok((input, Self { #(#names),* }))
-                    }
-                }
-            };
-
-            tokens.into()
+            generate_parser(
+                object,
+                name,
+                quote! {
+                    #(#parts)*
+                    Ok((input, Self { #(#names),* }))
+                },
+            )
         }
         Err(e) => e.to_compile_error().into(),
     }
 }
 
-fn generate_where_clause() -> proc_macro2::TokenStream {
-    quote! {
+fn generate_parser(object: impl ToTokens, name: Ident, content: impl ToTokens) -> TokenStream {
+    let tokens = quote! {
+        #object
+
+        impl<I, E> nom_parse_trait::ParseFrom<I, E> for #name
         where
+            E: nom::error::ParseError<I>,
             I: Clone,
             I: nom::Slice<std::ops::RangeTo<usize>> + nom::Slice<std::ops::RangeFrom<usize>> + nom::Slice<std::ops::Range<usize>>,
             I: nom::InputTake + nom::InputLength + nom::Offset + nom::AsBytes,
@@ -187,5 +176,15 @@ fn generate_where_clause() -> proc_macro2::TokenStream {
             I: nom::InputTakeAtPosition,
             <I as nom::InputTakeAtPosition>::Item: nom::AsChar + Copy,
             I: for<'a> nom::Compare<&'a [u8]>,
-    }
-}
+            I: nom::Compare<&'static str>,
+        {
+            fn parse(input: I) -> nom::IResult<I, Self, E> {
+                use nom::*;
+                use nom_parse_trait::ParseFrom;
+
+                #content
+            }
+        }
+    };
+    tokens.into()
+}
diff --git a/src/nom_packages.rs b/src/nom_packages.rs
@@ -51,6 +51,49 @@ const NOM_FUNCTIONS: phf::Map<&'static str, (&'static str, &'static [bool])> = p
     "multispace0" => ("nom::character::complete::multispace0", &[]),
     "multispace1" => ("nom::character::complete::multispace1", &[]),
     "sign" => ("nom::character::complete::sign", &[]),
+    // Primitive parsers
+    "u8" => ("nom::character::complete::u8", &[]),
+    "u16" => ("nom::character::complete::u16", &[]),
+    "u32" => ("nom::character::complete::u32", &[]),
+    "u64" => ("nom::character::complete::u64", &[]),
+    "u128" => ("nom::character::complete::u128", &[]),
+    "i8" => ("nom::character::complete::i8", &[]),
+    "i16" => ("nom::character::complete::i16", &[]),
+    "i32" => ("nom::character::complete::i32", &[]),
+    "i64" => ("nom::character::complete::i64", &[]),
+    "i128" => ("nom::character::complete::i128", &[]),
+    // From the nom::number::complete module,
+    "be_u8" => ("nom::number::complete::be_u8", &[]),
+    "be_i8" => ("nom::number::complete::be_i8", &[]),
+    "be_u16" => ("nom::number::complete::be_u16", &[]),
+    "be_i16" => ("nom::number::complete::be_i16", &[]),
+    "be_u24" => ("nom::number::complete::be_u24", &[]),
+    "be_i24" => ("nom::number::complete::be_i24", &[]),
+    "be_u32" => ("nom::number::complete::be_u32", &[]),
+    "be_i32" => ("nom::number::complete::be_i32", &[]),
+    "be_u64" => ("nom::number::complete::be_u64", &[]),
+    "be_i64" => ("nom::number::complete::be_i64", &[]),
+    "be_u128" => ("nom::number::complete::be_u128", &[]),
+    "be_i128" => ("nom::number::complete::be_i128", &[]),
+    "be_f32" => ("nom::number::complete::be_f32", &[]),
+    "be_f64" => ("nom::number::complete::be_f64", &[]),
+    "le_u8" => ("nom::number::complete::le_u8", &[]),
+    "le_i8" => ("nom::number::complete::le_i8", &[]),
+    "le_u16" => ("nom::number::complete::le_u16", &[]),
+    "le_i16" => ("nom::number::complete::le_i16", &[]),
+    "le_u24" => ("nom::number::complete::le_u24", &[]),
+    "le_i24" => ("nom::number::complete::le_i24", &[]),
+    "le_u32" => ("nom::number::complete::le_u32", &[]),
+    "le_i32" => ("nom::number::complete::le_i32", &[]),
+    "le_u64" => ("nom::number::complete::le_u64", &[]),
+    "le_i64" => ("nom::number::complete::le_i64", &[]),
+    "le_u128" => ("nom::number::complete::le_u128", &[]),
+    "le_i128" => ("nom::number::complete::le_i128", &[]),
+    "le_f32" => ("nom::number::complete::le_f32", &[]),
+    "le_f64" => ("nom::number::complete::le_f64", &[]),
+    "hex_u32" => ("nom::number::complete::hex_u32", &[]),
+    "float" => ("nom::number::complete::float", &[]),
+    "double" => ("nom::number::complete::double", &[]),
     // From the nom::combinator module
     "rest" => ("nom::combinator::rest", &[]),
     "rest_len" => ("nom::combinator::rest_len", &[]),
diff --git a/tests/different_input_types.rs b/tests/different_input_types.rs
@@ -1,3 +1,4 @@
+use nom::error::Error;
 use nom_parse_macros::parse_from;
 use nom_parse_trait::ParseFromExt;
 
@@ -7,10 +8,13 @@ struct Test(i32);
 
 #[test]
 pub fn from_str() {
-    assert_eq!(Ok(Test(32)), Test::parse_complete("32"));
+    assert_eq!(Ok::<_, Error<_>>(Test(32)), Test::parse_complete("32"));
 }
 
 #[test]
 pub fn from_bytes() {
-    assert_eq!(Ok(Test(32)), Test::parse_complete(b"32".as_ref()));
-}
+    assert_eq!(
+        Ok::<_, Error<_>>(Test(32)),
+        Test::parse_complete(b"32".as_ref())
+    );
+}
diff --git a/tests/enums.rs b/tests/enums.rs
@@ -1,3 +1,4 @@
+use nom::error::Error;
 use nom_parse_macros::parse_from;
 use nom_parse_trait::ParseFromExt;
 
@@ -7,34 +8,47 @@ enum TestStruct {
     Number(u32),
     #[format(delimited('(', separated_list0(",", ()), ')'))]
     Numbers(Vec<u32>, #[derived(field_0.iter().sum())] u32),
-    #[format(delimited('"', map(alpha0, |s: &str| s.to_string()), '"'))]
+    #[format(delimited('"', map(alpha0, |s: I| String::from_utf8_lossy(s.as_bytes()).to_string()), '"'))]
     String {
         value: String,
         #[derived(value.len())]
         len: usize,
     },
+    #[format("dummy")]
+    Dummy,
 }
 
 #[test]
 fn test_number() {
-    assert_eq!(Ok(TestStruct::Number(32)), TestStruct::parse_complete("32"));
+    assert_eq!(
+        Ok::<_, Error<_>>(TestStruct::Number(32)),
+        TestStruct::parse_complete("32")
+    );
 }
 
 #[test]
 fn test_numbers() {
     assert_eq!(
-        Ok(TestStruct::Numbers(vec![32, 34, 46], 112)),
+        Ok::<_, Error<_>>(TestStruct::Numbers(vec![32, 34, 46], 112)),
         TestStruct::parse_complete("(32,34,46)")
     );
 }
 
 #[test]
 fn test_string() {
     assert_eq!(
-        Ok(TestStruct::String {
+        Ok::<_, Error<_>>(TestStruct::String {
             value: "dummy".to_string(),
             len: 5,
         }),
         TestStruct::parse_complete("\"dummy\"")
     )
 }
+
+#[test]
+fn test_dummy() {
+    assert_eq!(
+        Ok::<_, Error<_>>(TestStruct::Dummy),
+        TestStruct::parse_complete("dummy")
+    );
+}
diff --git a/tests/string_matching.rs b/tests/string_matching.rs
@@ -13,7 +13,7 @@ fn test_vector() {
     }
 
     assert_eq!(
-        Ok(Test { x: 1, y: 3, z: 4 }),
+        Ok::<_, Error<_>>(Test { x: 1, y: 3, z: 4 }),
         Test::parse_complete("(1,3,4)")
     );
 
diff --git a/tests/structs.rs b/tests/structs.rs

Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@ fn test_vector() {`
`13`	`13`	`}`
`14`	`14`
`15`	`15`	`assert_eq!(`
`16`		`- Ok(Test { x: 1, y: 3, z: 4 }),`
	`16`	`+ Ok::<_, Error<_>>(Test { x: 1, y: 3, z: 4 }),`
`17`	`17`	`Test::parse_complete("(1,3,4)")`
`18`	`18`	`);`
`19`	`19`