Use phantomdata in CopyOnDrop

Author: Manishearth

src/slice/quicksort.rs

@@ -5,16 +5,20 @@
 //! `rayon_core::join`.
 
 use std::cmp;
+use std::marker::PhantomData;
 use std::mem::{self, MaybeUninit};
 use std::ptr;
 
 /// When dropped, copies from `src` into `dest`.
-struct CopyOnDrop<T> {
+struct CopyOnDrop<'src, 'dest, T> {
     src: *const T,
     dest: *mut T,
+    /// `src` is often a local pointer here, make sure we have appropriate
+    /// PhantomData so that dropck can protect us.
+    marker: PhantomData<(&'src T, &'dest mut T)>,
 }
 
-impl<T> Drop for CopyOnDrop<T> {
+impl<T> Drop for CopyOnDrop<'_, '_, T> {
     fn drop(&mut self) {
         // SAFETY:  This is a helper class.
         //          Please refer to its usage for correctness.
@@ -26,7 +30,7 @@ impl<T> Drop for CopyOnDrop<T> {
 }
 
 /// Shifts the first element to the right until it encounters a greater or equal element.
-fn shift_head<T, F>(v: &mut [T], is_less: &F)
+fn shift_head<'v, T, F>(v: &'v mut [T], is_less: &F)
 where
     F: Fn(&T, &T) -> bool,
 {
@@ -54,9 +58,10 @@ where
             // into the slice.
             let tmp = mem::ManuallyDrop::new(ptr::read(v.get_unchecked(0)));
             let v = v.as_mut_ptr();
-            let mut hole = CopyOnDrop {
+            let mut hole = CopyOnDrop::<'_, 'v, _> {
                 src: &*tmp,
                 dest: v.add(1),
+                marker: PhantomData,
             };
             ptr::copy_nonoverlapping(v.add(1), v.add(0), 1);
 
@@ -75,7 +80,7 @@ where
 }
 
 /// Shifts the last element to the left until it encounters a smaller or equal element.
-fn shift_tail<T, F>(v: &mut [T], is_less: &F)
+fn shift_tail<'v, T, F>(v: &'v mut [T], is_less: &F)
 where
     F: Fn(&T, &T) -> bool,
 {
@@ -103,9 +108,10 @@ where
             // into the slice.
             let tmp = mem::ManuallyDrop::new(ptr::read(v.get_unchecked(len - 1)));
             let v = v.as_mut_ptr();
-            let mut hole = CopyOnDrop {
+            let mut hole = CopyOnDrop::<'_, 'v, _> {
                 src: &*tmp,
                 dest: v.add(len - 2),
+                marker: PhantomData,
             };
             ptr::copy_nonoverlapping(v.add(len - 2), v.add(len - 1), 1);
 
@@ -495,7 +501,7 @@ where
 ///
 /// 1. Number of elements smaller than `v[pivot]`.
 /// 2. True if `v` was already partitioned.
-fn partition<T, F>(v: &mut [T], pivot: usize, is_less: &F) -> (usize, bool)
+fn partition<'v, T, F>(v: &'v mut [T], pivot: usize, is_less: &F) -> (usize, bool)
 where
     F: Fn(&T, &T) -> bool,
 {
@@ -510,9 +516,10 @@ where
 
         // SAFETY: `pivot` is a reference to the first element of `v`, so `ptr::read` is safe.
         let tmp = mem::ManuallyDrop::new(unsafe { ptr::read(pivot) });
-        let _pivot_guard = CopyOnDrop {
+        let _pivot_guard = CopyOnDrop::<'_, 'v, _> {
             src: &*tmp,
             dest: pivot,
+            marker: PhantomData,
         };
         let pivot = &*tmp;
 
@@ -556,7 +563,7 @@ where
 ///
 /// Returns the number of elements equal to the pivot. It is assumed that `v` does not contain
 /// elements smaller than the pivot.
-fn partition_equal<T, F>(v: &mut [T], pivot: usize, is_less: &F) -> usize
+fn partition_equal<'v, T, F>(v: &'v mut [T], pivot: usize, is_less: &F) -> usize
 where
     F: Fn(&T, &T) -> bool,
 {
@@ -569,9 +576,10 @@ where
     // operation panics, the pivot will be automatically written back into the slice.
     // SAFETY: The pointer here is valid because it is obtained from a reference to a slice.
     let tmp = mem::ManuallyDrop::new(unsafe { ptr::read(pivot) });
-    let _pivot_guard = CopyOnDrop {
+    let _pivot_guard = CopyOnDrop::<'_, 'v, _> {
         src: &*tmp,
         dest: pivot,
+        marker: PhantomData,
     };
     let pivot = &*tmp;