use proc_macro::TokenStream;use proc_macro2::{Span, TokenStream as TokenStream2};use quote::quote;use syn::{Data, DeriveInput, Fields, Ident, LitStr, parse_macro_input}; /// Derives [`feature_flags::FeatureFlagValue`] for a unit-only enum.////// Exactly one variant must be marked with `#[default]`. The default variant/// is the one returned when the feature flag is announced by the server,/// enabled for all users, or enabled by the staff rule — it's the "on"/// value, and also the fallback for `from_wire`.////// The generated impl derives:////// * `all_variants` — every variant, in source order./// * `override_key` — the variant name, lower-cased with dashes between///   PascalCase word boundaries (e.g. `NewWorktree` → `"new-worktree"`)./// * `label` — the variant name with PascalCase boundaries expanded to///   spaces (e.g. `NewWorktree` → `"New Worktree"`)./// * `from_wire` — always returns the default variant, since today the///   server wire format is just presence and does not carry a variant.////// ## Example////// ```ignore/// #[derive(Clone, Copy, PartialEq, Eq, Debug, EnumFeatureFlag)]/// enum Intensity {///     #[default]///     Low,///     High,/// }/// ```// `attributes(default)` lets users write `#[default]` on a variant even when// they're not also deriving `Default`. If `#[derive(Default)]` is present in// the same list, it reuses the same attribute — there's no conflict, because// helper attributes aren't consumed.#[proc_macro_derive(EnumFeatureFlag, attributes(default))]pub fn derive_enum_feature_flag(input: TokenStream) -> TokenStream {    let input = parse_macro_input!(input as DeriveInput);    match expand(&input) {        Ok(tokens) => tokens.into(),        Err(e) => e.to_compile_error().into(),    }} fn expand(input: &DeriveInput) -> syn::Result<TokenStream2> {    let Data::Enum(data) = &input.data else {        return Err(syn::Error::new_spanned(            input,            "EnumFeatureFlag can only be derived for enums",        ));    };     if data.variants.is_empty() {        return Err(syn::Error::new_spanned(            input,            "EnumFeatureFlag requires at least one variant",        ));    }     let mut default_ident: Option<&Ident> = None;    let mut variant_idents: Vec<&Ident> = Vec::new();     for variant in &data.variants {        if !matches!(variant.fields, Fields::Unit) {            return Err(syn::Error::new_spanned(                variant,                "EnumFeatureFlag only supports unit variants (no fields)",            ));        }        if has_default_attr(variant) {            if default_ident.is_some() {                return Err(syn::Error::new_spanned(                    variant,                    "only one variant may be marked with #[default]",                ));            }            default_ident = Some(&variant.ident);        }        variant_idents.push(&variant.ident);    }     let Some(default_ident) = default_ident else {        return Err(syn::Error::new_spanned(            input,            "EnumFeatureFlag requires exactly one variant to be marked with #[default]",        ));    };     let name = &input.ident;    let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();     let override_key_arms = variant_idents.iter().map(|variant| {        let key = LitStr::new(&to_kebab_case(&variant.to_string()), Span::call_site());        quote! { #name::#variant => #key }    });     let label_arms = variant_idents.iter().map(|variant| {        let label = LitStr::new(&to_space_separated(&variant.to_string()), Span::call_site());        quote! { #name::#variant => #label }    });     let all_variants = variant_idents.iter().map(|v| quote! { #name::#v });     Ok(quote! {        impl #impl_generics ::std::default::Default for #name #ty_generics #where_clause {            fn default() -> Self {                #name::#default_ident            }        }         impl #impl_generics ::feature_flags::FeatureFlagValue for #name #ty_generics #where_clause {            fn all_variants() -> &'static [Self] {                &[ #( #all_variants ),* ]            }             fn override_key(&self) -> &'static str {                match self {                    #( #override_key_arms ),*                }            }             fn label(&self) -> &'static str {                match self {                    #( #label_arms ),*                }            }             fn from_wire(_: &str) -> ::std::option::Option<Self> {                ::std::option::Option::Some(#name::#default_ident)            }        }    })} fn has_default_attr(variant: &syn::Variant) -> bool {    variant.attrs.iter().any(|a| a.path().is_ident("default"))} /// Converts a PascalCase identifier to lowercase kebab-case.////// `"NewWorktree"` → `"new-worktree"`, `"Low"` → `"low"`,/// `"HTTPServer"` → `"httpserver"` (acronyms are not split — keep variant/// names descriptive to avoid this).fn to_kebab_case(ident: &str) -> String {    let mut out = String::with_capacity(ident.len() + 4);    for (i, ch) in ident.chars().enumerate() {        if ch.is_ascii_uppercase() {            if i != 0 {                out.push('-');            }            out.push(ch.to_ascii_lowercase());        } else {            out.push(ch);        }    }    out} /// Converts a PascalCase identifier to space-separated word form for display.////// `"NewWorktree"` → `"New Worktree"`, `"Low"` → `"Low"`.fn to_space_separated(ident: &str) -> String {    let mut out = String::with_capacity(ident.len() + 4);    for (i, ch) in ident.chars().enumerate() {        if ch.is_ascii_uppercase() && i != 0 {            out.push(' ');        }        out.push(ch);    }    out} #[cfg(test)]mod tests {    use super::*;     #[test]    fn kebab_case() {        assert_eq!(to_kebab_case("Low"), "low");        assert_eq!(to_kebab_case("NewWorktree"), "new-worktree");        assert_eq!(to_kebab_case("A"), "a");    }     #[test]    fn space_separated() {        assert_eq!(to_space_separated("Low"), "Low");        assert_eq!(to_space_separated("NewWorktree"), "New Worktree");    }}