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