diff options
Diffstat (limited to 'third_party/rust/pin-project-lite/tests/expand')
32 files changed, 1682 insertions, 0 deletions
diff --git a/third_party/rust/pin-project-lite/tests/expand/default/enum.expanded.rs b/third_party/rust/pin-project-lite/tests/expand/default/enum.expanded.rs new file mode 100644 index 0000000000..eae0aac85e --- /dev/null +++ b/third_party/rust/pin-project-lite/tests/expand/default/enum.expanded.rs @@ -0,0 +1,127 @@ +use pin_project_lite::pin_project; +enum Enum<T, U> { + Struct { pinned: T, unpinned: U }, + Unit, +} +#[allow(dead_code)] +#[allow(single_use_lifetimes)] +#[allow(clippy::unknown_clippy_lints)] +#[allow(clippy::mut_mut)] +#[allow(clippy::redundant_pub_crate)] +#[allow(clippy::ref_option_ref)] +#[allow(clippy::type_repetition_in_bounds)] +enum EnumProj<'__pin, T, U> +where + Enum<T, U>: '__pin, +{ + Struct { + pinned: ::pin_project_lite::__private::Pin<&'__pin mut (T)>, + unpinned: &'__pin mut (U), + }, + Unit, +} +#[allow(dead_code)] +#[allow(single_use_lifetimes)] +#[allow(clippy::unknown_clippy_lints)] +#[allow(clippy::mut_mut)] +#[allow(clippy::redundant_pub_crate)] +#[allow(clippy::ref_option_ref)] +#[allow(clippy::type_repetition_in_bounds)] +enum EnumProjRef<'__pin, T, U> +where + Enum<T, U>: '__pin, +{ + Struct { + pinned: ::pin_project_lite::__private::Pin<&'__pin (T)>, + unpinned: &'__pin (U), + }, + Unit, +} +#[allow(dead_code)] +#[allow(single_use_lifetimes)] +#[allow(clippy::mut_mut)] +#[allow(clippy::redundant_pub_crate)] +#[allow(clippy::type_repetition_in_bounds)] +enum EnumProjReplace<T, U> { + Struct { + pinned: ::pin_project_lite::__private::PhantomData<T>, + unpinned: U, + }, + Unit, +} +#[allow(single_use_lifetimes)] +#[allow(clippy::unknown_clippy_lints)] +#[allow(clippy::used_underscore_binding)] +const _: () = { + impl<T, U> Enum<T, U> { + fn project<'__pin>( + self: ::pin_project_lite::__private::Pin<&'__pin mut Self>, + ) -> EnumProj<'__pin, T, U> { + unsafe { + match self.get_unchecked_mut() { + Self::Struct { pinned, unpinned } => EnumProj::Struct { + pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned), + unpinned: unpinned, + }, + Self::Unit => EnumProj::Unit, + } + } + } + fn project_ref<'__pin>( + self: ::pin_project_lite::__private::Pin<&'__pin Self>, + ) -> EnumProjRef<'__pin, T, U> { + unsafe { + match self.get_ref() { + Self::Struct { pinned, unpinned } => EnumProjRef::Struct { + pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned), + unpinned: unpinned, + }, + Self::Unit => EnumProjRef::Unit, + } + } + } + fn project_replace( + self: ::pin_project_lite::__private::Pin<&mut Self>, + replacement: Self, + ) -> EnumProjReplace<T, U> { + unsafe { + let __self_ptr: *mut Self = self.get_unchecked_mut(); + let __guard = ::pin_project_lite::__private::UnsafeOverwriteGuard::new( + __self_ptr, + replacement, + ); + match &mut *__self_ptr { + Self::Struct { pinned, unpinned } => { + let result = EnumProjReplace::Struct { + pinned: ::pin_project_lite::__private::PhantomData, + unpinned: ::pin_project_lite::__private::ptr::read(unpinned), + }; + { + ( + ::pin_project_lite::__private::UnsafeDropInPlaceGuard::new(pinned), + (), + ); + } + result + } + Self::Unit => EnumProjReplace::Unit, + } + } + } + } + #[allow(non_snake_case)] + struct __Origin<'__pin, T, U> { + __dummy_lifetime: ::pin_project_lite::__private::PhantomData<&'__pin ()>, + Struct: (T, ::pin_project_lite::__private::AlwaysUnpin<U>), + Unit: (), + } + impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Enum<T, U> where + __Origin<'__pin, T, U>: ::pin_project_lite::__private::Unpin + { + } + trait MustNotImplDrop {} + #[allow(clippy::drop_bounds, drop_bounds)] + impl<T: ::pin_project_lite::__private::Drop> MustNotImplDrop for T {} + impl<T, U> MustNotImplDrop for Enum<T, U> {} +}; +fn main() {} diff --git a/third_party/rust/pin-project-lite/tests/expand/default/enum.rs b/third_party/rust/pin-project-lite/tests/expand/default/enum.rs new file mode 100644 index 0000000000..90d6860a81 --- /dev/null +++ b/third_party/rust/pin-project-lite/tests/expand/default/enum.rs @@ -0,0 +1,17 @@ +use pin_project_lite::pin_project; + +pin_project! { + #[project = EnumProj] + #[project_ref = EnumProjRef] + #[project_replace = EnumProjReplace] + enum Enum<T, U> { + Struct { + #[pin] + pinned: T, + unpinned: U, + }, + Unit, + } +} + +fn main() {} diff --git a/third_party/rust/pin-project-lite/tests/expand/default/struct.expanded.rs b/third_party/rust/pin-project-lite/tests/expand/default/struct.expanded.rs new file mode 100644 index 0000000000..8ab318cfb8 --- /dev/null +++ b/third_party/rust/pin-project-lite/tests/expand/default/struct.expanded.rs @@ -0,0 +1,84 @@ +use pin_project_lite::pin_project; +struct Struct<T, U> { + pinned: T, + unpinned: U, +} +#[allow(explicit_outlives_requirements)] +#[allow(single_use_lifetimes)] +#[allow(clippy::unknown_clippy_lints)] +#[allow(clippy::redundant_pub_crate)] +#[allow(clippy::used_underscore_binding)] +const _: () = { + #[allow(dead_code)] + #[allow(single_use_lifetimes)] + #[allow(clippy::unknown_clippy_lints)] + #[allow(clippy::mut_mut)] + #[allow(clippy::redundant_pub_crate)] + #[allow(clippy::ref_option_ref)] + #[allow(clippy::type_repetition_in_bounds)] + struct Projection<'__pin, T, U> + where + Struct<T, U>: '__pin, + { + pinned: ::pin_project_lite::__private::Pin<&'__pin mut (T)>, + unpinned: &'__pin mut (U), + } + #[allow(dead_code)] + #[allow(single_use_lifetimes)] + #[allow(clippy::unknown_clippy_lints)] + #[allow(clippy::mut_mut)] + #[allow(clippy::redundant_pub_crate)] + #[allow(clippy::ref_option_ref)] + #[allow(clippy::type_repetition_in_bounds)] + struct ProjectionRef<'__pin, T, U> + where + Struct<T, U>: '__pin, + { + pinned: ::pin_project_lite::__private::Pin<&'__pin (T)>, + unpinned: &'__pin (U), + } + impl<T, U> Struct<T, U> { + fn project<'__pin>( + self: ::pin_project_lite::__private::Pin<&'__pin mut Self>, + ) -> Projection<'__pin, T, U> { + unsafe { + let Self { pinned, unpinned } = self.get_unchecked_mut(); + Projection { + pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned), + unpinned: unpinned, + } + } + } + fn project_ref<'__pin>( + self: ::pin_project_lite::__private::Pin<&'__pin Self>, + ) -> ProjectionRef<'__pin, T, U> { + unsafe { + let Self { pinned, unpinned } = self.get_ref(); + ProjectionRef { + pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned), + unpinned: unpinned, + } + } + } + } + #[allow(non_snake_case)] + struct __Origin<'__pin, T, U> { + __dummy_lifetime: ::pin_project_lite::__private::PhantomData<&'__pin ()>, + pinned: T, + unpinned: ::pin_project_lite::__private::AlwaysUnpin<U>, + } + impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Struct<T, U> where + __Origin<'__pin, T, U>: ::pin_project_lite::__private::Unpin + { + } + trait MustNotImplDrop {} + #[allow(clippy::drop_bounds, drop_bounds)] + impl<T: ::pin_project_lite::__private::Drop> MustNotImplDrop for T {} + impl<T, U> MustNotImplDrop for Struct<T, U> {} + #[forbid(unaligned_references, safe_packed_borrows)] + fn __assert_not_repr_packed<T, U>(this: &Struct<T, U>) { + let _ = &this.pinned; + let _ = &this.unpinned; + } +}; +fn main() {} diff --git a/third_party/rust/pin-project-lite/tests/expand/default/struct.rs b/third_party/rust/pin-project-lite/tests/expand/default/struct.rs new file mode 100644 index 0000000000..e5447c70a6 --- /dev/null +++ b/third_party/rust/pin-project-lite/tests/expand/default/struct.rs @@ -0,0 +1,11 @@ +use pin_project_lite::pin_project; + +pin_project! { + struct Struct<T, U> { + #[pin] + pinned: T, + unpinned: U, + } +} + +fn main() {} diff --git a/third_party/rust/pin-project-lite/tests/expand/multifields/enum.expanded.rs b/third_party/rust/pin-project-lite/tests/expand/multifields/enum.expanded.rs new file mode 100644 index 0000000000..fca0febcda --- /dev/null +++ b/third_party/rust/pin-project-lite/tests/expand/multifields/enum.expanded.rs @@ -0,0 +1,88 @@ +use pin_project_lite::pin_project; +enum Enum<T, U> { + Struct { + pinned1: T, + pinned2: T, + unpinned1: U, + unpinned2: U, + }, + Unit, +} +#[allow(dead_code)] +#[allow(single_use_lifetimes)] +#[allow(clippy::mut_mut)] +#[allow(clippy::redundant_pub_crate)] +#[allow(clippy::type_repetition_in_bounds)] +enum EnumProjReplace<T, U> { + Struct { + pinned1: ::pin_project_lite::__private::PhantomData<T>, + pinned2: ::pin_project_lite::__private::PhantomData<T>, + unpinned1: U, + unpinned2: U, + }, + Unit, +} +#[allow(single_use_lifetimes)] +#[allow(clippy::unknown_clippy_lints)] +#[allow(clippy::used_underscore_binding)] +const _: () = { + impl<T, U> Enum<T, U> { + fn project_replace( + self: ::pin_project_lite::__private::Pin<&mut Self>, + replacement: Self, + ) -> EnumProjReplace<T, U> { + unsafe { + let __self_ptr: *mut Self = self.get_unchecked_mut(); + let __guard = ::pin_project_lite::__private::UnsafeOverwriteGuard::new( + __self_ptr, + replacement, + ); + match &mut *__self_ptr { + Self::Struct { + pinned1, + pinned2, + unpinned1, + unpinned2, + } => { + let result = EnumProjReplace::Struct { + pinned1: ::pin_project_lite::__private::PhantomData, + pinned2: ::pin_project_lite::__private::PhantomData, + unpinned1: ::pin_project_lite::__private::ptr::read(unpinned1), + unpinned2: ::pin_project_lite::__private::ptr::read(unpinned2), + }; + { + ( + ::pin_project_lite::__private::UnsafeDropInPlaceGuard::new(pinned1), + ::pin_project_lite::__private::UnsafeDropInPlaceGuard::new(pinned2), + (), + (), + ); + } + result + } + Self::Unit => EnumProjReplace::Unit, + } + } + } + } + #[allow(non_snake_case)] + struct __Origin<'__pin, T, U> { + __dummy_lifetime: ::pin_project_lite::__private::PhantomData<&'__pin ()>, + Struct: ( + T, + T, + ::pin_project_lite::__private::AlwaysUnpin<U>, + ::pin_project_lite::__private::AlwaysUnpin<U>, + ), + Unit: (), + } + impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Enum<T, U> where + __Origin<'__pin, T, U>: ::pin_project_lite::__private::Unpin + { + } + trait MustNotImplDrop {} + #[allow(clippy::drop_bounds, drop_bounds)] + impl<T: ::pin_project_lite::__private::Drop> MustNotImplDrop for T {} + impl<T, U> MustNotImplDrop for Enum<T, U> {} +}; +fn main() {} diff --git a/third_party/rust/pin-project-lite/tests/expand/multifields/enum.rs b/third_party/rust/pin-project-lite/tests/expand/multifields/enum.rs new file mode 100644 index 0000000000..c713362ad6 --- /dev/null +++ b/third_party/rust/pin-project-lite/tests/expand/multifields/enum.rs @@ -0,0 +1,18 @@ +use pin_project_lite::pin_project; + +pin_project! { +#[project_replace = EnumProjReplace] +enum Enum<T, U> { + Struct { + #[pin] + pinned1: T, + #[pin] + pinned2: T, + unpinned1: U, + unpinned2: U, + }, + Unit, +} +} + +fn main() {} diff --git a/third_party/rust/pin-project-lite/tests/expand/multifields/struct.expanded.rs b/third_party/rust/pin-project-lite/tests/expand/multifields/struct.expanded.rs new file mode 100644 index 0000000000..4320f68438 --- /dev/null +++ b/third_party/rust/pin-project-lite/tests/expand/multifields/struct.expanded.rs @@ -0,0 +1,152 @@ +use pin_project_lite::pin_project; +struct Struct<T, U> { + pinned1: T, + pinned2: T, + unpinned1: U, + unpinned2: U, +} +#[allow(dead_code)] +#[allow(single_use_lifetimes)] +#[allow(clippy::mut_mut)] +#[allow(clippy::redundant_pub_crate)] +#[allow(clippy::type_repetition_in_bounds)] +struct StructProjReplace<T, U> { + pinned1: ::pin_project_lite::__private::PhantomData<T>, + pinned2: ::pin_project_lite::__private::PhantomData<T>, + unpinned1: U, + unpinned2: U, +} +#[allow(explicit_outlives_requirements)] +#[allow(single_use_lifetimes)] +#[allow(clippy::unknown_clippy_lints)] +#[allow(clippy::redundant_pub_crate)] +#[allow(clippy::used_underscore_binding)] +const _: () = { + #[allow(dead_code)] + #[allow(single_use_lifetimes)] + #[allow(clippy::unknown_clippy_lints)] + #[allow(clippy::mut_mut)] + #[allow(clippy::redundant_pub_crate)] + #[allow(clippy::ref_option_ref)] + #[allow(clippy::type_repetition_in_bounds)] + struct Projection<'__pin, T, U> + where + Struct<T, U>: '__pin, + { + pinned1: ::pin_project_lite::__private::Pin<&'__pin mut (T)>, + pinned2: ::pin_project_lite::__private::Pin<&'__pin mut (T)>, + unpinned1: &'__pin mut (U), + unpinned2: &'__pin mut (U), + } + #[allow(dead_code)] + #[allow(single_use_lifetimes)] + #[allow(clippy::unknown_clippy_lints)] + #[allow(clippy::mut_mut)] + #[allow(clippy::redundant_pub_crate)] + #[allow(clippy::ref_option_ref)] + #[allow(clippy::type_repetition_in_bounds)] + struct ProjectionRef<'__pin, T, U> + where + Struct<T, U>: '__pin, + { + pinned1: ::pin_project_lite::__private::Pin<&'__pin (T)>, + pinned2: ::pin_project_lite::__private::Pin<&'__pin (T)>, + unpinned1: &'__pin (U), + unpinned2: &'__pin (U), + } + impl<T, U> Struct<T, U> { + fn project<'__pin>( + self: ::pin_project_lite::__private::Pin<&'__pin mut Self>, + ) -> Projection<'__pin, T, U> { + unsafe { + let Self { + pinned1, + pinned2, + unpinned1, + unpinned2, + } = self.get_unchecked_mut(); + Projection { + pinned1: ::pin_project_lite::__private::Pin::new_unchecked(pinned1), + pinned2: ::pin_project_lite::__private::Pin::new_unchecked(pinned2), + unpinned1: unpinned1, + unpinned2: unpinned2, + } + } + } + fn project_ref<'__pin>( + self: ::pin_project_lite::__private::Pin<&'__pin Self>, + ) -> ProjectionRef<'__pin, T, U> { + unsafe { + let Self { + pinned1, + pinned2, + unpinned1, + unpinned2, + } = self.get_ref(); + ProjectionRef { + pinned1: ::pin_project_lite::__private::Pin::new_unchecked(pinned1), + pinned2: ::pin_project_lite::__private::Pin::new_unchecked(pinned2), + unpinned1: unpinned1, + unpinned2: unpinned2, + } + } + } + fn project_replace( + self: ::pin_project_lite::__private::Pin<&mut Self>, + replacement: Self, + ) -> StructProjReplace<T, U> { + unsafe { + let __self_ptr: *mut Self = self.get_unchecked_mut(); + let __guard = ::pin_project_lite::__private::UnsafeOverwriteGuard::new( + __self_ptr, + replacement, + ); + let Self { + pinned1, + pinned2, + unpinned1, + unpinned2, + } = &mut *__self_ptr; + let result = StructProjReplace { + pinned1: ::pin_project_lite::__private::PhantomData, + pinned2: ::pin_project_lite::__private::PhantomData, + unpinned1: ::pin_project_lite::__private::ptr::read(unpinned1), + unpinned2: ::pin_project_lite::__private::ptr::read(unpinned2), + }; + { + ( + ::pin_project_lite::__private::UnsafeDropInPlaceGuard::new(pinned1), + ::pin_project_lite::__private::UnsafeDropInPlaceGuard::new(pinned2), + (), + (), + ); + } + result + } + } + } + #[allow(non_snake_case)] + struct __Origin<'__pin, T, U> { + __dummy_lifetime: ::pin_project_lite::__private::PhantomData<&'__pin ()>, + pinned1: T, + pinned2: T, + unpinned1: ::pin_project_lite::__private::AlwaysUnpin<U>, + unpinned2: ::pin_project_lite::__private::AlwaysUnpin<U>, + } + impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Struct<T, U> where + __Origin<'__pin, T, U>: ::pin_project_lite::__private::Unpin + { + } + trait MustNotImplDrop {} + #[allow(clippy::drop_bounds, drop_bounds)] + impl<T: ::pin_project_lite::__private::Drop> MustNotImplDrop for T {} + impl<T, U> MustNotImplDrop for Struct<T, U> {} + #[forbid(unaligned_references, safe_packed_borrows)] + fn __assert_not_repr_packed<T, U>(this: &Struct<T, U>) { + let _ = &this.pinned1; + let _ = &this.pinned2; + let _ = &this.unpinned1; + let _ = &this.unpinned2; + } +}; +fn main() {} diff --git a/third_party/rust/pin-project-lite/tests/expand/multifields/struct.rs b/third_party/rust/pin-project-lite/tests/expand/multifields/struct.rs new file mode 100644 index 0000000000..a1d45d168e --- /dev/null +++ b/third_party/rust/pin-project-lite/tests/expand/multifields/struct.rs @@ -0,0 +1,15 @@ +use pin_project_lite::pin_project; + +pin_project! { +#[project_replace = StructProjReplace] +struct Struct<T, U> { + #[pin] + pinned1: T, + #[pin] + pinned2: T, + unpinned1: U, + unpinned2: U, +} +} + +fn main() {} diff --git a/third_party/rust/pin-project-lite/tests/expand/naming/enum-all.expanded.rs b/third_party/rust/pin-project-lite/tests/expand/naming/enum-all.expanded.rs new file mode 100644 index 0000000000..eae0aac85e --- /dev/null +++ b/third_party/rust/pin-project-lite/tests/expand/naming/enum-all.expanded.rs @@ -0,0 +1,127 @@ +use pin_project_lite::pin_project; +enum Enum<T, U> { + Struct { pinned: T, unpinned: U }, + Unit, +} +#[allow(dead_code)] +#[allow(single_use_lifetimes)] +#[allow(clippy::unknown_clippy_lints)] +#[allow(clippy::mut_mut)] +#[allow(clippy::redundant_pub_crate)] +#[allow(clippy::ref_option_ref)] +#[allow(clippy::type_repetition_in_bounds)] +enum EnumProj<'__pin, T, U> +where + Enum<T, U>: '__pin, +{ + Struct { + pinned: ::pin_project_lite::__private::Pin<&'__pin mut (T)>, + unpinned: &'__pin mut (U), + }, + Unit, +} +#[allow(dead_code)] +#[allow(single_use_lifetimes)] +#[allow(clippy::unknown_clippy_lints)] +#[allow(clippy::mut_mut)] +#[allow(clippy::redundant_pub_crate)] +#[allow(clippy::ref_option_ref)] +#[allow(clippy::type_repetition_in_bounds)] +enum EnumProjRef<'__pin, T, U> +where + Enum<T, U>: '__pin, +{ + Struct { + pinned: ::pin_project_lite::__private::Pin<&'__pin (T)>, + unpinned: &'__pin (U), + }, + Unit, +} +#[allow(dead_code)] +#[allow(single_use_lifetimes)] +#[allow(clippy::mut_mut)] +#[allow(clippy::redundant_pub_crate)] +#[allow(clippy::type_repetition_in_bounds)] +enum EnumProjReplace<T, U> { + Struct { + pinned: ::pin_project_lite::__private::PhantomData<T>, + unpinned: U, + }, + Unit, +} +#[allow(single_use_lifetimes)] +#[allow(clippy::unknown_clippy_lints)] +#[allow(clippy::used_underscore_binding)] +const _: () = { + impl<T, U> Enum<T, U> { + fn project<'__pin>( + self: ::pin_project_lite::__private::Pin<&'__pin mut Self>, + ) -> EnumProj<'__pin, T, U> { + unsafe { + match self.get_unchecked_mut() { + Self::Struct { pinned, unpinned } => EnumProj::Struct { + pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned), + unpinned: unpinned, + }, + Self::Unit => EnumProj::Unit, + } + } + } + fn project_ref<'__pin>( + self: ::pin_project_lite::__private::Pin<&'__pin Self>, + ) -> EnumProjRef<'__pin, T, U> { + unsafe { + match self.get_ref() { + Self::Struct { pinned, unpinned } => EnumProjRef::Struct { + pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned), + unpinned: unpinned, + }, + Self::Unit => EnumProjRef::Unit, + } + } + } + fn project_replace( + self: ::pin_project_lite::__private::Pin<&mut Self>, + replacement: Self, + ) -> EnumProjReplace<T, U> { + unsafe { + let __self_ptr: *mut Self = self.get_unchecked_mut(); + let __guard = ::pin_project_lite::__private::UnsafeOverwriteGuard::new( + __self_ptr, + replacement, + ); + match &mut *__self_ptr { + Self::Struct { pinned, unpinned } => { + let result = EnumProjReplace::Struct { + pinned: ::pin_project_lite::__private::PhantomData, + unpinned: ::pin_project_lite::__private::ptr::read(unpinned), + }; + { + ( + ::pin_project_lite::__private::UnsafeDropInPlaceGuard::new(pinned), + (), + ); + } + result + } + Self::Unit => EnumProjReplace::Unit, + } + } + } + } + #[allow(non_snake_case)] + struct __Origin<'__pin, T, U> { + __dummy_lifetime: ::pin_project_lite::__private::PhantomData<&'__pin ()>, + Struct: (T, ::pin_project_lite::__private::AlwaysUnpin<U>), + Unit: (), + } + impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Enum<T, U> where + __Origin<'__pin, T, U>: ::pin_project_lite::__private::Unpin + { + } + trait MustNotImplDrop {} + #[allow(clippy::drop_bounds, drop_bounds)] + impl<T: ::pin_project_lite::__private::Drop> MustNotImplDrop for T {} + impl<T, U> MustNotImplDrop for Enum<T, U> {} +}; +fn main() {} diff --git a/third_party/rust/pin-project-lite/tests/expand/naming/enum-all.rs b/third_party/rust/pin-project-lite/tests/expand/naming/enum-all.rs new file mode 100644 index 0000000000..90d6860a81 --- /dev/null +++ b/third_party/rust/pin-project-lite/tests/expand/naming/enum-all.rs @@ -0,0 +1,17 @@ +use pin_project_lite::pin_project; + +pin_project! { + #[project = EnumProj] + #[project_ref = EnumProjRef] + #[project_replace = EnumProjReplace] + enum Enum<T, U> { + Struct { + #[pin] + pinned: T, + unpinned: U, + }, + Unit, + } +} + +fn main() {} diff --git a/third_party/rust/pin-project-lite/tests/expand/naming/enum-mut.expanded.rs b/third_party/rust/pin-project-lite/tests/expand/naming/enum-mut.expanded.rs new file mode 100644 index 0000000000..7c4d6afbf9 --- /dev/null +++ b/third_party/rust/pin-project-lite/tests/expand/naming/enum-mut.expanded.rs @@ -0,0 +1,57 @@ +use pin_project_lite::pin_project; +enum Enum<T, U> { + Struct { pinned: T, unpinned: U }, + Unit, +} +#[allow(dead_code)] +#[allow(single_use_lifetimes)] +#[allow(clippy::unknown_clippy_lints)] +#[allow(clippy::mut_mut)] +#[allow(clippy::redundant_pub_crate)] +#[allow(clippy::ref_option_ref)] +#[allow(clippy::type_repetition_in_bounds)] +enum EnumProj<'__pin, T, U> +where + Enum<T, U>: '__pin, +{ + Struct { + pinned: ::pin_project_lite::__private::Pin<&'__pin mut (T)>, + unpinned: &'__pin mut (U), + }, + Unit, +} +#[allow(single_use_lifetimes)] +#[allow(clippy::unknown_clippy_lints)] +#[allow(clippy::used_underscore_binding)] +const _: () = { + impl<T, U> Enum<T, U> { + fn project<'__pin>( + self: ::pin_project_lite::__private::Pin<&'__pin mut Self>, + ) -> EnumProj<'__pin, T, U> { + unsafe { + match self.get_unchecked_mut() { + Self::Struct { pinned, unpinned } => EnumProj::Struct { + pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned), + unpinned: unpinned, + }, + Self::Unit => EnumProj::Unit, + } + } + } + } + #[allow(non_snake_case)] + struct __Origin<'__pin, T, U> { + __dummy_lifetime: ::pin_project_lite::__private::PhantomData<&'__pin ()>, + Struct: (T, ::pin_project_lite::__private::AlwaysUnpin<U>), + Unit: (), + } + impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Enum<T, U> where + __Origin<'__pin, T, U>: ::pin_project_lite::__private::Unpin + { + } + trait MustNotImplDrop {} + #[allow(clippy::drop_bounds, drop_bounds)] + impl<T: ::pin_project_lite::__private::Drop> MustNotImplDrop for T {} + impl<T, U> MustNotImplDrop for Enum<T, U> {} +}; +fn main() {} diff --git a/third_party/rust/pin-project-lite/tests/expand/naming/enum-mut.rs b/third_party/rust/pin-project-lite/tests/expand/naming/enum-mut.rs new file mode 100644 index 0000000000..69beecd1d9 --- /dev/null +++ b/third_party/rust/pin-project-lite/tests/expand/naming/enum-mut.rs @@ -0,0 +1,15 @@ +use pin_project_lite::pin_project; + +pin_project! { + #[project = EnumProj] + enum Enum<T, U> { + Struct { + #[pin] + pinned: T, + unpinned: U, + }, + Unit, + } +} + +fn main() {} diff --git a/third_party/rust/pin-project-lite/tests/expand/naming/enum-none.expanded.rs b/third_party/rust/pin-project-lite/tests/expand/naming/enum-none.expanded.rs new file mode 100644 index 0000000000..28ce97da7b --- /dev/null +++ b/third_party/rust/pin-project-lite/tests/expand/naming/enum-none.expanded.rs @@ -0,0 +1,26 @@ +use pin_project_lite::pin_project; +enum Enum<T, U> { + Struct { pinned: T, unpinned: U }, + Unit, +} +#[allow(single_use_lifetimes)] +#[allow(clippy::unknown_clippy_lints)] +#[allow(clippy::used_underscore_binding)] +const _: () = { + impl<T, U> Enum<T, U> {} + #[allow(non_snake_case)] + struct __Origin<'__pin, T, U> { + __dummy_lifetime: ::pin_project_lite::__private::PhantomData<&'__pin ()>, + Struct: (T, ::pin_project_lite::__private::AlwaysUnpin<U>), + Unit: (), + } + impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Enum<T, U> where + __Origin<'__pin, T, U>: ::pin_project_lite::__private::Unpin + { + } + trait MustNotImplDrop {} + #[allow(clippy::drop_bounds, drop_bounds)] + impl<T: ::pin_project_lite::__private::Drop> MustNotImplDrop for T {} + impl<T, U> MustNotImplDrop for Enum<T, U> {} +}; +fn main() {} diff --git a/third_party/rust/pin-project-lite/tests/expand/naming/enum-none.rs b/third_party/rust/pin-project-lite/tests/expand/naming/enum-none.rs new file mode 100644 index 0000000000..b2e3f9d76a --- /dev/null +++ b/third_party/rust/pin-project-lite/tests/expand/naming/enum-none.rs @@ -0,0 +1,14 @@ +use pin_project_lite::pin_project; + +pin_project! { + enum Enum<T, U> { + Struct { + #[pin] + pinned: T, + unpinned: U, + }, + Unit, + } +} + +fn main() {} diff --git a/third_party/rust/pin-project-lite/tests/expand/naming/enum-ref.expanded.rs b/third_party/rust/pin-project-lite/tests/expand/naming/enum-ref.expanded.rs new file mode 100644 index 0000000000..a1a013bda4 --- /dev/null +++ b/third_party/rust/pin-project-lite/tests/expand/naming/enum-ref.expanded.rs @@ -0,0 +1,57 @@ +use pin_project_lite::pin_project; +enum Enum<T, U> { + Struct { pinned: T, unpinned: U }, + Unit, +} +#[allow(dead_code)] +#[allow(single_use_lifetimes)] +#[allow(clippy::unknown_clippy_lints)] +#[allow(clippy::mut_mut)] +#[allow(clippy::redundant_pub_crate)] +#[allow(clippy::ref_option_ref)] +#[allow(clippy::type_repetition_in_bounds)] +enum EnumProjRef<'__pin, T, U> +where + Enum<T, U>: '__pin, +{ + Struct { + pinned: ::pin_project_lite::__private::Pin<&'__pin (T)>, + unpinned: &'__pin (U), + }, + Unit, +} +#[allow(single_use_lifetimes)] +#[allow(clippy::unknown_clippy_lints)] +#[allow(clippy::used_underscore_binding)] +const _: () = { + impl<T, U> Enum<T, U> { + fn project_ref<'__pin>( + self: ::pin_project_lite::__private::Pin<&'__pin Self>, + ) -> EnumProjRef<'__pin, T, U> { + unsafe { + match self.get_ref() { + Self::Struct { pinned, unpinned } => EnumProjRef::Struct { + pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned), + unpinned: unpinned, + }, + Self::Unit => EnumProjRef::Unit, + } + } + } + } + #[allow(non_snake_case)] + struct __Origin<'__pin, T, U> { + __dummy_lifetime: ::pin_project_lite::__private::PhantomData<&'__pin ()>, + Struct: (T, ::pin_project_lite::__private::AlwaysUnpin<U>), + Unit: (), + } + impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Enum<T, U> where + __Origin<'__pin, T, U>: ::pin_project_lite::__private::Unpin + { + } + trait MustNotImplDrop {} + #[allow(clippy::drop_bounds, drop_bounds)] + impl<T: ::pin_project_lite::__private::Drop> MustNotImplDrop for T {} + impl<T, U> MustNotImplDrop for Enum<T, U> {} +}; +fn main() {} diff --git a/third_party/rust/pin-project-lite/tests/expand/naming/enum-ref.rs b/third_party/rust/pin-project-lite/tests/expand/naming/enum-ref.rs new file mode 100644 index 0000000000..480d592d68 --- /dev/null +++ b/third_party/rust/pin-project-lite/tests/expand/naming/enum-ref.rs @@ -0,0 +1,15 @@ +use pin_project_lite::pin_project; + +pin_project! { + #[project_ref = EnumProjRef] + enum Enum<T, U> { + Struct { + #[pin] + pinned: T, + unpinned: U, + }, + Unit, + } +} + +fn main() {} diff --git a/third_party/rust/pin-project-lite/tests/expand/naming/struct-all.expanded.rs b/third_party/rust/pin-project-lite/tests/expand/naming/struct-all.expanded.rs new file mode 100644 index 0000000000..b91c24eb2a --- /dev/null +++ b/third_party/rust/pin-project-lite/tests/expand/naming/struct-all.expanded.rs @@ -0,0 +1,117 @@ +use pin_project_lite::pin_project; +struct Struct<T, U> { + pinned: T, + unpinned: U, +} +#[allow(dead_code)] +#[allow(single_use_lifetimes)] +#[allow(clippy::unknown_clippy_lints)] +#[allow(clippy::mut_mut)] +#[allow(clippy::redundant_pub_crate)] +#[allow(clippy::ref_option_ref)] +#[allow(clippy::type_repetition_in_bounds)] +struct StructProj<'__pin, T, U> +where + Struct<T, U>: '__pin, +{ + pinned: ::pin_project_lite::__private::Pin<&'__pin mut (T)>, + unpinned: &'__pin mut (U), +} +#[allow(dead_code)] +#[allow(single_use_lifetimes)] +#[allow(clippy::unknown_clippy_lints)] +#[allow(clippy::mut_mut)] +#[allow(clippy::redundant_pub_crate)] +#[allow(clippy::ref_option_ref)] +#[allow(clippy::type_repetition_in_bounds)] +struct StructProjRef<'__pin, T, U> +where + Struct<T, U>: '__pin, +{ + pinned: ::pin_project_lite::__private::Pin<&'__pin (T)>, + unpinned: &'__pin (U), +} +#[allow(dead_code)] +#[allow(single_use_lifetimes)] +#[allow(clippy::mut_mut)] +#[allow(clippy::redundant_pub_crate)] +#[allow(clippy::type_repetition_in_bounds)] +struct StructProjReplace<T, U> { + pinned: ::pin_project_lite::__private::PhantomData<T>, + unpinned: U, +} +#[allow(explicit_outlives_requirements)] +#[allow(single_use_lifetimes)] +#[allow(clippy::unknown_clippy_lints)] +#[allow(clippy::redundant_pub_crate)] +#[allow(clippy::used_underscore_binding)] +const _: () = { + impl<T, U> Struct<T, U> { + fn project<'__pin>( + self: ::pin_project_lite::__private::Pin<&'__pin mut Self>, + ) -> StructProj<'__pin, T, U> { + unsafe { + let Self { pinned, unpinned } = self.get_unchecked_mut(); + StructProj { + pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned), + unpinned: unpinned, + } + } + } + fn project_ref<'__pin>( + self: ::pin_project_lite::__private::Pin<&'__pin Self>, + ) -> StructProjRef<'__pin, T, U> { + unsafe { + let Self { pinned, unpinned } = self.get_ref(); + StructProjRef { + pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned), + unpinned: unpinned, + } + } + } + fn project_replace( + self: ::pin_project_lite::__private::Pin<&mut Self>, + replacement: Self, + ) -> StructProjReplace<T, U> { + unsafe { + let __self_ptr: *mut Self = self.get_unchecked_mut(); + let __guard = ::pin_project_lite::__private::UnsafeOverwriteGuard::new( + __self_ptr, + replacement, + ); + let Self { pinned, unpinned } = &mut *__self_ptr; + let result = StructProjReplace { + pinned: ::pin_project_lite::__private::PhantomData, + unpinned: ::pin_project_lite::__private::ptr::read(unpinned), + }; + { + ( + ::pin_project_lite::__private::UnsafeDropInPlaceGuard::new(pinned), + (), + ); + } + result + } + } + } + #[allow(non_snake_case)] + struct __Origin<'__pin, T, U> { + __dummy_lifetime: ::pin_project_lite::__private::PhantomData<&'__pin ()>, + pinned: T, + unpinned: ::pin_project_lite::__private::AlwaysUnpin<U>, + } + impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Struct<T, U> where + __Origin<'__pin, T, U>: ::pin_project_lite::__private::Unpin + { + } + trait MustNotImplDrop {} + #[allow(clippy::drop_bounds, drop_bounds)] + impl<T: ::pin_project_lite::__private::Drop> MustNotImplDrop for T {} + impl<T, U> MustNotImplDrop for Struct<T, U> {} + #[forbid(unaligned_references, safe_packed_borrows)] + fn __assert_not_repr_packed<T, U>(this: &Struct<T, U>) { + let _ = &this.pinned; + let _ = &this.unpinned; + } +}; +fn main() {} diff --git a/third_party/rust/pin-project-lite/tests/expand/naming/struct-all.rs b/third_party/rust/pin-project-lite/tests/expand/naming/struct-all.rs new file mode 100644 index 0000000000..cb087530fe --- /dev/null +++ b/third_party/rust/pin-project-lite/tests/expand/naming/struct-all.rs @@ -0,0 +1,14 @@ +use pin_project_lite::pin_project; + +pin_project! { + #[project = StructProj] + #[project_ref = StructProjRef] + #[project_replace = StructProjReplace] + struct Struct<T, U> { + #[pin] + pinned: T, + unpinned: U, + } +} + +fn main() {} diff --git a/third_party/rust/pin-project-lite/tests/expand/naming/struct-mut.expanded.rs b/third_party/rust/pin-project-lite/tests/expand/naming/struct-mut.expanded.rs new file mode 100644 index 0000000000..aaa41cd080 --- /dev/null +++ b/third_party/rust/pin-project-lite/tests/expand/naming/struct-mut.expanded.rs @@ -0,0 +1,84 @@ +use pin_project_lite::pin_project; +struct Struct<T, U> { + pinned: T, + unpinned: U, +} +#[allow(dead_code)] +#[allow(single_use_lifetimes)] +#[allow(clippy::unknown_clippy_lints)] +#[allow(clippy::mut_mut)] +#[allow(clippy::redundant_pub_crate)] +#[allow(clippy::ref_option_ref)] +#[allow(clippy::type_repetition_in_bounds)] +struct StructProj<'__pin, T, U> +where + Struct<T, U>: '__pin, +{ + pinned: ::pin_project_lite::__private::Pin<&'__pin mut (T)>, + unpinned: &'__pin mut (U), +} +#[allow(explicit_outlives_requirements)] +#[allow(single_use_lifetimes)] +#[allow(clippy::unknown_clippy_lints)] +#[allow(clippy::redundant_pub_crate)] +#[allow(clippy::used_underscore_binding)] +const _: () = { + #[allow(dead_code)] + #[allow(single_use_lifetimes)] + #[allow(clippy::unknown_clippy_lints)] + #[allow(clippy::mut_mut)] + #[allow(clippy::redundant_pub_crate)] + #[allow(clippy::ref_option_ref)] + #[allow(clippy::type_repetition_in_bounds)] + struct ProjectionRef<'__pin, T, U> + where + Struct<T, U>: '__pin, + { + pinned: ::pin_project_lite::__private::Pin<&'__pin (T)>, + unpinned: &'__pin (U), + } + impl<T, U> Struct<T, U> { + fn project<'__pin>( + self: ::pin_project_lite::__private::Pin<&'__pin mut Self>, + ) -> StructProj<'__pin, T, U> { + unsafe { + let Self { pinned, unpinned } = self.get_unchecked_mut(); + StructProj { + pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned), + unpinned: unpinned, + } + } + } + fn project_ref<'__pin>( + self: ::pin_project_lite::__private::Pin<&'__pin Self>, + ) -> ProjectionRef<'__pin, T, U> { + unsafe { + let Self { pinned, unpinned } = self.get_ref(); + ProjectionRef { + pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned), + unpinned: unpinned, + } + } + } + } + #[allow(non_snake_case)] + struct __Origin<'__pin, T, U> { + __dummy_lifetime: ::pin_project_lite::__private::PhantomData<&'__pin ()>, + pinned: T, + unpinned: ::pin_project_lite::__private::AlwaysUnpin<U>, + } + impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Struct<T, U> where + __Origin<'__pin, T, U>: ::pin_project_lite::__private::Unpin + { + } + trait MustNotImplDrop {} + #[allow(clippy::drop_bounds, drop_bounds)] + impl<T: ::pin_project_lite::__private::Drop> MustNotImplDrop for T {} + impl<T, U> MustNotImplDrop for Struct<T, U> {} + #[forbid(unaligned_references, safe_packed_borrows)] + fn __assert_not_repr_packed<T, U>(this: &Struct<T, U>) { + let _ = &this.pinned; + let _ = &this.unpinned; + } +}; +fn main() {} diff --git a/third_party/rust/pin-project-lite/tests/expand/naming/struct-mut.rs b/third_party/rust/pin-project-lite/tests/expand/naming/struct-mut.rs new file mode 100644 index 0000000000..59db44530a --- /dev/null +++ b/third_party/rust/pin-project-lite/tests/expand/naming/struct-mut.rs @@ -0,0 +1,12 @@ +use pin_project_lite::pin_project; + +pin_project! { + #[project = StructProj] + struct Struct<T, U> { + #[pin] + pinned: T, + unpinned: U, + } +} + +fn main() {} diff --git a/third_party/rust/pin-project-lite/tests/expand/naming/struct-none.expanded.rs b/third_party/rust/pin-project-lite/tests/expand/naming/struct-none.expanded.rs new file mode 100644 index 0000000000..8ab318cfb8 --- /dev/null +++ b/third_party/rust/pin-project-lite/tests/expand/naming/struct-none.expanded.rs @@ -0,0 +1,84 @@ +use pin_project_lite::pin_project; +struct Struct<T, U> { + pinned: T, + unpinned: U, +} +#[allow(explicit_outlives_requirements)] +#[allow(single_use_lifetimes)] +#[allow(clippy::unknown_clippy_lints)] +#[allow(clippy::redundant_pub_crate)] +#[allow(clippy::used_underscore_binding)] +const _: () = { + #[allow(dead_code)] + #[allow(single_use_lifetimes)] + #[allow(clippy::unknown_clippy_lints)] + #[allow(clippy::mut_mut)] + #[allow(clippy::redundant_pub_crate)] + #[allow(clippy::ref_option_ref)] + #[allow(clippy::type_repetition_in_bounds)] + struct Projection<'__pin, T, U> + where + Struct<T, U>: '__pin, + { + pinned: ::pin_project_lite::__private::Pin<&'__pin mut (T)>, + unpinned: &'__pin mut (U), + } + #[allow(dead_code)] + #[allow(single_use_lifetimes)] + #[allow(clippy::unknown_clippy_lints)] + #[allow(clippy::mut_mut)] + #[allow(clippy::redundant_pub_crate)] + #[allow(clippy::ref_option_ref)] + #[allow(clippy::type_repetition_in_bounds)] + struct ProjectionRef<'__pin, T, U> + where + Struct<T, U>: '__pin, + { + pinned: ::pin_project_lite::__private::Pin<&'__pin (T)>, + unpinned: &'__pin (U), + } + impl<T, U> Struct<T, U> { + fn project<'__pin>( + self: ::pin_project_lite::__private::Pin<&'__pin mut Self>, + ) -> Projection<'__pin, T, U> { + unsafe { + let Self { pinned, unpinned } = self.get_unchecked_mut(); + Projection { + pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned), + unpinned: unpinned, + } + } + } + fn project_ref<'__pin>( + self: ::pin_project_lite::__private::Pin<&'__pin Self>, + ) -> ProjectionRef<'__pin, T, U> { + unsafe { + let Self { pinned, unpinned } = self.get_ref(); + ProjectionRef { + pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned), + unpinned: unpinned, + } + } + } + } + #[allow(non_snake_case)] + struct __Origin<'__pin, T, U> { + __dummy_lifetime: ::pin_project_lite::__private::PhantomData<&'__pin ()>, + pinned: T, + unpinned: ::pin_project_lite::__private::AlwaysUnpin<U>, + } + impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Struct<T, U> where + __Origin<'__pin, T, U>: ::pin_project_lite::__private::Unpin + { + } + trait MustNotImplDrop {} + #[allow(clippy::drop_bounds, drop_bounds)] + impl<T: ::pin_project_lite::__private::Drop> MustNotImplDrop for T {} + impl<T, U> MustNotImplDrop for Struct<T, U> {} + #[forbid(unaligned_references, safe_packed_borrows)] + fn __assert_not_repr_packed<T, U>(this: &Struct<T, U>) { + let _ = &this.pinned; + let _ = &this.unpinned; + } +}; +fn main() {} diff --git a/third_party/rust/pin-project-lite/tests/expand/naming/struct-none.rs b/third_party/rust/pin-project-lite/tests/expand/naming/struct-none.rs new file mode 100644 index 0000000000..e5447c70a6 --- /dev/null +++ b/third_party/rust/pin-project-lite/tests/expand/naming/struct-none.rs @@ -0,0 +1,11 @@ +use pin_project_lite::pin_project; + +pin_project! { + struct Struct<T, U> { + #[pin] + pinned: T, + unpinned: U, + } +} + +fn main() {} diff --git a/third_party/rust/pin-project-lite/tests/expand/naming/struct-ref.expanded.rs b/third_party/rust/pin-project-lite/tests/expand/naming/struct-ref.expanded.rs new file mode 100644 index 0000000000..3d97ab8fae --- /dev/null +++ b/third_party/rust/pin-project-lite/tests/expand/naming/struct-ref.expanded.rs @@ -0,0 +1,84 @@ +use pin_project_lite::pin_project; +struct Struct<T, U> { + pinned: T, + unpinned: U, +} +#[allow(dead_code)] +#[allow(single_use_lifetimes)] +#[allow(clippy::unknown_clippy_lints)] +#[allow(clippy::mut_mut)] +#[allow(clippy::redundant_pub_crate)] +#[allow(clippy::ref_option_ref)] +#[allow(clippy::type_repetition_in_bounds)] +struct StructProjRef<'__pin, T, U> +where + Struct<T, U>: '__pin, +{ + pinned: ::pin_project_lite::__private::Pin<&'__pin (T)>, + unpinned: &'__pin (U), +} +#[allow(explicit_outlives_requirements)] +#[allow(single_use_lifetimes)] +#[allow(clippy::unknown_clippy_lints)] +#[allow(clippy::redundant_pub_crate)] +#[allow(clippy::used_underscore_binding)] +const _: () = { + #[allow(dead_code)] + #[allow(single_use_lifetimes)] + #[allow(clippy::unknown_clippy_lints)] + #[allow(clippy::mut_mut)] + #[allow(clippy::redundant_pub_crate)] + #[allow(clippy::ref_option_ref)] + #[allow(clippy::type_repetition_in_bounds)] + struct Projection<'__pin, T, U> + where + Struct<T, U>: '__pin, + { + pinned: ::pin_project_lite::__private::Pin<&'__pin mut (T)>, + unpinned: &'__pin mut (U), + } + impl<T, U> Struct<T, U> { + fn project<'__pin>( + self: ::pin_project_lite::__private::Pin<&'__pin mut Self>, + ) -> Projection<'__pin, T, U> { + unsafe { + let Self { pinned, unpinned } = self.get_unchecked_mut(); + Projection { + pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned), + unpinned: unpinned, + } + } + } + fn project_ref<'__pin>( + self: ::pin_project_lite::__private::Pin<&'__pin Self>, + ) -> StructProjRef<'__pin, T, U> { + unsafe { + let Self { pinned, unpinned } = self.get_ref(); + StructProjRef { + pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned), + unpinned: unpinned, + } + } + } + } + #[allow(non_snake_case)] + struct __Origin<'__pin, T, U> { + __dummy_lifetime: ::pin_project_lite::__private::PhantomData<&'__pin ()>, + pinned: T, + unpinned: ::pin_project_lite::__private::AlwaysUnpin<U>, + } + impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Struct<T, U> where + __Origin<'__pin, T, U>: ::pin_project_lite::__private::Unpin + { + } + trait MustNotImplDrop {} + #[allow(clippy::drop_bounds, drop_bounds)] + impl<T: ::pin_project_lite::__private::Drop> MustNotImplDrop for T {} + impl<T, U> MustNotImplDrop for Struct<T, U> {} + #[forbid(unaligned_references, safe_packed_borrows)] + fn __assert_not_repr_packed<T, U>(this: &Struct<T, U>) { + let _ = &this.pinned; + let _ = &this.unpinned; + } +}; +fn main() {} diff --git a/third_party/rust/pin-project-lite/tests/expand/naming/struct-ref.rs b/third_party/rust/pin-project-lite/tests/expand/naming/struct-ref.rs new file mode 100644 index 0000000000..6821af8274 --- /dev/null +++ b/third_party/rust/pin-project-lite/tests/expand/naming/struct-ref.rs @@ -0,0 +1,12 @@ +use pin_project_lite::pin_project; + +pin_project! { + #[project_ref = StructProjRef] + struct Struct<T, U> { + #[pin] + pinned: T, + unpinned: U, + } +} + +fn main() {} diff --git a/third_party/rust/pin-project-lite/tests/expand/pinned_drop/enum.expanded.rs b/third_party/rust/pin-project-lite/tests/expand/pinned_drop/enum.expanded.rs new file mode 100644 index 0000000000..665ff63386 --- /dev/null +++ b/third_party/rust/pin-project-lite/tests/expand/pinned_drop/enum.expanded.rs @@ -0,0 +1,95 @@ +use pin_project_lite::pin_project; +use std::pin::Pin; +enum Enum<T, U> { + Struct { pinned: T, unpinned: U }, + Unit, +} +#[allow(dead_code)] +#[allow(single_use_lifetimes)] +#[allow(clippy::unknown_clippy_lints)] +#[allow(clippy::mut_mut)] +#[allow(clippy::redundant_pub_crate)] +#[allow(clippy::ref_option_ref)] +#[allow(clippy::type_repetition_in_bounds)] +enum EnumProj<'__pin, T, U> +where + Enum<T, U>: '__pin, +{ + Struct { + pinned: ::pin_project_lite::__private::Pin<&'__pin mut (T)>, + unpinned: &'__pin mut (U), + }, + Unit, +} +#[allow(dead_code)] +#[allow(single_use_lifetimes)] +#[allow(clippy::unknown_clippy_lints)] +#[allow(clippy::mut_mut)] +#[allow(clippy::redundant_pub_crate)] +#[allow(clippy::ref_option_ref)] +#[allow(clippy::type_repetition_in_bounds)] +enum EnumProjRef<'__pin, T, U> +where + Enum<T, U>: '__pin, +{ + Struct { + pinned: ::pin_project_lite::__private::Pin<&'__pin (T)>, + unpinned: &'__pin (U), + }, + Unit, +} +#[allow(single_use_lifetimes)] +#[allow(clippy::unknown_clippy_lints)] +#[allow(clippy::used_underscore_binding)] +const _: () = { + impl<T, U> Enum<T, U> { + fn project<'__pin>( + self: ::pin_project_lite::__private::Pin<&'__pin mut Self>, + ) -> EnumProj<'__pin, T, U> { + unsafe { + match self.get_unchecked_mut() { + Self::Struct { pinned, unpinned } => EnumProj::Struct { + pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned), + unpinned: unpinned, + }, + Self::Unit => EnumProj::Unit, + } + } + } + fn project_ref<'__pin>( + self: ::pin_project_lite::__private::Pin<&'__pin Self>, + ) -> EnumProjRef<'__pin, T, U> { + unsafe { + match self.get_ref() { + Self::Struct { pinned, unpinned } => EnumProjRef::Struct { + pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned), + unpinned: unpinned, + }, + Self::Unit => EnumProjRef::Unit, + } + } + } + } + #[allow(non_snake_case)] + struct __Origin<'__pin, T, U> { + __dummy_lifetime: ::pin_project_lite::__private::PhantomData<&'__pin ()>, + Struct: (T, ::pin_project_lite::__private::AlwaysUnpin<U>), + Unit: (), + } + impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Enum<T, U> where + __Origin<'__pin, T, U>: ::pin_project_lite::__private::Unpin + { + } + impl<T, U> ::pin_project_lite::__private::Drop for Enum<T, U> { + fn drop(&mut self) { + fn __drop_inner<T, U>(this: ::pin_project_lite::__private::Pin<&mut Enum<T, U>>) { + fn __drop_inner() {} + let _ = this; + } + let pinned_self: ::pin_project_lite::__private::Pin<&mut Self> = + unsafe { ::pin_project_lite::__private::Pin::new_unchecked(self) }; + __drop_inner(pinned_self); + } + } +}; +fn main() {} diff --git a/third_party/rust/pin-project-lite/tests/expand/pinned_drop/enum.rs b/third_party/rust/pin-project-lite/tests/expand/pinned_drop/enum.rs new file mode 100644 index 0000000000..1855cb7a16 --- /dev/null +++ b/third_party/rust/pin-project-lite/tests/expand/pinned_drop/enum.rs @@ -0,0 +1,22 @@ +use pin_project_lite::pin_project; +use std::pin::Pin; + +pin_project! { + #[project = EnumProj] + #[project_ref = EnumProjRef] + enum Enum<T, U> { + Struct { + #[pin] + pinned: T, + unpinned: U, + }, + Unit, + } + impl<T, U> PinnedDrop for Enum<T, U> { + fn drop(this: Pin<&mut Self>) { + let _ = this; + } + } +} + +fn main() {} diff --git a/third_party/rust/pin-project-lite/tests/expand/pinned_drop/struct.expanded.rs b/third_party/rust/pin-project-lite/tests/expand/pinned_drop/struct.expanded.rs new file mode 100644 index 0000000000..5b82b7a19c --- /dev/null +++ b/third_party/rust/pin-project-lite/tests/expand/pinned_drop/struct.expanded.rs @@ -0,0 +1,92 @@ +use pin_project_lite::pin_project; +use std::pin::Pin; +struct Struct<T, U> { + pinned: T, + unpinned: U, +} +#[allow(explicit_outlives_requirements)] +#[allow(single_use_lifetimes)] +#[allow(clippy::unknown_clippy_lints)] +#[allow(clippy::redundant_pub_crate)] +#[allow(clippy::used_underscore_binding)] +const _: () = { + #[allow(dead_code)] + #[allow(single_use_lifetimes)] + #[allow(clippy::unknown_clippy_lints)] + #[allow(clippy::mut_mut)] + #[allow(clippy::redundant_pub_crate)] + #[allow(clippy::ref_option_ref)] + #[allow(clippy::type_repetition_in_bounds)] + struct Projection<'__pin, T, U> + where + Struct<T, U>: '__pin, + { + pinned: ::pin_project_lite::__private::Pin<&'__pin mut (T)>, + unpinned: &'__pin mut (U), + } + #[allow(dead_code)] + #[allow(single_use_lifetimes)] + #[allow(clippy::unknown_clippy_lints)] + #[allow(clippy::mut_mut)] + #[allow(clippy::redundant_pub_crate)] + #[allow(clippy::ref_option_ref)] + #[allow(clippy::type_repetition_in_bounds)] + struct ProjectionRef<'__pin, T, U> + where + Struct<T, U>: '__pin, + { + pinned: ::pin_project_lite::__private::Pin<&'__pin (T)>, + unpinned: &'__pin (U), + } + impl<T, U> Struct<T, U> { + fn project<'__pin>( + self: ::pin_project_lite::__private::Pin<&'__pin mut Self>, + ) -> Projection<'__pin, T, U> { + unsafe { + let Self { pinned, unpinned } = self.get_unchecked_mut(); + Projection { + pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned), + unpinned: unpinned, + } + } + } + fn project_ref<'__pin>( + self: ::pin_project_lite::__private::Pin<&'__pin Self>, + ) -> ProjectionRef<'__pin, T, U> { + unsafe { + let Self { pinned, unpinned } = self.get_ref(); + ProjectionRef { + pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned), + unpinned: unpinned, + } + } + } + } + #[allow(non_snake_case)] + struct __Origin<'__pin, T, U> { + __dummy_lifetime: ::pin_project_lite::__private::PhantomData<&'__pin ()>, + pinned: T, + unpinned: ::pin_project_lite::__private::AlwaysUnpin<U>, + } + impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Struct<T, U> where + __Origin<'__pin, T, U>: ::pin_project_lite::__private::Unpin + { + } + impl<T, U> ::pin_project_lite::__private::Drop for Struct<T, U> { + fn drop(&mut self) { + fn __drop_inner<T, U>(this: ::pin_project_lite::__private::Pin<&mut Struct<T, U>>) { + fn __drop_inner() {} + let _ = this; + } + let pinned_self: ::pin_project_lite::__private::Pin<&mut Self> = + unsafe { ::pin_project_lite::__private::Pin::new_unchecked(self) }; + __drop_inner(pinned_self); + } + } + #[forbid(unaligned_references, safe_packed_borrows)] + fn __assert_not_repr_packed<T, U>(this: &Struct<T, U>) { + let _ = &this.pinned; + let _ = &this.unpinned; + } +}; +fn main() {} diff --git a/third_party/rust/pin-project-lite/tests/expand/pinned_drop/struct.rs b/third_party/rust/pin-project-lite/tests/expand/pinned_drop/struct.rs new file mode 100644 index 0000000000..0cc7567690 --- /dev/null +++ b/third_party/rust/pin-project-lite/tests/expand/pinned_drop/struct.rs @@ -0,0 +1,17 @@ +use pin_project_lite::pin_project; +use std::pin::Pin; + +pin_project! { + struct Struct<T, U> { + #[pin] + pinned: T, + unpinned: U, + } + impl<T, U> PinnedDrop for Struct<T, U> { + fn drop(this: Pin<&mut Self>) { + let _ = this; + } + } +} + +fn main() {} diff --git a/third_party/rust/pin-project-lite/tests/expand/pub/enum.expanded.rs b/third_party/rust/pin-project-lite/tests/expand/pub/enum.expanded.rs new file mode 100644 index 0000000000..6f190cba08 --- /dev/null +++ b/third_party/rust/pin-project-lite/tests/expand/pub/enum.expanded.rs @@ -0,0 +1,87 @@ +use pin_project_lite::pin_project; +pub enum Enum<T, U> { + Struct { pinned: T, unpinned: U }, + Unit, +} +#[allow(dead_code)] +#[allow(single_use_lifetimes)] +#[allow(clippy::unknown_clippy_lints)] +#[allow(clippy::mut_mut)] +#[allow(clippy::redundant_pub_crate)] +#[allow(clippy::ref_option_ref)] +#[allow(clippy::type_repetition_in_bounds)] +pub(crate) enum EnumProj<'__pin, T, U> +where + Enum<T, U>: '__pin, +{ + Struct { + pinned: ::pin_project_lite::__private::Pin<&'__pin mut (T)>, + unpinned: &'__pin mut (U), + }, + Unit, +} +#[allow(dead_code)] +#[allow(single_use_lifetimes)] +#[allow(clippy::unknown_clippy_lints)] +#[allow(clippy::mut_mut)] +#[allow(clippy::redundant_pub_crate)] +#[allow(clippy::ref_option_ref)] +#[allow(clippy::type_repetition_in_bounds)] +pub(crate) enum EnumProjRef<'__pin, T, U> +where + Enum<T, U>: '__pin, +{ + Struct { + pinned: ::pin_project_lite::__private::Pin<&'__pin (T)>, + unpinned: &'__pin (U), + }, + Unit, +} +#[allow(single_use_lifetimes)] +#[allow(clippy::unknown_clippy_lints)] +#[allow(clippy::used_underscore_binding)] +const _: () = { + impl<T, U> Enum<T, U> { + pub(crate) fn project<'__pin>( + self: ::pin_project_lite::__private::Pin<&'__pin mut Self>, + ) -> EnumProj<'__pin, T, U> { + unsafe { + match self.get_unchecked_mut() { + Self::Struct { pinned, unpinned } => EnumProj::Struct { + pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned), + unpinned: unpinned, + }, + Self::Unit => EnumProj::Unit, + } + } + } + pub(crate) fn project_ref<'__pin>( + self: ::pin_project_lite::__private::Pin<&'__pin Self>, + ) -> EnumProjRef<'__pin, T, U> { + unsafe { + match self.get_ref() { + Self::Struct { pinned, unpinned } => EnumProjRef::Struct { + pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned), + unpinned: unpinned, + }, + Self::Unit => EnumProjRef::Unit, + } + } + } + } + #[allow(non_snake_case)] + pub struct __Origin<'__pin, T, U> { + __dummy_lifetime: ::pin_project_lite::__private::PhantomData<&'__pin ()>, + Struct: (T, ::pin_project_lite::__private::AlwaysUnpin<U>), + Unit: (), + } + impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Enum<T, U> where + __Origin<'__pin, T, U>: ::pin_project_lite::__private::Unpin + { + } + trait MustNotImplDrop {} + #[allow(clippy::drop_bounds, drop_bounds)] + impl<T: ::pin_project_lite::__private::Drop> MustNotImplDrop for T {} + impl<T, U> MustNotImplDrop for Enum<T, U> {} +}; +fn main() {} diff --git a/third_party/rust/pin-project-lite/tests/expand/pub/enum.rs b/third_party/rust/pin-project-lite/tests/expand/pub/enum.rs new file mode 100644 index 0000000000..d3968afdf2 --- /dev/null +++ b/third_party/rust/pin-project-lite/tests/expand/pub/enum.rs @@ -0,0 +1,16 @@ +use pin_project_lite::pin_project; + +pin_project! { + #[project = EnumProj] + #[project_ref = EnumProjRef] + pub enum Enum<T, U> { + Struct { + #[pin] + pinned: T, + unpinned: U, + }, + Unit, + } +} + +fn main() {} diff --git a/third_party/rust/pin-project-lite/tests/expand/pub/struct.expanded.rs b/third_party/rust/pin-project-lite/tests/expand/pub/struct.expanded.rs new file mode 100644 index 0000000000..7b5826d149 --- /dev/null +++ b/third_party/rust/pin-project-lite/tests/expand/pub/struct.expanded.rs @@ -0,0 +1,84 @@ +use pin_project_lite::pin_project; +pub struct Struct<T, U> { + pub pinned: T, + pub unpinned: U, +} +#[allow(explicit_outlives_requirements)] +#[allow(single_use_lifetimes)] +#[allow(clippy::unknown_clippy_lints)] +#[allow(clippy::redundant_pub_crate)] +#[allow(clippy::used_underscore_binding)] +const _: () = { + #[allow(dead_code)] + #[allow(single_use_lifetimes)] + #[allow(clippy::unknown_clippy_lints)] + #[allow(clippy::mut_mut)] + #[allow(clippy::redundant_pub_crate)] + #[allow(clippy::ref_option_ref)] + #[allow(clippy::type_repetition_in_bounds)] + pub(crate) struct Projection<'__pin, T, U> + where + Struct<T, U>: '__pin, + { + pub pinned: ::pin_project_lite::__private::Pin<&'__pin mut (T)>, + pub unpinned: &'__pin mut (U), + } + #[allow(dead_code)] + #[allow(single_use_lifetimes)] + #[allow(clippy::unknown_clippy_lints)] + #[allow(clippy::mut_mut)] + #[allow(clippy::redundant_pub_crate)] + #[allow(clippy::ref_option_ref)] + #[allow(clippy::type_repetition_in_bounds)] + pub(crate) struct ProjectionRef<'__pin, T, U> + where + Struct<T, U>: '__pin, + { + pub pinned: ::pin_project_lite::__private::Pin<&'__pin (T)>, + pub unpinned: &'__pin (U), + } + impl<T, U> Struct<T, U> { + pub(crate) fn project<'__pin>( + self: ::pin_project_lite::__private::Pin<&'__pin mut Self>, + ) -> Projection<'__pin, T, U> { + unsafe { + let Self { pinned, unpinned } = self.get_unchecked_mut(); + Projection { + pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned), + unpinned: unpinned, + } + } + } + pub(crate) fn project_ref<'__pin>( + self: ::pin_project_lite::__private::Pin<&'__pin Self>, + ) -> ProjectionRef<'__pin, T, U> { + unsafe { + let Self { pinned, unpinned } = self.get_ref(); + ProjectionRef { + pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned), + unpinned: unpinned, + } + } + } + } + #[allow(non_snake_case)] + pub struct __Origin<'__pin, T, U> { + __dummy_lifetime: ::pin_project_lite::__private::PhantomData<&'__pin ()>, + pinned: T, + unpinned: ::pin_project_lite::__private::AlwaysUnpin<U>, + } + impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Struct<T, U> where + __Origin<'__pin, T, U>: ::pin_project_lite::__private::Unpin + { + } + trait MustNotImplDrop {} + #[allow(clippy::drop_bounds, drop_bounds)] + impl<T: ::pin_project_lite::__private::Drop> MustNotImplDrop for T {} + impl<T, U> MustNotImplDrop for Struct<T, U> {} + #[forbid(unaligned_references, safe_packed_borrows)] + fn __assert_not_repr_packed<T, U>(this: &Struct<T, U>) { + let _ = &this.pinned; + let _ = &this.unpinned; + } +}; +fn main() {} diff --git a/third_party/rust/pin-project-lite/tests/expand/pub/struct.rs b/third_party/rust/pin-project-lite/tests/expand/pub/struct.rs new file mode 100644 index 0000000000..6659096909 --- /dev/null +++ b/third_party/rust/pin-project-lite/tests/expand/pub/struct.rs @@ -0,0 +1,11 @@ +use pin_project_lite::pin_project; + +pin_project! { + pub struct Struct<T, U> { + #[pin] + pub pinned: T, + pub unpinned: U, + } +} + +fn main() {} |