1 use std::pin::Pin;
2 use pin_project::{pin_project, pinned_drop};
3 #[pin(__private(PinnedDrop))]
4 struct Struct<T, U> {
5 #[pin]
6 pinned: T,
7 unpinned: U,
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(unused_qualifications)]
20 #[allow(clippy::semicolon_if_nothing_returned)]
21 #[allow(clippy::use_self)]
22 #[allow(clippy::used_underscore_binding)]
23 const _: () = {
24 #[allow(unused_extern_crates)]
25 extern crate pin_project as _pin_project;
26 #[allow(dead_code)]
27 #[allow(clippy::mut_mut)]
28 struct __StructProjection<'pin, T, U>
29 where
30 Struct<T, U>: 'pin,
31 {
32 pinned: ::pin_project::__private::Pin<&'pin mut (T)>,
33 unpinned: &'pin mut (U),
34 }
35 #[allow(dead_code)]
36 #[allow(clippy::ref_option_ref)]
37 struct __StructProjectionRef<'pin, T, U>
38 where
39 Struct<T, U>: 'pin,
40 {
41 pinned: ::pin_project::__private::Pin<&'pin (T)>,
42 unpinned: &'pin (U),
43 }
44 impl<T, U> Struct<T, U> {
45 #[allow(dead_code)]
46 #[inline]
project<'pin>( self: _pin_project::__private::Pin<&'pin mut Self>, ) -> __StructProjection<'pin, T, U>47 fn project<'pin>(
48 self: _pin_project::__private::Pin<&'pin mut Self>,
49 ) -> __StructProjection<'pin, T, U> {
50 unsafe {
51 let Self { pinned, unpinned } = self.get_unchecked_mut();
52 __StructProjection {
53 pinned: _pin_project::__private::Pin::new_unchecked(pinned),
54 unpinned,
55 }
56 }
57 }
58 #[allow(dead_code)]
59 #[allow(clippy::missing_const_for_fn)]
60 #[inline]
project_ref<'pin>( self: _pin_project::__private::Pin<&'pin Self>, ) -> __StructProjectionRef<'pin, T, U>61 fn project_ref<'pin>(
62 self: _pin_project::__private::Pin<&'pin Self>,
63 ) -> __StructProjectionRef<'pin, T, U> {
64 unsafe {
65 let Self { pinned, unpinned } = self.get_ref();
66 __StructProjectionRef {
67 pinned: _pin_project::__private::Pin::new_unchecked(pinned),
68 unpinned,
69 }
70 }
71 }
72 }
73 #[forbid(unaligned_references, safe_packed_borrows)]
__assert_not_repr_packed<T, U>(this: &Struct<T, U>)74 fn __assert_not_repr_packed<T, U>(this: &Struct<T, U>) {
75 let _ = &this.pinned;
76 let _ = &this.unpinned;
77 }
78 #[allow(missing_debug_implementations)]
79 struct __Struct<'pin, T, U> {
80 __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
81 'pin,
82 (
83 _pin_project::__private::PhantomData<T>,
84 _pin_project::__private::PhantomData<U>,
85 ),
86 >,
87 __field0: T,
88 }
89 impl<'pin, T, U> _pin_project::__private::Unpin for Struct<T, U>
90 where
91 __Struct<'pin, T, U>: _pin_project::__private::Unpin,
92 {}
93 #[doc(hidden)]
94 unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Struct<T, U>
95 where
96 __Struct<'pin, T, U>: _pin_project::__private::Unpin,
97 {}
98 impl<T, U> _pin_project::__private::Drop for Struct<T, U> {
drop(&mut self)99 fn drop(&mut self) {
100 unsafe {
101 let __pinned_self = _pin_project::__private::Pin::new_unchecked(self);
102 _pin_project::__private::PinnedDrop::drop(__pinned_self);
103 }
104 }
105 }
106 };
107 #[doc(hidden)]
108 impl<T, U> ::pin_project::__private::PinnedDrop for Struct<T, U> {
drop(self: Pin<&mut Self>)109 unsafe fn drop(self: Pin<&mut Self>) {
110 #[allow(clippy::needless_pass_by_value)]
111 fn __drop_inner<T, U>(__self: Pin<&mut Struct<T, U>>) {
112 fn __drop_inner() {}
113 let _ = __self;
114 }
115 __drop_inner(self);
116 }
117 }
main()118 fn main() {}
119