Cleaner macros utilizing syn::Member v2 (#21678)

# Objective

Some macros were handling Idents and indexes as seperate things, we can
use syn::Member to make this more readable and nicer.

revive of #18199

Author: Bleachfuel

crates/bevy_asset/macros/src/lib.rs

@@ -2,10 +2,10 @@
 
 //! Macros for deriving asset traits.
 
-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(|manifest| manifest.get_path("bevy_asset"))
@@ -55,47 +55,30 @@ 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)*
                 })
             });

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/Cargo.toml

@@ -11,7 +11,7 @@ proc-macro = true
 [dependencies]
 bevy_macro_utils = { path = "../../bevy_macro_utils", version = "0.18.0-dev" }
 
-syn = { version = "2.0.99", features = ["full", "extra-traits"] }
+syn = { version = "2.0.108", features = ["full", "extra-traits"] }
 quote = "1.0"
 proc-macro2 = "1.0"
 [lints]

crates/bevy_ecs/macros/src/component.rs

@@ -350,7 +350,7 @@ pub(crate) fn map_entities(
                 let ident = &variant.ident;
                 let field_idents = field_members
                     .iter()
-                    .map(|member| format_ident!("__self_{}", member))
+                    .map(|member| format_ident!("__self{}", member))
                     .collect::<Vec<_>>();
 
                 map.push(