Use PhantomData in InsertionHole.

Author: n3vu0r

src/insertion_sort.rs

@@ -2,16 +2,33 @@
 //!
 //! [`core::slice::sort`]: https://doc.rust-lang.org/src/core/slice/sort.rs.html
 
-use core::{mem, ptr};
+use core::{marker::PhantomData, mem, ptr};
 use ndarray::{s, ArrayViewMut1, IndexLonger};
 
 // When dropped, copies from `src` into `dest`.
-struct InsertionHole<T> {
-	src: *const T,
-	dest: *mut T,
+#[must_use]
+pub(super) struct InsertionHole<'a, T> {
+	pub(super) src: *const T,
+	pub(super) dest: *mut T,
+	/// `src` is often a local pointer here, make sure we have appropriate
+	/// PhantomData so that dropck can protect us.
+	marker: PhantomData<&'a mut T>,
 }
 
-impl<T> Drop for InsertionHole<T> {
+impl<'a, T> InsertionHole<'a, T> {
+	/// Construct from a source pointer and a destination
+	/// Assumes dest lives longer than src, since there is no easy way to
+	/// copy down lifetime information from another pointer
+	pub(super) unsafe fn new(src: &'a T, dest: *mut T) -> Self {
+		Self {
+			src,
+			dest,
+			marker: PhantomData,
+		}
+	}
+}
+
+impl<T> Drop for InsertionHole<'_, T> {
 	fn drop(&mut self) {
 		// SAFETY: This is a helper class. Please refer to its usage for correctness. Namely, one
 		// must be sure that `src` and `dst` does not overlap as required by
@@ -58,10 +75,7 @@ where
 			// If `is_less` panics at any point during the process, `hole` will get dropped and
 			// fill the hole in `v` with `tmp`, thus ensuring that `v` still holds every object it
 			// initially held exactly once.
-			let mut hole = InsertionHole {
-				src: &*tmp,
-				dest: v.view_mut().uget(i - 1),
-			};
+			let mut hole = InsertionHole::new(&*tmp, v.view_mut().uget(i - 1));
 			ptr::copy_nonoverlapping(hole.dest, v.view_mut().uget(i), 1);
 
 			// SAFETY: We know i is at least 1.
@@ -126,7 +140,7 @@ where
 			// fill the hole in `v` with `tmp`, thus ensuring that `v` still holds every object it
 			// initially held exactly once.
 			let dest = v.view_mut().uget(1);
-			let mut hole = InsertionHole { src: &*tmp, dest };
+			let mut hole = InsertionHole::new(&*tmp, dest);
 			ptr::copy_nonoverlapping(dest, v.view_mut().uget(0), 1);
 
 			for i in 2..v.len() {

src/par/insertion_sort.rs

@@ -2,26 +2,10 @@
 //!
 //! [`core::slice::sort`]: https://doc.rust-lang.org/src/core/slice/sort.rs.html
 
+use crate::insertion_sort::InsertionHole;
 use core::{mem, ptr};
 use ndarray::{s, ArrayViewMut1, IndexLonger};
 
-// When dropped, copies from `src` into `dest`.
-struct InsertionHole<T> {
-	src: *const T,
-	dest: *mut T,
-}
-
-impl<T> Drop for InsertionHole<T> {
-	fn drop(&mut self) {
-		// SAFETY: This is a helper class. Please refer to its usage for correctness. Namely, one
-		// must be sure that `src` and `dst` does not overlap as required by
-		// `ptr::copy_nonoverlapping` and are both valid for writes.
-		unsafe {
-			ptr::copy_nonoverlapping(self.src, self.dest, 1);
-		}
-	}
-}
-
 /// Inserts `v[v.len() - 1]` into pre-sorted sequence `v[..v.len() - 1]` so that whole `v[..]`
 /// becomes sorted.
 unsafe fn insert_tail<T, F>(mut v: ArrayViewMut1<'_, T>, is_less: &F)
@@ -58,10 +42,7 @@ where
 			// If `is_less` panics at any point during the process, `hole` will get dropped and
 			// fill the hole in `v` with `tmp`, thus ensuring that `v` still holds every object it
 			// initially held exactly once.
-			let mut hole = InsertionHole {
-				src: &*tmp,
-				dest: v.view_mut().uget(i - 1),
-			};
+			let mut hole = InsertionHole::new(&*tmp, v.view_mut().uget(i - 1));
 			ptr::copy_nonoverlapping(hole.dest, v.view_mut().uget(i), 1);
 
 			// SAFETY: We know i is at least 1.
@@ -126,7 +107,7 @@ where
 			// fill the hole in `v` with `tmp`, thus ensuring that `v` still holds every object it
 			// initially held exactly once.
 			let dest = v.view_mut().uget(1);
-			let mut hole = InsertionHole { src: &*tmp, dest };
+			let mut hole = InsertionHole::new(&*tmp, dest);
 			ptr::copy_nonoverlapping(dest, v.view_mut().uget(0), 1);
 
 			for i in 2..v.len() {

src/par/partition.rs

@@ -3,6 +3,7 @@
 //! [`core::slice::sort`]: https://doc.rust-lang.org/src/core/slice/sort.rs.html
 
 use crate::{
+	insertion_sort::InsertionHole,
 	par::insertion_sort::insertion_sort_shift_left,
 	partition::{break_patterns, reverse},
 };
@@ -361,10 +362,7 @@ 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 = ManuallyDrop::new(unsafe { ptr::read(pivot) });
-	let _pivot_guard = CopyOnDrop {
-		src: &*tmp,
-		dest: pivot,
-	};
+	let _pivot_guard = unsafe { InsertionHole::new(&*tmp, pivot) };
 	let pivot = &*tmp;
 
 	// Now partition the slice.
@@ -427,10 +425,7 @@ where
 
 		// SAFETY: `pivot` is a reference to the first element of `v`, so `ptr::read` is safe.
 		let tmp = ManuallyDrop::new(unsafe { ptr::read(pivot) });
-		let _pivot_guard = CopyOnDrop {
-			src: &*tmp,
-			dest: pivot,
-		};
+		let _pivot_guard = unsafe { InsertionHole::new(&*tmp, pivot) };
 		let pivot = &*tmp;
 
 		// Find the first pair of out-of-order elements.
@@ -830,23 +825,6 @@ where
 	}
 }
 
-/// When dropped, copies from `src` into `dest`.
-pub struct CopyOnDrop<T> {
-	pub src: *const T,
-	pub dest: *mut T,
-}
-
-impl<T> Drop for CopyOnDrop<T> {
-	fn drop(&mut self) {
-		// SAFETY: This is a helper class.
-		//         Please refer to its usage for correctness.
-		//         Namely, one must be sure that `src` and `dst` does not overlap as required by `ptr::copy_nonoverlapping`.
-		unsafe {
-			ptr::copy_nonoverlapping(self.src, self.dest, 1);
-		}
-	}
-}
-
 #[cfg(test)]
 mod test {
 	use super::{par_partition_at_indices, partition_at_index};