I’m experimenting with proc-macro, the goal is that I can chain functions like a struct that contain fields of enums,

Look at the test, the response will be
permission::auth::moderator::execute::conditional

main.rs:

use ::enum_display::RbacBuilder;

#[derive(Debug, RbacBuilder)]
pub struct PermissionBuilder {
    #[enum_def(Object)]
    object: Option<Object>,
    #[enum_def(Subject)]
    subject: Option<Subject>,
    #[enum_def(Action)]
    action: Option<Action>,
    #[enum_def(Permission)]
    permission: Option<Permission>,
}

#[derive(Debug)]
pub enum Subject {
    User,
    Admin,
    Guest,
    Moderator,
}

#[derive(Debug)]
pub enum Object {
    Auth,
    Role,
    Resource,
    Policy,
}

#[derive(Debug)]
pub enum Action {
    Create,
    Read,
    Update,
    Delete,
    List,
    Execute,
}

#[derive(Debug)]
pub enum Permission {
    Allow,
    Deny,
    Conditional,
}
#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_permission() {
        let result = PermissionBuilder::new()
            .auth()
            .moderator() // New method from added enum variant
            .execute() // New method from added enum variant
            .conditional() // New method from added enum variant
            .finish();

        println!("perm: {:?}", result);
    }
}

my proc macro library (enum_display/src/lib.rs) look like this:

extern crate proc_macro;
extern crate proc_macro2;
extern crate quote;
extern crate syn;

use proc_macro::TokenStream;
use quote::{format_ident, quote};
use syn::{parse_macro_input, Data, DeriveInput, Fields, Type};

#[proc_macro_derive(RbacBuilder, attributes(enum_def))]
pub fn rbac_builder_derive(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);
    let name = input.ident;

    let mut methods = vec![];

    if let Data::Struct(data_struct) = &input.data {
        if let Fields::Named(fields_named) = &data_struct.fields {
            for field in fields_named.named.iter() {
                if let Some(ident) = &field.ident {
                    let ty = &field.ty;

                    // Extract the enum name and its variants
                    let enum_name = match ty {
                        Type::Path(type_path) => {
                            if let Some(segment) = type_path.path.segments.last() {
                                // Check if it's an Option<T>
                                if segment.ident == "Option" {
                                    if let syn::PathArguments::AngleBracketed(args) =
                                        &segment.arguments
                                    {
                                        if let Some(syn::GenericArgument::Type(Type::Path(
                                            inner_type_path,
                                        ))) = args.args.first()
                                        {
                                            if let Some(inner_segment) =
                                                inner_type_path.path.segments.last()
                                            {
                                                Some(inner_segment.ident.clone())
                                            } else {
                                                None
                                            }
                                        } else {
                                            None
                                        }
                                    } else {
                                        None
                                    }
                                } else {
                                    Some(segment.ident.clone())
                                }
                            } else {
                                None
                            }
                        }
                        _ => None,
                    };

                    if let Some(enum_name) = enum_name {
                        eprintln!("Detected enum: {:?}", enum_name);

                        // Directly reference the enums instead of finding them in the AST
                        let enum_variants = get_enum_variants(&enum_name.to_string());

                        if let Some(variants) = enum_variants {
                            for variant in variants {
                                let method_name = format_ident!("{}", variant.to_lowercase());
                                let variant_ident = format_ident!("{}", variant);

                                methods.push(quote! {
                                    pub fn #method_name(mut self) -> Self {
                                        self.#ident = Some(#enum_name::#variant_ident);
                                        self
                                    }
                                });
                            }
                        } else {
                            eprintln!("Enum definition not found for {:?}", enum_name);
                        }
                    } else {
                        eprintln!("Field type is not a recognized path: {:?}", ty);
                    }
                } else {
                    eprintln!("Field without an identifier");
                }
            }
        } else {
            eprintln!("Struct does not have named fields");
        }
    } else {
        eprintln!("Not a struct: {:?}", input.data);
    }

    let expanded = quote! {
        impl #name {
            pub fn new() -> Self {
                Self {
                    object: None,
                    subject: None,
                    action: None,
                    permission: None,
                }
            }

            #(#methods)*

            pub fn finish(self) -> String {
                format!(
                    "permission::{:?}::{:?}::{:?}::{:?}",
                    self.object.unwrap(),
                    self.subject.unwrap(),
                    self.action.unwrap(),
                    self.permission.unwrap()
                ).to_lowercase().replace("::", "::")
            }
        }
    };

    TokenStream::from(expanded)
}

fn get_enum_variants(enum_name: &str) -> Option<Vec<&'static str>> {
    match enum_name {
        "Subject" => Some(vec!["User", "Admin", "Guest", "Moderator"]),
        "Object" => Some(vec!["Auth", "Role", "Resource", "Policy"]),
        "Action" => Some(vec![
            "Create", "Read", "Update", "Delete", "List", "Execute",
        ]),
        "Permission" => Some(vec!["Allow", "Deny", "Conditional"]),
        _ => None,
    }
}

The problem here is that I cannot find a way to infer the enum values and must hardcode them in my library.

How I can get rid of the hardcoded lib.rs?