fix: conditional and unconditional yield of optional filtered queries

Author: ten3roberts

flax-derive/src/lib.rs

@@ -211,11 +211,15 @@ fn derive_union(params: &Params) -> TokenStream {
 
     let prep_ty = params.w_ty();
 
+    // Make sure not to *or* ignored fields
     let filter_fields = fields.iter().filter(|v| !v.attrs.ignore).map(|v| v.ident);
+    let filter_types = fields.iter().filter(|v| !v.attrs.ignore).map(|v| v.ty);
 
     quote! {
         #[automatically_derived]
         impl #impl_generics #crate_name::fetch::UnionFilter for #prepared_name #prep_ty where #prepared_name #prep_ty: #crate_name::fetch::PreparedFetch<'q> {
+            const HAS_UNION_FILTER: bool = #(<<#filter_types as #crate_name::fetch::Fetch<'w>>::Prepared as #crate_name::fetch::PreparedFetch<'q>>::HAS_FILTER)&&*;
+
             unsafe fn filter_union(&mut self, slots: #crate_name::archetype::Slice) -> #crate_name::archetype::Slice {
                 #crate_name::fetch::PreparedFetch::filter_slots(&mut #crate_name::filter::Union((#(&mut self.#filter_fields,)*)), slots)
             }
@@ -386,6 +390,8 @@ fn derive_prepared_struct(params: &Params) -> TokenStream {
             type Item = #item_name #item_ty;
             type Chunk = (#(<<#field_types as #crate_name::fetch::Fetch<'w>>::Prepared as #crate_name::fetch::PreparedFetch<'q>>::Chunk,)*);
 
+            const HAS_FILTER: bool = #(<<#field_types as #crate_name::fetch::Fetch<'w>>::Prepared as #crate_name::fetch::PreparedFetch<'q>>::HAS_FILTER)||*;
+
             #[inline]
             unsafe fn fetch_next(chunk: &mut Self::Chunk) -> Self::Item {
                 Self::Item {

src/fetch/as_deref.rs

@@ -56,9 +56,10 @@ where
     V: 'static + Deref,
 {
     type Item = &'q V::Target;
-
     type Chunk = F::Chunk;
 
+    const HAS_FILTER: bool = F::HAS_FILTER;
+
     unsafe fn filter_slots(&mut self, slots: crate::archetype::Slice) -> crate::archetype::Slice {
         self.0.filter_slots(slots)
     }

src/fetch/cloned.rs

@@ -73,6 +73,8 @@ where
     type Item = V;
     type Chunk = F::Chunk;
 
+    const HAS_FILTER: bool = F::HAS_FILTER;
+
     unsafe fn create_chunk(&'q mut self, slots: Slice) -> Self::Chunk {
         self.0.create_chunk(slots)
     }

src/fetch/component.rs

@@ -14,6 +14,8 @@ impl<'w, 'q, T: 'q> PreparedFetch<'q> for ReadComponent<'w, T> {
 
     type Chunk = Ptr<'q, T>;
 
+    const HAS_FILTER: bool = false;
+
     #[inline]
     unsafe fn create_chunk(&'q mut self, slots: Slice) -> Self::Chunk {
         Ptr::new(self.borrow[slots.as_range()].as_ptr())

src/fetch/component_mut.rs

@@ -78,6 +78,8 @@ pub struct WriteComponent<'a, T> {
 impl<'w, 'q, T: 'q + ComponentValue> PreparedFetch<'q> for WriteComponent<'w, T> {
     type Item = &'q mut T;
     type Chunk = PtrMut<'q, T>;
+    
+    const HAS_FILTER: bool = false;
 
     unsafe fn create_chunk(&'q mut self, slots: Slice) -> Self::Chunk {
         self.guard

src/fetch/copied.rs

@@ -70,6 +70,8 @@ where
     type Item = V;
     type Chunk = F::Chunk;
 
+    const HAS_FILTER: bool = F::HAS_FILTER;
+
     unsafe fn create_chunk(&'q mut self, slots: Slice) -> Self::Chunk {
         self.0.create_chunk(slots)
     }

src/fetch/entity_ref.rs

@@ -74,6 +74,7 @@ pub struct Batch<'a> {
 impl<'w, 'q> PreparedFetch<'q> for PreparedEntityRef<'w> {
     type Item = EntityRef<'q>;
     type Chunk = Batch<'q>;
+    const HAS_FILTER: bool = false;
 
     unsafe fn create_chunk(&'q mut self, slice: crate::archetype::Slice) -> Self::Chunk {
         Batch {

src/fetch/ext.rs

@@ -19,7 +19,7 @@ use super::{
 pub trait FetchExt: Sized {
     /// Transform the fetch into an optional fetch, yielding Some or None
     fn opt(self) -> Opt<Self> {
-        Opt(self)
+        Opt { fetch: self }
     }
 
     /// Transform the fetch into a fetch with a provided default.

src/fetch/map.rs

@@ -72,6 +72,8 @@ where
 
     type Chunk = (&'q F, Q::Chunk);
 
+    const HAS_FILTER: bool = Q::HAS_FILTER;
+
     unsafe fn create_chunk(&'q mut self, slots: crate::archetype::Slice) -> Self::Chunk {
         (self.func, self.query.create_chunk(slots))
     }

src/fetch/maybe_mut.rs

@@ -90,6 +90,8 @@ impl<'w, 'q, T: ComponentValue> PreparedFetch<'q> for PreparedMaybeMut<'w, T> {
     type Item = MutGuard<'q, T>;
     type Chunk = Batch<'q>;
 
+    const HAS_FILTER: bool = false;
+
     unsafe fn create_chunk(&'q mut self, slice: crate::archetype::Slice) -> Self::Chunk {
         Batch {
             cell: self.cell,