Support non-archetypal QueryData (#21581)

# Objective

For #17647, we want to create a `QueryData` that can follow a relation
and query data from an entity's parent. If the parent does not have the
queried data, the child entity should be skipped in the query. However,
there is no way to tell from the child's archetype whether the parent
will match! So, we need to support *non-archetypal* `QueryData`, just as
we support non-archetypal `QueryFilter`s for `Added` and `Changed`.

That is, if `Query<Parent<&T>>` yields `&T`, and we do:

```rust
let parent1 = world.spawn(T).id();
let child1 = world.spawn(ChildOf(parent1));
let parent2 = world.spawn(()).id();
let child2 = world.spawn(ChildOf(parent2));

let query = world.query::<Parent<&T>>();
```

then `query` must yield a row for `child1` but not for `child2`, even
though they have the same archetype.

## Solution

Change `QueryData::fetch` to return `Option` so that entities can be
filtered during fetching by returning `None`.

To support `ExactSizeIterator`, introduce an `ArchetypeQueryData` trait
and an `QueryData::IS_ARCHETYPAL` associated constant, similar to
`ArchetypeFilter` and `QueryFilter::IS_ARCHETYPAL`. Implement this trait
on existing `QueryData` types. Modify `ExactSizeIterator`
implementations to require `D: ArchetypeQueryData`, and the
`size_hint()` methods to return a minimum size of `0` if
`!D::IS_ARCHETYPAL`.

## Alternatives

We could do nothing here, and have `Query<Parent<&T>>` yield
`Option<&T>`. That makes the API less convenient, though. Note that if
one *wants* to query for `Option`, they can use either
`Query<Option<Parent<&T>>` or `Query<Parent<Option<&T>>`, depending on
whether they want to include entities with no parent.

Another option is to re-use the `ArchetypeFilter` trait instead of
introducing a new one. There are no places where we want to abstract
over both, however, and it would require writing bounds like `D:
QueryData + ArchetypeFilter, F: QueryFilter + ArchetypeFilter` instead
of simply `D: ArchetypeQueryData, F: ArchetypeFilter`.

---------

Co-authored-by: Periwink <charlesbour@gmail.com>

Author: chescock

crates/bevy_asset/src/asset_changed.rs

@@ -279,7 +279,7 @@ unsafe impl<A: AsAssetId> QueryFilter for AssetChanged<A> {
             // SAFETY: We delegate to the inner `fetch` for `A`
             unsafe {
                 let handle = <&A>::fetch(&state.asset_id, inner, entity, table_row);
-                fetch.check.has_changed(handle)
+                handle.is_some_and(|handle| fetch.check.has_changed(handle))
             }
         })
     }

crates/bevy_ecs/macros/src/query_data.rs

@@ -266,6 +266,7 @@ pub fn derive_query_data_impl(input: TokenStream) -> TokenStream {
                 unsafe impl #user_impl_generics #path::query::QueryData
                 for #read_only_struct_name #user_ty_generics #user_where_clauses {
                     const IS_READ_ONLY: bool = true;
+                    const IS_ARCHETYPAL: bool = true #(&& <#read_only_field_types as #path::query::QueryData>::IS_ARCHETYPAL)*;
                     type ReadOnly = #read_only_struct_name #user_ty_generics;
                     type Item<'__w, '__s> = #read_only_item_struct_name #user_ty_generics_with_world_and_state;
 
@@ -294,10 +295,10 @@ pub fn derive_query_data_impl(input: TokenStream) -> TokenStream {
                         _fetch: &mut <Self as #path::query::WorldQuery>::Fetch<'__w>,
                         _entity: #path::entity::Entity,
                         _table_row: #path::storage::TableRow,
-                    ) -> Self::Item<'__w, '__s> {
-                        Self::Item {
-                            #(#field_idents: <#read_only_field_types>::fetch(&_state.#named_field_idents, &mut _fetch.#named_field_idents, _entity, _table_row),)*
-                        }
+                    ) -> Option<Self::Item<'__w, '__s>> {
+                        Some(Self::Item {
+                            #(#field_idents: <#read_only_field_types>::fetch(&_state.#named_field_idents, &mut _fetch.#named_field_idents, _entity, _table_row)?,)*
+                        })
                     }
                 }
 
@@ -312,6 +313,12 @@ pub fn derive_query_data_impl(input: TokenStream) -> TokenStream {
                         }
                     }
                 }
+
+                impl #user_impl_generics #path::query::ArchetypeQueryData
+                for #read_only_struct_name #user_ty_generics #user_where_clauses
+                // Make these HRTBs with an unused lifetime parameter to allow trivial constraints
+                // See https://github.com/rust-lang/rust/issues/48214
+                where #(for<'__a> #field_types: #path::query::ArchetypeQueryData,)* {}
             }
         } else {
             quote! {}
@@ -324,6 +331,7 @@ pub fn derive_query_data_impl(input: TokenStream) -> TokenStream {
             unsafe impl #user_impl_generics #path::query::QueryData
             for #struct_name #user_ty_generics #user_where_clauses {
                 const IS_READ_ONLY: bool = #is_read_only;
+                const IS_ARCHETYPAL: bool = true #(&& <#field_types as #path::query::QueryData>::IS_ARCHETYPAL)*;
                 type ReadOnly = #read_only_struct_name #user_ty_generics;
                 type Item<'__w, '__s> = #item_struct_name #user_ty_generics_with_world_and_state;
 
@@ -352,10 +360,10 @@ pub fn derive_query_data_impl(input: TokenStream) -> TokenStream {
                     _fetch: &mut <Self as #path::query::WorldQuery>::Fetch<'__w>,
                     _entity: #path::entity::Entity,
                     _table_row: #path::storage::TableRow,
-                ) -> Self::Item<'__w, '__s> {
-                    Self::Item {
-                        #(#field_idents: <#field_types>::fetch(&_state.#named_field_idents, &mut _fetch.#named_field_idents, _entity, _table_row),)*
-                    }
+                ) -> Option<Self::Item<'__w, '__s>> {
+                    Some(Self::Item {
+                        #(#field_idents: <#field_types>::fetch(&_state.#named_field_idents, &mut _fetch.#named_field_idents, _entity, _table_row)?,)*
+                    })
                 }
             }
 
@@ -371,6 +379,12 @@ pub fn derive_query_data_impl(input: TokenStream) -> TokenStream {
                 }
             }
 
+            impl #user_impl_generics #path::query::ArchetypeQueryData
+            for #struct_name #user_ty_generics #user_where_clauses
+            // Make these HRTBs with an unused lifetime parameter to allow trivial constraints
+            // See https://github.com/rust-lang/rust/issues/48214
+            where #(for<'__a> #field_types: #path::query::ArchetypeQueryData,)* {}
+
             #read_only_data_impl
         }
     };

crates/bevy_ecs/macros/src/query_filter.rs

@@ -97,7 +97,7 @@ pub fn derive_query_filter_impl(input: TokenStream) -> TokenStream {
         // SAFETY: This only performs access that subqueries perform, and they impl `QueryFilter` and so perform no mutable access.
         unsafe impl #user_impl_generics #path::query::QueryFilter
         for #struct_name #user_ty_generics #user_where_clauses {
-            const IS_ARCHETYPAL: bool = true #(&& <#field_types>::IS_ARCHETYPAL)*;
+            const IS_ARCHETYPAL: bool = true #(&& <#field_types as #path::query::QueryFilter>::IS_ARCHETYPAL)*;
 
             #[allow(unused_variables)]
             #[inline(always)]