Add RawUniqueRc type

Author: EFanZh

library/alloc/src/raw_rc/mod.rs

@@ -67,6 +67,7 @@ use core::mem;
 use core::sync::atomic::Atomic;
 
 mod raw_rc;
+mod raw_unique_rc;
 mod raw_weak;
 mod rc_alloc;
 mod rc_layout;

library/alloc/src/raw_rc/raw_unique_rc.rs

@@ -0,0 +1,75 @@
+use core::alloc::Allocator;
+use core::marker::PhantomData;
+
+use crate::raw_rc::RefCounter;
+use crate::raw_rc::raw_rc::RawRc;
+use crate::raw_rc::raw_weak::RawWeak;
+use crate::raw_rc::rc_value_pointer::RcValuePointer;
+
+/// A uniquely owned `RawRc` that allows multiple weak references but only one strong reference.
+/// `RawUniqueRc` does not implement `Drop`, user should call `RawUniqueRc::drop` manually to drop
+/// this object.
+#[repr(transparent)]
+pub(crate) struct RawUniqueRc<T, A>
+where
+    T: ?Sized,
+{
+    // A `RawUniqueRc` is just a non-danging `RawWeak` that has zero strong count but with the value
+    // initialized.
+    weak: RawWeak<T, A>,
+
+    // Defines the ownership of `T` for drop-check.
+    _marker: PhantomData<T>,
+
+    // Invariance is necessary for soundness: once other `RawWeak` references exist, we already have
+    // a form of shared mutability!
+    _marker2: PhantomData<*mut T>,
+}
+
+impl<T, A> RawUniqueRc<T, A>
+where
+    T: ?Sized,
+{
+    /// Increments the weak count and returns the corresponding `RawWeak` object.
+    ///
+    /// # Safety
+    ///
+    /// - `self`, derived `RawWeak` or `RawRc` should only be handled by the same `RefCounter`
+    ///   implementation.
+    pub(crate) unsafe fn downgrade<R>(&self) -> RawWeak<T, A>
+    where
+        A: Clone,
+        R: RefCounter,
+    {
+        // SAFETY: Caller guarantees we only use the same `Rc` implementation and `self.weak`
+        // is never dangling.
+        unsafe { self.weak.clone_unchecked::<R>() }
+    }
+
+    pub(crate) unsafe fn drop<R>(&mut self)
+    where
+        A: Allocator,
+        R: RefCounter,
+    {
+        unsafe { self.weak.assume_init_drop::<R>() };
+    }
+
+    pub(crate) unsafe fn into_rc<R>(self) -> RawRc<T, A>
+    where
+        R: RefCounter,
+    {
+        unsafe fn inner<R>(value_ptr: RcValuePointer)
+        where
+            R: RefCounter,
+        {
+            unsafe { R::from_raw_counter(value_ptr.strong_count_ptr().as_ref()) }
+                .unlock_strong_count();
+        }
+
+        unsafe {
+            inner::<R>(self.weak.value_ptr_unchecked());
+
+            RawRc::from_weak(self.weak)
+        }
+    }
+}