mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

library: Stabilize new_uninit for Box, Rc, and Arc

Browse Source 
A partial stabilization that only affects:
- AllocType<T>::new_uninit
- AllocType<T>::assume_init
- AllocType<[T]>::new_uninit_slice
- AllocType<[T]>::assume_init
where "AllocType" is Box, Rc, or Arc
This commit is contained in:
Jubilee Young 2024-08-21 22:22:18 -07:00
parent 600edc948a
commit 169b2f0e6d
7 changed files with 32 additions and 67 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

43
library/alloc/src/boxed.rs
View File

@ -262,8 +262,6 @@ pub fn new(x: T) -> Self {
/// # Examples
///
/// ```
/// #![feature(new_uninit)]
///
/// let mut five = Box::<u32>::new_uninit();
///
/// let five = unsafe {
@ -276,7 +274,7 @@ pub fn new(x: T) -> Self {
/// assert_eq!(*five, 5)
/// ```
#[cfg(not(no_global_oom_handling))]
#[unstable(feature = "new_uninit", issue = "63291")]
#[stable(feature = "new_uninit", since = "CURRENT_RUSTC_VERSION")]
#[must_use]
#[inline]
pub fn new_uninit() -> Box<mem::MaybeUninit<T>> {
@ -292,7 +290,6 @@ pub fn new_uninit() -> Box<mem::MaybeUninit<T>> {
/// # Examples
///
/// ```
/// #![feature(new_uninit)]
/// #![feature(new_zeroed_alloc)]
///
/// let zero = Box::<u32>::new_zeroed();
@ -350,7 +347,7 @@ pub fn try_new(x: T) -> Result<Self, AllocError> {
/// # Examples
///
/// ```
/// #![feature(allocator_api, new_uninit)]
/// #![feature(allocator_api)]
///
/// let mut five = Box::<u32>::try_new_uninit()?;
///
@ -380,7 +377,7 @@ pub fn try_new_uninit() -> Result<Box<mem::MaybeUninit<T>>, AllocError> {
/// # Examples
///
/// ```
/// #![feature(allocator_api, new_uninit)]
/// #![feature(allocator_api)]
///
/// let zero = Box::<u32>::try_new_zeroed()?;
/// let zero = unsafe { zero.assume_init() };
@ -460,7 +457,7 @@ pub fn try_new_in(x: T, alloc: A) -> Result<Self, AllocError>
/// # Examples
///
/// ```
/// #![feature(allocator_api, new_uninit)]
/// #![feature(allocator_api)]
///
/// use std::alloc::System;
///
@ -498,7 +495,7 @@ pub fn new_uninit_in(alloc: A) -> Box<mem::MaybeUninit<T>, A>
/// # Examples
///
/// ```
/// #![feature(allocator_api, new_uninit)]
/// #![feature(allocator_api)]
///
/// use std::alloc::System;
///
@ -538,7 +535,7 @@ pub fn try_new_uninit_in(alloc: A) -> Result<Box<mem::MaybeUninit<T>, A>, AllocE
/// # Examples
///
/// ```
/// #![feature(allocator_api, new_uninit)]
/// #![feature(allocator_api)]
///
/// use std::alloc::System;
///
@ -576,7 +573,7 @@ pub fn new_zeroed_in(alloc: A) -> Box<mem::MaybeUninit<T>, A>
/// # Examples
///
/// ```
/// #![feature(allocator_api, new_uninit)]
/// #![feature(allocator_api)]
///
/// use std::alloc::System;
///
@ -654,8 +651,6 @@ impl<T> Box<[T]> {
/// # Examples
///
/// ```
/// #![feature(new_uninit)]
///
/// let mut values = Box::<[u32]>::new_uninit_slice(3);
///
/// let values = unsafe {
@ -670,7 +665,7 @@ impl<T> Box<[T]> {
/// assert_eq!(*values, [1, 2, 3])
/// ```
#[cfg(not(no_global_oom_handling))]
#[unstable(feature = "new_uninit", issue = "63291")]
#[stable(feature = "new_uninit", since = "CURRENT_RUSTC_VERSION")]
#[must_use]
pub fn new_uninit_slice(len: usize) -> Box<[mem::MaybeUninit<T>]> {
unsafe { RawVec::with_capacity(len).into_box(len) }
@ -686,7 +681,6 @@ pub fn new_uninit_slice(len: usize) -> Box<[mem::MaybeUninit<T>]> {
///
/// ```
/// #![feature(new_zeroed_alloc)]
/// #![feature(new_uninit)]
///
/// let values = Box::<[u32]>::new_zeroed_slice(3);
/// let values = unsafe { values.assume_init() };
@ -708,7 +702,7 @@ pub fn new_zeroed_slice(len: usize) -> Box<[mem::MaybeUninit<T>]> {
/// # Examples
///
/// ```
/// #![feature(allocator_api, new_uninit)]
/// #![feature(allocator_api)]
///
/// let mut values = Box::<[u32]>::try_new_uninit_slice(3)?;
/// let values = unsafe {
@ -746,7 +740,7 @@ pub fn try_new_uninit_slice(len: usize) -> Result<Box<[mem::MaybeUninit<T>]>, Al
/// # Examples
///
/// ```
/// #![feature(allocator_api, new_uninit)]
/// #![feature(allocator_api)]
///
/// let values = Box::<[u32]>::try_new_zeroed_slice(3)?;
/// let values = unsafe { values.assume_init() };
@ -778,7 +772,7 @@ impl<T, A: Allocator> Box<[T], A> {
/// # Examples
///
/// ```
/// #![feature(allocator_api, new_uninit)]
/// #![feature(allocator_api)]
///
/// use std::alloc::System;
///
@ -812,7 +806,7 @@ pub fn new_uninit_slice_in(len: usize, alloc: A) -> Box<[mem::MaybeUninit<T>], A
/// # Examples
///
/// ```
/// #![feature(allocator_api, new_uninit)]
/// #![feature(allocator_api)]
///
/// use std::alloc::System;
///
@ -837,7 +831,7 @@ pub fn new_zeroed_slice_in(len: usize, alloc: A) -> Box<[mem::MaybeUninit<T>], A
/// # Examples
///
/// ```
/// #![feature(allocator_api, new_uninit)]
/// #![feature(allocator_api)]
///
/// use std::alloc::System;
///
@ -880,7 +874,7 @@ pub fn try_new_uninit_slice_in(
/// # Examples
///
/// ```
/// #![feature(allocator_api, new_uninit)]
/// #![feature(allocator_api)]
///
/// use std::alloc::System;
///
@ -927,8 +921,6 @@ impl<T, A: Allocator> Box<mem::MaybeUninit<T>, A> {
/// # Examples
///
/// ```
/// #![feature(new_uninit)]
///
/// let mut five = Box::<u32>::new_uninit();
///
/// let five: Box<u32> = unsafe {
@ -940,7 +932,7 @@ impl<T, A: Allocator> Box<mem::MaybeUninit<T>, A> {
///
/// assert_eq!(*five, 5)
/// ```
#[unstable(feature = "new_uninit", issue = "63291")]
#[stable(feature = "new_uninit", since = "CURRENT_RUSTC_VERSION")]
#[inline]
pub unsafe fn assume_init(self) -> Box<T, A> {
let (raw, alloc) = Box::into_raw_with_allocator(self);
@ -958,7 +950,6 @@ pub unsafe fn assume_init(self) -> Box<T, A> {
///
/// ```
/// #![feature(box_uninit_write)]
/// #![feature(new_uninit)]
///
/// let big_box = Box::<[usize; 1024]>::new_uninit();
///
@ -1001,8 +992,6 @@ impl<T, A: Allocator> Box<[mem::MaybeUninit<T>], A> {
/// # Examples
///
/// ```
/// #![feature(new_uninit)]
///
/// let mut values = Box::<[u32]>::new_uninit_slice(3);
///
/// let values = unsafe {
@ -1016,7 +1005,7 @@ impl<T, A: Allocator> Box<[mem::MaybeUninit<T>], A> {
///
/// assert_eq!(*values, [1, 2, 3])
/// ```
#[unstable(feature = "new_uninit", issue = "63291")]
#[stable(feature = "new_uninit", since = "CURRENT_RUSTC_VERSION")]
#[inline]
pub unsafe fn assume_init(self) -> Box<[T], A> {
let (raw, alloc) = Box::into_raw_with_allocator(self);

1
library/alloc/src/lib.rs
View File

@ -93,7 +93,6 @@
// tidy-alphabetical-start
#![cfg_attr(not(no_global_oom_handling), feature(const_alloc_error))]
#![cfg_attr(not(no_global_oom_handling), feature(const_btree_len))]
#![cfg_attr(test, feature(new_uninit))]
#![feature(alloc_layout_extra)]
#![feature(allocator_api)]
#![feature(array_chunks)]

26
library/alloc/src/rc.rs
View File

@ -503,7 +503,6 @@ pub fn new_cyclic<F>(data_fn: F) -> Rc<T>
/// # Examples
///
/// ```
/// #![feature(new_uninit)]
/// #![feature(get_mut_unchecked)]
///
/// use std::rc::Rc;
@ -518,7 +517,7 @@ pub fn new_cyclic<F>(data_fn: F) -> Rc<T>
/// assert_eq!(*five, 5)
/// ```
#[cfg(not(no_global_oom_handling))]
#[unstable(feature = "new_uninit", issue = "63291")]
#[stable(feature = "new_uninit", since = "CURRENT_RUSTC_VERSION")]
#[must_use]
pub fn new_uninit() -> Rc<mem::MaybeUninit<T>> {
unsafe {
@ -540,7 +539,6 @@ pub fn new_uninit() -> Rc<mem::MaybeUninit<T>> {
///
/// ```
/// #![feature(new_zeroed_alloc)]
/// #![feature(new_uninit)]
///
/// use std::rc::Rc;
///
@ -594,7 +592,7 @@ pub fn try_new(value: T) -> Result<Rc<T>, AllocError> {
/// # Examples
///
/// ```
/// #![feature(allocator_api, new_uninit)]
/// #![feature(allocator_api)]
/// #![feature(get_mut_unchecked)]
///
/// use std::rc::Rc;
@ -630,7 +628,7 @@ pub fn try_new_uninit() -> Result<Rc<mem::MaybeUninit<T>>, AllocError> {
/// # Examples
///
/// ```
/// #![feature(allocator_api, new_uninit)]
/// #![feature(allocator_api)]
///
/// use std::rc::Rc;
///
@ -692,7 +690,6 @@ pub fn new_in(value: T, alloc: A) -> Rc<T, A> {
/// # Examples
///
/// ```
/// #![feature(new_uninit)]
/// #![feature(get_mut_unchecked)]
/// #![feature(allocator_api)]
///
@ -736,7 +733,6 @@ pub fn new_uninit_in(alloc: A) -> Rc<mem::MaybeUninit<T>, A> {
/// # Examples
///
/// ```
/// #![feature(new_uninit)]
/// #![feature(allocator_api)]
///
/// use std::rc::Rc;
@ -799,7 +795,7 @@ pub fn try_new_in(value: T, alloc: A) -> Result<Self, AllocError> {
/// # Examples
///
/// ```
/// #![feature(allocator_api, new_uninit)]
/// #![feature(allocator_api)]
/// #![feature(get_mut_unchecked)]
///
/// use std::rc::Rc;
@ -843,7 +839,7 @@ pub fn try_new_uninit_in(alloc: A) -> Result<Rc<mem::MaybeUninit<T>, A>, AllocEr
/// # Examples
///
/// ```
/// #![feature(allocator_api, new_uninit)]
/// #![feature(allocator_api)]
///
/// use std::rc::Rc;
/// use std::alloc::System;
@ -967,7 +963,6 @@ impl<T> Rc<[T]> {
/// # Examples
///
/// ```
/// #![feature(new_uninit)]
/// #![feature(get_mut_unchecked)]
///
/// use std::rc::Rc;
@ -985,7 +980,7 @@ impl<T> Rc<[T]> {
/// assert_eq!(*values, [1, 2, 3])
/// ```
#[cfg(not(no_global_oom_handling))]
#[unstable(feature = "new_uninit", issue = "63291")]
#[stable(feature = "new_uninit", since = "CURRENT_RUSTC_VERSION")]
#[must_use]
pub fn new_uninit_slice(len: usize) -> Rc<[mem::MaybeUninit<T>]> {
unsafe { Rc::from_ptr(Rc::allocate_for_slice(len)) }
@ -1000,7 +995,6 @@ pub fn new_uninit_slice(len: usize) -> Rc<[mem::MaybeUninit<T>]> {
/// # Examples
///
/// ```
/// #![feature(new_uninit)]
/// #![feature(new_zeroed_alloc)]
///
/// use std::rc::Rc;
@ -1035,7 +1029,6 @@ impl<T, A: Allocator> Rc<[T], A> {
/// # Examples
///
/// ```
/// #![feature(new_uninit)]
/// #![feature(get_mut_unchecked)]
/// #![feature(allocator_api)]
///
@ -1072,7 +1065,6 @@ pub fn new_uninit_slice_in(len: usize, alloc: A) -> Rc<[mem::MaybeUninit<T>], A>
/// # Examples
///
/// ```
/// #![feature(new_uninit)]
/// #![feature(allocator_api)]
///
/// use std::rc::Rc;
@ -1122,7 +1114,6 @@ impl<T, A: Allocator> Rc<mem::MaybeUninit<T>, A> {
/// # Examples
///
/// ```
/// #![feature(new_uninit)]
/// #![feature(get_mut_unchecked)]
///
/// use std::rc::Rc;
@ -1136,7 +1127,7 @@ impl<T, A: Allocator> Rc<mem::MaybeUninit<T>, A> {
///
/// assert_eq!(*five, 5)
/// ```
#[unstable(feature = "new_uninit", issue = "63291")]
#[stable(feature = "new_uninit", since = "CURRENT_RUSTC_VERSION")]
#[inline]
pub unsafe fn assume_init(self) -> Rc<T, A> {
let (ptr, alloc) = Rc::into_inner_with_allocator(self);
@ -1160,7 +1151,6 @@ impl<T, A: Allocator> Rc<[mem::MaybeUninit<T>], A> {
/// # Examples
///
/// ```
/// #![feature(new_uninit)]
/// #![feature(get_mut_unchecked)]
///
/// use std::rc::Rc;
@ -1177,7 +1167,7 @@ impl<T, A: Allocator> Rc<[mem::MaybeUninit<T>], A> {
///
/// assert_eq!(*values, [1, 2, 3])
/// ```
#[unstable(feature = "new_uninit", issue = "63291")]
#[stable(feature = "new_uninit", since = "CURRENT_RUSTC_VERSION")]
#[inline]
pub unsafe fn assume_init(self) -> Rc<[T], A> {
let (ptr, alloc) = Rc::into_inner_with_allocator(self);

26
library/alloc/src/sync.rs
View File

@ -505,7 +505,6 @@ pub fn new_cyclic<F>(data_fn: F) -> Arc<T>
/// # Examples
///
/// ```
/// #![feature(new_uninit)]
/// #![feature(get_mut_unchecked)]
///
/// use std::sync::Arc;
@ -521,7 +520,7 @@ pub fn new_cyclic<F>(data_fn: F) -> Arc<T>
/// ```
#[cfg(not(no_global_oom_handling))]
#[inline]
#[unstable(feature = "new_uninit", issue = "63291")]
#[stable(feature = "new_uninit", since = "CURRENT_RUSTC_VERSION")]
#[must_use]
pub fn new_uninit() -> Arc<mem::MaybeUninit<T>> {
unsafe {
@ -543,7 +542,6 @@ pub fn new_uninit() -> Arc<mem::MaybeUninit<T>> {
///
/// ```
/// #![feature(new_zeroed_alloc)]
/// #![feature(new_uninit)]
///
/// use std::sync::Arc;
///
@ -614,7 +612,7 @@ pub fn try_new(data: T) -> Result<Arc<T>, AllocError> {
/// # Examples
///
/// ```
/// #![feature(new_uninit, allocator_api)]
/// #![feature(allocator_api)]
/// #![feature(get_mut_unchecked)]
///
/// use std::sync::Arc;
@ -650,7 +648,7 @@ pub fn try_new_uninit() -> Result<Arc<mem::MaybeUninit<T>>, AllocError> {
/// # Examples
///
/// ```
/// #![feature(new_uninit, allocator_api)]
/// #![feature( allocator_api)]
///
/// use std::sync::Arc;
///
@ -711,7 +709,6 @@ pub fn new_in(data: T, alloc: A) -> Arc<T, A> {
/// # Examples
///
/// ```
/// #![feature(new_uninit)]
/// #![feature(get_mut_unchecked)]
/// #![feature(allocator_api)]
///
@ -755,7 +752,6 @@ pub fn new_uninit_in(alloc: A) -> Arc<mem::MaybeUninit<T>, A> {
/// # Examples
///
/// ```
/// #![feature(new_uninit)]
/// #![feature(allocator_api)]
///
/// use std::sync::Arc;
@ -845,7 +841,7 @@ pub fn try_new_in(data: T, alloc: A) -> Result<Arc<T, A>, AllocError> {
/// # Examples
///
/// ```
/// #![feature(new_uninit, allocator_api)]
/// #![feature(allocator_api)]
/// #![feature(get_mut_unchecked)]
///
/// use std::sync::Arc;
@ -889,7 +885,7 @@ pub fn try_new_uninit_in(alloc: A) -> Result<Arc<mem::MaybeUninit<T>, A>, AllocE
/// # Examples
///
/// ```
/// #![feature(new_uninit, allocator_api)]
/// #![feature(allocator_api)]
///
/// use std::sync::Arc;
/// use std::alloc::System;
@ -1101,7 +1097,6 @@ impl<T> Arc<[T]> {
/// # Examples
///
/// ```
/// #![feature(new_uninit)]
/// #![feature(get_mut_unchecked)]
///
/// use std::sync::Arc;
@ -1120,7 +1115,7 @@ impl<T> Arc<[T]> {
/// ```
#[cfg(not(no_global_oom_handling))]
#[inline]
#[unstable(feature = "new_uninit", issue = "63291")]
#[stable(feature = "new_uninit", since = "CURRENT_RUSTC_VERSION")]
#[must_use]
pub fn new_uninit_slice(len: usize) -> Arc<[mem::MaybeUninit<T>]> {
unsafe { Arc::from_ptr(Arc::allocate_for_slice(len)) }
@ -1136,7 +1131,6 @@ pub fn new_uninit_slice(len: usize) -> Arc<[mem::MaybeUninit<T>]> {
///
/// ```
/// #![feature(new_zeroed_alloc)]
/// #![feature(new_uninit)]
///
/// use std::sync::Arc;
///
@ -1172,7 +1166,6 @@ impl<T, A: Allocator> Arc<[T], A> {
/// # Examples
///
/// ```
/// #![feature(new_uninit)]
/// #![feature(get_mut_unchecked)]
/// #![feature(allocator_api)]
///
@ -1208,7 +1201,6 @@ pub fn new_uninit_slice_in(len: usize, alloc: A) -> Arc<[mem::MaybeUninit<T>], A
/// # Examples
///
/// ```
/// #![feature(new_uninit)]
/// #![feature(allocator_api)]
///
/// use std::sync::Arc;
@ -1257,7 +1249,6 @@ impl<T, A: Allocator> Arc<mem::MaybeUninit<T>, A> {
/// # Examples
///
/// ```
/// #![feature(new_uninit)]
/// #![feature(get_mut_unchecked)]
///
/// use std::sync::Arc;
@ -1271,7 +1262,7 @@ impl<T, A: Allocator> Arc<mem::MaybeUninit<T>, A> {
///
/// assert_eq!(*five, 5)
/// ```
#[unstable(feature = "new_uninit", issue = "63291")]
#[stable(feature = "new_uninit", since = "CURRENT_RUSTC_VERSION")]
#[must_use = "`self` will be dropped if the result is not used"]
#[inline]
pub unsafe fn assume_init(self) -> Arc<T, A> {
@ -1296,7 +1287,6 @@ impl<T, A: Allocator> Arc<[mem::MaybeUninit<T>], A> {
/// # Examples
///
/// ```
/// #![feature(new_uninit)]
/// #![feature(get_mut_unchecked)]
///
/// use std::sync::Arc;
@ -1313,7 +1303,7 @@ impl<T, A: Allocator> Arc<[mem::MaybeUninit<T>], A> {
///
/// assert_eq!(*values, [1, 2, 3])
/// ```
#[unstable(feature = "new_uninit", issue = "63291")]
#[stable(feature = "new_uninit", since = "CURRENT_RUSTC_VERSION")]
#[must_use = "`self` will be dropped if the result is not used"]
#[inline]
pub unsafe fn assume_init(self) -> Arc<[T], A> {

1
library/alloc/tests/lib.rs
View File

@ -15,7 +15,6 @@
#![feature(exact_size_is_empty)]
#![feature(linked_list_cursors)]
#![feature(map_try_insert)]
#![feature(new_uninit)]
#![feature(pattern)]
#![feature(trusted_len)]
#![feature(try_reserve_kind)]

1
library/proc_macro/src/lib.rs
View File

@ -28,7 +28,6 @@
#![feature(decl_macro)]
#![feature(maybe_uninit_write_slice)]
#![feature(negative_impls)]
#![feature(new_uninit)]
#![feature(panic_can_unwind)]
#![feature(restricted_std)]
#![feature(rustc_attrs)]

1
library/std/src/lib.rs
View File

@ -362,7 +362,6 @@
#![feature(allocator_api)]
#![feature(get_mut_unchecked)]
#![feature(map_try_insert)]
#![feature(new_uninit)]
#![feature(new_zeroed_alloc)]
#![feature(slice_concat_trait)]
#![feature(thin_box)]