Refactor

Author: EFanZh

library/alloc/src/lib.rs

@@ -102,12 +102,10 @@
 #![feature(assert_matches)]
 #![feature(async_fn_traits)]
 #![feature(async_iterator)]
-#![feature(box_as_ptr)]
 #![feature(box_uninit_write)]
 #![feature(clone_to_uninit)]
 #![feature(coerce_unsized)]
 #![feature(const_alloc_layout)]
-#![feature(const_box)]
 #![feature(const_eval_select)]
 #![feature(const_heap)]
 #![feature(core_intrinsics)]

library/alloc/src/raw_rc.rs

@@ -15,8 +15,6 @@ use core::num::NonZeroUsize;
 use core::ops::{CoerceUnsized, DispatchFromDyn};
 use core::pin::PinCoerceUnsized;
 use core::ptr::{self, NonNull};
-#[cfg(not(no_global_oom_handling))]
-use core::slice;
 
 #[cfg(not(no_global_oom_handling))]
 use crate::alloc;
@@ -165,6 +163,30 @@ where
     }
 }
 
+#[cfg(not(no_global_oom_handling))]
+#[track_caller]
+unsafe fn allocate_for_rc_with_value<T, A, const STRONG_COUNT: usize>(
+    value: &T,
+    alloc: &A,
+) -> NonNull<T>
+where
+    A: Allocator,
+    T: ?Sized,
+{
+    unsafe {
+        let rc_layout = RcLayout::from_value_ptr(NonNull::from(value));
+        let ptr = allocate_for_rc::<A, _, STRONG_COUNT>(alloc, A::allocate, &rc_layout);
+
+        ptr::copy_nonoverlapping::<u8>(
+            ptr::from_ref(value).cast(),
+            ptr.as_ptr().cast(),
+            mem::size_of_val(value),
+        );
+
+        NonNull::new_unchecked(ptr.as_ptr().with_metadata_of(value))
+    }
+}
+
 fn try_allocate_uninit_for_rc<A, const STRONG_COUNT: usize>(
     alloc: &A,
     rc_layout: &RcLayout,
@@ -686,30 +708,6 @@ where
         unsafe { Self::from_weak(RawWeak::from_raw_parts(ptr, alloc)) }
     }
 
-    #[cfg(not(no_global_oom_handling))]
-    fn from_box(value: Box<T, A>) -> Self
-    where
-        A: Allocator,
-    {
-        unsafe {
-            let box_ptr = Box::as_ptr(&value);
-            let rc_layout = RcLayout::from_value_ptr(NonNull::new_unchecked(box_ptr.cast_mut()));
-            let rc_ptr = allocate_uninit_for_rc::<A, 1>(&Box::allocator(&value), &rc_layout);
-            let value_size = mem::size_of_val_raw(box_ptr);
-
-            ptr::copy_nonoverlapping::<u8>(box_ptr.cast(), rc_ptr.as_ptr().cast(), value_size);
-
-            let alloc = Box::into_non_null_with_allocator(value).1;
-
-            drop(Box::from_raw_in(box_ptr as *mut ManuallyDrop<T>, &alloc));
-
-            Self::from_raw_parts(
-                NonNull::new_unchecked(rc_ptr.as_ptr().with_metadata_of(box_ptr)),
-                alloc,
-            )
-        }
-    }
-
     pub unsafe fn from_raw(ptr: NonNull<T>) -> Self
     where
         A: Default,
@@ -859,9 +857,9 @@ where
 
             mem::forget(guard);
 
-            *ptr_ref = NonNull::new_unchecked(new_ptr.as_ptr().with_metadata_of(ptr.as_ptr()));
-
             RawRc::from_raw_parts(ptr, &*alloc).drop::<R>();
+
+            *ptr_ref = NonNull::new_unchecked(new_ptr.as_ptr().with_metadata_of(ptr.as_ptr()));
         }
     }
 
@@ -875,15 +873,11 @@ where
         let ptr = *ptr_ref;
 
         unsafe {
-            let rc_layout = RcLayout::from_value_ptr(ptr);
-            let new_ptr = allocate_uninit_for_rc::<A, 1>(alloc, &rc_layout);
-            let length = mem::size_of_val_raw(ptr.as_ptr());
-
-            ptr::copy_nonoverlapping::<u8>(ptr.as_ptr().cast(), new_ptr.as_ptr().cast(), length);
-
-            *ptr_ref = NonNull::new_unchecked(new_ptr.as_ptr().with_metadata_of(ptr.as_ptr()));
+            let new_ptr = allocate_for_rc_with_value::<T, A, 1>(ptr.as_ref(), alloc);
 
             RawWeak::from_raw_parts(ptr, &*alloc).drop_unchecked::<R>();
+
+            *ptr_ref = new_ptr;
         }
     }
 
@@ -1168,34 +1162,6 @@ impl<T, A> RawRc<[T], A> {
             uninit_rc.assume_init()
         }
     }
-
-    #[cfg(not(no_global_oom_handling))]
-    #[track_caller]
-    unsafe fn from_slice_copy_in(slice: &[T], alloc: A) -> Self
-    where
-        A: Allocator,
-    {
-        let uninit_rc = RawRc::new_uninit_slice_in(slice.len(), alloc);
-
-        unsafe {
-            ptr::copy_nonoverlapping::<T>(
-                slice.as_ptr(),
-                uninit_rc.as_ptr().as_ptr().cast(),
-                slice.len(),
-            );
-
-            uninit_rc.assume_init()
-        }
-    }
-
-    #[cfg(not(no_global_oom_handling))]
-    #[track_caller]
-    unsafe fn from_slice_copy(slice: &[T]) -> Self
-    where
-        A: Allocator + Default,
-    {
-        unsafe { Self::from_slice_copy_in(slice, A::default()) }
-    }
 }
 
 impl<T, A> RawRc<[MaybeUninit<T>], A> {
@@ -1562,7 +1528,17 @@ where
     A: Allocator,
 {
     fn from(value: Box<T, A>) -> Self {
-        Self::from_box(value)
+        let value_ref = &*value;
+        let alloc_ref = Box::allocator(&value);
+
+        unsafe {
+            let rc_ptr = allocate_for_rc_with_value::<T, A, 1>(value_ref, alloc_ref);
+            let (box_ptr, alloc) = Box::into_raw_with_allocator(value);
+
+            drop(Box::from_raw_in(box_ptr as *mut ManuallyDrop<T>, &alloc));
+
+            Self::from_raw_parts(rc_ptr, alloc)
+        }
     }
 }
 
@@ -1589,7 +1565,12 @@ where
     T: Copy,
 {
     default fn spec_from_slice(slice: &[T]) -> Self {
-        unsafe { RawRc::from_slice_copy(slice) }
+        unsafe {
+            let alloc = A::default();
+            let ptr = allocate_for_rc_with_value::<[T], A, 1>(slice, &alloc);
+
+            Self::from_raw_parts(ptr, alloc)
+        }
     }
 }
 
@@ -1668,12 +1649,17 @@ where
     A: Allocator,
 {
     fn from(value: Vec<T, A>) -> Self {
-        let (ptr, length, capacity, alloc) = value.into_raw_parts_with_alloc();
-        let rc = unsafe { RawRc::from_slice_copy_in(slice::from_raw_parts(ptr, length), alloc) };
+        let value_ref = &*value;
+        let alloc_ref = value.allocator();
+
+        unsafe {
+            let rc_ptr = allocate_for_rc_with_value::<[T], A, 1>(value_ref, alloc_ref);
+            let (vec_ptr, _length, capacity, alloc) = value.into_raw_parts_with_alloc();
 
-        drop(unsafe { Vec::from_raw_parts_in(ptr, 0, capacity, rc.allocator()) });
+            drop(Vec::from_raw_parts_in(vec_ptr, 0, capacity, &alloc));
 
-        rc
+            Self::from_raw_parts(rc_ptr, alloc)
+        }
     }
 }
 

library/alloc/src/rc/tests.rs

@@ -2,7 +2,6 @@ use std::cell::RefCell;
 use std::clone::Clone;
 
 use super::*;
-use crate::raw_rc::RcOps as _;
 
 #[test]
 fn test_clone() {
@@ -62,20 +61,25 @@ fn weak_self_cyclic() {
 
 #[test]
 fn is_unique() {
-    fn is_unique_impl(rc: &Rc<i32>) -> bool {
-        unsafe { RcOps::is_unique(rc.raw_rc.strong_count(), rc.raw_rc.weak_count()) }
+    fn rc_is_unique(rc: &Rc<i32>) -> bool {
+        unsafe {
+            <RcOps as crate::raw_rc::RcOps>::is_unique(
+                rc.raw_rc.strong_count(),
+                rc.raw_rc.weak_count(),
+            )
+        }
     }
 
     let x = Rc::new(3);
-    assert!(is_unique_impl(&x));
+    assert!(rc_is_unique(&x));
     let y = x.clone();
-    assert!(!is_unique_impl(&x));
+    assert!(!rc_is_unique(&x));
     drop(y);
-    assert!(is_unique_impl(&x));
+    assert!(rc_is_unique(&x));
     let w = Rc::downgrade(&x);
-    assert!(!is_unique_impl(&x));
+    assert!(!rc_is_unique(&x));
     drop(w);
-    assert!(is_unique_impl(&x));
+    assert!(rc_is_unique(&x));
 }
 
 #[test]
@@ -214,21 +218,11 @@ fn into_from_weak_raw() {
     unsafe {
         assert_eq!(**y_ptr, "hello");
 
-        dbg!(Rc::strong_count(&x));
-
         let y = Weak::from_raw(y_ptr);
-
-        dbg!(Rc::strong_count(&x));
-
         let y_up = Weak::upgrade(&y).unwrap();
         assert_eq!(**y_up, "hello");
-
-        dbg!(Rc::strong_count(&x));
-
         drop(y_up);
 
-        dbg!(Rc::strong_count(&x));
-
         assert_eq!(Rc::try_unwrap(x).map(|x| *x), Ok("hello"));
     }
 }