Run destructors when clearing PinVec

src/pin_slab.rs

@@ -281,12 +281,6 @@ impl<T> Default for PinSlab<T> {
     }
 }
 
-impl<T> Drop for PinSlab<T> {
-    fn drop(&mut self) {
-        self.clear();
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::PinSlab;

src/pin_vec.rs

@@ -1,5 +1,6 @@
 use std::mem::{self, MaybeUninit};
 use std::ops::{Index, IndexMut};
+use std::ptr::drop_in_place;
 
 pub struct PinVec<T> {
     // Slots of memory. Once one has been allocated it is never moved.
@@ -22,6 +23,12 @@ impl<T> PinVec<T> {
     }
 
     pub fn clear(&mut self) {
+        for i in 0..self.len {
+            // Safety: we know the pointer is initialized because its index is in bounds, and it
+            // can be dropped because we are emptying the container, which means these contents
+            // will not be accessed again.
+            unsafe { drop_in_place(self.get_mut(i).unwrap()) }
+        }
         self.slots.clear();
         self.len = 0;
     }
@@ -66,6 +73,12 @@ impl<T> PinVec<T> {
     }
 }
 
+impl<T> Drop for PinVec<T> {
+    fn drop(&mut self) {
+        self.clear();
+    }
+}
+
 impl<T> Index<usize> for PinVec<T> {
     type Output = T;
 
@@ -106,6 +119,8 @@ const fn calculate_key(key: usize) -> (usize, usize, usize) {
 mod tests {
     use crate::pin_vec::calculate_key;
 
+    use super::PinVec;
+
     #[test]
     fn key_test() {
         // NB: range of the first slot.
@@ -121,4 +136,24 @@ mod tests {
             );
         }
     }
+
+    #[test]
+    fn run_destructors() {
+        let mut destructor_ran = false;
+
+        struct RunDestructor<'a>(&'a mut bool);
+        impl<'a> Drop for RunDestructor<'a> {
+            fn drop(&mut self) {
+                *self.0 = true;
+            }
+        }
+
+        {
+            // Make sure PinVec runs the destructors
+            let mut v = PinVec::new();
+            v.push(RunDestructor(&mut destructor_ran));
+        }
+
+        assert!(destructor_ran);
+    }
 }

tests/pin_slab_memory_leak.rs

@@ -0,0 +1,17 @@
+use unicycle::pin_slab::PinSlab;
+
+struct Foo(u32);
+
+struct Bar(Vec<u32>);
+
+#[global_allocator]
+static ALLOCATOR: checkers::Allocator = checkers::Allocator::system();
+
+#[checkers::test]
+fn test_pin_slab_memory_leak() {
+    let mut copy = PinSlab::new();
+    copy.insert(Foo(42));
+
+    let mut non_copy = PinSlab::new();
+    non_copy.insert(Bar(vec![42]));
+}