Add RawRc methods for MaybeUninit<T> values

Author: EFanZh

library/alloc/src/raw_rc/raw_rc.rs

@@ -5,7 +5,7 @@ use core::clone::CloneToUninit;
 use core::marker::PhantomData;
 #[cfg(not(no_global_oom_handling))]
 use core::mem;
-use core::mem::DropGuard;
+use core::mem::{DropGuard, MaybeUninit};
 #[cfg(not(no_global_oom_handling))]
 use core::ops::DerefMut;
 #[cfg(not(no_global_oom_handling))]
@@ -479,3 +479,69 @@ impl<T, A> RawRc<T, A> {
         })
     }
 }
+
+impl<T, A> RawRc<MaybeUninit<T>, A> {
+    pub(crate) fn try_new_uninit() -> Result<Self, AllocError>
+    where
+        A: Allocator + Default,
+    {
+        RawWeak::try_new_uninit::<1>().map(|weak| unsafe { Self::from_weak(weak) })
+    }
+
+    pub(crate) fn try_new_uninit_in(alloc: A) -> Result<Self, AllocError>
+    where
+        A: Allocator,
+    {
+        RawWeak::try_new_uninit_in::<1>(alloc).map(|weak| unsafe { Self::from_weak(weak) })
+    }
+
+    pub(crate) fn try_new_zeroed() -> Result<Self, AllocError>
+    where
+        A: Allocator + Default,
+    {
+        RawWeak::try_new_zeroed::<1>().map(|weak| unsafe { Self::from_weak(weak) })
+    }
+
+    pub(crate) fn try_new_zeroed_in(alloc: A) -> Result<Self, AllocError>
+    where
+        A: Allocator,
+    {
+        RawWeak::try_new_zeroed_in::<1>(alloc).map(|weak| unsafe { Self::from_weak(weak) })
+    }
+
+    #[cfg(not(no_global_oom_handling))]
+    pub(crate) fn new_uninit() -> Self
+    where
+        A: Allocator + Default,
+    {
+        unsafe { Self::from_weak(RawWeak::new_uninit::<1>()) }
+    }
+
+    #[cfg(not(no_global_oom_handling))]
+    pub(crate) fn new_uninit_in(alloc: A) -> Self
+    where
+        A: Allocator,
+    {
+        unsafe { Self::from_weak(RawWeak::new_uninit_in::<1>(alloc)) }
+    }
+
+    #[cfg(not(no_global_oom_handling))]
+    pub(crate) fn new_zeroed() -> Self
+    where
+        A: Allocator + Default,
+    {
+        unsafe { Self::from_weak(RawWeak::new_zeroed::<1>()) }
+    }
+
+    #[cfg(not(no_global_oom_handling))]
+    pub(crate) fn new_zeroed_in(alloc: A) -> Self
+    where
+        A: Allocator,
+    {
+        unsafe { Self::from_weak(RawWeak::new_zeroed_in::<1>(alloc)) }
+    }
+
+    pub(crate) unsafe fn assume_init(self) -> RawRc<T, A> {
+        unsafe { self.cast() }
+    }
+}