dyn-ptr 0.2.3

A box that stores types like pointers, forgetting everything besides `Self: Unsize<dyn Trait>`
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

#![no_std]
#![cfg_attr(feature = "any-ptr", allow(incomplete_features))]
#![cfg_attr(feature = "any-ptr", feature(generic_const_exprs, specialization))]
#![feature(unsize, ptr_metadata, exact_size_is_empty, trivial_bounds)]
//#![feature(specialization)]

#[cfg(not(feature = "any-ptr"))]
extern crate alloc;

mod impls;

#[cfg(not(feature = "any-ptr"))]
use alloc::boxed::Box;
use core::{
    marker::Unsize,
    mem::{self, ManuallyDrop},
    ops::{Deref, DerefMut},
    ptr::{self, Pointee},
};

#[repr(transparent)]
#[derive(Copy, Clone)]
pub struct PtrRepr(pub(self) *const ());

pub unsafe fn faith_metadata<Ptr, Dyn: ?Sized>(val: Ptr) -> (PtrRepr, <Dyn as Pointee>::Metadata)
where
    Ptr: Unsize<Dyn>,
{
    let val = &*ManuallyDrop::new(val);
    (mem::transmute_copy(val), ptr::metadata(val as *const Dyn))
}

pub trait PointerLike<Dyn: ?Sized>: Sized {
    fn meta_repr(self) -> (PtrRepr, <Dyn as Pointee>::Metadata);

    fn do_dyn(self) -> DynPtr<Dyn>
    where
        Self: Unsize<Dyn>,
    {
        // SAFETY: ...
        unsafe { DynPtr::from_parts(faith_metadata::<_, Dyn>(self)) }
    }
}

struct AlignOf<const N: usize>;
struct SizeOf<const N: usize>;

trait SamePtr {}

impl SamePtr for SizeOf<{ mem::size_of::<PtrRepr>() }> {}
impl SamePtr for AlignOf<{ mem::align_of::<PtrRepr>() }> {}

#[cfg(feature = "any-ptr")]
impl<Ptr, Dyn: ?Sized> PointerLike<Dyn> for Ptr
where
    Ptr: Unsize<Dyn>,
    SizeOf<{ mem::size_of::<Ptr>() }>: SamePtr,
    AlignOf<{ mem::align_of::<Ptr>() }>: SamePtr,
{
    fn meta_repr(self) -> (PtrRepr, <Dyn as Pointee>::Metadata) {
        // SAFETY: `Ptr` has repr same as `ReprPtr` (aka `*const ()`)
        unsafe { faith_metadata::<_, Dyn>(self) }
    }
}

#[cfg(not(feature = "any-ptr"))]
impl<T, Dyn: ?Sized> PointerLike<Dyn> for Box<T>
where
    Self: Unsize<Dyn>,
{
    fn meta_repr(self) -> (PtrRepr, <Dyn as Pointee>::Metadata) {
        unsafe { faith_metadata::<_, Dyn>(self) }
    }
}

#[cfg(not(feature = "any-ptr"))]
impl<Dyn: ?Sized> PointerLike<Dyn> for *const ()
where
    Self: Unsize<Dyn>,
{
    fn meta_repr(self) -> (PtrRepr, <Dyn as Pointee>::Metadata) {
        unsafe { faith_metadata::<_, Dyn>(self) }
    }
}

#[cfg(not(feature = "any-ptr"))]
impl<Dyn: ?Sized> PointerLike<Dyn> for usize
where
    Self: Unsize<Dyn>,
{
    fn meta_repr(self) -> (PtrRepr, <Dyn as Pointee>::Metadata) {
        unsafe { faith_metadata::<_, Dyn>(self) }
    }
}

#[repr(C)]
pub struct DynPtr<Dyn: ?Sized> {
    repr: PtrRepr,
    meta: <Dyn as Pointee>::Metadata,
}

unsafe impl<Dyn: ?Sized + Sync> Sync for DynPtr<Dyn> {}
unsafe impl<Dyn: ?Sized + Send> Send for DynPtr<Dyn> {}

impl<Dyn: ?Sized> DynPtr<Dyn> {
    pub fn new<T>(val: T) -> Self
    where
        T: PointerLike<Dyn>,
    {
        // SAFETY: `T` is guaranty has repr like pointer
        unsafe { Self::from_parts(val.meta_repr()) }
    }

    pub unsafe fn from_parts((repr, meta): (PtrRepr, <Dyn as Pointee>::Metadata)) -> Self {
        Self { repr, meta }
    }

    fn const_ptr(&self) -> *const Dyn {
        ptr::from_raw_parts(ptr::addr_of!(self.repr).cast(), self.meta)
    }

    fn mut_ptr(&mut self) -> *mut Dyn {
        ptr::from_raw_parts_mut(ptr::addr_of_mut!(self.repr).cast(), self.meta)
    }
}

impl<Dyn: ?Sized> Deref for DynPtr<Dyn> {
    type Target = Dyn;

    fn deref(&self) -> &Self::Target {
        unsafe { &*self.const_ptr() }
    }
}

impl<Dyn: ?Sized> DerefMut for DynPtr<Dyn> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        unsafe { &mut *self.mut_ptr() }
    }
}

impl<Dyn: ?Sized> Drop for DynPtr<Dyn> {
    fn drop(&mut self) {
        unsafe { ptr::drop_in_place(self.mut_ptr()) }
    }
}

pub type Dyn<Trait> = DynPtr<Trait>;