Make #[system_param(ignore)] and #[world_query(ignore)] unnecessary

crates/bevy_ecs/macros/src/fetch.rs

@@ -120,33 +120,24 @@ pub fn derive_world_query_impl(ast: DeriveInput) -> TokenStream {
         _ => panic!("Expected a struct with named fields"),
     };
 
-    let mut ignored_field_attrs = Vec::new();
-    let mut ignored_field_visibilities = Vec::new();
-    let mut ignored_field_idents = Vec::new();
-    let mut ignored_field_types = Vec::new();
     let mut field_attrs = Vec::new();
     let mut field_visibilities = Vec::new();
     let mut field_idents = Vec::new();
     let mut field_types = Vec::new();
     let mut read_only_field_types = Vec::new();
 
     for field in fields {
-        let WorldQueryFieldInfo { is_ignored, attrs } = read_world_query_field_info(field);
+        match read_world_query_field_info(field) {
+            Ok(WorldQueryFieldInfo { attrs }) => field_attrs.push(attrs),
+            Err(e) => return e.into_compile_error().into(),
+        }
 
         let field_ident = field.ident.as_ref().unwrap().clone();
-        if is_ignored {
-            ignored_field_attrs.push(attrs);
-            ignored_field_visibilities.push(field.vis.clone());
-            ignored_field_idents.push(field_ident.clone());
-            ignored_field_types.push(field.ty.clone());
-        } else {
-            field_attrs.push(attrs);
-            field_visibilities.push(field.vis.clone());
-            field_idents.push(field_ident.clone());
-            let field_ty = field.ty.clone();
-            field_types.push(quote!(#field_ty));
-            read_only_field_types.push(quote!(<#field_ty as #path::query::WorldQuery>::ReadOnly));
-        }
+        field_visibilities.push(field.vis.clone());
+        field_idents.push(field_ident.clone());
+        let field_ty = field.ty.clone();
+        field_types.push(quote!(#field_ty));
+        read_only_field_types.push(quote!(<#field_ty as #path::query::WorldQuery>::ReadOnly));
     }
 
     let derive_args = &fetch_struct_attributes.derive_args;
@@ -184,7 +175,6 @@ pub fn derive_world_query_impl(ast: DeriveInput) -> TokenStream {
             #[automatically_derived]
             #visibility struct #item_struct_name #user_impl_generics_with_world #user_where_clauses_with_world {
                 #(#(#field_attrs)* #field_visibilities #field_idents: <#field_types as #path::query::WorldQuery>::Item<'__w>,)*
-                #(#(#ignored_field_attrs)* #ignored_field_visibilities #ignored_field_idents: #ignored_field_types,)*
             }
         };
 
@@ -196,7 +186,6 @@ pub fn derive_world_query_impl(ast: DeriveInput) -> TokenStream {
             #[automatically_derived]
             #visibility struct #fetch_struct_name #user_impl_generics_with_world #user_where_clauses_with_world {
                 #(#field_idents: <#field_types as #path::query::WorldQuery>::Fetch<'__w>,)*
-                #(#ignored_field_idents: #ignored_field_types,)*
             }
 
             // SAFETY: `update_component_access` and `update_archetype_component_access` are called on every field
@@ -215,9 +204,6 @@ pub fn derive_world_query_impl(ast: DeriveInput) -> TokenStream {
                         #(
                             #field_idents: <#field_types>::shrink(item.#field_idents),
                         )*
-                        #(
-                            #ignored_field_idents: item.#ignored_field_idents,
-                        )*
                     }
                 }
 
@@ -236,7 +222,6 @@ pub fn derive_world_query_impl(ast: DeriveInput) -> TokenStream {
                                 _this_run,
                             ),
                         )*
-                        #(#ignored_field_idents: Default::default(),)*
                     }
                 }
 
@@ -247,9 +232,6 @@ pub fn derive_world_query_impl(ast: DeriveInput) -> TokenStream {
                         #(
                             #field_idents: <#field_types>::clone_fetch(& _fetch. #field_idents),
                         )*
-                        #(
-                            #ignored_field_idents: Default::default(),
-                        )*
                     }
                 }
 
@@ -287,7 +269,6 @@ pub fn derive_world_query_impl(ast: DeriveInput) -> TokenStream {
                 ) -> <Self as #path::query::WorldQuery>::Item<'__w> {
                     Self::Item {
                         #(#field_idents: <#field_types>::fetch(&mut _fetch.#field_idents, _entity, _table_row),)*
-                        #(#ignored_field_idents: Default::default(),)*
                     }
                 }
 
@@ -318,7 +299,6 @@ pub fn derive_world_query_impl(ast: DeriveInput) -> TokenStream {
                 fn init_state(world: &mut #path::world::World) -> #state_struct_name #user_ty_generics {
                     #state_struct_name {
                         #(#field_idents: <#field_types>::init_state(world),)*
-                        #(#ignored_field_idents: Default::default(),)*
                     }
                 }
 
@@ -340,7 +320,6 @@ pub fn derive_world_query_impl(ast: DeriveInput) -> TokenStream {
             #[automatically_derived]
             #visibility struct #read_only_struct_name #user_impl_generics #user_where_clauses {
                 #( #field_idents: #read_only_field_types, )*
-                #(#(#ignored_field_attrs)* #ignored_field_visibilities #ignored_field_idents: #ignored_field_types,)*
             }
 
             #readonly_state
@@ -387,7 +366,6 @@ pub fn derive_world_query_impl(ast: DeriveInput) -> TokenStream {
             #[automatically_derived]
             #visibility struct #state_struct_name #user_impl_generics #user_where_clauses {
                 #(#field_idents: <#field_types as #path::query::WorldQuery>::State,)*
-                #(#ignored_field_idents: #ignored_field_types,)*
             }
 
             #mutable_impl
@@ -419,56 +397,33 @@ pub fn derive_world_query_impl(ast: DeriveInput) -> TokenStream {
                 q2: #read_only_struct_name #user_ty_generics
             ) #user_where_clauses {
                 #(q.#field_idents;)*
-                #(q.#ignored_field_idents;)*
                 #(q2.#field_idents;)*
-                #(q2.#ignored_field_idents;)*
             }
         };
     })
 }
 
 struct WorldQueryFieldInfo {
-    /// Has `#[fetch(ignore)]` or `#[filter_fetch(ignore)]` attribute.
-    is_ignored: bool,
     /// All field attributes except for `world_query` ones.
     attrs: Vec<Attribute>,
 }
 
-fn read_world_query_field_info(field: &Field) -> WorldQueryFieldInfo {
-    let is_ignored = field
-        .attrs
-        .iter()
-        .find(|attr| {
-            attr.path
-                .get_ident()
-                .map_or(false, |ident| ident == WORLD_QUERY_ATTRIBUTE_NAME)
-        })
-        .map_or(false, |attr| {
-            let mut is_ignored = false;
-            attr.parse_args_with(|input: ParseStream| {
-                if input
-                    .parse::<Option<field_attr_keywords::ignore>>()?
-                    .is_some()
-                {
-                    is_ignored = true;
-                }
-                Ok(())
-            })
-            .unwrap_or_else(|_| panic!("Invalid `{WORLD_QUERY_ATTRIBUTE_NAME}` attribute format"));
-
-            is_ignored
-        });
-
-    let attrs = field
-        .attrs
-        .iter()
-        .filter(|attr| {
-            attr.path
-                .get_ident()
-                .map_or(true, |ident| ident != WORLD_QUERY_ATTRIBUTE_NAME)
-        })
-        .cloned()
-        .collect();
+fn read_world_query_field_info(field: &Field) -> syn::Result<WorldQueryFieldInfo> {
+    let mut attrs = Vec::new();
+    for attr in &field.attrs {
+        if attr
+            .path
+            .get_ident()
+            .map_or(false, |ident| ident == WORLD_QUERY_ATTRIBUTE_NAME)
+        {
+            return Err(syn::Error::new_spanned(
+                attr,
+                "#[derive(WorldQuery)] does not support field attributes.",
+            ));
+        }
+
+        attrs.push(attr.clone());
+    }
 
-    WorldQueryFieldInfo { is_ignored, attrs }
+    Ok(WorldQueryFieldInfo { attrs })
 }

crates/bevy_ecs/macros/src/lib.rs

@@ -7,13 +7,12 @@ mod states;
 
 use crate::{fetch::derive_world_query_impl, set::derive_set};
 use bevy_macro_utils::{derive_boxed_label, get_named_struct_fields, BevyManifest};
-use proc_macro::TokenStream;
+use proc_macro::{TokenStream, TokenTree};
 use proc_macro2::Span;
 use quote::{format_ident, quote};
 use syn::{
-    parse::ParseStream, parse_macro_input, parse_quote, punctuated::Punctuated, spanned::Spanned,
-    ConstParam, DeriveInput, Field, GenericParam, Ident, Index, Meta, MetaList, NestedMeta, Token,
-    TypeParam,
+    parse_macro_input, parse_quote, punctuated::Punctuated, spanned::Spanned, ConstParam,
+    DeriveInput, GenericParam, Ident, Index, Meta, MetaList, NestedMeta, Token, TypeParam,
 };
 
 enum BundleFieldKind {
@@ -248,16 +247,29 @@ pub fn impl_param_set(_input: TokenStream) -> TokenStream {
     tokens
 }
 
-#[derive(Default)]
-struct SystemParamFieldAttributes {
-    pub ignore: bool,
+/// Checks if the specified identifier occurs in the specified [`TokenStream`].
+#[allow(clippy::cmp_owned)]
+fn check_for_collision(haystack: TokenStream, value: &Ident) -> bool {
+    haystack.into_iter().any(|t| match t {
+        TokenTree::Group(g) => check_for_collision(g.stream(), value),
+        TokenTree::Ident(ident) => ident.to_string() == value.to_string(),
+        TokenTree::Punct(_) | TokenTree::Literal(_) => false,
+    })
 }
 
-static SYSTEM_PARAM_ATTRIBUTE_NAME: &str = "system_param";
+fn ensure_no_collision(haystack: TokenStream, mut value: Ident) -> Ident {
+    // If there's a collision, add more characters to the identifier
+    // until it doesn't collide with anything anymore.
+    while check_for_collision(haystack.clone(), &value) {
+        value = format_ident!("{value}X");
+    }
+    value
+}
 
 /// Implement `SystemParam` to use a struct as a parameter in a system
-#[proc_macro_derive(SystemParam, attributes(system_param))]
+#[proc_macro_derive(SystemParam)]
 pub fn derive_system_param(input: TokenStream) -> TokenStream {
+    let token_stream = input.clone();
     let ast = parse_macro_input!(input as DeriveInput);
     let syn::Data::Struct(syn::DataStruct { fields: field_definitions, ..}) = ast.data else {
         return syn::Error::new(ast.span(), "Invalid `SystemParam` type: expected a `struct`")
@@ -266,52 +278,20 @@ pub fn derive_system_param(input: TokenStream) -> TokenStream {
     };
     let path = bevy_ecs_path();
 
-    let field_attributes = field_definitions
-        .iter()
-        .map(|field| {
-            (
-                field,
-                field
-                    .attrs
-                    .iter()
-                    .find(|a| *a.path.get_ident().as_ref().unwrap() == SYSTEM_PARAM_ATTRIBUTE_NAME)
-                    .map_or_else(SystemParamFieldAttributes::default, |a| {
-                        syn::custom_keyword!(ignore);
-                        let mut attributes = SystemParamFieldAttributes::default();
-                        a.parse_args_with(|input: ParseStream| {
-                            if input.parse::<Option<ignore>>()?.is_some() {
-                                attributes.ignore = true;
-                            }
-                            Ok(())
-                        })
-                        .expect("Invalid 'system_param' attribute format.");
-
-                        attributes
-                    }),
-            )
-        })
-        .collect::<Vec<(&Field, SystemParamFieldAttributes)>>();
     let mut field_locals = Vec::new();
     let mut fields = Vec::new();
     let mut field_types = Vec::new();
-    let mut ignored_fields = Vec::new();
-    let mut ignored_field_types = Vec::new();
-    for (i, (field, attrs)) in field_attributes.iter().enumerate() {
-        if attrs.ignore {
-            ignored_fields.push(field.ident.as_ref().unwrap());
-            ignored_field_types.push(&field.ty);
-        } else {
-            field_locals.push(format_ident!("f{i}"));
-            let i = Index::from(i);
-            fields.push(
-                field
-                    .ident
-                    .as_ref()
-                    .map(|f| quote! { #f })
-                    .unwrap_or_else(|| quote! { #i }),
-            );
-            field_types.push(&field.ty);
-        }
+    for (i, field) in field_definitions.iter().enumerate() {
+        field_locals.push(format_ident!("f{i}"));
+        let i = Index::from(i);
+        fields.push(
+            field
+                .ident
+                .as_ref()
+                .map(|f| quote! { #f })
+                .unwrap_or_else(|| quote! { #i }),
+        );
+        field_types.push(&field.ty);
     }
 
     let generics = ast.generics;
@@ -367,6 +347,18 @@ pub fn derive_system_param(input: TokenStream) -> TokenStream {
         _ => unreachable!(),
     }));
 
+    let punctuated_generics_no_bounds: Punctuated<_, Token![,]> = lifetimeless_generics
+        .iter()
+        .map(|&g| match g.clone() {
+            GenericParam::Type(mut g) => {
+                g.bounds.clear();
+                GenericParam::Type(g)
+            }
+            g @ GenericParam::Const(_) => g,
+            _ => unreachable!(),
+        })
+        .collect();
+
     let mut tuple_types: Vec<_> = field_types.iter().map(|x| quote! { #x }).collect();
     let mut tuple_patterns: Vec<_> = field_locals.iter().map(|x| quote! { #x }).collect();
 
@@ -392,39 +384,38 @@ pub fn derive_system_param(input: TokenStream) -> TokenStream {
 
     let struct_name = &ast.ident;
     let state_struct_visibility = &ast.vis;
+    let fields_alias = ensure_no_collision(token_stream, format_ident!("FieldsAlias"));
 
     TokenStream::from(quote! {
         // We define the FetchState struct in an anonymous scope to avoid polluting the user namespace.
         // The struct can still be accessed via SystemParam::State, e.g. EventReaderState can be accessed via
         // <EventReader<'static, 'static, T> as SystemParam>::State
         const _: () = {
+            // Allows rebinding the lifetimes of each field type.
+            type #fields_alias <'w, 's, #punctuated_generics_no_bounds> = (#(#tuple_types,)*);
+
             #[doc(hidden)]
-            #state_struct_visibility struct FetchState <'w, 's, #(#lifetimeless_generics,)*>
+            #state_struct_visibility struct FetchState <#(#lifetimeless_generics,)*>
             #where_clause {
-                state: (#(<#tuple_types as #path::system::SystemParam>::State,)*),
-                marker: std::marker::PhantomData<(
-                    <#path::prelude::Query<'w, 's, ()> as #path::system::SystemParam>::State,
-                    #(fn() -> #ignored_field_types,)*
-                )>,
+                state: <#fields_alias::<'static, 'static, #punctuated_generic_idents> as #path::system::SystemParam>::State,
             }
 
             unsafe impl<'w, 's, #punctuated_generics> #path::system::SystemParam for #struct_name #ty_generics #where_clause {
-                type State = FetchState<'static, 'static, #punctuated_generic_idents>;
+                type State = FetchState<#punctuated_generic_idents>;
                 type Item<'_w, '_s> = #struct_name <#(#shadowed_lifetimes,)* #punctuated_generic_idents>;
 
                 fn init_state(world: &mut #path::world::World, system_meta: &mut #path::system::SystemMeta) -> Self::State {
                     FetchState {
-                        state: <(#(#tuple_types,)*) as #path::system::SystemParam>::init_state(world, system_meta),
-                        marker: std::marker::PhantomData,
+                        state: <#fields_alias::<'static, 'static, #punctuated_generic_idents> as #path::system::SystemParam>::init_state(world, system_meta),
                     }
                 }
 
                 fn new_archetype(state: &mut Self::State, archetype: &#path::archetype::Archetype, system_meta: &mut #path::system::SystemMeta) {
-                    <(#(#tuple_types,)*) as #path::system::SystemParam>::new_archetype(&mut state.state, archetype, system_meta)
+                    <#fields_alias::<'w, 's, #punctuated_generic_idents> as #path::system::SystemParam>::new_archetype(&mut state.state, archetype, system_meta)
                 }
 
                 fn apply(state: &mut Self::State, system_meta: &#path::system::SystemMeta, world: &mut #path::world::World) {
-                    <(#(#tuple_types,)*) as #path::system::SystemParam>::apply(&mut state.state, system_meta, world);
+                    <#fields_alias::<'w, 's, #punctuated_generic_idents> as #path::system::SystemParam>::apply(&mut state.state, system_meta, world);
                 }
 
                 unsafe fn get_param<'w2, 's2>(
@@ -434,11 +425,10 @@ pub fn derive_system_param(input: TokenStream) -> TokenStream {
                     change_tick: #path::component::Tick,
                 ) -> Self::Item<'w2, 's2> {
                     let (#(#tuple_patterns,)*) = <
-                        (#(#tuple_types,)*) as #path::system::SystemParam
+                        #fields_alias::<'w2, 's2, #punctuated_generic_idents> as #path::system::SystemParam
                     >::get_param(&mut state.state, system_meta, world, change_tick);
                     #struct_name {
                         #(#fields: #field_locals,)*
-                        #(#ignored_fields: std::default::Default::default(),)*
                     }
                 }
             }