1 use pin_project::pin_project;
2 #[pin(__private(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(variant_size_differences)]
20 #[allow(clippy::large_enum_variant)]
21 enum ProjOwn<T, U> {
22     Struct { pinned: ::pin_project::__private::PhantomData<T>, unpinned: U },
23     Tuple(::pin_project::__private::PhantomData<T>, U),
24     Unit,
25 }
26 #[allow(box_pointers)]
27 #[allow(deprecated)]
28 #[allow(explicit_outlives_requirements)]
29 #[allow(single_use_lifetimes)]
30 #[allow(unreachable_pub)]
31 #[allow(unused_tuple_struct_fields)]
32 #[allow(clippy::unknown_clippy_lints)]
33 #[allow(clippy::pattern_type_mismatch)]
34 #[allow(clippy::redundant_pub_crate)]
35 #[allow(clippy::type_repetition_in_bounds)]
36 #[allow(unused_qualifications)]
37 #[allow(clippy::semicolon_if_nothing_returned)]
38 #[allow(clippy::use_self)]
39 #[allow(clippy::used_underscore_binding)]
40 const _: () = {
41     #[allow(unused_extern_crates)]
42     extern crate pin_project as _pin_project;
43     impl<T, U> Enum<T, U> {
44         #[allow(dead_code)]
45         #[inline]
project_replace( self: _pin_project::__private::Pin<&mut Self>, __replacement: Self, ) -> ProjOwn<T, U>46         fn project_replace(
47             self: _pin_project::__private::Pin<&mut Self>,
48             __replacement: Self,
49         ) -> ProjOwn<T, U> {
50             unsafe {
51                 let __self_ptr: *mut Self = self.get_unchecked_mut();
52                 let __guard = _pin_project::__private::UnsafeOverwriteGuard::new(
53                     __self_ptr,
54                     __replacement,
55                 );
56                 match &mut *__self_ptr {
57                     Self::Struct { pinned, unpinned } => {
58                         let __result = ProjOwn::Struct {
59                             pinned: _pin_project::__private::PhantomData,
60                             unpinned: _pin_project::__private::ptr::read(unpinned),
61                         };
62                         {
63                             let __guard = _pin_project::__private::UnsafeDropInPlaceGuard::new(
64                                 pinned,
65                             );
66                         }
67                         __result
68                     }
69                     Self::Tuple(_0, _1) => {
70                         let __result = ProjOwn::Tuple(
71                             _pin_project::__private::PhantomData,
72                             _pin_project::__private::ptr::read(_1),
73                         );
74                         {
75                             let __guard = _pin_project::__private::UnsafeDropInPlaceGuard::new(
76                                 _0,
77                             );
78                         }
79                         __result
80                     }
81                     Self::Unit => {
82                         let __result = ProjOwn::Unit;
83                         {}
84                         __result
85                     }
86                 }
87             }
88         }
89     }
90     #[allow(missing_debug_implementations)]
91     struct __Enum<'pin, T, U> {
92         __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
93             'pin,
94             (
95                 _pin_project::__private::PhantomData<T>,
96                 _pin_project::__private::PhantomData<U>,
97             ),
98         >,
99         __field0: T,
100         __field1: T,
101     }
102     impl<'pin, T, U> _pin_project::__private::Unpin for Enum<T, U>
103     where
104         __Enum<'pin, T, U>: _pin_project::__private::Unpin,
105     {}
106     #[doc(hidden)]
107     unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Enum<T, U>
108     where
109         __Enum<'pin, T, U>: _pin_project::__private::Unpin,
110     {}
111     trait EnumMustNotImplDrop {}
112     #[allow(clippy::drop_bounds, drop_bounds)]
113     impl<T: _pin_project::__private::Drop> EnumMustNotImplDrop for T {}
114     impl<T, U> EnumMustNotImplDrop for Enum<T, U> {}
115     #[doc(hidden)]
116     impl<T, U> _pin_project::__private::PinnedDrop for Enum<T, U> {
drop(self: _pin_project::__private::Pin<&mut Self>)117         unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
118     }
119 };
main()120 fn main() {}
121