fix queryData

Author: Bleachfuel

crates/bevy_ecs/macros/src/lib.rs

@@ -18,9 +18,10 @@ use crate::{
 use bevy_macro_utils::{derive_label, ensure_no_collision, get_struct_fields, BevyManifest};
 use proc_macro::TokenStream;
 use proc_macro2::{Ident, Span};
-use quote::{ToTokens, format_ident, quote};
+use quote::{format_ident, quote, ToTokens};
 use syn::{
-    ConstParam, Data, DeriveInput, GenericParam, TypeParam, parse_macro_input, parse_quote, punctuated::Punctuated, token::Comma
+    parse_macro_input, parse_quote, punctuated::Punctuated, token::Comma, ConstParam, Data,
+    DeriveInput, GenericParam, TypeParam,
 };
 
 enum BundleFieldKind {
@@ -51,7 +52,6 @@ pub fn derive_bundle(input: TokenStream) -> TokenStream {
     let ast = parse_macro_input!(input as DeriveInput);
     let ecs_path = bevy_ecs_path();
 
-
     let mut attributes = BundleAttributes::default();
 
     for attr in &ast.attrs {
@@ -66,7 +66,7 @@ pub fn derive_bundle(input: TokenStream) -> TokenStream {
             });
 
             if let Err(e) = parsing {
-                return e.into_compile_error().into()
+                return e.into_compile_error().into();
             }
         }
     }
@@ -103,18 +103,14 @@ pub fn derive_bundle(input: TokenStream) -> TokenStream {
         field_kinds.push(kind);
     }
 
-    let field_types = fields
-        .iter()
-        .map(|field| &field.ty)
-        .collect::<Vec<_>>();
+    let field_types = fields.iter().map(|field| &field.ty).collect::<Vec<_>>();
 
     let mut active_field_types = Vec::new();
-    let mut active_field_members    = Vec::new();
+    let mut active_field_members = Vec::new();
     let mut active_field_locals = Vec::new();
     let mut inactive_field_members = Vec::new();
-    for ((field_member, field_type), field_kind) in fields.members()
-        .zip(field_types)
-        .zip(field_kinds)
+    for ((field_member, field_type), field_kind) in
+        fields.members().zip(field_types).zip(field_kinds)
     {
         let field_local = format_ident!("field_{}", field_member);
 
@@ -123,8 +119,8 @@ pub fn derive_bundle(input: TokenStream) -> TokenStream {
                 active_field_types.push(field_type);
                 active_field_locals.push(field_local);
                 active_field_members.push(field_member);
-            },
-            BundleFieldKind::Ignore => inactive_field_members.push(field_member)
+            }
+            BundleFieldKind::Ignore => inactive_field_members.push(field_member),
         }
     }
     let generics = ast.generics;
@@ -281,7 +277,8 @@ fn derive_system_param_impl(
                 }
             })?;
         }
-        field_validation_messages.push(field_validation_message.unwrap_or_else(|| quote! { err.message }));
+        field_validation_messages
+            .push(field_validation_message.unwrap_or_else(|| quote! { err.message }));
     }
 
     let generics = ast.generics;
@@ -297,7 +294,7 @@ fn derive_system_param_impl(
                 r#"invalid lifetime name: expected `'w` or `'s`
  'w -- refers to data stored in the World.
  's -- refers to data stored in the SystemParam's state.'"#,
-            ))
+            ));
         }
     }
 
@@ -342,7 +339,6 @@ fn derive_system_param_impl(
         })
         .collect();
 
-
     let mut tuple_types: Vec<_> = field_types.iter().map(ToTokens::to_token_stream).collect();
     let mut tuple_patterns: Vec<_> = field_locals.iter().map(ToTokens::to_token_stream).collect();
 

crates/bevy_ecs/macros/src/query_data.rs

@@ -3,8 +3,7 @@ use proc_macro::TokenStream;
 use proc_macro2::{Ident, Span};
 use quote::{format_ident, quote};
 use syn::{
-    parse_macro_input, parse_quote, punctuated::Punctuated, token::Comma, Data,
-    DataStruct, DeriveInput, Index, Meta,
+    parse_macro_input, parse_quote, punctuated::Punctuated, token::Comma, DeriveInput, Meta,
 };
 
 use crate::{
@@ -121,9 +120,15 @@ pub fn derive_query_data_impl(input: TokenStream) -> TokenStream {
     let field_attrs = fields.iter().map(|f| f.attrs.clone()).collect();
     let field_visibilities = fields.iter().map(|f| f.vis.clone()).collect();
     let field_members = fields.members().collect();
-    let field_aliases = fields.members().map(|m| format_ident!("field_{}", m)).collect();
+    let field_aliases = fields
+        .members()
+        .map(|m| format_ident!("field_{}", m))
+        .collect();
     let field_types: Vec<syn::Type> = fields.iter().map(|f| f.ty.clone()).collect();
-    let read_only_field_types = field_types.iter().map(|ty| parse_quote!(quote!(<#ty as #path::query::QueryData>::ReadOnly))).collect();
+    let read_only_field_types = field_types
+        .iter()
+        .map(|ty| parse_quote!(<#ty as #path::query::QueryData>::ReadOnly))
+        .collect();
 
     let derive_args = &attributes.derive_args;
     // `#[derive()]` is valid syntax
@@ -210,7 +215,7 @@ pub fn derive_query_data_impl(input: TokenStream) -> TokenStream {
                     #[doc = "Automatically generated read-only field for accessing `"]
                     #[doc = stringify!(#field_types)]
                     #[doc = "`."]
-                    #field_visibilities #field_aliases: #read_only_field_types,
+                    #field_visibilities #field_members: #read_only_field_types,
                 )*
             }
 
@@ -430,4 +435,4 @@ pub fn derive_query_data_impl(input: TokenStream) -> TokenStream {
             }
         };
     })
-}
+}

crates/bevy_ecs/macros/src/query_filter.rs

@@ -2,7 +2,7 @@ use bevy_macro_utils::{ensure_no_collision, get_struct_fields};
 use proc_macro::TokenStream;
 use proc_macro2::{Ident, Span};
 use quote::{format_ident, quote};
-use syn::{parse_macro_input, parse_quote, Data, DataStruct, DeriveInput, Index};
+use syn::{parse_macro_input, parse_quote, DeriveInput};
 
 use crate::{bevy_ecs_path, world_query::world_query_impl};
 
@@ -41,14 +41,16 @@ pub fn derive_query_filter_impl(input: TokenStream) -> TokenStream {
     let state_struct_name = Ident::new(&format!("{struct_name}State"), Span::call_site());
     let state_struct_name = ensure_no_collision(state_struct_name, tokens);
 
-    let fields = match get_struct_fields(&ast.data, "derive(QueryFilter)") {
+    let fields = match get_struct_fields(&ast.data, "derive(WorldQuery)") {
         Ok(fields) => fields,
         Err(e) => return e.into_compile_error().into(),
     };
 
-
     let field_members: Vec<_> = fields.members().collect();
-    let field_aliases = fields.members().map(|m| format_ident!("field_{}", m)).collect();
+    let field_aliases = fields
+        .members()
+        .map(|m| format_ident!("field_{}", m))
+        .collect();
     let field_types = fields.iter().map(|f| f.ty.clone()).collect();
 
     let world_query_impl = world_query_impl(

crates/bevy_macro_utils/src/lib.rs

@@ -14,17 +14,17 @@ mod attrs;
 mod bevy_manifest;
 pub mod fq_std;
 mod label;
+mod member;
 mod parser;
 mod result_sifter;
 mod shape;
 mod symbol;
-mod member;
 
 pub use attrs::*;
 pub use bevy_manifest::*;
 pub use label::*;
+pub use member::*;
 pub use parser::*;
 pub use result_sifter::*;
 pub use shape::*;
 pub use symbol::*;
-pub use member::*;

crates/bevy_macro_utils/src/member.rs

@@ -43,4 +43,4 @@ use syn::{Ident, Member};
 ///
 pub fn as_member(ident: Option<&Ident>, index: usize) -> Member {
     ident.map_or_else(|| Member::from(index), |ident| Member::Named(ident.clone()))
-}
+}

crates/bevy_reflect/derive/src/from_reflect.rs

@@ -6,8 +6,8 @@ use crate::{
     where_clause_options::WhereClauseOptions,
     ReflectMeta, ReflectStruct,
 };
-use bevy_macro_utils::fq_std::{FQClone, FQDefault, FQOption};
 use bevy_macro_utils::as_member;
+use bevy_macro_utils::fq_std::{FQClone, FQDefault, FQOption};
 use proc_macro2::Span;
 use quote::{quote, ToTokens};
 use syn::{Field, Ident, Lit, LitInt, LitStr, Member};

crates/bevy_reflect/derive/src/remote.rs

@@ -1,12 +1,11 @@
 use crate::{
     derive_data::{ReflectImplSource, ReflectProvenance, ReflectTraitToImpl},
-    from_reflect,
-    impls,
+    from_reflect, impls,
     impls::impl_assertions,
     ReflectDerive, REFLECT_ATTRIBUTE_NAME,
 };
-use bevy_macro_utils::fq_std::FQOption;
 use bevy_macro_utils::as_member;
+use bevy_macro_utils::fq_std::FQOption;
 use proc_macro::TokenStream;
 use proc_macro2::{Ident, Span};
 use quote::{format_ident, quote, quote_spanned};
@@ -365,8 +364,7 @@ fn generate_remote_definition_assertions(derive_data: &ReflectDerive) -> proc_ma
             let mut output = proc_macro2::TokenStream::new();
 
             for field in data.fields() {
-                let field_member =
-                    as_member(field.data.ident.as_ref(), field.declaration_index);
+                let field_member = as_member(field.data.ident.as_ref(), field.declaration_index);
                 let field_ty = &field.data.ty;
                 let span = create_assertion_span(field_ty.span());