Fix Clippy warnings

benches/bench.rs

@@ -16,6 +16,7 @@ fn basics(c: &mut Criterion) {
     });
 
     group.bench_function("experimental_owned", |b| {
+        #[allow(clippy::arc_with_non_send_sync)]
         let pool = Arc::new(ExperimentalPool::from_iter(&[()]));
         b.iter(|| pool.pull_owned())
     });

src/experimental.rs

@@ -32,17 +32,19 @@ impl<A> FromIterator<A> for Pool<A> {
 }
 
 impl<T> Pool<T> {
+    #[allow(clippy::must_use_candidate)]
     pub fn pull(&self) -> Option<ObjectRef<T>> {
         unsafe {
             self.freelist.first_free().map(|index| ObjectRef {
-                pool: &self,
+                pool: self,
                 value: (*self.objects[index].get()).assume_init_mut(),
                 index,
             })
         }
     }
 
     #[cfg(not(loom))]
+    #[allow(clippy::must_use_candidate)]
     pub fn pull_owned(self: &Arc<Self>) -> Option<Object<T>> {
         unsafe {
             self.freelist.first_free().map(|index| Object {
@@ -58,14 +60,16 @@ impl<T> Pool<T> {
         }
     }
 
+    #[allow(clippy::must_use_candidate)]
     pub fn len(&self) -> usize {
         let mut len = 0;
-        for int in self.freelist.ints.iter() {
-            len += int.load(Relaxed).count_ones() as usize
+        for int in &self.freelist.ints {
+            len += int.load(Relaxed).count_ones() as usize;
         }
         len
     }
 
+    #[allow(clippy::must_use_candidate)]
     pub fn capacity(&self) -> usize {
         self.objects.len()
     }
@@ -75,7 +79,7 @@ impl<T> Drop for Pool<T> {
     fn drop(&mut self) {
         unsafe {
             self.freelist
-                .iter_taken(|index| (*self.objects[index].get()).assume_init_drop())
+                .iter_taken(|index| (*self.objects[index].get()).assume_init_drop());
         }
     }
 }
@@ -86,21 +90,21 @@ pub struct ObjectRef<'a, T> {
     index: usize,
 }
 
-impl<'a, T> Deref for ObjectRef<'a, T> {
+impl<T> Deref for ObjectRef<'_, T> {
     type Target = T;
 
     fn deref(&self) -> &Self::Target {
         self.value as _
     }
 }
 
-impl<'a, T> DerefMut for ObjectRef<'a, T> {
+impl<T> DerefMut for ObjectRef<'_, T> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         self.value
     }
 }
 
-impl<'a, T> Drop for ObjectRef<'a, T> {
+impl<T> Drop for ObjectRef<'_, T> {
     fn drop(&mut self) {
         self.pool.freelist.free(self.index);
     }
@@ -133,7 +137,7 @@ impl<T> Drop for Object<T> {
                 .get()
                 .write(MaybeUninit::new(ManuallyDrop::take(&mut self.value)));
         }
-        self.pool.freelist.free(self.index)
+        self.pool.freelist.free(self.index);
     }
 }
 
@@ -180,7 +184,7 @@ impl FreeList {
         let int = index / U64_BITS;
         let bit = index % U64_BITS;
         let bits = self.ints[int].fetch_or(1 << bit, Release);
-        debug_assert_eq!(bits & 1 << bit, 0)
+        debug_assert_eq!(bits & 1 << bit, 0);
     }
 
     fn iter_taken<F: Fn(usize)>(&self, f: F) {
@@ -247,7 +251,7 @@ mod tests {
 
         impl Drop for DropTest {
             fn drop(&mut self) {
-                self.drops.borrow_mut()[self.index] = true
+                self.drops.borrow_mut()[self.index] = true;
             }
         }
 
@@ -292,7 +296,7 @@ mod tests {
             if let Some(ref mut o) = o {
                 **o += 1;
             }
-            objects.push(o)
+            objects.push(o);
         }
 
         assert!(p

src/lib.rs

@@ -198,7 +198,7 @@ impl<'a, T> Reusable<'a, T> {
     }
 }
 
-impl<'a, T> Deref for Reusable<'a, T> {
+impl<T> Deref for Reusable<'_, T> {
     type Target = T;
 
     #[inline]
@@ -207,14 +207,14 @@ impl<'a, T> Deref for Reusable<'a, T> {
     }
 }
 
-impl<'a, T> DerefMut for Reusable<'a, T> {
+impl<T> DerefMut for Reusable<'_, T> {
     #[inline]
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.data
     }
 }
 
-impl<'a, T> Drop for Reusable<'a, T> {
+impl<T> Drop for Reusable<'_, T> {
     #[inline]
     fn drop(&mut self) {
         unsafe { self.pool.attach(self.take()) }
@@ -281,16 +281,16 @@ mod tests {
 
     #[test]
     fn detach() {
-        let pool = Pool::new(1, || Vec::new());
+        let pool = Pool::new(1, Vec::new);
         let (pool, mut object) = pool.try_pull().unwrap().detach();
         object.push(1);
-        Reusable::new(&pool, object);
+        Reusable::new(pool, object);
         assert_eq!(pool.try_pull().unwrap()[0], 1);
     }
 
     #[test]
     fn detach_then_attach() {
-        let pool = Pool::new(1, || Vec::new());
+        let pool = Pool::new(1, Vec::new);
         let (pool, mut object) = pool.try_pull().unwrap().detach();
         object.push(1);
         pool.attach(object);
@@ -299,11 +299,11 @@ mod tests {
 
     #[test]
     fn pull() {
-        let pool = Pool::<Vec<u8>>::new(1, || Vec::new());
+        let pool = Pool::<Vec<u8>>::new(1, Vec::new);
 
         let object1 = pool.try_pull();
         let object2 = pool.try_pull();
-        let object3 = pool.pull(|| Vec::new());
+        let object3 = pool.pull(Vec::new);
 
         assert!(object1.is_some());
         assert!(object2.is_none());
@@ -315,7 +315,7 @@ mod tests {
 
     #[test]
     fn e2e() {
-        let pool = Pool::new(10, || Vec::new());
+        let pool = Pool::new(10, Vec::new);
         let mut objects = Vec::new();
 
         for i in 0..10 {
@@ -328,7 +328,7 @@ mod tests {
         drop(objects);
         assert!(pool.try_pull().is_some());
 
-        for i in (10..0).rev() {
+        for i in (0..10).rev() {
             let mut object = pool.objects.lock().pop().unwrap();
             assert_eq!(object.pop(), Some(i));
         }