Add [A]RcBorrow -> Weak conversion without strong clone

Author: CAD97

Cargo.lock

@@ -1,8 +1,6 @@
 fn main() {
     let cfg = autocfg::new();
-    cfg.emit_expression_cfg("std::sync::Arc::as_raw", "has_Arc__into_raw");
-    cfg.emit_expression_cfg("std::sync::Arc::clone_raw", "has_Arc__clone_raw");
-    cfg.emit_expression_cfg("std::rc::Rc::as_raw", "has_Rc__into_raw");
-    cfg.emit_expression_cfg("std::rc::Rc::clone_raw", "has_Rc__clone_raw");
+    cfg.emit_expression_cfg("std::sync::Arc::as_ptr", "has_Arc__as_ptr");
+    cfg.emit_expression_cfg("std::rc::Rc::as_ptr", "has_Rc__as_ptr");
     autocfg::rerun_path("build.rs");
 }

crates/rc-borrow/build.rs

@@ -35,7 +35,10 @@ use std::{
     panic::{RefUnwindSafe, UnwindSafe},
 };
 use {
-    alloc::{rc::Rc, sync::Arc},
+    alloc::{
+        rc::{self, Rc},
+        sync::{self, Arc},
+    },
     core::{
         borrow::Borrow,
         cmp::Ordering,
@@ -55,59 +58,68 @@ use {
 /// See https://internals.rust-lang.org/t/_/11463/11 for why these are important.
 /// By using a trait here, we can more easily switch when these functions are available.
 trait RawRc<T: ?Sized> {
+    type Weak;
+
     //noinspection RsSelfConvention
     fn as_raw(this: &Self) -> *const T;
+
     /// # Safety
     ///
     /// This pointer must have come from [`RawRc::as_raw`] or `into_raw`.
     unsafe fn clone_raw(this: *const T) -> Self;
+
+    unsafe fn downgrade_raw(this: *const T) -> Self::Weak;
 }
 
 impl<T: ?Sized> RawRc<T> for Arc<T> {
+    type Weak = sync::Weak<T>;
+
     #[rustfmt::skip]
     #[inline(always)]
     fn as_raw(this: &Self) -> *const T {
-        #[cfg(not(has_Arc__as_raw))] {
+        #[cfg(not(has_Arc__as_ptr))] {
             Arc::into_raw(unsafe { ptr::read(this) })
         }
         #[cfg(has_Arc__as_raw)] {
-            Arc::as_raw(this)
+            Arc::as_ptr(this)
         }
     }
 
-    #[rustfmt::skip]
     #[inline(always)]
     unsafe fn clone_raw(this: *const T) -> Self {
-        #[cfg(not(has_Arc__clone_raw))] {
-            Arc::clone(&ManuallyDrop::new(Arc::from_raw(this)))
-        }
-        #[cfg(has_Arc__clone_raw)] {
-            Arc::clone_raw(this)
-        }
+        Arc::clone(&ManuallyDrop::new(Arc::from_raw(this)))
+    }
+
+    #[inline(always)]
+    unsafe fn downgrade_raw(this: *const T) -> sync::Weak<T> {
+        let this = ManuallyDrop::new(Arc::from_raw(this));
+        Arc::downgrade(&this)
     }
 }
 
 impl<T: ?Sized> RawRc<T> for Rc<T> {
+    type Weak = rc::Weak<T>;
+
     #[rustfmt::skip]
     #[inline(always)]
     fn as_raw(this: &Self) -> *const T {
-        #[cfg(not(has_Rc__as_raw))] {
+        #[cfg(not(has_Rc__as_ptr))] {
             Rc::into_raw(unsafe { ptr::read(this) })
         }
-        #[cfg(has_Rc__as_raw)] {
-            Rc::as_raw(this)
+        #[cfg(has_Rc__as_ptr)] {
+            Rc::as_ptr(this)
         }
     }
 
-    #[rustfmt::skip]
     #[inline(always)]
     unsafe fn clone_raw(this: *const T) -> Self {
-        #[cfg(not(has_Rc__clone_raw))] {
-            Rc::clone(&ManuallyDrop::new(Rc::from_raw(this)))
-        }
-        #[cfg(has_Rc__clone_raw)] {
-            Rc::clone_raw(this)
-        }
+        Rc::clone(&ManuallyDrop::new(Rc::from_raw(this)))
+    }
+
+    #[inline(always)]
+    unsafe fn downgrade_raw(this: *const T) -> rc::Weak<T> {
+        let this = ManuallyDrop::new(Rc::from_raw(this));
+        Rc::downgrade(&this)
     }
 }
 
@@ -120,7 +132,7 @@ macro_rules! doc_comment {
 }
 
 macro_rules! rc_borrow {
-    ($($(#[$m:meta])* $vis:vis struct $RcBorrow:ident = &$Rc:ident;)*) => {$(
+    ($($(#[$m:meta])* $vis:vis struct $RcBorrow:ident = &$Rc:ident ($rc:ident);)*) => {$(
         $(#[$m])*
         $vis struct $RcBorrow<'a, T: ?Sized> {
             raw: ptr::NonNull<T>,
@@ -147,6 +159,11 @@ macro_rules! rc_borrow {
                 unsafe { <$Rc<T> as RawRc<T>>::clone_raw(this.raw.as_ptr()) }
             }
 
+            /// Convert this borrowed pointer into a weak pointer.
+            $vis fn weaken(this: Self) -> $rc::Weak<T> {
+                unsafe { <$Rc<T> as RawRc<T>>::downgrade_raw(this.raw.as_ptr()) }
+            }
+
             /// Convert this borrowed pointer into a standard reference.
             ///
             /// This gives you a long-lived reference,
@@ -377,10 +394,10 @@ rc_borrow! {
     ///
     /// This type is guaranteed to have the same repr as `&T`.
     #[repr(transparent)]
-    pub struct ArcBorrow = &Arc;
+    pub struct ArcBorrow = &Arc (sync);
     /// Borrowed version of [`Rc`].
     ///
     /// This type is guaranteed to have the same repr as `&T`.
     #[repr(transparent)]
-    pub struct RcBorrow = &Rc;
+    pub struct RcBorrow = &Rc (rc);
 }