Add missing try_new_uninit_slice_in and try_new_zeroed_slice_in · patricklam/verify-rust-std@c3b602a (original) (raw)
`@@ -704,7 +704,7 @@ impl Box<[T]> {
`
704
704
`}
`
705
705
``
706
706
`/// Constructs a new boxed slice with uninitialized contents. Returns an error if
`
707
``
`-
/// the allocation fails
`
``
707
`+
/// the allocation fails.
`
708
708
`///
`
709
709
`/// # Examples
`
710
710
`///
`
`@@ -739,7 +739,7 @@ impl Box<[T]> {
`
739
739
`}
`
740
740
``
741
741
`/// Constructs a new boxed slice with uninitialized contents, with the memory
`
742
``
`` -
/// being filled with 0 bytes. Returns an error if the allocation fails
``
``
742
`` +
/// being filled with 0 bytes. Returns an error if the allocation fails.
``
743
743
`///
`
744
744
`` /// See [MaybeUninit::zeroed][zeroed] for examples of correct and incorrect usage
``
745
745
`/// of this method.
`
`@@ -831,6 +831,79 @@ impl<T, A: Allocator> Box<[T], A> {
`
831
831
`pub fn new_zeroed_slice_in(len: usize, alloc: A) -> Box<[mem::MaybeUninit], A> {
`
832
832
`unsafe { RawVec::with_capacity_zeroed_in(len, alloc).into_box(len) }
`
833
833
`}
`
``
834
+
``
835
`+
/// Constructs a new boxed slice with uninitialized contents in the provided allocator. Returns an error if
`
``
836
`+
/// the allocation fails.
`
``
837
`+
///
`
``
838
`+
/// # Examples
`
``
839
`+
///
`
``
840
/// ```
``
841
`+
/// #![feature(allocator_api, new_uninit)]
`
``
842
`+
///
`
``
843
`+
/// use std::alloc::System;
`
``
844
`+
///
`
``
845
`+
/// let mut values = Box::<[u32]>::try_new_uninit_slice(3, System)?;
`
``
846
`+
/// let values = unsafe {
`
``
847
`+
/// // Deferred initialization:
`
``
848
`+
/// values[0].as_mut_ptr().write(1);
`
``
849
`+
/// values[1].as_mut_ptr().write(2);
`
``
850
`+
/// values[2].as_mut_ptr().write(3);
`
``
851
`+
/// values.assume_init()
`
``
852
`+
/// };
`
``
853
`+
///
`
``
854
`+
/// assert_eq!(*values, [1, 2, 3]);
`
``
855
`+
/// # Ok::<(), std::alloc::AllocError>(())
`
``
856
/// ```
``
857
`+
#[unstable(feature = "allocator_api", issue = "32838")]
`
``
858
`+
#[inline]
`
``
859
`+
pub fn try_new_uninit_slice_in(len: usize, alloc: A) -> Result<Box<[mem::MaybeUninit], A>, AllocError> {
`
``
860
`+
let ptr = if T::IS_ZST || len == 0 {
`
``
861
`+
NonNull::dangling()
`
``
862
`+
} else {
`
``
863
`+
let layout = match Layout::array::<mem::MaybeUninit>(len) {
`
``
864
`+
Ok(l) => l,
`
``
865
`+
Err(_) => return Err(AllocError),
`
``
866
`+
};
`
``
867
`+
Global.allocate(layout)?.cast()
`
``
868
`+
};
`
``
869
`+
unsafe { Ok(RawVec::from_raw_parts_in(ptr.as_ptr(), len, alloc).into_box(len)) }
`
``
870
`+
}
`
``
871
+
``
872
`+
/// Constructs a new boxed slice with uninitialized contents in the provided allocator, with the memory
`
``
873
`` +
/// being filled with 0 bytes. Returns an error if the allocation fails.
``
``
874
`+
///
`
``
875
`` +
/// See [MaybeUninit::zeroed][zeroed] for examples of correct and incorrect usage
``
``
876
`+
/// of this method.
`
``
877
`+
///
`
``
878
`+
/// # Examples
`
``
879
`+
///
`
``
880
/// ```
``
881
`+
/// #![feature(allocator_api, new_uninit)]
`
``
882
`+
///
`
``
883
`+
/// use std::alloc::System;
`
``
884
`+
///
`
``
885
`+
/// let values = Box::<[u32]>::try_new_zeroed_slice(3, System)?;
`
``
886
`+
/// let values = unsafe { values.assume_init() };
`
``
887
`+
///
`
``
888
`+
/// assert_eq!(*values, [0, 0, 0]);
`
``
889
`+
/// # Ok::<(), std::alloc::AllocError>(())
`
``
890
/// ```
``
891
`+
///
`
``
892
`+
/// [zeroed]: mem::MaybeUninit::zeroed
`
``
893
`+
#[unstable(feature = "allocator_api", issue = "32838")]
`
``
894
`+
#[inline]
`
``
895
`+
pub fn try_new_zeroed_slice_in(len: usize, alloc: A) -> Result<Box<[mem::MaybeUninit], A>, AllocError> {
`
``
896
`+
let ptr = if T::IS_ZST || len == 0 {
`
``
897
`+
NonNull::dangling()
`
``
898
`+
} else {
`
``
899
`+
let layout = match Layout::array::<mem::MaybeUninit>(len) {
`
``
900
`+
Ok(l) => l,
`
``
901
`+
Err(_) => return Err(AllocError),
`
``
902
`+
};
`
``
903
`+
Global.allocate_zeroed(layout)?.cast()
`
``
904
`+
};
`
``
905
`+
unsafe { Ok(RawVec::from_raw_parts_in(ptr.as_ptr(), len, alloc).into_box(len)) }
`
``
906
`+
}
`
834
907
`}
`
835
908
``
836
909
`impl<T, A: Allocator> Box<mem::MaybeUninit, A> {
`