1 files changed, 23 insertions, 21 deletions

diff --git a/vendor/rayon/src/vec.rs b/vendor/rayon/src/vec.rs
index e07963922..c804b0f33 100644
--- a/vendor/rayon/src/vec.rs
+++ b/vendor/rayon/src/vec.rs
@@ -132,7 +132,7 @@ impl<'data, T: Send> IndexedParallelIterator for Drain<'data, T> {
         self.range.len()
     }
 
-    fn with_producer<CB>(mut self, callback: CB) -> CB::Output
+    fn with_producer<CB>(self, callback: CB) -> CB::Output
     where
         CB: ProducerCallback<Self::Item>,
     {
@@ -141,7 +141,7 @@ impl<'data, T: Send> IndexedParallelIterator for Drain<'data, T> {
             self.vec.set_len(self.range.start);
 
             // Create the producer as the exclusive "owner" of the slice.
-            let producer = DrainProducer::from_vec(&mut self.vec, self.range.len());
+            let producer = DrainProducer::from_vec(self.vec, self.range.len());
 
             // The producer will move or drop each item from the drained range.
             callback.callback(producer)
@@ -151,22 +151,24 @@ impl<'data, T: Send> IndexedParallelIterator for Drain<'data, T> {
 
 impl<'data, T: Send> Drop for Drain<'data, T> {
     fn drop(&mut self) {
-        if self.range.len() > 0 {
-            let Range { start, end } = self.range;
-            if self.vec.len() != start {
-                // We must not have produced, so just call a normal drain to remove the items.
-                assert_eq!(self.vec.len(), self.orig_len);
-                self.vec.drain(start..end);
-            } else if end < self.orig_len {
-                // The producer was responsible for consuming the drained items.
-                // Move the tail items to their new place, then set the length to include them.
-                unsafe {
-                    let ptr = self.vec.as_mut_ptr().add(start);
-                    let tail_ptr = self.vec.as_ptr().add(end);
-                    let tail_len = self.orig_len - end;
-                    ptr::copy(tail_ptr, ptr, tail_len);
-                    self.vec.set_len(start + tail_len);
-                }
+        let Range { start, end } = self.range;
+        if self.vec.len() == self.orig_len {
+            // We must not have produced, so just call a normal drain to remove the items.
+            self.vec.drain(start..end);
+        } else if start == end {
+            // Empty range, so just restore the length to its original state
+            unsafe {
+                self.vec.set_len(self.orig_len);
+            }
+        } else if end < self.orig_len {
+            // The producer was responsible for consuming the drained items.
+            // Move the tail items to their new place, then set the length to include them.
+            unsafe {
+                let ptr = self.vec.as_mut_ptr().add(start);
+                let tail_ptr = self.vec.as_ptr().add(end);
+                let tail_len = self.orig_len - end;
+                ptr::copy(tail_ptr, ptr, tail_len);
+                self.vec.set_len(start + tail_len);
             }
         }
     }
@@ -181,7 +183,7 @@ pub(crate) struct DrainProducer<'data, T: Send> {
 impl<T: Send> DrainProducer<'_, T> {
     /// Creates a draining producer, which *moves* items from the slice.
     ///
-    /// Unsafe bacause `!Copy` data must not be read after the borrow is released.
+    /// Unsafe because `!Copy` data must not be read after the borrow is released.
     pub(crate) unsafe fn new(slice: &mut [T]) -> DrainProducer<'_, T> {
         DrainProducer { slice }
     }
@@ -207,7 +209,7 @@ impl<'data, T: 'data + Send> Producer for DrainProducer<'data, T> {
 
     fn into_iter(mut self) -> Self::IntoIter {
         // replace the slice so we don't drop it twice
-        let slice = mem::replace(&mut self.slice, &mut []);
+        let slice = mem::take(&mut self.slice);
         SliceDrain {
             iter: slice.iter_mut(),
         }
@@ -215,7 +217,7 @@ impl<'data, T: 'data + Send> Producer for DrainProducer<'data, T> {
 
     fn split_at(mut self, index: usize) -> (Self, Self) {
         // replace the slice so we don't drop it twice
-        let slice = mem::replace(&mut self.slice, &mut []);
+        let slice = mem::take(&mut self.slice);
         let (left, right) = slice.split_at_mut(index);
         unsafe { (DrainProducer::new(left), DrainProducer::new(right)) }
     }