diff options
| -rw-r--r-- | library/alloc/src/collections/vec_deque/drain.rs | 30 | ||||
| -rw-r--r-- | library/alloc/src/collections/vec_deque/into_iter.rs | 21 | ||||
| -rw-r--r-- | library/alloc/src/collections/vec_deque/macros.rs | 4 | ||||
| -rw-r--r-- | library/alloc/src/collections/vec_deque/mod.rs | 152 | ||||
| -rw-r--r-- | library/alloc/src/collections/vec_deque/pair_slices.rs | 4 | ||||
| -rw-r--r-- | src/test/debuginfo/pretty-std.rs | 4 |
6 files changed, 139 insertions, 76 deletions
diff --git a/library/alloc/src/collections/vec_deque/drain.rs b/library/alloc/src/collections/vec_deque/drain.rs index 4ffb435d1e3..dfa0227dea3 100644 --- a/library/alloc/src/collections/vec_deque/drain.rs +++ b/library/alloc/src/collections/vec_deque/drain.rs @@ -2,6 +2,8 @@ use core::iter::FusedIterator; use core::ptr::{self, NonNull}; use core::{fmt, mem}; +use crate::alloc::{Allocator, Global}; + use super::{count, Iter, VecDeque}; /// A draining iterator over the elements of a `VecDeque`. @@ -11,15 +13,19 @@ use super::{count, Iter, VecDeque}; /// /// [`drain`]: VecDeque::drain #[stable(feature = "drain", since = "1.6.0")] -pub struct Drain<'a, T: 'a> { +pub struct Drain< + 'a, + T: 'a, + #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global, +> { pub(crate) after_tail: usize, pub(crate) after_head: usize, pub(crate) iter: Iter<'a, T>, - pub(crate) deque: NonNull<VecDeque<T>>, + pub(crate) deque: NonNull<VecDeque<T, A>>, } #[stable(feature = "collection_debug", since = "1.17.0")] -impl<T: fmt::Debug> fmt::Debug for Drain<'_, T> { +impl<T: fmt::Debug, A: Allocator> fmt::Debug for Drain<'_, T, A> { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.debug_tuple("Drain") .field(&self.after_tail) @@ -30,16 +36,16 @@ impl<T: fmt::Debug> fmt::Debug for Drain<'_, T> { } #[stable(feature = "drain", since = "1.6.0")] -unsafe impl<T: Sync> Sync for Drain<'_, T> {} +unsafe impl<T: Sync, A: Allocator + Sync> Sync for Drain<'_, T, A> {} #[stable(feature = "drain", since = "1.6.0")] -unsafe impl<T: Send> Send for Drain<'_, T> {} +unsafe impl<T: Send, A: Allocator + Send> Send for Drain<'_, T, A> {} #[stable(feature = "drain", since = "1.6.0")] -impl<T> Drop for Drain<'_, T> { +impl<T, A: Allocator> Drop for Drain<'_, T, A> { fn drop(&mut self) { - struct DropGuard<'r, 'a, T>(&'r mut Drain<'a, T>); + struct DropGuard<'r, 'a, T, A: Allocator>(&'r mut Drain<'a, T, A>); - impl<'r, 'a, T> Drop for DropGuard<'r, 'a, T> { + impl<'r, 'a, T, A: Allocator> Drop for DropGuard<'r, 'a, T, A> { fn drop(&mut self) { self.0.for_each(drop); @@ -96,7 +102,7 @@ impl<T> Drop for Drain<'_, T> { } #[stable(feature = "drain", since = "1.6.0")] -impl<T> Iterator for Drain<'_, T> { +impl<T, A: Allocator> Iterator for Drain<'_, T, A> { type Item = T; #[inline] @@ -111,7 +117,7 @@ impl<T> Iterator for Drain<'_, T> { } #[stable(feature = "drain", since = "1.6.0")] -impl<T> DoubleEndedIterator for Drain<'_, T> { +impl<T, A: Allocator> DoubleEndedIterator for Drain<'_, T, A> { #[inline] fn next_back(&mut self) -> Option<T> { self.iter.next_back().map(|elt| unsafe { ptr::read(elt) }) @@ -119,7 +125,7 @@ impl<T> DoubleEndedIterator for Drain<'_, T> { } #[stable(feature = "drain", since = "1.6.0")] -impl<T> ExactSizeIterator for Drain<'_, T> {} +impl<T, A: Allocator> ExactSizeIterator for Drain<'_, T, A> {} #[stable(feature = "fused", since = "1.26.0")] -impl<T> FusedIterator for Drain<'_, T> {} +impl<T, A: Allocator> FusedIterator for Drain<'_, T, A> {} diff --git a/library/alloc/src/collections/vec_deque/into_iter.rs b/library/alloc/src/collections/vec_deque/into_iter.rs index 612f7e6eb4d..5f13c3bf303 100644 --- a/library/alloc/src/collections/vec_deque/into_iter.rs +++ b/library/alloc/src/collections/vec_deque/into_iter.rs @@ -1,6 +1,8 @@ use core::fmt; use core::iter::{FusedIterator, TrustedLen}; +use crate::alloc::{Allocator, Global}; + use super::VecDeque; /// An owning iterator over the elements of a `VecDeque`. @@ -11,19 +13,22 @@ use super::VecDeque; /// [`into_iter`]: VecDeque::into_iter #[derive(Clone)] #[stable(feature = "rust1", since = "1.0.0")] -pub struct IntoIter<T> { - pub(crate) inner: VecDeque<T>, +pub struct IntoIter< + T, + #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global, +> { + pub(crate) inner: VecDeque<T, A>, } #[stable(feature = "collection_debug", since = "1.17.0")] -impl<T: fmt::Debug> fmt::Debug for IntoIter<T> { +impl<T: fmt::Debug, A: Allocator> fmt::Debug for IntoIter<T, A> { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.debug_tuple("IntoIter").field(&self.inner).finish() } } #[stable(feature = "rust1", since = "1.0.0")] -impl<T> Iterator for IntoIter<T> { +impl<T, A: Allocator> Iterator for IntoIter<T, A> { type Item = T; #[inline] @@ -39,7 +44,7 @@ impl<T> Iterator for IntoIter<T> { } #[stable(feature = "rust1", since = "1.0.0")] -impl<T> DoubleEndedIterator for IntoIter<T> { +impl<T, A: Allocator> DoubleEndedIterator for IntoIter<T, A> { #[inline] fn next_back(&mut self) -> Option<T> { self.inner.pop_back() @@ -47,14 +52,14 @@ impl<T> DoubleEndedIterator for IntoIter<T> { } #[stable(feature = "rust1", since = "1.0.0")] -impl<T> ExactSizeIterator for IntoIter<T> { +impl<T, A: Allocator> ExactSizeIterator for IntoIter<T, A> { fn is_empty(&self) -> bool { self.inner.is_empty() } } #[stable(feature = "fused", since = "1.26.0")] -impl<T> FusedIterator for IntoIter<T> {} +impl<T, A: Allocator> FusedIterator for IntoIter<T, A> {} #[unstable(feature = "trusted_len", issue = "37572")] -unsafe impl<T> TrustedLen for IntoIter<T> {} +unsafe impl<T, A: Allocator> TrustedLen for IntoIter<T, A> {} diff --git a/library/alloc/src/collections/vec_deque/macros.rs b/library/alloc/src/collections/vec_deque/macros.rs index 0d59d312cf4..5c7913073fe 100644 --- a/library/alloc/src/collections/vec_deque/macros.rs +++ b/library/alloc/src/collections/vec_deque/macros.rs @@ -1,9 +1,9 @@ macro_rules! __impl_slice_eq1 { ([$($vars:tt)*] $lhs:ty, $rhs:ty, $($constraints:tt)*) => { #[stable(feature = "vec_deque_partial_eq_slice", since = "1.17.0")] - impl<A, B, $($vars)*> PartialEq<$rhs> for $lhs + impl<T, U, A: Allocator, $($vars)*> PartialEq<$rhs> for $lhs where - A: PartialEq<B>, + T: PartialEq<U>, $($constraints)* { fn eq(&self, other: &$rhs) -> bool { diff --git a/library/alloc/src/collections/vec_deque/mod.rs b/library/alloc/src/collections/vec_deque/mod.rs index 26c9415a4de..386c7c2612d 100644 --- a/library/alloc/src/collections/vec_deque/mod.rs +++ b/library/alloc/src/collections/vec_deque/mod.rs @@ -17,6 +17,7 @@ use core::ops::{Index, IndexMut, Range, RangeBounds}; use core::ptr::{self, NonNull}; use core::slice; +use crate::alloc::{Allocator, Global}; use crate::collections::TryReserveError; use crate::raw_vec::RawVec; use crate::vec::Vec; @@ -88,7 +89,10 @@ const MAXIMUM_ZST_CAPACITY: usize = 1 << (usize::BITS - 1); // Largest possible /// [`make_contiguous`]: VecDeque::make_contiguous #[cfg_attr(not(test), rustc_diagnostic_item = "vecdeque_type")] #[stable(feature = "rust1", since = "1.0.0")] -pub struct VecDeque<T> { +pub struct VecDeque< + T, + #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global, +> { // tail and head are pointers into the buffer. Tail always points // to the first element that could be read, Head always points // to where data should be written. @@ -96,13 +100,15 @@ pub struct VecDeque<T> { // is defined as the distance between the two. tail: usize, head: usize, - buf: RawVec<T>, + buf: RawVec<T, A>, } #[stable(feature = "rust1", since = "1.0.0")] -impl<T: Clone> Clone for VecDeque<T> { - fn clone(&self) -> VecDeque<T> { - self.iter().cloned().collect() +impl<T: Clone, A: Allocator + Clone> Clone for VecDeque<T, A> { + fn clone(&self) -> Self { + let mut deq = Self::with_capacity_in(self.len(), self.allocator().clone()); + deq.extend(self.iter().cloned()); + deq } fn clone_from(&mut self, other: &Self) { @@ -122,7 +128,7 @@ impl<T: Clone> Clone for VecDeque<T> { } #[stable(feature = "rust1", since = "1.0.0")] -unsafe impl<#[may_dangle] T> Drop for VecDeque<T> { +unsafe impl<#[may_dangle] T, A: Allocator> Drop for VecDeque<T, A> { fn drop(&mut self) { /// Runs the destructor for all items in the slice when it gets dropped (normally or /// during unwinding). @@ -155,7 +161,7 @@ impl<T> Default for VecDeque<T> { } } -impl<T> VecDeque<T> { +impl<T, A: Allocator> VecDeque<T, A> { /// Marginally more convenient #[inline] fn ptr(&self) -> *mut T { @@ -465,9 +471,10 @@ impl<T> VecDeque<T> { /// /// let vector: VecDeque<u32> = VecDeque::new(); /// ``` + #[inline] #[stable(feature = "rust1", since = "1.0.0")] pub fn new() -> VecDeque<T> { - VecDeque::with_capacity(INITIAL_CAPACITY) + VecDeque::new_in(Global) } /// Creates an empty `VecDeque` with space for at least `capacity` elements. @@ -479,13 +486,45 @@ impl<T> VecDeque<T> { /// /// let vector: VecDeque<u32> = VecDeque::with_capacity(10); /// ``` + #[inline] #[stable(feature = "rust1", since = "1.0.0")] pub fn with_capacity(capacity: usize) -> VecDeque<T> { + Self::with_capacity_in(capacity, Global) + } +} + +impl<T, A: Allocator> VecDeque<T, A> { + /// Creates an empty `VecDeque`. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let vector: VecDeque<u32> = VecDeque::new(); + /// ``` + #[inline] + #[unstable(feature = "allocator_api", issue = "32838")] + pub fn new_in(alloc: A) -> VecDeque<T, A> { + VecDeque::with_capacity_in(INITIAL_CAPACITY, alloc) + } + + /// Creates an empty `VecDeque` with space for at least `capacity` elements. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let vector: VecDeque<u32> = VecDeque::with_capacity(10); + /// ``` + #[unstable(feature = "allocator_api", issue = "32838")] + pub fn with_capacity_in(capacity: usize, alloc: A) -> VecDeque<T, A> { // +1 since the ringbuffer always leaves one space empty let cap = cmp::max(capacity + 1, MINIMUM_CAPACITY + 1).next_power_of_two(); assert!(cap > capacity, "capacity overflow"); - VecDeque { tail: 0, head: 0, buf: RawVec::with_capacity(cap) } + VecDeque { tail: 0, head: 0, buf: RawVec::with_capacity_in(cap, alloc) } } /// Provides a reference to the element at the given index. @@ -912,6 +951,13 @@ impl<T> VecDeque<T> { } } + /// Returns a reference to the underlying allocator. + #[unstable(feature = "allocator_api", issue = "32838")] + #[inline] + pub fn allocator(&self) -> &A { + self.buf.allocator() + } + /// Returns a front-to-back iterator. /// /// # Examples @@ -1184,7 +1230,7 @@ impl<T> VecDeque<T> { /// ``` #[inline] #[stable(feature = "drain", since = "1.6.0")] - pub fn drain<R>(&mut self, range: R) -> Drain<'_, T> + pub fn drain<R>(&mut self, range: R) -> Drain<'_, T, A> where R: RangeBounds<usize>, { @@ -1973,12 +2019,15 @@ impl<T> VecDeque<T> { #[inline] #[must_use = "use `.truncate()` if you don't need the other half"] #[stable(feature = "split_off", since = "1.4.0")] - pub fn split_off(&mut self, at: usize) -> Self { + pub fn split_off(&mut self, at: usize) -> Self + where + A: Clone, + { let len = self.len(); assert!(at <= len, "`at` out of bounds"); let other_len = len - at; - let mut other = VecDeque::with_capacity(other_len); + let mut other = VecDeque::with_capacity_in(other_len, self.allocator().clone()); unsafe { let (first_half, second_half) = self.as_slices(); @@ -2601,7 +2650,7 @@ impl<T> VecDeque<T> { } } -impl<T: Clone> VecDeque<T> { +impl<T: Clone, A: Allocator> VecDeque<T, A> { /// Modifies the `VecDeque` in-place so that `len()` is equal to new_len, /// either by removing excess elements from the back or by appending clones of `value` /// to the back. @@ -2645,8 +2694,8 @@ fn count(tail: usize, head: usize, size: usize) -> usize { } #[stable(feature = "rust1", since = "1.0.0")] -impl<A: PartialEq> PartialEq for VecDeque<A> { - fn eq(&self, other: &VecDeque<A>) -> bool { +impl<T: PartialEq, A: Allocator> PartialEq for VecDeque<T, A> { + fn eq(&self, other: &Self) -> bool { if self.len() != other.len() { return false; } @@ -2684,32 +2733,32 @@ impl<A: PartialEq> PartialEq for VecDeque<A> { } #[stable(feature = "rust1", since = "1.0.0")] -impl<A: Eq> Eq for VecDeque<A> {} +impl<T: Eq, A: Allocator> Eq for VecDeque<T, A> {} -__impl_slice_eq1! { [] VecDeque<A>, Vec<B>, } -__impl_slice_eq1! { [] VecDeque<A>, &[B], } -__impl_slice_eq1! { [] VecDeque<A>, &mut [B], } -__impl_slice_eq1! { [const N: usize] VecDeque<A>, [B; N], } -__impl_slice_eq1! { [const N: usize] VecDeque<A>, &[B; N], } -__impl_slice_eq1! { [const N: usize] VecDeque<A>, &mut [B; N], } +__impl_slice_eq1! { [] VecDeque<T, A>, Vec<U, A>, } +__impl_slice_eq1! { [] VecDeque<T, A>, &[U], } +__impl_slice_eq1! { [] VecDeque<T, A>, &mut [U], } +__impl_slice_eq1! { [const N: usize] VecDeque<T, A>, [U; N], } +__impl_slice_eq1! { [const N: usize] VecDeque<T, A>, &[U; N], } +__impl_slice_eq1! { [const N: usize] VecDeque<T, A>, &mut [U; N], } #[stable(feature = "rust1", since = "1.0.0")] -impl<A: PartialOrd> PartialOrd for VecDeque<A> { - fn partial_cmp(&self, other: &VecDeque<A>) -> Option<Ordering> { +impl<T: PartialOrd, A: Allocator> PartialOrd for VecDeque<T, A> { + fn partial_cmp(&self, other: &Self) -> Option<Ordering> { self.iter().partial_cmp(other.iter()) } } #[stable(feature = "rust1", since = "1.0.0")] -impl<A: Ord> Ord for VecDeque<A> { +impl<T: Ord, A: Allocator> Ord for VecDeque<T, A> { #[inline] - fn cmp(&self, other: &VecDeque<A>) -> Ordering { + fn cmp(&self, other: &Self) -> Ordering { self.iter().cmp(other.iter()) } } #[stable(feature = "rust1", since = "1.0.0")] -impl<A: Hash> Hash for VecDeque<A> { +impl<T: Hash, A: Allocator> Hash for VecDeque<T, A> { fn hash<H: Hasher>(&self, state: &mut H) { self.len().hash(state); // It's not possible to use Hash::hash_slice on slices @@ -2723,26 +2772,26 @@ impl<A: Hash> Hash for VecDeque<A> { } #[stable(feature = "rust1", since = "1.0.0")] -impl<A> Index<usize> for VecDeque<A> { - type Output = A; +impl<T, A: Allocator> Index<usize> for VecDeque<T, A> { + type Output = T; #[inline] - fn index(&self, index: usize) -> &A { + fn index(&self, index: usize) -> &T { self.get(index).expect("Out of bounds access") } } #[stable(feature = "rust1", since = "1.0.0")] -impl<A> IndexMut<usize> for VecDeque<A> { +impl<T, A: Allocator> IndexMut<usize> for VecDeque<T, A> { #[inline] - fn index_mut(&mut self, index: usize) -> &mut A { + fn index_mut(&mut self, index: usize) -> &mut T { self.get_mut(index).expect("Out of bounds access") } } #[stable(feature = "rust1", since = "1.0.0")] -impl<A> FromIterator<A> for VecDeque<A> { - fn from_iter<T: IntoIterator<Item = A>>(iter: T) -> VecDeque<A> { +impl<T> FromIterator<T> for VecDeque<T> { + fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> VecDeque<T> { let iterator = iter.into_iter(); let (lower, _) = iterator.size_hint(); let mut deq = VecDeque::with_capacity(lower); @@ -2752,19 +2801,19 @@ impl<A> FromIterator<A> for VecDeque<A> { } #[stable(feature = "rust1", since = "1.0.0")] -impl<T> IntoIterator for VecDeque<T> { +impl<T, A: Allocator> IntoIterator for VecDeque<T, A> { type Item = T; - type IntoIter = IntoIter<T>; + type IntoIter = IntoIter<T, A>; /// Consumes the `VecDeque` into a front-to-back iterator yielding elements by /// value. - fn into_iter(self) -> IntoIter<T> { + fn into_iter(self) -> IntoIter<T, A> { IntoIter { inner: self } } } #[stable(feature = "rust1", since = "1.0.0")] -impl<'a, T> IntoIterator for &'a VecDeque<T> { +impl<'a, T, A: Allocator> IntoIterator for &'a VecDeque<T, A> { type Item = &'a T; type IntoIter = Iter<'a, T>; @@ -2774,7 +2823,7 @@ impl<'a, T> IntoIterator for &'a VecDeque<T> { } #[stable(feature = "rust1", since = "1.0.0")] -impl<'a, T> IntoIterator for &'a mut VecDeque<T> { +impl<'a, T, A: Allocator> IntoIterator for &'a mut VecDeque<T, A> { type Item = &'a mut T; type IntoIter = IterMut<'a, T>; @@ -2784,8 +2833,8 @@ impl<'a, T> IntoIterator for &'a mut VecDeque<T> { } #[stable(feature = "rust1", since = "1.0.0")] -impl<A> Extend<A> for VecDeque<A> { - fn extend<T: IntoIterator<Item = A>>(&mut self, iter: T) { +impl<T, A: Allocator> Extend<T> for VecDeque<T, A> { + fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) { // This function should be the moral equivalent of: // // for item in iter.into_iter() { @@ -2807,7 +2856,7 @@ impl<A> Extend<A> for VecDeque<A> { } #[inline] - fn extend_one(&mut self, elem: A) { + fn extend_one(&mut self, elem: T) { self.push_back(elem); } @@ -2818,7 +2867,7 @@ impl<A> Extend<A> for VecDeque<A> { } #[stable(feature = "extend_ref", since = "1.2.0")] -impl<'a, T: 'a + Copy> Extend<&'a T> for VecDeque<T> { +impl<'a, T: 'a + Copy, A: Allocator> Extend<&'a T> for VecDeque<T, A> { fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I) { self.extend(iter.into_iter().cloned()); } @@ -2835,14 +2884,14 @@ impl<'a, T: 'a + Copy> Extend<&'a T> for VecDeque<T> { } #[stable(feature = "rust1", since = "1.0.0")] -impl<T: fmt::Debug> fmt::Debug for VecDeque<T> { +impl<T: fmt::Debug, A: Allocator> fmt::Debug for VecDeque<T, A> { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.debug_list().entries(self).finish() } } #[stable(feature = "vecdeque_vec_conversions", since = "1.10.0")] -impl<T> From<Vec<T>> for VecDeque<T> { +impl<T, A: Allocator> From<Vec<T, A>> for VecDeque<T, A> { /// Turn a [`Vec<T>`] into a [`VecDeque<T>`]. /// /// [`Vec<T>`]: crate::vec::Vec @@ -2851,7 +2900,7 @@ impl<T> From<Vec<T>> for VecDeque<T> { /// This avoids reallocating where possible, but the conditions for that are /// strict, and subject to change, and so shouldn't be relied upon unless the /// `Vec<T>` came from `From<VecDeque<T>>` and hasn't been reallocated. - fn from(mut other: Vec<T>) -> Self { + fn from(mut other: Vec<T, A>) -> Self { let len = other.len(); if mem::size_of::<T>() == 0 { // There's no actual allocation for ZSTs to worry about capacity, @@ -2869,15 +2918,15 @@ impl<T> From<Vec<T>> for VecDeque<T> { } unsafe { - let (other_buf, len, capacity) = other.into_raw_parts(); - let buf = RawVec::from_raw_parts(other_buf, capacity); + let (other_buf, len, capacity, alloc) = other.into_raw_parts_with_alloc(); + let buf = RawVec::from_raw_parts_in(other_buf, capacity, alloc); VecDeque { tail: 0, head: len, buf } } } } #[stable(feature = "vecdeque_vec_conversions", since = "1.10.0")] -impl<T> From<VecDeque<T>> for Vec<T> { +impl<T, A: Allocator> From<VecDeque<T, A>> for Vec<T, A> { /// Turn a [`VecDeque<T>`] into a [`Vec<T>`]. /// /// [`Vec<T>`]: crate::vec::Vec @@ -2907,7 +2956,7 @@ impl<T> From<VecDeque<T>> for Vec<T> { /// assert_eq!(vec, [8, 9, 1, 2, 3, 4]); /// assert_eq!(vec.as_ptr(), ptr); /// ``` - fn from(mut other: VecDeque<T>) -> Self { + fn from(mut other: VecDeque<T, A>) -> Self { other.make_contiguous(); unsafe { @@ -2915,11 +2964,12 @@ impl<T> From<VecDeque<T>> for Vec<T> { let buf = other.buf.ptr(); let len = other.len(); let cap = other.cap(); + let alloc = ptr::read(other.allocator()); if other.tail != 0 { ptr::copy(buf.add(other.tail), buf, len); } - Vec::from_raw_parts(buf, len, cap) + Vec::from_raw_parts_in(buf, len, cap, alloc) } } } diff --git a/library/alloc/src/collections/vec_deque/pair_slices.rs b/library/alloc/src/collections/vec_deque/pair_slices.rs index 7b87090fb07..8e3ac9cfd1d 100644 --- a/library/alloc/src/collections/vec_deque/pair_slices.rs +++ b/library/alloc/src/collections/vec_deque/pair_slices.rs @@ -1,6 +1,8 @@ use core::cmp::{self}; use core::mem::replace; +use crate::alloc::Allocator; + use super::VecDeque; /// PairSlices pairs up equal length slice parts of two deques @@ -25,7 +27,7 @@ pub struct PairSlices<'a, 'b, T> { } impl<'a, 'b, T> PairSlices<'a, 'b, T> { - pub fn from(to: &'a mut VecDeque<T>, from: &'b VecDeque<T>) -> Self { + pub fn from<A: Allocator>(to: &'a mut VecDeque<T, A>, from: &'b VecDeque<T, A>) -> Self { let (a0, a1) = to.as_mut_slices(); let (b0, b1) = from.as_slices(); PairSlices { a0, a1, b0, b1 } diff --git a/src/test/debuginfo/pretty-std.rs b/src/test/debuginfo/pretty-std.rs index a190a29eec2..baeada69d1c 100644 --- a/src/test/debuginfo/pretty-std.rs +++ b/src/test/debuginfo/pretty-std.rs @@ -137,8 +137,8 @@ // cdb-check: [0x1] : 42 [Type: int] // cdb-command: dx vecdeque -// cdb-check:vecdeque : { len=0x2 } [Type: alloc::collections::vec_deque::VecDeque<i32>] -// cdb-check: [<Raw View>] [Type: alloc::collections::vec_deque::VecDeque<i32>] +// cdb-check:vecdeque : { len=0x2 } [Type: alloc::collections::vec_deque::VecDeque<i32,alloc::alloc::Global>] +// cdb-check: [<Raw View>] [Type: alloc::collections::vec_deque::VecDeque<i32,alloc::alloc::Global>] // cdb-check: [len] : 0x2 // cdb-check: [capacity] : 0x8 [Type: unsigned [...]] // cdb-check: [0x0] : 90 [Type: int] |