supp_macro/

lib.rs

use proc_macro::TokenStream;
use quote::quote;
use syn::Lit;
use syn::{Data, DeriveInput, Fields, ItemFn, Path, parse_macro_input};

#[proc_macro_attribute]
pub fn local_db_sqlx_test(_attr: TokenStream, item: TokenStream) -> TokenStream {
    let input = parse_macro_input!(item as ItemFn);
    let fn_name = &input.sig.ident;
    let block = &input.block;

    let expanded = quote! {
        #[sqlx::test(migrator = "server::db::MIGRATOR")]
        async fn #fn_name(pool: PgPool) -> Result<(), anyhow::Error> {
            setup().await;
            DB_POOL.set(Some(pool.clone()));
            #block
        Ok(())
        }
    };

    TokenStream::from(expanded)
}

/// Runs an async test body on ONE runtime shared by the whole test binary,
/// obtained from `crate::common::runtime()` (as [`local_db_sqlx_test`] expects
/// `setup()`).
///
/// `#[tokio::test]` builds a runtime per test and drops it when the test ends.
/// `server::db`'s production pool is a process-wide `OnceCell`, so connections
/// opened inside the first test's runtime are still pooled after that runtime is
/// gone, and a later acquire fails with "A Tokio 1.x context was found, but it
/// is being shutdown" — inside whatever test happened to run next, which is why
/// it reads as a bug in unrelated code.
#[proc_macro_attribute]
pub fn shared_runtime_test(_attr: TokenStream, item: TokenStream) -> TokenStream {
    let input = parse_macro_input!(item as ItemFn);
    if !input.sig.inputs.is_empty() {
        return syn::Error::new_spanned(&input.sig, "shared_runtime_test takes no arguments")
            .to_compile_error()
            .into();
    }
    let fn_name = &input.sig.ident;
    let output = &input.sig.output;
    let block = &input.block;
    let attrs = &input.attrs;

    // The return type is preserved and the value returned: erasing it would let
    // a test that returns `Err` pass with only an unused-`Result` warning.
    TokenStream::from(quote! {
        #[test]
        #(#attrs)*
        fn #fn_name() #output {
            crate::common::runtime().block_on(async #block)
        }
    })
}

#[proc_macro_derive(Builder, attributes(builder))]
pub fn builder_macro(input: TokenStream) -> TokenStream {
    // Parse the input tokens into a syntax tree
    let input = parse_macro_input!(input as DeriveInput);
    let name = &input.ident;
    let generics = &input.generics; // Capture generics (including lifetimes)
    let builder_name = syn::Ident::new(&format!("{name}Builder"), name.span());

    // Check for custom error_kind attribute
    let mut error_kind = None;

    // Parse attributes
    for attr in &input.attrs {
        if attr.path().is_ident("builder") {
            attr.parse_nested_meta(|meta| {
                if meta.path.is_ident("error_kind")
                    && let Ok(Lit::Str(lit_str)) = meta.value()?.parse()
                {
                    error_kind = Some(lit_str.parse::<Path>().unwrap());
                }
                Ok(())
            })
            .unwrap();
        }
    }

    // Set a default error kind if none is provided
    let error_kind = error_kind.expect(
        "Error kind (e.g., FinanceError) must be specified with #[builder(error_kind = \"...\")]",
    );

    // Define a custom error type based on the struct name, e.g., CommodityError for Commodity
    let custom_error_name = syn::Ident::new(&format!("{name}Error"), name.span());

    let fields = if let Data::Struct(data) = &input.data {
        if let Fields::Named(fields) = &data.fields {
            fields.named.iter().collect::<Vec<_>>()
        } else {
            panic!("Builder macro only supports structs with named fields");
        }
    } else {
        panic!("Builder macro only supports structs");
    };

    // Generate builder struct fields with the same generics (including lifetimes)
    let builder_fields = fields.iter().map(|field| {
        let field_name = &field.ident;
        let field_ty = &field.ty;
        let builder_field_type = quote! { Option<#field_ty> };
        quote! {
            #field_name: #builder_field_type
        }
    });

    // Generate initialization in new()
    let builder_fields_init = fields.iter().map(|field| {
        let field_name = &field.ident;
        quote! {
            #field_name: None
        }
    });

    // Generate setter methods
    let setters = fields.iter().map(|field| {
        let field_name = &field.ident;
        let field_type = &field.ty;

        if is_option_type(field_type) {
            let inner_type = get_inner_type(field_type);
            if is_string_type(&inner_type) {
                // For Option<String>, accept &str
                quote! {
                    pub fn #field_name(&mut self, value: &str) -> &mut Self {
                        self.#field_name = Some(Some(value.to_string()));
                        self
                    }
                }
            } else {
                // For Option<T>, accept T directly
                quote! {
                    pub fn #field_name(&mut self, value: #inner_type) -> &mut Self {
                        self.#field_name = Some(Some(value));
                        self
                    }
                }
            }
        } else if is_string_type(field_type) {
            // For String, accept &str
            quote! {
                pub fn #field_name(&mut self, value: &str) -> &mut Self {
                    self.#field_name = Some(value.to_string());
                    self
                }
            }
        } else {
            // For non-Option<T> and non-String fields, accept T directly
            quote! {
                pub fn #field_name(&mut self, value: #field_type) -> &mut Self {
                    self.#field_name = Some(value);
                    self
                }
            }
        }
    });

    // Generate code to check for missing required fields
    let check_required_fields = fields
        .iter()
        .filter(|field| !is_option_type(&field.ty))
        .map(|field| {
            let field_name = &field.ident;
            let field_name_str = field_name.as_ref().unwrap().to_string();
            quote! {
                if self.#field_name.is_none() {
                    missing_fields.push(#field_name_str);
                }
            }
        });

    // Generate build_fields
    let build_fields = fields.iter().map(|field| {
        let field_name = &field.ident;
        if is_option_type(&field.ty) {
            quote! {
                #field_name: self.#field_name.clone().unwrap_or(None)
            }
        } else {
            quote! {
                #field_name: self.#field_name.clone().unwrap()
            }
        }
    });

    // Extract the lifetime parameters from generics for use in the builder struct
    let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();

    let expanded = quote! {
        pub struct #builder_name #impl_generics #where_clause {
            #(#builder_fields),*
        }

        impl #impl_generics #builder_name #ty_generics #where_clause {
            pub fn new() -> Self {
                Self {
                    #(#builder_fields_init),*
                }
            }

            #(#setters)*

            pub fn build(&self) -> Result<#name #ty_generics, #error_kind> {
                let mut missing_fields = Vec::new();
                #(#check_required_fields)*

                if !missing_fields.is_empty() {
                    return Err(#error_kind::from(#custom_error_name::Build(format!(
                        "{} fields are missing: {}",
                        stringify!(#name),
                        missing_fields.join(", ")
                    ))));
                }

                Ok(#name {
                    #(#build_fields),*
                })
            }
        }

        impl #impl_generics #name #ty_generics #where_clause {
            pub fn builder() -> #builder_name #ty_generics {
                #builder_name::new()
            }
        }
    };

    TokenStream::from(expanded)
}

/// Helper function to determine if a type is an `Option<T>`
fn is_option_type(ty: &syn::Type) -> bool {
    matches!(ty, syn::Type::Path(syn::TypePath { path: syn::Path { segments, .. }, .. }) if segments.iter().any(|segment| segment.ident == "Option"))
}

/// Helper function to get the inner type of an `Option<T>`
fn get_inner_type(ty: &syn::Type) -> syn::Type {
    if let syn::Type::Path(type_path) = ty
        && let Some(segment) = type_path.path.segments.first()
        && segment.ident == "Option"
        && let syn::PathArguments::AngleBracketed(args) = &segment.arguments
        && let Some(syn::GenericArgument::Type(inner_type)) = args.args.first()
    {
        return inner_type.clone();
    }
    ty.clone()
}

/// Helper function to check if the type is String
fn is_string_type(ty: &syn::Type) -> bool {
    if let syn::Type::Path(type_path) = ty
        && let Some(segment) = type_path.path.segments.last()
    {
        return segment.ident == "String";
    }
    false
}

/// A procedural macro for generating typed Command implementations with compile-time validation.
///
/// This macro provides pure value-based argument passing with compile-time type safety by generating:
/// - Typed Args structs with proper field types passed by value only
/// - Commands that accept Args structs directly (no `HashMap` usage)
/// - Individual typed variables available directly in command scope
/// - Compile-time validation of argument types and required/optional fields
/// - Zero runtime argument parsing or validation overhead
///
/// # Syntax
///
/// ```ignore
/// command! {
///     CommandName {
///         #[required]
///         arg_name: Type,
///         #[optional]
///         opt_name: Type,
///     } => {
///         // Command implementation body
///         // Individual typed variables are available in scope
///     }
/// }
/// ```
///
/// # Generated Code
///
/// The macro generates:
/// - A `CommandNameArgs` struct with typed fields (required fields as `Type`, optional as `Option<Type>`)
/// - A `CommandName` struct implementing `Command` trait with typed `run(args: CommandNameArgs)` method
/// - Individual typed variables extracted from the Args struct and available in the command body
/// - Pure compile-time type validation with no runtime overhead
///
/// # Examples
///
/// ## Simple command with no arguments
///
/// ```rust
/// # use supp_macro::command;
/// # use async_trait::async_trait;
/// #
/// # #[derive(Debug)]
/// # pub enum CmdError {
/// #     Args(String),
/// # }
/// #
/// # impl std::fmt::Display for CmdError {
/// #     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
/// #         match self {
/// #             CmdError::Args(msg) => write!(f, "Argument error: {}", msg),
/// #         }
/// #     }
/// # }
/// #
/// # impl std::error::Error for CmdError {}
/// #
/// # #[derive(Debug)]
/// # pub enum CmdResult {
/// #     String(String),
/// # }
/// #
/// # #[derive(Debug, Default)]
/// # pub struct CommandArgs {}
/// # impl CommandArgs { pub fn new() -> Self { Self::default() } }
/// #
/// # #[async_trait]
/// # pub trait Command: std::fmt::Debug {
/// #     type Args;
/// #     async fn run(&self, args: Self::Args) -> Result<Option<CmdResult>, CmdError>;
/// # }
///
/// command! {
///     GetVersion {
///     } => {
///         Ok(Some(CmdResult::String("1.0.0".to_string())))
///     }
/// }
///
/// # #[tokio::main]
/// # async fn main() {
/// let result = GetVersion::new().run().await.unwrap();
/// # }
/// ```
///
/// ## Command with required arguments (server-compatible types)
///
/// ```rust
/// # use supp_macro::command;
/// # use async_trait::async_trait;
/// # use uuid::Uuid;
/// # use num_rational::Rational64;
/// #
/// # #[derive(Debug, Clone)]
/// # pub enum Argument {
/// #     String(String),
/// #     Uuid(Uuid),
/// #     Rational(Rational64),
/// # }
/// #
/// # #[derive(Debug)]
/// # pub enum CmdError {
/// #     Args(String),
/// # }
/// #
/// # impl std::fmt::Display for CmdError {
/// #     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
/// #         match self {
/// #             CmdError::Args(msg) => write!(f, "Argument error: {}", msg),
/// #         }
/// #     }
/// # }
/// #
/// # impl std::error::Error for CmdError {}
/// #
/// # #[derive(Debug)]
/// # pub enum CmdResult {
/// #     String(String),
/// # }
/// #
/// # #[derive(Debug, Default)]
/// # pub struct CommandArgs {
/// #     pub symbol: Option<String>,
/// #     pub name: Option<String>,
/// #     pub user_id: Option<uuid::Uuid>,
/// # }
/// # impl CommandArgs {
/// #     pub fn new() -> Self { Self::default() }
/// #     pub fn symbol(mut self, v: String) -> Self { self.symbol = Some(v); self }
/// #     pub fn name(mut self, v: String) -> Self { self.name = Some(v); self }
/// #     pub fn user_id(mut self, v: uuid::Uuid) -> Self { self.user_id = Some(v); self }
/// # }
/// #
/// # #[async_trait]
/// # pub trait Command: std::fmt::Debug {
/// #     type Args;
/// #     async fn run(&self, args: Self::Args) -> Result<Option<CmdResult>, CmdError>;
/// # }
///
/// // This creates a commodity in the financial system
/// command! {
///     CreateCommodity {
///         #[required]
///         symbol: String,
///         #[required]
///         name: String,
///         #[required]
///         user_id: Uuid,
///     } => {
///         // Individual typed variables are automatically available
///         Ok(Some(CmdResult::String(format!(
///             "Created commodity {} ({}) for user {}",
///             name, symbol, user_id
///         ))))
///     }
/// }
///
/// # #[tokio::main]
/// # async fn main() {
/// let result = CreateCommodity::new()
///     .symbol("USD".to_string())
///     .name("US Dollar".to_string())
///     .user_id(uuid::Uuid::new_v4())
///     .run()
///     .await
///     .unwrap();
/// # }
/// ```
///
/// ## Command with optional arguments
///
/// ```rust
/// # use supp_macro::command;
/// # use async_trait::async_trait;
/// # use uuid::Uuid;
/// #
/// # #[derive(Debug, Clone)]
/// # pub enum Argument {
/// #     String(String),
/// #     Uuid(Uuid),
/// # }
/// #
/// # #[derive(Debug)]
/// # pub enum CmdError {
/// #     Args(String),
/// # }
/// #
/// # impl std::fmt::Display for CmdError {
/// #     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
/// #         match self {
/// #             CmdError::Args(msg) => write!(f, "Argument error: {}", msg),
/// #         }
/// #     }
/// # }
/// #
/// # impl std::error::Error for CmdError {}
/// #
/// # #[derive(Debug)]
/// # pub enum CmdResult {
/// #     String(String),
/// # }
/// #
/// # #[derive(Debug, Default)]
/// # pub struct CommandArgs {
/// #     pub user_id: Option<uuid::Uuid>,
/// #     pub account: Option<String>,
/// # }
/// # impl CommandArgs {
/// #     pub fn new() -> Self { Self::default() }
/// #     pub fn user_id(mut self, v: uuid::Uuid) -> Self { self.user_id = Some(v); self }
/// #     pub fn account(mut self, v: String) -> Self { self.account = Some(v); self }
/// # }
/// #
/// # #[async_trait]
/// # pub trait Command: std::fmt::Debug {
/// #     type Args;
/// #     async fn run(&self, args: Self::Args) -> Result<Option<CmdResult>, CmdError>;
/// # }
///
/// command! {
///     ListTransactions {
///         #[required]
///         user_id: Uuid,
///         #[optional]
///         account: String,
///     } => {
///         let filter = if let Some(account) = account {
///             format!(" for account {}", account)
///         } else {
///             String::new()
///         };
///         Ok(Some(CmdResult::String(format!("Listing transactions for user {}{}", user_id, filter))))
///     }
/// }
/// ```
///
/// ## Command with mixed required and optional arguments
///
/// ```rust
/// # use supp_macro::command;
/// # use async_trait::async_trait;
/// #
/// # #[derive(Debug, Clone)]
/// # pub enum Argument {
/// #     String(String),
/// #     Integer(i64),
/// #     Boolean(bool),
/// # }
/// #
/// # #[derive(Debug)]
/// # pub enum CmdError {
/// #     Args(String),
/// # }
/// #
/// # impl std::fmt::Display for CmdError {
/// #     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
/// #         match self {
/// #             CmdError::Args(msg) => write!(f, "Argument error: {}", msg),
/// #         }
/// #     }
/// # }
/// #
/// # impl std::error::Error for CmdError {}
/// #
/// # #[derive(Debug)]
/// # pub enum CmdResult {
/// #     Success(String),
/// # }
/// #
/// # impl TryFrom<Argument> for String {
/// #     type Error = CmdError;
/// #     fn try_from(arg: Argument) -> Result<Self, Self::Error> {
/// #         match arg {
/// #             Argument::String(s) => Ok(s),
/// #             _ => Err(CmdError::Args(format!("Cannot convert {:?} to String", arg))),
/// #         }
/// #     }
/// # }
/// #
/// # impl TryFrom<Argument> for i64 {
/// #     type Error = CmdError;
/// #     fn try_from(arg: Argument) -> Result<Self, Self::Error> {
/// #         match arg {
/// #             Argument::Integer(i) => Ok(i),
/// #             _ => Err(CmdError::Args(format!("Cannot convert {:?} to i64", arg))),
/// #         }
/// #     }
/// # }
/// #
/// # impl TryFrom<Argument> for bool {
/// #     type Error = CmdError;
/// #     fn try_from(arg: Argument) -> Result<Self, Self::Error> {
/// #         match arg {
/// #             Argument::Boolean(b) => Ok(b),
/// #             _ => Err(CmdError::Args(format!("Cannot convert {:?} to bool", arg))),
/// #         }
/// #     }
/// # }
/// #
/// # #[async_trait]
/// # pub trait TypedCommand {
/// #     type Args;
/// #     async fn run_typed(&self, args: Self::Args) -> Result<Option<CmdResult>, CmdError>;
/// # }
/// #
/// # #[derive(Debug, Default)]
/// # pub struct CommandArgs {
/// #     pub user_id: Option<i64>,
/// #     pub username: Option<String>,
/// #     pub email: Option<String>,
/// #     pub is_admin: Option<bool>,
/// # }
/// # impl CommandArgs {
/// #     pub fn new() -> Self { Self::default() }
/// #     pub fn user_id(mut self, v: i64) -> Self { self.user_id = Some(v); self }
/// #     pub fn username(mut self, v: String) -> Self { self.username = Some(v); self }
/// #     pub fn email(mut self, v: String) -> Self { self.email = Some(v); self }
/// #     pub fn is_admin(mut self, v: bool) -> Self { self.is_admin = Some(v); self }
/// # }
/// #
/// # #[async_trait]
/// # pub trait Command {
/// #     type Args;
/// #     async fn run(&self, args: Self::Args) -> Result<Option<CmdResult>, CmdError>;
/// # }
///
/// command! {
///     CreateUserCommand {
///         #[required]
///         user_id: i64,
///         #[required]
///         username: String,
///         #[optional]
///         email: String,
///         #[optional]
///         is_admin: bool,
///     } => {
///         let email_str = email.map_or_else(|| format!("{}@example.com", username), |s| s.to_string());
///         let admin_status = is_admin.unwrap_or(false);
///
///         let message = format!(
///             "Created user {} (ID: {}, Email: {}, Admin: {})",
///             username, user_id, email_str, admin_status
///         );
///         Ok(Some(CmdResult::Success(message)))
///     }
/// }
///
/// # #[tokio::main]
/// # async fn main() {
/// let result = CreateUserCommand::new()
///     .user_id(123)
///     .username("alice".to_string())
///     .is_admin(true)
///     .run()
///     .await
///     .unwrap();
/// # }
/// ```
///
/// ## Server-compatible Command implementation
///
/// ```rust
/// # use supp_macro::command;
/// # use async_trait::async_trait;
/// #
/// # #[derive(Debug, Clone)]
/// # pub enum Argument {
/// #     String(String),
/// #     Integer(i64),
/// #     Boolean(bool),
/// # }
/// #
/// # #[derive(Debug)]
/// # pub enum CmdError {
/// #     Args(String),
/// # }
/// #
/// # impl std::fmt::Display for CmdError {
/// #     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
/// #         match self {
/// #             CmdError::Args(msg) => write!(f, "Argument error: {}", msg),
/// #         }
/// #     }
/// # }
/// #
/// # impl std::error::Error for CmdError {}
/// #
/// # #[derive(Debug)]
/// # pub enum CmdResult {
/// #     Success(String),
/// # }
/// #
/// # #[derive(Debug, Default)]
/// # pub struct CommandArgs {
/// #     pub a: Option<i64>,
/// #     pub b: Option<i64>,
/// # }
/// # impl CommandArgs {
/// #     pub fn new() -> Self { Self::default() }
/// #     pub fn a(mut self, v: i64) -> Self { self.a = Some(v); self }
/// #     pub fn b(mut self, v: i64) -> Self { self.b = Some(v); self }
/// # }
/// #
/// # #[async_trait]
/// # pub trait Command {
/// #     type Args;
/// #     async fn run(&self, args: Self::Args) -> Result<Option<CmdResult>, CmdError>;
/// # }
///
/// command! {
///     CalculateCommand {
///         #[required]
///         a: i64,
///         #[required]
///         b: i64,
///     } => {
///         let result = a + b;
///         Ok(Some(CmdResult::Success(format!("{} + {} = {}", a, b, result))))
///     }
/// }
///
/// # #[tokio::main]
/// # async fn main() {
/// let result = CalculateCommand::new()
///     .a(10)
///     .b(20)
///     .run()
///     .await
///     .unwrap();
/// # }
/// ```
///
/// ## Migration from Manual Commands
///
/// The macro makes it easy to migrate from manual Command implementations:
///
/// ```rust,ignore
/// // BEFORE: Manual implementation
/// #[derive(Debug)]
/// pub struct GetConfig;
///
/// #[async_trait]
/// impl Command for GetConfig {
///     async fn run<'a>(&self, args: &'a HashMap<&'a str, &'a Argument>) -> Result<Option<CmdResult>, CmdError> {
///         if let Some(Argument::String(name)) = args.get("name") {
///             Ok(config(name).await?.map(|v| CmdResult::String(v)))
///         } else {
///             Err(CmdError::Args("No field name provided".to_string()))
///         }
///     }
/// }
///
/// // AFTER: Using the macro
/// command! {
///     GetConfig {
///         #[required]
///         name: String,
///     } => {
///         Ok(config(name).await?.map(|v| CmdResult::String(v)))
///     }
/// }
/// ```
///
/// # Error Handling
///
/// The new pure typed system provides compile-time error prevention:
///
/// - Missing required arguments are compile-time errors (cannot compile without them)
/// - Invalid argument types are compile-time errors (type checking at build time)
/// - Runtime errors only occur in the command body logic itself
/// - No argument validation overhead at runtime
///
/// # Supported Argument Types
///
/// The macro supports any Rust type for arguments:
/// - `String` - Text arguments
/// - `i64`, `u64`, etc. - Integer arguments
/// - `bool` - Boolean arguments
/// - `Rational64` - Rational number arguments (for financial precision)
/// - `Uuid` - UUID arguments
/// - `Vec<u8>` - Binary data arguments
/// - `DateTime<Utc>` - `DateTime` arguments
/// - Custom types - Any type can be used as an argument
/// - `Option<T>` - Automatically applied for optional arguments
#[proc_macro]
pub fn command(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as CommandInput);

    let name = &input.name;
    let required_args = &input.required_args;
    let optional_args = &input.optional_args;
    let body = &input.body;

    // Generate progressive runner types for all combinations of required fields
    let runner_types = generate_progressive_runner_types(name, required_args, optional_args, body);

    // Generate the main command struct
    let command_struct = quote! {
        #[derive(Debug)]
        pub struct #name;
    };

    // Generate the new() method that starts the builder chain
    let new_method = generate_new_method(name, required_args.len(), optional_args);

    let expanded = quote! {
        #command_struct

        #runner_types

        #new_method
    };

    TokenStream::from(expanded)
}

/// Generate all possible runner type combinations for required fields
fn generate_progressive_runner_types(
    command_name: &syn::Ident,
    required_args: &[(syn::Ident, syn::Type)],
    optional_args: &[(syn::Ident, syn::Type)],
    body: &syn::Block,
) -> proc_macro2::TokenStream {
    let num_required = required_args.len();
    let total_combinations = 1 << num_required; // 2^num_required

    let mut runner_types = Vec::new();

    // Generate a runner type for each possible combination of set required fields
    for combination in 0..total_combinations {
        let runner_type = generate_single_runner_type(
            command_name,
            required_args,
            optional_args,
            combination,
            num_required,
            body,
        );
        runner_types.push(runner_type);
    }

    quote! {
        #(#runner_types)*
    }
}

/// Generate a single runner type for a specific combination of set fields
fn generate_single_runner_type(
    command_name: &syn::Ident,
    required_args: &[(syn::Ident, syn::Type)],
    optional_args: &[(syn::Ident, syn::Type)],
    combination: usize,
    num_required: usize,
    body: &syn::Block,
) -> proc_macro2::TokenStream {
    // Create binary representation for the runner type name
    let binary_suffix = format!("{:0width$b}", combination, width = num_required.max(1));
    let runner_name = syn::Ident::new(
        &format!("{command_name}Runner{binary_suffix}"),
        command_name.span(),
    );

    // Determine which required fields are set in this combination
    let mut struct_fields = Vec::new();
    for (i, (field_name, field_type)) in required_args.iter().enumerate() {
        if (combination >> i) & 1 == 1 {
            // This required field is set in this combination
            struct_fields.push(quote! {
                pub #field_name: #field_type
            });
        }
    }

    // Always include optional fields in all runner types
    for (field_name, field_type) in optional_args {
        struct_fields.push(quote! {
            pub #field_name: Option<#field_type>
        });
    }

    // Generate the struct definition
    let struct_def = if struct_fields.is_empty() {
        quote! {
            #[derive(Debug)]
            pub struct #runner_name;
        }
    } else {
        quote! {
            #[derive(Debug)]
            pub struct #runner_name {
                #(#struct_fields),*
            }
        }
    };

    // Generate transition methods for this runner type
    let transition_methods = generate_transition_methods(
        command_name,
        required_args,
        optional_args,
        combination,
        num_required,
    );

    // Generate run method if this is the complete state (all required fields set)
    let complete_mask = (1 << num_required) - 1;
    let run_method = if combination == complete_mask {
        generate_run_method(command_name, required_args, optional_args, body)
    } else {
        quote! {}
    };

    quote! {
        #struct_def

        impl #runner_name {
            #transition_methods
            #run_method
        }
    }
}

/// Generate transition methods for a runner type (field setters)
fn generate_transition_methods(
    command_name: &syn::Ident,
    required_args: &[(syn::Ident, syn::Type)],
    optional_args: &[(syn::Ident, syn::Type)],
    current_combination: usize,
    num_required: usize,
) -> proc_macro2::TokenStream {
    let mut methods = Vec::new();

    // Generate setter methods for required fields not yet set
    for (i, (field_name, field_type)) in required_args.iter().enumerate() {
        if (current_combination >> i) & 1 == 0 {
            // This required field is not set yet, generate a setter
            let new_combination = current_combination | (1 << i);
            let binary_suffix =
                format!("{:0width$b}", new_combination, width = num_required.max(1));
            let target_runner = syn::Ident::new(
                &format!("{command_name}Runner{binary_suffix}"),
                command_name.span(),
            );

            let method = generate_field_setter_method(
                required_args,
                optional_args,
                field_name,
                field_type,
                current_combination,
                &target_runner,
            );
            methods.push(method);
        }
    }

    // Generate setter methods for optional fields (available on all runner types)
    for (field_name, field_type) in optional_args {
        let current_runner = syn::Ident::new(
            &format!(
                "{}Runner{:0width$b}",
                command_name,
                current_combination,
                width = num_required.max(1)
            ),
            command_name.span(),
        );

        let method = generate_optional_field_setter(
            field_name,
            field_type,
            &current_runner,
            required_args,
            optional_args,
            current_combination,
            num_required,
        );
        methods.push(method);
    }

    quote! {
        #(#methods)*
    }
}

/// Generate a setter method for a required field
fn generate_field_setter_method(
    required_args: &[(syn::Ident, syn::Type)],
    optional_args: &[(syn::Ident, syn::Type)],
    field_name: &syn::Ident,
    field_type: &syn::Type,
    current_combination: usize,
    target_runner: &syn::Ident,
) -> proc_macro2::TokenStream {
    // Generate field assignments for the new state
    let mut field_assignments = Vec::new();

    // Handle required fields
    for (i, (req_field_name, _)) in required_args.iter().enumerate() {
        if req_field_name == field_name {
            // This is the field being set
            field_assignments.push(quote! {
                #req_field_name: value
            });
        } else if (current_combination >> i) & 1 == 1 {
            // This field was already set, move it from self
            field_assignments.push(quote! {
                #req_field_name: self.#req_field_name
            });
        }
        // Fields not set in either state are omitted
    }

    // Handle optional fields (always present, move from self)
    for (opt_field_name, _) in optional_args {
        field_assignments.push(quote! {
            #opt_field_name: self.#opt_field_name
        });
    }

    // Generate the constructor call
    let constructor = if field_assignments.is_empty() {
        quote! { #target_runner }
    } else {
        quote! {
            #target_runner {
                #(#field_assignments),*
            }
        }
    };

    quote! {
        pub fn #field_name(self, value: #field_type) -> #target_runner {
            #constructor
        }
    }
}

/// Generate a setter method for an optional field
fn generate_optional_field_setter(
    field_name: &syn::Ident,
    field_type: &syn::Type,
    current_runner: &syn::Ident,
    required_args: &[(syn::Ident, syn::Type)],
    optional_args: &[(syn::Ident, syn::Type)],
    current_combination: usize,
    _num_required: usize,
) -> proc_macro2::TokenStream {
    // Generate field assignments (same state, but update the optional field)
    let mut field_assignments = Vec::new();

    // Handle required fields (move from self if set)
    for (i, (req_field_name, _)) in required_args.iter().enumerate() {
        if (current_combination >> i) & 1 == 1 {
            field_assignments.push(quote! {
                #req_field_name: self.#req_field_name
            });
        }
    }

    // Handle optional fields
    for (opt_field_name, _) in optional_args {
        if opt_field_name == field_name {
            // This is the field being set
            field_assignments.push(quote! {
                #opt_field_name: Some(value)
            });
        } else {
            // Move other optional fields from self
            field_assignments.push(quote! {
                #opt_field_name: self.#opt_field_name
            });
        }
    }

    let constructor = if field_assignments.is_empty() {
        quote! { #current_runner }
    } else {
        quote! {
            #current_runner {
                #(#field_assignments),*
            }
        }
    };

    quote! {
        pub fn #field_name(self, value: #field_type) -> #current_runner {
            #constructor
        }
    }
}

/// Generate the run method for the complete runner state
fn generate_run_method(
    _command_name: &syn::Ident,
    required_args: &[(syn::Ident, syn::Type)],
    optional_args: &[(syn::Ident, syn::Type)],
    body: &syn::Block,
) -> proc_macro2::TokenStream {
    // Extract field values directly (no unwrap needed!)
    let mut variable_assignments = Vec::new();

    // Required fields - direct field access
    for (field_name, _) in required_args {
        variable_assignments.push(quote! {
            let #field_name = self.#field_name;
        });
    }

    // Optional fields - direct field access
    for (field_name, _) in optional_args {
        variable_assignments.push(quote! {
            let #field_name = self.#field_name;
        });
    }

    quote! {
        pub async fn run(self) -> Result<Option<CmdResult>, CmdError> {
            // Zero runtime checks - direct field access!
            #(#variable_assignments)*

            // Original command body
            #body
        }
    }
}

/// Generate the `new()` method for the command
fn generate_new_method(
    command_name: &syn::Ident,
    num_required: usize,
    optional_args: &[(syn::Ident, syn::Type)],
) -> proc_macro2::TokenStream {
    let initial_runner = syn::Ident::new(
        &format!(
            "{}Runner{:0width$b}",
            command_name,
            0,
            width = num_required.max(1)
        ),
        command_name.span(),
    );

    // Initial state has no required fields set, but has optional fields as None
    let constructor = if optional_args.is_empty() && num_required > 0 {
        // Unit struct (no fields at all in initial state)
        quote! { #initial_runner }
    } else {
        // Struct with optional fields initialized to None
        let optional_field_inits = optional_args.iter().map(|(field_name, _)| {
            quote! { #field_name: None }
        });

        if optional_field_inits.len() > 0 {
            quote! {
                #initial_runner {
                    #(#optional_field_inits),*
                }
            }
        } else {
            quote! { #initial_runner }
        }
    };

    quote! {
        impl #command_name {
            pub fn new() -> #initial_runner {
                #constructor
            }
        }
    }
}

struct CommandInput {
    name: syn::Ident,
    required_args: Vec<(syn::Ident, syn::Type)>,
    optional_args: Vec<(syn::Ident, syn::Type)>,
    body: syn::Block,
}

impl syn::parse::Parse for CommandInput {
    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
        let name: syn::Ident = input.parse()?;

        let content;
        syn::braced!(content in input);

        let mut required_args = Vec::new();
        let mut optional_args = Vec::new();

        while !content.is_empty() {
            // Parse attributes
            let mut is_optional = false;
            let mut is_required = false;

            while content.peek(syn::Token![#]) {
                content.parse::<syn::Token![#]>()?;
                let attr_content;
                syn::bracketed!(attr_content in content);
                let attr_name: syn::Ident = attr_content.parse()?;

                if attr_name == "optional" {
                    is_optional = true;
                } else if attr_name == "required" {
                    is_required = true;
                } else {
                    return Err(syn::Error::new(
                        attr_name.span(),
                        "Unknown attribute. Use #[required] or #[optional]",
                    ));
                }
            }

            // Parse the field
            let arg_name: syn::Ident = content.parse()?;
            content.parse::<syn::Token![:]>()?;
            let arg_type: syn::Type = content.parse()?;

            if content.peek(syn::Token![,]) {
                content.parse::<syn::Token![,]>()?;
            }

            // Determine if optional (default to required if no attribute specified)
            let is_optional_field = if is_required && is_optional {
                return Err(syn::Error::new(
                    arg_name.span(),
                    "Field cannot be both #[required] and #[optional]",
                ));
            } else if is_optional {
                true
            } else {
                false // Default to required
            };

            if is_optional_field {
                optional_args.push((arg_name, arg_type));
            } else {
                required_args.push((arg_name, arg_type));
            }
        }

        // The '=>' is outside the braces
        input.parse::<syn::Token![=>]>()?;
        let body: syn::Block = input.parse()?;

        Ok(CommandInput {
            name,
            required_args,
            optional_args,
            body,
        })
    }
}