1 use pin_project::pin_project;
2 #[pin(__private(project = Proj, project_ref = ProjRef, project_replace = ProjOwn))]
3 enum Enum<T, U> {
4 Struct { #[pin] pinned: T, unpinned: U },
5 Tuple(#[pin] T, U),
6 Unit,
7 }
8 #[allow(box_pointers)]
9 #[allow(deprecated)]
10 #[allow(explicit_outlives_requirements)]
11 #[allow(single_use_lifetimes)]
12 #[allow(unreachable_pub)]
13 #[allow(unused_tuple_struct_fields)]
14 #[allow(clippy::unknown_clippy_lints)]
15 #[allow(clippy::pattern_type_mismatch)]
16 #[allow(clippy::redundant_pub_crate)]
17 #[allow(clippy::type_repetition_in_bounds)]
18 #[allow(dead_code)]
19 #[allow(clippy::mut_mut)]
20 enum Proj<'pin, T, U>
21 where
22 Enum<T, U>: 'pin,
23 {
24 Struct {
25 pinned: ::pin_project::__private::Pin<&'pin mut (T)>,
26 unpinned: &'pin mut (U),
27 },
28 Tuple(::pin_project::__private::Pin<&'pin mut (T)>, &'pin mut (U)),
29 Unit,
30 }
31 #[allow(box_pointers)]
32 #[allow(deprecated)]
33 #[allow(explicit_outlives_requirements)]
34 #[allow(single_use_lifetimes)]
35 #[allow(unreachable_pub)]
36 #[allow(unused_tuple_struct_fields)]
37 #[allow(clippy::unknown_clippy_lints)]
38 #[allow(clippy::pattern_type_mismatch)]
39 #[allow(clippy::redundant_pub_crate)]
40 #[allow(clippy::type_repetition_in_bounds)]
41 #[allow(dead_code)]
42 #[allow(clippy::ref_option_ref)]
43 enum ProjRef<'pin, T, U>
44 where
45 Enum<T, U>: 'pin,
46 {
47 Struct { pinned: ::pin_project::__private::Pin<&'pin (T)>, unpinned: &'pin (U) },
48 Tuple(::pin_project::__private::Pin<&'pin (T)>, &'pin (U)),
49 Unit,
50 }
51 #[allow(box_pointers)]
52 #[allow(deprecated)]
53 #[allow(explicit_outlives_requirements)]
54 #[allow(single_use_lifetimes)]
55 #[allow(unreachable_pub)]
56 #[allow(unused_tuple_struct_fields)]
57 #[allow(clippy::unknown_clippy_lints)]
58 #[allow(clippy::pattern_type_mismatch)]
59 #[allow(clippy::redundant_pub_crate)]
60 #[allow(clippy::type_repetition_in_bounds)]
61 #[allow(dead_code)]
62 #[allow(variant_size_differences)]
63 #[allow(clippy::large_enum_variant)]
64 enum ProjOwn<T, U> {
65 Struct { pinned: ::pin_project::__private::PhantomData<T>, unpinned: U },
66 Tuple(::pin_project::__private::PhantomData<T>, U),
67 Unit,
68 }
69 #[allow(box_pointers)]
70 #[allow(deprecated)]
71 #[allow(explicit_outlives_requirements)]
72 #[allow(single_use_lifetimes)]
73 #[allow(unreachable_pub)]
74 #[allow(unused_tuple_struct_fields)]
75 #[allow(clippy::unknown_clippy_lints)]
76 #[allow(clippy::pattern_type_mismatch)]
77 #[allow(clippy::redundant_pub_crate)]
78 #[allow(clippy::type_repetition_in_bounds)]
79 #[allow(unused_qualifications)]
80 #[allow(clippy::semicolon_if_nothing_returned)]
81 #[allow(clippy::use_self)]
82 #[allow(clippy::used_underscore_binding)]
83 const _: () = {
84 #[allow(unused_extern_crates)]
85 extern crate pin_project as _pin_project;
86 impl<T, U> Enum<T, U> {
87 #[allow(dead_code)]
88 #[inline]
project<'pin>( self: _pin_project::__private::Pin<&'pin mut Self>, ) -> Proj<'pin, T, U>89 fn project<'pin>(
90 self: _pin_project::__private::Pin<&'pin mut Self>,
91 ) -> Proj<'pin, T, U> {
92 unsafe {
93 match self.get_unchecked_mut() {
94 Self::Struct { pinned, unpinned } => {
95 Proj::Struct {
96 pinned: _pin_project::__private::Pin::new_unchecked(pinned),
97 unpinned,
98 }
99 }
100 Self::Tuple(_0, _1) => {
101 Proj::Tuple(_pin_project::__private::Pin::new_unchecked(_0), _1)
102 }
103 Self::Unit => Proj::Unit,
104 }
105 }
106 }
107 #[allow(dead_code)]
108 #[allow(clippy::missing_const_for_fn)]
109 #[inline]
project_ref<'pin>( self: _pin_project::__private::Pin<&'pin Self>, ) -> ProjRef<'pin, T, U>110 fn project_ref<'pin>(
111 self: _pin_project::__private::Pin<&'pin Self>,
112 ) -> ProjRef<'pin, T, U> {
113 unsafe {
114 match self.get_ref() {
115 Self::Struct { pinned, unpinned } => {
116 ProjRef::Struct {
117 pinned: _pin_project::__private::Pin::new_unchecked(pinned),
118 unpinned,
119 }
120 }
121 Self::Tuple(_0, _1) => {
122 ProjRef::Tuple(
123 _pin_project::__private::Pin::new_unchecked(_0),
124 _1,
125 )
126 }
127 Self::Unit => ProjRef::Unit,
128 }
129 }
130 }
131 #[allow(dead_code)]
132 #[inline]
project_replace( self: _pin_project::__private::Pin<&mut Self>, __replacement: Self, ) -> ProjOwn<T, U>133 fn project_replace(
134 self: _pin_project::__private::Pin<&mut Self>,
135 __replacement: Self,
136 ) -> ProjOwn<T, U> {
137 unsafe {
138 let __self_ptr: *mut Self = self.get_unchecked_mut();
139 let __guard = _pin_project::__private::UnsafeOverwriteGuard::new(
140 __self_ptr,
141 __replacement,
142 );
143 match &mut *__self_ptr {
144 Self::Struct { pinned, unpinned } => {
145 let __result = ProjOwn::Struct {
146 pinned: _pin_project::__private::PhantomData,
147 unpinned: _pin_project::__private::ptr::read(unpinned),
148 };
149 {
150 let __guard = _pin_project::__private::UnsafeDropInPlaceGuard::new(
151 pinned,
152 );
153 }
154 __result
155 }
156 Self::Tuple(_0, _1) => {
157 let __result = ProjOwn::Tuple(
158 _pin_project::__private::PhantomData,
159 _pin_project::__private::ptr::read(_1),
160 );
161 {
162 let __guard = _pin_project::__private::UnsafeDropInPlaceGuard::new(
163 _0,
164 );
165 }
166 __result
167 }
168 Self::Unit => {
169 let __result = ProjOwn::Unit;
170 {}
171 __result
172 }
173 }
174 }
175 }
176 }
177 #[allow(missing_debug_implementations)]
178 struct __Enum<'pin, T, U> {
179 __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
180 'pin,
181 (
182 _pin_project::__private::PhantomData<T>,
183 _pin_project::__private::PhantomData<U>,
184 ),
185 >,
186 __field0: T,
187 __field1: T,
188 }
189 impl<'pin, T, U> _pin_project::__private::Unpin for Enum<T, U>
190 where
191 __Enum<'pin, T, U>: _pin_project::__private::Unpin,
192 {}
193 #[doc(hidden)]
194 unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Enum<T, U>
195 where
196 __Enum<'pin, T, U>: _pin_project::__private::Unpin,
197 {}
198 trait EnumMustNotImplDrop {}
199 #[allow(clippy::drop_bounds, drop_bounds)]
200 impl<T: _pin_project::__private::Drop> EnumMustNotImplDrop for T {}
201 impl<T, U> EnumMustNotImplDrop for Enum<T, U> {}
202 #[doc(hidden)]
203 impl<T, U> _pin_project::__private::PinnedDrop for Enum<T, U> {
drop(self: _pin_project::__private::Pin<&mut Self>)204 unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
205 }
206 };
main()207 fn main() {}
208