add specialization for vec::IntoIter to extend_front

Author: antonilol

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

@@ -1,6 +1,4 @@
-#[cfg(not(test))]
-use core::iter::Rev;
-use core::iter::TrustedLen;
+use core::iter::{Rev, TrustedLen};
 use core::slice;
 
 use super::VecDeque;
@@ -160,20 +158,57 @@ where
     }
 }
 
+#[cfg(not(test))]
+impl<T, A: Allocator> SpecExtendFront<T, vec::IntoIter<T>> for VecDeque<T, A> {
+    #[track_caller]
+    fn spec_extend_front(&mut self, mut iterator: vec::IntoIter<T>) {
+        let slice = iterator.as_mut_slice();
+        slice.reverse();
+        unsafe { prepend(self, slice) };
+        iterator.forget_remaining_elements();
+    }
+}
+
 #[cfg(not(test))]
 impl<T, A: Allocator> SpecExtendFront<T, Rev<vec::IntoIter<T>>> for VecDeque<T, A> {
     #[track_caller]
     fn spec_extend_front(&mut self, iterator: Rev<vec::IntoIter<T>>) {
         let mut iterator = iterator.into_inner();
-
-        let slice = iterator.as_slice();
-        self.reserve(slice.len());
-
-        unsafe {
-            self.head = self.wrap_sub(self.head, slice.len());
-            self.copy_slice(self.head, slice);
-            self.len += slice.len();
-        }
+        unsafe { prepend(self, iterator.as_slice()) };
         iterator.forget_remaining_elements();
     }
 }
+
+// impl<T, A: Allocator> SpecExtendFront<T, Copied<slice::Iter<'_, T>>> for VecDeque<T, A>
+// where
+//     T: Copy,
+// {
+//     #[track_caller]
+//     fn spec_extend_front(&mut self, _iter: Copied<slice::Iter<'_, T>>) {
+//         // unsafe { prepend(self, slice) };
+//         // reverse in place?
+//     }
+// }
+
+// impl<T, A: Allocator> SpecExtendFront<T, Rev<Copied<slice::Iter<'_, T>>>> for VecDeque<T, A>
+// where
+//     T: Copy,
+// {
+//     #[track_caller]
+//     fn spec_extend_front(&mut self, iter: Rev<Copied<slice::Iter<'_, T>>>) {
+//         unsafe { prepend(self, iter.into_inner().it.as_slice()) };
+//     }
+// }
+
+/// # Safety
+///
+/// `slice` will be copied into the deque, make sure to forget the items if `T` is not `Copy`.
+unsafe fn prepend<T, A: Allocator>(deque: &mut VecDeque<T, A>, slice: &[T]) {
+    deque.reserve(slice.len());
+
+    unsafe {
+        deque.head = deque.wrap_sub(deque.head, slice.len());
+        deque.copy_slice(deque.head, slice);
+        deque.len += slice.len();
+    }
+}