ecs: Fix panic when query contains unknown components

Author: caelunshun

Cargo.lock

@@ -8,4 +8,6 @@ edition = "2018"
 ahash = "0.7"
 arrayvec = "0.5"
 itertools = "0.10"
+once_cell = "1"
 thiserror = "1"
+thread_local= "1"

quill/ecs/Cargo.toml

@@ -145,7 +145,7 @@ impl Ecs {
     ///
     /// Returns an iterator over tuples of `(entity, components)`.
     pub fn query<'w, 'q, Q: QueryTuple<'w>>(&'w self) -> Query<'w, 'q, Q> {
-        let sparse_sets = Q::sparse_sets(&self.components).unwrap_or_else(|| todo!());
+        let sparse_sets = Q::sparse_sets(&self.components);
         let sparse_set_refs: Vec<_> = sparse_sets.iter().map(|set| set.to_ref()).collect();
         let dense_indices = Q::dense_indices();
 

quill/ecs/src/ecs.rs

@@ -131,7 +131,7 @@ pub trait QueryTuple<'a> {
     type Output: 'a;
 
     // avoiding allocations here is blocked on const generics and/or GATs
-    fn sparse_sets(components: &Components) -> Option<Vec<&SparseSetStorage>>;
+    fn sparse_sets(components: &Components) -> Vec<&SparseSetStorage>;
 
     fn dense_indices() -> Vec<Cell<u32>>;
 
@@ -153,12 +153,12 @@ macro_rules! query_tuple_impl {
         impl <'a, $($ty: QueryParameter<'a>),*> QueryTuple<'a> for ($($ty),*) {
             type Output = ($($ty::Output),*);
 
-            fn sparse_sets(components: &Components) -> Option<Vec<&SparseSetStorage>> {
-                Some(vec![
+            fn sparse_sets(components: &Components) -> Vec<&SparseSetStorage> {
+                vec![
                     $(
-                        components.storage_for::<$ty::Component>().ok()?,
+                        components.storage_for::<$ty::Component>().unwrap_or_else(|_| SparseSetStorage::empty()),
                     )*
-                ])
+                ]
             }
 
             fn dense_indices() -> Vec<Cell<u32>> {

quill/ecs/src/query.rs

@@ -188,6 +188,8 @@ impl Drop for BlobArray {
     }
 }
 
+unsafe impl Send for BlobArray {}
+
 #[cfg(test)]
 mod tests {
     use super::*;

quill/ecs/src/storage/blob_array.rs

@@ -6,13 +6,18 @@ use std::{
     ptr::NonNull,
 };
 
+use once_cell::sync::Lazy;
+use thread_local::ThreadLocal;
+
 use crate::{
     borrow::BorrowFlag,
     component::{self, ComponentMeta},
 };
 
 use super::{blob_array::BlobArray, component_vec::ComponentVec};
 
+static EMPTY: Lazy<ThreadLocal<SparseSetStorage>> = Lazy::new(ThreadLocal::new);
+
 /// Stores components in a sparse set.
 pub struct SparseSetStorage {
     // Data structure invariant: if `dense[sparse[i]] == i`,
@@ -37,6 +42,13 @@ impl SparseSetStorage {
         }
     }
 
+    /// The empty sparse set.
+    /// Attempting to access components from this sparse
+    /// set will usually cause a panic.
+    pub fn empty() -> &'static Self {
+        EMPTY.get_or(|| SparseSetStorage::new(ComponentMeta::of::<()>()))
+    }
+
     pub fn insert<T: 'static>(&mut self, index: u32, value: T) {
         self.assert_type_matches::<T>();
         let value = MaybeUninit::new(value);

quill/ecs/src/storage/sparse_set.rs

@@ -106,7 +106,7 @@ fn query_big_ecs_after_despawn() {
     let mut ecs = Ecs::new();
 
     let mut entities = Vec::new();
-    for i in 0..10_000usize {
+    for i in 0..100usize {
         let mut builder = EntityBuilder::new();
         if i % 3 == 0 {
             builder.add(format!("entity #{}", i));
@@ -130,3 +130,10 @@ fn query_big_ecs_after_despawn() {
 
     assert_eq!(queried.len(), entities.len());
 }
+
+#[test]
+fn empty_query() {
+    let ecs = Ecs::new();
+
+    assert_eq!(ecs.query::<&i32>().iter().count(), 0);
+}