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