pin_init/
alloc.rs

1// SPDX-License-Identifier: Apache-2.0 OR MIT
2
3#[cfg(all(feature = "alloc", not(feature = "std")))]
4use alloc::{boxed::Box, sync::Arc};
5#[cfg(feature = "alloc")]
6use core::alloc::AllocError;
7use core::{mem::MaybeUninit, pin::Pin};
8#[cfg(feature = "std")]
9use std::sync::Arc;
10
11#[cfg(not(feature = "alloc"))]
12type AllocError = core::convert::Infallible;
13
14use crate::{
15    init_from_closure, pin_init_from_closure, InPlaceWrite, Init, PinInit, ZeroableOption,
16};
17
18pub extern crate alloc;
19
20// SAFETY: All zeros is equivalent to `None` (option layout optimization guarantee).
21//
22// In this case we are allowed to use `T: ?Sized`, since all zeros is the `None` variant and there
23// is no problem with a VTABLE pointer being null.
24unsafe impl<T: ?Sized> ZeroableOption for Box<T> {}
25
26/// Smart pointer that can initialize memory in-place.
27pub trait InPlaceInit<T>: Sized {
28    /// Use the given pin-initializer to pin-initialize a `T` inside of a new smart pointer of this
29    /// type.
30    ///
31    /// If `T: !Unpin` it will not be able to move afterwards.
32    fn try_pin_init<E>(init: impl PinInit<T, E>) -> Result<Pin<Self>, E>
33    where
34        E: From<AllocError>;
35
36    /// Use the given pin-initializer to pin-initialize a `T` inside of a new smart pointer of this
37    /// type.
38    ///
39    /// If `T: !Unpin` it will not be able to move afterwards.
40    fn pin_init(init: impl PinInit<T>) -> Result<Pin<Self>, AllocError> {
41        // SAFETY: We delegate to `init` and only change the error type.
42        let init = unsafe {
43            pin_init_from_closure(|slot| match init.__pinned_init(slot) {
44                Ok(()) => Ok(()),
45                Err(i) => match i {},
46            })
47        };
48        Self::try_pin_init(init)
49    }
50
51    /// Use the given initializer to in-place initialize a `T`.
52    fn try_init<E>(init: impl Init<T, E>) -> Result<Self, E>
53    where
54        E: From<AllocError>;
55
56    /// Use the given initializer to in-place initialize a `T`.
57    fn init(init: impl Init<T>) -> Result<Self, AllocError> {
58        // SAFETY: We delegate to `init` and only change the error type.
59        let init = unsafe {
60            init_from_closure(|slot| match init.__init(slot) {
61                Ok(()) => Ok(()),
62                Err(i) => match i {},
63            })
64        };
65        Self::try_init(init)
66    }
67}
68
69#[cfg(feature = "alloc")]
70macro_rules! try_new_uninit {
71    ($type:ident) => {
72        $type::try_new_uninit()?
73    };
74}
75#[cfg(all(feature = "std", not(feature = "alloc")))]
76macro_rules! try_new_uninit {
77    ($type:ident) => {
78        $type::new_uninit()
79    };
80}
81
82impl<T> InPlaceInit<T> for Box<T> {
83    #[inline]
84    fn try_pin_init<E>(init: impl PinInit<T, E>) -> Result<Pin<Self>, E>
85    where
86        E: From<AllocError>,
87    {
88        try_new_uninit!(Box).write_pin_init(init)
89    }
90
91    #[inline]
92    fn try_init<E>(init: impl Init<T, E>) -> Result<Self, E>
93    where
94        E: From<AllocError>,
95    {
96        try_new_uninit!(Box).write_init(init)
97    }
98}
99
100impl<T> InPlaceInit<T> for Arc<T> {
101    #[inline]
102    fn try_pin_init<E>(init: impl PinInit<T, E>) -> Result<Pin<Self>, E>
103    where
104        E: From<AllocError>,
105    {
106        let mut this = try_new_uninit!(Arc);
107        let Some(slot) = Arc::get_mut(&mut this) else {
108            // SAFETY: the Arc has just been created and has no external references
109            unsafe { core::hint::unreachable_unchecked() }
110        };
111        let slot = slot.as_mut_ptr();
112        // SAFETY: When init errors/panics, slot will get deallocated but not dropped,
113        // slot is valid and will not be moved, because we pin it later.
114        unsafe { init.__pinned_init(slot)? };
115        // SAFETY: All fields have been initialized and this is the only `Arc` to that data.
116        Ok(unsafe { Pin::new_unchecked(this.assume_init()) })
117    }
118
119    #[inline]
120    fn try_init<E>(init: impl Init<T, E>) -> Result<Self, E>
121    where
122        E: From<AllocError>,
123    {
124        let mut this = try_new_uninit!(Arc);
125        let Some(slot) = Arc::get_mut(&mut this) else {
126            // SAFETY: the Arc has just been created and has no external references
127            unsafe { core::hint::unreachable_unchecked() }
128        };
129        let slot = slot.as_mut_ptr();
130        // SAFETY: When init errors/panics, slot will get deallocated but not dropped,
131        // slot is valid.
132        unsafe { init.__init(slot)? };
133        // SAFETY: All fields have been initialized.
134        Ok(unsafe { this.assume_init() })
135    }
136}
137
138impl<T> InPlaceWrite<T> for Box<MaybeUninit<T>> {
139    type Initialized = Box<T>;
140
141    fn write_init<E>(mut self, init: impl Init<T, E>) -> Result<Self::Initialized, E> {
142        let slot = self.as_mut_ptr();
143        // SAFETY: When init errors/panics, slot will get deallocated but not dropped,
144        // slot is valid.
145        unsafe { init.__init(slot)? };
146        // SAFETY: All fields have been initialized.
147        Ok(unsafe { self.assume_init() })
148    }
149
150    fn write_pin_init<E>(mut self, init: impl PinInit<T, E>) -> Result<Pin<Self::Initialized>, E> {
151        let slot = self.as_mut_ptr();
152        // SAFETY: When init errors/panics, slot will get deallocated but not dropped,
153        // slot is valid and will not be moved, because we pin it later.
154        unsafe { init.__pinned_init(slot)? };
155        // SAFETY: All fields have been initialized.
156        Ok(unsafe { self.assume_init() }.into())
157    }
158}
pin_init/alloc.rs

pin_init/
alloc.rs
