thinnable 0.3.3

Thin references to unsized types.
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
148
149
150

use core::{
    convert::TryInto,
    marker::{PhantomData, Unsize},
    ops::{Deref, DerefMut},
    ptr,
};

use crate::metadata::{Metadata, MetadataCreationFailure, MetadataFor};

// repr(C) because we require a guarantee that, given some `U` and `M`, field
// offsets remain identical for all `T`.
#[repr(C)]
pub(crate) struct Real<T, U, M>
where
    T: ?Sized,
    U: ?Sized,
{
    metadata: MetadataFor<U, M>,
    data: T,
}

impl<T, U, M> Real<T, U, M>
where
    U: ?Sized,
{
    #[inline(always)]
    pub fn try_new(data: T) -> Result<Self, MetadataCreationFailure<U, M>>
    where
        T: Unsize<U>,
        Metadata<U>: TryInto<M>,
    {
        MetadataFor::try_new(&data).map(|metadata| Self { metadata, data })
    }

    /// Obtain the metadata for the DST wrapper.
    ///
    /// ### Panics
    /// This method will panic if `metadata` contains a value that cannot be
    /// converted to a `Metadata<U>`.
    #[inline(always)]
    pub fn metadata(&self) -> Metadata<U>
    where
        M: Copy + TryInto<Metadata<U>>,
    {
        self.metadata.try_get().ok().unwrap()
    }

    #[inline(always)]
    pub fn into_inner(self) -> T {
        self.data
    }
}

impl<T, U, M> Deref for Real<T, U, M>
where
    T: ?Sized,
    U: ?Sized,
{
    type Target = T;
    #[inline(always)]
    fn deref(&self) -> &T {
        &self.data
    }
}

impl<T, U, M> DerefMut for Real<T, U, M>
where
    T: ?Sized,
    U: ?Sized,
{
    #[inline(always)]
    fn deref_mut(&mut self) -> &mut T {
        &mut self.data
    }
}

#[repr(transparent)]
pub(crate) struct Fake<U: ?Sized, M>(Real<PhantomData<U>, U, M>);

/// Obtain the metadata for the DST wrapper.
///
/// ### Panics
/// This method will panic if `fake.0` contains metadata that cannot be
/// converted to a `Metadata<U>`.
#[inline(always)]
fn metadata<U, M>(fake: &Fake<U, M>) -> Metadata<Real<U, U, M>>
where
    U: ?Sized,
    M: Copy + TryInto<Metadata<U>>,
{
    let metadata = fake.0.metadata();

    // The metadata of `Real<U, _, _>` is that of its last field, `data`,
    // which has type `U`.
    //
    // `Metadata<U>` and `Metadata<Real<U, _, _>>` are therefore the same,
    // but we cannot inform the compiler of this without publicly exposing
    // `Real`; likewise for adding constraints that would enable safe
    // conversion (such as `Metadata<U>: Into<Metadata<Real<U, M>>>`).
    //
    // Instead, we simply dereference a casted raw pointer, which is
    // perfectly safe because the types are necessarily identical.
    let ptr = ptr::addr_of!(metadata).cast();
    unsafe { *ptr }
}

impl<U, M> Deref for Fake<U, M>
where
    U: ?Sized,
    M: Copy + TryInto<Metadata<U>>,
{
    type Target = Real<U, U, M>;
    #[inline(always)]
    fn deref(&self) -> &Real<U, U, M> {
        let data_address = ptr::addr_of!(self.0).cast();
        let metadata = metadata(self);
        let ptr = ptr::from_raw_parts(data_address, metadata);
        unsafe { &*ptr }
    }
}

impl<U, M> DerefMut for Fake<U, M>
where
    U: ?Sized,
    M: Copy + TryInto<Metadata<U>>,
{
    #[inline(always)]
    fn deref_mut(&mut self) -> &mut Real<U, U, M> {
        let data_address = ptr::addr_of_mut!(self.0).cast();
        let metadata = metadata(self);
        let ptr = ptr::from_raw_parts_mut(data_address, metadata);
        unsafe { &mut *ptr }
    }
}

impl<T, U: ?Sized, M> AsRef<Fake<U, M>> for Real<T, U, M> {
    #[inline(always)]
    fn as_ref(&self) -> &Fake<U, M> {
        let ptr = (self as *const Self).cast();
        unsafe { &*ptr }
    }
}

impl<T, U: ?Sized, M> AsMut<Fake<U, M>> for Real<T, U, M> {
    #[inline(always)]
    fn as_mut(&mut self) -> &mut Fake<U, M> {
        let ptr = (self as *mut Self).cast();
        unsafe { &mut *ptr }
    }
}