1 use pin_project::pin_project;
2 #[pin(
3 __private(
4 project = EnumProj,
5 project_ref = EnumProjRef,
6 project_replace = EnumProjOwn
7 )
8 )]
9 enum Enum<T, U> {
10 Struct { #[pin] pinned1: T, #[pin] pinned2: T, unpinned1: U, unpinned2: U },
11 Tuple(#[pin] T, #[pin] T, U, U),
12 Unit,
13 }
14 #[allow(
15 dead_code,
16 deprecated,
17 explicit_outlives_requirements,
18 single_use_lifetimes,
19 unreachable_pub,
20 unused_tuple_struct_fields,
21 clippy::unknown_clippy_lints,
22 clippy::absolute_paths,
23 clippy::min_ident_chars,
24 clippy::pattern_type_mismatch,
25 clippy::pub_with_shorthand,
26 clippy::redundant_pub_crate,
27 clippy::single_char_lifetime_names,
28 clippy::type_repetition_in_bounds,
29 clippy::missing_docs_in_private_items,
30 clippy::mut_mut
31 )]
32 enum EnumProj<'pin, T, U>
33 where
34 Enum<T, U>: 'pin,
35 {
36 Struct {
37 pinned1: ::pin_project::__private::Pin<&'pin mut (T)>,
38 pinned2: ::pin_project::__private::Pin<&'pin mut (T)>,
39 unpinned1: &'pin mut (U),
40 unpinned2: &'pin mut (U),
41 },
42 Tuple(
43 ::pin_project::__private::Pin<&'pin mut (T)>,
44 ::pin_project::__private::Pin<&'pin mut (T)>,
45 &'pin mut (U),
46 &'pin mut (U),
47 ),
48 Unit,
49 }
50 #[allow(
51 dead_code,
52 deprecated,
53 explicit_outlives_requirements,
54 single_use_lifetimes,
55 unreachable_pub,
56 unused_tuple_struct_fields,
57 clippy::unknown_clippy_lints,
58 clippy::absolute_paths,
59 clippy::min_ident_chars,
60 clippy::pattern_type_mismatch,
61 clippy::pub_with_shorthand,
62 clippy::redundant_pub_crate,
63 clippy::single_char_lifetime_names,
64 clippy::type_repetition_in_bounds,
65 clippy::missing_docs_in_private_items,
66 clippy::ref_option_ref
67 )]
68 enum EnumProjRef<'pin, T, U>
69 where
70 Enum<T, U>: 'pin,
71 {
72 Struct {
73 pinned1: ::pin_project::__private::Pin<&'pin (T)>,
74 pinned2: ::pin_project::__private::Pin<&'pin (T)>,
75 unpinned1: &'pin (U),
76 unpinned2: &'pin (U),
77 },
78 Tuple(
79 ::pin_project::__private::Pin<&'pin (T)>,
80 ::pin_project::__private::Pin<&'pin (T)>,
81 &'pin (U),
82 &'pin (U),
83 ),
84 Unit,
85 }
86 #[allow(
87 dead_code,
88 deprecated,
89 explicit_outlives_requirements,
90 single_use_lifetimes,
91 unreachable_pub,
92 unused_tuple_struct_fields,
93 clippy::unknown_clippy_lints,
94 clippy::absolute_paths,
95 clippy::min_ident_chars,
96 clippy::pattern_type_mismatch,
97 clippy::pub_with_shorthand,
98 clippy::redundant_pub_crate,
99 clippy::single_char_lifetime_names,
100 clippy::type_repetition_in_bounds,
101 variant_size_differences,
102 clippy::large_enum_variant,
103 clippy::missing_docs_in_private_items
104 )]
105 enum EnumProjOwn<T, U> {
106 Struct {
107 pinned1: ::pin_project::__private::PhantomData<T>,
108 pinned2: ::pin_project::__private::PhantomData<T>,
109 unpinned1: U,
110 unpinned2: U,
111 },
112 Tuple(
113 ::pin_project::__private::PhantomData<T>,
114 ::pin_project::__private::PhantomData<T>,
115 U,
116 U,
117 ),
118 Unit,
119 }
120 #[allow(
121 unused_qualifications,
122 deprecated,
123 explicit_outlives_requirements,
124 single_use_lifetimes,
125 unreachable_pub,
126 unused_tuple_struct_fields,
127 clippy::unknown_clippy_lints,
128 clippy::absolute_paths,
129 clippy::min_ident_chars,
130 clippy::pattern_type_mismatch,
131 clippy::pub_with_shorthand,
132 clippy::redundant_pub_crate,
133 clippy::single_char_lifetime_names,
134 clippy::type_repetition_in_bounds,
135 clippy::needless_lifetimes,
136 clippy::semicolon_if_nothing_returned,
137 clippy::use_self,
138 clippy::used_underscore_binding
139 )]
140 const _: () = {
141 #[allow(unused_extern_crates)]
142 extern crate pin_project as _pin_project;
143 impl<T, U> Enum<T, U> {
144 #[allow(dead_code)]
145 #[inline]
project<'pin>( self: _pin_project::__private::Pin<&'pin mut Self>, ) -> EnumProj<'pin, T, U>146 fn project<'pin>(
147 self: _pin_project::__private::Pin<&'pin mut Self>,
148 ) -> EnumProj<'pin, T, U> {
149 unsafe {
150 match self.get_unchecked_mut() {
151 Self::Struct { pinned1, pinned2, unpinned1, unpinned2 } => {
152 EnumProj::Struct {
153 pinned1: _pin_project::__private::Pin::new_unchecked(
154 pinned1,
155 ),
156 pinned2: _pin_project::__private::Pin::new_unchecked(
157 pinned2,
158 ),
159 unpinned1,
160 unpinned2,
161 }
162 }
163 Self::Tuple(_0, _1, _2, _3) => {
164 EnumProj::Tuple(
165 _pin_project::__private::Pin::new_unchecked(_0),
166 _pin_project::__private::Pin::new_unchecked(_1),
167 _2,
168 _3,
169 )
170 }
171 Self::Unit => EnumProj::Unit,
172 }
173 }
174 }
175 #[allow(dead_code)]
176 #[allow(clippy::missing_const_for_fn)]
177 #[inline]
project_ref<'pin>( self: _pin_project::__private::Pin<&'pin Self>, ) -> EnumProjRef<'pin, T, U>178 fn project_ref<'pin>(
179 self: _pin_project::__private::Pin<&'pin Self>,
180 ) -> EnumProjRef<'pin, T, U> {
181 unsafe {
182 match self.get_ref() {
183 Self::Struct { pinned1, pinned2, unpinned1, unpinned2 } => {
184 EnumProjRef::Struct {
185 pinned1: _pin_project::__private::Pin::new_unchecked(
186 pinned1,
187 ),
188 pinned2: _pin_project::__private::Pin::new_unchecked(
189 pinned2,
190 ),
191 unpinned1,
192 unpinned2,
193 }
194 }
195 Self::Tuple(_0, _1, _2, _3) => {
196 EnumProjRef::Tuple(
197 _pin_project::__private::Pin::new_unchecked(_0),
198 _pin_project::__private::Pin::new_unchecked(_1),
199 _2,
200 _3,
201 )
202 }
203 Self::Unit => EnumProjRef::Unit,
204 }
205 }
206 }
207 #[allow(dead_code)]
208 #[inline]
project_replace( self: _pin_project::__private::Pin<&mut Self>, __replacement: Self, ) -> EnumProjOwn<T, U>209 fn project_replace(
210 self: _pin_project::__private::Pin<&mut Self>,
211 __replacement: Self,
212 ) -> EnumProjOwn<T, U> {
213 unsafe {
214 let __self_ptr: *mut Self = self.get_unchecked_mut();
215 let __guard = _pin_project::__private::UnsafeOverwriteGuard::new(
216 __self_ptr,
217 __replacement,
218 );
219 match &mut *__self_ptr {
220 Self::Struct { pinned1, pinned2, unpinned1, unpinned2 } => {
221 let __result = EnumProjOwn::Struct {
222 pinned1: _pin_project::__private::PhantomData,
223 pinned2: _pin_project::__private::PhantomData,
224 unpinned1: _pin_project::__private::ptr::read(unpinned1),
225 unpinned2: _pin_project::__private::ptr::read(unpinned2),
226 };
227 {
228 let __guard = _pin_project::__private::UnsafeDropInPlaceGuard::new(
229 pinned2,
230 );
231 let __guard = _pin_project::__private::UnsafeDropInPlaceGuard::new(
232 pinned1,
233 );
234 }
235 __result
236 }
237 Self::Tuple(_0, _1, _2, _3) => {
238 let __result = EnumProjOwn::Tuple(
239 _pin_project::__private::PhantomData,
240 _pin_project::__private::PhantomData,
241 _pin_project::__private::ptr::read(_2),
242 _pin_project::__private::ptr::read(_3),
243 );
244 {
245 let __guard = _pin_project::__private::UnsafeDropInPlaceGuard::new(
246 _1,
247 );
248 let __guard = _pin_project::__private::UnsafeDropInPlaceGuard::new(
249 _0,
250 );
251 }
252 __result
253 }
254 Self::Unit => {
255 let __result = EnumProjOwn::Unit;
256 {}
257 __result
258 }
259 }
260 }
261 }
262 }
263 #[allow(missing_debug_implementations, unnameable_types)]
264 struct __Enum<'pin, T, U> {
265 __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
266 'pin,
267 (
268 _pin_project::__private::PhantomData<T>,
269 _pin_project::__private::PhantomData<U>,
270 ),
271 >,
272 __field0: T,
273 __field1: T,
274 __field2: T,
275 __field3: T,
276 }
277 impl<'pin, T, U> _pin_project::__private::Unpin for Enum<T, U>
278 where
279 _pin_project::__private::PinnedFieldsOf<
280 __Enum<'pin, T, U>,
281 >: _pin_project::__private::Unpin,
282 {}
283 #[doc(hidden)]
284 unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Enum<T, U>
285 where
286 _pin_project::__private::PinnedFieldsOf<
287 __Enum<'pin, T, U>,
288 >: _pin_project::__private::Unpin,
289 {}
290 trait EnumMustNotImplDrop {}
291 #[allow(clippy::drop_bounds, drop_bounds)]
292 impl<T: _pin_project::__private::Drop> EnumMustNotImplDrop for T {}
293 impl<T, U> EnumMustNotImplDrop for Enum<T, U> {}
294 #[doc(hidden)]
295 impl<T, U> _pin_project::__private::PinnedDrop for Enum<T, U> {
drop(self: _pin_project::__private::Pin<&mut Self>)296 unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
297 }
298 };
main()299 fn main() {}
300