Enum support in SettingsGroup derive macro, implemented key attribute (#23719)

# Objective

Implements part of #23302

Fixes: #23722

For background on bevy settings see the initial PR:
#23034

## Solution

Supports `unit-like` Enum resources:
```rust
#[derive(Resource, SettingsGroup, Reflect, Debug, Default)]
#[reflect(Resource, SettingsGroup, Default)]
enum CounterRefreshRateSettings {
    #[default]
    Slow,
    Fast,
}
```

Assuming the above is initialised as `CounterRefreshRateSettings::Slow`,
results in:
```toml
[counter_refresh_rate_settings]
counter_refresh_rate_settings = "Slow"
```

Setting the `group` attribute works the same as structs:
```rust
#[settings_group(group = "counter_settings")]
```
Results in:
```toml
[counter_settings]
counter_refresh_rate_settings = "Slow"
```

This PR adds a `key` attribute which can only be used on enums (for
now), otherwise a compile-time error is thrown:
```rust
#[settings_group(key = "refresh_rate")]
```
Results in:
```toml
[counter_refresh_rate_settings]
refresh_rate = "Slow"
```

## Testing
- Added tests that checks merging enums into groups and round trip
serialisation.
- Added a "cheat sheet" for the derive syntax, immitating other derive
macros in the file.

---------

Co-authored-by: Kevin Chen <chen.kevin.f@gmail.com>
Co-authored-by: Alice Cecile <alice.i.cecile@gmail.com>

Author: 3 people

Cargo.toml

@@ -736,6 +736,7 @@ bevy_gizmos = { path = "crates/bevy_gizmos", version = "0.19.0-dev", default-fea
 bevy_image = { path = "crates/bevy_image", version = "0.19.0-dev", default-features = false }
 bevy_reflect = { path = "crates/bevy_reflect", version = "0.19.0-dev", default-features = false }
 bevy_render = { path = "crates/bevy_render", version = "0.19.0-dev", default-features = false }
+bevy_settings = { path = "crates/bevy_settings", version = "0.19.0-dev", default-features = false }
 bevy_state = { path = "crates/bevy_state", version = "0.19.0-dev", default-features = false }
 bevy_scene = { path = "crates/bevy_scene", version = "0.19.0-dev", default-features = false }
 # Needed to poll Task examples

crates/bevy_ecs/macros/src/lib.rs

@@ -25,7 +25,7 @@ use proc_macro2::{Ident, Span};
 use quote::{format_ident, quote, ToTokens};
 use syn::{
     parse_macro_input, parse_quote, punctuated::Punctuated, token::Comma, ConstParam, Data,
-    DeriveInput, GenericParam, TypeParam,
+    DeriveInput, Fields, GenericParam, TypeParam,
 };
 
 enum BundleFieldKind {
@@ -524,6 +524,10 @@ pub(crate) fn bevy_ecs_path() -> syn::Path {
     BevyManifest::shared(|manifest| manifest.get_path("bevy_ecs"))
 }
 
+pub(crate) fn bevy_settings_path() -> syn::Path {
+    BevyManifest::shared(|manifest| manifest.get_path("bevy_settings"))
+}
+
 /// Implement the `Event` trait.
 #[proc_macro_derive(Event, attributes(event))]
 pub fn derive_event(input: TokenStream) -> TokenStream {
@@ -560,15 +564,58 @@ pub fn derive_resource(input: TokenStream) -> TokenStream {
     component::derive_resource(input)
 }
 
-/// Implement the `SettingsGroup` trait.
+/// Cheat sheet for derive syntax,
+///
+/// ## Group Override
+/// ```ignore
+/// #[derive(SettingsGroup)]
+/// #[settings_group(group = "my_group")]
+/// struct MySettings {
+///     test: true
+/// }
+/// ```
+/// results in:
+/// ```ignore
+/// [my_group]
+/// test = true
+/// ```
+///
+/// ## File Override
+/// ```ignore
+/// #[derive(SettingsGroup)]
+/// #[settings_group(file = "my_file")]
+/// struct MySettings {
+///     test: true
+/// }
+/// ```
+/// results in a different file being used as the source of the settings.
+///
+/// ## Key Override
+/// Only valid for enums, as struct keys are always derived from the field name.
+/// ```ignore
+/// #[derive(SettingsGroup)]
+/// #[settings_group(key = "my_key")]
+/// enum MySettingsEnum {
+///     Variant1,
+///     Variant2
+/// };
+/// ```
+/// results in:
+/// ```ignore
+/// [my_settings_enum]
+/// my_key = "variant1"
+/// ```
 #[proc_macro_derive(SettingsGroup, attributes(settings_group))]
 pub fn derive_settings_group(input: TokenStream) -> TokenStream {
     let input = parse_macro_input!(input as DeriveInput);
 
     let name = &input.ident;
 
-    let (override_name, override_file) = {
-        let mut override_name: Option<String> = None;
+    let path = bevy_settings_path();
+
+    let (override_group_name, override_key_name, override_file) = {
+        let mut override_group_name: Option<String> = None;
+        let mut override_key_name: Option<String> = None;
         let mut override_file: Option<String> = None;
 
         input
@@ -580,7 +627,12 @@ pub fn derive_settings_group(input: TokenStream) -> TokenStream {
                     if meta.path.is_ident("group") {
                         let value = meta.value()?;
                         let s: syn::LitStr = value.parse()?;
-                        override_name = Some(s.value());
+                        override_group_name = Some(s.value());
+                        Ok(())
+                    } else if meta.path.is_ident("key") {
+                        let value = meta.value()?;
+                        let s: syn::LitStr = value.parse()?;
+                        override_key_name = Some(s.value());
                         Ok(())
                     } else if meta.path.is_ident("file") {
                         let value = meta.value()?;
@@ -594,19 +646,65 @@ pub fn derive_settings_group(input: TokenStream) -> TokenStream {
                 .ok()
             });
 
-        (override_name, override_file)
+        (override_group_name, override_key_name, override_file)
     };
 
-    let group_name = override_name.unwrap_or(pascal_to_snake_case(&name.to_string()));
+    let (group_name, key_name) = match &input.data {
+        Data::Struct(_) => {
+            if override_key_name.is_some() {
+                return syn::Error::new(
+                    Span::call_site(),
+                    "The `key` attribute is not supported for structs",
+                )
+                .into_compile_error()
+                .into();
+            }
+            let group_name = override_group_name.unwrap_or(pascal_to_snake_case(&name.to_string()));
+
+            (group_name, override_key_name)
+        }
+        Data::Enum(data) => {
+            if data.variants.iter().any(|v| v.fields != Fields::Unit) {
+                return syn::Error::new(
+                    Span::call_site(),
+                    "SettingsGroup can only be derived for enums with unit variants",
+                )
+                .into_compile_error()
+                .into();
+            }
+
+            let group_name = override_group_name.unwrap_or(pascal_to_snake_case(&name.to_string()));
+            let key_name = override_key_name.or(Some(pascal_to_snake_case(&name.to_string())));
+
+            (group_name, key_name)
+        }
+        _ => {
+            return syn::Error::new(
+                Span::call_site(),
+                "SettingsGroup can only be derived for structs and enums",
+            )
+            .into_compile_error()
+            .into();
+        }
+    };
+
+    let key_name = key_name
+        .map(|f| quote! { ::core::option::Option::Some(#f) })
+        .unwrap_or(quote! { ::core::option::Option::None });
     let file_name = override_file
         .map(|f| quote! { ::core::option::Option::Some(#f) })
         .unwrap_or(quote! { ::core::option::Option::None });
 
     let expanded = quote! {
-        impl SettingsGroup for #name {
+        impl #path::SettingsGroup for #name {
             fn settings_group_name() -> &'static str {
                 #group_name
             }
+
+            fn settings_key_name() -> ::core::option::Option<&'static str> {
+                #key_name
+            }
+
             fn settings_source() -> ::core::option::Option<&'static str> {
                 #file_name
             }