fix prepend_from_within not wrapping for non Copy types, add tests

Author: antonilol

library/alloc/src/collections/vec_deque/mod.rs

@@ -3165,14 +3165,31 @@ impl<T: Clone, A: Allocator> SpecExtendFromWithin for VecDeque<T, A> {
         let src = src.start + count;
 
         let new_head = self.wrap_sub(self.head, count);
+        let cap = self.capacity();
 
         unsafe {
             // SAFETY:
             // - Ranges do not overlap: src entirely spans initialized values, dst entirely spans uninitialized values.
             // - Ranges are in bounds: guaranteed by the caller.
             let ranges = self.nonoverlapping_ranges(src, dst, count, new_head);
-            for (src, dst, count) in ranges.into_iter().rev() {
-                for offset in (0..count).rev() {
+            let (src, dst, count) = ranges[1];
+            for offset in (0..count).rev() {
+                dst.add(offset).write((*src.add(offset)).clone());
+                self.head -= 1;
+                self.len += 1;
+            }
+
+            let (src, dst, count) = ranges[0];
+            let mut iter = (0..count).rev();
+            if let Some(offset) = iter.next() {
+                dst.add(offset).write((*src.add(offset)).clone());
+                if self.head == 0 {
+                    self.head = cap;
+                }
+                self.head -= 1;
+                self.len += 1;
+
+                for offset in iter {
                     dst.add(offset).write((*src.add(offset)).clone());
                     self.head -= 1;
                     self.len += 1;

library/alloctests/tests/vec_deque.rs

@@ -1,3 +1,4 @@
+use core::cell::Cell;
 use core::num::NonZero;
 use std::assert_matches::assert_matches;
 use std::collections::TryReserveErrorKind::*;
@@ -1863,22 +1864,185 @@ fn test_extend_from_within() {
     assert_eq!(v, [2, 3, 4, 5, 3, 4, 5, 3, 4, 2, 3, 4]);
 }
 
+struct CloneTracker<'a> {
+    clone: &'a Cell<u32>,
+    drop: &'a Cell<u32>,
+    panic: bool,
+}
+
+impl<'a> Clone for CloneTracker<'a> {
+    fn clone(&self) -> Self {
+        self.clone.set(self.clone.get() + 1);
+        if self.panic {
+            panic!();
+        }
+        Self { clone: self.clone, drop: self.drop, panic: false }
+    }
+}
+
+impl<'a> Drop for CloneTracker<'a> {
+    fn drop(&mut self) {
+        self.drop.set(self.drop.get() + 1);
+    }
+}
+
 #[test]
 fn test_extend_from_within_clone() {
-    // keep track of clone count and correct dropping when clone impl panics
+    let clone_counts = [const { Cell::new(0) }; 6];
+    let drop_count = Cell::new(0);
+    let mut v = VecDeque::with_capacity(10);
+    v.extend(clone_counts.iter().map(|clone_count| CloneTracker {
+        clone: clone_count,
+        drop: &drop_count,
+        panic: false,
+    }));
+    v.truncate_front(4);
+
+    v.extend_from_within(2..);
+    v.extend_from_within(1..5);
+    assert_eq!(
+        v.iter().map(|tr| tr.clone.get()).collect::<Vec<_>>(),
+        [0, 1, 3, 2, 3, 2, 1, 3, 2, 3],
+    );
+    assert_eq!(
+        clone_counts.each_ref().map(|c| {
+            let old = c.get();
+            c.set(0);
+            old
+        }),
+        [0, 0, 0, 1, 3, 2],
+    );
+}
+
+#[test]
+#[cfg_attr(not(panic = "unwind"), ignore = "test requires unwinding support")]
+fn test_extend_from_within_clone_panic() {
+    let clone_counts = [const { Cell::new(0) }; 6];
+    let drop_count = Cell::new(0);
+    let mut v = VecDeque::with_capacity(8);
+    v.extend(clone_counts.iter().map(|clone_count| CloneTracker {
+        clone: clone_count,
+        drop: &drop_count,
+        panic: false,
+    }));
+
+    v.truncate_front(4);
+
+    // panic after wrapping
+    v[2].panic = true;
+    catch_unwind(AssertUnwindSafe(|| {
+        v.extend_from_within(..);
+    }))
+    .unwrap_err();
+    v[2].panic = false;
+    assert_eq!(v.iter().map(|tr| tr.clone.get()).collect::<Vec<_>>(), [1, 1, 1, 0, 1, 1]);
+    assert_eq!(clone_counts.each_ref().map(|c| c.get()), [0, 0, 1, 1, 1, 0]);
+    assert_eq!(drop_count.get(), 2);
+
+    v.truncate_front(2);
+
+    // panic before wrapping
+    v[1].panic = true;
+    catch_unwind(AssertUnwindSafe(|| {
+        v.extend_from_within(..);
+    }))
+    .unwrap_err();
+    v[1].panic = false;
+    assert_eq!(v.iter().map(|tr| tr.clone.get()).collect::<Vec<_>>(), [2, 2, 2]);
+    assert_eq!(clone_counts.each_ref().map(|c| c.get()), [0, 0, 2, 2, 1, 0]);
+    assert_eq!(drop_count.get(), 6);
 }
 
 #[test]
 fn test_prepend_from_within() {
-    // like test_extend_from_within
+    let mut v = VecDeque::with_capacity(8);
+    v.extend(0..6);
+    v.truncate_front(4);
+    v.prepend_from_within(..=0);
+    assert_eq!(v.as_slices(), ([2, 2, 3, 4, 5].as_slice(), [].as_slice()));
+    v.prepend_from_within(2..);
+    assert_eq!(v.as_slices(), ([3, 4].as_slice(), [5, 2, 2, 3, 4, 5].as_slice()));
+    v.prepend_from_within(..);
+    assert_eq!(v, [[3, 4, 5, 2, 2, 3, 4, 5]; 2].as_flattened());
 }
 
 #[test]
 fn test_prepend_from_within_clone() {
-    // like test_extend_from_within_clone
+    let clone_counts = [const { Cell::new(0) }; 6];
+    let drop_count = Cell::new(0);
+    let mut v = VecDeque::with_capacity(10);
+    v.extend(clone_counts.iter().map(|clone_count| CloneTracker {
+        clone: clone_count,
+        drop: &drop_count,
+        panic: false,
+    }));
+    v.truncate_front(4);
+
+    v.prepend_from_within(..2);
+    v.prepend_from_within(1..5);
+    assert_eq!(
+        v.iter().map(|tr| tr.clone.get()).collect::<Vec<_>>(),
+        [3, 2, 3, 1, 2, 3, 2, 3, 1, 0],
+    );
+    assert_eq!(
+        clone_counts.each_ref().map(|c| {
+            let old = c.get();
+            c.set(0);
+            old
+        }),
+        [0, 0, 2, 3, 1, 0],
+    );
+}
+
+#[test]
+#[cfg_attr(not(panic = "unwind"), ignore = "test requires unwinding support")]
+fn test_prepend_from_within_clone_panic() {
+    let clone_counts = [const { Cell::new(0) }; 6];
+    let drop_count = Cell::new(0);
+    let mut v = VecDeque::with_capacity(8);
+    v.extend(clone_counts.iter().map(|clone_count| CloneTracker {
+        clone: clone_count,
+        drop: &drop_count,
+        panic: false,
+    }));
+
+    v.truncate_front(4);
+
+    // panic after wrapping
+    v[1].panic = true;
+    catch_unwind(AssertUnwindSafe(|| {
+        v.prepend_from_within(..);
+    }))
+    .unwrap_err();
+    v[1].panic = false;
+    assert_eq!(v.iter().map(|tr| tr.clone.get()).collect::<Vec<_>>(), [1, 1, 0, 1, 1, 1]);
+    assert_eq!(clone_counts.each_ref().map(|c| c.get()), [0, 0, 0, 1, 1, 1]);
+    assert_eq!(drop_count.get(), 2);
+
+    v.truncate_front(2);
+
+    // panic before wrapping
+    v[0].panic = true;
+    catch_unwind(AssertUnwindSafe(|| {
+        v.prepend_from_within(..);
+    }))
+    .unwrap_err();
+    v[0].panic = false;
+    assert_eq!(v.iter().map(|tr| tr.clone.get()).collect::<Vec<_>>(), [2, 2, 2]);
+    assert_eq!(clone_counts.each_ref().map(|c| c.get()), [0, 0, 0, 1, 2, 2]);
+    assert_eq!(drop_count.get(), 6);
 }
 
 #[test]
 fn test_extend_and_prepend_from_within() {
-    // mix extend_from_within and prepend_from_within
+    let mut v = ('0'..='9').map(String::from).collect::<VecDeque<_>>();
+    v.truncate_front(5);
+    v.extend_from_within(4..);
+    v.prepend_from_within(..2);
+    assert_eq!(v.iter().map(|s| &**s).collect::<String>(), "56567899");
+    v.clear();
+    v.extend(['1', '2', '3'].into_iter().map(String::from));
+    v.prepend_from_within(..);
+    v.extend_from_within(..);
+    assert_eq!(v.iter().map(|s| &**s).collect::<String>(), "123123123123");
 }