Rename Fetch and FilterFetch macros to WorldQuery

Author: vladbat00

crates/bevy_ecs/macros/src/fetch.rs

@@ -3,7 +3,7 @@ use proc_macro2::{Ident, Span};
 use quote::{quote, ToTokens};
 use syn::{
     parse::{Parse, ParseStream},
-    parse_macro_input, parse_quote,
+    parse_quote,
     punctuated::Punctuated,
     Attribute, Data, DataStruct, DeriveInput, Field, Fields, GenericArgument, GenericParam,
     ImplGenerics, Lifetime, LifetimeDef, Path, PathArguments, ReturnType, Token, Type,
@@ -18,25 +18,23 @@ struct FetchStructAttributes {
     pub read_only_derive_args: Punctuated<syn::NestedMeta, syn::token::Comma>,
 }
 
+pub static FILTER_ATTRIBUTE_NAME: &str = "filter";
 static MUTABLE_ATTRIBUTE_NAME: &str = "mutable";
 static READ_ONLY_DERIVE_ATTRIBUTE_NAME: &str = "read_only_derive";
 
 mod field_attr_keywords {
     syn::custom_keyword!(ignore);
 }
 
-static FETCH_ATTRIBUTE_NAME: &str = "fetch";
-static FILTER_FETCH_ATTRIBUTE_NAME: &str = "filter_fetch";
-
-pub fn derive_fetch_impl(input: TokenStream) -> TokenStream {
-    let ast = parse_macro_input!(input as DeriveInput);
+pub static WORLD_QUERY_ATTRIBUTE_NAME: &str = "world_query";
 
+pub fn derive_world_query_impl(ast: DeriveInput) -> TokenStream {
     let mut fetch_struct_attributes = FetchStructAttributes::default();
     for attr in &ast.attrs {
         if !attr
             .path
             .get_ident()
-            .map_or(false, |ident| ident == FETCH_ATTRIBUTE_NAME)
+            .map_or(false, |ident| ident == WORLD_QUERY_ATTRIBUTE_NAME)
         {
             continue;
         }
@@ -74,7 +72,7 @@ pub fn derive_fetch_impl(input: TokenStream) -> TokenStream {
             }
             Ok(())
         })
-        .unwrap_or_else(|_| panic!("Invalid `{}` attribute format", FETCH_ATTRIBUTE_NAME));
+        .unwrap_or_else(|_| panic!("Invalid `{}` attribute format", WORLD_QUERY_ATTRIBUTE_NAME));
     }
 
     let FetchImplTokens {
@@ -101,7 +99,11 @@ pub fn derive_fetch_impl(input: TokenStream) -> TokenStream {
         field_types: _,
         query_types,
         fetch_init_types,
-    } = fetch_impl_tokens(&ast, FETCH_ATTRIBUTE_NAME, fetch_struct_attributes.mutable);
+    } = fetch_impl_tokens(
+        &ast,
+        WORLD_QUERY_ATTRIBUTE_NAME,
+        fetch_struct_attributes.mutable,
+    );
 
     if !has_world_lifetime {
         panic!("Expected a struct with a lifetime");
@@ -319,9 +321,7 @@ pub fn derive_fetch_impl(input: TokenStream) -> TokenStream {
     tokens
 }
 
-pub fn derive_filter_fetch_impl(input: TokenStream) -> TokenStream {
-    let ast = parse_macro_input!(input as DeriveInput);
-
+pub fn derive_world_query_filter_impl(ast: DeriveInput) -> TokenStream {
     let FetchImplTokens {
         struct_name,
         struct_name_read_only: _,
@@ -346,7 +346,7 @@ pub fn derive_filter_fetch_impl(input: TokenStream) -> TokenStream {
         field_types,
         query_types: _,
         fetch_init_types: _,
-    } = fetch_impl_tokens(&ast, FILTER_FETCH_ATTRIBUTE_NAME, false);
+    } = fetch_impl_tokens(&ast, WORLD_QUERY_ATTRIBUTE_NAME, false);
 
     if has_world_lifetime {
         panic!("Expected a struct without a lifetime");

crates/bevy_ecs/macros/src/lib.rs

@@ -3,7 +3,10 @@ extern crate proc_macro;
 mod component;
 mod fetch;
 
-use crate::fetch::{derive_fetch_impl, derive_filter_fetch_impl};
+use crate::fetch::{
+    derive_world_query_filter_impl, derive_world_query_impl, FILTER_ATTRIBUTE_NAME,
+    WORLD_QUERY_ATTRIBUTE_NAME,
+};
 use bevy_macro_utils::{derive_label, get_named_struct_fields, BevyManifest};
 use proc_macro::TokenStream;
 use proc_macro2::Span;
@@ -428,15 +431,45 @@ pub fn derive_system_param(input: TokenStream) -> TokenStream {
 }
 
 /// Implement `WorldQuery` to use a struct as a parameter in a query
-#[proc_macro_derive(Fetch, attributes(fetch))]
-pub fn derive_fetch(input: TokenStream) -> TokenStream {
-    derive_fetch_impl(input)
-}
+#[proc_macro_derive(WorldQuery, attributes(world_query))]
+pub fn derive_world_query(input: TokenStream) -> TokenStream {
+    let ast = parse_macro_input!(input as DeriveInput);
+
+    let mut is_filter = false;
 
-/// Implement `FilterFetch` to use a struct as a filter parameter in a query
-#[proc_macro_derive(FilterFetch, attributes(filter_fetch))]
-pub fn derive_filter_fetch(input: TokenStream) -> TokenStream {
-    derive_filter_fetch_impl(input)
+    for attr in &ast.attrs {
+        if !attr
+            .path
+            .get_ident()
+            .map_or(false, |ident| ident == WORLD_QUERY_ATTRIBUTE_NAME)
+        {
+            continue;
+        }
+        attr.parse_args_with(|input: ParseStream| {
+            let meta = input.parse_terminated::<syn::Meta, syn::token::Comma>(syn::Meta::parse)?;
+            for meta in meta {
+                let ident = meta.path().get_ident();
+                if ident.map_or(false, |ident| ident == FILTER_ATTRIBUTE_NAME) {
+                    if let syn::Meta::Path(_) = meta {
+                        is_filter = true;
+                    } else {
+                        panic!(
+                            "The `{}` attribute is expected to have no value or arguments",
+                            FILTER_ATTRIBUTE_NAME
+                        );
+                    }
+                }
+            }
+            Ok(())
+        })
+        .unwrap_or_else(|_| panic!("Invalid `{}` attribute format", WORLD_QUERY_ATTRIBUTE_NAME));
+    }
+
+    if is_filter {
+        derive_world_query_filter_impl(ast)
+    } else {
+        derive_world_query_impl(ast)
+    }
 }
 
 #[proc_macro_derive(SystemLabel)]