Implement alloc::sync::{Arc,Weak,UniqueArc} with alloc::raw_rc types

Author: EFanZh

library/alloc/src/raw_rc/raw_rc.rs

@@ -246,6 +246,16 @@ where
         self.weak.into_raw_parts()
     }
 
+    // `is_unique` only exists on `Arc`, so we need this `#[cfg(not(no_sync))]`. It can be removed
+    // if `Rc::is_unique` is added.
+    #[cfg(not(no_sync))]
+    pub(crate) unsafe fn is_unique<R>(&self) -> bool
+    where
+        R: RefCounter,
+    {
+        unsafe { is_unique::<R>(self.value_ptr()) }
+    }
+
     #[cfg(not(no_global_oom_handling))]
     pub(crate) unsafe fn make_mut<R>(&mut self) -> &mut T
     where
@@ -744,6 +754,23 @@ impl<A> RawRc<dyn Any, A> {
     }
 }
 
+#[cfg(not(no_sync))]
+impl<A> RawRc<dyn Any + Send + Sync, A> {
+    pub(crate) fn downcast<T>(self) -> Result<RawRc<T, A>, Self>
+    where
+        T: Any,
+    {
+        if self.as_ref().is::<T>() { Ok(unsafe { self.downcast_unchecked() }) } else { Err(self) }
+    }
+
+    pub(crate) unsafe fn downcast_unchecked<T>(self) -> RawRc<T, A>
+    where
+        T: Any,
+    {
+        unsafe { self.cast() }
+    }
+}
+
 impl<T, A> AsRef<T> for RawRc<T, A>
 where
     T: ?Sized,

library/alloc/src/raw_rc/raw_weak.rs

@@ -282,13 +282,19 @@ where
         !ptr::addr_eq(self.ptr.as_ptr(), other.ptr.as_ptr())
     }
 
+    /// Returns the `RefCounts` object inside the reference-counted allocation if `self` is
+    /// non-dangling.
+    #[cfg(not(no_sync))]
+    pub(crate) fn ref_counts(&self) -> Option<&RefCounts> {
+        (!is_dangling(self.ptr.cast())).then(|| unsafe { self.ref_counts_unchecked() })
+    }
+
     /// Returns the `RefCounts` object inside the reference-counted allocation, assume `self` is
     /// non-dangling.
     ///
     /// # Safety
     ///
     /// `self` is non-dangling.
-    #[cfg(not(no_global_oom_handling))]
     pub(super) unsafe fn ref_counts_unchecked(&self) -> &RefCounts {
         unsafe { self.value_ptr_unchecked().ref_counts_ptr().as_ref() }
     }

library/alloc/src/rc.rs

@@ -272,7 +272,7 @@ use crate::vec::Vec;
 
 type RefCounter = Cell<usize>;
 
-unsafe impl raw_rc::RefCounter for RefCounter {
+unsafe impl raw_rc::RefCounter for Cell<usize> {
     #[inline]
     fn increment(&self) {
         // NOTE: If you `mem::forget` `Rc`s (or `Weak`s), drop is skipped and the ref-count