vendor/pin-project-lite/tests/expand/naming/enum-all.expanded.rs

   1 use pin_project_lite::pin_project;
   2 enum Enum<T, U> {
   3     Struct { pinned: T, unpinned: U },
   4     Unit,
   5 }
   6 #[allow(dead_code)]
   7 #[allow(single_use_lifetimes)]
   8 #[allow(clippy::unknown_clippy_lints)]
   9 #[allow(clippy::mut_mut)]
  10 #[allow(clippy::redundant_pub_crate)]
  11 #[allow(clippy::ref_option_ref)]
  12 #[allow(clippy::type_repetition_in_bounds)]
  13 enum EnumProj<'__pin, T, U>
  14 where
  15     Enum<T, U>: '__pin,
  16 {
  17     Struct {
  18         pinned: ::pin_project_lite::__private::Pin<&'__pin mut (T)>,
  19         unpinned: &'__pin mut (U),
  20     },
  21     Unit,
  22 }
  23 #[allow(dead_code)]
  24 #[allow(single_use_lifetimes)]
  25 #[allow(clippy::unknown_clippy_lints)]
  26 #[allow(clippy::mut_mut)]
  27 #[allow(clippy::redundant_pub_crate)]
  28 #[allow(clippy::ref_option_ref)]
  29 #[allow(clippy::type_repetition_in_bounds)]
  30 enum EnumProjRef<'__pin, T, U>
  31 where
  32     Enum<T, U>: '__pin,
  33 {
  34     Struct {
  35         pinned: ::pin_project_lite::__private::Pin<&'__pin (T)>,
  36         unpinned: &'__pin (U),
  37     },
  38     Unit,
  39 }
  40 #[allow(dead_code)]
  41 #[allow(single_use_lifetimes)]
  42 #[allow(clippy::mut_mut)]
  43 #[allow(clippy::redundant_pub_crate)]
  44 #[allow(clippy::type_repetition_in_bounds)]
  45 enum EnumProjReplace<T, U> {
  46     Struct {
  47         pinned: ::pin_project_lite::__private::PhantomData<T>,
  48         unpinned: U,
  49     },
  50     Unit,
  51 }
  52 #[allow(single_use_lifetimes)]
  53 #[allow(clippy::unknown_clippy_lints)]
  54 #[allow(clippy::used_underscore_binding)]
  55 const _: () = {
  56     impl<T, U> Enum<T, U> {
  57         fn project<'__pin>(
  58             self: ::pin_project_lite::__private::Pin<&'__pin mut Self>,
  59         ) -> EnumProj<'__pin, T, U> {
  60             unsafe {
  61                 match self.get_unchecked_mut() {
  62                     Self::Struct { pinned, unpinned } => EnumProj::Struct {
  63                         pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned),
  64                         unpinned: unpinned,
  65                     },
  66                     Self::Unit => EnumProj::Unit,
  67                 }
  68             }
  69         }
  70         fn project_ref<'__pin>(
  71             self: ::pin_project_lite::__private::Pin<&'__pin Self>,
  72         ) -> EnumProjRef<'__pin, T, U> {
  73             unsafe {
  74                 match self.get_ref() {
  75                     Self::Struct { pinned, unpinned } => EnumProjRef::Struct {
  76                         pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned),
  77                         unpinned: unpinned,
  78                     },
  79                     Self::Unit => EnumProjRef::Unit,
  80                 }
  81             }
  82         }
  83         fn project_replace(
  84             self: ::pin_project_lite::__private::Pin<&mut Self>,
  85             replacement: Self,
  86         ) -> EnumProjReplace<T, U> {
  87             unsafe {
  88                 let __self_ptr: *mut Self = self.get_unchecked_mut();
  89                 let __guard = ::pin_project_lite::__private::UnsafeOverwriteGuard {
  90                     target: __self_ptr,
  91                     value: ::pin_project_lite::__private::ManuallyDrop::new(replacement),
  92                 };
  93                 match &mut *__self_ptr {
  94                     Self::Struct { pinned, unpinned } => {
  95                         let result = EnumProjReplace::Struct {
  96                             pinned: ::pin_project_lite::__private::PhantomData,
  97                             unpinned: ::pin_project_lite::__private::ptr::read(unpinned),
  98                         };
  99                         {
 100                             (
 101                                 ::pin_project_lite::__private::UnsafeDropInPlaceGuard(pinned),
 102                                 (),
 103                             );
 104                         }
 105                         result
 106                     }
 107                     Self::Unit => EnumProjReplace::Unit,
 108                 }
 109             }
 110         }
 111     }
 112     #[allow(non_snake_case)]
 113     struct __Origin<'__pin, T, U> {
 114         __dummy_lifetime: ::pin_project_lite::__private::PhantomData<&'__pin ()>,
 115         Struct: (T, ::pin_project_lite::__private::AlwaysUnpin<U>),
 116         Unit: (),
 117     }
 118     impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Enum<T, U> where
 119         __Origin<'__pin, T, U>: ::pin_project_lite::__private::Unpin
 120     {
 121     }
 122     trait MustNotImplDrop {}
 123     #[allow(clippy::drop_bounds, drop_bounds)]
 124     impl<T: ::pin_project_lite::__private::Drop> MustNotImplDrop for T {}
 125     impl<T, U> MustNotImplDrop for Enum<T, U> {}
 126 };
 127 fn main() {}