ecs: Resolve Clippy lints

There was one false positive never_loop lint.

Author: caelunshun

quill/ecs/src/borrow.rs

@@ -116,3 +116,38 @@ impl<'a, T> Drop for RefMut<'a, T> {
         self.flag.unborrow_mut();
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn borrow_unborrow() {
+        let flag = BorrowFlag::default();
+        flag.borrow().unwrap();
+        assert!(flag.borrow_mut().is_err());
+        flag.borrow().unwrap();
+        assert!(flag.borrow_mut().is_err());
+
+        flag.unborrow();
+        assert!(flag.borrow_mut().is_err());
+        flag.unborrow();
+
+        flag.borrow_mut().unwrap();
+        assert!(flag.borrow().is_err());
+        assert!(flag.borrow_mut().is_err());
+
+        flag.unborrow_mut();
+        flag.borrow().unwrap();
+    }
+
+    #[test]
+    fn borrow_max_amount() {
+        let flag = BorrowFlag::default();
+        for _ in 0..254 {
+            flag.borrow().unwrap();
+            assert!(flag.borrow_mut().is_err());
+        }
+        assert!(flag.borrow().is_err());
+    }
+}

quill/ecs/src/query.rs

@@ -65,6 +65,7 @@ pub struct QueryDriverIter<'w, 'q> {
 }
 
 impl<'w, 'q> QueryDriverIter<'w, 'q> {
+    #[allow(clippy::never_loop)] // looks like a false positive - the loop has a `continue`
     pub fn next(&mut self) -> Option<QueryItem> {
         loop {
             let (sparse_index, lead_dense_index) = self.lead_iter.next()?;

quill/ecs/src/storage/component_vec.rs

@@ -141,7 +141,7 @@ impl ComponentVec {
             .arrays
             .last()
             .map(|array| array.capacity())
-            .unwrap_or(2usize.pow(START_CAP_LOG2 as u32));
+            .unwrap_or_else(|| 2usize.pow(START_CAP_LOG2 as u32));
         let next_capacity = previous_capacity.checked_mul(2).expect("capacity overflow");
         let array = BlobArray::new(self.component_meta.layout, next_capacity);
         self.arrays.push(array);

quill/ecs/src/storage/sparse_set.rs

@@ -57,6 +57,9 @@ impl SparseSetStorage {
         }
     }
 
+    /// # Safety
+    /// `component` must point to a valid (but not necessarily aligned) instance of the component
+    /// stored in this sparse set.
     pub unsafe fn insert_raw(&mut self, index: u32, component: *const u8) {
         self.grow_sparse_for(index);
 
@@ -183,6 +186,10 @@ impl<'a> SparseSetRef<'a> {
         self.dense.len()
     }
 
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
     /// Returns an iterator over (sparse_index, dense_index) within this sparse set.
     pub fn iter(&self) -> Iter<'a> {
         Iter {

quill/ecs/tests/ecs.rs

@@ -23,14 +23,14 @@ fn spawn_many_entities() {
     let mut entities = Vec::new();
     for i in 0..10_000 {
         let entity = EntityBuilder::new()
-            .add(10.0f32)
+            .add(10i32)
             .add(format!("Entity #{}", i))
             .spawn_into(&mut ecs);
         entities.push(entity);
     }
 
     for (i, entity) in entities.into_iter().enumerate() {
-        assert_eq!(*ecs.get::<f32>(entity).unwrap(), 10.0);
+        assert_eq!(*ecs.get::<i32>(entity).unwrap(), 10);
         assert_eq!(
             *ecs.get::<String>(entity).unwrap(),
             format!("Entity #{}", i)