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