Add RcAlloc and ArcAlloc

These allocators use the StructAlloc infrastructure to add enough
padding in front and behind the allocation so that Box<T, XAlloc> can be
converted into X<T> without reallocating.

Author: Julian Orth

library/alloc/src/rc.rs

@@ -257,7 +257,7 @@ use core::hash::{Hash, Hasher};
 use core::intrinsics::abort;
 use core::iter;
 use core::marker::{self, PhantomData, Unpin, Unsize};
-use core::mem::{self, forget, size_of_val};
+use core::mem::{self, forget, size_of_val, MaybeUninit};
 use core::ops::{CoerceUnsized, Deref, DispatchFromDyn, Receiver};
 use core::pin::Pin;
 use core::ptr::{self, NonNull};
@@ -853,13 +853,7 @@ impl<T: ?Sized> Rc<T> {
     /// ```
     #[stable(feature = "rc_raw", since = "1.17.0")]
     pub unsafe fn from_raw(ptr: *const T) -> Self {
-        let offset = unsafe { data_offset(ptr) };
-
-        // Reverse the offset to find the original RcBox.
-        let rc_ptr =
-            unsafe { (ptr as *mut RcBox<T>).set_ptr_value((ptr as *mut u8).offset(-offset)) };
-
-        unsafe { Self::from_ptr(rc_ptr) }
+        unsafe { Self::from_data_ptr(ptr).assume_init() }
     }
 
     /// Creates a new [`Weak`] pointer to this allocation.
@@ -1217,6 +1211,35 @@ impl<T: ?Sized> Rc<T> {
             Self::from_ptr(ptr)
         }
     }
+
+    /// # Safety
+    ///
+    /// The caller must ensure that the pointer points to the `value` field of a `Global`
+    /// allocation of type `RcBox<T>`. Depending on how the pointer was created, the
+    /// `meta` field might or might not be uninitialized. It's up to the caller to ensure
+    /// that this field is set to the correct value before the return value is unwrapped.
+    #[inline]
+    unsafe fn from_data_ptr(ptr: *const T) -> MaybeUninit<Self> {
+        let offset = unsafe { data_offset(ptr) };
+
+        // Reverse the offset to find the original RcBox.
+        let rc_ptr =
+            unsafe { (ptr as *mut RcBox<T>).set_ptr_value((ptr as *mut u8).offset(-offset)) };
+
+        unsafe { MaybeUninit::new(Self::from_ptr(rc_ptr)) }
+    }
+
+    #[inline]
+    fn from_rc_alloc_box(v: Box<T, RcAlloc>) -> Rc<T> {
+        unsafe {
+            // SAFETY: RcAlloc allocations of `T` have the same layout as Global
+            // allocations of `RcBox<T>`. We use `Self::from_raw` as a shorthand
+            let data_ptr = Box::into_raw(v);
+            let mut rc = Self::from_data_ptr(data_ptr);
+            rc.assume_init_mut().ptr.as_mut().meta = RcBoxMetadata::new_strong();
+            rc.assume_init()
+        }
+    }
 }
 
 impl<T> Rc<[T]> {
@@ -2359,3 +2382,48 @@ unsafe fn data_offset<T: ?Sized>(data_ptr: *const T) -> isize {
         RcStructAlloc::offset_of_data(data_layout) as isize
     }
 }
+
+/// A memory allocator for [`Rc`] objects.
+///
+/// This allocator behaves like the underlying allocator except that values of type
+/// [`Box<T, RcAlloc>`] can be converted to [`Rc<T>`] without copying the allocation.
+///
+/// # Example
+///
+/// ```
+/// #![feature(struct_alloc, allocator_api)]
+///
+/// use std::rc::{Rc, RcAlloc};
+///
+/// let mut contents = Vec::new_in(RcAlloc::new());
+/// contents.push(1u32);
+/// let contents: Rc<[u32]> = contents.into_boxed_slice().into();
+/// ```
+#[derive(Debug)]
+#[unstable(feature = "struct_alloc", issue = "none")]
+pub struct RcAlloc<A = Global>(StructAlloc<RcBoxMetadata, A>);
+
+#[unstable(feature = "struct_alloc", issue = "none")]
+impl RcAlloc<Global> {
+    /// Constructs a new `RcAlloc<Global>`.
+    pub fn new() -> Self {
+        Self::new_with(Global)
+    }
+}
+
+#[unstable(feature = "struct_alloc", issue = "none")]
+impl<A> RcAlloc<A> {
+    /// Constructs a new `RcAlloc<A>`.
+    pub fn new_with(alloc: A) -> Self {
+        RcAlloc(StructAlloc::new(alloc))
+    }
+}
+
+implement_struct_allocator!(RcAlloc);
+
+#[unstable(feature = "struct_alloc", issue = "none")]
+impl<T: ?Sized> From<Box<T, RcAlloc>> for Rc<T> {
+    fn from(v: Box<T, RcAlloc>) -> Self {
+        Self::from_rc_alloc_box(v)
+    }
+}

library/alloc/src/rc/tests.rs

@@ -559,3 +559,14 @@ fn test_rc_cyclic_with_two_ref() {
     assert_eq!(Rc::strong_count(&two_refs), 3);
     assert_eq!(Rc::weak_count(&two_refs), 2);
 }
+
+#[test]
+fn test_from_rc_alloc() {
+    let mut vec = Vec::new_in(RcAlloc::new());
+    vec.push(1i32);
+    let b = vec.into_boxed_slice();
+    let b_addr = &*b as *const _;
+    let rc = Rc::from(b);
+    let rc_addr = &*rc as *const _;
+    assert_eq!(b_addr, rc_addr);
+}

library/alloc/src/sync.rs

@@ -14,7 +14,7 @@ use core::hint;
 use core::intrinsics::abort;
 use core::iter;
 use core::marker::{PhantomData, Unpin, Unsize};
-use core::mem::{self, size_of_val};
+use core::mem::{self, size_of_val, MaybeUninit};
 use core::ops::{CoerceUnsized, Deref, DispatchFromDyn, Receiver};
 use core::pin::Pin;
 use core::ptr::{self, NonNull};
@@ -845,14 +845,7 @@ impl<T: ?Sized> Arc<T> {
     /// ```
     #[stable(feature = "rc_raw", since = "1.17.0")]
     pub unsafe fn from_raw(ptr: *const T) -> Self {
-        unsafe {
-            let offset = data_offset(ptr);
-
-            // Reverse the offset to find the original ArcInner.
-            let arc_ptr = (ptr as *mut ArcInner<T>).set_ptr_value((ptr as *mut u8).offset(-offset));
-
-            Self::from_ptr(arc_ptr)
-        }
+        unsafe { Self::from_data_ptr(ptr).assume_init() }
     }
 
     /// Creates a new [`Weak`] pointer to this allocation.
@@ -1155,6 +1148,34 @@ impl<T: ?Sized> Arc<T> {
             Self::from_ptr(ptr)
         }
     }
+
+    /// # Safety
+    ///
+    /// The caller must ensure that the pointer points to the `data` field of a `Global`
+    /// allocation of type `ArcInner<T>`. Depending on how the pointer was created, the
+    /// `meta` field might or might not be uninitialized. It's up to the caller to ensure
+    /// that this field is set to the correct value before the return value is unwrapped.
+    #[inline]
+    unsafe fn from_data_ptr(ptr: *const T) -> MaybeUninit<Self> {
+        unsafe {
+            let offset = data_offset(ptr);
+
+            // Reverse the offset to find the original ArcInner.
+            let arc_ptr = (ptr as *mut ArcInner<T>).set_ptr_value((ptr as *mut u8).offset(-offset));
+
+            MaybeUninit::new(Self::from_ptr(arc_ptr))
+        }
+    }
+
+    #[inline]
+    fn from_arc_alloc_box(v: Box<T, ArcAlloc>) -> Arc<T> {
+        unsafe {
+            let data_ptr = Box::into_raw(v);
+            let mut rc = Self::from_data_ptr(data_ptr);
+            rc.assume_init_mut().ptr.as_mut().meta = ArcInnerMetadata::new_strong();
+            rc.assume_init()
+        }
+    }
 }
 
 impl<T> Arc<[T]> {
@@ -2476,3 +2497,48 @@ unsafe fn data_offset<T: ?Sized>(data_ptr: *const T) -> isize {
         ArcStructAlloc::offset_of_data(data_layout) as isize
     }
 }
+
+/// A memory allocator for [`Arc`] objects.
+///
+/// This allocator behaves like the underlying allocator except that values of type
+/// [`Box<T, ArcAlloc>`] can be converted to [`Arc<T>`] without copying the allocation.
+///
+/// # Example
+///
+/// ```
+/// #![feature(struct_alloc, allocator_api)]
+///
+/// use alloc::sync::{Arc, ArcAlloc};
+///
+/// let mut contents = Vec::new_in(ArcAlloc::new());
+/// contents.push(1u32);
+/// let contents: Arc<[u32]> = contents.into_boxed_slice().into();
+/// ```
+#[derive(Debug)]
+#[unstable(feature = "struct_alloc", issue = "none")]
+pub struct ArcAlloc<A = Global>(StructAlloc<ArcInnerMetadata, A>);
+
+#[unstable(feature = "struct_alloc", issue = "none")]
+impl ArcAlloc<Global> {
+    /// Constructs a new `ArcAlloc<Global>`.
+    pub fn new() -> Self {
+        ArcAlloc(StructAlloc::new(Global))
+    }
+}
+
+#[unstable(feature = "struct_alloc", issue = "none")]
+impl<A> ArcAlloc<A> {
+    /// Constructs a new `ArcAlloc<A>`.
+    pub fn new_with(alloc: A) -> Self {
+        ArcAlloc(StructAlloc::new(alloc))
+    }
+}
+
+implement_struct_allocator!(ArcAlloc);
+
+#[unstable(feature = "struct_alloc", issue = "none")]
+impl<T: ?Sized> From<Box<T, ArcAlloc>> for Arc<T> {
+    fn from(v: Box<T, ArcAlloc>) -> Self {
+        Self::from_arc_alloc_box(v)
+    }
+}

library/alloc/src/sync/tests.rs

@@ -618,3 +618,14 @@ fn test_arc_cyclic_two_refs() {
     assert_eq!(Arc::strong_count(&two_refs), 3);
     assert_eq!(Arc::weak_count(&two_refs), 2);
 }
+
+#[test]
+fn test_from_arc_alloc() {
+    let mut vec = Vec::new_in(ArcAlloc::new());
+    vec.push(1i32);
+    let b = vec.into_boxed_slice();
+    let b_addr = &*b as *const _;
+    let rc = Arc::from(b);
+    let rc_addr = &*rc as *const _;
+    assert_eq!(b_addr, rc_addr);
+}