From 170d933d2f8a7d4787355a86136093af86b03077 Mon Sep 17 00:00:00 2001 From: Simon Sapin Date: Sat, 6 Jul 2019 21:52:15 +0200 Subject: Move constructors of boxed/rc’ed slices to matching `impl` blocks MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/liballoc/boxed.rs | 22 ++++++------ src/liballoc/rc.rs | 92 ++++++++++++++++++++++++++------------------------- src/liballoc/sync.rs | 92 ++++++++++++++++++++++++++------------------------- 3 files changed, 106 insertions(+), 100 deletions(-) (limited to 'src/liballoc') diff --git a/src/liballoc/boxed.rs b/src/liballoc/boxed.rs index a759260bd8f..6e296907ce8 100644 --- a/src/liballoc/boxed.rs +++ b/src/liballoc/boxed.rs @@ -149,6 +149,16 @@ impl Box { Box(unique.cast()) } + /// Constructs a new `Pin>`. If `T` does not implement `Unpin`, then + /// `x` will be pinned in memory and unable to be moved. + #[stable(feature = "pin", since = "1.33.0")] + #[inline(always)] + pub fn pin(x: T) -> Pin> { + (box x).into() + } +} + +impl Box<[T]> { /// Construct a new boxed slice with uninitialized contents. /// /// # Examples @@ -156,7 +166,7 @@ impl Box { /// ``` /// #![feature(new_uninit)] /// - /// let mut values = Box::::new_uninit_slice(3); + /// let mut values = Box::<[u32]>::new_uninit_slice(3); /// /// let values = unsafe { /// // Deferred initialization: @@ -177,14 +187,6 @@ impl Box { let slice = unsafe { slice::from_raw_parts_mut(unique.cast().as_ptr(), len) }; Box(Unique::from(slice)) } - - /// Constructs a new `Pin>`. If `T` does not implement `Unpin`, then - /// `x` will be pinned in memory and unable to be moved. - #[stable(feature = "pin", since = "1.33.0")] - #[inline(always)] - pub fn pin(x: T) -> Pin> { - (box x).into() - } } impl Box> { @@ -237,7 +239,7 @@ impl Box<[mem::MaybeUninit]> { /// ``` /// #![feature(new_uninit)] /// - /// let mut values = Box::::new_uninit_slice(3); + /// let mut values = Box::<[u32]>::new_uninit_slice(3); /// /// let values = unsafe { /// // Deferred initialization: diff --git a/src/liballoc/rc.rs b/src/liballoc/rc.rs index 404c86a24da..aa1268ec051 100644 --- a/src/liballoc/rc.rs +++ b/src/liballoc/rc.rs @@ -364,50 +364,6 @@ impl Rc { } } - /// Construct a new reference-counted slice with uninitialized contents. - /// - /// # Examples - /// - /// ``` - /// #![feature(new_uninit)] - /// #![feature(get_mut_unchecked)] - /// - /// use std::rc::Rc; - /// - /// let mut values = Rc::::new_uninit_slice(3); - /// - /// let values = unsafe { - /// // Deferred initialization: - /// Rc::get_mut_unchecked(&mut values)[0].as_mut_ptr().write(1); - /// Rc::get_mut_unchecked(&mut values)[1].as_mut_ptr().write(2); - /// Rc::get_mut_unchecked(&mut values)[2].as_mut_ptr().write(3); - /// - /// values.assume_init() - /// }; - /// - /// assert_eq!(*values, [1, 2, 3]) - /// ``` - #[unstable(feature = "new_uninit", issue = "0")] - pub fn new_uninit_slice(len: usize) -> Rc<[mem::MaybeUninit]> { - let data_layout = Layout::array::>(len).unwrap(); - let (layout, offset) = Layout::new::>().extend(data_layout).unwrap(); - unsafe { - let allocated_ptr = Global.alloc(layout) - .unwrap_or_else(|_| handle_alloc_error(layout)) - .as_ptr(); - let data_ptr = allocated_ptr.add(offset) as *mut mem::MaybeUninit; - let slice: *mut [mem::MaybeUninit] = from_raw_parts_mut(data_ptr, len); - let wide_ptr = slice as *mut RcBox<[mem::MaybeUninit]>; - let wide_ptr = set_data_ptr(wide_ptr, allocated_ptr); - ptr::write(&mut (*wide_ptr).strong, Cell::new(1)); - ptr::write(&mut (*wide_ptr).weak, Cell::new(1)); - Rc { - ptr: NonNull::new_unchecked(wide_ptr), - phantom: PhantomData, - } - } - } - /// Constructs a new `Pin>`. If `T` does not implement `Unpin`, then /// `value` will be pinned in memory and unable to be moved. #[stable(feature = "pin", since = "1.33.0")] @@ -458,6 +414,52 @@ impl Rc { } } +impl Rc<[T]> { + /// Construct a new reference-counted slice with uninitialized contents. + /// + /// # Examples + /// + /// ``` + /// #![feature(new_uninit)] + /// #![feature(get_mut_unchecked)] + /// + /// use std::rc::Rc; + /// + /// let mut values = Rc::<[u32]>::new_uninit_slice(3); + /// + /// let values = unsafe { + /// // Deferred initialization: + /// Rc::get_mut_unchecked(&mut values)[0].as_mut_ptr().write(1); + /// Rc::get_mut_unchecked(&mut values)[1].as_mut_ptr().write(2); + /// Rc::get_mut_unchecked(&mut values)[2].as_mut_ptr().write(3); + /// + /// values.assume_init() + /// }; + /// + /// assert_eq!(*values, [1, 2, 3]) + /// ``` + #[unstable(feature = "new_uninit", issue = "0")] + pub fn new_uninit_slice(len: usize) -> Rc<[mem::MaybeUninit]> { + let data_layout = Layout::array::>(len).unwrap(); + let (layout, offset) = Layout::new::>().extend(data_layout).unwrap(); + unsafe { + let allocated_ptr = Global.alloc(layout) + .unwrap_or_else(|_| handle_alloc_error(layout)) + .as_ptr(); + let data_ptr = allocated_ptr.add(offset) as *mut mem::MaybeUninit; + let slice: *mut [mem::MaybeUninit] = from_raw_parts_mut(data_ptr, len); + let wide_ptr = slice as *mut RcBox<[mem::MaybeUninit]>; + let wide_ptr = set_data_ptr(wide_ptr, allocated_ptr); + ptr::write(&mut (*wide_ptr).strong, Cell::new(1)); + ptr::write(&mut (*wide_ptr).weak, Cell::new(1)); + Rc { + ptr: NonNull::new_unchecked(wide_ptr), + phantom: PhantomData, + } + } + } +} + impl Rc> { /// Convert to `Rc`. /// @@ -519,7 +521,7 @@ impl Rc<[mem::MaybeUninit]> { /// /// use std::rc::Rc; /// - /// let mut values = Rc::::new_uninit_slice(3); + /// let mut values = Rc::<[u32]>::new_uninit_slice(3); /// /// let values = unsafe { /// // Deferred initialization: diff --git a/src/liballoc/sync.rs b/src/liballoc/sync.rs index 3f47b9e6c7d..93441437e45 100644 --- a/src/liballoc/sync.rs +++ b/src/liballoc/sync.rs @@ -348,50 +348,6 @@ impl Arc { } } - /// Construct a new reference-counted slice with uninitialized contents. - /// - /// # Examples - /// - /// ``` - /// #![feature(new_uninit)] - /// #![feature(get_mut_unchecked)] - /// - /// use std::sync::Arc; - /// - /// let mut values = Arc::::new_uninit_slice(3); - /// - /// let values = unsafe { - /// // Deferred initialization: - /// Arc::get_mut_unchecked(&mut values)[0].as_mut_ptr().write(1); - /// Arc::get_mut_unchecked(&mut values)[1].as_mut_ptr().write(2); - /// Arc::get_mut_unchecked(&mut values)[2].as_mut_ptr().write(3); - /// - /// values.assume_init() - /// }; - /// - /// assert_eq!(*values, [1, 2, 3]) - /// ``` - #[unstable(feature = "new_uninit", issue = "0")] - pub fn new_uninit_slice(len: usize) -> Arc<[mem::MaybeUninit]> { - let data_layout = Layout::array::>(len).unwrap(); - let (layout, offset) = Layout::new::>().extend(data_layout).unwrap(); - unsafe { - let allocated_ptr = Global.alloc(layout) - .unwrap_or_else(|_| handle_alloc_error(layout)) - .as_ptr(); - let data_ptr = allocated_ptr.add(offset) as *mut mem::MaybeUninit; - let slice: *mut [mem::MaybeUninit] = from_raw_parts_mut(data_ptr, len); - let wide_ptr = slice as *mut ArcInner<[mem::MaybeUninit]>; - let wide_ptr = set_data_ptr(wide_ptr, allocated_ptr); - ptr::write(&mut (*wide_ptr).strong, atomic::AtomicUsize::new(1)); - ptr::write(&mut (*wide_ptr).weak, atomic::AtomicUsize::new(1)); - Arc { - ptr: NonNull::new_unchecked(wide_ptr), - phantom: PhantomData, - } - } - } - /// Constructs a new `Pin>`. If `T` does not implement `Unpin`, then /// `data` will be pinned in memory and unable to be moved. #[stable(feature = "pin", since = "1.33.0")] @@ -442,6 +398,52 @@ impl Arc { } } +impl Arc<[T]> { + /// Construct a new reference-counted slice with uninitialized contents. + /// + /// # Examples + /// + /// ``` + /// #![feature(new_uninit)] + /// #![feature(get_mut_unchecked)] + /// + /// use std::sync::Arc; + /// + /// let mut values = Arc::<[u32]>::new_uninit_slice(3); + /// + /// let values = unsafe { + /// // Deferred initialization: + /// Arc::get_mut_unchecked(&mut values)[0].as_mut_ptr().write(1); + /// Arc::get_mut_unchecked(&mut values)[1].as_mut_ptr().write(2); + /// Arc::get_mut_unchecked(&mut values)[2].as_mut_ptr().write(3); + /// + /// values.assume_init() + /// }; + /// + /// assert_eq!(*values, [1, 2, 3]) + /// ``` + #[unstable(feature = "new_uninit", issue = "0")] + pub fn new_uninit_slice(len: usize) -> Arc<[mem::MaybeUninit]> { + let data_layout = Layout::array::>(len).unwrap(); + let (layout, offset) = Layout::new::>().extend(data_layout).unwrap(); + unsafe { + let allocated_ptr = Global.alloc(layout) + .unwrap_or_else(|_| handle_alloc_error(layout)) + .as_ptr(); + let data_ptr = allocated_ptr.add(offset) as *mut mem::MaybeUninit; + let slice: *mut [mem::MaybeUninit] = from_raw_parts_mut(data_ptr, len); + let wide_ptr = slice as *mut ArcInner<[mem::MaybeUninit]>; + let wide_ptr = set_data_ptr(wide_ptr, allocated_ptr); + ptr::write(&mut (*wide_ptr).strong, atomic::AtomicUsize::new(1)); + ptr::write(&mut (*wide_ptr).weak, atomic::AtomicUsize::new(1)); + Arc { + ptr: NonNull::new_unchecked(wide_ptr), + phantom: PhantomData, + } + } + } +} + impl Arc> { /// Convert to `Arc`. /// @@ -503,7 +505,7 @@ impl Arc<[mem::MaybeUninit]> { /// /// use std::sync::Arc; /// - /// let mut values = Arc::::new_uninit_slice(3); + /// let mut values = Arc::<[u32]>::new_uninit_slice(3); /// /// let values = unsafe { /// // Deferred initialization: -- cgit 1.4.1-3-g733a5