refactor: simplify macro parsing code and fix clippy warnings

10 files changed, 57 insertions, 54 deletions

diff --git a/mingling_macros/src/attr/command.rs b/mingling_macros/src/attr/command.rs
index 9598fa8..bec4dc2 100644
--- a/mingling_macros/src/attr/command.rs
+++ b/mingling_macros/src/attr/command.rs
@@ -51,8 +51,7 @@ impl Parse for CommandArgs {
                     entry = Some(input.parse()?);
                 } else {
                     return Err(input.error(format!(
-                        "unknown key `{}`; expected `node`, `name`, or `entry`",
-                        key
+                        "unknown key `{key}`; expected `node`, `name`, or `entry`"
                     )));
                 }
             } else {
@@ -67,7 +66,7 @@ impl Parse for CommandArgs {
             }
         }
 
-        Ok(CommandArgs {
+        Ok(Self {
             node,
             name,
             entry,
@@ -142,10 +141,10 @@ struct ResolvedNames {
 fn resolve_names(fn_name: &Ident, args: &CommandArgs) -> ResolvedNames {
     let fn_name_str = fn_name.to_string();
 
-    let node_str = match &args.node {
-        Some(lit) => lit.value(),
-        None => default_node_from_fn(fn_name),
-    };
+    let node_str = args
+        .node
+        .as_ref()
+        .map_or_else(|| default_node_from_fn(fn_name), syn::LitStr::value);
     let node_lit = syn::LitStr::new(&node_str, fn_name.span());
 
     let has_overrides = args.node.is_some() || args.name.is_some() || args.entry.is_some();
@@ -160,7 +159,7 @@ fn resolve_names(fn_name: &Ident, args: &CommandArgs) -> ResolvedNames {
         Ident::new(&format!("Entry{pascal}"), fn_name.span())
     });
 
-    let chain_fn_name = Ident::new(&format!("__command_chain_{}", fn_name_str), fn_name.span());
+    let chain_fn_name = Ident::new(&format!("__command_chain_{fn_name_str}"), fn_name.span());
 
     ResolvedNames {
         node_lit,
@@ -213,7 +212,7 @@ fn build_wrapper_params(
         let mut params = syn::punctuated::Punctuated::new();
         let entry_param: FnArg = syn::parse_quote! { _args: #entry_type };
         params.push(entry_param);
-        for arg in sig.inputs.iter() {
+        for arg in &sig.inputs {
             params.push(arg.clone());
         }
         params
@@ -317,7 +316,7 @@ pub(crate) fn command_attr(attr: TokenStream, item: TokenStream) -> TokenStream
     let wrapper_full = format!("__command_chain_{}", &fn_name_s);
     let snaked_wrapper = just_fmt::snake_case!(wrapper_full);
     let chain_internal = Ident::new(
-        &format!("__internal_chain_{}", snaked_wrapper),
+        &format!("__internal_chain_{snaked_wrapper}"),
         fn_name.span(),
     );
 
diff --git a/mingling_macros/src/attr/dispatcher_clap.rs b/mingling_macros/src/attr/dispatcher_clap.rs
index 218750c..c0665d0 100644
--- a/mingling_macros/src/attr/dispatcher_clap.rs
+++ b/mingling_macros/src/attr/dispatcher_clap.rs
@@ -39,11 +39,11 @@ impl Parse for ClapOptions {
                 error_struct = Some(value);
             } else if key == "help" {
                 let value: LitBool = input.parse()?;
-                if !value.value() {
+                if value.value() {
+                    help_enabled = true;
+                } else {
                     // help = false is allowed but does nothing
                     help_enabled = false;
-                } else {
-                    help_enabled = true;
                 }
             } else {
                 return Err(syn::Error::new(
@@ -53,14 +53,14 @@ impl Parse for ClapOptions {
             }
         }
 
-        Ok(ClapOptions {
+        Ok(Self {
             error_struct,
             help_enabled,
         })
     }
 }
 
-/// Input for the dispatcher_clap attribute
+/// Input for the `dispatcher_clap` attribute
 struct DispatcherClapInput {
     /// `("cmd", Disp, ...)`
     command_name: LitStr,
@@ -84,7 +84,7 @@ impl Parse for DispatcherClapInput {
             input.parse::<ClapOptions>()?
         };
 
-        Ok(DispatcherClapInput {
+        Ok(Self {
             command_name,
             dispatcher_struct,
             options,
@@ -105,28 +105,31 @@ pub(crate) fn dispatcher_clap_attr(attr: TokenStream, item: TokenStream) -> Toke
     let options = &attr_input.options;
 
     // Generate the `begin` method body
-    let begin_body = if let Some(ref error_struct) = options.error_struct {
-        quote! {
-            if ::mingling::this::<#program_path>().user_context.help {
-                return ::mingling::Routable::<#program_path>::to_chain(#struct_name::default());
-            }
-            match <#struct_name as ::clap::Parser>::try_parse_from(clap_args) {
-                Ok(parsed) => ::mingling::Routable::<#program_path>::to_chain(parsed),
-                Err(e) => {
-                    return ::mingling::Routable::<#program_path>::to_render(#error_struct::new(format!("{}", e.render().ansi())))
-                },
+    let begin_body = options.error_struct.as_ref().map_or_else(
+        || {
+            quote! {
+                if ::mingling::this::<#program_path>().user_context.help {
+                    return ::mingling::Routable::<#program_path>::to_chain(#struct_name::default());
+                }
+                let parsed = <#struct_name as ::clap::Parser>::try_parse_from(clap_args)
+                    .unwrap_or_else(|e| e.exit());
+                ::mingling::Routable::<#program_path>::to_chain(parsed)
             }
-        }
-    } else {
-        quote! {
-            if ::mingling::this::<#program_path>().user_context.help {
-                return ::mingling::Routable::<#program_path>::to_chain(#struct_name::default());
+        },
+        |error_struct| {
+            quote! {
+                if ::mingling::this::<#program_path>().user_context.help {
+                    return ::mingling::Routable::<#program_path>::to_chain(#struct_name::default());
+                }
+                match <#struct_name as ::clap::Parser>::try_parse_from(clap_args) {
+                    Ok(parsed) => ::mingling::Routable::<#program_path>::to_chain(parsed),
+                    Err(e) => {
+                        return ::mingling::Routable::<#program_path>::to_render(#error_struct::new(format!("{}", e.render().ansi())))
+                    },
+                }
             }
-            let parsed = <#struct_name as ::clap::Parser>::try_parse_from(clap_args)
-                .unwrap_or_else(|e| e.exit());
-            ::mingling::Routable::<#program_path>::to_chain(parsed)
-        }
-    };
+        },
+    );
 
     // Generate the error pack type
     let error_pack = options.error_struct.as_ref().map(|error_struct| {
diff --git a/mingling_macros/src/attr/program_setup.rs b/mingling_macros/src/attr/program_setup.rs
index dee5a1c..fa01178 100644
--- a/mingling_macros/src/attr/program_setup.rs
+++ b/mingling_macros/src/attr/program_setup.rs
@@ -47,7 +47,7 @@ fn extract_return_type(sig: &Signature) -> syn::Result<()> {
     }
 }
 
-pub(crate) fn setup_attr(attr: TokenStream, item: TokenStream) -> TokenStream {
+pub(crate) fn setup_attr(attr: &TokenStream, item: TokenStream) -> TokenStream {
     // #[program_setup] takes no arguments; always use the default program path
     let _ = attr;
     let program_path = crate::default_program_path();
diff --git a/mingling_macros/src/func/dispatcher.rs b/mingling_macros/src/func/dispatcher.rs
index d834c95..bbe1074 100644
--- a/mingling_macros/src/func/dispatcher.rs
+++ b/mingling_macros/src/func/dispatcher.rs
@@ -32,7 +32,7 @@ impl Parse for DispatcherChainInput {
             if input.is_empty() {
                 #[cfg(feature = "extras")]
                 {
-                    return Ok(DispatcherChainInput::Auto {
+                    return Ok(Self::Auto {
                         cmd_attrs,
                         command_name,
                     });
diff --git a/mingling_macros/src/func/entry.rs b/mingling_macros/src/func/entry.rs
index 35209e5..76fbc15 100644
--- a/mingling_macros/src/func/entry.rs
+++ b/mingling_macros/src/func/entry.rs
@@ -18,11 +18,11 @@ impl syn::parse::Parse for EntryInput {
             let content;
             syn::bracketed!(content in input);
             let strings = parse_strings(&content)?;
-            Ok(EntryInput::Typed { ident, strings })
+            Ok(Self::Typed { ident, strings })
         } else {
             // entry!["a", "b", "c"]  — bare bracket content
             let strings = parse_strings(input)?;
-            Ok(EntryInput::Untyped { strings })
+            Ok(Self::Untyped { strings })
         }
     }
 }
diff --git a/mingling_macros/src/func/group.rs b/mingling_macros/src/func/group.rs
index edb1fe1..8ca46d9 100644
--- a/mingling_macros/src/func/group.rs
+++ b/mingling_macros/src/func/group.rs
@@ -33,10 +33,10 @@ impl Parse for GroupInput {
             let alias: Ident = input.parse()?;
             let _eq: syn::Token![=] = input.parse()?;
             let type_path: TypePath = input.parse()?;
-            Ok(GroupInput::Aliased { alias, type_path })
+            Ok(Self::Aliased { alias, type_path })
         } else {
             let type_path: TypePath = input.parse()?;
-            Ok(GroupInput::Plain(type_path))
+            Ok(Self::Plain(type_path))
         }
     }
 }
diff --git a/mingling_macros/src/func/group_structural.rs b/mingling_macros/src/func/group_structural.rs
index 2bd2f83..3e6dbc5 100644
--- a/mingling_macros/src/func/group_structural.rs
+++ b/mingling_macros/src/func/group_structural.rs
@@ -115,10 +115,10 @@ impl syn::parse::Parse for GroupStructuralInput {
             let alias: Ident = input.parse()?;
             let _eq: syn::Token![=] = input.parse()?;
             let type_path: TypePath = input.parse()?;
-            Ok(GroupStructuralInput::Aliased { alias, type_path })
+            Ok(Self::Aliased { alias, type_path })
         } else {
             let type_path: TypePath = input.parse()?;
-            Ok(GroupStructuralInput::Plain(type_path))
+            Ok(Self::Plain(type_path))
         }
     }
 }
diff --git a/mingling_macros/src/func/pack_err.rs b/mingling_macros/src/func/pack_err.rs
index 8b224b0..dcfcf86 100644
--- a/mingling_macros/src/func/pack_err.rs
+++ b/mingling_macros/src/func/pack_err.rs
@@ -4,9 +4,9 @@ use quote::quote;
 use syn::{Ident, Token, Type, parse_macro_input};
 
 enum PackErrInput {
-    /// pack_err!(ErrorNotFound)
+    /// `pack_err!(ErrorNotFound)`
     Simple { type_name: Ident },
-    /// pack_err!(ErrorNotDir = PathBuf)
+    /// `pack_err!(ErrorNotDir = PathBuf)`
     Typed {
         type_name: Ident,
         inner_type: Box<Type>,
@@ -20,12 +20,12 @@ impl syn::parse::Parse for PackErrInput {
         if input.peek(Token![=]) {
             input.parse::<Token![=]>()?;
             let inner_type: Type = input.parse()?;
-            Ok(PackErrInput::Typed {
+            Ok(Self::Typed {
                 type_name,
                 inner_type: Box::new(inner_type),
             })
         } else {
-            Ok(PackErrInput::Simple { type_name })
+            Ok(Self::Simple { type_name })
         }
     }
 }
diff --git a/mingling_macros/src/func/pack_err_structural.rs b/mingling_macros/src/func/pack_err_structural.rs
index 7d3a6f8..2c4a2fb 100644
--- a/mingling_macros/src/func/pack_err_structural.rs
+++ b/mingling_macros/src/func/pack_err_structural.rs
@@ -9,8 +9,9 @@ pub(crate) fn pack_err_structural(input: TokenStream) -> TokenStream {
     let parsed = parse_macro_input!(input as PackErrInput);
 
     let type_name = match &parsed {
-        PackErrInput::Simple { type_name } => type_name.clone(),
-        PackErrInput::Typed { type_name, .. } => type_name.clone(),
+        PackErrInput::Simple { type_name } | PackErrInput::Typed { type_name, .. } => {
+            type_name.clone()
+        }
     };
 
     // Register in STRUCTURED_TYPES
@@ -108,12 +109,12 @@ impl syn::parse::Parse for PackErrInput {
         if input.peek(Token![=]) {
             input.parse::<Token![=]>()?;
             let inner_type: Type = input.parse()?;
-            Ok(PackErrInput::Typed {
+            Ok(Self::Typed {
                 type_name,
                 inner_type: Box::new(inner_type),
             })
         } else {
-            Ok(PackErrInput::Simple { type_name })
+            Ok(Self::Simple { type_name })
         }
     }
 }
diff --git a/mingling_macros/src/lib.rs b/mingling_macros/src/lib.rs
index c87584d..6ae8693 100644
--- a/mingling_macros/src/lib.rs
+++ b/mingling_macros/src/lib.rs
@@ -438,7 +438,7 @@ pub fn pack_structural(input: TokenStream) -> TokenStream {
 /// This macro provides a concise way to define error types that implement `Grouped`
 /// and are registered for inclusion in the program enum.
 ///
-/// The `name` field is automatically set to the snake_case version of the struct name
+/// The `name` field is automatically set to the `snake_case` version of the struct name
 /// at compile time.
 ///
 /// # Syntax
@@ -1101,7 +1101,7 @@ pub fn completion(attr: TokenStream, item: TokenStream) -> TokenStream {
 #[cfg(feature = "extras")]
 #[proc_macro_attribute]
 pub fn program_setup(attr: TokenStream, item: TokenStream) -> TokenStream {
-    program_setup::setup_attr(attr, item)
+    program_setup::setup_attr(&attr, item)
 }
 
 /// Declares a command from a plain function.