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