1 use pin_project_lite::pin_project;
2 enum Enum<T, U> {
3     Struct { pinned: T, unpinned: U },
4     Unit,
5 }
6 #[doc(hidden)]
7 #[allow(dead_code)]
8 #[allow(single_use_lifetimes)]
9 #[allow(clippy::unknown_clippy_lints)]
10 #[allow(clippy::mut_mut)]
11 #[allow(clippy::redundant_pub_crate)]
12 #[allow(clippy::ref_option_ref)]
13 #[allow(clippy::type_repetition_in_bounds)]
14 enum EnumProj<'__pin, T, U>
15 where
16     Enum<T, U>: '__pin,
17 {
18     Struct {
19         pinned: ::pin_project_lite::__private::Pin<&'__pin mut (T)>,
20         unpinned: &'__pin mut (U),
21     },
22     Unit,
23 }
24 #[doc(hidden)]
25 #[allow(dead_code)]
26 #[allow(single_use_lifetimes)]
27 #[allow(clippy::unknown_clippy_lints)]
28 #[allow(clippy::mut_mut)]
29 #[allow(clippy::redundant_pub_crate)]
30 #[allow(clippy::ref_option_ref)]
31 #[allow(clippy::type_repetition_in_bounds)]
32 enum EnumProjRef<'__pin, T, U>
33 where
34     Enum<T, U>: '__pin,
35 {
36     Struct {
37         pinned: ::pin_project_lite::__private::Pin<&'__pin (T)>,
38         unpinned: &'__pin (U),
39     },
40     Unit,
41 }
42 #[doc(hidden)]
43 #[allow(dead_code)]
44 #[allow(single_use_lifetimes)]
45 #[allow(clippy::mut_mut)]
46 #[allow(clippy::redundant_pub_crate)]
47 #[allow(clippy::type_repetition_in_bounds)]
48 enum EnumProjReplace<T, U> {
49     Struct { pinned: ::pin_project_lite::__private::PhantomData<T>, unpinned: U },
50     Unit,
51 }
52 #[allow(single_use_lifetimes)]
53 #[allow(clippy::unknown_clippy_lints)]
54 #[allow(clippy::used_underscore_binding)]
55 const _: () = {
56     impl<T, U> Enum<T, U> {
57         #[doc(hidden)]
58         #[inline]
project<'__pin>( self: ::pin_project_lite::__private::Pin<&'__pin mut Self>, ) -> EnumProj<'__pin, T, U>59         fn project<'__pin>(
60             self: ::pin_project_lite::__private::Pin<&'__pin mut Self>,
61         ) -> EnumProj<'__pin, T, U> {
62             unsafe {
63                 match self.get_unchecked_mut() {
64                     Self::Struct { pinned, unpinned } => {
65                         EnumProj::Struct {
66                             pinned: ::pin_project_lite::__private::Pin::new_unchecked(
67                                 pinned,
68                             ),
69                             unpinned: unpinned,
70                         }
71                     }
72                     Self::Unit => EnumProj::Unit,
73                 }
74             }
75         }
76         #[doc(hidden)]
77         #[inline]
project_ref<'__pin>( self: ::pin_project_lite::__private::Pin<&'__pin Self>, ) -> EnumProjRef<'__pin, T, U>78         fn project_ref<'__pin>(
79             self: ::pin_project_lite::__private::Pin<&'__pin Self>,
80         ) -> EnumProjRef<'__pin, T, U> {
81             unsafe {
82                 match self.get_ref() {
83                     Self::Struct { pinned, unpinned } => {
84                         EnumProjRef::Struct {
85                             pinned: ::pin_project_lite::__private::Pin::new_unchecked(
86                                 pinned,
87                             ),
88                             unpinned: unpinned,
89                         }
90                     }
91                     Self::Unit => EnumProjRef::Unit,
92                 }
93             }
94         }
95         #[doc(hidden)]
96         #[inline]
project_replace( self: ::pin_project_lite::__private::Pin<&mut Self>, replacement: Self, ) -> EnumProjReplace<T, U>97         fn project_replace(
98             self: ::pin_project_lite::__private::Pin<&mut Self>,
99             replacement: Self,
100         ) -> EnumProjReplace<T, U> {
101             unsafe {
102                 let __self_ptr: *mut Self = self.get_unchecked_mut();
103                 let __guard = ::pin_project_lite::__private::UnsafeOverwriteGuard::new(
104                     __self_ptr,
105                     replacement,
106                 );
107                 match &mut *__self_ptr {
108                     Self::Struct { pinned, unpinned } => {
109                         let result = EnumProjReplace::Struct {
110                             pinned: ::pin_project_lite::__private::PhantomData,
111                             unpinned: ::pin_project_lite::__private::ptr::read(unpinned),
112                         };
113                         {
114                             (
115                                 ::pin_project_lite::__private::UnsafeDropInPlaceGuard::new(
116                                     pinned,
117                                 ),
118                                 (),
119                             );
120                         }
121                         result
122                     }
123                     Self::Unit => EnumProjReplace::Unit,
124                 }
125             }
126         }
127     }
128     #[allow(non_snake_case)]
129     struct __Origin<'__pin, T, U> {
130         __dummy_lifetime: ::pin_project_lite::__private::PhantomData<&'__pin ()>,
131         Struct: (T, ::pin_project_lite::__private::AlwaysUnpin<U>),
132         Unit: (),
133     }
134     impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Enum<T, U>
135     where
136         __Origin<'__pin, T, U>: ::pin_project_lite::__private::Unpin,
137     {}
138     trait MustNotImplDrop {}
139     #[allow(clippy::drop_bounds, drop_bounds)]
140     impl<T: ::pin_project_lite::__private::Drop> MustNotImplDrop for T {}
141     impl<T, U> MustNotImplDrop for Enum<T, U> {}
142 };
main()143 fn main() {}
144