1 use std::pin::Pin;
2 use pin_project::{pin_project, pinned_drop};
3 #[pin(__private(PinnedDrop, project = EnumProj, project_ref = EnumProjRef))]
4 enum Enum<T, U> {
5 Struct { #[pin] pinned: T, unpinned: U },
6 Tuple(#[pin] T, U),
7 Unit,
8 }
9 #[allow(box_pointers)]
10 #[allow(deprecated)]
11 #[allow(explicit_outlives_requirements)]
12 #[allow(single_use_lifetimes)]
13 #[allow(unreachable_pub)]
14 #[allow(unused_tuple_struct_fields)]
15 #[allow(clippy::unknown_clippy_lints)]
16 #[allow(clippy::pattern_type_mismatch)]
17 #[allow(clippy::redundant_pub_crate)]
18 #[allow(clippy::type_repetition_in_bounds)]
19 #[allow(dead_code)]
20 #[allow(clippy::mut_mut)]
21 enum EnumProj<'pin, T, U>
22 where
23 Enum<T, U>: 'pin,
24 {
25 Struct {
26 pinned: ::pin_project::__private::Pin<&'pin mut (T)>,
27 unpinned: &'pin mut (U),
28 },
29 Tuple(::pin_project::__private::Pin<&'pin mut (T)>, &'pin mut (U)),
30 Unit,
31 }
32 #[allow(box_pointers)]
33 #[allow(deprecated)]
34 #[allow(explicit_outlives_requirements)]
35 #[allow(single_use_lifetimes)]
36 #[allow(unreachable_pub)]
37 #[allow(unused_tuple_struct_fields)]
38 #[allow(clippy::unknown_clippy_lints)]
39 #[allow(clippy::pattern_type_mismatch)]
40 #[allow(clippy::redundant_pub_crate)]
41 #[allow(clippy::type_repetition_in_bounds)]
42 #[allow(dead_code)]
43 #[allow(clippy::ref_option_ref)]
44 enum EnumProjRef<'pin, T, U>
45 where
46 Enum<T, U>: 'pin,
47 {
48 Struct { pinned: ::pin_project::__private::Pin<&'pin (T)>, unpinned: &'pin (U) },
49 Tuple(::pin_project::__private::Pin<&'pin (T)>, &'pin (U)),
50 Unit,
51 }
52 #[allow(box_pointers)]
53 #[allow(deprecated)]
54 #[allow(explicit_outlives_requirements)]
55 #[allow(single_use_lifetimes)]
56 #[allow(unreachable_pub)]
57 #[allow(unused_tuple_struct_fields)]
58 #[allow(clippy::unknown_clippy_lints)]
59 #[allow(clippy::pattern_type_mismatch)]
60 #[allow(clippy::redundant_pub_crate)]
61 #[allow(clippy::type_repetition_in_bounds)]
62 #[allow(unused_qualifications)]
63 #[allow(clippy::semicolon_if_nothing_returned)]
64 #[allow(clippy::use_self)]
65 #[allow(clippy::used_underscore_binding)]
66 const _: () = {
67 #[allow(unused_extern_crates)]
68 extern crate pin_project as _pin_project;
69 impl<T, U> Enum<T, U> {
70 #[allow(dead_code)]
71 #[inline]
project<'pin>( self: _pin_project::__private::Pin<&'pin mut Self>, ) -> EnumProj<'pin, T, U>72 fn project<'pin>(
73 self: _pin_project::__private::Pin<&'pin mut Self>,
74 ) -> EnumProj<'pin, T, U> {
75 unsafe {
76 match self.get_unchecked_mut() {
77 Self::Struct { pinned, unpinned } => {
78 EnumProj::Struct {
79 pinned: _pin_project::__private::Pin::new_unchecked(pinned),
80 unpinned,
81 }
82 }
83 Self::Tuple(_0, _1) => {
84 EnumProj::Tuple(
85 _pin_project::__private::Pin::new_unchecked(_0),
86 _1,
87 )
88 }
89 Self::Unit => EnumProj::Unit,
90 }
91 }
92 }
93 #[allow(dead_code)]
94 #[allow(clippy::missing_const_for_fn)]
95 #[inline]
project_ref<'pin>( self: _pin_project::__private::Pin<&'pin Self>, ) -> EnumProjRef<'pin, T, U>96 fn project_ref<'pin>(
97 self: _pin_project::__private::Pin<&'pin Self>,
98 ) -> EnumProjRef<'pin, T, U> {
99 unsafe {
100 match self.get_ref() {
101 Self::Struct { pinned, unpinned } => {
102 EnumProjRef::Struct {
103 pinned: _pin_project::__private::Pin::new_unchecked(pinned),
104 unpinned,
105 }
106 }
107 Self::Tuple(_0, _1) => {
108 EnumProjRef::Tuple(
109 _pin_project::__private::Pin::new_unchecked(_0),
110 _1,
111 )
112 }
113 Self::Unit => EnumProjRef::Unit,
114 }
115 }
116 }
117 }
118 #[allow(missing_debug_implementations)]
119 struct __Enum<'pin, T, U> {
120 __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
121 'pin,
122 (
123 _pin_project::__private::PhantomData<T>,
124 _pin_project::__private::PhantomData<U>,
125 ),
126 >,
127 __field0: T,
128 __field1: T,
129 }
130 impl<'pin, T, U> _pin_project::__private::Unpin for Enum<T, U>
131 where
132 __Enum<'pin, T, U>: _pin_project::__private::Unpin,
133 {}
134 #[doc(hidden)]
135 unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Enum<T, U>
136 where
137 __Enum<'pin, T, U>: _pin_project::__private::Unpin,
138 {}
139 impl<T, U> _pin_project::__private::Drop for Enum<T, U> {
drop(&mut self)140 fn drop(&mut self) {
141 unsafe {
142 let __pinned_self = _pin_project::__private::Pin::new_unchecked(self);
143 _pin_project::__private::PinnedDrop::drop(__pinned_self);
144 }
145 }
146 }
147 };
148 #[doc(hidden)]
149 impl<T, U> ::pin_project::__private::PinnedDrop for Enum<T, U> {
drop(self: Pin<&mut Self>)150 unsafe fn drop(self: Pin<&mut Self>) {
151 #[allow(clippy::needless_pass_by_value)]
152 fn __drop_inner<T, U>(__self: Pin<&mut Enum<T, U>>) {
153 fn __drop_inner() {}
154 let _ = __self;
155 }
156 __drop_inner(self);
157 }
158 }
main()159 fn main() {}
160