~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/rust/kernel/init/macros.rs

Version: ~ [ linux-6.12-rc7 ] ~ [ linux-6.11.7 ] ~ [ linux-6.10.14 ] ~ [ linux-6.9.12 ] ~ [ linux-6.8.12 ] ~ [ linux-6.7.12 ] ~ [ linux-6.6.60 ] ~ [ linux-6.5.13 ] ~ [ linux-6.4.16 ] ~ [ linux-6.3.13 ] ~ [ linux-6.2.16 ] ~ [ linux-6.1.116 ] ~ [ linux-6.0.19 ] ~ [ linux-5.19.17 ] ~ [ linux-5.18.19 ] ~ [ linux-5.17.15 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.171 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.229 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.285 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.323 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.336 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.337 ] ~ [ linux-4.4.302 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.12 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

Diff markup

Differences between /rust/kernel/init/macros.rs (Architecture m68k) and /rust/kernel/init/macros.rs (Architecture sparc)


  1 // SPDX-License-Identifier: Apache-2.0 OR MIT       1 // SPDX-License-Identifier: Apache-2.0 OR MIT
  2                                                     2 
  3 //! This module provides the macros that actua      3 //! This module provides the macros that actually implement the proc-macros `pin_data` and
  4 //! `pinned_drop`. It also contains `__init_in      4 //! `pinned_drop`. It also contains `__init_internal` the implementation of the `{try_}{pin_}init!`
  5 //! macros.                                         5 //! macros.
  6 //!                                                 6 //!
  7 //! These macros should never be called direct      7 //! These macros should never be called directly, since they expect their input to be
  8 //! in a certain format which is internal. If       8 //! in a certain format which is internal. If used incorrectly, these macros can lead to UB even in
  9 //! safe code! Use the public facing macros in      9 //! safe code! Use the public facing macros instead.
 10 //!                                                10 //!
 11 //! This architecture has been chosen because      11 //! This architecture has been chosen because the kernel does not yet have access to `syn` which
 12 //! would make matters a lot easier for implem     12 //! would make matters a lot easier for implementing these as proc-macros.
 13 //!                                                13 //!
 14 //! # Macro expansion example                      14 //! # Macro expansion example
 15 //!                                                15 //!
 16 //! This section is intended for readers tryin     16 //! This section is intended for readers trying to understand the macros in this module and the
 17 //! `pin_init!` macros from `init.rs`.             17 //! `pin_init!` macros from `init.rs`.
 18 //!                                                18 //!
 19 //! We will look at the following example:         19 //! We will look at the following example:
 20 //!                                                20 //!
 21 //! ```rust,ignore                                 21 //! ```rust,ignore
 22 //! # use kernel::init::*;                         22 //! # use kernel::init::*;
 23 //! # use core::pin::Pin;                          23 //! # use core::pin::Pin;
 24 //! #[pin_data]                                    24 //! #[pin_data]
 25 //! #[repr(C)]                                     25 //! #[repr(C)]
 26 //! struct Bar<T> {                                26 //! struct Bar<T> {
 27 //!     #[pin]                                     27 //!     #[pin]
 28 //!     t: T,                                      28 //!     t: T,
 29 //!     pub x: usize,                              29 //!     pub x: usize,
 30 //! }                                              30 //! }
 31 //!                                                31 //!
 32 //! impl<T> Bar<T> {                               32 //! impl<T> Bar<T> {
 33 //!     fn new(t: T) -> impl PinInit<Self> {       33 //!     fn new(t: T) -> impl PinInit<Self> {
 34 //!         pin_init!(Self { t, x: 0 })            34 //!         pin_init!(Self { t, x: 0 })
 35 //!     }                                          35 //!     }
 36 //! }                                              36 //! }
 37 //!                                                37 //!
 38 //! #[pin_data(PinnedDrop)]                        38 //! #[pin_data(PinnedDrop)]
 39 //! struct Foo {                                   39 //! struct Foo {
 40 //!     a: usize,                                  40 //!     a: usize,
 41 //!     #[pin]                                     41 //!     #[pin]
 42 //!     b: Bar<u32>,                               42 //!     b: Bar<u32>,
 43 //! }                                              43 //! }
 44 //!                                                44 //!
 45 //! #[pinned_drop]                                 45 //! #[pinned_drop]
 46 //! impl PinnedDrop for Foo {                      46 //! impl PinnedDrop for Foo {
 47 //!     fn drop(self: Pin<&mut Self>) {            47 //!     fn drop(self: Pin<&mut Self>) {
 48 //!         pr_info!("{self:p} is getting drop     48 //!         pr_info!("{self:p} is getting dropped.");
 49 //!     }                                          49 //!     }
 50 //! }                                              50 //! }
 51 //!                                                51 //!
 52 //! let a = 42;                                    52 //! let a = 42;
 53 //! let initializer = pin_init!(Foo {              53 //! let initializer = pin_init!(Foo {
 54 //!     a,                                         54 //!     a,
 55 //!     b <- Bar::new(36),                         55 //!     b <- Bar::new(36),
 56 //! });                                            56 //! });
 57 //! ```                                            57 //! ```
 58 //!                                                58 //!
 59 //! This example includes the most common and      59 //! This example includes the most common and important features of the pin-init API.
 60 //!                                                60 //!
 61 //! Below you can find individual section abou     61 //! Below you can find individual section about the different macro invocations. Here are some
 62 //! general things we need to take into accoun     62 //! general things we need to take into account when designing macros:
 63 //! - use global paths, similarly to file path     63 //! - use global paths, similarly to file paths, these start with the separator: `::core::panic!()`
 64 //!   this ensures that the correct item is us     64 //!   this ensures that the correct item is used, since users could define their own `mod core {}`
 65 //!   and then their own `panic!` inside to ex     65 //!   and then their own `panic!` inside to execute arbitrary code inside of our macro.
 66 //! - macro `unsafe` hygiene: we need to ensur     66 //! - macro `unsafe` hygiene: we need to ensure that we do not expand arbitrary, user-supplied
 67 //!   expressions inside of an `unsafe` block      67 //!   expressions inside of an `unsafe` block in the macro, because this would allow users to do
 68 //!   `unsafe` operations without an associate     68 //!   `unsafe` operations without an associated `unsafe` block.
 69 //!                                                69 //!
 70 //! ## `#[pin_data]` on `Bar`                      70 //! ## `#[pin_data]` on `Bar`
 71 //!                                                71 //!
 72 //! This macro is used to specify which fields     72 //! This macro is used to specify which fields are structurally pinned and which fields are not. It
 73 //! is placed on the struct definition and all     73 //! is placed on the struct definition and allows `#[pin]` to be placed on the fields.
 74 //!                                                74 //!
 75 //! Here is the definition of `Bar` from our e     75 //! Here is the definition of `Bar` from our example:
 76 //!                                                76 //!
 77 //! ```rust,ignore                                 77 //! ```rust,ignore
 78 //! # use kernel::init::*;                         78 //! # use kernel::init::*;
 79 //! #[pin_data]                                    79 //! #[pin_data]
 80 //! #[repr(C)]                                     80 //! #[repr(C)]
 81 //! struct Bar<T> {                                81 //! struct Bar<T> {
 82 //!     #[pin]                                     82 //!     #[pin]
 83 //!     t: T,                                      83 //!     t: T,
 84 //!     pub x: usize,                              84 //!     pub x: usize,
 85 //! }                                              85 //! }
 86 //! ```                                            86 //! ```
 87 //!                                                87 //!
 88 //! This expands to the following code:            88 //! This expands to the following code:
 89 //!                                                89 //!
 90 //! ```rust,ignore                                 90 //! ```rust,ignore
 91 //! // Firstly the normal definition of the st     91 //! // Firstly the normal definition of the struct, attributes are preserved:
 92 //! #[repr(C)]                                     92 //! #[repr(C)]
 93 //! struct Bar<T> {                                93 //! struct Bar<T> {
 94 //!     t: T,                                      94 //!     t: T,
 95 //!     pub x: usize,                              95 //!     pub x: usize,
 96 //! }                                              96 //! }
 97 //! // Then an anonymous constant is defined,      97 //! // Then an anonymous constant is defined, this is because we do not want any code to access the
 98 //! // types that we define inside:                98 //! // types that we define inside:
 99 //! const _: () = {                                99 //! const _: () = {
100 //!     // We define the pin-data carrying str    100 //!     // We define the pin-data carrying struct, it is a ZST and needs to have the same generics,
101 //!     // since we need to implement access f    101 //!     // since we need to implement access functions for each field and thus need to know its
102 //!     // type.                                  102 //!     // type.
103 //!     struct __ThePinData<T> {                  103 //!     struct __ThePinData<T> {
104 //!         __phantom: ::core::marker::Phantom    104 //!         __phantom: ::core::marker::PhantomData<fn(Bar<T>) -> Bar<T>>,
105 //!     }                                         105 //!     }
106 //!     // We implement `Copy` for the pin-dat    106 //!     // We implement `Copy` for the pin-data struct, since all functions it defines will take
107 //!     // `self` by value.                       107 //!     // `self` by value.
108 //!     impl<T> ::core::clone::Clone for __The    108 //!     impl<T> ::core::clone::Clone for __ThePinData<T> {
109 //!         fn clone(&self) -> Self {             109 //!         fn clone(&self) -> Self {
110 //!             *self                             110 //!             *self
111 //!         }                                     111 //!         }
112 //!     }                                         112 //!     }
113 //!     impl<T> ::core::marker::Copy for __The    113 //!     impl<T> ::core::marker::Copy for __ThePinData<T> {}
114 //!     // For every field of `Bar`, the pin-d    114 //!     // For every field of `Bar`, the pin-data struct will define a function with the same name
115 //!     // and accessor (`pub` or `pub(crate)`    115 //!     // and accessor (`pub` or `pub(crate)` etc.). This function will take a pointer to the
116 //!     // field (`slot`) and a `PinInit` or `    116 //!     // field (`slot`) and a `PinInit` or `Init` depending on the projection kind of the field
117 //!     // (if pinning is structural for the f    117 //!     // (if pinning is structural for the field, then `PinInit` otherwise `Init`).
118 //!     #[allow(dead_code)]                       118 //!     #[allow(dead_code)]
119 //!     impl<T> __ThePinData<T> {                 119 //!     impl<T> __ThePinData<T> {
120 //!         unsafe fn t<E>(                       120 //!         unsafe fn t<E>(
121 //!             self,                             121 //!             self,
122 //!             slot: *mut T,                     122 //!             slot: *mut T,
123 //!             // Since `t` is `#[pin]`, this    123 //!             // Since `t` is `#[pin]`, this is `PinInit`.
124 //!             init: impl ::kernel::init::Pin    124 //!             init: impl ::kernel::init::PinInit<T, E>,
125 //!         ) -> ::core::result::Result<(), E>    125 //!         ) -> ::core::result::Result<(), E> {
126 //!             unsafe { ::kernel::init::PinIn    126 //!             unsafe { ::kernel::init::PinInit::__pinned_init(init, slot) }
127 //!         }                                     127 //!         }
128 //!         pub unsafe fn x<E>(                   128 //!         pub unsafe fn x<E>(
129 //!             self,                             129 //!             self,
130 //!             slot: *mut usize,                 130 //!             slot: *mut usize,
131 //!             // Since `x` is not `#[pin]`,     131 //!             // Since `x` is not `#[pin]`, this is `Init`.
132 //!             init: impl ::kernel::init::Ini    132 //!             init: impl ::kernel::init::Init<usize, E>,
133 //!         ) -> ::core::result::Result<(), E>    133 //!         ) -> ::core::result::Result<(), E> {
134 //!             unsafe { ::kernel::init::Init:    134 //!             unsafe { ::kernel::init::Init::__init(init, slot) }
135 //!         }                                     135 //!         }
136 //!     }                                         136 //!     }
137 //!     // Implement the internal `HasPinData`    137 //!     // Implement the internal `HasPinData` trait that associates `Bar` with the pin-data struct
138 //!     // that we constructed above.             138 //!     // that we constructed above.
139 //!     unsafe impl<T> ::kernel::init::__inter    139 //!     unsafe impl<T> ::kernel::init::__internal::HasPinData for Bar<T> {
140 //!         type PinData = __ThePinData<T>;       140 //!         type PinData = __ThePinData<T>;
141 //!         unsafe fn __pin_data() -> Self::Pi    141 //!         unsafe fn __pin_data() -> Self::PinData {
142 //!             __ThePinData {                    142 //!             __ThePinData {
143 //!                 __phantom: ::core::marker:    143 //!                 __phantom: ::core::marker::PhantomData,
144 //!             }                                 144 //!             }
145 //!         }                                     145 //!         }
146 //!     }                                         146 //!     }
147 //!     // Implement the internal `PinData` tr    147 //!     // Implement the internal `PinData` trait that marks the pin-data struct as a pin-data
148 //!     // struct. This is important to ensure    148 //!     // struct. This is important to ensure that no user can implement a rogue `__pin_data`
149 //!     // function without using `unsafe`.       149 //!     // function without using `unsafe`.
150 //!     unsafe impl<T> ::kernel::init::__inter    150 //!     unsafe impl<T> ::kernel::init::__internal::PinData for __ThePinData<T> {
151 //!         type Datee = Bar<T>;                  151 //!         type Datee = Bar<T>;
152 //!     }                                         152 //!     }
153 //!     // Now we only want to implement `Unpi    153 //!     // Now we only want to implement `Unpin` for `Bar` when every structurally pinned field is
154 //!     // `Unpin`. In other words, whether `B    154 //!     // `Unpin`. In other words, whether `Bar` is `Unpin` only depends on structurally pinned
155 //!     // fields (those marked with `#[pin]`)    155 //!     // fields (those marked with `#[pin]`). These fields will be listed in this struct, in our
156 //!     // case no such fields exist, hence th    156 //!     // case no such fields exist, hence this is almost empty. The two phantomdata fields exist
157 //!     // for two reasons:                       157 //!     // for two reasons:
158 //!     // - `__phantom`: every generic must b    158 //!     // - `__phantom`: every generic must be used, since we cannot really know which generics
159 //!     //   are used, we declare all and then    159 //!     //   are used, we declare all and then use everything here once.
160 //!     // - `__phantom_pin`: uses the `'__pin    160 //!     // - `__phantom_pin`: uses the `'__pin` lifetime and ensures that this struct is invariant
161 //!     //   over it. The lifetime is needed t    161 //!     //   over it. The lifetime is needed to work around the limitation that trait bounds must
162 //!     //   not be trivial, e.g. the user has    162 //!     //   not be trivial, e.g. the user has a `#[pin] PhantomPinned` field -- this is
163 //!     //   unconditionally `!Unpin` and resu    163 //!     //   unconditionally `!Unpin` and results in an error. The lifetime tricks the compiler
164 //!     //   into accepting these bounds regar    164 //!     //   into accepting these bounds regardless.
165 //!     #[allow(dead_code)]                       165 //!     #[allow(dead_code)]
166 //!     struct __Unpin<'__pin, T> {               166 //!     struct __Unpin<'__pin, T> {
167 //!         __phantom_pin: ::core::marker::Pha    167 //!         __phantom_pin: ::core::marker::PhantomData<fn(&'__pin ()) -> &'__pin ()>,
168 //!         __phantom: ::core::marker::Phantom    168 //!         __phantom: ::core::marker::PhantomData<fn(Bar<T>) -> Bar<T>>,
169 //!         // Our only `#[pin]` field is `t`.    169 //!         // Our only `#[pin]` field is `t`.
170 //!         t: T,                                 170 //!         t: T,
171 //!     }                                         171 //!     }
172 //!     #[doc(hidden)]                            172 //!     #[doc(hidden)]
173 //!     impl<'__pin, T> ::core::marker::Unpin     173 //!     impl<'__pin, T> ::core::marker::Unpin for Bar<T>
174 //!     where                                     174 //!     where
175 //!         __Unpin<'__pin, T>: ::core::marker    175 //!         __Unpin<'__pin, T>: ::core::marker::Unpin,
176 //!     {}                                        176 //!     {}
177 //!     // Now we need to ensure that `Bar` do    177 //!     // Now we need to ensure that `Bar` does not implement `Drop`, since that would give users
178 //!     // access to `&mut self` inside of `dr    178 //!     // access to `&mut self` inside of `drop` even if the struct was pinned. This could lead to
179 //!     // UB with only safe code, so we disal    179 //!     // UB with only safe code, so we disallow this by giving a trait implementation error using
180 //!     // a direct impl and a blanket impleme    180 //!     // a direct impl and a blanket implementation.
181 //!     trait MustNotImplDrop {}                  181 //!     trait MustNotImplDrop {}
182 //!     // Normally `Drop` bounds do not have     182 //!     // Normally `Drop` bounds do not have the correct semantics, but for this purpose they do
183 //!     // (normally people want to know if a     183 //!     // (normally people want to know if a type has any kind of drop glue at all, here we want
184 //!     // to know if it has any kind of custo    184 //!     // to know if it has any kind of custom drop glue, which is exactly what this bound does).
185 //!     #[allow(drop_bounds)]                     185 //!     #[allow(drop_bounds)]
186 //!     impl<T: ::core::ops::Drop> MustNotImpl    186 //!     impl<T: ::core::ops::Drop> MustNotImplDrop for T {}
187 //!     impl<T> MustNotImplDrop for Bar<T> {}     187 //!     impl<T> MustNotImplDrop for Bar<T> {}
188 //!     // Here comes a convenience check, if     188 //!     // Here comes a convenience check, if one implemented `PinnedDrop`, but forgot to add it to
189 //!     // `#[pin_data]`, then this will error    189 //!     // `#[pin_data]`, then this will error with the same mechanic as above, this is not needed
190 //!     // for safety, but a good sanity check    190 //!     // for safety, but a good sanity check, since no normal code calls `PinnedDrop::drop`.
191 //!     #[allow(non_camel_case_types)]            191 //!     #[allow(non_camel_case_types)]
192 //!     trait UselessPinnedDropImpl_you_need_t    192 //!     trait UselessPinnedDropImpl_you_need_to_specify_PinnedDrop {}
193 //!     impl<                                     193 //!     impl<
194 //!         T: ::kernel::init::PinnedDrop,        194 //!         T: ::kernel::init::PinnedDrop,
195 //!     > UselessPinnedDropImpl_you_need_to_sp    195 //!     > UselessPinnedDropImpl_you_need_to_specify_PinnedDrop for T {}
196 //!     impl<T> UselessPinnedDropImpl_you_need    196 //!     impl<T> UselessPinnedDropImpl_you_need_to_specify_PinnedDrop for Bar<T> {}
197 //! };                                            197 //! };
198 //! ```                                           198 //! ```
199 //!                                               199 //!
200 //! ## `pin_init!` in `impl Bar`                  200 //! ## `pin_init!` in `impl Bar`
201 //!                                               201 //!
202 //! This macro creates an pin-initializer for     202 //! This macro creates an pin-initializer for the given struct. It requires that the struct is
203 //! annotated by `#[pin_data]`.                   203 //! annotated by `#[pin_data]`.
204 //!                                               204 //!
205 //! Here is the impl on `Bar` defining the new    205 //! Here is the impl on `Bar` defining the new function:
206 //!                                               206 //!
207 //! ```rust,ignore                                207 //! ```rust,ignore
208 //! impl<T> Bar<T> {                              208 //! impl<T> Bar<T> {
209 //!     fn new(t: T) -> impl PinInit<Self> {      209 //!     fn new(t: T) -> impl PinInit<Self> {
210 //!         pin_init!(Self { t, x: 0 })           210 //!         pin_init!(Self { t, x: 0 })
211 //!     }                                         211 //!     }
212 //! }                                             212 //! }
213 //! ```                                           213 //! ```
214 //!                                               214 //!
215 //! This expands to the following code:           215 //! This expands to the following code:
216 //!                                               216 //!
217 //! ```rust,ignore                                217 //! ```rust,ignore
218 //! impl<T> Bar<T> {                              218 //! impl<T> Bar<T> {
219 //!     fn new(t: T) -> impl PinInit<Self> {      219 //!     fn new(t: T) -> impl PinInit<Self> {
220 //!         {                                     220 //!         {
221 //!             // We do not want to allow arb    221 //!             // We do not want to allow arbitrary returns, so we declare this type as the `Ok`
222 //!             // return type and shadow it l    222 //!             // return type and shadow it later when we insert the arbitrary user code. That way
223 //!             // there will be no possibilit    223 //!             // there will be no possibility of returning without `unsafe`.
224 //!             struct __InitOk;                  224 //!             struct __InitOk;
225 //!             // Get the data about fields f    225 //!             // Get the data about fields from the supplied type.
226 //!             // - the function is unsafe, h    226 //!             // - the function is unsafe, hence the unsafe block
227 //!             // - we `use` the `HasPinData`    227 //!             // - we `use` the `HasPinData` trait in the block, it is only available in that
228 //!             //   scope.                       228 //!             //   scope.
229 //!             let data = unsafe {               229 //!             let data = unsafe {
230 //!                 use ::kernel::init::__inte    230 //!                 use ::kernel::init::__internal::HasPinData;
231 //!                 Self::__pin_data()            231 //!                 Self::__pin_data()
232 //!             };                                232 //!             };
233 //!             // Ensure that `data` really i    233 //!             // Ensure that `data` really is of type `PinData` and help with type inference:
234 //!             let init = ::kernel::init::__i    234 //!             let init = ::kernel::init::__internal::PinData::make_closure::<
235 //!                 _,                            235 //!                 _,
236 //!                 __InitOk,                     236 //!                 __InitOk,
237 //!                 ::core::convert::Infallibl    237 //!                 ::core::convert::Infallible,
238 //!             >(data, move |slot| {             238 //!             >(data, move |slot| {
239 //!                 {                             239 //!                 {
240 //!                     // Shadow the structur    240 //!                     // Shadow the structure so it cannot be used to return early. If a user
241 //!                     // tries to write `ret    241 //!                     // tries to write `return Ok(__InitOk)`, then they get a type error,
242 //!                     // since that will ref    242 //!                     // since that will refer to this struct instead of the one defined
243 //!                     // above.                 243 //!                     // above.
244 //!                     struct __InitOk;          244 //!                     struct __InitOk;
245 //!                     // This is the expansi    245 //!                     // This is the expansion of `t,`, which is syntactic sugar for `t: t,`.
246 //!                     {                         246 //!                     {
247 //!                         unsafe { ::core::p    247 //!                         unsafe { ::core::ptr::write(::core::addr_of_mut!((*slot).t), t) };
248 //!                     }                         248 //!                     }
249 //!                     // Since initializatio    249 //!                     // Since initialization could fail later (not in this case, since the
250 //!                     // error type is `Infa    250 //!                     // error type is `Infallible`) we will need to drop this field if there
251 //!                     // is an error later.     251 //!                     // is an error later. This `DropGuard` will drop the field when it gets
252 //!                     // dropped and has not    252 //!                     // dropped and has not yet been forgotten.
253 //!                     let __t_guard = unsafe    253 //!                     let __t_guard = unsafe {
254 //!                         ::pinned_init::__i    254 //!                         ::pinned_init::__internal::DropGuard::new(::core::addr_of_mut!((*slot).t))
255 //!                     };                        255 //!                     };
256 //!                     // Expansion of `x: 0,    256 //!                     // Expansion of `x: 0,`:
257 //!                     // Since this can be a    257 //!                     // Since this can be an arbitrary expression we cannot place it inside
258 //!                     // of the `unsafe` blo    258 //!                     // of the `unsafe` block, so we bind it here.
259 //!                     {                         259 //!                     {
260 //!                         let x = 0;            260 //!                         let x = 0;
261 //!                         unsafe { ::core::p    261 //!                         unsafe { ::core::ptr::write(::core::addr_of_mut!((*slot).x), x) };
262 //!                     }                         262 //!                     }
263 //!                     // We again create a `    263 //!                     // We again create a `DropGuard`.
264 //!                     let __x_guard = unsafe    264 //!                     let __x_guard = unsafe {
265 //!                         ::kernel::init::__    265 //!                         ::kernel::init::__internal::DropGuard::new(::core::addr_of_mut!((*slot).x))
266 //!                     };                        266 //!                     };
267 //!                     // Since initializatio    267 //!                     // Since initialization has successfully completed, we can now forget
268 //!                     // the guards. This is    268 //!                     // the guards. This is not `mem::forget`, since we only have
269 //!                     // `&DropGuard`.          269 //!                     // `&DropGuard`.
270 //!                     ::core::mem::forget(__    270 //!                     ::core::mem::forget(__x_guard);
271 //!                     ::core::mem::forget(__    271 //!                     ::core::mem::forget(__t_guard);
272 //!                     // Here we use the typ    272 //!                     // Here we use the type checker to ensure that every field has been
273 //!                     // initialized exactly    273 //!                     // initialized exactly once, since this is `if false` it will never get
274 //!                     // executed, but still    274 //!                     // executed, but still type-checked.
275 //!                     // Additionally we abu    275 //!                     // Additionally we abuse `slot` to automatically infer the correct type
276 //!                     // for the struct. Thi    276 //!                     // for the struct. This is also another check that every field is
277 //!                     // accessible from thi    277 //!                     // accessible from this scope.
278 //!                     #[allow(unreachable_co    278 //!                     #[allow(unreachable_code, clippy::diverging_sub_expression)]
279 //!                     let _ = || {              279 //!                     let _ = || {
280 //!                         unsafe {              280 //!                         unsafe {
281 //!                             ::core::ptr::w    281 //!                             ::core::ptr::write(
282 //!                                 slot,         282 //!                                 slot,
283 //!                                 Self {        283 //!                                 Self {
284 //!                                     // We     284 //!                                     // We only care about typecheck finding every field
285 //!                                     // her    285 //!                                     // here, the expression does not matter, just conjure
286 //!                                     // one    286 //!                                     // one using `panic!()`:
287 //!                                     t: ::c    287 //!                                     t: ::core::panic!(),
288 //!                                     x: ::c    288 //!                                     x: ::core::panic!(),
289 //!                                 },            289 //!                                 },
290 //!                             );                290 //!                             );
291 //!                         };                    291 //!                         };
292 //!                     };                        292 //!                     };
293 //!                 }                             293 //!                 }
294 //!                 // We leave the scope abov    294 //!                 // We leave the scope above and gain access to the previously shadowed
295 //!                 // `__InitOk` that we need    295 //!                 // `__InitOk` that we need to return.
296 //!                 Ok(__InitOk)                  296 //!                 Ok(__InitOk)
297 //!             });                               297 //!             });
298 //!             // Change the return type from    298 //!             // Change the return type from `__InitOk` to `()`.
299 //!             let init = move |                 299 //!             let init = move |
300 //!                 slot,                         300 //!                 slot,
301 //!             | -> ::core::result::Result<()    301 //!             | -> ::core::result::Result<(), ::core::convert::Infallible> {
302 //!                 init(slot).map(|__InitOk|     302 //!                 init(slot).map(|__InitOk| ())
303 //!             };                                303 //!             };
304 //!             // Construct the initializer.     304 //!             // Construct the initializer.
305 //!             let init = unsafe {               305 //!             let init = unsafe {
306 //!                 ::kernel::init::pin_init_f    306 //!                 ::kernel::init::pin_init_from_closure::<
307 //!                     _,                        307 //!                     _,
308 //!                     ::core::convert::Infal    308 //!                     ::core::convert::Infallible,
309 //!                 >(init)                       309 //!                 >(init)
310 //!             };                                310 //!             };
311 //!             init                              311 //!             init
312 //!         }                                     312 //!         }
313 //!     }                                         313 //!     }
314 //! }                                             314 //! }
315 //! ```                                           315 //! ```
316 //!                                               316 //!
317 //! ## `#[pin_data]` on `Foo`                     317 //! ## `#[pin_data]` on `Foo`
318 //!                                               318 //!
319 //! Since we already took a look at `#[pin_dat    319 //! Since we already took a look at `#[pin_data]` on `Bar`, this section will only explain the
320 //! differences/new things in the expansion of    320 //! differences/new things in the expansion of the `Foo` definition:
321 //!                                               321 //!
322 //! ```rust,ignore                                322 //! ```rust,ignore
323 //! #[pin_data(PinnedDrop)]                       323 //! #[pin_data(PinnedDrop)]
324 //! struct Foo {                                  324 //! struct Foo {
325 //!     a: usize,                                 325 //!     a: usize,
326 //!     #[pin]                                    326 //!     #[pin]
327 //!     b: Bar<u32>,                              327 //!     b: Bar<u32>,
328 //! }                                             328 //! }
329 //! ```                                           329 //! ```
330 //!                                               330 //!
331 //! This expands to the following code:           331 //! This expands to the following code:
332 //!                                               332 //!
333 //! ```rust,ignore                                333 //! ```rust,ignore
334 //! struct Foo {                                  334 //! struct Foo {
335 //!     a: usize,                                 335 //!     a: usize,
336 //!     b: Bar<u32>,                              336 //!     b: Bar<u32>,
337 //! }                                             337 //! }
338 //! const _: () = {                               338 //! const _: () = {
339 //!     struct __ThePinData {                     339 //!     struct __ThePinData {
340 //!         __phantom: ::core::marker::Phantom    340 //!         __phantom: ::core::marker::PhantomData<fn(Foo) -> Foo>,
341 //!     }                                         341 //!     }
342 //!     impl ::core::clone::Clone for __ThePin    342 //!     impl ::core::clone::Clone for __ThePinData {
343 //!         fn clone(&self) -> Self {             343 //!         fn clone(&self) -> Self {
344 //!             *self                             344 //!             *self
345 //!         }                                     345 //!         }
346 //!     }                                         346 //!     }
347 //!     impl ::core::marker::Copy for __ThePin    347 //!     impl ::core::marker::Copy for __ThePinData {}
348 //!     #[allow(dead_code)]                       348 //!     #[allow(dead_code)]
349 //!     impl __ThePinData {                       349 //!     impl __ThePinData {
350 //!         unsafe fn b<E>(                       350 //!         unsafe fn b<E>(
351 //!             self,                             351 //!             self,
352 //!             slot: *mut Bar<u32>,              352 //!             slot: *mut Bar<u32>,
353 //!             init: impl ::kernel::init::Pin    353 //!             init: impl ::kernel::init::PinInit<Bar<u32>, E>,
354 //!         ) -> ::core::result::Result<(), E>    354 //!         ) -> ::core::result::Result<(), E> {
355 //!             unsafe { ::kernel::init::PinIn    355 //!             unsafe { ::kernel::init::PinInit::__pinned_init(init, slot) }
356 //!         }                                     356 //!         }
357 //!         unsafe fn a<E>(                       357 //!         unsafe fn a<E>(
358 //!             self,                             358 //!             self,
359 //!             slot: *mut usize,                 359 //!             slot: *mut usize,
360 //!             init: impl ::kernel::init::Ini    360 //!             init: impl ::kernel::init::Init<usize, E>,
361 //!         ) -> ::core::result::Result<(), E>    361 //!         ) -> ::core::result::Result<(), E> {
362 //!             unsafe { ::kernel::init::Init:    362 //!             unsafe { ::kernel::init::Init::__init(init, slot) }
363 //!         }                                     363 //!         }
364 //!     }                                         364 //!     }
365 //!     unsafe impl ::kernel::init::__internal    365 //!     unsafe impl ::kernel::init::__internal::HasPinData for Foo {
366 //!         type PinData = __ThePinData;          366 //!         type PinData = __ThePinData;
367 //!         unsafe fn __pin_data() -> Self::Pi    367 //!         unsafe fn __pin_data() -> Self::PinData {
368 //!             __ThePinData {                    368 //!             __ThePinData {
369 //!                 __phantom: ::core::marker:    369 //!                 __phantom: ::core::marker::PhantomData,
370 //!             }                                 370 //!             }
371 //!         }                                     371 //!         }
372 //!     }                                         372 //!     }
373 //!     unsafe impl ::kernel::init::__internal    373 //!     unsafe impl ::kernel::init::__internal::PinData for __ThePinData {
374 //!         type Datee = Foo;                     374 //!         type Datee = Foo;
375 //!     }                                         375 //!     }
376 //!     #[allow(dead_code)]                       376 //!     #[allow(dead_code)]
377 //!     struct __Unpin<'__pin> {                  377 //!     struct __Unpin<'__pin> {
378 //!         __phantom_pin: ::core::marker::Pha    378 //!         __phantom_pin: ::core::marker::PhantomData<fn(&'__pin ()) -> &'__pin ()>,
379 //!         __phantom: ::core::marker::Phantom    379 //!         __phantom: ::core::marker::PhantomData<fn(Foo) -> Foo>,
380 //!         b: Bar<u32>,                          380 //!         b: Bar<u32>,
381 //!     }                                         381 //!     }
382 //!     #[doc(hidden)]                            382 //!     #[doc(hidden)]
383 //!     impl<'__pin> ::core::marker::Unpin for    383 //!     impl<'__pin> ::core::marker::Unpin for Foo
384 //!     where                                     384 //!     where
385 //!         __Unpin<'__pin>: ::core::marker::U    385 //!         __Unpin<'__pin>: ::core::marker::Unpin,
386 //!     {}                                        386 //!     {}
387 //!     // Since we specified `PinnedDrop` as     387 //!     // Since we specified `PinnedDrop` as the argument to `#[pin_data]`, we expect `Foo` to
388 //!     // implement `PinnedDrop`. Thus we do     388 //!     // implement `PinnedDrop`. Thus we do not need to prevent `Drop` implementations like
389 //!     // before, instead we implement `Drop`    389 //!     // before, instead we implement `Drop` here and delegate to `PinnedDrop`.
390 //!     impl ::core::ops::Drop for Foo {          390 //!     impl ::core::ops::Drop for Foo {
391 //!         fn drop(&mut self) {                  391 //!         fn drop(&mut self) {
392 //!             // Since we are getting droppe    392 //!             // Since we are getting dropped, no one else has a reference to `self` and thus we
393 //!             // can assume that we never mo    393 //!             // can assume that we never move.
394 //!             let pinned = unsafe { ::core::    394 //!             let pinned = unsafe { ::core::pin::Pin::new_unchecked(self) };
395 //!             // Create the unsafe token tha    395 //!             // Create the unsafe token that proves that we are inside of a destructor, this
396 //!             // type is only allowed to be     396 //!             // type is only allowed to be created in a destructor.
397 //!             let token = unsafe { ::kernel:    397 //!             let token = unsafe { ::kernel::init::__internal::OnlyCallFromDrop::new() };
398 //!             ::kernel::init::PinnedDrop::dr    398 //!             ::kernel::init::PinnedDrop::drop(pinned, token);
399 //!         }                                     399 //!         }
400 //!     }                                         400 //!     }
401 //! };                                            401 //! };
402 //! ```                                           402 //! ```
403 //!                                               403 //!
404 //! ## `#[pinned_drop]` on `impl PinnedDrop fo    404 //! ## `#[pinned_drop]` on `impl PinnedDrop for Foo`
405 //!                                               405 //!
406 //! This macro is used to implement the `Pinne    406 //! This macro is used to implement the `PinnedDrop` trait, since that trait is `unsafe` and has an
407 //! extra parameter that should not be used at    407 //! extra parameter that should not be used at all. The macro hides that parameter.
408 //!                                               408 //!
409 //! Here is the `PinnedDrop` impl for `Foo`:      409 //! Here is the `PinnedDrop` impl for `Foo`:
410 //!                                               410 //!
411 //! ```rust,ignore                                411 //! ```rust,ignore
412 //! #[pinned_drop]                                412 //! #[pinned_drop]
413 //! impl PinnedDrop for Foo {                     413 //! impl PinnedDrop for Foo {
414 //!     fn drop(self: Pin<&mut Self>) {           414 //!     fn drop(self: Pin<&mut Self>) {
415 //!         pr_info!("{self:p} is getting drop    415 //!         pr_info!("{self:p} is getting dropped.");
416 //!     }                                         416 //!     }
417 //! }                                             417 //! }
418 //! ```                                           418 //! ```
419 //!                                               419 //!
420 //! This expands to the following code:           420 //! This expands to the following code:
421 //!                                               421 //!
422 //! ```rust,ignore                                422 //! ```rust,ignore
423 //! // `unsafe`, full path and the token param    423 //! // `unsafe`, full path and the token parameter are added, everything else stays the same.
424 //! unsafe impl ::kernel::init::PinnedDrop for    424 //! unsafe impl ::kernel::init::PinnedDrop for Foo {
425 //!     fn drop(self: Pin<&mut Self>, _: ::ker    425 //!     fn drop(self: Pin<&mut Self>, _: ::kernel::init::__internal::OnlyCallFromDrop) {
426 //!         pr_info!("{self:p} is getting drop    426 //!         pr_info!("{self:p} is getting dropped.");
427 //!     }                                         427 //!     }
428 //! }                                             428 //! }
429 //! ```                                           429 //! ```
430 //!                                               430 //!
431 //! ## `pin_init!` on `Foo`                       431 //! ## `pin_init!` on `Foo`
432 //!                                               432 //!
433 //! Since we already took a look at `pin_init!    433 //! Since we already took a look at `pin_init!` on `Bar`, this section will only show the expansion
434 //! of `pin_init!` on `Foo`:                      434 //! of `pin_init!` on `Foo`:
435 //!                                               435 //!
436 //! ```rust,ignore                                436 //! ```rust,ignore
437 //! let a = 42;                                   437 //! let a = 42;
438 //! let initializer = pin_init!(Foo {             438 //! let initializer = pin_init!(Foo {
439 //!     a,                                        439 //!     a,
440 //!     b <- Bar::new(36),                        440 //!     b <- Bar::new(36),
441 //! });                                           441 //! });
442 //! ```                                           442 //! ```
443 //!                                               443 //!
444 //! This expands to the following code:           444 //! This expands to the following code:
445 //!                                               445 //!
446 //! ```rust,ignore                                446 //! ```rust,ignore
447 //! let a = 42;                                   447 //! let a = 42;
448 //! let initializer = {                           448 //! let initializer = {
449 //!     struct __InitOk;                          449 //!     struct __InitOk;
450 //!     let data = unsafe {                       450 //!     let data = unsafe {
451 //!         use ::kernel::init::__internal::Ha    451 //!         use ::kernel::init::__internal::HasPinData;
452 //!         Foo::__pin_data()                     452 //!         Foo::__pin_data()
453 //!     };                                        453 //!     };
454 //!     let init = ::kernel::init::__internal:    454 //!     let init = ::kernel::init::__internal::PinData::make_closure::<
455 //!         _,                                    455 //!         _,
456 //!         __InitOk,                             456 //!         __InitOk,
457 //!         ::core::convert::Infallible,          457 //!         ::core::convert::Infallible,
458 //!     >(data, move |slot| {                     458 //!     >(data, move |slot| {
459 //!         {                                     459 //!         {
460 //!             struct __InitOk;                  460 //!             struct __InitOk;
461 //!             {                                 461 //!             {
462 //!                 unsafe { ::core::ptr::writ    462 //!                 unsafe { ::core::ptr::write(::core::addr_of_mut!((*slot).a), a) };
463 //!             }                                 463 //!             }
464 //!             let __a_guard = unsafe {          464 //!             let __a_guard = unsafe {
465 //!                 ::kernel::init::__internal    465 //!                 ::kernel::init::__internal::DropGuard::new(::core::addr_of_mut!((*slot).a))
466 //!             };                                466 //!             };
467 //!             let init = Bar::new(36);          467 //!             let init = Bar::new(36);
468 //!             unsafe { data.b(::core::addr_o    468 //!             unsafe { data.b(::core::addr_of_mut!((*slot).b), b)? };
469 //!             let __b_guard = unsafe {          469 //!             let __b_guard = unsafe {
470 //!                 ::kernel::init::__internal    470 //!                 ::kernel::init::__internal::DropGuard::new(::core::addr_of_mut!((*slot).b))
471 //!             };                                471 //!             };
472 //!             ::core::mem::forget(__b_guard)    472 //!             ::core::mem::forget(__b_guard);
473 //!             ::core::mem::forget(__a_guard)    473 //!             ::core::mem::forget(__a_guard);
474 //!             #[allow(unreachable_code, clip    474 //!             #[allow(unreachable_code, clippy::diverging_sub_expression)]
475 //!             let _ = || {                      475 //!             let _ = || {
476 //!                 unsafe {                      476 //!                 unsafe {
477 //!                     ::core::ptr::write(       477 //!                     ::core::ptr::write(
478 //!                         slot,                 478 //!                         slot,
479 //!                         Foo {                 479 //!                         Foo {
480 //!                             a: ::core::pan    480 //!                             a: ::core::panic!(),
481 //!                             b: ::core::pan    481 //!                             b: ::core::panic!(),
482 //!                         },                    482 //!                         },
483 //!                     );                        483 //!                     );
484 //!                 };                            484 //!                 };
485 //!             };                                485 //!             };
486 //!         }                                     486 //!         }
487 //!         Ok(__InitOk)                          487 //!         Ok(__InitOk)
488 //!     });                                       488 //!     });
489 //!     let init = move |                         489 //!     let init = move |
490 //!         slot,                                 490 //!         slot,
491 //!     | -> ::core::result::Result<(), ::core    491 //!     | -> ::core::result::Result<(), ::core::convert::Infallible> {
492 //!         init(slot).map(|__InitOk| ())         492 //!         init(slot).map(|__InitOk| ())
493 //!     };                                        493 //!     };
494 //!     let init = unsafe {                       494 //!     let init = unsafe {
495 //!         ::kernel::init::pin_init_from_clos    495 //!         ::kernel::init::pin_init_from_closure::<_, ::core::convert::Infallible>(init)
496 //!     };                                        496 //!     };
497 //!     init                                      497 //!     init
498 //! };                                            498 //! };
499 //! ```                                           499 //! ```
500                                                   500 
501 /// Creates a `unsafe impl<...> PinnedDrop for    501 /// Creates a `unsafe impl<...> PinnedDrop for $type` block.
502 ///                                               502 ///
503 /// See [`PinnedDrop`] for more information.      503 /// See [`PinnedDrop`] for more information.
504 #[doc(hidden)]                                    504 #[doc(hidden)]
505 #[macro_export]                                   505 #[macro_export]
506 macro_rules! __pinned_drop {                      506 macro_rules! __pinned_drop {
507     (                                             507     (
508         @impl_sig($($impl_sig:tt)*),              508         @impl_sig($($impl_sig:tt)*),
509         @impl_body(                               509         @impl_body(
510             $(#[$($attr:tt)*])*                   510             $(#[$($attr:tt)*])*
511             fn drop($($sig:tt)*) {                511             fn drop($($sig:tt)*) {
512                 $($inner:tt)*                     512                 $($inner:tt)*
513             }                                     513             }
514         ),                                        514         ),
515     ) => {                                        515     ) => {
516         unsafe $($impl_sig)* {                    516         unsafe $($impl_sig)* {
517             // Inherit all attributes and the     517             // Inherit all attributes and the type/ident tokens for the signature.
518             $(#[$($attr)*])*                      518             $(#[$($attr)*])*
519             fn drop($($sig)*, _: $crate::init:    519             fn drop($($sig)*, _: $crate::init::__internal::OnlyCallFromDrop) {
520                 $($inner)*                        520                 $($inner)*
521             }                                     521             }
522         }                                         522         }
523     }                                             523     }
524 }                                                 524 }
525                                                   525 
526 /// This macro first parses the struct definit    526 /// This macro first parses the struct definition such that it separates pinned and not pinned
527 /// fields. Afterwards it declares the struct     527 /// fields. Afterwards it declares the struct and implement the `PinData` trait safely.
528 #[doc(hidden)]                                    528 #[doc(hidden)]
529 #[macro_export]                                   529 #[macro_export]
530 macro_rules! __pin_data {                         530 macro_rules! __pin_data {
531     // Proc-macro entry point, this is supplie    531     // Proc-macro entry point, this is supplied by the proc-macro pre-parsing.
532     (parse_input:                                 532     (parse_input:
533         @args($($pinned_drop:ident)?),            533         @args($($pinned_drop:ident)?),
534         @sig(                                     534         @sig(
535             $(#[$($struct_attr:tt)*])*            535             $(#[$($struct_attr:tt)*])*
536             $vis:vis struct $name:ident           536             $vis:vis struct $name:ident
537             $(where $($whr:tt)*)?                 537             $(where $($whr:tt)*)?
538         ),                                        538         ),
539         @impl_generics($($impl_generics:tt)*),    539         @impl_generics($($impl_generics:tt)*),
540         @ty_generics($($ty_generics:tt)*),        540         @ty_generics($($ty_generics:tt)*),
541         @decl_generics($($decl_generics:tt)*),    541         @decl_generics($($decl_generics:tt)*),
542         @body({ $($fields:tt)* }),                542         @body({ $($fields:tt)* }),
543     ) => {                                        543     ) => {
544         // We now use token munching to iterat    544         // We now use token munching to iterate through all of the fields. While doing this we
545         // identify fields marked with `#[pin]    545         // identify fields marked with `#[pin]`, these fields are the 'pinned fields'. The user
546         // wants these to be structurally pinn    546         // wants these to be structurally pinned. The rest of the fields are the
547         // 'not pinned fields'. Additionally w    547         // 'not pinned fields'. Additionally we collect all fields, since we need them in the right
548         // order to declare the struct.           548         // order to declare the struct.
549         //                                        549         //
550         // In this call we also put some expla    550         // In this call we also put some explaining comments for the parameters.
551         $crate::__pin_data!(find_pinned_fields    551         $crate::__pin_data!(find_pinned_fields:
552             // Attributes on the struct itself    552             // Attributes on the struct itself, these will just be propagated to be put onto the
553             // struct definition.                 553             // struct definition.
554             @struct_attrs($(#[$($struct_attr)*    554             @struct_attrs($(#[$($struct_attr)*])*),
555             // The visibility of the struct.      555             // The visibility of the struct.
556             @vis($vis),                           556             @vis($vis),
557             // The name of the struct.            557             // The name of the struct.
558             @name($name),                         558             @name($name),
559             // The 'impl generics', the generi    559             // The 'impl generics', the generics that will need to be specified on the struct inside
560             // of an `impl<$ty_generics>` bloc    560             // of an `impl<$ty_generics>` block.
561             @impl_generics($($impl_generics)*)    561             @impl_generics($($impl_generics)*),
562             // The 'ty generics', the generics    562             // The 'ty generics', the generics that will need to be specified on the impl blocks.
563             @ty_generics($($ty_generics)*),       563             @ty_generics($($ty_generics)*),
564             // The 'decl generics', the generi    564             // The 'decl generics', the generics that need to be specified on the struct
565             // definition.                        565             // definition.
566             @decl_generics($($decl_generics)*)    566             @decl_generics($($decl_generics)*),
567             // The where clause of any impl bl    567             // The where clause of any impl block and the declaration.
568             @where($($($whr)*)?),                 568             @where($($($whr)*)?),
569             // The remaining fields tokens tha    569             // The remaining fields tokens that need to be processed.
570             // We add a `,` at the end to ensu    570             // We add a `,` at the end to ensure correct parsing.
571             @fields_munch($($fields)* ,),         571             @fields_munch($($fields)* ,),
572             // The pinned fields.                 572             // The pinned fields.
573             @pinned(),                            573             @pinned(),
574             // The not pinned fields.             574             // The not pinned fields.
575             @not_pinned(),                        575             @not_pinned(),
576             // All fields.                        576             // All fields.
577             @fields(),                            577             @fields(),
578             // The accumulator containing all     578             // The accumulator containing all attributes already parsed.
579             @accum(),                             579             @accum(),
580             // Contains `yes` or `` to indicat    580             // Contains `yes` or `` to indicate if `#[pin]` was found on the current field.
581             @is_pinned(),                         581             @is_pinned(),
582             // The proc-macro argument, this s    582             // The proc-macro argument, this should be `PinnedDrop` or ``.
583             @pinned_drop($($pinned_drop)?),       583             @pinned_drop($($pinned_drop)?),
584         );                                        584         );
585     };                                            585     };
586     (find_pinned_fields:                          586     (find_pinned_fields:
587         @struct_attrs($($struct_attrs:tt)*),      587         @struct_attrs($($struct_attrs:tt)*),
588         @vis($vis:vis),                           588         @vis($vis:vis),
589         @name($name:ident),                       589         @name($name:ident),
590         @impl_generics($($impl_generics:tt)*),    590         @impl_generics($($impl_generics:tt)*),
591         @ty_generics($($ty_generics:tt)*),        591         @ty_generics($($ty_generics:tt)*),
592         @decl_generics($($decl_generics:tt)*),    592         @decl_generics($($decl_generics:tt)*),
593         @where($($whr:tt)*),                      593         @where($($whr:tt)*),
594         // We found a PhantomPinned field, thi    594         // We found a PhantomPinned field, this should generally be pinned!
595         @fields_munch($field:ident : $($($(::)    595         @fields_munch($field:ident : $($($(::)?core::)?marker::)?PhantomPinned, $($rest:tt)*),
596         @pinned($($pinned:tt)*),                  596         @pinned($($pinned:tt)*),
597         @not_pinned($($not_pinned:tt)*),          597         @not_pinned($($not_pinned:tt)*),
598         @fields($($fields:tt)*),                  598         @fields($($fields:tt)*),
599         @accum($($accum:tt)*),                    599         @accum($($accum:tt)*),
600         // This field is not pinned.              600         // This field is not pinned.
601         @is_pinned(),                             601         @is_pinned(),
602         @pinned_drop($($pinned_drop:ident)?),     602         @pinned_drop($($pinned_drop:ident)?),
603     ) => {                                        603     ) => {
604         ::core::compile_error!(concat!(           604         ::core::compile_error!(concat!(
605             "The field `",                        605             "The field `",
606             stringify!($field),                   606             stringify!($field),
607             "` of type `PhantomPinned` only ha    607             "` of type `PhantomPinned` only has an effect, if it has the `#[pin]` attribute.",
608         ));                                       608         ));
609         $crate::__pin_data!(find_pinned_fields    609         $crate::__pin_data!(find_pinned_fields:
610             @struct_attrs($($struct_attrs)*),     610             @struct_attrs($($struct_attrs)*),
611             @vis($vis),                           611             @vis($vis),
612             @name($name),                         612             @name($name),
613             @impl_generics($($impl_generics)*)    613             @impl_generics($($impl_generics)*),
614             @ty_generics($($ty_generics)*),       614             @ty_generics($($ty_generics)*),
615             @decl_generics($($decl_generics)*)    615             @decl_generics($($decl_generics)*),
616             @where($($whr)*),                     616             @where($($whr)*),
617             @fields_munch($($rest)*),             617             @fields_munch($($rest)*),
618             @pinned($($pinned)* $($accum)* $fi    618             @pinned($($pinned)* $($accum)* $field: ::core::marker::PhantomPinned,),
619             @not_pinned($($not_pinned)*),         619             @not_pinned($($not_pinned)*),
620             @fields($($fields)* $($accum)* $fi    620             @fields($($fields)* $($accum)* $field: ::core::marker::PhantomPinned,),
621             @accum(),                             621             @accum(),
622             @is_pinned(),                         622             @is_pinned(),
623             @pinned_drop($($pinned_drop)?),       623             @pinned_drop($($pinned_drop)?),
624         );                                        624         );
625     };                                            625     };
626     (find_pinned_fields:                          626     (find_pinned_fields:
627         @struct_attrs($($struct_attrs:tt)*),      627         @struct_attrs($($struct_attrs:tt)*),
628         @vis($vis:vis),                           628         @vis($vis:vis),
629         @name($name:ident),                       629         @name($name:ident),
630         @impl_generics($($impl_generics:tt)*),    630         @impl_generics($($impl_generics:tt)*),
631         @ty_generics($($ty_generics:tt)*),        631         @ty_generics($($ty_generics:tt)*),
632         @decl_generics($($decl_generics:tt)*),    632         @decl_generics($($decl_generics:tt)*),
633         @where($($whr:tt)*),                      633         @where($($whr:tt)*),
634         // We reached the field declaration.      634         // We reached the field declaration.
635         @fields_munch($field:ident : $type:ty,    635         @fields_munch($field:ident : $type:ty, $($rest:tt)*),
636         @pinned($($pinned:tt)*),                  636         @pinned($($pinned:tt)*),
637         @not_pinned($($not_pinned:tt)*),          637         @not_pinned($($not_pinned:tt)*),
638         @fields($($fields:tt)*),                  638         @fields($($fields:tt)*),
639         @accum($($accum:tt)*),                    639         @accum($($accum:tt)*),
640         // This field is pinned.                  640         // This field is pinned.
641         @is_pinned(yes),                          641         @is_pinned(yes),
642         @pinned_drop($($pinned_drop:ident)?),     642         @pinned_drop($($pinned_drop:ident)?),
643     ) => {                                        643     ) => {
644         $crate::__pin_data!(find_pinned_fields    644         $crate::__pin_data!(find_pinned_fields:
645             @struct_attrs($($struct_attrs)*),     645             @struct_attrs($($struct_attrs)*),
646             @vis($vis),                           646             @vis($vis),
647             @name($name),                         647             @name($name),
648             @impl_generics($($impl_generics)*)    648             @impl_generics($($impl_generics)*),
649             @ty_generics($($ty_generics)*),       649             @ty_generics($($ty_generics)*),
650             @decl_generics($($decl_generics)*)    650             @decl_generics($($decl_generics)*),
651             @where($($whr)*),                     651             @where($($whr)*),
652             @fields_munch($($rest)*),             652             @fields_munch($($rest)*),
653             @pinned($($pinned)* $($accum)* $fi    653             @pinned($($pinned)* $($accum)* $field: $type,),
654             @not_pinned($($not_pinned)*),         654             @not_pinned($($not_pinned)*),
655             @fields($($fields)* $($accum)* $fi    655             @fields($($fields)* $($accum)* $field: $type,),
656             @accum(),                             656             @accum(),
657             @is_pinned(),                         657             @is_pinned(),
658             @pinned_drop($($pinned_drop)?),       658             @pinned_drop($($pinned_drop)?),
659         );                                        659         );
660     };                                            660     };
661     (find_pinned_fields:                          661     (find_pinned_fields:
662         @struct_attrs($($struct_attrs:tt)*),      662         @struct_attrs($($struct_attrs:tt)*),
663         @vis($vis:vis),                           663         @vis($vis:vis),
664         @name($name:ident),                       664         @name($name:ident),
665         @impl_generics($($impl_generics:tt)*),    665         @impl_generics($($impl_generics:tt)*),
666         @ty_generics($($ty_generics:tt)*),        666         @ty_generics($($ty_generics:tt)*),
667         @decl_generics($($decl_generics:tt)*),    667         @decl_generics($($decl_generics:tt)*),
668         @where($($whr:tt)*),                      668         @where($($whr:tt)*),
669         // We reached the field declaration.      669         // We reached the field declaration.
670         @fields_munch($field:ident : $type:ty,    670         @fields_munch($field:ident : $type:ty, $($rest:tt)*),
671         @pinned($($pinned:tt)*),                  671         @pinned($($pinned:tt)*),
672         @not_pinned($($not_pinned:tt)*),          672         @not_pinned($($not_pinned:tt)*),
673         @fields($($fields:tt)*),                  673         @fields($($fields:tt)*),
674         @accum($($accum:tt)*),                    674         @accum($($accum:tt)*),
675         // This field is not pinned.              675         // This field is not pinned.
676         @is_pinned(),                             676         @is_pinned(),
677         @pinned_drop($($pinned_drop:ident)?),     677         @pinned_drop($($pinned_drop:ident)?),
678     ) => {                                        678     ) => {
679         $crate::__pin_data!(find_pinned_fields    679         $crate::__pin_data!(find_pinned_fields:
680             @struct_attrs($($struct_attrs)*),     680             @struct_attrs($($struct_attrs)*),
681             @vis($vis),                           681             @vis($vis),
682             @name($name),                         682             @name($name),
683             @impl_generics($($impl_generics)*)    683             @impl_generics($($impl_generics)*),
684             @ty_generics($($ty_generics)*),       684             @ty_generics($($ty_generics)*),
685             @decl_generics($($decl_generics)*)    685             @decl_generics($($decl_generics)*),
686             @where($($whr)*),                     686             @where($($whr)*),
687             @fields_munch($($rest)*),             687             @fields_munch($($rest)*),
688             @pinned($($pinned)*),                 688             @pinned($($pinned)*),
689             @not_pinned($($not_pinned)* $($acc    689             @not_pinned($($not_pinned)* $($accum)* $field: $type,),
690             @fields($($fields)* $($accum)* $fi    690             @fields($($fields)* $($accum)* $field: $type,),
691             @accum(),                             691             @accum(),
692             @is_pinned(),                         692             @is_pinned(),
693             @pinned_drop($($pinned_drop)?),       693             @pinned_drop($($pinned_drop)?),
694         );                                        694         );
695     };                                            695     };
696     (find_pinned_fields:                          696     (find_pinned_fields:
697         @struct_attrs($($struct_attrs:tt)*),      697         @struct_attrs($($struct_attrs:tt)*),
698         @vis($vis:vis),                           698         @vis($vis:vis),
699         @name($name:ident),                       699         @name($name:ident),
700         @impl_generics($($impl_generics:tt)*),    700         @impl_generics($($impl_generics:tt)*),
701         @ty_generics($($ty_generics:tt)*),        701         @ty_generics($($ty_generics:tt)*),
702         @decl_generics($($decl_generics:tt)*),    702         @decl_generics($($decl_generics:tt)*),
703         @where($($whr:tt)*),                      703         @where($($whr:tt)*),
704         // We found the `#[pin]` attr.            704         // We found the `#[pin]` attr.
705         @fields_munch(#[pin] $($rest:tt)*),       705         @fields_munch(#[pin] $($rest:tt)*),
706         @pinned($($pinned:tt)*),                  706         @pinned($($pinned:tt)*),
707         @not_pinned($($not_pinned:tt)*),          707         @not_pinned($($not_pinned:tt)*),
708         @fields($($fields:tt)*),                  708         @fields($($fields:tt)*),
709         @accum($($accum:tt)*),                    709         @accum($($accum:tt)*),
710         @is_pinned($($is_pinned:ident)?),         710         @is_pinned($($is_pinned:ident)?),
711         @pinned_drop($($pinned_drop:ident)?),     711         @pinned_drop($($pinned_drop:ident)?),
712     ) => {                                        712     ) => {
713         $crate::__pin_data!(find_pinned_fields    713         $crate::__pin_data!(find_pinned_fields:
714             @struct_attrs($($struct_attrs)*),     714             @struct_attrs($($struct_attrs)*),
715             @vis($vis),                           715             @vis($vis),
716             @name($name),                         716             @name($name),
717             @impl_generics($($impl_generics)*)    717             @impl_generics($($impl_generics)*),
718             @ty_generics($($ty_generics)*),       718             @ty_generics($($ty_generics)*),
719             @decl_generics($($decl_generics)*)    719             @decl_generics($($decl_generics)*),
720             @where($($whr)*),                     720             @where($($whr)*),
721             @fields_munch($($rest)*),             721             @fields_munch($($rest)*),
722             // We do not include `#[pin]` in t    722             // We do not include `#[pin]` in the list of attributes, since it is not actually an
723             // attribute that is defined somew    723             // attribute that is defined somewhere.
724             @pinned($($pinned)*),                 724             @pinned($($pinned)*),
725             @not_pinned($($not_pinned)*),         725             @not_pinned($($not_pinned)*),
726             @fields($($fields)*),                 726             @fields($($fields)*),
727             @accum($($accum)*),                   727             @accum($($accum)*),
728             // Set this to `yes`.                 728             // Set this to `yes`.
729             @is_pinned(yes),                      729             @is_pinned(yes),
730             @pinned_drop($($pinned_drop)?),       730             @pinned_drop($($pinned_drop)?),
731         );                                        731         );
732     };                                            732     };
733     (find_pinned_fields:                          733     (find_pinned_fields:
734         @struct_attrs($($struct_attrs:tt)*),      734         @struct_attrs($($struct_attrs:tt)*),
735         @vis($vis:vis),                           735         @vis($vis:vis),
736         @name($name:ident),                       736         @name($name:ident),
737         @impl_generics($($impl_generics:tt)*),    737         @impl_generics($($impl_generics:tt)*),
738         @ty_generics($($ty_generics:tt)*),        738         @ty_generics($($ty_generics:tt)*),
739         @decl_generics($($decl_generics:tt)*),    739         @decl_generics($($decl_generics:tt)*),
740         @where($($whr:tt)*),                      740         @where($($whr:tt)*),
741         // We reached the field declaration wi    741         // We reached the field declaration with visibility, for simplicity we only munch the
742         // visibility and put it into `$accum`    742         // visibility and put it into `$accum`.
743         @fields_munch($fvis:vis $field:ident $    743         @fields_munch($fvis:vis $field:ident $($rest:tt)*),
744         @pinned($($pinned:tt)*),                  744         @pinned($($pinned:tt)*),
745         @not_pinned($($not_pinned:tt)*),          745         @not_pinned($($not_pinned:tt)*),
746         @fields($($fields:tt)*),                  746         @fields($($fields:tt)*),
747         @accum($($accum:tt)*),                    747         @accum($($accum:tt)*),
748         @is_pinned($($is_pinned:ident)?),         748         @is_pinned($($is_pinned:ident)?),
749         @pinned_drop($($pinned_drop:ident)?),     749         @pinned_drop($($pinned_drop:ident)?),
750     ) => {                                        750     ) => {
751         $crate::__pin_data!(find_pinned_fields    751         $crate::__pin_data!(find_pinned_fields:
752             @struct_attrs($($struct_attrs)*),     752             @struct_attrs($($struct_attrs)*),
753             @vis($vis),                           753             @vis($vis),
754             @name($name),                         754             @name($name),
755             @impl_generics($($impl_generics)*)    755             @impl_generics($($impl_generics)*),
756             @ty_generics($($ty_generics)*),       756             @ty_generics($($ty_generics)*),
757             @decl_generics($($decl_generics)*)    757             @decl_generics($($decl_generics)*),
758             @where($($whr)*),                     758             @where($($whr)*),
759             @fields_munch($field $($rest)*),      759             @fields_munch($field $($rest)*),
760             @pinned($($pinned)*),                 760             @pinned($($pinned)*),
761             @not_pinned($($not_pinned)*),         761             @not_pinned($($not_pinned)*),
762             @fields($($fields)*),                 762             @fields($($fields)*),
763             @accum($($accum)* $fvis),             763             @accum($($accum)* $fvis),
764             @is_pinned($($is_pinned)?),           764             @is_pinned($($is_pinned)?),
765             @pinned_drop($($pinned_drop)?),       765             @pinned_drop($($pinned_drop)?),
766         );                                        766         );
767     };                                            767     };
768     (find_pinned_fields:                          768     (find_pinned_fields:
769         @struct_attrs($($struct_attrs:tt)*),      769         @struct_attrs($($struct_attrs:tt)*),
770         @vis($vis:vis),                           770         @vis($vis:vis),
771         @name($name:ident),                       771         @name($name:ident),
772         @impl_generics($($impl_generics:tt)*),    772         @impl_generics($($impl_generics:tt)*),
773         @ty_generics($($ty_generics:tt)*),        773         @ty_generics($($ty_generics:tt)*),
774         @decl_generics($($decl_generics:tt)*),    774         @decl_generics($($decl_generics:tt)*),
775         @where($($whr:tt)*),                      775         @where($($whr:tt)*),
776         // Some other attribute, just put it i    776         // Some other attribute, just put it into `$accum`.
777         @fields_munch(#[$($attr:tt)*] $($rest:    777         @fields_munch(#[$($attr:tt)*] $($rest:tt)*),
778         @pinned($($pinned:tt)*),                  778         @pinned($($pinned:tt)*),
779         @not_pinned($($not_pinned:tt)*),          779         @not_pinned($($not_pinned:tt)*),
780         @fields($($fields:tt)*),                  780         @fields($($fields:tt)*),
781         @accum($($accum:tt)*),                    781         @accum($($accum:tt)*),
782         @is_pinned($($is_pinned:ident)?),         782         @is_pinned($($is_pinned:ident)?),
783         @pinned_drop($($pinned_drop:ident)?),     783         @pinned_drop($($pinned_drop:ident)?),
784     ) => {                                        784     ) => {
785         $crate::__pin_data!(find_pinned_fields    785         $crate::__pin_data!(find_pinned_fields:
786             @struct_attrs($($struct_attrs)*),     786             @struct_attrs($($struct_attrs)*),
787             @vis($vis),                           787             @vis($vis),
788             @name($name),                         788             @name($name),
789             @impl_generics($($impl_generics)*)    789             @impl_generics($($impl_generics)*),
790             @ty_generics($($ty_generics)*),       790             @ty_generics($($ty_generics)*),
791             @decl_generics($($decl_generics)*)    791             @decl_generics($($decl_generics)*),
792             @where($($whr)*),                     792             @where($($whr)*),
793             @fields_munch($($rest)*),             793             @fields_munch($($rest)*),
794             @pinned($($pinned)*),                 794             @pinned($($pinned)*),
795             @not_pinned($($not_pinned)*),         795             @not_pinned($($not_pinned)*),
796             @fields($($fields)*),                 796             @fields($($fields)*),
797             @accum($($accum)* #[$($attr)*]),      797             @accum($($accum)* #[$($attr)*]),
798             @is_pinned($($is_pinned)?),           798             @is_pinned($($is_pinned)?),
799             @pinned_drop($($pinned_drop)?),       799             @pinned_drop($($pinned_drop)?),
800         );                                        800         );
801     };                                            801     };
802     (find_pinned_fields:                          802     (find_pinned_fields:
803         @struct_attrs($($struct_attrs:tt)*),      803         @struct_attrs($($struct_attrs:tt)*),
804         @vis($vis:vis),                           804         @vis($vis:vis),
805         @name($name:ident),                       805         @name($name:ident),
806         @impl_generics($($impl_generics:tt)*),    806         @impl_generics($($impl_generics:tt)*),
807         @ty_generics($($ty_generics:tt)*),        807         @ty_generics($($ty_generics:tt)*),
808         @decl_generics($($decl_generics:tt)*),    808         @decl_generics($($decl_generics:tt)*),
809         @where($($whr:tt)*),                      809         @where($($whr:tt)*),
810         // We reached the end of the fields, p    810         // We reached the end of the fields, plus an optional additional comma, since we added one
811         // before and the user is also allowed    811         // before and the user is also allowed to put a trailing comma.
812         @fields_munch($(,)?),                     812         @fields_munch($(,)?),
813         @pinned($($pinned:tt)*),                  813         @pinned($($pinned:tt)*),
814         @not_pinned($($not_pinned:tt)*),          814         @not_pinned($($not_pinned:tt)*),
815         @fields($($fields:tt)*),                  815         @fields($($fields:tt)*),
816         @accum(),                                 816         @accum(),
817         @is_pinned(),                             817         @is_pinned(),
818         @pinned_drop($($pinned_drop:ident)?),     818         @pinned_drop($($pinned_drop:ident)?),
819     ) => {                                        819     ) => {
820         // Declare the struct with all fields     820         // Declare the struct with all fields in the correct order.
821         $($struct_attrs)*                         821         $($struct_attrs)*
822         $vis struct $name <$($decl_generics)*>    822         $vis struct $name <$($decl_generics)*>
823         where $($whr)*                            823         where $($whr)*
824         {                                         824         {
825             $($fields)*                           825             $($fields)*
826         }                                         826         }
827                                                   827 
828         // We put the rest into this const ite    828         // We put the rest into this const item, because it then will not be accessible to anything
829         // outside.                               829         // outside.
830         const _: () = {                           830         const _: () = {
831             // We declare this struct which wi    831             // We declare this struct which will host all of the projection function for our type.
832             // it will be invariant over all g    832             // it will be invariant over all generic parameters which are inherited from the
833             // struct.                            833             // struct.
834             $vis struct __ThePinData<$($impl_g    834             $vis struct __ThePinData<$($impl_generics)*>
835             where $($whr)*                        835             where $($whr)*
836             {                                     836             {
837                 __phantom: ::core::marker::Pha    837                 __phantom: ::core::marker::PhantomData<
838                     fn($name<$($ty_generics)*>    838                     fn($name<$($ty_generics)*>) -> $name<$($ty_generics)*>
839                 >,                                839                 >,
840             }                                     840             }
841                                                   841 
842             impl<$($impl_generics)*> ::core::c    842             impl<$($impl_generics)*> ::core::clone::Clone for __ThePinData<$($ty_generics)*>
843             where $($whr)*                        843             where $($whr)*
844             {                                     844             {
845                 fn clone(&self) -> Self { *sel    845                 fn clone(&self) -> Self { *self }
846             }                                     846             }
847                                                   847 
848             impl<$($impl_generics)*> ::core::m    848             impl<$($impl_generics)*> ::core::marker::Copy for __ThePinData<$($ty_generics)*>
849             where $($whr)*                        849             where $($whr)*
850             {}                                    850             {}
851                                                   851 
852             // Make all projection functions.     852             // Make all projection functions.
853             $crate::__pin_data!(make_pin_data:    853             $crate::__pin_data!(make_pin_data:
854                 @pin_data(__ThePinData),          854                 @pin_data(__ThePinData),
855                 @impl_generics($($impl_generic    855                 @impl_generics($($impl_generics)*),
856                 @ty_generics($($ty_generics)*)    856                 @ty_generics($($ty_generics)*),
857                 @where($($whr)*),                 857                 @where($($whr)*),
858                 @pinned($($pinned)*),             858                 @pinned($($pinned)*),
859                 @not_pinned($($not_pinned)*),     859                 @not_pinned($($not_pinned)*),
860             );                                    860             );
861                                                   861 
862             // SAFETY: We have added the corre    862             // SAFETY: We have added the correct projection functions above to `__ThePinData` and
863             // we also use the least restricti    863             // we also use the least restrictive generics possible.
864             unsafe impl<$($impl_generics)*>       864             unsafe impl<$($impl_generics)*>
865                 $crate::init::__internal::HasP    865                 $crate::init::__internal::HasPinData for $name<$($ty_generics)*>
866             where $($whr)*                        866             where $($whr)*
867             {                                     867             {
868                 type PinData = __ThePinData<$(    868                 type PinData = __ThePinData<$($ty_generics)*>;
869                                                   869 
870                 unsafe fn __pin_data() -> Self    870                 unsafe fn __pin_data() -> Self::PinData {
871                     __ThePinData { __phantom:     871                     __ThePinData { __phantom: ::core::marker::PhantomData }
872                 }                                 872                 }
873             }                                     873             }
874                                                   874 
875             unsafe impl<$($impl_generics)*>       875             unsafe impl<$($impl_generics)*>
876                 $crate::init::__internal::PinD    876                 $crate::init::__internal::PinData for __ThePinData<$($ty_generics)*>
877             where $($whr)*                        877             where $($whr)*
878             {                                     878             {
879                 type Datee = $name<$($ty_gener    879                 type Datee = $name<$($ty_generics)*>;
880             }                                     880             }
881                                                   881 
882             // This struct will be used for th    882             // This struct will be used for the unpin analysis. Since only structurally pinned
883             // fields are relevant whether the    883             // fields are relevant whether the struct should implement `Unpin`.
884             #[allow(dead_code)]                   884             #[allow(dead_code)]
885             struct __Unpin <'__pin, $($impl_ge    885             struct __Unpin <'__pin, $($impl_generics)*>
886             where $($whr)*                        886             where $($whr)*
887             {                                     887             {
888                 __phantom_pin: ::core::marker:    888                 __phantom_pin: ::core::marker::PhantomData<fn(&'__pin ()) -> &'__pin ()>,
889                 __phantom: ::core::marker::Pha    889                 __phantom: ::core::marker::PhantomData<
890                     fn($name<$($ty_generics)*>    890                     fn($name<$($ty_generics)*>) -> $name<$($ty_generics)*>
891                 >,                                891                 >,
892                 // Only the pinned fields.        892                 // Only the pinned fields.
893                 $($pinned)*                       893                 $($pinned)*
894             }                                     894             }
895                                                   895 
896             #[doc(hidden)]                        896             #[doc(hidden)]
897             impl<'__pin, $($impl_generics)*> :    897             impl<'__pin, $($impl_generics)*> ::core::marker::Unpin for $name<$($ty_generics)*>
898             where                                 898             where
899                 __Unpin<'__pin, $($ty_generics    899                 __Unpin<'__pin, $($ty_generics)*>: ::core::marker::Unpin,
900                 $($whr)*                          900                 $($whr)*
901             {}                                    901             {}
902                                                   902 
903             // We need to disallow normal `Dro    903             // We need to disallow normal `Drop` implementation, the exact behavior depends on
904             // whether `PinnedDrop` was specif    904             // whether `PinnedDrop` was specified as the parameter.
905             $crate::__pin_data!(drop_preventio    905             $crate::__pin_data!(drop_prevention:
906                 @name($name),                     906                 @name($name),
907                 @impl_generics($($impl_generic    907                 @impl_generics($($impl_generics)*),
908                 @ty_generics($($ty_generics)*)    908                 @ty_generics($($ty_generics)*),
909                 @where($($whr)*),                 909                 @where($($whr)*),
910                 @pinned_drop($($pinned_drop)?)    910                 @pinned_drop($($pinned_drop)?),
911             );                                    911             );
912         };                                        912         };
913     };                                            913     };
914     // When no `PinnedDrop` was specified, the    914     // When no `PinnedDrop` was specified, then we have to prevent implementing drop.
915     (drop_prevention:                             915     (drop_prevention:
916         @name($name:ident),                       916         @name($name:ident),
917         @impl_generics($($impl_generics:tt)*),    917         @impl_generics($($impl_generics:tt)*),
918         @ty_generics($($ty_generics:tt)*),        918         @ty_generics($($ty_generics:tt)*),
919         @where($($whr:tt)*),                      919         @where($($whr:tt)*),
920         @pinned_drop(),                           920         @pinned_drop(),
921     ) => {                                        921     ) => {
922         // We prevent this by creating a trait    922         // We prevent this by creating a trait that will be implemented for all types implementing
923         // `Drop`. Additionally we will implem    923         // `Drop`. Additionally we will implement this trait for the struct leading to a conflict,
924         // if it also implements `Drop`           924         // if it also implements `Drop`
925         trait MustNotImplDrop {}                  925         trait MustNotImplDrop {}
926         #[allow(drop_bounds)]                     926         #[allow(drop_bounds)]
927         impl<T: ::core::ops::Drop> MustNotImpl    927         impl<T: ::core::ops::Drop> MustNotImplDrop for T {}
928         impl<$($impl_generics)*> MustNotImplDr    928         impl<$($impl_generics)*> MustNotImplDrop for $name<$($ty_generics)*>
929         where $($whr)* {}                         929         where $($whr)* {}
930         // We also take care to prevent users     930         // We also take care to prevent users from writing a useless `PinnedDrop` implementation.
931         // They might implement `PinnedDrop` c    931         // They might implement `PinnedDrop` correctly for the struct, but forget to give
932         // `PinnedDrop` as the parameter to `#    932         // `PinnedDrop` as the parameter to `#[pin_data]`.
933         #[allow(non_camel_case_types)]            933         #[allow(non_camel_case_types)]
934         trait UselessPinnedDropImpl_you_need_t    934         trait UselessPinnedDropImpl_you_need_to_specify_PinnedDrop {}
935         impl<T: $crate::init::PinnedDrop>         935         impl<T: $crate::init::PinnedDrop>
936             UselessPinnedDropImpl_you_need_to_    936             UselessPinnedDropImpl_you_need_to_specify_PinnedDrop for T {}
937         impl<$($impl_generics)*>                  937         impl<$($impl_generics)*>
938             UselessPinnedDropImpl_you_need_to_    938             UselessPinnedDropImpl_you_need_to_specify_PinnedDrop for $name<$($ty_generics)*>
939         where $($whr)* {}                         939         where $($whr)* {}
940     };                                            940     };
941     // When `PinnedDrop` was specified we just    941     // When `PinnedDrop` was specified we just implement `Drop` and delegate.
942     (drop_prevention:                             942     (drop_prevention:
943         @name($name:ident),                       943         @name($name:ident),
944         @impl_generics($($impl_generics:tt)*),    944         @impl_generics($($impl_generics:tt)*),
945         @ty_generics($($ty_generics:tt)*),        945         @ty_generics($($ty_generics:tt)*),
946         @where($($whr:tt)*),                      946         @where($($whr:tt)*),
947         @pinned_drop(PinnedDrop),                 947         @pinned_drop(PinnedDrop),
948     ) => {                                        948     ) => {
949         impl<$($impl_generics)*> ::core::ops::    949         impl<$($impl_generics)*> ::core::ops::Drop for $name<$($ty_generics)*>
950         where $($whr)*                            950         where $($whr)*
951         {                                         951         {
952             fn drop(&mut self) {                  952             fn drop(&mut self) {
953                 // SAFETY: Since this is a des    953                 // SAFETY: Since this is a destructor, `self` will not move after this function
954                 // terminates, since it is ina    954                 // terminates, since it is inaccessible.
955                 let pinned = unsafe { ::core::    955                 let pinned = unsafe { ::core::pin::Pin::new_unchecked(self) };
956                 // SAFETY: Since this is a dro    956                 // SAFETY: Since this is a drop function, we can create this token to call the
957                 // pinned destructor of this t    957                 // pinned destructor of this type.
958                 let token = unsafe { $crate::i    958                 let token = unsafe { $crate::init::__internal::OnlyCallFromDrop::new() };
959                 $crate::init::PinnedDrop::drop    959                 $crate::init::PinnedDrop::drop(pinned, token);
960             }                                     960             }
961         }                                         961         }
962     };                                            962     };
963     // If some other parameter was specified,     963     // If some other parameter was specified, we emit a readable error.
964     (drop_prevention:                             964     (drop_prevention:
965         @name($name:ident),                       965         @name($name:ident),
966         @impl_generics($($impl_generics:tt)*),    966         @impl_generics($($impl_generics:tt)*),
967         @ty_generics($($ty_generics:tt)*),        967         @ty_generics($($ty_generics:tt)*),
968         @where($($whr:tt)*),                      968         @where($($whr:tt)*),
969         @pinned_drop($($rest:tt)*),               969         @pinned_drop($($rest:tt)*),
970     ) => {                                        970     ) => {
971         compile_error!(                           971         compile_error!(
972             "Wrong parameters to `#[pin_data]`    972             "Wrong parameters to `#[pin_data]`, expected nothing or `PinnedDrop`, got '{}'.",
973             stringify!($($rest)*),                973             stringify!($($rest)*),
974         );                                        974         );
975     };                                            975     };
976     (make_pin_data:                               976     (make_pin_data:
977         @pin_data($pin_data:ident),               977         @pin_data($pin_data:ident),
978         @impl_generics($($impl_generics:tt)*),    978         @impl_generics($($impl_generics:tt)*),
979         @ty_generics($($ty_generics:tt)*),        979         @ty_generics($($ty_generics:tt)*),
980         @where($($whr:tt)*),                      980         @where($($whr:tt)*),
981         @pinned($($(#[$($p_attr:tt)*])* $pvis:    981         @pinned($($(#[$($p_attr:tt)*])* $pvis:vis $p_field:ident : $p_type:ty),* $(,)?),
982         @not_pinned($($(#[$($attr:tt)*])* $fvi    982         @not_pinned($($(#[$($attr:tt)*])* $fvis:vis $field:ident : $type:ty),* $(,)?),
983     ) => {                                        983     ) => {
984         // For every field, we create a projec    984         // For every field, we create a projection function according to its projection type. If a
985         // field is structurally pinned, then     985         // field is structurally pinned, then it must be initialized via `PinInit`, if it is not
986         // structurally pinned, then it can be    986         // structurally pinned, then it can be initialized via `Init`.
987         //                                        987         //
988         // The functions are `unsafe` to preve    988         // The functions are `unsafe` to prevent accidentally calling them.
989         #[allow(dead_code)]                       989         #[allow(dead_code)]
990         impl<$($impl_generics)*> $pin_data<$($    990         impl<$($impl_generics)*> $pin_data<$($ty_generics)*>
991         where $($whr)*                            991         where $($whr)*
992         {                                         992         {
993             $(                                    993             $(
994                 $(#[$($p_attr)*])*                994                 $(#[$($p_attr)*])*
995                 $pvis unsafe fn $p_field<E>(      995                 $pvis unsafe fn $p_field<E>(
996                     self,                         996                     self,
997                     slot: *mut $p_type,           997                     slot: *mut $p_type,
998                     init: impl $crate::init::P    998                     init: impl $crate::init::PinInit<$p_type, E>,
999                 ) -> ::core::result::Result<()    999                 ) -> ::core::result::Result<(), E> {
1000                     unsafe { $crate::init::Pi    1000                     unsafe { $crate::init::PinInit::__pinned_init(init, slot) }
1001                 }                                1001                 }
1002             )*                                   1002             )*
1003             $(                                   1003             $(
1004                 $(#[$($attr)*])*                 1004                 $(#[$($attr)*])*
1005                 $fvis unsafe fn $field<E>(       1005                 $fvis unsafe fn $field<E>(
1006                     self,                        1006                     self,
1007                     slot: *mut $type,            1007                     slot: *mut $type,
1008                     init: impl $crate::init::    1008                     init: impl $crate::init::Init<$type, E>,
1009                 ) -> ::core::result::Result<(    1009                 ) -> ::core::result::Result<(), E> {
1010                     unsafe { $crate::init::In    1010                     unsafe { $crate::init::Init::__init(init, slot) }
1011                 }                                1011                 }
1012             )*                                   1012             )*
1013         }                                        1013         }
1014     };                                           1014     };
1015 }                                                1015 }
1016                                                  1016 
1017 /// The internal init macro. Do not call manu    1017 /// The internal init macro. Do not call manually!
1018 ///                                              1018 ///
1019 /// This is called by the `{try_}{pin_}init!`    1019 /// This is called by the `{try_}{pin_}init!` macros with various inputs.
1020 ///                                              1020 ///
1021 /// This macro has multiple internal call con    1021 /// This macro has multiple internal call configurations, these are always the very first ident:
1022 /// - nothing: this is the base case and call    1022 /// - nothing: this is the base case and called by the `{try_}{pin_}init!` macros.
1023 /// - `with_update_parsed`: when the `..Zeroa    1023 /// - `with_update_parsed`: when the `..Zeroable::zeroed()` syntax has been handled.
1024 /// - `init_slot`: recursively creates the co    1024 /// - `init_slot`: recursively creates the code that initializes all fields in `slot`.
1025 /// - `make_initializer`: recursively create     1025 /// - `make_initializer`: recursively create the struct initializer that guarantees that every
1026 ///   field has been initialized exactly once    1026 ///   field has been initialized exactly once.
1027 #[doc(hidden)]                                   1027 #[doc(hidden)]
1028 #[macro_export]                                  1028 #[macro_export]
1029 macro_rules! __init_internal {                   1029 macro_rules! __init_internal {
1030     (                                            1030     (
1031         @this($($this:ident)?),                  1031         @this($($this:ident)?),
1032         @typ($t:path),                           1032         @typ($t:path),
1033         @fields($($fields:tt)*),                 1033         @fields($($fields:tt)*),
1034         @error($err:ty),                         1034         @error($err:ty),
1035         // Either `PinData` or `InitData`, `$    1035         // Either `PinData` or `InitData`, `$use_data` should only be present in the `PinData`
1036         // case.                                 1036         // case.
1037         @data($data:ident, $($use_data:ident)    1037         @data($data:ident, $($use_data:ident)?),
1038         // `HasPinData` or `HasInitData`.        1038         // `HasPinData` or `HasInitData`.
1039         @has_data($has_data:ident, $get_data:    1039         @has_data($has_data:ident, $get_data:ident),
1040         // `pin_init_from_closure` or `init_f    1040         // `pin_init_from_closure` or `init_from_closure`.
1041         @construct_closure($construct_closure    1041         @construct_closure($construct_closure:ident),
1042         @munch_fields(),                         1042         @munch_fields(),
1043     ) => {                                       1043     ) => {
1044         $crate::__init_internal!(with_update_    1044         $crate::__init_internal!(with_update_parsed:
1045             @this($($this)?),                    1045             @this($($this)?),
1046             @typ($t),                            1046             @typ($t),
1047             @fields($($fields)*),                1047             @fields($($fields)*),
1048             @error($err),                        1048             @error($err),
1049             @data($data, $($use_data)?),         1049             @data($data, $($use_data)?),
1050             @has_data($has_data, $get_data),     1050             @has_data($has_data, $get_data),
1051             @construct_closure($construct_clo    1051             @construct_closure($construct_closure),
1052             @zeroed(), // Nothing means defau    1052             @zeroed(), // Nothing means default behavior.
1053         )                                        1053         )
1054     };                                           1054     };
1055     (                                            1055     (
1056         @this($($this:ident)?),                  1056         @this($($this:ident)?),
1057         @typ($t:path),                           1057         @typ($t:path),
1058         @fields($($fields:tt)*),                 1058         @fields($($fields:tt)*),
1059         @error($err:ty),                         1059         @error($err:ty),
1060         // Either `PinData` or `InitData`, `$    1060         // Either `PinData` or `InitData`, `$use_data` should only be present in the `PinData`
1061         // case.                                 1061         // case.
1062         @data($data:ident, $($use_data:ident)    1062         @data($data:ident, $($use_data:ident)?),
1063         // `HasPinData` or `HasInitData`.        1063         // `HasPinData` or `HasInitData`.
1064         @has_data($has_data:ident, $get_data:    1064         @has_data($has_data:ident, $get_data:ident),
1065         // `pin_init_from_closure` or `init_f    1065         // `pin_init_from_closure` or `init_from_closure`.
1066         @construct_closure($construct_closure    1066         @construct_closure($construct_closure:ident),
1067         @munch_fields(..Zeroable::zeroed()),     1067         @munch_fields(..Zeroable::zeroed()),
1068     ) => {                                       1068     ) => {
1069         $crate::__init_internal!(with_update_    1069         $crate::__init_internal!(with_update_parsed:
1070             @this($($this)?),                    1070             @this($($this)?),
1071             @typ($t),                            1071             @typ($t),
1072             @fields($($fields)*),                1072             @fields($($fields)*),
1073             @error($err),                        1073             @error($err),
1074             @data($data, $($use_data)?),         1074             @data($data, $($use_data)?),
1075             @has_data($has_data, $get_data),     1075             @has_data($has_data, $get_data),
1076             @construct_closure($construct_clo    1076             @construct_closure($construct_closure),
1077             @zeroed(()), // `()` means zero a    1077             @zeroed(()), // `()` means zero all fields not mentioned.
1078         )                                        1078         )
1079     };                                           1079     };
1080     (                                            1080     (
1081         @this($($this:ident)?),                  1081         @this($($this:ident)?),
1082         @typ($t:path),                           1082         @typ($t:path),
1083         @fields($($fields:tt)*),                 1083         @fields($($fields:tt)*),
1084         @error($err:ty),                         1084         @error($err:ty),
1085         // Either `PinData` or `InitData`, `$    1085         // Either `PinData` or `InitData`, `$use_data` should only be present in the `PinData`
1086         // case.                                 1086         // case.
1087         @data($data:ident, $($use_data:ident)    1087         @data($data:ident, $($use_data:ident)?),
1088         // `HasPinData` or `HasInitData`.        1088         // `HasPinData` or `HasInitData`.
1089         @has_data($has_data:ident, $get_data:    1089         @has_data($has_data:ident, $get_data:ident),
1090         // `pin_init_from_closure` or `init_f    1090         // `pin_init_from_closure` or `init_from_closure`.
1091         @construct_closure($construct_closure    1091         @construct_closure($construct_closure:ident),
1092         @munch_fields($ignore:tt $($rest:tt)*    1092         @munch_fields($ignore:tt $($rest:tt)*),
1093     ) => {                                       1093     ) => {
1094         $crate::__init_internal!(                1094         $crate::__init_internal!(
1095             @this($($this)?),                    1095             @this($($this)?),
1096             @typ($t),                            1096             @typ($t),
1097             @fields($($fields)*),                1097             @fields($($fields)*),
1098             @error($err),                        1098             @error($err),
1099             @data($data, $($use_data)?),         1099             @data($data, $($use_data)?),
1100             @has_data($has_data, $get_data),     1100             @has_data($has_data, $get_data),
1101             @construct_closure($construct_clo    1101             @construct_closure($construct_closure),
1102             @munch_fields($($rest)*),            1102             @munch_fields($($rest)*),
1103         )                                        1103         )
1104     };                                           1104     };
1105     (with_update_parsed:                         1105     (with_update_parsed:
1106         @this($($this:ident)?),                  1106         @this($($this:ident)?),
1107         @typ($t:path),                           1107         @typ($t:path),
1108         @fields($($fields:tt)*),                 1108         @fields($($fields:tt)*),
1109         @error($err:ty),                         1109         @error($err:ty),
1110         // Either `PinData` or `InitData`, `$    1110         // Either `PinData` or `InitData`, `$use_data` should only be present in the `PinData`
1111         // case.                                 1111         // case.
1112         @data($data:ident, $($use_data:ident)    1112         @data($data:ident, $($use_data:ident)?),
1113         // `HasPinData` or `HasInitData`.        1113         // `HasPinData` or `HasInitData`.
1114         @has_data($has_data:ident, $get_data:    1114         @has_data($has_data:ident, $get_data:ident),
1115         // `pin_init_from_closure` or `init_f    1115         // `pin_init_from_closure` or `init_from_closure`.
1116         @construct_closure($construct_closure    1116         @construct_closure($construct_closure:ident),
1117         @zeroed($($init_zeroed:expr)?),          1117         @zeroed($($init_zeroed:expr)?),
1118     ) => {{                                      1118     ) => {{
1119         // We do not want to allow arbitrary     1119         // We do not want to allow arbitrary returns, so we declare this type as the `Ok` return
1120         // type and shadow it later when we i    1120         // type and shadow it later when we insert the arbitrary user code. That way there will be
1121         // no possibility of returning withou    1121         // no possibility of returning without `unsafe`.
1122         struct __InitOk;                         1122         struct __InitOk;
1123         // Get the data about fields from the    1123         // Get the data about fields from the supplied type.
1124         let data = unsafe {                      1124         let data = unsafe {
1125             use $crate::init::__internal::$ha    1125             use $crate::init::__internal::$has_data;
1126             // Here we abuse `paste!` to reto    1126             // Here we abuse `paste!` to retokenize `$t`. Declarative macros have some internal
1127             // information that is associated    1127             // information that is associated to already parsed fragments, so a path fragment
1128             // cannot be used in this positio    1128             // cannot be used in this position. Doing the retokenization results in valid rust
1129             // code.                             1129             // code.
1130             ::kernel::macros::paste!($t::$get    1130             ::kernel::macros::paste!($t::$get_data())
1131         };                                       1131         };
1132         // Ensure that `data` really is of ty    1132         // Ensure that `data` really is of type `$data` and help with type inference:
1133         let init = $crate::init::__internal::    1133         let init = $crate::init::__internal::$data::make_closure::<_, __InitOk, $err>(
1134             data,                                1134             data,
1135             move |slot| {                        1135             move |slot| {
1136                 {                                1136                 {
1137                     // Shadow the structure s    1137                     // Shadow the structure so it cannot be used to return early.
1138                     struct __InitOk;             1138                     struct __InitOk;
1139                     // If `$init_zeroed` is p    1139                     // If `$init_zeroed` is present we should zero the slot now and not emit an
1140                     // error when fields are     1140                     // error when fields are missing (since they will be zeroed). We also have to
1141                     // check that the type ac    1141                     // check that the type actually implements `Zeroable`.
1142                     $({                          1142                     $({
1143                         fn assert_zeroable<T:    1143                         fn assert_zeroable<T: $crate::init::Zeroable>(_: *mut T) {}
1144                         // Ensure that the st    1144                         // Ensure that the struct is indeed `Zeroable`.
1145                         assert_zeroable(slot)    1145                         assert_zeroable(slot);
1146                         // SAFETY: The type i    1146                         // SAFETY: The type implements `Zeroable` by the check above.
1147                         unsafe { ::core::ptr:    1147                         unsafe { ::core::ptr::write_bytes(slot, 0, 1) };
1148                         $init_zeroed // This     1148                         $init_zeroed // This will be `()` if set.
1149                     })?                          1149                     })?
1150                     // Create the `this` so i    1150                     // Create the `this` so it can be referenced by the user inside of the
1151                     // expressions creating t    1151                     // expressions creating the individual fields.
1152                     $(let $this = unsafe { ::    1152                     $(let $this = unsafe { ::core::ptr::NonNull::new_unchecked(slot) };)?
1153                     // Initialize every field    1153                     // Initialize every field.
1154                     $crate::__init_internal!(    1154                     $crate::__init_internal!(init_slot($($use_data)?):
1155                         @data(data),             1155                         @data(data),
1156                         @slot(slot),             1156                         @slot(slot),
1157                         @guards(),               1157                         @guards(),
1158                         @munch_fields($($fiel    1158                         @munch_fields($($fields)*,),
1159                     );                           1159                     );
1160                     // We use unreachable cod    1160                     // We use unreachable code to ensure that all fields have been mentioned exactly
1161                     // once, this struct init    1161                     // once, this struct initializer will still be type-checked and complain with a
1162                     // very natural error mes    1162                     // very natural error message if a field is forgotten/mentioned more than once.
1163                     #[allow(unreachable_code,    1163                     #[allow(unreachable_code, clippy::diverging_sub_expression)]
1164                     let _ = || {                 1164                     let _ = || {
1165                         $crate::__init_intern    1165                         $crate::__init_internal!(make_initializer:
1166                             @slot(slot),         1166                             @slot(slot),
1167                             @type_name($t),      1167                             @type_name($t),
1168                             @munch_fields($($    1168                             @munch_fields($($fields)*,),
1169                             @acc(),              1169                             @acc(),
1170                         );                       1170                         );
1171                     };                           1171                     };
1172                 }                                1172                 }
1173                 Ok(__InitOk)                     1173                 Ok(__InitOk)
1174             }                                    1174             }
1175         );                                       1175         );
1176         let init = move |slot| -> ::core::res    1176         let init = move |slot| -> ::core::result::Result<(), $err> {
1177             init(slot).map(|__InitOk| ())        1177             init(slot).map(|__InitOk| ())
1178         };                                       1178         };
1179         let init = unsafe { $crate::init::$co    1179         let init = unsafe { $crate::init::$construct_closure::<_, $err>(init) };
1180         init                                     1180         init
1181     }};                                          1181     }};
1182     (init_slot($($use_data:ident)?):             1182     (init_slot($($use_data:ident)?):
1183         @data($data:ident),                      1183         @data($data:ident),
1184         @slot($slot:ident),                      1184         @slot($slot:ident),
1185         @guards($($guards:ident,)*),             1185         @guards($($guards:ident,)*),
1186         @munch_fields($(..Zeroable::zeroed())    1186         @munch_fields($(..Zeroable::zeroed())? $(,)?),
1187     ) => {                                       1187     ) => {
1188         // Endpoint of munching, no fields ar    1188         // Endpoint of munching, no fields are left. If execution reaches this point, all fields
1189         // have been initialized. Therefore w    1189         // have been initialized. Therefore we can now dismiss the guards by forgetting them.
1190         $(::core::mem::forget($guards);)*        1190         $(::core::mem::forget($guards);)*
1191     };                                           1191     };
1192     (init_slot($use_data:ident): // `use_data    1192     (init_slot($use_data:ident): // `use_data` is present, so we use the `data` to init fields.
1193         @data($data:ident),                      1193         @data($data:ident),
1194         @slot($slot:ident),                      1194         @slot($slot:ident),
1195         @guards($($guards:ident,)*),             1195         @guards($($guards:ident,)*),
1196         // In-place initialization syntax.       1196         // In-place initialization syntax.
1197         @munch_fields($field:ident <- $val:ex    1197         @munch_fields($field:ident <- $val:expr, $($rest:tt)*),
1198     ) => {                                       1198     ) => {
1199         let init = $val;                         1199         let init = $val;
1200         // Call the initializer.                 1200         // Call the initializer.
1201         //                                       1201         //
1202         // SAFETY: `slot` is valid, because w    1202         // SAFETY: `slot` is valid, because we are inside of an initializer closure, we
1203         // return when an error/panic occurs.    1203         // return when an error/panic occurs.
1204         // We also use the `data` to require     1204         // We also use the `data` to require the correct trait (`Init` or `PinInit`) for `$field`.
1205         unsafe { $data.$field(::core::ptr::ad    1205         unsafe { $data.$field(::core::ptr::addr_of_mut!((*$slot).$field), init)? };
1206         // Create the drop guard:                1206         // Create the drop guard:
1207         //                                       1207         //
1208         // We rely on macro hygiene to make i    1208         // We rely on macro hygiene to make it impossible for users to access this local variable.
1209         // We use `paste!` to create new hygi    1209         // We use `paste!` to create new hygiene for `$field`.
1210         ::kernel::macros::paste! {               1210         ::kernel::macros::paste! {
1211             // SAFETY: We forget the guard la    1211             // SAFETY: We forget the guard later when initialization has succeeded.
1212             let [< __ $field _guard >] = unsa    1212             let [< __ $field _guard >] = unsafe {
1213                 $crate::init::__internal::Dro    1213                 $crate::init::__internal::DropGuard::new(::core::ptr::addr_of_mut!((*$slot).$field))
1214             };                                   1214             };
1215                                                  1215 
1216             $crate::__init_internal!(init_slo    1216             $crate::__init_internal!(init_slot($use_data):
1217                 @data($data),                    1217                 @data($data),
1218                 @slot($slot),                    1218                 @slot($slot),
1219                 @guards([< __ $field _guard >    1219                 @guards([< __ $field _guard >], $($guards,)*),
1220                 @munch_fields($($rest)*),        1220                 @munch_fields($($rest)*),
1221             );                                   1221             );
1222         }                                        1222         }
1223     };                                           1223     };
1224     (init_slot(): // No `use_data`, so we use    1224     (init_slot(): // No `use_data`, so we use `Init::__init` directly.
1225         @data($data:ident),                      1225         @data($data:ident),
1226         @slot($slot:ident),                      1226         @slot($slot:ident),
1227         @guards($($guards:ident,)*),             1227         @guards($($guards:ident,)*),
1228         // In-place initialization syntax.       1228         // In-place initialization syntax.
1229         @munch_fields($field:ident <- $val:ex    1229         @munch_fields($field:ident <- $val:expr, $($rest:tt)*),
1230     ) => {                                       1230     ) => {
1231         let init = $val;                         1231         let init = $val;
1232         // Call the initializer.                 1232         // Call the initializer.
1233         //                                       1233         //
1234         // SAFETY: `slot` is valid, because w    1234         // SAFETY: `slot` is valid, because we are inside of an initializer closure, we
1235         // return when an error/panic occurs.    1235         // return when an error/panic occurs.
1236         unsafe { $crate::init::Init::__init(i    1236         unsafe { $crate::init::Init::__init(init, ::core::ptr::addr_of_mut!((*$slot).$field))? };
1237         // Create the drop guard:                1237         // Create the drop guard:
1238         //                                       1238         //
1239         // We rely on macro hygiene to make i    1239         // We rely on macro hygiene to make it impossible for users to access this local variable.
1240         // We use `paste!` to create new hygi    1240         // We use `paste!` to create new hygiene for `$field`.
1241         ::kernel::macros::paste! {               1241         ::kernel::macros::paste! {
1242             // SAFETY: We forget the guard la    1242             // SAFETY: We forget the guard later when initialization has succeeded.
1243             let [< __ $field _guard >] = unsa    1243             let [< __ $field _guard >] = unsafe {
1244                 $crate::init::__internal::Dro    1244                 $crate::init::__internal::DropGuard::new(::core::ptr::addr_of_mut!((*$slot).$field))
1245             };                                   1245             };
1246                                                  1246 
1247             $crate::__init_internal!(init_slo    1247             $crate::__init_internal!(init_slot():
1248                 @data($data),                    1248                 @data($data),
1249                 @slot($slot),                    1249                 @slot($slot),
1250                 @guards([< __ $field _guard >    1250                 @guards([< __ $field _guard >], $($guards,)*),
1251                 @munch_fields($($rest)*),        1251                 @munch_fields($($rest)*),
1252             );                                   1252             );
1253         }                                        1253         }
1254     };                                           1254     };
1255     (init_slot($($use_data:ident)?):             1255     (init_slot($($use_data:ident)?):
1256         @data($data:ident),                      1256         @data($data:ident),
1257         @slot($slot:ident),                      1257         @slot($slot:ident),
1258         @guards($($guards:ident,)*),             1258         @guards($($guards:ident,)*),
1259         // Init by-value.                        1259         // Init by-value.
1260         @munch_fields($field:ident $(: $val:e    1260         @munch_fields($field:ident $(: $val:expr)?, $($rest:tt)*),
1261     ) => {                                       1261     ) => {
1262         {                                        1262         {
1263             $(let $field = $val;)?               1263             $(let $field = $val;)?
1264             // Initialize the field.             1264             // Initialize the field.
1265             //                                   1265             //
1266             // SAFETY: The memory at `slot` i    1266             // SAFETY: The memory at `slot` is uninitialized.
1267             unsafe { ::core::ptr::write(::cor    1267             unsafe { ::core::ptr::write(::core::ptr::addr_of_mut!((*$slot).$field), $field) };
1268         }                                        1268         }
1269         // Create the drop guard:                1269         // Create the drop guard:
1270         //                                       1270         //
1271         // We rely on macro hygiene to make i    1271         // We rely on macro hygiene to make it impossible for users to access this local variable.
1272         // We use `paste!` to create new hygi    1272         // We use `paste!` to create new hygiene for `$field`.
1273         ::kernel::macros::paste! {               1273         ::kernel::macros::paste! {
1274             // SAFETY: We forget the guard la    1274             // SAFETY: We forget the guard later when initialization has succeeded.
1275             let [< __ $field _guard >] = unsa    1275             let [< __ $field _guard >] = unsafe {
1276                 $crate::init::__internal::Dro    1276                 $crate::init::__internal::DropGuard::new(::core::ptr::addr_of_mut!((*$slot).$field))
1277             };                                   1277             };
1278                                                  1278 
1279             $crate::__init_internal!(init_slo    1279             $crate::__init_internal!(init_slot($($use_data)?):
1280                 @data($data),                    1280                 @data($data),
1281                 @slot($slot),                    1281                 @slot($slot),
1282                 @guards([< __ $field _guard >    1282                 @guards([< __ $field _guard >], $($guards,)*),
1283                 @munch_fields($($rest)*),        1283                 @munch_fields($($rest)*),
1284             );                                   1284             );
1285         }                                        1285         }
1286     };                                           1286     };
1287     (make_initializer:                           1287     (make_initializer:
1288         @slot($slot:ident),                      1288         @slot($slot:ident),
1289         @type_name($t:path),                     1289         @type_name($t:path),
1290         @munch_fields(..Zeroable::zeroed() $(    1290         @munch_fields(..Zeroable::zeroed() $(,)?),
1291         @acc($($acc:tt)*),                       1291         @acc($($acc:tt)*),
1292     ) => {                                       1292     ) => {
1293         // Endpoint, nothing more to munch, c    1293         // Endpoint, nothing more to munch, create the initializer. Since the users specified
1294         // `..Zeroable::zeroed()`, the slot w    1294         // `..Zeroable::zeroed()`, the slot will already have been zeroed and all field that have
1295         // not been overwritten are thus zero    1295         // not been overwritten are thus zero and initialized. We still check that all fields are
1296         // actually accessible by using the s    1296         // actually accessible by using the struct update syntax ourselves.
1297         // We are inside of a closure that is    1297         // We are inside of a closure that is never executed and thus we can abuse `slot` to
1298         // get the correct type inference her    1298         // get the correct type inference here:
1299         #[allow(unused_assignments)]             1299         #[allow(unused_assignments)]
1300         unsafe {                                 1300         unsafe {
1301             let mut zeroed = ::core::mem::zer    1301             let mut zeroed = ::core::mem::zeroed();
1302             // We have to use type inference     1302             // We have to use type inference here to make zeroed have the correct type. This does
1303             // not get executed, so it has no    1303             // not get executed, so it has no effect.
1304             ::core::ptr::write($slot, zeroed)    1304             ::core::ptr::write($slot, zeroed);
1305             zeroed = ::core::mem::zeroed();      1305             zeroed = ::core::mem::zeroed();
1306             // Here we abuse `paste!` to reto    1306             // Here we abuse `paste!` to retokenize `$t`. Declarative macros have some internal
1307             // information that is associated    1307             // information that is associated to already parsed fragments, so a path fragment
1308             // cannot be used in this positio    1308             // cannot be used in this position. Doing the retokenization results in valid rust
1309             // code.                             1309             // code.
1310             ::kernel::macros::paste!(            1310             ::kernel::macros::paste!(
1311                 ::core::ptr::write($slot, $t     1311                 ::core::ptr::write($slot, $t {
1312                     $($acc)*                     1312                     $($acc)*
1313                     ..zeroed                     1313                     ..zeroed
1314                 });                              1314                 });
1315             );                                   1315             );
1316         }                                        1316         }
1317     };                                           1317     };
1318     (make_initializer:                           1318     (make_initializer:
1319         @slot($slot:ident),                      1319         @slot($slot:ident),
1320         @type_name($t:path),                     1320         @type_name($t:path),
1321         @munch_fields($(,)?),                    1321         @munch_fields($(,)?),
1322         @acc($($acc:tt)*),                       1322         @acc($($acc:tt)*),
1323     ) => {                                       1323     ) => {
1324         // Endpoint, nothing more to munch, c    1324         // Endpoint, nothing more to munch, create the initializer.
1325         // Since we are in the closure that i    1325         // Since we are in the closure that is never called, this will never get executed.
1326         // We abuse `slot` to get the correct    1326         // We abuse `slot` to get the correct type inference here:
1327         unsafe {                                 1327         unsafe {
1328             // Here we abuse `paste!` to reto    1328             // Here we abuse `paste!` to retokenize `$t`. Declarative macros have some internal
1329             // information that is associated    1329             // information that is associated to already parsed fragments, so a path fragment
1330             // cannot be used in this positio    1330             // cannot be used in this position. Doing the retokenization results in valid rust
1331             // code.                             1331             // code.
1332             ::kernel::macros::paste!(            1332             ::kernel::macros::paste!(
1333                 ::core::ptr::write($slot, $t     1333                 ::core::ptr::write($slot, $t {
1334                     $($acc)*                     1334                     $($acc)*
1335                 });                              1335                 });
1336             );                                   1336             );
1337         }                                        1337         }
1338     };                                           1338     };
1339     (make_initializer:                           1339     (make_initializer:
1340         @slot($slot:ident),                      1340         @slot($slot:ident),
1341         @type_name($t:path),                     1341         @type_name($t:path),
1342         @munch_fields($field:ident <- $val:ex    1342         @munch_fields($field:ident <- $val:expr, $($rest:tt)*),
1343         @acc($($acc:tt)*),                       1343         @acc($($acc:tt)*),
1344     ) => {                                       1344     ) => {
1345         $crate::__init_internal!(make_initial    1345         $crate::__init_internal!(make_initializer:
1346             @slot($slot),                        1346             @slot($slot),
1347             @type_name($t),                      1347             @type_name($t),
1348             @munch_fields($($rest)*),            1348             @munch_fields($($rest)*),
1349             @acc($($acc)* $field: ::core::pan    1349             @acc($($acc)* $field: ::core::panic!(),),
1350         );                                       1350         );
1351     };                                           1351     };
1352     (make_initializer:                           1352     (make_initializer:
1353         @slot($slot:ident),                      1353         @slot($slot:ident),
1354         @type_name($t:path),                     1354         @type_name($t:path),
1355         @munch_fields($field:ident $(: $val:e    1355         @munch_fields($field:ident $(: $val:expr)?, $($rest:tt)*),
1356         @acc($($acc:tt)*),                       1356         @acc($($acc:tt)*),
1357     ) => {                                       1357     ) => {
1358         $crate::__init_internal!(make_initial    1358         $crate::__init_internal!(make_initializer:
1359             @slot($slot),                        1359             @slot($slot),
1360             @type_name($t),                      1360             @type_name($t),
1361             @munch_fields($($rest)*),            1361             @munch_fields($($rest)*),
1362             @acc($($acc)* $field: ::core::pan    1362             @acc($($acc)* $field: ::core::panic!(),),
1363         );                                       1363         );
1364     };                                           1364     };
1365 }                                                1365 }
1366                                                  1366 
1367 #[doc(hidden)]                                   1367 #[doc(hidden)]
1368 #[macro_export]                                  1368 #[macro_export]
1369 macro_rules! __derive_zeroable {                 1369 macro_rules! __derive_zeroable {
1370     (parse_input:                                1370     (parse_input:
1371         @sig(                                    1371         @sig(
1372             $(#[$($struct_attr:tt)*])*           1372             $(#[$($struct_attr:tt)*])*
1373             $vis:vis struct $name:ident          1373             $vis:vis struct $name:ident
1374             $(where $($whr:tt)*)?                1374             $(where $($whr:tt)*)?
1375         ),                                       1375         ),
1376         @impl_generics($($impl_generics:tt)*)    1376         @impl_generics($($impl_generics:tt)*),
1377         @ty_generics($($ty_generics:tt)*),       1377         @ty_generics($($ty_generics:tt)*),
1378         @body({                                  1378         @body({
1379             $(                                   1379             $(
1380                 $(#[$($field_attr:tt)*])*        1380                 $(#[$($field_attr:tt)*])*
1381                 $field:ident : $field_ty:ty      1381                 $field:ident : $field_ty:ty
1382             ),* $(,)?                            1382             ),* $(,)?
1383         }),                                      1383         }),
1384     ) => {                                       1384     ) => {
1385         // SAFETY: Every field type implement    1385         // SAFETY: Every field type implements `Zeroable` and padding bytes may be zero.
1386         #[automatically_derived]                 1386         #[automatically_derived]
1387         unsafe impl<$($impl_generics)*> $crat    1387         unsafe impl<$($impl_generics)*> $crate::init::Zeroable for $name<$($ty_generics)*>
1388         where                                    1388         where
1389             $($($whr)*)?                         1389             $($($whr)*)?
1390         {}                                       1390         {}
1391         const _: () = {                          1391         const _: () = {
1392             fn assert_zeroable<T: ?::core::ma    1392             fn assert_zeroable<T: ?::core::marker::Sized + $crate::init::Zeroable>() {}
1393             fn ensure_zeroable<$($impl_generi    1393             fn ensure_zeroable<$($impl_generics)*>()
1394                 where $($($whr)*)?               1394                 where $($($whr)*)?
1395             {                                    1395             {
1396                 $(assert_zeroable::<$field_ty    1396                 $(assert_zeroable::<$field_ty>();)*
1397             }                                    1397             }
1398         };                                       1398         };
1399     };                                           1399     };
1400 }                                                1400 }
                                                      

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

sflogo.php