feat: support strict provenance and use it for fat pointer coercion

Author: CertainLach

src/cc.rs

@@ -78,6 +78,7 @@ pub type Cc<T> = RawCc<T, ObjectSpace>;
 pub type Weak<T> = RawWeak<T, ObjectSpace>;
 
 /// Low-level type for [`Cc<T>`](type.Cc.html).
+#[repr(transparent)]
 pub struct RawCc<T: ?Sized, O: AbstractObjectSpace>(NonNull<RawCcBox<T, O>>);
 
 /// Low-level type for [`Weak<T>`](type.Weak.html).
@@ -225,9 +226,8 @@ impl<T: Trace, O: AbstractObjectSpace> RawCc<T, O> {
             // Cc<dyn Trace> has 2 usize values: The first one is the same
             // as Cc<T>. The second one is the vtable. The vtable pointer
             // is the same as the second pointer of `&dyn Trace`.
-            let mut fat_ptr: [usize; 2] = mem::transmute(self.inner().deref() as &dyn Trace);
-            let self_ptr: usize = mem::transmute(self);
-            fat_ptr[0] = self_ptr;
+            let fat_ptr: *const dyn Trace = &**self.inner();
+            let fat_ptr = fat_ptr.with_addr(mem::transmute::<RawCc<T, O>, usize>(self));
             mem::transmute(fat_ptr)
         }
     }
@@ -236,11 +236,15 @@ impl<T: Trace, O: AbstractObjectSpace> RawCc<T, O> {
 /// Create Cc<dyn Trait> from Cc<T> where T: impl Trait, Trait is trait object
 #[macro_export]
 macro_rules! cc_dyn {
-    ($(#[$($meta:meta)+])* $conv:ident, $t:path $(, $new_vis:vis fn new() {...})?) => {
+    (
+        $(#[$($meta:meta)+])*
+        $conv:ident $(<$($gen:ident $(: $($gen_bound:path),+)?),+>)?,
+        $t:path $(, $new_vis:vis fn new() {...})?
+    ) => {
         $(#[$($meta)+])*
         #[repr(transparent)]
-        pub struct $conv($crate::Cc<dyn $t>);
-        impl $crate::Trace for $conv {
+        pub struct $conv$(<$($gen),+>)?($crate::Cc<dyn $t>);
+        impl$(<$($gen: 'static),+>)? $crate::Trace for $conv$(<$($gen),+>)? {
             fn trace(&self, tracer: &mut $crate::Tracer) {
                 $crate::Cc::<dyn $t>::trace(&self.0, tracer)
             }
@@ -250,17 +254,14 @@ macro_rules! cc_dyn {
                 true
             }
         }
-        impl $conv {
+        impl$(<$($gen $(: $($gen_bound),+)?),+>)? $conv$(<$($gen),+>)? {
             $($new_vis)? fn new<T: $t + $crate::Trace>(input: T) -> Self {
-                use std::ops::Deref;
-                unsafe {
-                    let cc: $crate::RawCc<_, _> = $crate::Cc::new(input);
-                    let mut fat_ptr: [usize; 2] =
-                        core::mem::transmute(cc.inner().deref() as &dyn $t);
-                    let self_ptr: usize = core::mem::transmute(cc);
-                    fat_ptr[0] = self_ptr;
-                    $conv(core::mem::transmute::<[usize; 2], $crate::RawCc<dyn $t, _>>(fat_ptr))
-                }
+                let cc: $crate::RawCc<_, _> = $crate::Cc::new(input);
+                let ptr: *const dyn $t = &**cc.inner();
+                let ptr = unsafe {
+                    ptr.with_addr(core::mem::transmute::<$crate::RawCc<T, _>, usize>(cc))
+                };
+                $conv(unsafe {core::mem::transmute::<*const dyn $t, $crate::RawCc<dyn $t, _>>(ptr)})
             }
         }
     };

src/collect.rs

@@ -293,7 +293,7 @@ const PREV_SHIFT: u32 = 2;
 
 #[inline]
 fn unmask_ptr<T>(ptr: *const T) -> *const T {
-    ((ptr as usize) & PTR_MASK) as *const T
+    ptr.map_addr(|ptr| ptr & PTR_MASK)
 }
 
 /// Temporarily use `GcHeader.prev` as `gc_ref_count`.

src/lib.rs

@@ -379,11 +379,10 @@ pub mod interop {
 
 #[cfg(test)]
 mod dyn_cc {
-    use crate::Trace;
+    use crate::{dyn_cc, Trace};
     use std::fmt::Debug;
-    use std::ops::Deref;
 
-    use crate::{cc_dyn, Cc};
+    use crate::cc_dyn;
 
     #[derive(Debug, Trace)]
     struct Test {
@@ -392,25 +391,56 @@ mod dyn_cc {
 
     trait DebugAndTrace: Debug + Trace {}
     impl<T> DebugAndTrace for T where T: Debug + Trace {}
-    cc_dyn!(CcDebugAndTrace, DebugAndTrace);
+    cc_dyn!(
+        #[derive(Debug)]
+        CcDebugAndTrace,
+        DebugAndTrace
+    );
+
+    trait BorrowTy<O> {
+        fn borrow_ty(&self) -> &O;
+    }
+    cc_dyn!(CcBorrowTy<O>, BorrowTy<O>);
+    cc_dyn!(
+        CcBorrowTyAlsoDebug<O: Debug>,
+        BorrowTy<O>
+    );
+
+    #[derive(Trace)]
+    struct Borrowable<T: Trace> {
+        v: T,
+    }
+    impl<T: Trace> BorrowTy<T> for Borrowable<T> {
+        fn borrow_ty(&self) -> &T {
+            &self.v
+        }
+    }
 
     #[test]
     fn test_dyn() {
         let test = Test {
             a: "hello".to_owned(),
         };
 
+        let dynccgeneric = CcBorrowTy::new(Borrowable { v: 1u32 });
+        let v = dynccgeneric.0.borrow_ty();
+        assert_eq!(*v, 1);
+
+        let dynccgeneric = CcBorrowTyAlsoDebug::new(Borrowable { v: 1u32 });
+        let v = dynccgeneric.0.borrow_ty();
+        assert_eq!(*v, 1);
+
         let dyncc = CcDebugAndTrace::new(test);
-        assert_eq!(format!("{dyncc:?}"), "Cc(Test { a: \"hello\" })");
+        assert_eq!(format!("{dyncc:?}"), "CcDebugAndTrace(Cc(Test { a: \"hello\" }))");
         let dyncc_is_trace = dyncc;
         assert_eq!(
             format!("{dyncc_is_trace:?}"),
-            "Cc(Cc(Test { a: \"hello\" }))"
+            "CcDebugAndTrace(Cc(Test { a: \"hello\" }))"
         );
         let dyncc_is_trace_as_dyn = CcDebugAndTrace::new(dyncc_is_trace);
         assert_eq!(
             format!("{dyncc_is_trace_as_dyn:?}"),
-            "Cc(Cc(Test { a: \"hello\" }))"
+            "CcDebugAndTrace(Cc(CcDebugAndTrace(Cc(Test { a: \"hello\" }))))"
         );
     }
 }

src/ref_count.rs

@@ -40,6 +40,7 @@ pub trait RefCount: 'static {
     fn weak_count(&self) -> usize;
 }
 
+#[repr(C)]
 pub struct SingleThreadRefCount(Cell<usize>, Cell<usize>);
 
 impl SingleThreadRefCount {