Cleaner macros utilizing syn::Member

crates/bevy_asset/macros/src/lib.rs

@@ -1,10 +1,10 @@
 #![expect(missing_docs, reason = "Not all docs are written yet, see #3492.")]
 #![cfg_attr(docsrs, feature(doc_auto_cfg))]
 
-use bevy_macro_utils::BevyManifest;
+use bevy_macro_utils::{as_member, BevyManifest};
 use proc_macro::{Span, TokenStream};
 use quote::{format_ident, quote};
-use syn::{parse_macro_input, Data, DeriveInput, Path};
+use syn::{parse_macro_input, Data, DataStruct, DeriveInput, Path};
 
 pub(crate) fn bevy_asset_path() -> Path {
     BevyManifest::shared().get_path("bevy_asset")
@@ -23,7 +23,6 @@ pub fn derive_asset(input: TokenStream) -> TokenStream {
         Ok(dependency_visitor) => dependency_visitor,
         Err(err) => return err.into_compile_error().into(),
     };
-
     TokenStream::from(quote! {
         impl #impl_generics #bevy_asset_path::Asset for #struct_name #type_generics #where_clause { }
         #dependency_visitor
@@ -52,52 +51,35 @@ fn derive_dependency_visitor_internal(
     let field_has_dep = |f: &syn::Field| f.attrs.iter().any(is_dep_attribute);
 
     let body = match &ast.data {
-        Data::Struct(data_struct) => {
-            let fields = data_struct.fields.iter();
-            let field_visitors = fields.enumerate().filter(|(_, f)| field_has_dep(f));
-            let field_visitors = field_visitors.map(|(i, field)| match &field.ident {
-                Some(ident) => visit_dep(quote!(&self.#ident)),
-                None => {
-                    let index = syn::Index::from(i);
-                    visit_dep(quote!(&self.#index))
-                }
-            });
-            Some(quote!( #(#field_visitors)* ))
+        Data::Struct(DataStruct { fields, .. }) => {
+            let field_visitors = fields
+                .iter()
+                .enumerate()
+                .filter(|(_, f)| field_has_dep(f))
+                .map(|(i, field)| as_member(field.ident.as_ref(), i))
+                .map(|member| visit_dep(quote!(&self.#member)));
+            Some(quote!(#(#field_visitors)*))
         }
         Data::Enum(data_enum) => {
             let variant_has_dep = |v: &syn::Variant| v.fields.iter().any(field_has_dep);
             let any_case_required = data_enum.variants.iter().any(variant_has_dep);
             let cases = data_enum.variants.iter().filter(|v| variant_has_dep(v));
             let cases = cases.map(|variant| {
                 let ident = &variant.ident;
-                let fields = &variant.fields;
-
-                let field_visitors = fields.iter().enumerate().filter(|(_, f)| field_has_dep(f));
-
-                let field_visitors = field_visitors.map(|(i, field)| match &field.ident {
-                    Some(ident) => visit_dep(quote!(#ident)),
-                    None => {
-                        let ident = format_ident!("member{i}");
-                        visit_dep(quote!(#ident))
-                    }
-                });
-                let fields = match fields {
-                    syn::Fields::Named(fields) => {
-                        let named = fields.named.iter().map(|f| f.ident.as_ref());
-                        quote!({ #(#named,)* .. })
-                    }
-                    syn::Fields::Unnamed(fields) => {
-                        let named = (0..fields.unnamed.len()).map(|i| format_ident!("member{i}"));
-                        quote!( ( #(#named,)* ) )
-                    }
-                    syn::Fields::Unit => unreachable!("Can't pass filter is_dep_attribute"),
-                };
-                quote!(Self::#ident #fields => {
+                let field_members = variant
+                    .fields
+                    .iter()
+                    .enumerate()
+                    .filter(|(_, f)| field_has_dep(f))
+                    .map(|(i, field)| as_member(field.ident.as_ref(), i));
+                let field_locals = field_members.clone().map(|m| format_ident!("__self_{}", m));
+                let field_visitors = field_locals.clone().map(|i| visit_dep(quote!(#i)));
+                quote!(Self::#ident {#(#field_members: #field_locals,)* ..} => {
                     #(#field_visitors)*
-                })
+                },)
             });
 
-            any_case_required.then(|| quote!(match self { #(#cases)*, _ => {} }))
+            any_case_required.then(|| quote!(match self { #(#cases)* _ => {} }))
         }
         Data::Union(_) => {
             return Err(syn::Error::new(

crates/bevy_ecs/compile_fail/tests/ui/world_query_derive.rs

@@ -17,20 +17,6 @@ struct MutableInvalidAttribute {
     a: &'static mut Foo,
 }
 
-#[derive(QueryData)]
-#[query_data(mutable(foo))]
-//~^ ERROR: `mutable` does not take any arguments
-struct MutableInvalidAttributeParameters {
-    a: &'static mut Foo,
-}
-
-#[derive(QueryData)]
-#[query_data(derive)]
-//~^ ERROR: `derive` requires at least one argument
-struct MutableMissingAttributeParameters {
-    a: &'static mut Foo,
-}
-
 #[derive(QueryData)]
 #[query_data(mutable)]
 struct MutableMarked {

crates/bevy_ecs/compile_fail/tests/ui/world_query_derive.stderr

@@ -4,18 +4,6 @@ error: invalid attribute, expected `mutable` or `derive`
 14 | #[query_data(mut)]
    |              ^^^
 
-error: `mutable` does not take any arguments
-  --> tests/ui/world_query_derive.rs:21:14
-   |
-21 | #[query_data(mutable(foo))]
-   |              ^^^^^^^
-
-error: `derive` requires at least one argument
-  --> tests/ui/world_query_derive.rs:28:14
-   |
-28 | #[query_data(derive)]
-   |              ^^^^^^
-
 error[E0277]: the trait bound `&'static mut Foo: ReadOnlyQueryData` is not satisfied
   --> tests/ui/world_query_derive.rs:10:8
    |

crates/bevy_ecs/macros/src/component.rs

@@ -1,3 +1,4 @@
+use bevy_macro_utils::{as_member, fq_std::FQOption};
 use proc_macro::TokenStream;
 use proc_macro2::{Span, TokenStream as TokenStream2};
 use quote::{format_ident, quote, ToTokens};
@@ -324,13 +325,10 @@ pub(crate) fn map_entities(
                         || relationship.is_some_and(|relationship| relationship == *field)
                 })
                 .for_each(|(index, field)| {
-                    let field_member = field
-                        .ident
-                        .clone()
-                        .map_or(Member::from(index), Member::Named);
-
-                    map.push(quote!(#self_ident.#field_member.map_entities(mapper);));
+                    let member = as_member(field.ident.as_ref(), index);
+                    map.push(quote!(#self_ident.#member.map_entities(mapper);));
                 });
+
             if map.is_empty() {
                 return None;
             };
@@ -347,12 +345,7 @@ pub(crate) fn map_entities(
                     .iter()
                     .enumerate()
                     .filter(|(_, field)| field.attrs.iter().any(|a| a.path().is_ident(ENTITIES)))
-                    .map(|(index, field)| {
-                        field
-                            .ident
-                            .clone()
-                            .map_or(Member::from(index), Member::Named)
-                    })
+                    .map(|(index, field)| as_member(field.ident.as_ref(), index))
                     .collect::<Vec<_>>();
 
                 let ident = &variant.ident;
@@ -643,8 +636,8 @@ fn hook_register_function_call(
 ) -> Option<TokenStream2> {
     function.map(|meta| {
         quote! {
-            fn #hook() -> ::core::option::Option<#bevy_ecs_path::component::ComponentHook> {
-                ::core::option::Option::Some(#meta)
+            fn #hook() -> #FQOption<#bevy_ecs_path::component::ComponentHook> {
+                #FQOption::Some(#meta)
             }
         }
     })