two parsers with macros, enum deps, allow dead code

bng_macros/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "bng_macros"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+proc-macro = true
+
+[dependencies]
+proc-macro2 = "1.0"
+quote = "1.0"
+syn = { version = "2.0", features = ["full"] }

bng_macros/src/lib.rs

@@ -0,0 +1,79 @@
+extern crate proc_macro;
+use proc_macro::TokenStream;
+use quote::quote;
+use syn::{parse_macro_input, Data, DataEnum, DeriveInput, Fields};
+
+#[proc_macro_derive(ModifierParser)]
+pub fn modifier_parser(input: TokenStream) -> TokenStream {
+    let ast = parse_macro_input!(input as DeriveInput);
+    impl_modifier_parser(ast)
+}
+
+#[proc_macro_derive(SlopeModifierParser)]
+pub fn slope_modifier_parser(input: TokenStream) -> TokenStream {
+    let ast = parse_macro_input!(input as DeriveInput);
+    impl_slope_modifier_parser(ast)
+}
+
+fn impl_modifier_parser(ast: DeriveInput) -> TokenStream {
+    let name = &ast.ident;
+    if let Data::Enum(DataEnum { variants, .. }) = ast.data {
+        let match_arms = variants.iter().map(|variant| {
+            let variant_name = &variant.ident;
+            let variant_type = if let Fields::Unnamed(ref fields) = variant.fields {
+                &fields.unnamed[0].ty
+            } else {
+                panic!("Expected unnamed fields in enum variants");
+            };
+
+            quote! {
+                nom::combinator::map(
+                    nom::sequence::preceded(
+                        nom::character::complete::char(#name::#variant_name(Default::default()).token()),
+                        nom::character::complete::#variant_type
+                    ),
+                    #name::#variant_name
+                )
+            }
+        });
+
+        quote! {
+            impl lex::lexer::Parse for #name {
+                fn parse(input: &str) -> nom::IResult<&str, #name> {
+                    nom::branch::alt((
+                        #(#match_arms),*
+                    ))(input)
+                }
+            }
+        }
+        .into()
+    } else {
+        panic!("this macro only works on enums")
+    }
+}
+
+fn impl_slope_modifier_parser(ast: DeriveInput) -> TokenStream {
+    let name = &ast.ident;
+    if let Data::Enum(DataEnum { variants, .. }) = ast.data {
+        let match_arms = variants.iter().map(|variant| {
+            let variant_name = &variant.ident;
+            quote! {
+                tag(#name::#variant_name)
+            }
+        });
+
+        quote! {
+            impl lex::lexer::Parse for #name {
+                fn parse(input: &str) -> nom::IResult<&str, #name> {
+                    let tag = |sm: SlopeModifier| nom::combinator::value(sm, nom::character::complete::char(sm.token()));
+                    nom::branch::alt((
+                        #(#match_arms),*
+                    ))(input)
+                }
+            }
+        }
+        .into()
+    } else {
+        panic!("this macro only works on enums")
+    }
+}