1 use pin_project::pin_project;
2 #[pin(__private(project_replace))]
3 struct Struct<T, U> {
4 #[pin]
5 pinned: T,
6 unpinned: U,
7 }
8 #[allow(
9 unused_qualifications,
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::needless_lifetimes,
24 clippy::semicolon_if_nothing_returned,
25 clippy::use_self,
26 clippy::used_underscore_binding
27 )]
28 const _: () = {
29 #[allow(unused_extern_crates)]
30 extern crate pin_project as _pin_project;
31 #[allow(dead_code, clippy::missing_docs_in_private_items, clippy::mut_mut)]
32 struct __StructProjection<'pin, T, U>
33 where
34 Struct<T, U>: 'pin,
35 {
36 pinned: ::pin_project::__private::Pin<&'pin mut (T)>,
37 unpinned: &'pin mut (U),
38 }
39 #[allow(dead_code, clippy::missing_docs_in_private_items, clippy::ref_option_ref)]
40 struct __StructProjectionRef<'pin, T, U>
41 where
42 Struct<T, U>: 'pin,
43 {
44 pinned: ::pin_project::__private::Pin<&'pin (T)>,
45 unpinned: &'pin (U),
46 }
47 #[allow(dead_code, clippy::missing_docs_in_private_items)]
48 struct __StructProjectionOwned<T, U> {
49 pinned: ::pin_project::__private::PhantomData<T>,
50 unpinned: U,
51 }
52 impl<T, U> Struct<T, U> {
53 #[allow(dead_code)]
54 #[inline]
project<'pin>( self: _pin_project::__private::Pin<&'pin mut Self>, ) -> __StructProjection<'pin, T, U>55 fn project<'pin>(
56 self: _pin_project::__private::Pin<&'pin mut Self>,
57 ) -> __StructProjection<'pin, T, U> {
58 unsafe {
59 let Self { pinned, unpinned } = self.get_unchecked_mut();
60 __StructProjection {
61 pinned: _pin_project::__private::Pin::new_unchecked(pinned),
62 unpinned,
63 }
64 }
65 }
66 #[allow(dead_code)]
67 #[allow(clippy::missing_const_for_fn)]
68 #[inline]
project_ref<'pin>( self: _pin_project::__private::Pin<&'pin Self>, ) -> __StructProjectionRef<'pin, T, U>69 fn project_ref<'pin>(
70 self: _pin_project::__private::Pin<&'pin Self>,
71 ) -> __StructProjectionRef<'pin, T, U> {
72 unsafe {
73 let Self { pinned, unpinned } = self.get_ref();
74 __StructProjectionRef {
75 pinned: _pin_project::__private::Pin::new_unchecked(pinned),
76 unpinned,
77 }
78 }
79 }
80 #[allow(dead_code)]
81 #[inline]
project_replace( self: _pin_project::__private::Pin<&mut Self>, __replacement: Self, ) -> __StructProjectionOwned<T, U>82 fn project_replace(
83 self: _pin_project::__private::Pin<&mut Self>,
84 __replacement: Self,
85 ) -> __StructProjectionOwned<T, U> {
86 unsafe {
87 let __self_ptr: *mut Self = self.get_unchecked_mut();
88 let __guard = _pin_project::__private::UnsafeOverwriteGuard::new(
89 __self_ptr,
90 __replacement,
91 );
92 let Self { pinned, unpinned } = &mut *__self_ptr;
93 let __result = __StructProjectionOwned {
94 pinned: _pin_project::__private::PhantomData,
95 unpinned: _pin_project::__private::ptr::read(unpinned),
96 };
97 {
98 let __guard = _pin_project::__private::UnsafeDropInPlaceGuard::new(
99 pinned,
100 );
101 }
102 __result
103 }
104 }
105 }
106 #[forbid(unaligned_references, safe_packed_borrows)]
__assert_not_repr_packed<T, U>(this: &Struct<T, U>)107 fn __assert_not_repr_packed<T, U>(this: &Struct<T, U>) {
108 let _ = &this.pinned;
109 let _ = &this.unpinned;
110 }
111 #[allow(missing_debug_implementations, unnameable_types)]
112 struct __Struct<'pin, T, U> {
113 __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
114 'pin,
115 (
116 _pin_project::__private::PhantomData<T>,
117 _pin_project::__private::PhantomData<U>,
118 ),
119 >,
120 __field0: T,
121 }
122 impl<'pin, T, U> _pin_project::__private::Unpin for Struct<T, U>
123 where
124 _pin_project::__private::PinnedFieldsOf<
125 __Struct<'pin, T, U>,
126 >: _pin_project::__private::Unpin,
127 {}
128 #[doc(hidden)]
129 unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Struct<T, U>
130 where
131 _pin_project::__private::PinnedFieldsOf<
132 __Struct<'pin, T, U>,
133 >: _pin_project::__private::Unpin,
134 {}
135 trait StructMustNotImplDrop {}
136 #[allow(clippy::drop_bounds, drop_bounds)]
137 impl<T: _pin_project::__private::Drop> StructMustNotImplDrop for T {}
138 impl<T, U> StructMustNotImplDrop for Struct<T, U> {}
139 #[doc(hidden)]
140 impl<T, U> _pin_project::__private::PinnedDrop for Struct<T, U> {
drop(self: _pin_project::__private::Pin<&mut Self>)141 unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
142 }
143 };
main()144 fn main() {}
145