Skip to content

Commit 170d933

Browse files
SimonSapinSimonSapin
committed
Move constructors of boxed/rc’ed slices to matching impl blocks
1 parent bde1924 commit 170d933

File tree

3 files changed

+106
-100
lines changed

3 files changed

+106
-100
lines changed

‎src/liballoc/boxed.rs

+12-10
Original file line numberDiff line numberDiff line change
@@ -149,14 +149,24 @@ impl<T> Box<T> {
149149
Box(unique.cast())
150150
}
151151

152+
/// Constructs a new `Pin<Box<T>>`. If `T` does not implement `Unpin`, then
153+
/// `x` will be pinned in memory and unable to be moved.
154+
#[stable(feature = "pin", since = "1.33.0")]
155+
#[inline(always)]
156+
pub fn pin(x: T) -> Pin<Box<T>> {
157+
(box x).into()
158+
}
159+
}
160+
161+
impl<T> Box<[T]> {
152162
/// Construct a new boxed slice with uninitialized contents.
153163
///
154164
/// # Examples
155165
///
156166
/// ```
157167
/// #![feature(new_uninit)]
158168
///
159-
/// let mut values = Box::<u32>::new_uninit_slice(3);
169+
/// let mut values = Box::<[u32]>::new_uninit_slice(3);
160170
///
161171
/// let values = unsafe {
162172
/// // Deferred initialization:
@@ -177,14 +187,6 @@ impl<T> Box<T> {
177187
let slice = unsafe { slice::from_raw_parts_mut(unique.cast().as_ptr(), len) };
178188
Box(Unique::from(slice))
179189
}
180-
181-
/// Constructs a new `Pin<Box<T>>`. If `T` does not implement `Unpin`, then
182-
/// `x` will be pinned in memory and unable to be moved.
183-
#[stable(feature = "pin", since = "1.33.0")]
184-
#[inline(always)]
185-
pub fn pin(x: T) -> Pin<Box<T>> {
186-
(box x).into()
187-
}
188190
}
189191

190192
impl<T> Box<mem::MaybeUninit<T>> {
@@ -237,7 +239,7 @@ impl<T> Box<[mem::MaybeUninit<T>]> {
237239
/// ```
238240
/// #![feature(new_uninit)]
239241
///
240-
/// let mut values = Box::<u32>::new_uninit_slice(3);
242+
/// let mut values = Box::<[u32]>::new_uninit_slice(3);
241243
///
242244
/// let values = unsafe {
243245
/// // Deferred initialization:

‎src/liballoc/rc.rs

+47-45
Original file line numberDiff line numberDiff line change
@@ -364,50 +364,6 @@ impl<T> Rc<T> {
364364
}
365365
}
366366

367-
/// Construct a new reference-counted slice with uninitialized contents.
368-
///
369-
/// # Examples
370-
///
371-
/// ```
372-
/// #![feature(new_uninit)]
373-
/// #![feature(get_mut_unchecked)]
374-
///
375-
/// use std::rc::Rc;
376-
///
377-
/// let mut values = Rc::<u32>::new_uninit_slice(3);
378-
///
379-
/// let values = unsafe {
380-
/// // Deferred initialization:
381-
/// Rc::get_mut_unchecked(&mut values)[0].as_mut_ptr().write(1);
382-
/// Rc::get_mut_unchecked(&mut values)[1].as_mut_ptr().write(2);
383-
/// Rc::get_mut_unchecked(&mut values)[2].as_mut_ptr().write(3);
384-
///
385-
/// values.assume_init()
386-
/// };
387-
///
388-
/// assert_eq!(*values, [1, 2, 3])
389-
/// ```
390-
#[unstable(feature = "new_uninit", issue = "0")]
391-
pub fn new_uninit_slice(len: usize) -> Rc<[mem::MaybeUninit<T>]> {
392-
let data_layout = Layout::array::<mem::MaybeUninit<T>>(len).unwrap();
393-
let (layout, offset) = Layout::new::<RcBox<()>>().extend(data_layout).unwrap();
394-
unsafe {
395-
let allocated_ptr = Global.alloc(layout)
396-
.unwrap_or_else(|_| handle_alloc_error(layout))
397-
.as_ptr();
398-
let data_ptr = allocated_ptr.add(offset) as *mut mem::MaybeUninit<T>;
399-
let slice: *mut [mem::MaybeUninit<T>] = from_raw_parts_mut(data_ptr, len);
400-
let wide_ptr = slice as *mut RcBox<[mem::MaybeUninit<T>]>;
401-
let wide_ptr = set_data_ptr(wide_ptr, allocated_ptr);
402-
ptr::write(&mut (*wide_ptr).strong, Cell::new(1));
403-
ptr::write(&mut (*wide_ptr).weak, Cell::new(1));
404-
Rc {
405-
ptr: NonNull::new_unchecked(wide_ptr),
406-
phantom: PhantomData,
407-
}
408-
}
409-
}
410-
411367
/// Constructs a new `Pin<Rc<T>>`. If `T` does not implement `Unpin`, then
412368
/// `value` will be pinned in memory and unable to be moved.
413369
#[stable(feature = "pin", since = "1.33.0")]
@@ -458,6 +414,52 @@ impl<T> Rc<T> {
458414
}
459415
}
460416

417+
impl<T> Rc<[T]> {
418+
/// Construct a new reference-counted slice with uninitialized contents.
419+
///
420+
/// # Examples
421+
///
422+
/// ```
423+
/// #![feature(new_uninit)]
424+
/// #![feature(get_mut_unchecked)]
425+
///
426+
/// use std::rc::Rc;
427+
///
428+
/// let mut values = Rc::<[u32]>::new_uninit_slice(3);
429+
///
430+
/// let values = unsafe {
431+
/// // Deferred initialization:
432+
/// Rc::get_mut_unchecked(&mut values)[0].as_mut_ptr().write(1);
433+
/// Rc::get_mut_unchecked(&mut values)[1].as_mut_ptr().write(2);
434+
/// Rc::get_mut_unchecked(&mut values)[2].as_mut_ptr().write(3);
435+
///
436+
/// values.assume_init()
437+
/// };
438+
///
439+
/// assert_eq!(*values, [1, 2, 3])
440+
/// ```
441+
#[unstable(feature = "new_uninit", issue = "0")]
442+
pub fn new_uninit_slice(len: usize) -> Rc<[mem::MaybeUninit<T>]> {
443+
let data_layout = Layout::array::<mem::MaybeUninit<T>>(len).unwrap();
444+
let (layout, offset) = Layout::new::<RcBox<()>>().extend(data_layout).unwrap();
445+
unsafe {
446+
let allocated_ptr = Global.alloc(layout)
447+
.unwrap_or_else(|_| handle_alloc_error(layout))
448+
.as_ptr();
449+
let data_ptr = allocated_ptr.add(offset) as *mut mem::MaybeUninit<T>;
450+
let slice: *mut [mem::MaybeUninit<T>] = from_raw_parts_mut(data_ptr, len);
451+
let wide_ptr = slice as *mut RcBox<[mem::MaybeUninit<T>]>;
452+
let wide_ptr = set_data_ptr(wide_ptr, allocated_ptr);
453+
ptr::write(&mut (*wide_ptr).strong, Cell::new(1));
454+
ptr::write(&mut (*wide_ptr).weak, Cell::new(1));
455+
Rc {
456+
ptr: NonNull::new_unchecked(wide_ptr),
457+
phantom: PhantomData,
458+
}
459+
}
460+
}
461+
}
462+
461463
impl<T> Rc<mem::MaybeUninit<T>> {
462464
/// Convert to `Rc<T>`.
463465
///
@@ -519,7 +521,7 @@ impl<T> Rc<[mem::MaybeUninit<T>]> {
519521
///
520522
/// use std::rc::Rc;
521523
///
522-
/// let mut values = Rc::<u32>::new_uninit_slice(3);
524+
/// let mut values = Rc::<[u32]>::new_uninit_slice(3);
523525
///
524526
/// let values = unsafe {
525527
/// // Deferred initialization:

‎src/liballoc/sync.rs

+47-45
Original file line numberDiff line numberDiff line change
@@ -348,50 +348,6 @@ impl<T> Arc<T> {
348348
}
349349
}
350350

351-
/// Construct a new reference-counted slice with uninitialized contents.
352-
///
353-
/// # Examples
354-
///
355-
/// ```
356-
/// #![feature(new_uninit)]
357-
/// #![feature(get_mut_unchecked)]
358-
///
359-
/// use std::sync::Arc;
360-
///
361-
/// let mut values = Arc::<u32>::new_uninit_slice(3);
362-
///
363-
/// let values = unsafe {
364-
/// // Deferred initialization:
365-
/// Arc::get_mut_unchecked(&mut values)[0].as_mut_ptr().write(1);
366-
/// Arc::get_mut_unchecked(&mut values)[1].as_mut_ptr().write(2);
367-
/// Arc::get_mut_unchecked(&mut values)[2].as_mut_ptr().write(3);
368-
///
369-
/// values.assume_init()
370-
/// };
371-
///
372-
/// assert_eq!(*values, [1, 2, 3])
373-
/// ```
374-
#[unstable(feature = "new_uninit", issue = "0")]
375-
pub fn new_uninit_slice(len: usize) -> Arc<[mem::MaybeUninit<T>]> {
376-
let data_layout = Layout::array::<mem::MaybeUninit<T>>(len).unwrap();
377-
let (layout, offset) = Layout::new::<ArcInner<()>>().extend(data_layout).unwrap();
378-
unsafe {
379-
let allocated_ptr = Global.alloc(layout)
380-
.unwrap_or_else(|_| handle_alloc_error(layout))
381-
.as_ptr();
382-
let data_ptr = allocated_ptr.add(offset) as *mut mem::MaybeUninit<T>;
383-
let slice: *mut [mem::MaybeUninit<T>] = from_raw_parts_mut(data_ptr, len);
384-
let wide_ptr = slice as *mut ArcInner<[mem::MaybeUninit<T>]>;
385-
let wide_ptr = set_data_ptr(wide_ptr, allocated_ptr);
386-
ptr::write(&mut (*wide_ptr).strong, atomic::AtomicUsize::new(1));
387-
ptr::write(&mut (*wide_ptr).weak, atomic::AtomicUsize::new(1));
388-
Arc {
389-
ptr: NonNull::new_unchecked(wide_ptr),
390-
phantom: PhantomData,
391-
}
392-
}
393-
}
394-
395351
/// Constructs a new `Pin<Arc<T>>`. If `T` does not implement `Unpin`, then
396352
/// `data` will be pinned in memory and unable to be moved.
397353
#[stable(feature = "pin", since = "1.33.0")]
@@ -442,6 +398,52 @@ impl<T> Arc<T> {
442398
}
443399
}
444400

401+
impl<T> Arc<[T]> {
402+
/// Construct a new reference-counted slice with uninitialized contents.
403+
///
404+
/// # Examples
405+
///
406+
/// ```
407+
/// #![feature(new_uninit)]
408+
/// #![feature(get_mut_unchecked)]
409+
///
410+
/// use std::sync::Arc;
411+
///
412+
/// let mut values = Arc::<[u32]>::new_uninit_slice(3);
413+
///
414+
/// let values = unsafe {
415+
/// // Deferred initialization:
416+
/// Arc::get_mut_unchecked(&mut values)[0].as_mut_ptr().write(1);
417+
/// Arc::get_mut_unchecked(&mut values)[1].as_mut_ptr().write(2);
418+
/// Arc::get_mut_unchecked(&mut values)[2].as_mut_ptr().write(3);
419+
///
420+
/// values.assume_init()
421+
/// };
422+
///
423+
/// assert_eq!(*values, [1, 2, 3])
424+
/// ```
425+
#[unstable(feature = "new_uninit", issue = "0")]
426+
pub fn new_uninit_slice(len: usize) -> Arc<[mem::MaybeUninit<T>]> {
427+
let data_layout = Layout::array::<mem::MaybeUninit<T>>(len).unwrap();
428+
let (layout, offset) = Layout::new::<ArcInner<()>>().extend(data_layout).unwrap();
429+
unsafe {
430+
let allocated_ptr = Global.alloc(layout)
431+
.unwrap_or_else(|_| handle_alloc_error(layout))
432+
.as_ptr();
433+
let data_ptr = allocated_ptr.add(offset) as *mut mem::MaybeUninit<T>;
434+
let slice: *mut [mem::MaybeUninit<T>] = from_raw_parts_mut(data_ptr, len);
435+
let wide_ptr = slice as *mut ArcInner<[mem::MaybeUninit<T>]>;
436+
let wide_ptr = set_data_ptr(wide_ptr, allocated_ptr);
437+
ptr::write(&mut (*wide_ptr).strong, atomic::AtomicUsize::new(1));
438+
ptr::write(&mut (*wide_ptr).weak, atomic::AtomicUsize::new(1));
439+
Arc {
440+
ptr: NonNull::new_unchecked(wide_ptr),
441+
phantom: PhantomData,
442+
}
443+
}
444+
}
445+
}
446+
445447
impl<T> Arc<mem::MaybeUninit<T>> {
446448
/// Convert to `Arc<T>`.
447449
///
@@ -503,7 +505,7 @@ impl<T> Arc<[mem::MaybeUninit<T>]> {
503505
///
504506
/// use std::sync::Arc;
505507
///
506-
/// let mut values = Arc::<u32>::new_uninit_slice(3);
508+
/// let mut values = Arc::<[u32]>::new_uninit_slice(3);
507509
///
508510
/// let values = unsafe {
509511
/// // Deferred initialization:

0 commit comments

Comments
 (0)