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