summaryrefslogtreecommitdiffstats
path: root/third_party/rust/pin-project/tests
diff options
context:
space:
mode:
Diffstat (limited to 'third_party/rust/pin-project/tests')
-rw-r--r--third_party/rust/pin-project/tests/auxiliary/mod.rs12
-rw-r--r--third_party/rust/pin-project/tests/cfg.rs184
-rw-r--r--third_party/rust/pin-project/tests/compiletest.rs17
-rw-r--r--third_party/rust/pin-project/tests/drop_order.rs162
-rw-r--r--third_party/rust/pin-project/tests/expand/default/enum.expanded.rs145
-rw-r--r--third_party/rust/pin-project/tests/expand/default/enum.rs14
-rw-r--r--third_party/rust/pin-project/tests/expand/default/struct.expanded.rs104
-rw-r--r--third_party/rust/pin-project/tests/expand/default/struct.rs10
-rw-r--r--third_party/rust/pin-project/tests/expand/default/tuple_struct.expanded.rs98
-rw-r--r--third_party/rust/pin-project/tests/expand/default/tuple_struct.rs6
-rw-r--r--third_party/rust/pin-project/tests/expand/multifields/enum.expanded.rs268
-rw-r--r--third_party/rust/pin-project/tests/expand/multifields/enum.rs17
-rw-r--r--third_party/rust/pin-project/tests/expand/multifields/struct.expanded.rs155
-rw-r--r--third_party/rust/pin-project/tests/expand/multifields/struct.rs13
-rw-r--r--third_party/rust/pin-project/tests/expand/multifields/tuple_struct.expanded.rs145
-rw-r--r--third_party/rust/pin-project/tests/expand/multifields/tuple_struct.rs6
-rw-r--r--third_party/rust/pin-project/tests/expand/naming/enum-all.expanded.rs204
-rw-r--r--third_party/rust/pin-project/tests/expand/naming/enum-all.rs14
-rw-r--r--third_party/rust/pin-project/tests/expand/naming/enum-mut.expanded.rs99
-rw-r--r--third_party/rust/pin-project/tests/expand/naming/enum-mut.rs14
-rw-r--r--third_party/rust/pin-project/tests/expand/naming/enum-none.expanded.rs56
-rw-r--r--third_party/rust/pin-project/tests/expand/naming/enum-none.rs14
-rw-r--r--third_party/rust/pin-project/tests/expand/naming/enum-own.expanded.rs119
-rw-r--r--third_party/rust/pin-project/tests/expand/naming/enum-own.rs14
-rw-r--r--third_party/rust/pin-project/tests/expand/naming/enum-ref.expanded.rs100
-rw-r--r--third_party/rust/pin-project/tests/expand/naming/enum-ref.rs14
-rw-r--r--third_party/rust/pin-project/tests/expand/naming/struct-all.expanded.rs163
-rw-r--r--third_party/rust/pin-project/tests/expand/naming/struct-all.rs10
-rw-r--r--third_party/rust/pin-project/tests/expand/naming/struct-mut.expanded.rs114
-rw-r--r--third_party/rust/pin-project/tests/expand/naming/struct-mut.rs10
-rw-r--r--third_party/rust/pin-project/tests/expand/naming/struct-none.expanded.rs104
-rw-r--r--third_party/rust/pin-project/tests/expand/naming/struct-none.rs10
-rw-r--r--third_party/rust/pin-project/tests/expand/naming/struct-own.expanded.rs143
-rw-r--r--third_party/rust/pin-project/tests/expand/naming/struct-own.rs10
-rw-r--r--third_party/rust/pin-project/tests/expand/naming/struct-ref.expanded.rs114
-rw-r--r--third_party/rust/pin-project/tests/expand/naming/struct-ref.rs10
-rw-r--r--third_party/rust/pin-project/tests/expand/naming/tuple_struct-all.expanded.rs148
-rw-r--r--third_party/rust/pin-project/tests/expand/naming/tuple_struct-all.rs6
-rw-r--r--third_party/rust/pin-project/tests/expand/naming/tuple_struct-mut.expanded.rs105
-rw-r--r--third_party/rust/pin-project/tests/expand/naming/tuple_struct-mut.rs6
-rw-r--r--third_party/rust/pin-project/tests/expand/naming/tuple_struct-none.expanded.rs98
-rw-r--r--third_party/rust/pin-project/tests/expand/naming/tuple_struct-none.rs6
-rw-r--r--third_party/rust/pin-project/tests/expand/naming/tuple_struct-own.expanded.rs134
-rw-r--r--third_party/rust/pin-project/tests/expand/naming/tuple_struct-own.rs6
-rw-r--r--third_party/rust/pin-project/tests/expand/naming/tuple_struct-ref.expanded.rs105
-rw-r--r--third_party/rust/pin-project/tests/expand/naming/tuple_struct-ref.rs6
-rw-r--r--third_party/rust/pin-project/tests/expand/not_unpin/enum.expanded.rs139
-rw-r--r--third_party/rust/pin-project/tests/expand/not_unpin/enum.rs14
-rw-r--r--third_party/rust/pin-project/tests/expand/not_unpin/struct.expanded.rs99
-rw-r--r--third_party/rust/pin-project/tests/expand/not_unpin/struct.rs10
-rw-r--r--third_party/rust/pin-project/tests/expand/not_unpin/tuple_struct.expanded.rs93
-rw-r--r--third_party/rust/pin-project/tests/expand/not_unpin/tuple_struct.rs6
-rw-r--r--third_party/rust/pin-project/tests/expand/pinned_drop/enum.expanded.rs157
-rw-r--r--third_party/rust/pin-project/tests/expand/pinned_drop/enum.rs23
-rw-r--r--third_party/rust/pin-project/tests/expand/pinned_drop/struct.expanded.rs116
-rw-r--r--third_party/rust/pin-project/tests/expand/pinned_drop/struct.rs19
-rw-r--r--third_party/rust/pin-project/tests/expand/pinned_drop/tuple_struct.expanded.rs110
-rw-r--r--third_party/rust/pin-project/tests/expand/pinned_drop/tuple_struct.rs15
-rw-r--r--third_party/rust/pin-project/tests/expand/project_replace/enum.expanded.rs119
-rw-r--r--third_party/rust/pin-project/tests/expand/project_replace/enum.rs14
-rw-r--r--third_party/rust/pin-project/tests/expand/project_replace/struct.expanded.rs133
-rw-r--r--third_party/rust/pin-project/tests/expand/project_replace/struct.rs10
-rw-r--r--third_party/rust/pin-project/tests/expand/project_replace/tuple_struct.expanded.rs127
-rw-r--r--third_party/rust/pin-project/tests/expand/project_replace/tuple_struct.rs6
-rw-r--r--third_party/rust/pin-project/tests/expand/pub/enum.expanded.rs145
-rw-r--r--third_party/rust/pin-project/tests/expand/pub/enum.rs14
-rw-r--r--third_party/rust/pin-project/tests/expand/pub/struct.expanded.rs104
-rw-r--r--third_party/rust/pin-project/tests/expand/pub/struct.rs10
-rw-r--r--third_party/rust/pin-project/tests/expand/pub/tuple_struct.expanded.rs98
-rw-r--r--third_party/rust/pin-project/tests/expand/pub/tuple_struct.rs6
-rw-r--r--third_party/rust/pin-project/tests/expand/unsafe_unpin/enum.expanded.rs129
-rw-r--r--third_party/rust/pin-project/tests/expand/unsafe_unpin/enum.rs16
-rw-r--r--third_party/rust/pin-project/tests/expand/unsafe_unpin/struct.expanded.rs89
-rw-r--r--third_party/rust/pin-project/tests/expand/unsafe_unpin/struct.rs12
-rw-r--r--third_party/rust/pin-project/tests/expand/unsafe_unpin/tuple_struct.expanded.rs83
-rw-r--r--third_party/rust/pin-project/tests/expand/unsafe_unpin/tuple_struct.rs8
-rw-r--r--third_party/rust/pin-project/tests/expandtest.rs44
-rw-r--r--third_party/rust/pin-project/tests/include/basic-safe-part.rs193
-rw-r--r--third_party/rust/pin-project/tests/include/basic.rs17
-rw-r--r--third_party/rust/pin-project/tests/lint.rs1191
-rw-r--r--third_party/rust/pin-project/tests/pin_project.rs888
-rw-r--r--third_party/rust/pin-project/tests/pinned_drop.rs284
-rw-r--r--third_party/rust/pin-project/tests/proper_unpin.rs153
-rw-r--r--third_party/rust/pin-project/tests/repr_packed.rs52
-rw-r--r--third_party/rust/pin-project/tests/ui/cfg/cfg_attr-resolve.rs11
-rw-r--r--third_party/rust/pin-project/tests/ui/cfg/cfg_attr-resolve.stderr5
-rw-r--r--third_party/rust/pin-project/tests/ui/cfg/cfg_attr-type-mismatch.rs25
-rw-r--r--third_party/rust/pin-project/tests/ui/cfg/cfg_attr-type-mismatch.stderr25
-rw-r--r--third_party/rust/pin-project/tests/ui/cfg/packed_sneaky-span-issue-1.rs15
-rw-r--r--third_party/rust/pin-project/tests/ui/cfg/packed_sneaky-span-issue-1.stderr5
-rw-r--r--third_party/rust/pin-project/tests/ui/cfg/packed_sneaky-span-issue-2.rs15
-rw-r--r--third_party/rust/pin-project/tests/ui/cfg/packed_sneaky-span-issue-2.stderr5
-rw-r--r--third_party/rust/pin-project/tests/ui/cfg/packed_sneaky.rs12
-rw-r--r--third_party/rust/pin-project/tests/ui/cfg/packed_sneaky.stderr5
-rw-r--r--third_party/rust/pin-project/tests/ui/cfg/unsupported.rs11
-rw-r--r--third_party/rust/pin-project/tests/ui/cfg/unsupported.stderr11
-rw-r--r--third_party/rust/pin-project/tests/ui/not_unpin/conflict-unpin.rs30
-rw-r--r--third_party/rust/pin-project/tests/ui/not_unpin/conflict-unpin.stderr26
-rw-r--r--third_party/rust/pin-project/tests/ui/not_unpin/impl-unsafe-unpin.rs30
-rw-r--r--third_party/rust/pin-project/tests/ui/not_unpin/impl-unsafe-unpin.stderr32
-rw-r--r--third_party/rust/pin-project/tests/ui/pin_project/add-attr-to-struct.rs20
-rw-r--r--third_party/rust/pin-project/tests/ui/pin_project/add-attr-to-struct.stderr15
-rw-r--r--third_party/rust/pin-project/tests/ui/pin_project/add-pinned-field.rs23
-rw-r--r--third_party/rust/pin-project/tests/ui/pin_project/add-pinned-field.stderr54
-rw-r--r--third_party/rust/pin-project/tests/ui/pin_project/conflict-drop.rs32
-rw-r--r--third_party/rust/pin-project/tests/ui/pin_project/conflict-drop.stderr19
-rw-r--r--third_party/rust/pin-project/tests/ui/pin_project/conflict-unpin.rs37
-rw-r--r--third_party/rust/pin-project/tests/ui/pin_project/conflict-unpin.stderr32
-rw-r--r--third_party/rust/pin-project/tests/ui/pin_project/impl-unsafe-unpin.rs30
-rw-r--r--third_party/rust/pin-project/tests/ui/pin_project/impl-unsafe-unpin.stderr32
-rw-r--r--third_party/rust/pin-project/tests/ui/pin_project/import_unnamed.rs30
-rw-r--r--third_party/rust/pin-project/tests/ui/pin_project/import_unnamed.stderr29
-rw-r--r--third_party/rust/pin-project/tests/ui/pin_project/invalid.rs280
-rw-r--r--third_party/rust/pin-project/tests/ui/pin_project/invalid.stderr364
-rw-r--r--third_party/rust/pin-project/tests/ui/pin_project/overlapping_unpin_struct.rs19
-rw-r--r--third_party/rust/pin-project/tests/ui/pin_project/overlapping_unpin_struct.stderr26
-rw-r--r--third_party/rust/pin-project/tests/ui/pin_project/override-priv-mod.rs32
-rw-r--r--third_party/rust/pin-project/tests/ui/pin_project/override-priv-mod.stderr10
-rw-r--r--third_party/rust/pin-project/tests/ui/pin_project/packed-enum.rs24
-rw-r--r--third_party/rust/pin-project/tests/ui/pin_project/packed-enum.stderr42
-rw-r--r--third_party/rust/pin-project/tests/ui/pin_project/packed-name-value.rs27
-rw-r--r--third_party/rust/pin-project/tests/ui/pin_project/packed-name-value.stderr23
-rw-r--r--third_party/rust/pin-project/tests/ui/pin_project/packed.rs33
-rw-r--r--third_party/rust/pin-project/tests/ui/pin_project/packed.stderr23
-rw-r--r--third_party/rust/pin-project/tests/ui/pin_project/packed_sneaky-1.rs41
-rw-r--r--third_party/rust/pin-project/tests/ui/pin_project/packed_sneaky-1.stderr25
-rw-r--r--third_party/rust/pin-project/tests/ui/pin_project/packed_sneaky-2.rs12
-rw-r--r--third_party/rust/pin-project/tests/ui/pin_project/packed_sneaky-2.stderr13
-rw-r--r--third_party/rust/pin-project/tests/ui/pin_project/packed_sneaky-3.rs32
-rw-r--r--third_party/rust/pin-project/tests/ui/pin_project/packed_sneaky-3.stderr32
-rw-r--r--third_party/rust/pin-project/tests/ui/pin_project/packed_sneaky-4.rs13
-rw-r--r--third_party/rust/pin-project/tests/ui/pin_project/packed_sneaky-4.stderr20
-rw-r--r--third_party/rust/pin-project/tests/ui/pin_project/private_in_public-enum.rs23
-rw-r--r--third_party/rust/pin-project/tests/ui/pin_project/private_in_public-enum.stderr17
-rw-r--r--third_party/rust/pin-project/tests/ui/pin_project/project_replace_unsized.rs11
-rw-r--r--third_party/rust/pin-project/tests/ui/pin_project/project_replace_unsized.stderr124
-rw-r--r--third_party/rust/pin-project/tests/ui/pin_project/project_replace_unsized_fn_params.rs13
-rw-r--r--third_party/rust/pin-project/tests/ui/pin_project/project_replace_unsized_fn_params.stderr118
-rw-r--r--third_party/rust/pin-project/tests/ui/pin_project/remove-attr-from-field.rs33
-rw-r--r--third_party/rust/pin-project/tests/ui/pin_project/remove-attr-from-field.stderr21
-rw-r--r--third_party/rust/pin-project/tests/ui/pin_project/remove-attr-from-struct.rs47
-rw-r--r--third_party/rust/pin-project/tests/ui/pin_project/remove-attr-from-struct.stderr117
-rw-r--r--third_party/rust/pin-project/tests/ui/pin_project/safe_packed_borrows.rs25
-rw-r--r--third_party/rust/pin-project/tests/ui/pin_project/safe_packed_borrows.stderr31
-rw-r--r--third_party/rust/pin-project/tests/ui/pin_project/unaligned_references.rs19
-rw-r--r--third_party/rust/pin-project/tests/ui/pin_project/unaligned_references.stderr19
-rw-r--r--third_party/rust/pin-project/tests/ui/pin_project/unpin_sneaky.rs11
-rw-r--r--third_party/rust/pin-project/tests/ui/pin_project/unpin_sneaky.stderr5
-rw-r--r--third_party/rust/pin-project/tests/ui/pin_project/visibility.rs49
-rw-r--r--third_party/rust/pin-project/tests/ui/pin_project/visibility.stderr39
-rw-r--r--third_party/rust/pin-project/tests/ui/pinned_drop/call-drop-inner.rs17
-rw-r--r--third_party/rust/pin-project/tests/ui/pinned_drop/call-drop-inner.stderr15
-rw-r--r--third_party/rust/pin-project/tests/ui/pinned_drop/conditional-drop-impl.rs27
-rw-r--r--third_party/rust/pin-project/tests/ui/pinned_drop/conditional-drop-impl.stderr31
-rw-r--r--third_party/rust/pin-project/tests/ui/pinned_drop/forget-pinned-drop-impl.rs9
-rw-r--r--third_party/rust/pin-project/tests/ui/pinned_drop/forget-pinned-drop-impl.stderr5
-rw-r--r--third_party/rust/pin-project/tests/ui/pinned_drop/invalid-self.rs14
-rw-r--r--third_party/rust/pin-project/tests/ui/pinned_drop/invalid-self.stderr25
-rw-r--r--third_party/rust/pin-project/tests/ui/pinned_drop/invalid.rs231
-rw-r--r--third_party/rust/pin-project/tests/ui/pinned_drop/invalid.stderr143
-rw-r--r--third_party/rust/pin-project/tests/ui/pinned_drop/pinned-drop-no-attr-arg.rs17
-rw-r--r--third_party/rust/pin-project/tests/ui/pinned_drop/pinned-drop-no-attr-arg.stderr8
-rw-r--r--third_party/rust/pin-project/tests/ui/pinned_drop/self.rs58
-rw-r--r--third_party/rust/pin-project/tests/ui/pinned_drop/self.stderr62
-rw-r--r--third_party/rust/pin-project/tests/ui/pinned_drop/unsafe-call.rs18
-rw-r--r--third_party/rust/pin-project/tests/ui/pinned_drop/unsafe-call.stderr10
-rw-r--r--third_party/rust/pin-project/tests/ui/unsafe_unpin/conflict-unpin.rs30
-rw-r--r--third_party/rust/pin-project/tests/ui/unsafe_unpin/conflict-unpin.stderr32
-rw-r--r--third_party/rust/pin-project/tests/ui/unstable-features/README.md7
-rw-r--r--third_party/rust/pin-project/tests/ui/unstable-features/marker_trait_attr-feature-gate.rs20
-rw-r--r--third_party/rust/pin-project/tests/ui/unstable-features/marker_trait_attr-feature-gate.stderr10
-rw-r--r--third_party/rust/pin-project/tests/ui/unstable-features/marker_trait_attr.rs26
-rw-r--r--third_party/rust/pin-project/tests/ui/unstable-features/marker_trait_attr.stderr10
-rw-r--r--third_party/rust/pin-project/tests/ui/unstable-features/negative_impls.rs23
-rw-r--r--third_party/rust/pin-project/tests/ui/unstable-features/negative_impls.stderr19
-rw-r--r--third_party/rust/pin-project/tests/ui/unstable-features/overlapping_marker_traits-feature-gate.rs20
-rw-r--r--third_party/rust/pin-project/tests/ui/unstable-features/overlapping_marker_traits-feature-gate.stderr10
-rw-r--r--third_party/rust/pin-project/tests/ui/unstable-features/overlapping_marker_traits.rs30
-rw-r--r--third_party/rust/pin-project/tests/ui/unstable-features/overlapping_marker_traits.stderr18
-rw-r--r--third_party/rust/pin-project/tests/ui/unstable-features/trivial_bounds-feature-gate.rs53
-rw-r--r--third_party/rust/pin-project/tests/ui/unstable-features/trivial_bounds-feature-gate.stderr63
-rw-r--r--third_party/rust/pin-project/tests/ui/unstable-features/trivial_bounds.rs39
-rw-r--r--third_party/rust/pin-project/tests/ui/unstable-features/trivial_bounds.stderr23
-rw-r--r--third_party/rust/pin-project/tests/unsafe_unpin.rs50
184 files changed, 11660 insertions, 0 deletions
diff --git a/third_party/rust/pin-project/tests/auxiliary/mod.rs b/third_party/rust/pin-project/tests/auxiliary/mod.rs
new file mode 100644
index 0000000000..1457099160
--- /dev/null
+++ b/third_party/rust/pin-project/tests/auxiliary/mod.rs
@@ -0,0 +1,12 @@
+#![allow(dead_code, unused_macros)]
+
+macro_rules! assert_unpin {
+ ($ty:ty) => {
+ static_assertions::assert_impl_all!($ty: Unpin);
+ };
+}
+macro_rules! assert_not_unpin {
+ ($ty:ty) => {
+ static_assertions::assert_not_impl_all!($ty: Unpin);
+ };
+}
diff --git a/third_party/rust/pin-project/tests/cfg.rs b/third_party/rust/pin-project/tests/cfg.rs
new file mode 100644
index 0000000000..2f5387b671
--- /dev/null
+++ b/third_party/rust/pin-project/tests/cfg.rs
@@ -0,0 +1,184 @@
+#![warn(rust_2018_idioms, single_use_lifetimes)]
+#![allow(dead_code)]
+
+// Refs: https://doc.rust-lang.org/reference/attributes.html
+
+#[macro_use]
+mod auxiliary;
+
+use std::{marker::PhantomPinned, pin::Pin};
+
+use pin_project::pin_project;
+
+struct Always;
+
+// Use this type to check that `cfg(any())` is working properly.
+struct Never(PhantomPinned);
+
+#[test]
+fn cfg() {
+ // structs
+
+ #[pin_project(project_replace)]
+ struct SameName {
+ #[cfg(not(any()))]
+ #[pin]
+ inner: Always,
+ #[cfg(any())]
+ #[pin]
+ inner: Never,
+ }
+
+ assert_unpin!(SameName);
+
+ let _ = SameName { inner: Always };
+
+ #[pin_project(project_replace)]
+ struct DifferentName {
+ #[cfg(not(any()))]
+ #[pin]
+ a: Always,
+ #[cfg(any())]
+ #[pin]
+ n: Never,
+ }
+
+ assert_unpin!(DifferentName);
+
+ let _ = DifferentName { a: Always };
+
+ #[pin_project(project_replace)]
+ struct TupleStruct(
+ #[cfg(not(any()))]
+ #[pin]
+ Always,
+ #[cfg(any())]
+ #[pin]
+ Never,
+ );
+
+ assert_unpin!(TupleStruct);
+
+ let _ = TupleStruct(Always);
+
+ // enums
+
+ #[pin_project(
+ project = VariantProj,
+ project_ref = VariantProjRef,
+ project_replace = VariantProjOwn,
+ )]
+ enum Variant {
+ #[cfg(not(any()))]
+ Inner(#[pin] Always),
+ #[cfg(any())]
+ Inner(#[pin] Never),
+
+ #[cfg(not(any()))]
+ A(#[pin] Always),
+ #[cfg(any())]
+ N(#[pin] Never),
+ }
+
+ assert_unpin!(Variant);
+
+ let _ = Variant::Inner(Always);
+ let _ = Variant::A(Always);
+
+ #[pin_project(
+ project = FieldProj,
+ project_ref = FieldProjRef,
+ project_replace = FieldProjOwn,
+ )]
+ enum Field {
+ SameName {
+ #[cfg(not(any()))]
+ #[pin]
+ inner: Always,
+ #[cfg(any())]
+ #[pin]
+ inner: Never,
+ },
+ DifferentName {
+ #[cfg(not(any()))]
+ #[pin]
+ a: Always,
+ #[cfg(any())]
+ #[pin]
+ n: Never,
+ },
+ TupleVariant(
+ #[cfg(not(any()))]
+ #[pin]
+ Always,
+ #[cfg(any())]
+ #[pin]
+ Never,
+ ),
+ }
+
+ assert_unpin!(Field);
+
+ let _ = Field::SameName { inner: Always };
+ let _ = Field::DifferentName { a: Always };
+ let _ = Field::TupleVariant(Always);
+}
+
+#[test]
+fn cfg_attr() {
+ #[pin_project(project_replace)]
+ struct SameCfg {
+ #[cfg(not(any()))]
+ #[cfg_attr(not(any()), pin)]
+ inner: Always,
+ #[cfg(any())]
+ #[cfg_attr(any(), pin)]
+ inner: Never,
+ }
+
+ assert_unpin!(SameCfg);
+
+ let mut x = SameCfg { inner: Always };
+ let x = Pin::new(&mut x).project();
+ let _: Pin<&mut Always> = x.inner;
+
+ #[pin_project(project_replace)]
+ struct DifferentCfg {
+ #[cfg(not(any()))]
+ #[cfg_attr(any(), pin)]
+ inner: Always,
+ #[cfg(any())]
+ #[cfg_attr(not(any()), pin)]
+ inner: Never,
+ }
+
+ assert_unpin!(DifferentCfg);
+
+ let mut x = DifferentCfg { inner: Always };
+ let x = Pin::new(&mut x).project();
+ let _: &mut Always = x.inner;
+
+ #[cfg_attr(not(any()), pin_project)]
+ struct Foo<T> {
+ #[cfg_attr(not(any()), pin)]
+ inner: T,
+ }
+
+ assert_unpin!(Foo<()>);
+ assert_not_unpin!(Foo<PhantomPinned>);
+
+ let mut x = Foo { inner: 0_u8 };
+ let x = Pin::new(&mut x).project();
+ let _: Pin<&mut u8> = x.inner;
+}
+
+#[test]
+fn cfg_attr_any_packed() {
+ // Since `cfg(any())` can never be true, it is okay for this to pass.
+ #[pin_project(project_replace)]
+ #[cfg_attr(any(), repr(packed))]
+ struct Struct {
+ #[pin]
+ f: u32,
+ }
+}
diff --git a/third_party/rust/pin-project/tests/compiletest.rs b/third_party/rust/pin-project/tests/compiletest.rs
new file mode 100644
index 0000000000..cb30f602ab
--- /dev/null
+++ b/third_party/rust/pin-project/tests/compiletest.rs
@@ -0,0 +1,17 @@
+#![cfg(not(miri))]
+#![cfg(not(careful))]
+#![warn(rust_2018_idioms, single_use_lifetimes)]
+
+use std::env;
+
+#[rustversion::attr(not(nightly), ignore)]
+#[test]
+fn ui() {
+ if env::var_os("CI").is_none() {
+ env::set_var("TRYBUILD", "overwrite");
+ }
+
+ let t = trybuild::TestCases::new();
+ t.compile_fail("tests/ui/**/*.rs");
+ t.pass("tests/run-pass/**/*.rs");
+}
diff --git a/third_party/rust/pin-project/tests/drop_order.rs b/third_party/rust/pin-project/tests/drop_order.rs
new file mode 100644
index 0000000000..8ced56e75a
--- /dev/null
+++ b/third_party/rust/pin-project/tests/drop_order.rs
@@ -0,0 +1,162 @@
+#![warn(rust_2018_idioms, single_use_lifetimes)]
+
+// Refs: https://doc.rust-lang.org/reference/destructors.html
+
+use std::{cell::Cell, pin::Pin, thread};
+
+use pin_project::pin_project;
+
+struct D<'a>(&'a Cell<usize>, usize);
+
+impl Drop for D<'_> {
+ fn drop(&mut self) {
+ if !thread::panicking() {
+ let old = self.0.replace(self.1);
+ assert_eq!(old, self.1 - 1);
+ }
+ }
+}
+
+#[pin_project(project_replace)]
+struct StructPinned<'a> {
+ #[pin]
+ f1: D<'a>,
+ #[pin]
+ f2: D<'a>,
+}
+
+#[pin_project(project_replace)]
+struct StructUnpinned<'a> {
+ f1: D<'a>,
+ f2: D<'a>,
+}
+
+#[pin_project(project_replace)]
+struct TuplePinned<'a>(#[pin] D<'a>, #[pin] D<'a>);
+
+#[pin_project(project_replace)]
+struct TupleUnpinned<'a>(D<'a>, D<'a>);
+
+#[pin_project(project_replace = EnumProj)]
+enum Enum<'a> {
+ #[allow(dead_code)] // false positive that fixed in Rust 1.38
+ StructPinned {
+ #[pin]
+ f1: D<'a>,
+ #[pin]
+ f2: D<'a>,
+ },
+ #[allow(dead_code)] // false positive that fixed in Rust 1.38
+ StructUnpinned {
+ f1: D<'a>,
+ f2: D<'a>,
+ },
+ TuplePinned(#[pin] D<'a>, #[pin] D<'a>),
+ TupleUnpinned(D<'a>, D<'a>),
+}
+
+#[test]
+fn struct_pinned() {
+ {
+ let c = Cell::new(0);
+ let _x = StructPinned { f1: D(&c, 1), f2: D(&c, 2) };
+ }
+ {
+ let c = Cell::new(0);
+ let mut x = StructPinned { f1: D(&c, 1), f2: D(&c, 2) };
+ let y = Pin::new(&mut x);
+ let _z = y.project_replace(StructPinned { f1: D(&c, 3), f2: D(&c, 4) });
+ }
+}
+
+#[test]
+fn struct_unpinned() {
+ {
+ let c = Cell::new(0);
+ let _x = StructUnpinned { f1: D(&c, 1), f2: D(&c, 2) };
+ }
+ {
+ let c = Cell::new(0);
+ let mut x = StructUnpinned { f1: D(&c, 1), f2: D(&c, 2) };
+ let y = Pin::new(&mut x);
+ let _z = y.project_replace(StructUnpinned { f1: D(&c, 3), f2: D(&c, 4) });
+ }
+}
+
+#[test]
+fn tuple_pinned() {
+ {
+ let c = Cell::new(0);
+ let _x = TuplePinned(D(&c, 1), D(&c, 2));
+ }
+ {
+ let c = Cell::new(0);
+ let mut x = TuplePinned(D(&c, 1), D(&c, 2));
+ let y = Pin::new(&mut x);
+ let _z = y.project_replace(TuplePinned(D(&c, 3), D(&c, 4)));
+ }
+}
+
+#[test]
+fn tuple_unpinned() {
+ {
+ let c = Cell::new(0);
+ let _x = TupleUnpinned(D(&c, 1), D(&c, 2));
+ }
+ {
+ let c = Cell::new(0);
+ let mut x = TupleUnpinned(D(&c, 1), D(&c, 2));
+ let y = Pin::new(&mut x);
+ let _z = y.project_replace(TupleUnpinned(D(&c, 3), D(&c, 4)));
+ }
+}
+
+#[test]
+fn enum_struct() {
+ {
+ let c = Cell::new(0);
+ let _x = Enum::StructPinned { f1: D(&c, 1), f2: D(&c, 2) };
+ }
+ {
+ let c = Cell::new(0);
+ let mut x = Enum::StructPinned { f1: D(&c, 1), f2: D(&c, 2) };
+ let y = Pin::new(&mut x);
+ let _z = y.project_replace(Enum::StructPinned { f1: D(&c, 3), f2: D(&c, 4) });
+ }
+
+ {
+ let c = Cell::new(0);
+ let _x = Enum::StructUnpinned { f1: D(&c, 1), f2: D(&c, 2) };
+ }
+ {
+ let c = Cell::new(0);
+ let mut x = Enum::StructUnpinned { f1: D(&c, 1), f2: D(&c, 2) };
+ let y = Pin::new(&mut x);
+ let _z = y.project_replace(Enum::StructUnpinned { f1: D(&c, 3), f2: D(&c, 4) });
+ }
+}
+
+#[test]
+fn enum_tuple() {
+ {
+ let c = Cell::new(0);
+ let _x = Enum::TuplePinned(D(&c, 1), D(&c, 2));
+ }
+ {
+ let c = Cell::new(0);
+ let mut x = Enum::TuplePinned(D(&c, 1), D(&c, 2));
+ let y = Pin::new(&mut x);
+ let _z = y.project_replace(Enum::TuplePinned(D(&c, 3), D(&c, 4)));
+ }
+
+ {
+ let c = Cell::new(0);
+ let _x = Enum::TupleUnpinned(D(&c, 1), D(&c, 2));
+ }
+ {
+ let c = Cell::new(0);
+ let mut x = Enum::TupleUnpinned(D(&c, 1), D(&c, 2));
+ let y = Pin::new(&mut x);
+ let _z = y.project_replace(Enum::TupleUnpinned(D(&c, 3), D(&c, 4)));
+ }
+}
diff --git a/third_party/rust/pin-project/tests/expand/default/enum.expanded.rs b/third_party/rust/pin-project/tests/expand/default/enum.expanded.rs
new file mode 100644
index 0000000000..490bf2e453
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/default/enum.expanded.rs
@@ -0,0 +1,145 @@
+use pin_project::pin_project;
+#[pin(__private(project = EnumProj, project_ref = EnumProjRef))]
+enum Enum<T, U> {
+ Struct { #[pin] pinned: T, unpinned: U },
+ Tuple(#[pin] T, U),
+ Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+#[allow(clippy::mut_mut)]
+enum EnumProj<'pin, T, U>
+where
+ Enum<T, U>: 'pin,
+{
+ Struct {
+ pinned: ::pin_project::__private::Pin<&'pin mut (T)>,
+ unpinned: &'pin mut (U),
+ },
+ Tuple(::pin_project::__private::Pin<&'pin mut (T)>, &'pin mut (U)),
+ Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+#[allow(clippy::ref_option_ref)]
+enum EnumProjRef<'pin, T, U>
+where
+ Enum<T, U>: 'pin,
+{
+ Struct { pinned: ::pin_project::__private::Pin<&'pin (T)>, unpinned: &'pin (U) },
+ Tuple(::pin_project::__private::Pin<&'pin (T)>, &'pin (U)),
+ Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+ #[allow(unused_extern_crates)]
+ extern crate pin_project as _pin_project;
+ impl<T, U> Enum<T, U> {
+ #[allow(dead_code)]
+ fn project<'pin>(
+ self: _pin_project::__private::Pin<&'pin mut Self>,
+ ) -> EnumProj<'pin, T, U> {
+ unsafe {
+ match self.get_unchecked_mut() {
+ Self::Struct { pinned, unpinned } => {
+ EnumProj::Struct {
+ pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+ unpinned,
+ }
+ }
+ Self::Tuple(_0, _1) => {
+ EnumProj::Tuple(
+ _pin_project::__private::Pin::new_unchecked(_0),
+ _1,
+ )
+ }
+ Self::Unit => EnumProj::Unit,
+ }
+ }
+ }
+ #[allow(dead_code)]
+ #[allow(clippy::missing_const_for_fn)]
+ fn project_ref<'pin>(
+ self: _pin_project::__private::Pin<&'pin Self>,
+ ) -> EnumProjRef<'pin, T, U> {
+ unsafe {
+ match self.get_ref() {
+ Self::Struct { pinned, unpinned } => {
+ EnumProjRef::Struct {
+ pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+ unpinned,
+ }
+ }
+ Self::Tuple(_0, _1) => {
+ EnumProjRef::Tuple(
+ _pin_project::__private::Pin::new_unchecked(_0),
+ _1,
+ )
+ }
+ Self::Unit => EnumProjRef::Unit,
+ }
+ }
+ }
+ }
+ #[allow(missing_debug_implementations)]
+ struct __Enum<'pin, T, U> {
+ __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
+ 'pin,
+ (
+ _pin_project::__private::PhantomData<T>,
+ _pin_project::__private::PhantomData<U>,
+ ),
+ >,
+ __field0: T,
+ __field1: T,
+ }
+ impl<'pin, T, U> _pin_project::__private::Unpin for Enum<T, U>
+ where
+ __Enum<'pin, T, U>: _pin_project::__private::Unpin,
+ {}
+ #[doc(hidden)]
+ unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Enum<T, U>
+ where
+ __Enum<'pin, T, U>: _pin_project::__private::Unpin,
+ {}
+ trait EnumMustNotImplDrop {}
+ #[allow(clippy::drop_bounds, drop_bounds)]
+ impl<T: _pin_project::__private::Drop> EnumMustNotImplDrop for T {}
+ impl<T, U> EnumMustNotImplDrop for Enum<T, U> {}
+ #[doc(hidden)]
+ impl<T, U> _pin_project::__private::PinnedDrop for Enum<T, U> {
+ unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+ }
+};
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/default/enum.rs b/third_party/rust/pin-project/tests/expand/default/enum.rs
new file mode 100644
index 0000000000..ff056150ad
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/default/enum.rs
@@ -0,0 +1,14 @@
+use pin_project::pin_project;
+
+#[pin_project(project = EnumProj, project_ref = EnumProjRef)]
+enum Enum<T, U> {
+ Struct {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+ },
+ Tuple(#[pin] T, U),
+ Unit,
+}
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/default/struct.expanded.rs b/third_party/rust/pin-project/tests/expand/default/struct.expanded.rs
new file mode 100644
index 0000000000..0005d863c4
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/default/struct.expanded.rs
@@ -0,0 +1,104 @@
+use pin_project::pin_project;
+#[pin(__private())]
+struct Struct<T, U> {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+ #[allow(unused_extern_crates)]
+ extern crate pin_project as _pin_project;
+ #[allow(dead_code)]
+ #[allow(clippy::mut_mut)]
+ struct __StructProjection<'pin, T, U>
+ where
+ Struct<T, U>: 'pin,
+ {
+ pinned: ::pin_project::__private::Pin<&'pin mut (T)>,
+ unpinned: &'pin mut (U),
+ }
+ #[allow(dead_code)]
+ #[allow(clippy::ref_option_ref)]
+ struct __StructProjectionRef<'pin, T, U>
+ where
+ Struct<T, U>: 'pin,
+ {
+ pinned: ::pin_project::__private::Pin<&'pin (T)>,
+ unpinned: &'pin (U),
+ }
+ impl<T, U> Struct<T, U> {
+ #[allow(dead_code)]
+ fn project<'pin>(
+ self: _pin_project::__private::Pin<&'pin mut Self>,
+ ) -> __StructProjection<'pin, T, U> {
+ unsafe {
+ let Self { pinned, unpinned } = self.get_unchecked_mut();
+ __StructProjection {
+ pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+ unpinned,
+ }
+ }
+ }
+ #[allow(dead_code)]
+ #[allow(clippy::missing_const_for_fn)]
+ fn project_ref<'pin>(
+ self: _pin_project::__private::Pin<&'pin Self>,
+ ) -> __StructProjectionRef<'pin, T, U> {
+ unsafe {
+ let Self { pinned, unpinned } = self.get_ref();
+ __StructProjectionRef {
+ pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+ unpinned,
+ }
+ }
+ }
+ }
+ #[forbid(unaligned_references, safe_packed_borrows)]
+ fn __assert_not_repr_packed<T, U>(this: &Struct<T, U>) {
+ let _ = &this.pinned;
+ let _ = &this.unpinned;
+ }
+ #[allow(missing_debug_implementations)]
+ struct __Struct<'pin, T, U> {
+ __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
+ 'pin,
+ (
+ _pin_project::__private::PhantomData<T>,
+ _pin_project::__private::PhantomData<U>,
+ ),
+ >,
+ __field0: T,
+ }
+ impl<'pin, T, U> _pin_project::__private::Unpin for Struct<T, U>
+ where
+ __Struct<'pin, T, U>: _pin_project::__private::Unpin,
+ {}
+ #[doc(hidden)]
+ unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Struct<T, U>
+ where
+ __Struct<'pin, T, U>: _pin_project::__private::Unpin,
+ {}
+ trait StructMustNotImplDrop {}
+ #[allow(clippy::drop_bounds, drop_bounds)]
+ impl<T: _pin_project::__private::Drop> StructMustNotImplDrop for T {}
+ impl<T, U> StructMustNotImplDrop for Struct<T, U> {}
+ #[doc(hidden)]
+ impl<T, U> _pin_project::__private::PinnedDrop for Struct<T, U> {
+ unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+ }
+};
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/default/struct.rs b/third_party/rust/pin-project/tests/expand/default/struct.rs
new file mode 100644
index 0000000000..474f0a1161
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/default/struct.rs
@@ -0,0 +1,10 @@
+use pin_project::pin_project;
+
+#[pin_project]
+struct Struct<T, U> {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+}
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/default/tuple_struct.expanded.rs b/third_party/rust/pin-project/tests/expand/default/tuple_struct.expanded.rs
new file mode 100644
index 0000000000..1c5e3b08be
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/default/tuple_struct.expanded.rs
@@ -0,0 +1,98 @@
+use pin_project::pin_project;
+#[pin(__private())]
+struct TupleStruct<T, U>(#[pin] T, U);
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+ #[allow(unused_extern_crates)]
+ extern crate pin_project as _pin_project;
+ #[allow(dead_code)]
+ #[allow(clippy::mut_mut)]
+ struct __TupleStructProjection<'pin, T, U>(
+ ::pin_project::__private::Pin<&'pin mut (T)>,
+ &'pin mut (U),
+ )
+ where
+ TupleStruct<T, U>: 'pin;
+ #[allow(dead_code)]
+ #[allow(clippy::ref_option_ref)]
+ struct __TupleStructProjectionRef<'pin, T, U>(
+ ::pin_project::__private::Pin<&'pin (T)>,
+ &'pin (U),
+ )
+ where
+ TupleStruct<T, U>: 'pin;
+ impl<T, U> TupleStruct<T, U> {
+ #[allow(dead_code)]
+ fn project<'pin>(
+ self: _pin_project::__private::Pin<&'pin mut Self>,
+ ) -> __TupleStructProjection<'pin, T, U> {
+ unsafe {
+ let Self(_0, _1) = self.get_unchecked_mut();
+ __TupleStructProjection(
+ _pin_project::__private::Pin::new_unchecked(_0),
+ _1,
+ )
+ }
+ }
+ #[allow(dead_code)]
+ #[allow(clippy::missing_const_for_fn)]
+ fn project_ref<'pin>(
+ self: _pin_project::__private::Pin<&'pin Self>,
+ ) -> __TupleStructProjectionRef<'pin, T, U> {
+ unsafe {
+ let Self(_0, _1) = self.get_ref();
+ __TupleStructProjectionRef(
+ _pin_project::__private::Pin::new_unchecked(_0),
+ _1,
+ )
+ }
+ }
+ }
+ #[forbid(unaligned_references, safe_packed_borrows)]
+ fn __assert_not_repr_packed<T, U>(this: &TupleStruct<T, U>) {
+ let _ = &this.0;
+ let _ = &this.1;
+ }
+ #[allow(missing_debug_implementations)]
+ struct __TupleStruct<'pin, T, U> {
+ __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
+ 'pin,
+ (
+ _pin_project::__private::PhantomData<T>,
+ _pin_project::__private::PhantomData<U>,
+ ),
+ >,
+ __field0: T,
+ }
+ impl<'pin, T, U> _pin_project::__private::Unpin for TupleStruct<T, U>
+ where
+ __TupleStruct<'pin, T, U>: _pin_project::__private::Unpin,
+ {}
+ #[doc(hidden)]
+ unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for TupleStruct<T, U>
+ where
+ __TupleStruct<'pin, T, U>: _pin_project::__private::Unpin,
+ {}
+ trait TupleStructMustNotImplDrop {}
+ #[allow(clippy::drop_bounds, drop_bounds)]
+ impl<T: _pin_project::__private::Drop> TupleStructMustNotImplDrop for T {}
+ impl<T, U> TupleStructMustNotImplDrop for TupleStruct<T, U> {}
+ #[doc(hidden)]
+ impl<T, U> _pin_project::__private::PinnedDrop for TupleStruct<T, U> {
+ unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+ }
+};
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/default/tuple_struct.rs b/third_party/rust/pin-project/tests/expand/default/tuple_struct.rs
new file mode 100644
index 0000000000..398b14f3a5
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/default/tuple_struct.rs
@@ -0,0 +1,6 @@
+use pin_project::pin_project;
+
+#[pin_project]
+struct TupleStruct<T, U>(#[pin] T, U);
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/multifields/enum.expanded.rs b/third_party/rust/pin-project/tests/expand/multifields/enum.expanded.rs
new file mode 100644
index 0000000000..8223de3418
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/multifields/enum.expanded.rs
@@ -0,0 +1,268 @@
+use pin_project::pin_project;
+#[pin(
+ __private(
+ project = EnumProj,
+ project_ref = EnumProjRef,
+ project_replace = EnumProjOwn
+ )
+)]
+enum Enum<T, U> {
+ Struct { #[pin] pinned1: T, #[pin] pinned2: T, unpinned1: U, unpinned2: U },
+ Tuple(#[pin] T, #[pin] T, U, U),
+ Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+#[allow(clippy::mut_mut)]
+enum EnumProj<'pin, T, U>
+where
+ Enum<T, U>: 'pin,
+{
+ Struct {
+ pinned1: ::pin_project::__private::Pin<&'pin mut (T)>,
+ pinned2: ::pin_project::__private::Pin<&'pin mut (T)>,
+ unpinned1: &'pin mut (U),
+ unpinned2: &'pin mut (U),
+ },
+ Tuple(
+ ::pin_project::__private::Pin<&'pin mut (T)>,
+ ::pin_project::__private::Pin<&'pin mut (T)>,
+ &'pin mut (U),
+ &'pin mut (U),
+ ),
+ Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+#[allow(clippy::ref_option_ref)]
+enum EnumProjRef<'pin, T, U>
+where
+ Enum<T, U>: 'pin,
+{
+ Struct {
+ pinned1: ::pin_project::__private::Pin<&'pin (T)>,
+ pinned2: ::pin_project::__private::Pin<&'pin (T)>,
+ unpinned1: &'pin (U),
+ unpinned2: &'pin (U),
+ },
+ Tuple(
+ ::pin_project::__private::Pin<&'pin (T)>,
+ ::pin_project::__private::Pin<&'pin (T)>,
+ &'pin (U),
+ &'pin (U),
+ ),
+ Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+#[allow(variant_size_differences)]
+#[allow(clippy::large_enum_variant)]
+enum EnumProjOwn<T, U> {
+ Struct {
+ pinned1: ::pin_project::__private::PhantomData<T>,
+ pinned2: ::pin_project::__private::PhantomData<T>,
+ unpinned1: U,
+ unpinned2: U,
+ },
+ Tuple(
+ ::pin_project::__private::PhantomData<T>,
+ ::pin_project::__private::PhantomData<T>,
+ U,
+ U,
+ ),
+ Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+ #[allow(unused_extern_crates)]
+ extern crate pin_project as _pin_project;
+ impl<T, U> Enum<T, U> {
+ #[allow(dead_code)]
+ fn project<'pin>(
+ self: _pin_project::__private::Pin<&'pin mut Self>,
+ ) -> EnumProj<'pin, T, U> {
+ unsafe {
+ match self.get_unchecked_mut() {
+ Self::Struct { pinned1, pinned2, unpinned1, unpinned2 } => {
+ EnumProj::Struct {
+ pinned1: _pin_project::__private::Pin::new_unchecked(
+ pinned1,
+ ),
+ pinned2: _pin_project::__private::Pin::new_unchecked(
+ pinned2,
+ ),
+ unpinned1,
+ unpinned2,
+ }
+ }
+ Self::Tuple(_0, _1, _2, _3) => {
+ EnumProj::Tuple(
+ _pin_project::__private::Pin::new_unchecked(_0),
+ _pin_project::__private::Pin::new_unchecked(_1),
+ _2,
+ _3,
+ )
+ }
+ Self::Unit => EnumProj::Unit,
+ }
+ }
+ }
+ #[allow(dead_code)]
+ #[allow(clippy::missing_const_for_fn)]
+ fn project_ref<'pin>(
+ self: _pin_project::__private::Pin<&'pin Self>,
+ ) -> EnumProjRef<'pin, T, U> {
+ unsafe {
+ match self.get_ref() {
+ Self::Struct { pinned1, pinned2, unpinned1, unpinned2 } => {
+ EnumProjRef::Struct {
+ pinned1: _pin_project::__private::Pin::new_unchecked(
+ pinned1,
+ ),
+ pinned2: _pin_project::__private::Pin::new_unchecked(
+ pinned2,
+ ),
+ unpinned1,
+ unpinned2,
+ }
+ }
+ Self::Tuple(_0, _1, _2, _3) => {
+ EnumProjRef::Tuple(
+ _pin_project::__private::Pin::new_unchecked(_0),
+ _pin_project::__private::Pin::new_unchecked(_1),
+ _2,
+ _3,
+ )
+ }
+ Self::Unit => EnumProjRef::Unit,
+ }
+ }
+ }
+ #[allow(dead_code)]
+ fn project_replace(
+ self: _pin_project::__private::Pin<&mut Self>,
+ __replacement: Self,
+ ) -> EnumProjOwn<T, U> {
+ unsafe {
+ let __self_ptr: *mut Self = self.get_unchecked_mut();
+ let __guard = _pin_project::__private::UnsafeOverwriteGuard::new(
+ __self_ptr,
+ __replacement,
+ );
+ match &mut *__self_ptr {
+ Self::Struct { pinned1, pinned2, unpinned1, unpinned2 } => {
+ let __result = EnumProjOwn::Struct {
+ pinned1: _pin_project::__private::PhantomData,
+ pinned2: _pin_project::__private::PhantomData,
+ unpinned1: _pin_project::__private::ptr::read(unpinned1),
+ unpinned2: _pin_project::__private::ptr::read(unpinned2),
+ };
+ {
+ let __guard = _pin_project::__private::UnsafeDropInPlaceGuard::new(
+ pinned2,
+ );
+ let __guard = _pin_project::__private::UnsafeDropInPlaceGuard::new(
+ pinned1,
+ );
+ }
+ __result
+ }
+ Self::Tuple(_0, _1, _2, _3) => {
+ let __result = EnumProjOwn::Tuple(
+ _pin_project::__private::PhantomData,
+ _pin_project::__private::PhantomData,
+ _pin_project::__private::ptr::read(_2),
+ _pin_project::__private::ptr::read(_3),
+ );
+ {
+ let __guard = _pin_project::__private::UnsafeDropInPlaceGuard::new(
+ _1,
+ );
+ let __guard = _pin_project::__private::UnsafeDropInPlaceGuard::new(
+ _0,
+ );
+ }
+ __result
+ }
+ Self::Unit => {
+ let __result = EnumProjOwn::Unit;
+ {}
+ __result
+ }
+ }
+ }
+ }
+ }
+ #[allow(missing_debug_implementations)]
+ struct __Enum<'pin, T, U> {
+ __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
+ 'pin,
+ (
+ _pin_project::__private::PhantomData<T>,
+ _pin_project::__private::PhantomData<U>,
+ ),
+ >,
+ __field0: T,
+ __field1: T,
+ __field2: T,
+ __field3: T,
+ }
+ impl<'pin, T, U> _pin_project::__private::Unpin for Enum<T, U>
+ where
+ __Enum<'pin, T, U>: _pin_project::__private::Unpin,
+ {}
+ #[doc(hidden)]
+ unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Enum<T, U>
+ where
+ __Enum<'pin, T, U>: _pin_project::__private::Unpin,
+ {}
+ trait EnumMustNotImplDrop {}
+ #[allow(clippy::drop_bounds, drop_bounds)]
+ impl<T: _pin_project::__private::Drop> EnumMustNotImplDrop for T {}
+ impl<T, U> EnumMustNotImplDrop for Enum<T, U> {}
+ #[doc(hidden)]
+ impl<T, U> _pin_project::__private::PinnedDrop for Enum<T, U> {
+ unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+ }
+};
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/multifields/enum.rs b/third_party/rust/pin-project/tests/expand/multifields/enum.rs
new file mode 100644
index 0000000000..754d48c9f9
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/multifields/enum.rs
@@ -0,0 +1,17 @@
+use pin_project::pin_project;
+
+#[pin_project(project = EnumProj, project_ref = EnumProjRef, project_replace = EnumProjOwn)]
+enum Enum<T, U> {
+ Struct {
+ #[pin]
+ pinned1: T,
+ #[pin]
+ pinned2: T,
+ unpinned1: U,
+ unpinned2: U,
+ },
+ Tuple(#[pin] T, #[pin] T, U, U),
+ Unit,
+}
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/multifields/struct.expanded.rs b/third_party/rust/pin-project/tests/expand/multifields/struct.expanded.rs
new file mode 100644
index 0000000000..df8dc92575
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/multifields/struct.expanded.rs
@@ -0,0 +1,155 @@
+use pin_project::pin_project;
+#[pin(__private(project_replace))]
+struct Struct<T, U> {
+ #[pin]
+ pinned1: T,
+ #[pin]
+ pinned2: T,
+ unpinned1: U,
+ unpinned2: U,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+ #[allow(unused_extern_crates)]
+ extern crate pin_project as _pin_project;
+ #[allow(dead_code)]
+ #[allow(clippy::mut_mut)]
+ struct __StructProjection<'pin, T, U>
+ where
+ Struct<T, U>: 'pin,
+ {
+ pinned1: ::pin_project::__private::Pin<&'pin mut (T)>,
+ pinned2: ::pin_project::__private::Pin<&'pin mut (T)>,
+ unpinned1: &'pin mut (U),
+ unpinned2: &'pin mut (U),
+ }
+ #[allow(dead_code)]
+ #[allow(clippy::ref_option_ref)]
+ struct __StructProjectionRef<'pin, T, U>
+ where
+ Struct<T, U>: 'pin,
+ {
+ pinned1: ::pin_project::__private::Pin<&'pin (T)>,
+ pinned2: ::pin_project::__private::Pin<&'pin (T)>,
+ unpinned1: &'pin (U),
+ unpinned2: &'pin (U),
+ }
+ #[allow(dead_code)]
+ struct __StructProjectionOwned<T, U> {
+ pinned1: ::pin_project::__private::PhantomData<T>,
+ pinned2: ::pin_project::__private::PhantomData<T>,
+ unpinned1: U,
+ unpinned2: U,
+ }
+ impl<T, U> Struct<T, U> {
+ #[allow(dead_code)]
+ fn project<'pin>(
+ self: _pin_project::__private::Pin<&'pin mut Self>,
+ ) -> __StructProjection<'pin, T, U> {
+ unsafe {
+ let Self { pinned1, pinned2, unpinned1, unpinned2 } = self
+ .get_unchecked_mut();
+ __StructProjection {
+ pinned1: _pin_project::__private::Pin::new_unchecked(pinned1),
+ pinned2: _pin_project::__private::Pin::new_unchecked(pinned2),
+ unpinned1,
+ unpinned2,
+ }
+ }
+ }
+ #[allow(dead_code)]
+ #[allow(clippy::missing_const_for_fn)]
+ fn project_ref<'pin>(
+ self: _pin_project::__private::Pin<&'pin Self>,
+ ) -> __StructProjectionRef<'pin, T, U> {
+ unsafe {
+ let Self { pinned1, pinned2, unpinned1, unpinned2 } = self.get_ref();
+ __StructProjectionRef {
+ pinned1: _pin_project::__private::Pin::new_unchecked(pinned1),
+ pinned2: _pin_project::__private::Pin::new_unchecked(pinned2),
+ unpinned1,
+ unpinned2,
+ }
+ }
+ }
+ #[allow(dead_code)]
+ fn project_replace(
+ self: _pin_project::__private::Pin<&mut Self>,
+ __replacement: Self,
+ ) -> __StructProjectionOwned<T, U> {
+ unsafe {
+ let __self_ptr: *mut Self = self.get_unchecked_mut();
+ let __guard = _pin_project::__private::UnsafeOverwriteGuard::new(
+ __self_ptr,
+ __replacement,
+ );
+ let Self { pinned1, pinned2, unpinned1, unpinned2 } = &mut *__self_ptr;
+ let __result = __StructProjectionOwned {
+ pinned1: _pin_project::__private::PhantomData,
+ pinned2: _pin_project::__private::PhantomData,
+ unpinned1: _pin_project::__private::ptr::read(unpinned1),
+ unpinned2: _pin_project::__private::ptr::read(unpinned2),
+ };
+ {
+ let __guard = _pin_project::__private::UnsafeDropInPlaceGuard::new(
+ pinned2,
+ );
+ let __guard = _pin_project::__private::UnsafeDropInPlaceGuard::new(
+ pinned1,
+ );
+ }
+ __result
+ }
+ }
+ }
+ #[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;
+ }
+ #[allow(missing_debug_implementations)]
+ struct __Struct<'pin, T, U> {
+ __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
+ 'pin,
+ (
+ _pin_project::__private::PhantomData<T>,
+ _pin_project::__private::PhantomData<U>,
+ ),
+ >,
+ __field0: T,
+ __field1: T,
+ }
+ impl<'pin, T, U> _pin_project::__private::Unpin for Struct<T, U>
+ where
+ __Struct<'pin, T, U>: _pin_project::__private::Unpin,
+ {}
+ #[doc(hidden)]
+ unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Struct<T, U>
+ where
+ __Struct<'pin, T, U>: _pin_project::__private::Unpin,
+ {}
+ trait StructMustNotImplDrop {}
+ #[allow(clippy::drop_bounds, drop_bounds)]
+ impl<T: _pin_project::__private::Drop> StructMustNotImplDrop for T {}
+ impl<T, U> StructMustNotImplDrop for Struct<T, U> {}
+ #[doc(hidden)]
+ impl<T, U> _pin_project::__private::PinnedDrop for Struct<T, U> {
+ unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+ }
+};
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/multifields/struct.rs b/third_party/rust/pin-project/tests/expand/multifields/struct.rs
new file mode 100644
index 0000000000..3b319bf813
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/multifields/struct.rs
@@ -0,0 +1,13 @@
+use pin_project::pin_project;
+
+#[pin_project(project_replace)]
+struct Struct<T, U> {
+ #[pin]
+ pinned1: T,
+ #[pin]
+ pinned2: T,
+ unpinned1: U,
+ unpinned2: U,
+}
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/multifields/tuple_struct.expanded.rs b/third_party/rust/pin-project/tests/expand/multifields/tuple_struct.expanded.rs
new file mode 100644
index 0000000000..0c85f9a605
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/multifields/tuple_struct.expanded.rs
@@ -0,0 +1,145 @@
+use pin_project::pin_project;
+#[pin(__private(project_replace))]
+struct TupleStruct<T, U>(#[pin] T, #[pin] T, U, U);
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+ #[allow(unused_extern_crates)]
+ extern crate pin_project as _pin_project;
+ #[allow(dead_code)]
+ #[allow(clippy::mut_mut)]
+ struct __TupleStructProjection<'pin, T, U>(
+ ::pin_project::__private::Pin<&'pin mut (T)>,
+ ::pin_project::__private::Pin<&'pin mut (T)>,
+ &'pin mut (U),
+ &'pin mut (U),
+ )
+ where
+ TupleStruct<T, U>: 'pin;
+ #[allow(dead_code)]
+ #[allow(clippy::ref_option_ref)]
+ struct __TupleStructProjectionRef<'pin, T, U>(
+ ::pin_project::__private::Pin<&'pin (T)>,
+ ::pin_project::__private::Pin<&'pin (T)>,
+ &'pin (U),
+ &'pin (U),
+ )
+ where
+ TupleStruct<T, U>: 'pin;
+ #[allow(dead_code)]
+ struct __TupleStructProjectionOwned<T, U>(
+ ::pin_project::__private::PhantomData<T>,
+ ::pin_project::__private::PhantomData<T>,
+ U,
+ U,
+ );
+ impl<T, U> TupleStruct<T, U> {
+ #[allow(dead_code)]
+ fn project<'pin>(
+ self: _pin_project::__private::Pin<&'pin mut Self>,
+ ) -> __TupleStructProjection<'pin, T, U> {
+ unsafe {
+ let Self(_0, _1, _2, _3) = self.get_unchecked_mut();
+ __TupleStructProjection(
+ _pin_project::__private::Pin::new_unchecked(_0),
+ _pin_project::__private::Pin::new_unchecked(_1),
+ _2,
+ _3,
+ )
+ }
+ }
+ #[allow(dead_code)]
+ #[allow(clippy::missing_const_for_fn)]
+ fn project_ref<'pin>(
+ self: _pin_project::__private::Pin<&'pin Self>,
+ ) -> __TupleStructProjectionRef<'pin, T, U> {
+ unsafe {
+ let Self(_0, _1, _2, _3) = self.get_ref();
+ __TupleStructProjectionRef(
+ _pin_project::__private::Pin::new_unchecked(_0),
+ _pin_project::__private::Pin::new_unchecked(_1),
+ _2,
+ _3,
+ )
+ }
+ }
+ #[allow(dead_code)]
+ fn project_replace(
+ self: _pin_project::__private::Pin<&mut Self>,
+ __replacement: Self,
+ ) -> __TupleStructProjectionOwned<T, U> {
+ unsafe {
+ let __self_ptr: *mut Self = self.get_unchecked_mut();
+ let __guard = _pin_project::__private::UnsafeOverwriteGuard::new(
+ __self_ptr,
+ __replacement,
+ );
+ let Self(_0, _1, _2, _3) = &mut *__self_ptr;
+ let __result = __TupleStructProjectionOwned(
+ _pin_project::__private::PhantomData,
+ _pin_project::__private::PhantomData,
+ _pin_project::__private::ptr::read(_2),
+ _pin_project::__private::ptr::read(_3),
+ );
+ {
+ let __guard = _pin_project::__private::UnsafeDropInPlaceGuard::new(
+ _1,
+ );
+ let __guard = _pin_project::__private::UnsafeDropInPlaceGuard::new(
+ _0,
+ );
+ }
+ __result
+ }
+ }
+ }
+ #[forbid(unaligned_references, safe_packed_borrows)]
+ fn __assert_not_repr_packed<T, U>(this: &TupleStruct<T, U>) {
+ let _ = &this.0;
+ let _ = &this.1;
+ let _ = &this.2;
+ let _ = &this.3;
+ }
+ #[allow(missing_debug_implementations)]
+ struct __TupleStruct<'pin, T, U> {
+ __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
+ 'pin,
+ (
+ _pin_project::__private::PhantomData<T>,
+ _pin_project::__private::PhantomData<U>,
+ ),
+ >,
+ __field0: T,
+ __field1: T,
+ }
+ impl<'pin, T, U> _pin_project::__private::Unpin for TupleStruct<T, U>
+ where
+ __TupleStruct<'pin, T, U>: _pin_project::__private::Unpin,
+ {}
+ #[doc(hidden)]
+ unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for TupleStruct<T, U>
+ where
+ __TupleStruct<'pin, T, U>: _pin_project::__private::Unpin,
+ {}
+ trait TupleStructMustNotImplDrop {}
+ #[allow(clippy::drop_bounds, drop_bounds)]
+ impl<T: _pin_project::__private::Drop> TupleStructMustNotImplDrop for T {}
+ impl<T, U> TupleStructMustNotImplDrop for TupleStruct<T, U> {}
+ #[doc(hidden)]
+ impl<T, U> _pin_project::__private::PinnedDrop for TupleStruct<T, U> {
+ unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+ }
+};
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/multifields/tuple_struct.rs b/third_party/rust/pin-project/tests/expand/multifields/tuple_struct.rs
new file mode 100644
index 0000000000..bc92eee52c
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/multifields/tuple_struct.rs
@@ -0,0 +1,6 @@
+use pin_project::pin_project;
+
+#[pin_project(project_replace)]
+struct TupleStruct<T, U>(#[pin] T, #[pin] T, U, U);
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/naming/enum-all.expanded.rs b/third_party/rust/pin-project/tests/expand/naming/enum-all.expanded.rs
new file mode 100644
index 0000000000..8dbe768ef3
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/naming/enum-all.expanded.rs
@@ -0,0 +1,204 @@
+use pin_project::pin_project;
+#[pin(__private(project = Proj, project_ref = ProjRef, project_replace = ProjOwn))]
+enum Enum<T, U> {
+ Struct { #[pin] pinned: T, unpinned: U },
+ Tuple(#[pin] T, U),
+ Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+#[allow(clippy::mut_mut)]
+enum Proj<'pin, T, U>
+where
+ Enum<T, U>: 'pin,
+{
+ Struct {
+ pinned: ::pin_project::__private::Pin<&'pin mut (T)>,
+ unpinned: &'pin mut (U),
+ },
+ Tuple(::pin_project::__private::Pin<&'pin mut (T)>, &'pin mut (U)),
+ Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+#[allow(clippy::ref_option_ref)]
+enum ProjRef<'pin, T, U>
+where
+ Enum<T, U>: 'pin,
+{
+ Struct { pinned: ::pin_project::__private::Pin<&'pin (T)>, unpinned: &'pin (U) },
+ Tuple(::pin_project::__private::Pin<&'pin (T)>, &'pin (U)),
+ Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+#[allow(variant_size_differences)]
+#[allow(clippy::large_enum_variant)]
+enum ProjOwn<T, U> {
+ Struct { pinned: ::pin_project::__private::PhantomData<T>, unpinned: U },
+ Tuple(::pin_project::__private::PhantomData<T>, U),
+ Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+ #[allow(unused_extern_crates)]
+ extern crate pin_project as _pin_project;
+ impl<T, U> Enum<T, U> {
+ #[allow(dead_code)]
+ fn project<'pin>(
+ self: _pin_project::__private::Pin<&'pin mut Self>,
+ ) -> Proj<'pin, T, U> {
+ unsafe {
+ match self.get_unchecked_mut() {
+ Self::Struct { pinned, unpinned } => {
+ Proj::Struct {
+ pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+ unpinned,
+ }
+ }
+ Self::Tuple(_0, _1) => {
+ Proj::Tuple(_pin_project::__private::Pin::new_unchecked(_0), _1)
+ }
+ Self::Unit => Proj::Unit,
+ }
+ }
+ }
+ #[allow(dead_code)]
+ #[allow(clippy::missing_const_for_fn)]
+ fn project_ref<'pin>(
+ self: _pin_project::__private::Pin<&'pin Self>,
+ ) -> ProjRef<'pin, T, U> {
+ unsafe {
+ match self.get_ref() {
+ Self::Struct { pinned, unpinned } => {
+ ProjRef::Struct {
+ pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+ unpinned,
+ }
+ }
+ Self::Tuple(_0, _1) => {
+ ProjRef::Tuple(
+ _pin_project::__private::Pin::new_unchecked(_0),
+ _1,
+ )
+ }
+ Self::Unit => ProjRef::Unit,
+ }
+ }
+ }
+ #[allow(dead_code)]
+ fn project_replace(
+ self: _pin_project::__private::Pin<&mut Self>,
+ __replacement: Self,
+ ) -> ProjOwn<T, U> {
+ unsafe {
+ let __self_ptr: *mut Self = self.get_unchecked_mut();
+ let __guard = _pin_project::__private::UnsafeOverwriteGuard::new(
+ __self_ptr,
+ __replacement,
+ );
+ match &mut *__self_ptr {
+ Self::Struct { pinned, unpinned } => {
+ let __result = ProjOwn::Struct {
+ pinned: _pin_project::__private::PhantomData,
+ unpinned: _pin_project::__private::ptr::read(unpinned),
+ };
+ {
+ let __guard = _pin_project::__private::UnsafeDropInPlaceGuard::new(
+ pinned,
+ );
+ }
+ __result
+ }
+ Self::Tuple(_0, _1) => {
+ let __result = ProjOwn::Tuple(
+ _pin_project::__private::PhantomData,
+ _pin_project::__private::ptr::read(_1),
+ );
+ {
+ let __guard = _pin_project::__private::UnsafeDropInPlaceGuard::new(
+ _0,
+ );
+ }
+ __result
+ }
+ Self::Unit => {
+ let __result = ProjOwn::Unit;
+ {}
+ __result
+ }
+ }
+ }
+ }
+ }
+ #[allow(missing_debug_implementations)]
+ struct __Enum<'pin, T, U> {
+ __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
+ 'pin,
+ (
+ _pin_project::__private::PhantomData<T>,
+ _pin_project::__private::PhantomData<U>,
+ ),
+ >,
+ __field0: T,
+ __field1: T,
+ }
+ impl<'pin, T, U> _pin_project::__private::Unpin for Enum<T, U>
+ where
+ __Enum<'pin, T, U>: _pin_project::__private::Unpin,
+ {}
+ #[doc(hidden)]
+ unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Enum<T, U>
+ where
+ __Enum<'pin, T, U>: _pin_project::__private::Unpin,
+ {}
+ trait EnumMustNotImplDrop {}
+ #[allow(clippy::drop_bounds, drop_bounds)]
+ impl<T: _pin_project::__private::Drop> EnumMustNotImplDrop for T {}
+ impl<T, U> EnumMustNotImplDrop for Enum<T, U> {}
+ #[doc(hidden)]
+ impl<T, U> _pin_project::__private::PinnedDrop for Enum<T, U> {
+ unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+ }
+};
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/naming/enum-all.rs b/third_party/rust/pin-project/tests/expand/naming/enum-all.rs
new file mode 100644
index 0000000000..dd513e6c36
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/naming/enum-all.rs
@@ -0,0 +1,14 @@
+use pin_project::pin_project;
+
+#[pin_project(project = Proj, project_ref = ProjRef, project_replace = ProjOwn)]
+enum Enum<T, U> {
+ Struct {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+ },
+ Tuple(#[pin] T, U),
+ Unit,
+}
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/naming/enum-mut.expanded.rs b/third_party/rust/pin-project/tests/expand/naming/enum-mut.expanded.rs
new file mode 100644
index 0000000000..c6916ece85
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/naming/enum-mut.expanded.rs
@@ -0,0 +1,99 @@
+use pin_project::pin_project;
+#[pin(__private(project = Proj))]
+enum Enum<T, U> {
+ Struct { #[pin] pinned: T, unpinned: U },
+ Tuple(#[pin] T, U),
+ Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+#[allow(clippy::mut_mut)]
+enum Proj<'pin, T, U>
+where
+ Enum<T, U>: 'pin,
+{
+ Struct {
+ pinned: ::pin_project::__private::Pin<&'pin mut (T)>,
+ unpinned: &'pin mut (U),
+ },
+ Tuple(::pin_project::__private::Pin<&'pin mut (T)>, &'pin mut (U)),
+ Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+ #[allow(unused_extern_crates)]
+ extern crate pin_project as _pin_project;
+ impl<T, U> Enum<T, U> {
+ #[allow(dead_code)]
+ fn project<'pin>(
+ self: _pin_project::__private::Pin<&'pin mut Self>,
+ ) -> Proj<'pin, T, U> {
+ unsafe {
+ match self.get_unchecked_mut() {
+ Self::Struct { pinned, unpinned } => {
+ Proj::Struct {
+ pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+ unpinned,
+ }
+ }
+ Self::Tuple(_0, _1) => {
+ Proj::Tuple(_pin_project::__private::Pin::new_unchecked(_0), _1)
+ }
+ Self::Unit => Proj::Unit,
+ }
+ }
+ }
+ }
+ #[allow(missing_debug_implementations)]
+ struct __Enum<'pin, T, U> {
+ __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
+ 'pin,
+ (
+ _pin_project::__private::PhantomData<T>,
+ _pin_project::__private::PhantomData<U>,
+ ),
+ >,
+ __field0: T,
+ __field1: T,
+ }
+ impl<'pin, T, U> _pin_project::__private::Unpin for Enum<T, U>
+ where
+ __Enum<'pin, T, U>: _pin_project::__private::Unpin,
+ {}
+ #[doc(hidden)]
+ unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Enum<T, U>
+ where
+ __Enum<'pin, T, U>: _pin_project::__private::Unpin,
+ {}
+ trait EnumMustNotImplDrop {}
+ #[allow(clippy::drop_bounds, drop_bounds)]
+ impl<T: _pin_project::__private::Drop> EnumMustNotImplDrop for T {}
+ impl<T, U> EnumMustNotImplDrop for Enum<T, U> {}
+ #[doc(hidden)]
+ impl<T, U> _pin_project::__private::PinnedDrop for Enum<T, U> {
+ unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+ }
+};
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/naming/enum-mut.rs b/third_party/rust/pin-project/tests/expand/naming/enum-mut.rs
new file mode 100644
index 0000000000..818276f39c
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/naming/enum-mut.rs
@@ -0,0 +1,14 @@
+use pin_project::pin_project;
+
+#[pin_project(project = Proj)]
+enum Enum<T, U> {
+ Struct {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+ },
+ Tuple(#[pin] T, U),
+ Unit,
+}
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/naming/enum-none.expanded.rs b/third_party/rust/pin-project/tests/expand/naming/enum-none.expanded.rs
new file mode 100644
index 0000000000..46477d1e9d
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/naming/enum-none.expanded.rs
@@ -0,0 +1,56 @@
+use pin_project::pin_project;
+#[pin(__private())]
+enum Enum<T, U> {
+ Struct { #[pin] pinned: T, unpinned: U },
+ Tuple(#[pin] T, U),
+ Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+ #[allow(unused_extern_crates)]
+ extern crate pin_project as _pin_project;
+ impl<T, U> Enum<T, U> {}
+ #[allow(missing_debug_implementations)]
+ struct __Enum<'pin, T, U> {
+ __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
+ 'pin,
+ (
+ _pin_project::__private::PhantomData<T>,
+ _pin_project::__private::PhantomData<U>,
+ ),
+ >,
+ __field0: T,
+ __field1: T,
+ }
+ impl<'pin, T, U> _pin_project::__private::Unpin for Enum<T, U>
+ where
+ __Enum<'pin, T, U>: _pin_project::__private::Unpin,
+ {}
+ #[doc(hidden)]
+ unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Enum<T, U>
+ where
+ __Enum<'pin, T, U>: _pin_project::__private::Unpin,
+ {}
+ trait EnumMustNotImplDrop {}
+ #[allow(clippy::drop_bounds, drop_bounds)]
+ impl<T: _pin_project::__private::Drop> EnumMustNotImplDrop for T {}
+ impl<T, U> EnumMustNotImplDrop for Enum<T, U> {}
+ #[doc(hidden)]
+ impl<T, U> _pin_project::__private::PinnedDrop for Enum<T, U> {
+ unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+ }
+};
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/naming/enum-none.rs b/third_party/rust/pin-project/tests/expand/naming/enum-none.rs
new file mode 100644
index 0000000000..a87438db38
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/naming/enum-none.rs
@@ -0,0 +1,14 @@
+use pin_project::pin_project;
+
+#[pin_project]
+enum Enum<T, U> {
+ Struct {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+ },
+ Tuple(#[pin] T, U),
+ Unit,
+}
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/naming/enum-own.expanded.rs b/third_party/rust/pin-project/tests/expand/naming/enum-own.expanded.rs
new file mode 100644
index 0000000000..ddeb00c4b5
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/naming/enum-own.expanded.rs
@@ -0,0 +1,119 @@
+use pin_project::pin_project;
+#[pin(__private(project_replace = ProjOwn))]
+enum Enum<T, U> {
+ Struct { #[pin] pinned: T, unpinned: U },
+ Tuple(#[pin] T, U),
+ Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+#[allow(variant_size_differences)]
+#[allow(clippy::large_enum_variant)]
+enum ProjOwn<T, U> {
+ Struct { pinned: ::pin_project::__private::PhantomData<T>, unpinned: U },
+ Tuple(::pin_project::__private::PhantomData<T>, U),
+ Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+ #[allow(unused_extern_crates)]
+ extern crate pin_project as _pin_project;
+ impl<T, U> Enum<T, U> {
+ #[allow(dead_code)]
+ fn project_replace(
+ self: _pin_project::__private::Pin<&mut Self>,
+ __replacement: Self,
+ ) -> ProjOwn<T, U> {
+ unsafe {
+ let __self_ptr: *mut Self = self.get_unchecked_mut();
+ let __guard = _pin_project::__private::UnsafeOverwriteGuard::new(
+ __self_ptr,
+ __replacement,
+ );
+ match &mut *__self_ptr {
+ Self::Struct { pinned, unpinned } => {
+ let __result = ProjOwn::Struct {
+ pinned: _pin_project::__private::PhantomData,
+ unpinned: _pin_project::__private::ptr::read(unpinned),
+ };
+ {
+ let __guard = _pin_project::__private::UnsafeDropInPlaceGuard::new(
+ pinned,
+ );
+ }
+ __result
+ }
+ Self::Tuple(_0, _1) => {
+ let __result = ProjOwn::Tuple(
+ _pin_project::__private::PhantomData,
+ _pin_project::__private::ptr::read(_1),
+ );
+ {
+ let __guard = _pin_project::__private::UnsafeDropInPlaceGuard::new(
+ _0,
+ );
+ }
+ __result
+ }
+ Self::Unit => {
+ let __result = ProjOwn::Unit;
+ {}
+ __result
+ }
+ }
+ }
+ }
+ }
+ #[allow(missing_debug_implementations)]
+ struct __Enum<'pin, T, U> {
+ __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
+ 'pin,
+ (
+ _pin_project::__private::PhantomData<T>,
+ _pin_project::__private::PhantomData<U>,
+ ),
+ >,
+ __field0: T,
+ __field1: T,
+ }
+ impl<'pin, T, U> _pin_project::__private::Unpin for Enum<T, U>
+ where
+ __Enum<'pin, T, U>: _pin_project::__private::Unpin,
+ {}
+ #[doc(hidden)]
+ unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Enum<T, U>
+ where
+ __Enum<'pin, T, U>: _pin_project::__private::Unpin,
+ {}
+ trait EnumMustNotImplDrop {}
+ #[allow(clippy::drop_bounds, drop_bounds)]
+ impl<T: _pin_project::__private::Drop> EnumMustNotImplDrop for T {}
+ impl<T, U> EnumMustNotImplDrop for Enum<T, U> {}
+ #[doc(hidden)]
+ impl<T, U> _pin_project::__private::PinnedDrop for Enum<T, U> {
+ unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+ }
+};
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/naming/enum-own.rs b/third_party/rust/pin-project/tests/expand/naming/enum-own.rs
new file mode 100644
index 0000000000..cf886974db
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/naming/enum-own.rs
@@ -0,0 +1,14 @@
+use pin_project::pin_project;
+
+#[pin_project(project_replace = ProjOwn)]
+enum Enum<T, U> {
+ Struct {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+ },
+ Tuple(#[pin] T, U),
+ Unit,
+}
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/naming/enum-ref.expanded.rs b/third_party/rust/pin-project/tests/expand/naming/enum-ref.expanded.rs
new file mode 100644
index 0000000000..1a49584e75
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/naming/enum-ref.expanded.rs
@@ -0,0 +1,100 @@
+use pin_project::pin_project;
+#[pin(__private(project_ref = ProjRef))]
+enum Enum<T, U> {
+ Struct { #[pin] pinned: T, unpinned: U },
+ Tuple(#[pin] T, U),
+ Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+#[allow(clippy::ref_option_ref)]
+enum ProjRef<'pin, T, U>
+where
+ Enum<T, U>: 'pin,
+{
+ Struct { pinned: ::pin_project::__private::Pin<&'pin (T)>, unpinned: &'pin (U) },
+ Tuple(::pin_project::__private::Pin<&'pin (T)>, &'pin (U)),
+ Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+ #[allow(unused_extern_crates)]
+ extern crate pin_project as _pin_project;
+ impl<T, U> Enum<T, U> {
+ #[allow(dead_code)]
+ #[allow(clippy::missing_const_for_fn)]
+ fn project_ref<'pin>(
+ self: _pin_project::__private::Pin<&'pin Self>,
+ ) -> ProjRef<'pin, T, U> {
+ unsafe {
+ match self.get_ref() {
+ Self::Struct { pinned, unpinned } => {
+ ProjRef::Struct {
+ pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+ unpinned,
+ }
+ }
+ Self::Tuple(_0, _1) => {
+ ProjRef::Tuple(
+ _pin_project::__private::Pin::new_unchecked(_0),
+ _1,
+ )
+ }
+ Self::Unit => ProjRef::Unit,
+ }
+ }
+ }
+ }
+ #[allow(missing_debug_implementations)]
+ struct __Enum<'pin, T, U> {
+ __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
+ 'pin,
+ (
+ _pin_project::__private::PhantomData<T>,
+ _pin_project::__private::PhantomData<U>,
+ ),
+ >,
+ __field0: T,
+ __field1: T,
+ }
+ impl<'pin, T, U> _pin_project::__private::Unpin for Enum<T, U>
+ where
+ __Enum<'pin, T, U>: _pin_project::__private::Unpin,
+ {}
+ #[doc(hidden)]
+ unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Enum<T, U>
+ where
+ __Enum<'pin, T, U>: _pin_project::__private::Unpin,
+ {}
+ trait EnumMustNotImplDrop {}
+ #[allow(clippy::drop_bounds, drop_bounds)]
+ impl<T: _pin_project::__private::Drop> EnumMustNotImplDrop for T {}
+ impl<T, U> EnumMustNotImplDrop for Enum<T, U> {}
+ #[doc(hidden)]
+ impl<T, U> _pin_project::__private::PinnedDrop for Enum<T, U> {
+ unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+ }
+};
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/naming/enum-ref.rs b/third_party/rust/pin-project/tests/expand/naming/enum-ref.rs
new file mode 100644
index 0000000000..b1ff805ce5
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/naming/enum-ref.rs
@@ -0,0 +1,14 @@
+use pin_project::pin_project;
+
+#[pin_project(project_ref = ProjRef)]
+enum Enum<T, U> {
+ Struct {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+ },
+ Tuple(#[pin] T, U),
+ Unit,
+}
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/naming/struct-all.expanded.rs b/third_party/rust/pin-project/tests/expand/naming/struct-all.expanded.rs
new file mode 100644
index 0000000000..e598a4f354
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/naming/struct-all.expanded.rs
@@ -0,0 +1,163 @@
+use pin_project::pin_project;
+#[pin(__private(project = Proj, project_ref = ProjRef, project_replace = ProjOwn))]
+struct Struct<T, U> {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+#[allow(clippy::mut_mut)]
+struct Proj<'pin, T, U>
+where
+ Struct<T, U>: 'pin,
+{
+ pinned: ::pin_project::__private::Pin<&'pin mut (T)>,
+ unpinned: &'pin mut (U),
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+#[allow(clippy::ref_option_ref)]
+struct ProjRef<'pin, T, U>
+where
+ Struct<T, U>: 'pin,
+{
+ pinned: ::pin_project::__private::Pin<&'pin (T)>,
+ unpinned: &'pin (U),
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+struct ProjOwn<T, U> {
+ pinned: ::pin_project::__private::PhantomData<T>,
+ unpinned: U,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+ #[allow(unused_extern_crates)]
+ extern crate pin_project as _pin_project;
+ impl<T, U> Struct<T, U> {
+ #[allow(dead_code)]
+ fn project<'pin>(
+ self: _pin_project::__private::Pin<&'pin mut Self>,
+ ) -> Proj<'pin, T, U> {
+ unsafe {
+ let Self { pinned, unpinned } = self.get_unchecked_mut();
+ Proj {
+ pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+ unpinned,
+ }
+ }
+ }
+ #[allow(dead_code)]
+ #[allow(clippy::missing_const_for_fn)]
+ fn project_ref<'pin>(
+ self: _pin_project::__private::Pin<&'pin Self>,
+ ) -> ProjRef<'pin, T, U> {
+ unsafe {
+ let Self { pinned, unpinned } = self.get_ref();
+ ProjRef {
+ pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+ unpinned,
+ }
+ }
+ }
+ #[allow(dead_code)]
+ fn project_replace(
+ self: _pin_project::__private::Pin<&mut Self>,
+ __replacement: Self,
+ ) -> ProjOwn<T, U> {
+ unsafe {
+ let __self_ptr: *mut Self = self.get_unchecked_mut();
+ let __guard = _pin_project::__private::UnsafeOverwriteGuard::new(
+ __self_ptr,
+ __replacement,
+ );
+ let Self { pinned, unpinned } = &mut *__self_ptr;
+ let __result = ProjOwn {
+ pinned: _pin_project::__private::PhantomData,
+ unpinned: _pin_project::__private::ptr::read(unpinned),
+ };
+ {
+ let __guard = _pin_project::__private::UnsafeDropInPlaceGuard::new(
+ pinned,
+ );
+ }
+ __result
+ }
+ }
+ }
+ #[forbid(unaligned_references, safe_packed_borrows)]
+ fn __assert_not_repr_packed<T, U>(this: &Struct<T, U>) {
+ let _ = &this.pinned;
+ let _ = &this.unpinned;
+ }
+ #[allow(missing_debug_implementations)]
+ struct __Struct<'pin, T, U> {
+ __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
+ 'pin,
+ (
+ _pin_project::__private::PhantomData<T>,
+ _pin_project::__private::PhantomData<U>,
+ ),
+ >,
+ __field0: T,
+ }
+ impl<'pin, T, U> _pin_project::__private::Unpin for Struct<T, U>
+ where
+ __Struct<'pin, T, U>: _pin_project::__private::Unpin,
+ {}
+ #[doc(hidden)]
+ unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Struct<T, U>
+ where
+ __Struct<'pin, T, U>: _pin_project::__private::Unpin,
+ {}
+ trait StructMustNotImplDrop {}
+ #[allow(clippy::drop_bounds, drop_bounds)]
+ impl<T: _pin_project::__private::Drop> StructMustNotImplDrop for T {}
+ impl<T, U> StructMustNotImplDrop for Struct<T, U> {}
+ #[doc(hidden)]
+ impl<T, U> _pin_project::__private::PinnedDrop for Struct<T, U> {
+ unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+ }
+};
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/naming/struct-all.rs b/third_party/rust/pin-project/tests/expand/naming/struct-all.rs
new file mode 100644
index 0000000000..c229ba4e0e
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/naming/struct-all.rs
@@ -0,0 +1,10 @@
+use pin_project::pin_project;
+
+#[pin_project(project = Proj, project_ref = ProjRef, project_replace = ProjOwn)]
+struct Struct<T, U> {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+}
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/naming/struct-mut.expanded.rs b/third_party/rust/pin-project/tests/expand/naming/struct-mut.expanded.rs
new file mode 100644
index 0000000000..88782ee253
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/naming/struct-mut.expanded.rs
@@ -0,0 +1,114 @@
+use pin_project::pin_project;
+#[pin(__private(project = Proj))]
+struct Struct<T, U> {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+#[allow(clippy::mut_mut)]
+struct Proj<'pin, T, U>
+where
+ Struct<T, U>: 'pin,
+{
+ pinned: ::pin_project::__private::Pin<&'pin mut (T)>,
+ unpinned: &'pin mut (U),
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+ #[allow(unused_extern_crates)]
+ extern crate pin_project as _pin_project;
+ #[allow(dead_code)]
+ #[allow(clippy::ref_option_ref)]
+ struct __StructProjectionRef<'pin, T, U>
+ where
+ Struct<T, U>: 'pin,
+ {
+ pinned: ::pin_project::__private::Pin<&'pin (T)>,
+ unpinned: &'pin (U),
+ }
+ impl<T, U> Struct<T, U> {
+ #[allow(dead_code)]
+ fn project<'pin>(
+ self: _pin_project::__private::Pin<&'pin mut Self>,
+ ) -> Proj<'pin, T, U> {
+ unsafe {
+ let Self { pinned, unpinned } = self.get_unchecked_mut();
+ Proj {
+ pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+ unpinned,
+ }
+ }
+ }
+ #[allow(dead_code)]
+ #[allow(clippy::missing_const_for_fn)]
+ fn project_ref<'pin>(
+ self: _pin_project::__private::Pin<&'pin Self>,
+ ) -> __StructProjectionRef<'pin, T, U> {
+ unsafe {
+ let Self { pinned, unpinned } = self.get_ref();
+ __StructProjectionRef {
+ pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+ unpinned,
+ }
+ }
+ }
+ }
+ #[forbid(unaligned_references, safe_packed_borrows)]
+ fn __assert_not_repr_packed<T, U>(this: &Struct<T, U>) {
+ let _ = &this.pinned;
+ let _ = &this.unpinned;
+ }
+ #[allow(missing_debug_implementations)]
+ struct __Struct<'pin, T, U> {
+ __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
+ 'pin,
+ (
+ _pin_project::__private::PhantomData<T>,
+ _pin_project::__private::PhantomData<U>,
+ ),
+ >,
+ __field0: T,
+ }
+ impl<'pin, T, U> _pin_project::__private::Unpin for Struct<T, U>
+ where
+ __Struct<'pin, T, U>: _pin_project::__private::Unpin,
+ {}
+ #[doc(hidden)]
+ unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Struct<T, U>
+ where
+ __Struct<'pin, T, U>: _pin_project::__private::Unpin,
+ {}
+ trait StructMustNotImplDrop {}
+ #[allow(clippy::drop_bounds, drop_bounds)]
+ impl<T: _pin_project::__private::Drop> StructMustNotImplDrop for T {}
+ impl<T, U> StructMustNotImplDrop for Struct<T, U> {}
+ #[doc(hidden)]
+ impl<T, U> _pin_project::__private::PinnedDrop for Struct<T, U> {
+ unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+ }
+};
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/naming/struct-mut.rs b/third_party/rust/pin-project/tests/expand/naming/struct-mut.rs
new file mode 100644
index 0000000000..2f554d324d
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/naming/struct-mut.rs
@@ -0,0 +1,10 @@
+use pin_project::pin_project;
+
+#[pin_project(project = Proj)]
+struct Struct<T, U> {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+}
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/naming/struct-none.expanded.rs b/third_party/rust/pin-project/tests/expand/naming/struct-none.expanded.rs
new file mode 100644
index 0000000000..0005d863c4
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/naming/struct-none.expanded.rs
@@ -0,0 +1,104 @@
+use pin_project::pin_project;
+#[pin(__private())]
+struct Struct<T, U> {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+ #[allow(unused_extern_crates)]
+ extern crate pin_project as _pin_project;
+ #[allow(dead_code)]
+ #[allow(clippy::mut_mut)]
+ struct __StructProjection<'pin, T, U>
+ where
+ Struct<T, U>: 'pin,
+ {
+ pinned: ::pin_project::__private::Pin<&'pin mut (T)>,
+ unpinned: &'pin mut (U),
+ }
+ #[allow(dead_code)]
+ #[allow(clippy::ref_option_ref)]
+ struct __StructProjectionRef<'pin, T, U>
+ where
+ Struct<T, U>: 'pin,
+ {
+ pinned: ::pin_project::__private::Pin<&'pin (T)>,
+ unpinned: &'pin (U),
+ }
+ impl<T, U> Struct<T, U> {
+ #[allow(dead_code)]
+ fn project<'pin>(
+ self: _pin_project::__private::Pin<&'pin mut Self>,
+ ) -> __StructProjection<'pin, T, U> {
+ unsafe {
+ let Self { pinned, unpinned } = self.get_unchecked_mut();
+ __StructProjection {
+ pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+ unpinned,
+ }
+ }
+ }
+ #[allow(dead_code)]
+ #[allow(clippy::missing_const_for_fn)]
+ fn project_ref<'pin>(
+ self: _pin_project::__private::Pin<&'pin Self>,
+ ) -> __StructProjectionRef<'pin, T, U> {
+ unsafe {
+ let Self { pinned, unpinned } = self.get_ref();
+ __StructProjectionRef {
+ pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+ unpinned,
+ }
+ }
+ }
+ }
+ #[forbid(unaligned_references, safe_packed_borrows)]
+ fn __assert_not_repr_packed<T, U>(this: &Struct<T, U>) {
+ let _ = &this.pinned;
+ let _ = &this.unpinned;
+ }
+ #[allow(missing_debug_implementations)]
+ struct __Struct<'pin, T, U> {
+ __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
+ 'pin,
+ (
+ _pin_project::__private::PhantomData<T>,
+ _pin_project::__private::PhantomData<U>,
+ ),
+ >,
+ __field0: T,
+ }
+ impl<'pin, T, U> _pin_project::__private::Unpin for Struct<T, U>
+ where
+ __Struct<'pin, T, U>: _pin_project::__private::Unpin,
+ {}
+ #[doc(hidden)]
+ unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Struct<T, U>
+ where
+ __Struct<'pin, T, U>: _pin_project::__private::Unpin,
+ {}
+ trait StructMustNotImplDrop {}
+ #[allow(clippy::drop_bounds, drop_bounds)]
+ impl<T: _pin_project::__private::Drop> StructMustNotImplDrop for T {}
+ impl<T, U> StructMustNotImplDrop for Struct<T, U> {}
+ #[doc(hidden)]
+ impl<T, U> _pin_project::__private::PinnedDrop for Struct<T, U> {
+ unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+ }
+};
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/naming/struct-none.rs b/third_party/rust/pin-project/tests/expand/naming/struct-none.rs
new file mode 100644
index 0000000000..474f0a1161
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/naming/struct-none.rs
@@ -0,0 +1,10 @@
+use pin_project::pin_project;
+
+#[pin_project]
+struct Struct<T, U> {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+}
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/naming/struct-own.expanded.rs b/third_party/rust/pin-project/tests/expand/naming/struct-own.expanded.rs
new file mode 100644
index 0000000000..cc248628a9
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/naming/struct-own.expanded.rs
@@ -0,0 +1,143 @@
+use pin_project::pin_project;
+#[pin(__private(project_replace = ProjOwn))]
+struct Struct<T, U> {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+struct ProjOwn<T, U> {
+ pinned: ::pin_project::__private::PhantomData<T>,
+ unpinned: U,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+ #[allow(unused_extern_crates)]
+ extern crate pin_project as _pin_project;
+ #[allow(dead_code)]
+ #[allow(clippy::mut_mut)]
+ struct __StructProjection<'pin, T, U>
+ where
+ Struct<T, U>: 'pin,
+ {
+ pinned: ::pin_project::__private::Pin<&'pin mut (T)>,
+ unpinned: &'pin mut (U),
+ }
+ #[allow(dead_code)]
+ #[allow(clippy::ref_option_ref)]
+ struct __StructProjectionRef<'pin, T, U>
+ where
+ Struct<T, U>: 'pin,
+ {
+ pinned: ::pin_project::__private::Pin<&'pin (T)>,
+ unpinned: &'pin (U),
+ }
+ impl<T, U> Struct<T, U> {
+ #[allow(dead_code)]
+ fn project<'pin>(
+ self: _pin_project::__private::Pin<&'pin mut Self>,
+ ) -> __StructProjection<'pin, T, U> {
+ unsafe {
+ let Self { pinned, unpinned } = self.get_unchecked_mut();
+ __StructProjection {
+ pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+ unpinned,
+ }
+ }
+ }
+ #[allow(dead_code)]
+ #[allow(clippy::missing_const_for_fn)]
+ fn project_ref<'pin>(
+ self: _pin_project::__private::Pin<&'pin Self>,
+ ) -> __StructProjectionRef<'pin, T, U> {
+ unsafe {
+ let Self { pinned, unpinned } = self.get_ref();
+ __StructProjectionRef {
+ pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+ unpinned,
+ }
+ }
+ }
+ #[allow(dead_code)]
+ fn project_replace(
+ self: _pin_project::__private::Pin<&mut Self>,
+ __replacement: Self,
+ ) -> ProjOwn<T, U> {
+ unsafe {
+ let __self_ptr: *mut Self = self.get_unchecked_mut();
+ let __guard = _pin_project::__private::UnsafeOverwriteGuard::new(
+ __self_ptr,
+ __replacement,
+ );
+ let Self { pinned, unpinned } = &mut *__self_ptr;
+ let __result = ProjOwn {
+ pinned: _pin_project::__private::PhantomData,
+ unpinned: _pin_project::__private::ptr::read(unpinned),
+ };
+ {
+ let __guard = _pin_project::__private::UnsafeDropInPlaceGuard::new(
+ pinned,
+ );
+ }
+ __result
+ }
+ }
+ }
+ #[forbid(unaligned_references, safe_packed_borrows)]
+ fn __assert_not_repr_packed<T, U>(this: &Struct<T, U>) {
+ let _ = &this.pinned;
+ let _ = &this.unpinned;
+ }
+ #[allow(missing_debug_implementations)]
+ struct __Struct<'pin, T, U> {
+ __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
+ 'pin,
+ (
+ _pin_project::__private::PhantomData<T>,
+ _pin_project::__private::PhantomData<U>,
+ ),
+ >,
+ __field0: T,
+ }
+ impl<'pin, T, U> _pin_project::__private::Unpin for Struct<T, U>
+ where
+ __Struct<'pin, T, U>: _pin_project::__private::Unpin,
+ {}
+ #[doc(hidden)]
+ unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Struct<T, U>
+ where
+ __Struct<'pin, T, U>: _pin_project::__private::Unpin,
+ {}
+ trait StructMustNotImplDrop {}
+ #[allow(clippy::drop_bounds, drop_bounds)]
+ impl<T: _pin_project::__private::Drop> StructMustNotImplDrop for T {}
+ impl<T, U> StructMustNotImplDrop for Struct<T, U> {}
+ #[doc(hidden)]
+ impl<T, U> _pin_project::__private::PinnedDrop for Struct<T, U> {
+ unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+ }
+};
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/naming/struct-own.rs b/third_party/rust/pin-project/tests/expand/naming/struct-own.rs
new file mode 100644
index 0000000000..4924362ba0
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/naming/struct-own.rs
@@ -0,0 +1,10 @@
+use pin_project::pin_project;
+
+#[pin_project(project_replace = ProjOwn)]
+struct Struct<T, U> {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+}
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/naming/struct-ref.expanded.rs b/third_party/rust/pin-project/tests/expand/naming/struct-ref.expanded.rs
new file mode 100644
index 0000000000..e392f6f9c3
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/naming/struct-ref.expanded.rs
@@ -0,0 +1,114 @@
+use pin_project::pin_project;
+#[pin(__private(project_ref = ProjRef))]
+struct Struct<T, U> {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+#[allow(clippy::ref_option_ref)]
+struct ProjRef<'pin, T, U>
+where
+ Struct<T, U>: 'pin,
+{
+ pinned: ::pin_project::__private::Pin<&'pin (T)>,
+ unpinned: &'pin (U),
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+ #[allow(unused_extern_crates)]
+ extern crate pin_project as _pin_project;
+ #[allow(dead_code)]
+ #[allow(clippy::mut_mut)]
+ struct __StructProjection<'pin, T, U>
+ where
+ Struct<T, U>: 'pin,
+ {
+ pinned: ::pin_project::__private::Pin<&'pin mut (T)>,
+ unpinned: &'pin mut (U),
+ }
+ impl<T, U> Struct<T, U> {
+ #[allow(dead_code)]
+ fn project<'pin>(
+ self: _pin_project::__private::Pin<&'pin mut Self>,
+ ) -> __StructProjection<'pin, T, U> {
+ unsafe {
+ let Self { pinned, unpinned } = self.get_unchecked_mut();
+ __StructProjection {
+ pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+ unpinned,
+ }
+ }
+ }
+ #[allow(dead_code)]
+ #[allow(clippy::missing_const_for_fn)]
+ fn project_ref<'pin>(
+ self: _pin_project::__private::Pin<&'pin Self>,
+ ) -> ProjRef<'pin, T, U> {
+ unsafe {
+ let Self { pinned, unpinned } = self.get_ref();
+ ProjRef {
+ pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+ unpinned,
+ }
+ }
+ }
+ }
+ #[forbid(unaligned_references, safe_packed_borrows)]
+ fn __assert_not_repr_packed<T, U>(this: &Struct<T, U>) {
+ let _ = &this.pinned;
+ let _ = &this.unpinned;
+ }
+ #[allow(missing_debug_implementations)]
+ struct __Struct<'pin, T, U> {
+ __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
+ 'pin,
+ (
+ _pin_project::__private::PhantomData<T>,
+ _pin_project::__private::PhantomData<U>,
+ ),
+ >,
+ __field0: T,
+ }
+ impl<'pin, T, U> _pin_project::__private::Unpin for Struct<T, U>
+ where
+ __Struct<'pin, T, U>: _pin_project::__private::Unpin,
+ {}
+ #[doc(hidden)]
+ unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Struct<T, U>
+ where
+ __Struct<'pin, T, U>: _pin_project::__private::Unpin,
+ {}
+ trait StructMustNotImplDrop {}
+ #[allow(clippy::drop_bounds, drop_bounds)]
+ impl<T: _pin_project::__private::Drop> StructMustNotImplDrop for T {}
+ impl<T, U> StructMustNotImplDrop for Struct<T, U> {}
+ #[doc(hidden)]
+ impl<T, U> _pin_project::__private::PinnedDrop for Struct<T, U> {
+ unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+ }
+};
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/naming/struct-ref.rs b/third_party/rust/pin-project/tests/expand/naming/struct-ref.rs
new file mode 100644
index 0000000000..4e29a162d4
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/naming/struct-ref.rs
@@ -0,0 +1,10 @@
+use pin_project::pin_project;
+
+#[pin_project(project_ref = ProjRef)]
+struct Struct<T, U> {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+}
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/naming/tuple_struct-all.expanded.rs b/third_party/rust/pin-project/tests/expand/naming/tuple_struct-all.expanded.rs
new file mode 100644
index 0000000000..8c148ed95b
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/naming/tuple_struct-all.expanded.rs
@@ -0,0 +1,148 @@
+use pin_project::pin_project;
+#[pin(__private(project = Proj, project_ref = ProjRef, project_replace = ProjOwn))]
+struct TupleStruct<T, U>(#[pin] T, U);
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+#[allow(clippy::mut_mut)]
+struct Proj<'pin, T, U>(
+ ::pin_project::__private::Pin<&'pin mut (T)>,
+ &'pin mut (U),
+)
+where
+ TupleStruct<T, U>: 'pin;
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+#[allow(clippy::ref_option_ref)]
+struct ProjRef<'pin, T, U>(
+ ::pin_project::__private::Pin<&'pin (T)>,
+ &'pin (U),
+)
+where
+ TupleStruct<T, U>: 'pin;
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+struct ProjOwn<T, U>(::pin_project::__private::PhantomData<T>, U);
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+ #[allow(unused_extern_crates)]
+ extern crate pin_project as _pin_project;
+ impl<T, U> TupleStruct<T, U> {
+ #[allow(dead_code)]
+ fn project<'pin>(
+ self: _pin_project::__private::Pin<&'pin mut Self>,
+ ) -> Proj<'pin, T, U> {
+ unsafe {
+ let Self(_0, _1) = self.get_unchecked_mut();
+ Proj(_pin_project::__private::Pin::new_unchecked(_0), _1)
+ }
+ }
+ #[allow(dead_code)]
+ #[allow(clippy::missing_const_for_fn)]
+ fn project_ref<'pin>(
+ self: _pin_project::__private::Pin<&'pin Self>,
+ ) -> ProjRef<'pin, T, U> {
+ unsafe {
+ let Self(_0, _1) = self.get_ref();
+ ProjRef(_pin_project::__private::Pin::new_unchecked(_0), _1)
+ }
+ }
+ #[allow(dead_code)]
+ fn project_replace(
+ self: _pin_project::__private::Pin<&mut Self>,
+ __replacement: Self,
+ ) -> ProjOwn<T, U> {
+ unsafe {
+ let __self_ptr: *mut Self = self.get_unchecked_mut();
+ let __guard = _pin_project::__private::UnsafeOverwriteGuard::new(
+ __self_ptr,
+ __replacement,
+ );
+ let Self(_0, _1) = &mut *__self_ptr;
+ let __result = ProjOwn(
+ _pin_project::__private::PhantomData,
+ _pin_project::__private::ptr::read(_1),
+ );
+ {
+ let __guard = _pin_project::__private::UnsafeDropInPlaceGuard::new(
+ _0,
+ );
+ }
+ __result
+ }
+ }
+ }
+ #[forbid(unaligned_references, safe_packed_borrows)]
+ fn __assert_not_repr_packed<T, U>(this: &TupleStruct<T, U>) {
+ let _ = &this.0;
+ let _ = &this.1;
+ }
+ #[allow(missing_debug_implementations)]
+ struct __TupleStruct<'pin, T, U> {
+ __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
+ 'pin,
+ (
+ _pin_project::__private::PhantomData<T>,
+ _pin_project::__private::PhantomData<U>,
+ ),
+ >,
+ __field0: T,
+ }
+ impl<'pin, T, U> _pin_project::__private::Unpin for TupleStruct<T, U>
+ where
+ __TupleStruct<'pin, T, U>: _pin_project::__private::Unpin,
+ {}
+ #[doc(hidden)]
+ unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for TupleStruct<T, U>
+ where
+ __TupleStruct<'pin, T, U>: _pin_project::__private::Unpin,
+ {}
+ trait TupleStructMustNotImplDrop {}
+ #[allow(clippy::drop_bounds, drop_bounds)]
+ impl<T: _pin_project::__private::Drop> TupleStructMustNotImplDrop for T {}
+ impl<T, U> TupleStructMustNotImplDrop for TupleStruct<T, U> {}
+ #[doc(hidden)]
+ impl<T, U> _pin_project::__private::PinnedDrop for TupleStruct<T, U> {
+ unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+ }
+};
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/naming/tuple_struct-all.rs b/third_party/rust/pin-project/tests/expand/naming/tuple_struct-all.rs
new file mode 100644
index 0000000000..0d95cb0080
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/naming/tuple_struct-all.rs
@@ -0,0 +1,6 @@
+use pin_project::pin_project;
+
+#[pin_project(project = Proj, project_ref = ProjRef, project_replace = ProjOwn)]
+struct TupleStruct<T, U>(#[pin] T, U);
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/naming/tuple_struct-mut.expanded.rs b/third_party/rust/pin-project/tests/expand/naming/tuple_struct-mut.expanded.rs
new file mode 100644
index 0000000000..79c790100d
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/naming/tuple_struct-mut.expanded.rs
@@ -0,0 +1,105 @@
+use pin_project::pin_project;
+#[pin(__private(project = Proj))]
+struct TupleStruct<T, U>(#[pin] T, U);
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+#[allow(clippy::mut_mut)]
+struct Proj<'pin, T, U>(
+ ::pin_project::__private::Pin<&'pin mut (T)>,
+ &'pin mut (U),
+)
+where
+ TupleStruct<T, U>: 'pin;
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+ #[allow(unused_extern_crates)]
+ extern crate pin_project as _pin_project;
+ #[allow(dead_code)]
+ #[allow(clippy::ref_option_ref)]
+ struct __TupleStructProjectionRef<'pin, T, U>(
+ ::pin_project::__private::Pin<&'pin (T)>,
+ &'pin (U),
+ )
+ where
+ TupleStruct<T, U>: 'pin;
+ impl<T, U> TupleStruct<T, U> {
+ #[allow(dead_code)]
+ fn project<'pin>(
+ self: _pin_project::__private::Pin<&'pin mut Self>,
+ ) -> Proj<'pin, T, U> {
+ unsafe {
+ let Self(_0, _1) = self.get_unchecked_mut();
+ Proj(_pin_project::__private::Pin::new_unchecked(_0), _1)
+ }
+ }
+ #[allow(dead_code)]
+ #[allow(clippy::missing_const_for_fn)]
+ fn project_ref<'pin>(
+ self: _pin_project::__private::Pin<&'pin Self>,
+ ) -> __TupleStructProjectionRef<'pin, T, U> {
+ unsafe {
+ let Self(_0, _1) = self.get_ref();
+ __TupleStructProjectionRef(
+ _pin_project::__private::Pin::new_unchecked(_0),
+ _1,
+ )
+ }
+ }
+ }
+ #[forbid(unaligned_references, safe_packed_borrows)]
+ fn __assert_not_repr_packed<T, U>(this: &TupleStruct<T, U>) {
+ let _ = &this.0;
+ let _ = &this.1;
+ }
+ #[allow(missing_debug_implementations)]
+ struct __TupleStruct<'pin, T, U> {
+ __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
+ 'pin,
+ (
+ _pin_project::__private::PhantomData<T>,
+ _pin_project::__private::PhantomData<U>,
+ ),
+ >,
+ __field0: T,
+ }
+ impl<'pin, T, U> _pin_project::__private::Unpin for TupleStruct<T, U>
+ where
+ __TupleStruct<'pin, T, U>: _pin_project::__private::Unpin,
+ {}
+ #[doc(hidden)]
+ unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for TupleStruct<T, U>
+ where
+ __TupleStruct<'pin, T, U>: _pin_project::__private::Unpin,
+ {}
+ trait TupleStructMustNotImplDrop {}
+ #[allow(clippy::drop_bounds, drop_bounds)]
+ impl<T: _pin_project::__private::Drop> TupleStructMustNotImplDrop for T {}
+ impl<T, U> TupleStructMustNotImplDrop for TupleStruct<T, U> {}
+ #[doc(hidden)]
+ impl<T, U> _pin_project::__private::PinnedDrop for TupleStruct<T, U> {
+ unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+ }
+};
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/naming/tuple_struct-mut.rs b/third_party/rust/pin-project/tests/expand/naming/tuple_struct-mut.rs
new file mode 100644
index 0000000000..e9779a6cad
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/naming/tuple_struct-mut.rs
@@ -0,0 +1,6 @@
+use pin_project::pin_project;
+
+#[pin_project(project = Proj)]
+struct TupleStruct<T, U>(#[pin] T, U);
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/naming/tuple_struct-none.expanded.rs b/third_party/rust/pin-project/tests/expand/naming/tuple_struct-none.expanded.rs
new file mode 100644
index 0000000000..1c5e3b08be
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/naming/tuple_struct-none.expanded.rs
@@ -0,0 +1,98 @@
+use pin_project::pin_project;
+#[pin(__private())]
+struct TupleStruct<T, U>(#[pin] T, U);
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+ #[allow(unused_extern_crates)]
+ extern crate pin_project as _pin_project;
+ #[allow(dead_code)]
+ #[allow(clippy::mut_mut)]
+ struct __TupleStructProjection<'pin, T, U>(
+ ::pin_project::__private::Pin<&'pin mut (T)>,
+ &'pin mut (U),
+ )
+ where
+ TupleStruct<T, U>: 'pin;
+ #[allow(dead_code)]
+ #[allow(clippy::ref_option_ref)]
+ struct __TupleStructProjectionRef<'pin, T, U>(
+ ::pin_project::__private::Pin<&'pin (T)>,
+ &'pin (U),
+ )
+ where
+ TupleStruct<T, U>: 'pin;
+ impl<T, U> TupleStruct<T, U> {
+ #[allow(dead_code)]
+ fn project<'pin>(
+ self: _pin_project::__private::Pin<&'pin mut Self>,
+ ) -> __TupleStructProjection<'pin, T, U> {
+ unsafe {
+ let Self(_0, _1) = self.get_unchecked_mut();
+ __TupleStructProjection(
+ _pin_project::__private::Pin::new_unchecked(_0),
+ _1,
+ )
+ }
+ }
+ #[allow(dead_code)]
+ #[allow(clippy::missing_const_for_fn)]
+ fn project_ref<'pin>(
+ self: _pin_project::__private::Pin<&'pin Self>,
+ ) -> __TupleStructProjectionRef<'pin, T, U> {
+ unsafe {
+ let Self(_0, _1) = self.get_ref();
+ __TupleStructProjectionRef(
+ _pin_project::__private::Pin::new_unchecked(_0),
+ _1,
+ )
+ }
+ }
+ }
+ #[forbid(unaligned_references, safe_packed_borrows)]
+ fn __assert_not_repr_packed<T, U>(this: &TupleStruct<T, U>) {
+ let _ = &this.0;
+ let _ = &this.1;
+ }
+ #[allow(missing_debug_implementations)]
+ struct __TupleStruct<'pin, T, U> {
+ __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
+ 'pin,
+ (
+ _pin_project::__private::PhantomData<T>,
+ _pin_project::__private::PhantomData<U>,
+ ),
+ >,
+ __field0: T,
+ }
+ impl<'pin, T, U> _pin_project::__private::Unpin for TupleStruct<T, U>
+ where
+ __TupleStruct<'pin, T, U>: _pin_project::__private::Unpin,
+ {}
+ #[doc(hidden)]
+ unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for TupleStruct<T, U>
+ where
+ __TupleStruct<'pin, T, U>: _pin_project::__private::Unpin,
+ {}
+ trait TupleStructMustNotImplDrop {}
+ #[allow(clippy::drop_bounds, drop_bounds)]
+ impl<T: _pin_project::__private::Drop> TupleStructMustNotImplDrop for T {}
+ impl<T, U> TupleStructMustNotImplDrop for TupleStruct<T, U> {}
+ #[doc(hidden)]
+ impl<T, U> _pin_project::__private::PinnedDrop for TupleStruct<T, U> {
+ unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+ }
+};
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/naming/tuple_struct-none.rs b/third_party/rust/pin-project/tests/expand/naming/tuple_struct-none.rs
new file mode 100644
index 0000000000..398b14f3a5
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/naming/tuple_struct-none.rs
@@ -0,0 +1,6 @@
+use pin_project::pin_project;
+
+#[pin_project]
+struct TupleStruct<T, U>(#[pin] T, U);
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/naming/tuple_struct-own.expanded.rs b/third_party/rust/pin-project/tests/expand/naming/tuple_struct-own.expanded.rs
new file mode 100644
index 0000000000..37e4c34373
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/naming/tuple_struct-own.expanded.rs
@@ -0,0 +1,134 @@
+use pin_project::pin_project;
+#[pin(__private(project_replace = ProjOwn))]
+struct TupleStruct<T, U>(#[pin] T, U);
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+struct ProjOwn<T, U>(::pin_project::__private::PhantomData<T>, U);
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+ #[allow(unused_extern_crates)]
+ extern crate pin_project as _pin_project;
+ #[allow(dead_code)]
+ #[allow(clippy::mut_mut)]
+ struct __TupleStructProjection<'pin, T, U>(
+ ::pin_project::__private::Pin<&'pin mut (T)>,
+ &'pin mut (U),
+ )
+ where
+ TupleStruct<T, U>: 'pin;
+ #[allow(dead_code)]
+ #[allow(clippy::ref_option_ref)]
+ struct __TupleStructProjectionRef<'pin, T, U>(
+ ::pin_project::__private::Pin<&'pin (T)>,
+ &'pin (U),
+ )
+ where
+ TupleStruct<T, U>: 'pin;
+ impl<T, U> TupleStruct<T, U> {
+ #[allow(dead_code)]
+ fn project<'pin>(
+ self: _pin_project::__private::Pin<&'pin mut Self>,
+ ) -> __TupleStructProjection<'pin, T, U> {
+ unsafe {
+ let Self(_0, _1) = self.get_unchecked_mut();
+ __TupleStructProjection(
+ _pin_project::__private::Pin::new_unchecked(_0),
+ _1,
+ )
+ }
+ }
+ #[allow(dead_code)]
+ #[allow(clippy::missing_const_for_fn)]
+ fn project_ref<'pin>(
+ self: _pin_project::__private::Pin<&'pin Self>,
+ ) -> __TupleStructProjectionRef<'pin, T, U> {
+ unsafe {
+ let Self(_0, _1) = self.get_ref();
+ __TupleStructProjectionRef(
+ _pin_project::__private::Pin::new_unchecked(_0),
+ _1,
+ )
+ }
+ }
+ #[allow(dead_code)]
+ fn project_replace(
+ self: _pin_project::__private::Pin<&mut Self>,
+ __replacement: Self,
+ ) -> ProjOwn<T, U> {
+ unsafe {
+ let __self_ptr: *mut Self = self.get_unchecked_mut();
+ let __guard = _pin_project::__private::UnsafeOverwriteGuard::new(
+ __self_ptr,
+ __replacement,
+ );
+ let Self(_0, _1) = &mut *__self_ptr;
+ let __result = ProjOwn(
+ _pin_project::__private::PhantomData,
+ _pin_project::__private::ptr::read(_1),
+ );
+ {
+ let __guard = _pin_project::__private::UnsafeDropInPlaceGuard::new(
+ _0,
+ );
+ }
+ __result
+ }
+ }
+ }
+ #[forbid(unaligned_references, safe_packed_borrows)]
+ fn __assert_not_repr_packed<T, U>(this: &TupleStruct<T, U>) {
+ let _ = &this.0;
+ let _ = &this.1;
+ }
+ #[allow(missing_debug_implementations)]
+ struct __TupleStruct<'pin, T, U> {
+ __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
+ 'pin,
+ (
+ _pin_project::__private::PhantomData<T>,
+ _pin_project::__private::PhantomData<U>,
+ ),
+ >,
+ __field0: T,
+ }
+ impl<'pin, T, U> _pin_project::__private::Unpin for TupleStruct<T, U>
+ where
+ __TupleStruct<'pin, T, U>: _pin_project::__private::Unpin,
+ {}
+ #[doc(hidden)]
+ unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for TupleStruct<T, U>
+ where
+ __TupleStruct<'pin, T, U>: _pin_project::__private::Unpin,
+ {}
+ trait TupleStructMustNotImplDrop {}
+ #[allow(clippy::drop_bounds, drop_bounds)]
+ impl<T: _pin_project::__private::Drop> TupleStructMustNotImplDrop for T {}
+ impl<T, U> TupleStructMustNotImplDrop for TupleStruct<T, U> {}
+ #[doc(hidden)]
+ impl<T, U> _pin_project::__private::PinnedDrop for TupleStruct<T, U> {
+ unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+ }
+};
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/naming/tuple_struct-own.rs b/third_party/rust/pin-project/tests/expand/naming/tuple_struct-own.rs
new file mode 100644
index 0000000000..a15ad4094a
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/naming/tuple_struct-own.rs
@@ -0,0 +1,6 @@
+use pin_project::pin_project;
+
+#[pin_project(project_replace = ProjOwn)]
+struct TupleStruct<T, U>(#[pin] T, U);
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/naming/tuple_struct-ref.expanded.rs b/third_party/rust/pin-project/tests/expand/naming/tuple_struct-ref.expanded.rs
new file mode 100644
index 0000000000..8c8686808c
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/naming/tuple_struct-ref.expanded.rs
@@ -0,0 +1,105 @@
+use pin_project::pin_project;
+#[pin(__private(project_ref = ProjRef))]
+struct TupleStruct<T, U>(#[pin] T, U);
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+#[allow(clippy::ref_option_ref)]
+struct ProjRef<'pin, T, U>(
+ ::pin_project::__private::Pin<&'pin (T)>,
+ &'pin (U),
+)
+where
+ TupleStruct<T, U>: 'pin;
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+ #[allow(unused_extern_crates)]
+ extern crate pin_project as _pin_project;
+ #[allow(dead_code)]
+ #[allow(clippy::mut_mut)]
+ struct __TupleStructProjection<'pin, T, U>(
+ ::pin_project::__private::Pin<&'pin mut (T)>,
+ &'pin mut (U),
+ )
+ where
+ TupleStruct<T, U>: 'pin;
+ impl<T, U> TupleStruct<T, U> {
+ #[allow(dead_code)]
+ fn project<'pin>(
+ self: _pin_project::__private::Pin<&'pin mut Self>,
+ ) -> __TupleStructProjection<'pin, T, U> {
+ unsafe {
+ let Self(_0, _1) = self.get_unchecked_mut();
+ __TupleStructProjection(
+ _pin_project::__private::Pin::new_unchecked(_0),
+ _1,
+ )
+ }
+ }
+ #[allow(dead_code)]
+ #[allow(clippy::missing_const_for_fn)]
+ fn project_ref<'pin>(
+ self: _pin_project::__private::Pin<&'pin Self>,
+ ) -> ProjRef<'pin, T, U> {
+ unsafe {
+ let Self(_0, _1) = self.get_ref();
+ ProjRef(_pin_project::__private::Pin::new_unchecked(_0), _1)
+ }
+ }
+ }
+ #[forbid(unaligned_references, safe_packed_borrows)]
+ fn __assert_not_repr_packed<T, U>(this: &TupleStruct<T, U>) {
+ let _ = &this.0;
+ let _ = &this.1;
+ }
+ #[allow(missing_debug_implementations)]
+ struct __TupleStruct<'pin, T, U> {
+ __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
+ 'pin,
+ (
+ _pin_project::__private::PhantomData<T>,
+ _pin_project::__private::PhantomData<U>,
+ ),
+ >,
+ __field0: T,
+ }
+ impl<'pin, T, U> _pin_project::__private::Unpin for TupleStruct<T, U>
+ where
+ __TupleStruct<'pin, T, U>: _pin_project::__private::Unpin,
+ {}
+ #[doc(hidden)]
+ unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for TupleStruct<T, U>
+ where
+ __TupleStruct<'pin, T, U>: _pin_project::__private::Unpin,
+ {}
+ trait TupleStructMustNotImplDrop {}
+ #[allow(clippy::drop_bounds, drop_bounds)]
+ impl<T: _pin_project::__private::Drop> TupleStructMustNotImplDrop for T {}
+ impl<T, U> TupleStructMustNotImplDrop for TupleStruct<T, U> {}
+ #[doc(hidden)]
+ impl<T, U> _pin_project::__private::PinnedDrop for TupleStruct<T, U> {
+ unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+ }
+};
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/naming/tuple_struct-ref.rs b/third_party/rust/pin-project/tests/expand/naming/tuple_struct-ref.rs
new file mode 100644
index 0000000000..cc61edfb79
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/naming/tuple_struct-ref.rs
@@ -0,0 +1,6 @@
+use pin_project::pin_project;
+
+#[pin_project(project_ref = ProjRef)]
+struct TupleStruct<T, U>(#[pin] T, U);
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/not_unpin/enum.expanded.rs b/third_party/rust/pin-project/tests/expand/not_unpin/enum.expanded.rs
new file mode 100644
index 0000000000..98e7bbe16d
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/not_unpin/enum.expanded.rs
@@ -0,0 +1,139 @@
+use pin_project::pin_project;
+#[pin(__private(!Unpin, project = EnumProj, project_ref = EnumProjRef))]
+enum Enum<T, U> {
+ Struct { #[pin] pinned: T, unpinned: U },
+ Tuple(#[pin] T, U),
+ Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+#[allow(clippy::mut_mut)]
+enum EnumProj<'pin, T, U>
+where
+ Enum<T, U>: 'pin,
+{
+ Struct {
+ pinned: ::pin_project::__private::Pin<&'pin mut (T)>,
+ unpinned: &'pin mut (U),
+ },
+ Tuple(::pin_project::__private::Pin<&'pin mut (T)>, &'pin mut (U)),
+ Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+#[allow(clippy::ref_option_ref)]
+enum EnumProjRef<'pin, T, U>
+where
+ Enum<T, U>: 'pin,
+{
+ Struct { pinned: ::pin_project::__private::Pin<&'pin (T)>, unpinned: &'pin (U) },
+ Tuple(::pin_project::__private::Pin<&'pin (T)>, &'pin (U)),
+ Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+ #[allow(unused_extern_crates)]
+ extern crate pin_project as _pin_project;
+ impl<T, U> Enum<T, U> {
+ #[allow(dead_code)]
+ fn project<'pin>(
+ self: _pin_project::__private::Pin<&'pin mut Self>,
+ ) -> EnumProj<'pin, T, U> {
+ unsafe {
+ match self.get_unchecked_mut() {
+ Self::Struct { pinned, unpinned } => {
+ EnumProj::Struct {
+ pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+ unpinned,
+ }
+ }
+ Self::Tuple(_0, _1) => {
+ EnumProj::Tuple(
+ _pin_project::__private::Pin::new_unchecked(_0),
+ _1,
+ )
+ }
+ Self::Unit => EnumProj::Unit,
+ }
+ }
+ }
+ #[allow(dead_code)]
+ #[allow(clippy::missing_const_for_fn)]
+ fn project_ref<'pin>(
+ self: _pin_project::__private::Pin<&'pin Self>,
+ ) -> EnumProjRef<'pin, T, U> {
+ unsafe {
+ match self.get_ref() {
+ Self::Struct { pinned, unpinned } => {
+ EnumProjRef::Struct {
+ pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+ unpinned,
+ }
+ }
+ Self::Tuple(_0, _1) => {
+ EnumProjRef::Tuple(
+ _pin_project::__private::Pin::new_unchecked(_0),
+ _1,
+ )
+ }
+ Self::Unit => EnumProjRef::Unit,
+ }
+ }
+ }
+ }
+ impl<'pin, T, U> _pin_project::__private::Unpin for Enum<T, U>
+ where
+ _pin_project::__private::Wrapper<
+ 'pin,
+ _pin_project::__private::PhantomPinned,
+ >: _pin_project::__private::Unpin,
+ {}
+ #[doc(hidden)]
+ unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Enum<T, U>
+ where
+ _pin_project::__private::Wrapper<
+ 'pin,
+ _pin_project::__private::PhantomPinned,
+ >: _pin_project::__private::Unpin,
+ {}
+ trait EnumMustNotImplDrop {}
+ #[allow(clippy::drop_bounds, drop_bounds)]
+ impl<T: _pin_project::__private::Drop> EnumMustNotImplDrop for T {}
+ impl<T, U> EnumMustNotImplDrop for Enum<T, U> {}
+ #[doc(hidden)]
+ impl<T, U> _pin_project::__private::PinnedDrop for Enum<T, U> {
+ unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+ }
+};
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/not_unpin/enum.rs b/third_party/rust/pin-project/tests/expand/not_unpin/enum.rs
new file mode 100644
index 0000000000..ac0b3b80c0
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/not_unpin/enum.rs
@@ -0,0 +1,14 @@
+use pin_project::pin_project;
+
+#[pin_project(!Unpin, project = EnumProj, project_ref = EnumProjRef)]
+enum Enum<T, U> {
+ Struct {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+ },
+ Tuple(#[pin] T, U),
+ Unit,
+}
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/not_unpin/struct.expanded.rs b/third_party/rust/pin-project/tests/expand/not_unpin/struct.expanded.rs
new file mode 100644
index 0000000000..420f21aaaf
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/not_unpin/struct.expanded.rs
@@ -0,0 +1,99 @@
+use pin_project::pin_project;
+#[pin(__private(!Unpin))]
+struct Struct<T, U> {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+ #[allow(unused_extern_crates)]
+ extern crate pin_project as _pin_project;
+ #[allow(dead_code)]
+ #[allow(clippy::mut_mut)]
+ struct __StructProjection<'pin, T, U>
+ where
+ Struct<T, U>: 'pin,
+ {
+ pinned: ::pin_project::__private::Pin<&'pin mut (T)>,
+ unpinned: &'pin mut (U),
+ }
+ #[allow(dead_code)]
+ #[allow(clippy::ref_option_ref)]
+ struct __StructProjectionRef<'pin, T, U>
+ where
+ Struct<T, U>: 'pin,
+ {
+ pinned: ::pin_project::__private::Pin<&'pin (T)>,
+ unpinned: &'pin (U),
+ }
+ impl<T, U> Struct<T, U> {
+ #[allow(dead_code)]
+ fn project<'pin>(
+ self: _pin_project::__private::Pin<&'pin mut Self>,
+ ) -> __StructProjection<'pin, T, U> {
+ unsafe {
+ let Self { pinned, unpinned } = self.get_unchecked_mut();
+ __StructProjection {
+ pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+ unpinned,
+ }
+ }
+ }
+ #[allow(dead_code)]
+ #[allow(clippy::missing_const_for_fn)]
+ fn project_ref<'pin>(
+ self: _pin_project::__private::Pin<&'pin Self>,
+ ) -> __StructProjectionRef<'pin, T, U> {
+ unsafe {
+ let Self { pinned, unpinned } = self.get_ref();
+ __StructProjectionRef {
+ pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+ unpinned,
+ }
+ }
+ }
+ }
+ #[forbid(unaligned_references, safe_packed_borrows)]
+ fn __assert_not_repr_packed<T, U>(this: &Struct<T, U>) {
+ let _ = &this.pinned;
+ let _ = &this.unpinned;
+ }
+ impl<'pin, T, U> _pin_project::__private::Unpin for Struct<T, U>
+ where
+ _pin_project::__private::Wrapper<
+ 'pin,
+ _pin_project::__private::PhantomPinned,
+ >: _pin_project::__private::Unpin,
+ {}
+ #[doc(hidden)]
+ unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Struct<T, U>
+ where
+ _pin_project::__private::Wrapper<
+ 'pin,
+ _pin_project::__private::PhantomPinned,
+ >: _pin_project::__private::Unpin,
+ {}
+ trait StructMustNotImplDrop {}
+ #[allow(clippy::drop_bounds, drop_bounds)]
+ impl<T: _pin_project::__private::Drop> StructMustNotImplDrop for T {}
+ impl<T, U> StructMustNotImplDrop for Struct<T, U> {}
+ #[doc(hidden)]
+ impl<T, U> _pin_project::__private::PinnedDrop for Struct<T, U> {
+ unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+ }
+};
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/not_unpin/struct.rs b/third_party/rust/pin-project/tests/expand/not_unpin/struct.rs
new file mode 100644
index 0000000000..233e6d41f8
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/not_unpin/struct.rs
@@ -0,0 +1,10 @@
+use pin_project::pin_project;
+
+#[pin_project(!Unpin)]
+struct Struct<T, U> {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+}
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/not_unpin/tuple_struct.expanded.rs b/third_party/rust/pin-project/tests/expand/not_unpin/tuple_struct.expanded.rs
new file mode 100644
index 0000000000..99621f496d
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/not_unpin/tuple_struct.expanded.rs
@@ -0,0 +1,93 @@
+use pin_project::pin_project;
+#[pin(__private(!Unpin))]
+struct TupleStruct<T, U>(#[pin] T, U);
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+ #[allow(unused_extern_crates)]
+ extern crate pin_project as _pin_project;
+ #[allow(dead_code)]
+ #[allow(clippy::mut_mut)]
+ struct __TupleStructProjection<'pin, T, U>(
+ ::pin_project::__private::Pin<&'pin mut (T)>,
+ &'pin mut (U),
+ )
+ where
+ TupleStruct<T, U>: 'pin;
+ #[allow(dead_code)]
+ #[allow(clippy::ref_option_ref)]
+ struct __TupleStructProjectionRef<'pin, T, U>(
+ ::pin_project::__private::Pin<&'pin (T)>,
+ &'pin (U),
+ )
+ where
+ TupleStruct<T, U>: 'pin;
+ impl<T, U> TupleStruct<T, U> {
+ #[allow(dead_code)]
+ fn project<'pin>(
+ self: _pin_project::__private::Pin<&'pin mut Self>,
+ ) -> __TupleStructProjection<'pin, T, U> {
+ unsafe {
+ let Self(_0, _1) = self.get_unchecked_mut();
+ __TupleStructProjection(
+ _pin_project::__private::Pin::new_unchecked(_0),
+ _1,
+ )
+ }
+ }
+ #[allow(dead_code)]
+ #[allow(clippy::missing_const_for_fn)]
+ fn project_ref<'pin>(
+ self: _pin_project::__private::Pin<&'pin Self>,
+ ) -> __TupleStructProjectionRef<'pin, T, U> {
+ unsafe {
+ let Self(_0, _1) = self.get_ref();
+ __TupleStructProjectionRef(
+ _pin_project::__private::Pin::new_unchecked(_0),
+ _1,
+ )
+ }
+ }
+ }
+ #[forbid(unaligned_references, safe_packed_borrows)]
+ fn __assert_not_repr_packed<T, U>(this: &TupleStruct<T, U>) {
+ let _ = &this.0;
+ let _ = &this.1;
+ }
+ impl<'pin, T, U> _pin_project::__private::Unpin for TupleStruct<T, U>
+ where
+ _pin_project::__private::Wrapper<
+ 'pin,
+ _pin_project::__private::PhantomPinned,
+ >: _pin_project::__private::Unpin,
+ {}
+ #[doc(hidden)]
+ unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for TupleStruct<T, U>
+ where
+ _pin_project::__private::Wrapper<
+ 'pin,
+ _pin_project::__private::PhantomPinned,
+ >: _pin_project::__private::Unpin,
+ {}
+ trait TupleStructMustNotImplDrop {}
+ #[allow(clippy::drop_bounds, drop_bounds)]
+ impl<T: _pin_project::__private::Drop> TupleStructMustNotImplDrop for T {}
+ impl<T, U> TupleStructMustNotImplDrop for TupleStruct<T, U> {}
+ #[doc(hidden)]
+ impl<T, U> _pin_project::__private::PinnedDrop for TupleStruct<T, U> {
+ unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+ }
+};
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/not_unpin/tuple_struct.rs b/third_party/rust/pin-project/tests/expand/not_unpin/tuple_struct.rs
new file mode 100644
index 0000000000..c8065db6ad
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/not_unpin/tuple_struct.rs
@@ -0,0 +1,6 @@
+use pin_project::pin_project;
+
+#[pin_project(!Unpin)]
+struct TupleStruct<T, U>(#[pin] T, U);
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/pinned_drop/enum.expanded.rs b/third_party/rust/pin-project/tests/expand/pinned_drop/enum.expanded.rs
new file mode 100644
index 0000000000..1a8e746127
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/pinned_drop/enum.expanded.rs
@@ -0,0 +1,157 @@
+use std::pin::Pin;
+use pin_project::{pin_project, pinned_drop};
+#[pin(__private(PinnedDrop, project = EnumProj, project_ref = EnumProjRef))]
+enum Enum<T, U> {
+ Struct { #[pin] pinned: T, unpinned: U },
+ Tuple(#[pin] T, U),
+ Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+#[allow(clippy::mut_mut)]
+enum EnumProj<'pin, T, U>
+where
+ Enum<T, U>: 'pin,
+{
+ Struct {
+ pinned: ::pin_project::__private::Pin<&'pin mut (T)>,
+ unpinned: &'pin mut (U),
+ },
+ Tuple(::pin_project::__private::Pin<&'pin mut (T)>, &'pin mut (U)),
+ Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+#[allow(clippy::ref_option_ref)]
+enum EnumProjRef<'pin, T, U>
+where
+ Enum<T, U>: 'pin,
+{
+ Struct { pinned: ::pin_project::__private::Pin<&'pin (T)>, unpinned: &'pin (U) },
+ Tuple(::pin_project::__private::Pin<&'pin (T)>, &'pin (U)),
+ Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+ #[allow(unused_extern_crates)]
+ extern crate pin_project as _pin_project;
+ impl<T, U> Enum<T, U> {
+ #[allow(dead_code)]
+ fn project<'pin>(
+ self: _pin_project::__private::Pin<&'pin mut Self>,
+ ) -> EnumProj<'pin, T, U> {
+ unsafe {
+ match self.get_unchecked_mut() {
+ Self::Struct { pinned, unpinned } => {
+ EnumProj::Struct {
+ pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+ unpinned,
+ }
+ }
+ Self::Tuple(_0, _1) => {
+ EnumProj::Tuple(
+ _pin_project::__private::Pin::new_unchecked(_0),
+ _1,
+ )
+ }
+ Self::Unit => EnumProj::Unit,
+ }
+ }
+ }
+ #[allow(dead_code)]
+ #[allow(clippy::missing_const_for_fn)]
+ fn project_ref<'pin>(
+ self: _pin_project::__private::Pin<&'pin Self>,
+ ) -> EnumProjRef<'pin, T, U> {
+ unsafe {
+ match self.get_ref() {
+ Self::Struct { pinned, unpinned } => {
+ EnumProjRef::Struct {
+ pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+ unpinned,
+ }
+ }
+ Self::Tuple(_0, _1) => {
+ EnumProjRef::Tuple(
+ _pin_project::__private::Pin::new_unchecked(_0),
+ _1,
+ )
+ }
+ Self::Unit => EnumProjRef::Unit,
+ }
+ }
+ }
+ }
+ #[allow(missing_debug_implementations)]
+ struct __Enum<'pin, T, U> {
+ __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
+ 'pin,
+ (
+ _pin_project::__private::PhantomData<T>,
+ _pin_project::__private::PhantomData<U>,
+ ),
+ >,
+ __field0: T,
+ __field1: T,
+ }
+ impl<'pin, T, U> _pin_project::__private::Unpin for Enum<T, U>
+ where
+ __Enum<'pin, T, U>: _pin_project::__private::Unpin,
+ {}
+ #[doc(hidden)]
+ unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Enum<T, U>
+ where
+ __Enum<'pin, T, U>: _pin_project::__private::Unpin,
+ {}
+ impl<T, U> _pin_project::__private::Drop for Enum<T, U> {
+ fn drop(&mut self) {
+ unsafe {
+ let __pinned_self = _pin_project::__private::Pin::new_unchecked(self);
+ _pin_project::__private::PinnedDrop::drop(__pinned_self);
+ }
+ }
+ }
+};
+#[doc(hidden)]
+impl<T, U> ::pin_project::__private::PinnedDrop for Enum<T, U> {
+ unsafe fn drop(self: Pin<&mut Self>) {
+ #[allow(clippy::needless_pass_by_value)]
+ fn __drop_inner<T, U>(__self: Pin<&mut Enum<T, U>>) {
+ fn __drop_inner() {}
+ let _ = __self;
+ }
+ __drop_inner(self);
+ }
+}
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/pinned_drop/enum.rs b/third_party/rust/pin-project/tests/expand/pinned_drop/enum.rs
new file mode 100644
index 0000000000..c162ef6b2b
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/pinned_drop/enum.rs
@@ -0,0 +1,23 @@
+use std::pin::Pin;
+
+use pin_project::{pin_project, pinned_drop};
+
+#[pin_project(PinnedDrop, project = EnumProj, project_ref = EnumProjRef)]
+enum Enum<T, U> {
+ Struct {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+ },
+ Tuple(#[pin] T, U),
+ Unit,
+}
+
+#[pinned_drop]
+impl<T, U> PinnedDrop for Enum<T, U> {
+ fn drop(self: Pin<&mut Self>) {
+ let _ = self;
+ }
+}
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/pinned_drop/struct.expanded.rs b/third_party/rust/pin-project/tests/expand/pinned_drop/struct.expanded.rs
new file mode 100644
index 0000000000..d21440d347
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/pinned_drop/struct.expanded.rs
@@ -0,0 +1,116 @@
+use std::pin::Pin;
+use pin_project::{pin_project, pinned_drop};
+#[pin(__private(PinnedDrop))]
+struct Struct<T, U> {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+ #[allow(unused_extern_crates)]
+ extern crate pin_project as _pin_project;
+ #[allow(dead_code)]
+ #[allow(clippy::mut_mut)]
+ struct __StructProjection<'pin, T, U>
+ where
+ Struct<T, U>: 'pin,
+ {
+ pinned: ::pin_project::__private::Pin<&'pin mut (T)>,
+ unpinned: &'pin mut (U),
+ }
+ #[allow(dead_code)]
+ #[allow(clippy::ref_option_ref)]
+ struct __StructProjectionRef<'pin, T, U>
+ where
+ Struct<T, U>: 'pin,
+ {
+ pinned: ::pin_project::__private::Pin<&'pin (T)>,
+ unpinned: &'pin (U),
+ }
+ impl<T, U> Struct<T, U> {
+ #[allow(dead_code)]
+ fn project<'pin>(
+ self: _pin_project::__private::Pin<&'pin mut Self>,
+ ) -> __StructProjection<'pin, T, U> {
+ unsafe {
+ let Self { pinned, unpinned } = self.get_unchecked_mut();
+ __StructProjection {
+ pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+ unpinned,
+ }
+ }
+ }
+ #[allow(dead_code)]
+ #[allow(clippy::missing_const_for_fn)]
+ fn project_ref<'pin>(
+ self: _pin_project::__private::Pin<&'pin Self>,
+ ) -> __StructProjectionRef<'pin, T, U> {
+ unsafe {
+ let Self { pinned, unpinned } = self.get_ref();
+ __StructProjectionRef {
+ pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+ unpinned,
+ }
+ }
+ }
+ }
+ #[forbid(unaligned_references, safe_packed_borrows)]
+ fn __assert_not_repr_packed<T, U>(this: &Struct<T, U>) {
+ let _ = &this.pinned;
+ let _ = &this.unpinned;
+ }
+ #[allow(missing_debug_implementations)]
+ struct __Struct<'pin, T, U> {
+ __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
+ 'pin,
+ (
+ _pin_project::__private::PhantomData<T>,
+ _pin_project::__private::PhantomData<U>,
+ ),
+ >,
+ __field0: T,
+ }
+ impl<'pin, T, U> _pin_project::__private::Unpin for Struct<T, U>
+ where
+ __Struct<'pin, T, U>: _pin_project::__private::Unpin,
+ {}
+ #[doc(hidden)]
+ unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Struct<T, U>
+ where
+ __Struct<'pin, T, U>: _pin_project::__private::Unpin,
+ {}
+ impl<T, U> _pin_project::__private::Drop for Struct<T, U> {
+ fn drop(&mut self) {
+ unsafe {
+ let __pinned_self = _pin_project::__private::Pin::new_unchecked(self);
+ _pin_project::__private::PinnedDrop::drop(__pinned_self);
+ }
+ }
+ }
+};
+#[doc(hidden)]
+impl<T, U> ::pin_project::__private::PinnedDrop for Struct<T, U> {
+ unsafe fn drop(self: Pin<&mut Self>) {
+ #[allow(clippy::needless_pass_by_value)]
+ fn __drop_inner<T, U>(__self: Pin<&mut Struct<T, U>>) {
+ fn __drop_inner() {}
+ let _ = __self;
+ }
+ __drop_inner(self);
+ }
+}
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/pinned_drop/struct.rs b/third_party/rust/pin-project/tests/expand/pinned_drop/struct.rs
new file mode 100644
index 0000000000..691d3cb4a0
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/pinned_drop/struct.rs
@@ -0,0 +1,19 @@
+use std::pin::Pin;
+
+use pin_project::{pin_project, pinned_drop};
+
+#[pin_project(PinnedDrop)]
+struct Struct<T, U> {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+}
+
+#[pinned_drop]
+impl<T, U> PinnedDrop for Struct<T, U> {
+ fn drop(self: Pin<&mut Self>) {
+ let _ = self;
+ }
+}
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/pinned_drop/tuple_struct.expanded.rs b/third_party/rust/pin-project/tests/expand/pinned_drop/tuple_struct.expanded.rs
new file mode 100644
index 0000000000..9a614ae551
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/pinned_drop/tuple_struct.expanded.rs
@@ -0,0 +1,110 @@
+use std::pin::Pin;
+use pin_project::{pin_project, pinned_drop};
+#[pin(__private(PinnedDrop))]
+struct TupleStruct<T, U>(#[pin] T, U);
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+ #[allow(unused_extern_crates)]
+ extern crate pin_project as _pin_project;
+ #[allow(dead_code)]
+ #[allow(clippy::mut_mut)]
+ struct __TupleStructProjection<'pin, T, U>(
+ ::pin_project::__private::Pin<&'pin mut (T)>,
+ &'pin mut (U),
+ )
+ where
+ TupleStruct<T, U>: 'pin;
+ #[allow(dead_code)]
+ #[allow(clippy::ref_option_ref)]
+ struct __TupleStructProjectionRef<'pin, T, U>(
+ ::pin_project::__private::Pin<&'pin (T)>,
+ &'pin (U),
+ )
+ where
+ TupleStruct<T, U>: 'pin;
+ impl<T, U> TupleStruct<T, U> {
+ #[allow(dead_code)]
+ fn project<'pin>(
+ self: _pin_project::__private::Pin<&'pin mut Self>,
+ ) -> __TupleStructProjection<'pin, T, U> {
+ unsafe {
+ let Self(_0, _1) = self.get_unchecked_mut();
+ __TupleStructProjection(
+ _pin_project::__private::Pin::new_unchecked(_0),
+ _1,
+ )
+ }
+ }
+ #[allow(dead_code)]
+ #[allow(clippy::missing_const_for_fn)]
+ fn project_ref<'pin>(
+ self: _pin_project::__private::Pin<&'pin Self>,
+ ) -> __TupleStructProjectionRef<'pin, T, U> {
+ unsafe {
+ let Self(_0, _1) = self.get_ref();
+ __TupleStructProjectionRef(
+ _pin_project::__private::Pin::new_unchecked(_0),
+ _1,
+ )
+ }
+ }
+ }
+ #[forbid(unaligned_references, safe_packed_borrows)]
+ fn __assert_not_repr_packed<T, U>(this: &TupleStruct<T, U>) {
+ let _ = &this.0;
+ let _ = &this.1;
+ }
+ #[allow(missing_debug_implementations)]
+ struct __TupleStruct<'pin, T, U> {
+ __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
+ 'pin,
+ (
+ _pin_project::__private::PhantomData<T>,
+ _pin_project::__private::PhantomData<U>,
+ ),
+ >,
+ __field0: T,
+ }
+ impl<'pin, T, U> _pin_project::__private::Unpin for TupleStruct<T, U>
+ where
+ __TupleStruct<'pin, T, U>: _pin_project::__private::Unpin,
+ {}
+ #[doc(hidden)]
+ unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for TupleStruct<T, U>
+ where
+ __TupleStruct<'pin, T, U>: _pin_project::__private::Unpin,
+ {}
+ impl<T, U> _pin_project::__private::Drop for TupleStruct<T, U> {
+ fn drop(&mut self) {
+ unsafe {
+ let __pinned_self = _pin_project::__private::Pin::new_unchecked(self);
+ _pin_project::__private::PinnedDrop::drop(__pinned_self);
+ }
+ }
+ }
+};
+#[doc(hidden)]
+impl<T, U> ::pin_project::__private::PinnedDrop for TupleStruct<T, U> {
+ unsafe fn drop(self: Pin<&mut Self>) {
+ #[allow(clippy::needless_pass_by_value)]
+ fn __drop_inner<T, U>(__self: Pin<&mut TupleStruct<T, U>>) {
+ fn __drop_inner() {}
+ let _ = __self;
+ }
+ __drop_inner(self);
+ }
+}
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/pinned_drop/tuple_struct.rs b/third_party/rust/pin-project/tests/expand/pinned_drop/tuple_struct.rs
new file mode 100644
index 0000000000..1f4917c221
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/pinned_drop/tuple_struct.rs
@@ -0,0 +1,15 @@
+use std::pin::Pin;
+
+use pin_project::{pin_project, pinned_drop};
+
+#[pin_project(PinnedDrop)]
+struct TupleStruct<T, U>(#[pin] T, U);
+
+#[pinned_drop]
+impl<T, U> PinnedDrop for TupleStruct<T, U> {
+ fn drop(self: Pin<&mut Self>) {
+ let _ = self;
+ }
+}
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/project_replace/enum.expanded.rs b/third_party/rust/pin-project/tests/expand/project_replace/enum.expanded.rs
new file mode 100644
index 0000000000..178cb99758
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/project_replace/enum.expanded.rs
@@ -0,0 +1,119 @@
+use pin_project::pin_project;
+#[pin(__private(project_replace = EnumProjOwn))]
+enum Enum<T, U> {
+ Struct { #[pin] pinned: T, unpinned: U },
+ Tuple(#[pin] T, U),
+ Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+#[allow(variant_size_differences)]
+#[allow(clippy::large_enum_variant)]
+enum EnumProjOwn<T, U> {
+ Struct { pinned: ::pin_project::__private::PhantomData<T>, unpinned: U },
+ Tuple(::pin_project::__private::PhantomData<T>, U),
+ Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+ #[allow(unused_extern_crates)]
+ extern crate pin_project as _pin_project;
+ impl<T, U> Enum<T, U> {
+ #[allow(dead_code)]
+ fn project_replace(
+ self: _pin_project::__private::Pin<&mut Self>,
+ __replacement: Self,
+ ) -> EnumProjOwn<T, U> {
+ unsafe {
+ let __self_ptr: *mut Self = self.get_unchecked_mut();
+ let __guard = _pin_project::__private::UnsafeOverwriteGuard::new(
+ __self_ptr,
+ __replacement,
+ );
+ match &mut *__self_ptr {
+ Self::Struct { pinned, unpinned } => {
+ let __result = EnumProjOwn::Struct {
+ pinned: _pin_project::__private::PhantomData,
+ unpinned: _pin_project::__private::ptr::read(unpinned),
+ };
+ {
+ let __guard = _pin_project::__private::UnsafeDropInPlaceGuard::new(
+ pinned,
+ );
+ }
+ __result
+ }
+ Self::Tuple(_0, _1) => {
+ let __result = EnumProjOwn::Tuple(
+ _pin_project::__private::PhantomData,
+ _pin_project::__private::ptr::read(_1),
+ );
+ {
+ let __guard = _pin_project::__private::UnsafeDropInPlaceGuard::new(
+ _0,
+ );
+ }
+ __result
+ }
+ Self::Unit => {
+ let __result = EnumProjOwn::Unit;
+ {}
+ __result
+ }
+ }
+ }
+ }
+ }
+ #[allow(missing_debug_implementations)]
+ struct __Enum<'pin, T, U> {
+ __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
+ 'pin,
+ (
+ _pin_project::__private::PhantomData<T>,
+ _pin_project::__private::PhantomData<U>,
+ ),
+ >,
+ __field0: T,
+ __field1: T,
+ }
+ impl<'pin, T, U> _pin_project::__private::Unpin for Enum<T, U>
+ where
+ __Enum<'pin, T, U>: _pin_project::__private::Unpin,
+ {}
+ #[doc(hidden)]
+ unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Enum<T, U>
+ where
+ __Enum<'pin, T, U>: _pin_project::__private::Unpin,
+ {}
+ trait EnumMustNotImplDrop {}
+ #[allow(clippy::drop_bounds, drop_bounds)]
+ impl<T: _pin_project::__private::Drop> EnumMustNotImplDrop for T {}
+ impl<T, U> EnumMustNotImplDrop for Enum<T, U> {}
+ #[doc(hidden)]
+ impl<T, U> _pin_project::__private::PinnedDrop for Enum<T, U> {
+ unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+ }
+};
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/project_replace/enum.rs b/third_party/rust/pin-project/tests/expand/project_replace/enum.rs
new file mode 100644
index 0000000000..d737f649bf
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/project_replace/enum.rs
@@ -0,0 +1,14 @@
+use pin_project::pin_project;
+
+#[pin_project(project_replace = EnumProjOwn)]
+enum Enum<T, U> {
+ Struct {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+ },
+ Tuple(#[pin] T, U),
+ Unit,
+}
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/project_replace/struct.expanded.rs b/third_party/rust/pin-project/tests/expand/project_replace/struct.expanded.rs
new file mode 100644
index 0000000000..45839a2857
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/project_replace/struct.expanded.rs
@@ -0,0 +1,133 @@
+use pin_project::pin_project;
+#[pin(__private(project_replace))]
+struct Struct<T, U> {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+ #[allow(unused_extern_crates)]
+ extern crate pin_project as _pin_project;
+ #[allow(dead_code)]
+ #[allow(clippy::mut_mut)]
+ struct __StructProjection<'pin, T, U>
+ where
+ Struct<T, U>: 'pin,
+ {
+ pinned: ::pin_project::__private::Pin<&'pin mut (T)>,
+ unpinned: &'pin mut (U),
+ }
+ #[allow(dead_code)]
+ #[allow(clippy::ref_option_ref)]
+ struct __StructProjectionRef<'pin, T, U>
+ where
+ Struct<T, U>: 'pin,
+ {
+ pinned: ::pin_project::__private::Pin<&'pin (T)>,
+ unpinned: &'pin (U),
+ }
+ #[allow(dead_code)]
+ struct __StructProjectionOwned<T, U> {
+ pinned: ::pin_project::__private::PhantomData<T>,
+ unpinned: U,
+ }
+ impl<T, U> Struct<T, U> {
+ #[allow(dead_code)]
+ fn project<'pin>(
+ self: _pin_project::__private::Pin<&'pin mut Self>,
+ ) -> __StructProjection<'pin, T, U> {
+ unsafe {
+ let Self { pinned, unpinned } = self.get_unchecked_mut();
+ __StructProjection {
+ pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+ unpinned,
+ }
+ }
+ }
+ #[allow(dead_code)]
+ #[allow(clippy::missing_const_for_fn)]
+ fn project_ref<'pin>(
+ self: _pin_project::__private::Pin<&'pin Self>,
+ ) -> __StructProjectionRef<'pin, T, U> {
+ unsafe {
+ let Self { pinned, unpinned } = self.get_ref();
+ __StructProjectionRef {
+ pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+ unpinned,
+ }
+ }
+ }
+ #[allow(dead_code)]
+ fn project_replace(
+ self: _pin_project::__private::Pin<&mut Self>,
+ __replacement: Self,
+ ) -> __StructProjectionOwned<T, U> {
+ unsafe {
+ let __self_ptr: *mut Self = self.get_unchecked_mut();
+ let __guard = _pin_project::__private::UnsafeOverwriteGuard::new(
+ __self_ptr,
+ __replacement,
+ );
+ let Self { pinned, unpinned } = &mut *__self_ptr;
+ let __result = __StructProjectionOwned {
+ pinned: _pin_project::__private::PhantomData,
+ unpinned: _pin_project::__private::ptr::read(unpinned),
+ };
+ {
+ let __guard = _pin_project::__private::UnsafeDropInPlaceGuard::new(
+ pinned,
+ );
+ }
+ __result
+ }
+ }
+ }
+ #[forbid(unaligned_references, safe_packed_borrows)]
+ fn __assert_not_repr_packed<T, U>(this: &Struct<T, U>) {
+ let _ = &this.pinned;
+ let _ = &this.unpinned;
+ }
+ #[allow(missing_debug_implementations)]
+ struct __Struct<'pin, T, U> {
+ __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
+ 'pin,
+ (
+ _pin_project::__private::PhantomData<T>,
+ _pin_project::__private::PhantomData<U>,
+ ),
+ >,
+ __field0: T,
+ }
+ impl<'pin, T, U> _pin_project::__private::Unpin for Struct<T, U>
+ where
+ __Struct<'pin, T, U>: _pin_project::__private::Unpin,
+ {}
+ #[doc(hidden)]
+ unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Struct<T, U>
+ where
+ __Struct<'pin, T, U>: _pin_project::__private::Unpin,
+ {}
+ trait StructMustNotImplDrop {}
+ #[allow(clippy::drop_bounds, drop_bounds)]
+ impl<T: _pin_project::__private::Drop> StructMustNotImplDrop for T {}
+ impl<T, U> StructMustNotImplDrop for Struct<T, U> {}
+ #[doc(hidden)]
+ impl<T, U> _pin_project::__private::PinnedDrop for Struct<T, U> {
+ unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+ }
+};
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/project_replace/struct.rs b/third_party/rust/pin-project/tests/expand/project_replace/struct.rs
new file mode 100644
index 0000000000..5865526a58
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/project_replace/struct.rs
@@ -0,0 +1,10 @@
+use pin_project::pin_project;
+
+#[pin_project(project_replace)]
+struct Struct<T, U> {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+}
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/project_replace/tuple_struct.expanded.rs b/third_party/rust/pin-project/tests/expand/project_replace/tuple_struct.expanded.rs
new file mode 100644
index 0000000000..cdee3d149e
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/project_replace/tuple_struct.expanded.rs
@@ -0,0 +1,127 @@
+use pin_project::pin_project;
+#[pin(__private(project_replace))]
+struct TupleStruct<T, U>(#[pin] T, U);
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+ #[allow(unused_extern_crates)]
+ extern crate pin_project as _pin_project;
+ #[allow(dead_code)]
+ #[allow(clippy::mut_mut)]
+ struct __TupleStructProjection<'pin, T, U>(
+ ::pin_project::__private::Pin<&'pin mut (T)>,
+ &'pin mut (U),
+ )
+ where
+ TupleStruct<T, U>: 'pin;
+ #[allow(dead_code)]
+ #[allow(clippy::ref_option_ref)]
+ struct __TupleStructProjectionRef<'pin, T, U>(
+ ::pin_project::__private::Pin<&'pin (T)>,
+ &'pin (U),
+ )
+ where
+ TupleStruct<T, U>: 'pin;
+ #[allow(dead_code)]
+ struct __TupleStructProjectionOwned<T, U>(
+ ::pin_project::__private::PhantomData<T>,
+ U,
+ );
+ impl<T, U> TupleStruct<T, U> {
+ #[allow(dead_code)]
+ fn project<'pin>(
+ self: _pin_project::__private::Pin<&'pin mut Self>,
+ ) -> __TupleStructProjection<'pin, T, U> {
+ unsafe {
+ let Self(_0, _1) = self.get_unchecked_mut();
+ __TupleStructProjection(
+ _pin_project::__private::Pin::new_unchecked(_0),
+ _1,
+ )
+ }
+ }
+ #[allow(dead_code)]
+ #[allow(clippy::missing_const_for_fn)]
+ fn project_ref<'pin>(
+ self: _pin_project::__private::Pin<&'pin Self>,
+ ) -> __TupleStructProjectionRef<'pin, T, U> {
+ unsafe {
+ let Self(_0, _1) = self.get_ref();
+ __TupleStructProjectionRef(
+ _pin_project::__private::Pin::new_unchecked(_0),
+ _1,
+ )
+ }
+ }
+ #[allow(dead_code)]
+ fn project_replace(
+ self: _pin_project::__private::Pin<&mut Self>,
+ __replacement: Self,
+ ) -> __TupleStructProjectionOwned<T, U> {
+ unsafe {
+ let __self_ptr: *mut Self = self.get_unchecked_mut();
+ let __guard = _pin_project::__private::UnsafeOverwriteGuard::new(
+ __self_ptr,
+ __replacement,
+ );
+ let Self(_0, _1) = &mut *__self_ptr;
+ let __result = __TupleStructProjectionOwned(
+ _pin_project::__private::PhantomData,
+ _pin_project::__private::ptr::read(_1),
+ );
+ {
+ let __guard = _pin_project::__private::UnsafeDropInPlaceGuard::new(
+ _0,
+ );
+ }
+ __result
+ }
+ }
+ }
+ #[forbid(unaligned_references, safe_packed_borrows)]
+ fn __assert_not_repr_packed<T, U>(this: &TupleStruct<T, U>) {
+ let _ = &this.0;
+ let _ = &this.1;
+ }
+ #[allow(missing_debug_implementations)]
+ struct __TupleStruct<'pin, T, U> {
+ __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
+ 'pin,
+ (
+ _pin_project::__private::PhantomData<T>,
+ _pin_project::__private::PhantomData<U>,
+ ),
+ >,
+ __field0: T,
+ }
+ impl<'pin, T, U> _pin_project::__private::Unpin for TupleStruct<T, U>
+ where
+ __TupleStruct<'pin, T, U>: _pin_project::__private::Unpin,
+ {}
+ #[doc(hidden)]
+ unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for TupleStruct<T, U>
+ where
+ __TupleStruct<'pin, T, U>: _pin_project::__private::Unpin,
+ {}
+ trait TupleStructMustNotImplDrop {}
+ #[allow(clippy::drop_bounds, drop_bounds)]
+ impl<T: _pin_project::__private::Drop> TupleStructMustNotImplDrop for T {}
+ impl<T, U> TupleStructMustNotImplDrop for TupleStruct<T, U> {}
+ #[doc(hidden)]
+ impl<T, U> _pin_project::__private::PinnedDrop for TupleStruct<T, U> {
+ unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+ }
+};
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/project_replace/tuple_struct.rs b/third_party/rust/pin-project/tests/expand/project_replace/tuple_struct.rs
new file mode 100644
index 0000000000..c4d05f5faa
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/project_replace/tuple_struct.rs
@@ -0,0 +1,6 @@
+use pin_project::pin_project;
+
+#[pin_project(project_replace)]
+struct TupleStruct<T, U>(#[pin] T, U);
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/pub/enum.expanded.rs b/third_party/rust/pin-project/tests/expand/pub/enum.expanded.rs
new file mode 100644
index 0000000000..90be268005
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/pub/enum.expanded.rs
@@ -0,0 +1,145 @@
+use pin_project::pin_project;
+#[pin(__private(project = EnumProj, project_ref = EnumProjRef))]
+pub enum Enum<T, U> {
+ Struct { #[pin] pinned: T, unpinned: U },
+ Tuple(#[pin] T, U),
+ Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+#[allow(clippy::mut_mut)]
+pub(crate) enum EnumProj<'pin, T, U>
+where
+ Enum<T, U>: 'pin,
+{
+ Struct {
+ pinned: ::pin_project::__private::Pin<&'pin mut (T)>,
+ unpinned: &'pin mut (U),
+ },
+ Tuple(::pin_project::__private::Pin<&'pin mut (T)>, &'pin mut (U)),
+ Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+#[allow(clippy::ref_option_ref)]
+pub(crate) enum EnumProjRef<'pin, T, U>
+where
+ Enum<T, U>: 'pin,
+{
+ Struct { pinned: ::pin_project::__private::Pin<&'pin (T)>, unpinned: &'pin (U) },
+ Tuple(::pin_project::__private::Pin<&'pin (T)>, &'pin (U)),
+ Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+ #[allow(unused_extern_crates)]
+ extern crate pin_project as _pin_project;
+ impl<T, U> Enum<T, U> {
+ #[allow(dead_code)]
+ pub(crate) fn project<'pin>(
+ self: _pin_project::__private::Pin<&'pin mut Self>,
+ ) -> EnumProj<'pin, T, U> {
+ unsafe {
+ match self.get_unchecked_mut() {
+ Self::Struct { pinned, unpinned } => {
+ EnumProj::Struct {
+ pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+ unpinned,
+ }
+ }
+ Self::Tuple(_0, _1) => {
+ EnumProj::Tuple(
+ _pin_project::__private::Pin::new_unchecked(_0),
+ _1,
+ )
+ }
+ Self::Unit => EnumProj::Unit,
+ }
+ }
+ }
+ #[allow(dead_code)]
+ #[allow(clippy::missing_const_for_fn)]
+ pub(crate) fn project_ref<'pin>(
+ self: _pin_project::__private::Pin<&'pin Self>,
+ ) -> EnumProjRef<'pin, T, U> {
+ unsafe {
+ match self.get_ref() {
+ Self::Struct { pinned, unpinned } => {
+ EnumProjRef::Struct {
+ pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+ unpinned,
+ }
+ }
+ Self::Tuple(_0, _1) => {
+ EnumProjRef::Tuple(
+ _pin_project::__private::Pin::new_unchecked(_0),
+ _1,
+ )
+ }
+ Self::Unit => EnumProjRef::Unit,
+ }
+ }
+ }
+ }
+ #[allow(missing_debug_implementations)]
+ pub struct __Enum<'pin, T, U> {
+ __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
+ 'pin,
+ (
+ _pin_project::__private::PhantomData<T>,
+ _pin_project::__private::PhantomData<U>,
+ ),
+ >,
+ __field0: T,
+ __field1: T,
+ }
+ impl<'pin, T, U> _pin_project::__private::Unpin for Enum<T, U>
+ where
+ __Enum<'pin, T, U>: _pin_project::__private::Unpin,
+ {}
+ #[doc(hidden)]
+ unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Enum<T, U>
+ where
+ __Enum<'pin, T, U>: _pin_project::__private::Unpin,
+ {}
+ trait EnumMustNotImplDrop {}
+ #[allow(clippy::drop_bounds, drop_bounds)]
+ impl<T: _pin_project::__private::Drop> EnumMustNotImplDrop for T {}
+ impl<T, U> EnumMustNotImplDrop for Enum<T, U> {}
+ #[doc(hidden)]
+ impl<T, U> _pin_project::__private::PinnedDrop for Enum<T, U> {
+ unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+ }
+};
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/pub/enum.rs b/third_party/rust/pin-project/tests/expand/pub/enum.rs
new file mode 100644
index 0000000000..7c8577fd1b
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/pub/enum.rs
@@ -0,0 +1,14 @@
+use pin_project::pin_project;
+
+#[pin_project(project = EnumProj, project_ref = EnumProjRef)]
+pub enum Enum<T, U> {
+ Struct {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+ },
+ Tuple(#[pin] T, U),
+ Unit,
+}
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/pub/struct.expanded.rs b/third_party/rust/pin-project/tests/expand/pub/struct.expanded.rs
new file mode 100644
index 0000000000..ca31f3d768
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/pub/struct.expanded.rs
@@ -0,0 +1,104 @@
+use pin_project::pin_project;
+#[pin(__private())]
+pub struct Struct<T, U> {
+ #[pin]
+ pub pinned: T,
+ pub unpinned: U,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+ #[allow(unused_extern_crates)]
+ extern crate pin_project as _pin_project;
+ #[allow(dead_code)]
+ #[allow(clippy::mut_mut)]
+ pub(crate) struct __StructProjection<'pin, T, U>
+ where
+ Struct<T, U>: 'pin,
+ {
+ pub pinned: ::pin_project::__private::Pin<&'pin mut (T)>,
+ pub unpinned: &'pin mut (U),
+ }
+ #[allow(dead_code)]
+ #[allow(clippy::ref_option_ref)]
+ pub(crate) struct __StructProjectionRef<'pin, T, U>
+ where
+ Struct<T, U>: 'pin,
+ {
+ pub pinned: ::pin_project::__private::Pin<&'pin (T)>,
+ pub unpinned: &'pin (U),
+ }
+ impl<T, U> Struct<T, U> {
+ #[allow(dead_code)]
+ pub(crate) fn project<'pin>(
+ self: _pin_project::__private::Pin<&'pin mut Self>,
+ ) -> __StructProjection<'pin, T, U> {
+ unsafe {
+ let Self { pinned, unpinned } = self.get_unchecked_mut();
+ __StructProjection {
+ pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+ unpinned,
+ }
+ }
+ }
+ #[allow(dead_code)]
+ #[allow(clippy::missing_const_for_fn)]
+ pub(crate) fn project_ref<'pin>(
+ self: _pin_project::__private::Pin<&'pin Self>,
+ ) -> __StructProjectionRef<'pin, T, U> {
+ unsafe {
+ let Self { pinned, unpinned } = self.get_ref();
+ __StructProjectionRef {
+ pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+ unpinned,
+ }
+ }
+ }
+ }
+ #[forbid(unaligned_references, safe_packed_borrows)]
+ fn __assert_not_repr_packed<T, U>(this: &Struct<T, U>) {
+ let _ = &this.pinned;
+ let _ = &this.unpinned;
+ }
+ #[allow(missing_debug_implementations)]
+ pub struct __Struct<'pin, T, U> {
+ __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
+ 'pin,
+ (
+ _pin_project::__private::PhantomData<T>,
+ _pin_project::__private::PhantomData<U>,
+ ),
+ >,
+ __field0: T,
+ }
+ impl<'pin, T, U> _pin_project::__private::Unpin for Struct<T, U>
+ where
+ __Struct<'pin, T, U>: _pin_project::__private::Unpin,
+ {}
+ #[doc(hidden)]
+ unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Struct<T, U>
+ where
+ __Struct<'pin, T, U>: _pin_project::__private::Unpin,
+ {}
+ trait StructMustNotImplDrop {}
+ #[allow(clippy::drop_bounds, drop_bounds)]
+ impl<T: _pin_project::__private::Drop> StructMustNotImplDrop for T {}
+ impl<T, U> StructMustNotImplDrop for Struct<T, U> {}
+ #[doc(hidden)]
+ impl<T, U> _pin_project::__private::PinnedDrop for Struct<T, U> {
+ unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+ }
+};
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/pub/struct.rs b/third_party/rust/pin-project/tests/expand/pub/struct.rs
new file mode 100644
index 0000000000..f50d1e9272
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/pub/struct.rs
@@ -0,0 +1,10 @@
+use pin_project::pin_project;
+
+#[pin_project]
+pub struct Struct<T, U> {
+ #[pin]
+ pub pinned: T,
+ pub unpinned: U,
+}
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/pub/tuple_struct.expanded.rs b/third_party/rust/pin-project/tests/expand/pub/tuple_struct.expanded.rs
new file mode 100644
index 0000000000..5c7efbf23d
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/pub/tuple_struct.expanded.rs
@@ -0,0 +1,98 @@
+use pin_project::pin_project;
+#[pin(__private())]
+pub struct TupleStruct<T, U>(#[pin] pub T, pub U);
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+ #[allow(unused_extern_crates)]
+ extern crate pin_project as _pin_project;
+ #[allow(dead_code)]
+ #[allow(clippy::mut_mut)]
+ pub(crate) struct __TupleStructProjection<'pin, T, U>(
+ pub ::pin_project::__private::Pin<&'pin mut (T)>,
+ pub &'pin mut (U),
+ )
+ where
+ TupleStruct<T, U>: 'pin;
+ #[allow(dead_code)]
+ #[allow(clippy::ref_option_ref)]
+ pub(crate) struct __TupleStructProjectionRef<'pin, T, U>(
+ pub ::pin_project::__private::Pin<&'pin (T)>,
+ pub &'pin (U),
+ )
+ where
+ TupleStruct<T, U>: 'pin;
+ impl<T, U> TupleStruct<T, U> {
+ #[allow(dead_code)]
+ pub(crate) fn project<'pin>(
+ self: _pin_project::__private::Pin<&'pin mut Self>,
+ ) -> __TupleStructProjection<'pin, T, U> {
+ unsafe {
+ let Self(_0, _1) = self.get_unchecked_mut();
+ __TupleStructProjection(
+ _pin_project::__private::Pin::new_unchecked(_0),
+ _1,
+ )
+ }
+ }
+ #[allow(dead_code)]
+ #[allow(clippy::missing_const_for_fn)]
+ pub(crate) fn project_ref<'pin>(
+ self: _pin_project::__private::Pin<&'pin Self>,
+ ) -> __TupleStructProjectionRef<'pin, T, U> {
+ unsafe {
+ let Self(_0, _1) = self.get_ref();
+ __TupleStructProjectionRef(
+ _pin_project::__private::Pin::new_unchecked(_0),
+ _1,
+ )
+ }
+ }
+ }
+ #[forbid(unaligned_references, safe_packed_borrows)]
+ fn __assert_not_repr_packed<T, U>(this: &TupleStruct<T, U>) {
+ let _ = &this.0;
+ let _ = &this.1;
+ }
+ #[allow(missing_debug_implementations)]
+ pub struct __TupleStruct<'pin, T, U> {
+ __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
+ 'pin,
+ (
+ _pin_project::__private::PhantomData<T>,
+ _pin_project::__private::PhantomData<U>,
+ ),
+ >,
+ __field0: T,
+ }
+ impl<'pin, T, U> _pin_project::__private::Unpin for TupleStruct<T, U>
+ where
+ __TupleStruct<'pin, T, U>: _pin_project::__private::Unpin,
+ {}
+ #[doc(hidden)]
+ unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for TupleStruct<T, U>
+ where
+ __TupleStruct<'pin, T, U>: _pin_project::__private::Unpin,
+ {}
+ trait TupleStructMustNotImplDrop {}
+ #[allow(clippy::drop_bounds, drop_bounds)]
+ impl<T: _pin_project::__private::Drop> TupleStructMustNotImplDrop for T {}
+ impl<T, U> TupleStructMustNotImplDrop for TupleStruct<T, U> {}
+ #[doc(hidden)]
+ impl<T, U> _pin_project::__private::PinnedDrop for TupleStruct<T, U> {
+ unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+ }
+};
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/pub/tuple_struct.rs b/third_party/rust/pin-project/tests/expand/pub/tuple_struct.rs
new file mode 100644
index 0000000000..5756aafcc8
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/pub/tuple_struct.rs
@@ -0,0 +1,6 @@
+use pin_project::pin_project;
+
+#[pin_project]
+pub struct TupleStruct<T, U>(#[pin] pub T, pub U);
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/unsafe_unpin/enum.expanded.rs b/third_party/rust/pin-project/tests/expand/unsafe_unpin/enum.expanded.rs
new file mode 100644
index 0000000000..1f88cccae6
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/unsafe_unpin/enum.expanded.rs
@@ -0,0 +1,129 @@
+use pin_project::{pin_project, UnsafeUnpin};
+#[pin(__private(UnsafeUnpin, project = EnumProj, project_ref = EnumProjRef))]
+enum Enum<T, U> {
+ Struct { #[pin] pinned: T, unpinned: U },
+ Tuple(#[pin] T, U),
+ Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+#[allow(clippy::mut_mut)]
+enum EnumProj<'pin, T, U>
+where
+ Enum<T, U>: 'pin,
+{
+ Struct {
+ pinned: ::pin_project::__private::Pin<&'pin mut (T)>,
+ unpinned: &'pin mut (U),
+ },
+ Tuple(::pin_project::__private::Pin<&'pin mut (T)>, &'pin mut (U)),
+ Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+#[allow(clippy::ref_option_ref)]
+enum EnumProjRef<'pin, T, U>
+where
+ Enum<T, U>: 'pin,
+{
+ Struct { pinned: ::pin_project::__private::Pin<&'pin (T)>, unpinned: &'pin (U) },
+ Tuple(::pin_project::__private::Pin<&'pin (T)>, &'pin (U)),
+ Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+ #[allow(unused_extern_crates)]
+ extern crate pin_project as _pin_project;
+ impl<T, U> Enum<T, U> {
+ #[allow(dead_code)]
+ fn project<'pin>(
+ self: _pin_project::__private::Pin<&'pin mut Self>,
+ ) -> EnumProj<'pin, T, U> {
+ unsafe {
+ match self.get_unchecked_mut() {
+ Self::Struct { pinned, unpinned } => {
+ EnumProj::Struct {
+ pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+ unpinned,
+ }
+ }
+ Self::Tuple(_0, _1) => {
+ EnumProj::Tuple(
+ _pin_project::__private::Pin::new_unchecked(_0),
+ _1,
+ )
+ }
+ Self::Unit => EnumProj::Unit,
+ }
+ }
+ }
+ #[allow(dead_code)]
+ #[allow(clippy::missing_const_for_fn)]
+ fn project_ref<'pin>(
+ self: _pin_project::__private::Pin<&'pin Self>,
+ ) -> EnumProjRef<'pin, T, U> {
+ unsafe {
+ match self.get_ref() {
+ Self::Struct { pinned, unpinned } => {
+ EnumProjRef::Struct {
+ pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+ unpinned,
+ }
+ }
+ Self::Tuple(_0, _1) => {
+ EnumProjRef::Tuple(
+ _pin_project::__private::Pin::new_unchecked(_0),
+ _1,
+ )
+ }
+ Self::Unit => EnumProjRef::Unit,
+ }
+ }
+ }
+ }
+ impl<'pin, T, U> _pin_project::__private::Unpin for Enum<T, U>
+ where
+ _pin_project::__private::Wrapper<'pin, Self>: _pin_project::UnsafeUnpin,
+ {}
+ trait EnumMustNotImplDrop {}
+ #[allow(clippy::drop_bounds, drop_bounds)]
+ impl<T: _pin_project::__private::Drop> EnumMustNotImplDrop for T {}
+ impl<T, U> EnumMustNotImplDrop for Enum<T, U> {}
+ #[doc(hidden)]
+ impl<T, U> _pin_project::__private::PinnedDrop for Enum<T, U> {
+ unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+ }
+};
+unsafe impl<T: Unpin, U> UnsafeUnpin for Enum<T, U> {}
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/unsafe_unpin/enum.rs b/third_party/rust/pin-project/tests/expand/unsafe_unpin/enum.rs
new file mode 100644
index 0000000000..d368d7132b
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/unsafe_unpin/enum.rs
@@ -0,0 +1,16 @@
+use pin_project::{pin_project, UnsafeUnpin};
+
+#[pin_project(UnsafeUnpin, project = EnumProj, project_ref = EnumProjRef)]
+enum Enum<T, U> {
+ Struct {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+ },
+ Tuple(#[pin] T, U),
+ Unit,
+}
+
+unsafe impl<T: Unpin, U> UnsafeUnpin for Enum<T, U> {}
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/unsafe_unpin/struct.expanded.rs b/third_party/rust/pin-project/tests/expand/unsafe_unpin/struct.expanded.rs
new file mode 100644
index 0000000000..5fa7271572
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/unsafe_unpin/struct.expanded.rs
@@ -0,0 +1,89 @@
+use pin_project::{pin_project, UnsafeUnpin};
+#[pin(__private(UnsafeUnpin))]
+struct Struct<T, U> {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+ #[allow(unused_extern_crates)]
+ extern crate pin_project as _pin_project;
+ #[allow(dead_code)]
+ #[allow(clippy::mut_mut)]
+ struct __StructProjection<'pin, T, U>
+ where
+ Struct<T, U>: 'pin,
+ {
+ pinned: ::pin_project::__private::Pin<&'pin mut (T)>,
+ unpinned: &'pin mut (U),
+ }
+ #[allow(dead_code)]
+ #[allow(clippy::ref_option_ref)]
+ struct __StructProjectionRef<'pin, T, U>
+ where
+ Struct<T, U>: 'pin,
+ {
+ pinned: ::pin_project::__private::Pin<&'pin (T)>,
+ unpinned: &'pin (U),
+ }
+ impl<T, U> Struct<T, U> {
+ #[allow(dead_code)]
+ fn project<'pin>(
+ self: _pin_project::__private::Pin<&'pin mut Self>,
+ ) -> __StructProjection<'pin, T, U> {
+ unsafe {
+ let Self { pinned, unpinned } = self.get_unchecked_mut();
+ __StructProjection {
+ pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+ unpinned,
+ }
+ }
+ }
+ #[allow(dead_code)]
+ #[allow(clippy::missing_const_for_fn)]
+ fn project_ref<'pin>(
+ self: _pin_project::__private::Pin<&'pin Self>,
+ ) -> __StructProjectionRef<'pin, T, U> {
+ unsafe {
+ let Self { pinned, unpinned } = self.get_ref();
+ __StructProjectionRef {
+ pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+ unpinned,
+ }
+ }
+ }
+ }
+ #[forbid(unaligned_references, safe_packed_borrows)]
+ fn __assert_not_repr_packed<T, U>(this: &Struct<T, U>) {
+ let _ = &this.pinned;
+ let _ = &this.unpinned;
+ }
+ impl<'pin, T, U> _pin_project::__private::Unpin for Struct<T, U>
+ where
+ _pin_project::__private::Wrapper<'pin, Self>: _pin_project::UnsafeUnpin,
+ {}
+ trait StructMustNotImplDrop {}
+ #[allow(clippy::drop_bounds, drop_bounds)]
+ impl<T: _pin_project::__private::Drop> StructMustNotImplDrop for T {}
+ impl<T, U> StructMustNotImplDrop for Struct<T, U> {}
+ #[doc(hidden)]
+ impl<T, U> _pin_project::__private::PinnedDrop for Struct<T, U> {
+ unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+ }
+};
+unsafe impl<T: Unpin, U> UnsafeUnpin for Struct<T, U> {}
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/unsafe_unpin/struct.rs b/third_party/rust/pin-project/tests/expand/unsafe_unpin/struct.rs
new file mode 100644
index 0000000000..b0851b1ad6
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/unsafe_unpin/struct.rs
@@ -0,0 +1,12 @@
+use pin_project::{pin_project, UnsafeUnpin};
+
+#[pin_project(UnsafeUnpin)]
+struct Struct<T, U> {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+}
+
+unsafe impl<T: Unpin, U> UnsafeUnpin for Struct<T, U> {}
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/unsafe_unpin/tuple_struct.expanded.rs b/third_party/rust/pin-project/tests/expand/unsafe_unpin/tuple_struct.expanded.rs
new file mode 100644
index 0000000000..de4e9269cb
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/unsafe_unpin/tuple_struct.expanded.rs
@@ -0,0 +1,83 @@
+use pin_project::{pin_project, UnsafeUnpin};
+#[pin(__private(UnsafeUnpin))]
+struct TupleStruct<T, U>(#[pin] T, U);
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+ #[allow(unused_extern_crates)]
+ extern crate pin_project as _pin_project;
+ #[allow(dead_code)]
+ #[allow(clippy::mut_mut)]
+ struct __TupleStructProjection<'pin, T, U>(
+ ::pin_project::__private::Pin<&'pin mut (T)>,
+ &'pin mut (U),
+ )
+ where
+ TupleStruct<T, U>: 'pin;
+ #[allow(dead_code)]
+ #[allow(clippy::ref_option_ref)]
+ struct __TupleStructProjectionRef<'pin, T, U>(
+ ::pin_project::__private::Pin<&'pin (T)>,
+ &'pin (U),
+ )
+ where
+ TupleStruct<T, U>: 'pin;
+ impl<T, U> TupleStruct<T, U> {
+ #[allow(dead_code)]
+ fn project<'pin>(
+ self: _pin_project::__private::Pin<&'pin mut Self>,
+ ) -> __TupleStructProjection<'pin, T, U> {
+ unsafe {
+ let Self(_0, _1) = self.get_unchecked_mut();
+ __TupleStructProjection(
+ _pin_project::__private::Pin::new_unchecked(_0),
+ _1,
+ )
+ }
+ }
+ #[allow(dead_code)]
+ #[allow(clippy::missing_const_for_fn)]
+ fn project_ref<'pin>(
+ self: _pin_project::__private::Pin<&'pin Self>,
+ ) -> __TupleStructProjectionRef<'pin, T, U> {
+ unsafe {
+ let Self(_0, _1) = self.get_ref();
+ __TupleStructProjectionRef(
+ _pin_project::__private::Pin::new_unchecked(_0),
+ _1,
+ )
+ }
+ }
+ }
+ #[forbid(unaligned_references, safe_packed_borrows)]
+ fn __assert_not_repr_packed<T, U>(this: &TupleStruct<T, U>) {
+ let _ = &this.0;
+ let _ = &this.1;
+ }
+ impl<'pin, T, U> _pin_project::__private::Unpin for TupleStruct<T, U>
+ where
+ _pin_project::__private::Wrapper<'pin, Self>: _pin_project::UnsafeUnpin,
+ {}
+ trait TupleStructMustNotImplDrop {}
+ #[allow(clippy::drop_bounds, drop_bounds)]
+ impl<T: _pin_project::__private::Drop> TupleStructMustNotImplDrop for T {}
+ impl<T, U> TupleStructMustNotImplDrop for TupleStruct<T, U> {}
+ #[doc(hidden)]
+ impl<T, U> _pin_project::__private::PinnedDrop for TupleStruct<T, U> {
+ unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+ }
+};
+unsafe impl<T: Unpin, U> UnsafeUnpin for Struct<T, U> {}
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expand/unsafe_unpin/tuple_struct.rs b/third_party/rust/pin-project/tests/expand/unsafe_unpin/tuple_struct.rs
new file mode 100644
index 0000000000..964617a1c9
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expand/unsafe_unpin/tuple_struct.rs
@@ -0,0 +1,8 @@
+use pin_project::{pin_project, UnsafeUnpin};
+
+#[pin_project(UnsafeUnpin)]
+struct TupleStruct<T, U>(#[pin] T, U);
+
+unsafe impl<T: Unpin, U> UnsafeUnpin for Struct<T, U> {}
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/expandtest.rs b/third_party/rust/pin-project/tests/expandtest.rs
new file mode 100644
index 0000000000..04a06669df
--- /dev/null
+++ b/third_party/rust/pin-project/tests/expandtest.rs
@@ -0,0 +1,44 @@
+#![cfg(not(miri))]
+#![cfg(not(careful))]
+#![warn(rust_2018_idioms, single_use_lifetimes)]
+
+use std::{
+ env,
+ process::{Command, ExitStatus, Stdio},
+};
+
+const PATH: &str = "tests/expand/**/*.rs";
+
+#[rustversion::attr(not(nightly), ignore)]
+#[test]
+fn expandtest() {
+ let is_ci = env::var_os("CI").is_some();
+ let cargo = &*env::var("CARGO").unwrap_or_else(|_| "cargo".into());
+ if !has_command(&[cargo, "expand"]) {
+ if is_ci {
+ panic!("expandtest requires cargo-expand");
+ }
+ return;
+ }
+
+ let args = &["--all-features"];
+ if is_ci {
+ macrotest::expand_without_refresh_args(PATH, args);
+ } else {
+ env::set_var("MACROTEST", "overwrite");
+ macrotest::expand_args(PATH, args);
+ }
+}
+
+fn has_command(command: &[&str]) -> bool {
+ Command::new(command[0])
+ .args(&command[1..])
+ .arg("--version")
+ .stdin(Stdio::null())
+ .stdout(Stdio::null())
+ .stderr(Stdio::null())
+ .status()
+ .as_ref()
+ .map(ExitStatus::success)
+ .unwrap_or(false)
+}
diff --git a/third_party/rust/pin-project/tests/include/basic-safe-part.rs b/third_party/rust/pin-project/tests/include/basic-safe-part.rs
new file mode 100644
index 0000000000..0b7c43e873
--- /dev/null
+++ b/third_party/rust/pin-project/tests/include/basic-safe-part.rs
@@ -0,0 +1,193 @@
+// default #[pin_project], PinnedDrop, project_replace, !Unpin, and UnsafeUnpin without UnsafeUnpin impl are completely safe.
+
+#[::pin_project::pin_project]
+#[derive(Debug)]
+pub struct DefaultStruct<T, U> {
+ #[pin]
+ pub pinned: T,
+ pub unpinned: U,
+}
+
+#[::pin_project::pin_project(
+ project = DefaultStructNamedProj,
+ project_ref = DefaultStructNamedProjRef,
+)]
+#[derive(Debug)]
+pub struct DefaultStructNamed<T, U> {
+ #[pin]
+ pub pinned: T,
+ pub unpinned: U,
+}
+
+#[::pin_project::pin_project]
+#[derive(Debug)]
+pub struct DefaultTupleStruct<T, U>(#[pin] pub T, pub U);
+
+#[::pin_project::pin_project(
+ project = DefaultTupleStructNamedProj,
+ project_ref = DefaultTupleStructNamedProjRef,
+)]
+#[derive(Debug)]
+pub struct DefaultTupleStructNamed<T, U>(#[pin] pub T, pub U);
+
+#[::pin_project::pin_project(
+ project = DefaultEnumProj,
+ project_ref = DefaultEnumProjRef,
+)]
+#[derive(Debug)]
+pub enum DefaultEnum<T, U> {
+ Struct {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+ },
+ Tuple(#[pin] T, U),
+ Unit,
+}
+
+#[::pin_project::pin_project(PinnedDrop)]
+#[derive(Debug)]
+pub struct PinnedDropStruct<T, U> {
+ #[pin]
+ pub pinned: T,
+ pub unpinned: U,
+}
+
+#[::pin_project::pinned_drop]
+impl<T, U> PinnedDrop for PinnedDropStruct<T, U> {
+ fn drop(self: ::pin_project::__private::Pin<&mut Self>) {}
+}
+
+#[::pin_project::pin_project(PinnedDrop)]
+#[derive(Debug)]
+pub struct PinnedDropTupleStruct<T, U>(#[pin] pub T, pub U);
+
+#[::pin_project::pinned_drop]
+impl<T, U> PinnedDrop for PinnedDropTupleStruct<T, U> {
+ fn drop(self: ::pin_project::__private::Pin<&mut Self>) {}
+}
+
+#[::pin_project::pin_project(
+ PinnedDrop,
+ project = PinnedDropEnumProj,
+ project_ref = PinnedDropEnumProjRef,
+)]
+#[derive(Debug)]
+pub enum PinnedDropEnum<T, U> {
+ Struct {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+ },
+ Tuple(#[pin] T, U),
+ Unit,
+}
+
+#[::pin_project::pinned_drop]
+impl<T, U> PinnedDrop for PinnedDropEnum<T, U> {
+ fn drop(self: ::pin_project::__private::Pin<&mut Self>) {}
+}
+
+#[::pin_project::pin_project(project_replace)]
+#[derive(Debug)]
+pub struct ReplaceStruct<T, U> {
+ #[pin]
+ pub pinned: T,
+ pub unpinned: U,
+}
+
+#[::pin_project::pin_project(
+ project = ReplaceStructNamedProj,
+ project_ref = ReplaceStructNamedProjRef,
+ project_replace = ReplaceStructNamedProjOwn,
+)]
+#[derive(Debug)]
+pub struct ReplaceStructNamed<T, U> {
+ #[pin]
+ pub pinned: T,
+ pub unpinned: U,
+}
+
+#[::pin_project::pin_project(project_replace)]
+#[derive(Debug)]
+pub struct ReplaceTupleStruct<T, U>(#[pin] pub T, pub U);
+
+#[::pin_project::pin_project(
+ project = ReplaceTupleStructNamedProj,
+ project_ref = ReplaceTupleStructNamedProjRef,
+ project_replace = ReplaceTupleStructNamedProjOwn,
+)]
+#[derive(Debug)]
+pub struct ReplaceTupleStructNamed<T, U>(#[pin] pub T, pub U);
+
+#[::pin_project::pin_project(
+ project = ReplaceEnumProj,
+ project_ref = ReplaceEnumProjRef,
+ project_replace = ReplaceEnumProjOwn,
+)]
+#[derive(Debug)]
+pub enum ReplaceEnum<T, U> {
+ Struct {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+ },
+ Tuple(#[pin] T, U),
+ Unit,
+}
+
+#[::pin_project::pin_project(UnsafeUnpin)]
+#[derive(Debug)]
+pub struct UnsafeUnpinStruct<T, U> {
+ #[pin]
+ pub pinned: T,
+ pub unpinned: U,
+}
+
+#[::pin_project::pin_project(UnsafeUnpin)]
+#[derive(Debug)]
+pub struct UnsafeUnpinTupleStruct<T, U>(#[pin] pub T, pub U);
+
+#[::pin_project::pin_project(
+ UnsafeUnpin,
+ project = UnsafeUnpinEnumProj,
+ project_ref = UnsafeUnpinEnumProjRef,
+)]
+#[derive(Debug)]
+pub enum UnsafeUnpinEnum<T, U> {
+ Struct {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+ },
+ Tuple(#[pin] T, U),
+ Unit,
+}
+
+#[::pin_project::pin_project(!Unpin)]
+#[derive(Debug)]
+pub struct NotUnpinStruct<T, U> {
+ #[pin]
+ pub pinned: T,
+ pub unpinned: U,
+}
+
+#[::pin_project::pin_project(!Unpin)]
+#[derive(Debug)]
+pub struct NotUnpinTupleStruct<T, U>(#[pin] pub T, pub U);
+
+#[::pin_project::pin_project(
+ !Unpin,
+ project = NotUnpinEnumProj,
+ project_ref = NotUnpinEnumProjRef,
+)]
+#[derive(Debug)]
+pub enum NotUnpinEnum<T, U> {
+ Struct {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+ },
+ Tuple(#[pin] T, U),
+ Unit,
+}
diff --git a/third_party/rust/pin-project/tests/include/basic.rs b/third_party/rust/pin-project/tests/include/basic.rs
new file mode 100644
index 0000000000..57cbaeb86b
--- /dev/null
+++ b/third_party/rust/pin-project/tests/include/basic.rs
@@ -0,0 +1,17 @@
+include!("basic-safe-part.rs");
+
+#[allow(clippy::undocumented_unsafe_blocks)]
+unsafe impl<T: ::pin_project::__private::Unpin, U: ::pin_project::__private::Unpin>
+ ::pin_project::UnsafeUnpin for UnsafeUnpinStruct<T, U>
+{
+}
+#[allow(clippy::undocumented_unsafe_blocks)]
+unsafe impl<T: ::pin_project::__private::Unpin, U: ::pin_project::__private::Unpin>
+ ::pin_project::UnsafeUnpin for UnsafeUnpinTupleStruct<T, U>
+{
+}
+#[allow(clippy::undocumented_unsafe_blocks)]
+unsafe impl<T: ::pin_project::__private::Unpin, U: ::pin_project::__private::Unpin>
+ ::pin_project::UnsafeUnpin for UnsafeUnpinEnum<T, U>
+{
+}
diff --git a/third_party/rust/pin-project/tests/lint.rs b/third_party/rust/pin-project/tests/lint.rs
new file mode 100644
index 0000000000..c60f769f8d
--- /dev/null
+++ b/third_party/rust/pin-project/tests/lint.rs
@@ -0,0 +1,1191 @@
+// Check interoperability with rustc and clippy lints.
+
+// for old compilers
+#![allow(unknown_lints)]
+#![warn(nonstandard_style, rust_2018_idioms, unused)]
+// Note: This does not guarantee compatibility with forbidding these lints in the future.
+// If rustc adds a new lint, we may not be able to keep this.
+#![forbid(future_incompatible, rust_2018_compatibility, rust_2021_compatibility)]
+// lints forbidden as a part of future_incompatible, rust_2018_compatibility, and rust_2021_compatibility are not included in the list below.
+// elided_lifetimes_in_paths, explicit_outlives_requirements, unused_extern_crates: as a part of rust_2018_idioms
+// unsafe_op_in_unsafe_fn: requires Rust 1.52. and, we don't generate unsafe fn.
+// non_exhaustive_omitted_patterns: unstable
+// unstable_features: no way to generate #![feature(..)] by macros, expect for unstable inner attribute. and this lint is deprecated: https://doc.rust-lang.org/rustc/lints/listing/allowed-by-default.html#unstable-features
+// unused_crate_dependencies, must_not_suspend: unrelated
+// unsafe_code: checked in forbid_unsafe module
+#![warn(
+ box_pointers,
+ deprecated_in_future,
+ fuzzy_provenance_casts,
+ let_underscore_drop,
+ lossy_provenance_casts,
+ macro_use_extern_crate,
+ meta_variable_misuse,
+ missing_abi,
+ missing_copy_implementations,
+ missing_debug_implementations,
+ missing_docs,
+ non_ascii_idents,
+ noop_method_call,
+ single_use_lifetimes,
+ trivial_casts,
+ trivial_numeric_casts,
+ unreachable_pub,
+ unused_import_braces,
+ unused_lifetimes,
+ unused_qualifications,
+ unused_results,
+ unused_tuple_struct_fields,
+ variant_size_differences
+)]
+#![warn(clippy::all, clippy::pedantic, clippy::nursery, clippy::restriction)]
+#![allow(clippy::blanket_clippy_restriction_lints)] // this is a test, so enable all restriction lints intentionally.
+#![allow(clippy::exhaustive_structs, clippy::exhaustive_enums, clippy::single_char_lifetime_names)] // TODO
+
+pub mod basic {
+ include!("include/basic.rs");
+
+ pub mod inside_macro {
+ #[rustfmt::skip]
+ macro_rules! mac {
+ () => {
+ #[::pin_project::pin_project]
+ #[derive(Debug)]
+ pub struct DefaultStruct<T, U> {
+ #[pin]
+ pub pinned: T,
+ pub unpinned: U,
+ }
+
+ #[::pin_project::pin_project(
+ project = DefaultStructNamedProj,
+ project_ref = DefaultStructNamedProjRef,
+ )]
+ #[derive(Debug)]
+ pub struct DefaultStructNamed<T, U> {
+ #[pin]
+ pub pinned: T,
+ pub unpinned: U,
+ }
+
+ #[::pin_project::pin_project]
+ #[derive(Debug)]
+ pub struct DefaultTupleStruct<T, U>(#[pin] pub T, pub U);
+
+ #[::pin_project::pin_project(
+ project = DefaultTupleStructNamedProj,
+ project_ref = DefaultTupleStructNamedProjRef,
+ )]
+ #[derive(Debug)]
+ pub struct DefaultTupleStructNamed<T, U>(#[pin] pub T, pub U);
+
+ #[::pin_project::pin_project(
+ project = DefaultEnumProj,
+ project_ref = DefaultEnumProjRef,
+ )]
+ #[derive(Debug)]
+ pub enum DefaultEnum<T, U> {
+ Struct {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+ },
+ Tuple(#[pin] T, U),
+ Unit,
+ }
+
+ #[::pin_project::pin_project(PinnedDrop)]
+ #[derive(Debug)]
+ pub struct PinnedDropStruct<T, U> {
+ #[pin]
+ pub pinned: T,
+ pub unpinned: U,
+ }
+
+ #[::pin_project::pinned_drop]
+ impl<T, U> PinnedDrop for PinnedDropStruct<T, U> {
+ fn drop(self: ::pin_project::__private::Pin<&mut Self>) {}
+ }
+
+ #[::pin_project::pin_project(PinnedDrop)]
+ #[derive(Debug)]
+ pub struct PinnedDropTupleStruct<T, U>(#[pin] pub T, pub U);
+
+ #[::pin_project::pinned_drop]
+ impl<T, U> PinnedDrop for PinnedDropTupleStruct<T, U> {
+ fn drop(self: ::pin_project::__private::Pin<&mut Self>) {}
+ }
+
+ #[::pin_project::pin_project(
+ PinnedDrop,
+ project = PinnedDropEnumProj,
+ project_ref = PinnedDropEnumProjRef,
+ )]
+ #[derive(Debug)]
+ pub enum PinnedDropEnum<T, U> {
+ Struct {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+ },
+ Tuple(#[pin] T, U),
+ Unit,
+ }
+
+ #[::pin_project::pinned_drop]
+ impl<T, U> PinnedDrop for PinnedDropEnum<T, U> {
+ fn drop(self: ::pin_project::__private::Pin<&mut Self>) {}
+ }
+
+ #[::pin_project::pin_project(project_replace)]
+ #[derive(Debug)]
+ pub struct ReplaceStruct<T, U> {
+ #[pin]
+ pub pinned: T,
+ pub unpinned: U,
+ }
+
+ #[::pin_project::pin_project(
+ project = ReplaceStructNamedProj,
+ project_ref = ReplaceStructNamedProjRef,
+ project_replace = ReplaceStructNamedProjOwn,
+ )]
+ #[derive(Debug)]
+ pub struct ReplaceStructNamed<T, U> {
+ #[pin]
+ pub pinned: T,
+ pub unpinned: U,
+ }
+
+ #[::pin_project::pin_project(project_replace)]
+ #[derive(Debug)]
+ pub struct ReplaceTupleStruct<T, U>(#[pin] pub T, pub U);
+
+ #[::pin_project::pin_project(
+ project = ReplaceTupleStructNamedProj,
+ project_ref = ReplaceTupleStructNamedProjRef,
+ project_replace = ReplaceTupleStructNamedProjOwn,
+ )]
+ #[derive(Debug)]
+ pub struct ReplaceTupleStructNamed<T, U>(#[pin] pub T, pub U);
+
+ #[::pin_project::pin_project(
+ project = ReplaceEnumProj,
+ project_ref = ReplaceEnumProjRef,
+ project_replace = ReplaceEnumProjOwn,
+ )]
+ #[derive(Debug)]
+ pub enum ReplaceEnum<T, U> {
+ Struct {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+ },
+ Tuple(#[pin] T, U),
+ Unit,
+ }
+
+ #[::pin_project::pin_project(UnsafeUnpin)]
+ #[derive(Debug)]
+ pub struct UnsafeUnpinStruct<T, U> {
+ #[pin]
+ pub pinned: T,
+ pub unpinned: U,
+ }
+
+ #[::pin_project::pin_project(UnsafeUnpin)]
+ #[derive(Debug)]
+ pub struct UnsafeUnpinTupleStruct<T, U>(#[pin] pub T, pub U);
+
+ #[::pin_project::pin_project(
+ UnsafeUnpin,
+ project = UnsafeUnpinEnumProj,
+ project_ref = UnsafeUnpinEnumProjRef,
+ )]
+ #[derive(Debug)]
+ pub enum UnsafeUnpinEnum<T, U> {
+ Struct {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+ },
+ Tuple(#[pin] T, U),
+ Unit,
+ }
+
+ #[::pin_project::pin_project(!Unpin)]
+ #[derive(Debug)]
+ pub struct NotUnpinStruct<T, U> {
+ #[pin]
+ pub pinned: T,
+ pub unpinned: U,
+ }
+
+ #[::pin_project::pin_project(!Unpin)]
+ #[derive(Debug)]
+ pub struct NotUnpinTupleStruct<T, U>(#[pin] pub T, pub U);
+
+ #[::pin_project::pin_project(
+ !Unpin,
+ project = NotUnpinEnumProj,
+ project_ref = NotUnpinEnumProjRef,
+ )]
+ #[derive(Debug)]
+ pub enum NotUnpinEnum<T, U> {
+ Struct {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+ },
+ Tuple(#[pin] T, U),
+ Unit,
+ }
+
+ #[allow(clippy::undocumented_unsafe_blocks)]
+ unsafe impl<T: ::pin_project::__private::Unpin, U: ::pin_project::__private::Unpin>
+ ::pin_project::UnsafeUnpin for UnsafeUnpinStruct<T, U>
+ {
+ }
+ #[allow(clippy::undocumented_unsafe_blocks)]
+ unsafe impl<T: ::pin_project::__private::Unpin, U: ::pin_project::__private::Unpin>
+ ::pin_project::UnsafeUnpin for UnsafeUnpinTupleStruct<T, U>
+ {
+ }
+ #[allow(clippy::undocumented_unsafe_blocks)]
+ unsafe impl<T: ::pin_project::__private::Unpin, U: ::pin_project::__private::Unpin>
+ ::pin_project::UnsafeUnpin for UnsafeUnpinEnum<T, U>
+ {
+ }
+ };
+ }
+
+ mac!();
+ }
+}
+
+pub mod forbid_unsafe {
+ #![forbid(unsafe_code)]
+
+ include!("include/basic-safe-part.rs");
+
+ pub mod inside_macro {
+ #[rustfmt::skip]
+ macro_rules! mac {
+ () => {
+ #[::pin_project::pin_project]
+ #[derive(Debug)]
+ pub struct DefaultStruct<T, U> {
+ #[pin]
+ pub pinned: T,
+ pub unpinned: U,
+ }
+
+ #[::pin_project::pin_project(
+ project = DefaultStructNamedProj,
+ project_ref = DefaultStructNamedProjRef,
+ )]
+ #[derive(Debug)]
+ pub struct DefaultStructNamed<T, U> {
+ #[pin]
+ pub pinned: T,
+ pub unpinned: U,
+ }
+
+ #[::pin_project::pin_project]
+ #[derive(Debug)]
+ pub struct DefaultTupleStruct<T, U>(#[pin] pub T, pub U);
+
+ #[::pin_project::pin_project(
+ project = DefaultTupleStructNamedProj,
+ project_ref = DefaultTupleStructNamedProjRef,
+ )]
+ #[derive(Debug)]
+ pub struct DefaultTupleStructNamed<T, U>(#[pin] pub T, pub U);
+
+ #[::pin_project::pin_project(
+ project = DefaultEnumProj,
+ project_ref = DefaultEnumProjRef,
+ )]
+ #[derive(Debug)]
+ pub enum DefaultEnum<T, U> {
+ Struct {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+ },
+ Tuple(#[pin] T, U),
+ Unit,
+ }
+
+ #[::pin_project::pin_project(PinnedDrop)]
+ #[derive(Debug)]
+ pub struct PinnedDropStruct<T, U> {
+ #[pin]
+ pub pinned: T,
+ pub unpinned: U,
+ }
+
+ #[::pin_project::pinned_drop]
+ impl<T, U> PinnedDrop for PinnedDropStruct<T, U> {
+ fn drop(self: ::pin_project::__private::Pin<&mut Self>) {}
+ }
+
+ #[::pin_project::pin_project(PinnedDrop)]
+ #[derive(Debug)]
+ pub struct PinnedDropTupleStruct<T, U>(#[pin] pub T, pub U);
+
+ #[::pin_project::pinned_drop]
+ impl<T, U> PinnedDrop for PinnedDropTupleStruct<T, U> {
+ fn drop(self: ::pin_project::__private::Pin<&mut Self>) {}
+ }
+
+ #[::pin_project::pin_project(
+ PinnedDrop,
+ project = PinnedDropEnumProj,
+ project_ref = PinnedDropEnumProjRef,
+ )]
+ #[derive(Debug)]
+ pub enum PinnedDropEnum<T, U> {
+ Struct {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+ },
+ Tuple(#[pin] T, U),
+ Unit,
+ }
+
+ #[::pin_project::pinned_drop]
+ impl<T, U> PinnedDrop for PinnedDropEnum<T, U> {
+ fn drop(self: ::pin_project::__private::Pin<&mut Self>) {}
+ }
+
+ #[::pin_project::pin_project(project_replace)]
+ #[derive(Debug)]
+ pub struct ReplaceStruct<T, U> {
+ #[pin]
+ pub pinned: T,
+ pub unpinned: U,
+ }
+
+ #[::pin_project::pin_project(
+ project = ReplaceStructNamedProj,
+ project_ref = ReplaceStructNamedProjRef,
+ project_replace = ReplaceStructNamedProjOwn,
+ )]
+ #[derive(Debug)]
+ pub struct ReplaceStructNamed<T, U> {
+ #[pin]
+ pub pinned: T,
+ pub unpinned: U,
+ }
+
+ #[::pin_project::pin_project(project_replace)]
+ #[derive(Debug)]
+ pub struct ReplaceTupleStruct<T, U>(#[pin] pub T, pub U);
+
+ #[::pin_project::pin_project(
+ project = ReplaceTupleStructNamedProj,
+ project_ref = ReplaceTupleStructNamedProjRef,
+ project_replace = ReplaceTupleStructNamedProjOwn,
+ )]
+ #[derive(Debug)]
+ pub struct ReplaceTupleStructNamed<T, U>(#[pin] pub T, pub U);
+
+ #[::pin_project::pin_project(
+ project = ReplaceEnumProj,
+ project_ref = ReplaceEnumProjRef,
+ project_replace = ReplaceEnumProjOwn,
+ )]
+ #[derive(Debug)]
+ pub enum ReplaceEnum<T, U> {
+ Struct {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+ },
+ Tuple(#[pin] T, U),
+ Unit,
+ }
+
+ #[::pin_project::pin_project(UnsafeUnpin)]
+ #[derive(Debug)]
+ pub struct UnsafeUnpinStruct<T, U> {
+ #[pin]
+ pub pinned: T,
+ pub unpinned: U,
+ }
+
+ #[::pin_project::pin_project(UnsafeUnpin)]
+ #[derive(Debug)]
+ pub struct UnsafeUnpinTupleStruct<T, U>(#[pin] pub T, pub U);
+
+ #[::pin_project::pin_project(
+ UnsafeUnpin,
+ project = UnsafeUnpinEnumProj,
+ project_ref = UnsafeUnpinEnumProjRef,
+ )]
+ #[derive(Debug)]
+ pub enum UnsafeUnpinEnum<T, U> {
+ Struct {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+ },
+ Tuple(#[pin] T, U),
+ Unit,
+ }
+
+ #[::pin_project::pin_project(!Unpin)]
+ #[derive(Debug)]
+ pub struct NotUnpinStruct<T, U> {
+ #[pin]
+ pub pinned: T,
+ pub unpinned: U,
+ }
+
+ #[::pin_project::pin_project(!Unpin)]
+ #[derive(Debug)]
+ pub struct NotUnpinTupleStruct<T, U>(#[pin] pub T, pub U);
+
+ #[::pin_project::pin_project(
+ !Unpin,
+ project = NotUnpinEnumProj,
+ project_ref = NotUnpinEnumProjRef,
+ )]
+ #[derive(Debug)]
+ pub enum NotUnpinEnum<T, U> {
+ Struct {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+ },
+ Tuple(#[pin] T, U),
+ Unit,
+ }
+ };
+ }
+
+ mac!();
+ }
+}
+
+pub mod box_pointers {
+ use pin_project::pin_project;
+
+ #[allow(box_pointers)] // for the type itself
+ #[pin_project(project_replace)]
+ #[derive(Debug)]
+ pub struct Struct {
+ #[pin]
+ pub p: Box<isize>,
+ pub u: Box<isize>,
+ }
+
+ #[allow(box_pointers)] // for the type itself
+ #[pin_project(project_replace)]
+ #[derive(Debug)]
+ pub struct TupleStruct(#[pin] pub Box<isize>, pub Box<isize>);
+
+ #[allow(box_pointers)] // for the type itself
+ #[pin_project(
+ project = EnumProj,
+ project_ref = EnumProjRef,
+ project_replace = EnumProjOwn,
+ )]
+ #[derive(Debug)]
+ pub enum Enum {
+ Struct {
+ #[pin]
+ p: Box<isize>,
+ u: Box<isize>,
+ },
+ Tuple(#[pin] Box<isize>, Box<isize>),
+ Unit,
+ }
+
+ pub mod inside_macro {
+ use pin_project::pin_project;
+
+ #[rustfmt::skip]
+ macro_rules! mac {
+ () => {
+ #[allow(box_pointers)] // for the type itself
+ #[pin_project(project_replace)]
+ #[derive(Debug)]
+ pub struct Struct {
+ #[pin]
+ pub p: Box<isize>,
+ pub u: Box<isize>,
+ }
+
+ #[allow(box_pointers)] // for the type itself
+ #[pin_project(project_replace)]
+ #[derive(Debug)]
+ pub struct TupleStruct(#[pin] pub Box<isize>, pub Box<isize>);
+
+ #[allow(box_pointers)] // for the type itself
+ #[pin_project(
+ project = EnumProj,
+ project_ref = EnumProjRef,
+ project_replace = EnumProjOwn,
+ )]
+ #[derive(Debug)]
+ pub enum Enum {
+ Struct {
+ #[pin]
+ p: Box<isize>,
+ u: Box<isize>,
+ },
+ Tuple(#[pin] Box<isize>, Box<isize>),
+ Unit,
+ }
+ };
+ }
+
+ mac!();
+ }
+}
+
+pub mod deprecated {
+ use pin_project::pin_project;
+
+ #[allow(deprecated)] // for the type itself
+ #[pin_project(project_replace)]
+ #[derive(Debug, Clone, Copy)]
+ #[deprecated]
+ pub struct Struct {
+ #[deprecated]
+ #[pin]
+ pub p: (),
+ #[deprecated]
+ pub u: (),
+ }
+
+ #[allow(deprecated)] // for the type itself
+ #[pin_project(project_replace)]
+ #[derive(Debug, Clone, Copy)]
+ #[deprecated]
+ pub struct TupleStruct(
+ #[deprecated]
+ #[pin]
+ pub (),
+ #[deprecated] pub (),
+ );
+
+ #[allow(deprecated)] // for the type itself
+ #[pin_project(
+ project = EnumProj,
+ project_ref = EnumProjRef,
+ project_replace = EnumProjOwn,
+ )]
+ #[derive(Debug, Clone, Copy)]
+ #[deprecated]
+ pub enum Enum {
+ #[deprecated]
+ Struct {
+ #[deprecated]
+ #[pin]
+ p: (),
+ #[deprecated]
+ u: (),
+ },
+ #[deprecated]
+ Tuple(
+ #[deprecated]
+ #[pin]
+ (),
+ #[deprecated] (),
+ ),
+ #[deprecated]
+ Unit,
+ }
+
+ pub mod inside_macro {
+ use pin_project::pin_project;
+
+ #[rustfmt::skip]
+ macro_rules! mac {
+ () => {
+ #[allow(deprecated)] // for the type itself
+ #[pin_project(project_replace)]
+ #[derive(Debug, Clone, Copy)]
+ #[deprecated]
+ pub struct Struct {
+ #[deprecated]
+ #[pin]
+ pub p: (),
+ #[deprecated]
+ pub u: (),
+ }
+
+ #[allow(deprecated)] // for the type itself
+ #[pin_project(project_replace)]
+ #[derive(Debug, Clone, Copy)]
+ #[deprecated]
+ pub struct TupleStruct(
+ #[deprecated]
+ #[pin]
+ pub (),
+ #[deprecated] pub (),
+ );
+
+ #[allow(deprecated)] // for the type itself
+ #[pin_project(
+ project = EnumProj,
+ project_ref = EnumProjRef,
+ project_replace = EnumProjOwn,
+ )]
+ #[derive(Debug, Clone, Copy)]
+ #[deprecated]
+ pub enum Enum {
+ #[deprecated]
+ Struct {
+ #[deprecated]
+ #[pin]
+ p: (),
+ #[deprecated]
+ u: (),
+ },
+ #[deprecated]
+ Tuple(
+ #[deprecated]
+ #[pin]
+ (),
+ #[deprecated] (),
+ ),
+ #[deprecated]
+ Unit,
+ }
+ };
+ }
+
+ mac!();
+ }
+}
+
+pub mod explicit_outlives_requirements {
+ use pin_project::pin_project;
+
+ #[allow(explicit_outlives_requirements)] // for the type itself: https://github.com/rust-lang/rust/issues/60993
+ #[pin_project(project_replace)]
+ #[derive(Debug)]
+ pub struct Struct<'a, T, U>
+ where
+ T: ?Sized,
+ U: ?Sized,
+ {
+ #[pin]
+ pub pinned: &'a mut T,
+ pub unpinned: &'a mut U,
+ }
+
+ #[allow(explicit_outlives_requirements)] // for the type itself: https://github.com/rust-lang/rust/issues/60993
+ #[pin_project(project_replace)]
+ #[derive(Debug)]
+ pub struct TupleStruct<'a, T, U>(#[pin] pub &'a mut T, pub &'a mut U)
+ where
+ T: ?Sized,
+ U: ?Sized;
+
+ #[allow(explicit_outlives_requirements)] // for the type itself: https://github.com/rust-lang/rust/issues/60993
+ #[pin_project(
+ project = EnumProj,
+ project_ref = EnumProjRef,
+ project_replace = EnumProjOwn,
+ )]
+ #[derive(Debug)]
+ pub enum Enum<'a, T, U>
+ where
+ T: ?Sized,
+ U: ?Sized,
+ {
+ Struct {
+ #[pin]
+ pinned: &'a mut T,
+ unpinned: &'a mut U,
+ },
+ Tuple(#[pin] &'a mut T, &'a mut U),
+ Unit,
+ }
+
+ pub mod inside_macro {
+ use pin_project::pin_project;
+
+ #[rustfmt::skip]
+ macro_rules! mac {
+ () => {
+ #[allow(explicit_outlives_requirements)] // for the type itself: https://github.com/rust-lang/rust/issues/60993
+ #[pin_project(project_replace)]
+ #[derive(Debug)]
+ pub struct Struct<'a, T, U>
+ where
+ T: ?Sized,
+ U: ?Sized,
+ {
+ #[pin]
+ pub pinned: &'a mut T,
+ pub unpinned: &'a mut U,
+ }
+
+ #[allow(explicit_outlives_requirements)] // for the type itself: https://github.com/rust-lang/rust/issues/60993
+ #[pin_project(project_replace)]
+ #[derive(Debug)]
+ pub struct TupleStruct<'a, T, U>(#[pin] pub &'a mut T, pub &'a mut U)
+ where
+ T: ?Sized,
+ U: ?Sized;
+
+ #[allow(explicit_outlives_requirements)] // for the type itself: https://github.com/rust-lang/rust/issues/60993
+ #[pin_project(
+ project = EnumProj,
+ project_ref = EnumProjRef,
+ project_replace = EnumProjOwn,
+ )]
+ #[derive(Debug)]
+ pub enum Enum<'a, T, U>
+ where
+ T: ?Sized,
+ U: ?Sized,
+ {
+ Struct {
+ #[pin]
+ pinned: &'a mut T,
+ unpinned: &'a mut U,
+ },
+ Tuple(#[pin] &'a mut T, &'a mut U),
+ Unit,
+ }
+ };
+ }
+
+ mac!();
+ }
+}
+
+#[allow(missing_debug_implementations)]
+pub mod single_use_lifetimes {
+ use pin_project::pin_project;
+
+ #[allow(unused_lifetimes)]
+ pub trait Trait<'a> {}
+
+ #[allow(unused_lifetimes)] // for the type itself
+ #[allow(single_use_lifetimes)] // for the type itself: https://github.com/rust-lang/rust/issues/55058
+ #[pin_project(project_replace)]
+ pub struct Hrtb<'pin___, T>
+ where
+ for<'pin> &'pin T: Unpin,
+ T: for<'pin> Trait<'pin>,
+ for<'pin, 'pin_, 'pin__> &'pin &'pin_ &'pin__ T: Unpin,
+ {
+ #[pin]
+ _f: &'pin___ mut T,
+ }
+
+ pub mod inside_macro {
+ use pin_project::pin_project;
+
+ #[rustfmt::skip]
+ macro_rules! mac {
+ () => {
+ #[allow(unused_lifetimes)]
+ pub trait Trait<'a> {}
+
+ #[allow(unused_lifetimes)] // for the type itself
+ #[allow(single_use_lifetimes)] // for the type itself: https://github.com/rust-lang/rust/issues/55058
+ #[pin_project(project_replace)]
+ pub struct Hrtb<'pin___, T>
+ where
+ for<'pin> &'pin T: Unpin,
+ T: for<'pin> Trait<'pin>,
+ for<'pin, 'pin_, 'pin__> &'pin &'pin_ &'pin__ T: Unpin,
+ {
+ #[pin]
+ _f: &'pin___ mut T,
+ }
+ };
+ }
+
+ mac!();
+ }
+}
+
+pub mod variant_size_differences {
+ use pin_project::pin_project;
+
+ #[allow(missing_debug_implementations, missing_copy_implementations)] // https://github.com/rust-lang/rust/pull/74060
+ #[allow(variant_size_differences)] // for the type itself
+ #[allow(clippy::large_enum_variant)] // for the type itself
+ #[pin_project(
+ project = EnumProj,
+ project_ref = EnumProjRef,
+ project_replace = EnumProjOwn,
+ )]
+ pub enum Enum {
+ V1(u8),
+ V2([u8; 1024]),
+ }
+
+ pub mod inside_macro {
+ use pin_project::pin_project;
+
+ #[rustfmt::skip]
+ macro_rules! mac {
+ () => {
+ #[allow(missing_debug_implementations, missing_copy_implementations)] // https://github.com/rust-lang/rust/pull/74060
+ #[allow(variant_size_differences)] // for the type itself
+ #[allow(clippy::large_enum_variant)] // for the type itself
+ #[pin_project(
+ project = EnumProj,
+ project_ref = EnumProjRef,
+ project_replace = EnumProjOwn,
+ )]
+ pub enum Enum {
+ V1(u8),
+ V2([u8; 1024]),
+ }
+ };
+ }
+
+ mac!();
+ }
+}
+
+pub mod clippy_mut_mut {
+ use pin_project::pin_project;
+
+ #[pin_project(project_replace)]
+ #[derive(Debug)]
+ pub struct Struct<'a, T, U> {
+ #[pin]
+ pub pinned: &'a mut T,
+ pub unpinned: &'a mut U,
+ }
+
+ #[pin_project(project_replace)]
+ #[derive(Debug)]
+ pub struct TupleStruct<'a, T, U>(#[pin] &'a mut T, &'a mut U);
+
+ #[pin_project(
+ project = EnumProj,
+ project_ref = EnumProjRef,
+ project_replace = EnumProjOwn,
+ )]
+ #[derive(Debug)]
+ pub enum Enum<'a, T, U> {
+ Struct {
+ #[pin]
+ pinned: &'a mut T,
+ unpinned: &'a mut U,
+ },
+ Tuple(#[pin] &'a mut T, &'a mut U),
+ Unit,
+ }
+
+ pub mod inside_macro {
+ use pin_project::pin_project;
+
+ #[rustfmt::skip]
+ macro_rules! mac {
+ () => {
+ #[pin_project(project_replace)]
+ #[derive(Debug)]
+ pub struct Struct<'a, T, U> {
+ #[pin]
+ pub pinned: &'a mut T,
+ pub unpinned: &'a mut U,
+ }
+
+ #[pin_project(project_replace)]
+ #[derive(Debug)]
+ pub struct TupleStruct<'a, T, U>(#[pin] &'a mut T, &'a mut U);
+
+ #[pin_project(
+ project = EnumProj,
+ project_ref = EnumProjRef,
+ project_replace = EnumProjOwn,
+ )]
+ #[derive(Debug)]
+ pub enum Enum<'a, T, U> {
+ Struct {
+ #[pin]
+ pinned: &'a mut T,
+ unpinned: &'a mut U,
+ },
+ Tuple(#[pin] &'a mut T, &'a mut U),
+ Unit,
+ }
+ };
+ }
+
+ mac!();
+ }
+}
+
+#[allow(missing_debug_implementations)]
+#[allow(unreachable_pub)]
+mod clippy_redundant_pub_crate {
+ use pin_project::pin_project;
+
+ #[pin_project(project_replace)]
+ pub struct Struct<T, U> {
+ #[pin]
+ pub pinned: T,
+ pub unpinned: U,
+ }
+
+ #[pin_project(project_replace)]
+ pub struct TupleStruct<T, U>(#[pin] pub T, pub U);
+
+ #[allow(dead_code)]
+ #[pin_project(
+ project = EnumProj,
+ project_ref = EnumProjRef,
+ project_replace = EnumProjOwn,
+ )]
+ pub enum Enum<T, U> {
+ Struct {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+ },
+ Tuple(#[pin] T, U),
+ Unit,
+ }
+
+ pub mod inside_macro {
+ use pin_project::pin_project;
+
+ #[allow(clippy::redundant_pub_crate)]
+ #[rustfmt::skip]
+ macro_rules! mac {
+ () => {
+ #[pin_project(project_replace)]
+ pub struct Struct<T, U> {
+ #[pin]
+ pub pinned: T,
+ pub unpinned: U,
+ }
+
+ #[pin_project(project_replace)]
+ pub struct TupleStruct<T, U>(#[pin] pub T, pub U);
+
+ #[allow(dead_code)]
+ #[pin_project(
+ project = EnumProj,
+ project_ref = EnumProjRef,
+ project_replace = EnumProjOwn,
+ )]
+ pub enum Enum<T, U> {
+ Struct {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+ },
+ Tuple(#[pin] T, U),
+ Unit,
+ }
+ };
+ }
+
+ mac!();
+ }
+}
+
+#[allow(missing_debug_implementations)]
+pub mod clippy_type_repetition_in_bounds {
+ use pin_project::pin_project;
+
+ #[pin_project(project_replace)]
+ pub struct Struct<T, U>
+ where
+ Self: Sized,
+ {
+ #[pin]
+ pub pinned: T,
+ pub unpinned: U,
+ }
+
+ #[pin_project(project_replace)]
+ pub struct TupleStruct<T, U>(#[pin] T, U)
+ where
+ Self: Sized;
+
+ #[pin_project(
+ project = EnumProj,
+ project_ref = EnumProjRef,
+ project_replace = EnumProjOwn,
+ )]
+ pub enum Enum<T, U>
+ where
+ Self: Sized,
+ {
+ Struct {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+ },
+ Tuple(#[pin] T, U),
+ Unit,
+ }
+
+ pub mod inside_macro {
+ use pin_project::pin_project;
+
+ #[rustfmt::skip]
+ macro_rules! mac {
+ () => {
+ #[pin_project(project_replace)]
+ pub struct Struct<T, U>
+ where
+ Self: Sized,
+ {
+ #[pin]
+ pub pinned: T,
+ pub unpinned: U,
+ }
+
+ #[pin_project(project_replace)]
+ pub struct TupleStruct<T, U>(#[pin] T, U)
+ where
+ Self: Sized;
+
+ #[pin_project(
+ project = EnumProj,
+ project_ref = EnumProjRef,
+ project_replace = EnumProjOwn,
+ )]
+ pub enum Enum<T, U>
+ where
+ Self: Sized,
+ {
+ Struct {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+ },
+ Tuple(#[pin] T, U),
+ Unit,
+ }
+ };
+ }
+
+ mac!();
+ }
+}
+
+#[allow(missing_debug_implementations)]
+pub mod clippy_use_self {
+ use pin_project::pin_project;
+
+ pub trait Trait {
+ type Assoc;
+ }
+
+ #[pin_project(project_replace)]
+ pub struct Generics<T: Trait<Assoc = Self>>
+ where
+ Self: Trait<Assoc = Self>,
+ {
+ _f: T,
+ }
+
+ pub mod inside_macro {
+ use pin_project::pin_project;
+
+ use super::Trait;
+
+ #[rustfmt::skip]
+ macro_rules! mac {
+ () => {
+ #[pin_project(project_replace)]
+ pub struct Generics<T: Trait<Assoc = Self>>
+ where
+ Self: Trait<Assoc = Self>,
+ {
+ _f: T,
+ }
+ };
+ }
+
+ mac!();
+ }
+}
+
+#[allow(missing_debug_implementations)]
+pub mod clippy_used_underscore_binding {
+ use pin_project::pin_project;
+
+ #[pin_project(project_replace)]
+ pub struct Struct<T, U> {
+ #[pin]
+ pub _pinned: T,
+ pub _unpinned: U,
+ }
+
+ #[pin_project(
+ project = EnumProj,
+ project_ref = EnumProjRef,
+ project_replace = EnumProjOwn,
+ )]
+ pub enum Enum<T, U> {
+ Struct {
+ #[pin]
+ _pinned: T,
+ _unpinned: U,
+ },
+ }
+
+ pub mod inside_macro {
+ use pin_project::pin_project;
+
+ #[rustfmt::skip]
+ macro_rules! mac {
+ () => {
+ #[pin_project(project_replace)]
+ pub struct Struct<T, U> {
+ #[pin]
+ pub _pinned: T,
+ pub _unpinned: U,
+ }
+
+ #[pin_project(
+ project = EnumProj,
+ project_ref = EnumProjRef,
+ project_replace = EnumProjOwn,
+ )]
+ pub enum Enum<T, U> {
+ Struct {
+ #[pin]
+ _pinned: T,
+ _unpinned: U,
+ },
+ }
+ };
+ }
+
+ mac!();
+ }
+}
+
+#[allow(missing_debug_implementations)]
+pub mod clippy_ref_option_ref {
+ use pin_project::pin_project;
+
+ #[pin_project]
+ pub struct Struct<'a> {
+ #[pin]
+ pub _pinned: Option<&'a ()>,
+ pub _unpinned: Option<&'a ()>,
+ }
+
+ #[pin_project(project = EnumProj, project_ref = EnumProjRef)]
+ pub enum Enum<'a> {
+ Struct {
+ #[pin]
+ _pinned: Option<&'a ()>,
+ _unpinned: Option<&'a ()>,
+ },
+ }
+}
diff --git a/third_party/rust/pin-project/tests/pin_project.rs b/third_party/rust/pin-project/tests/pin_project.rs
new file mode 100644
index 0000000000..cbc67ce8e9
--- /dev/null
+++ b/third_party/rust/pin-project/tests/pin_project.rs
@@ -0,0 +1,888 @@
+#![warn(rust_2018_idioms, single_use_lifetimes)]
+#![allow(dead_code)]
+
+#[macro_use]
+mod auxiliary;
+
+use std::{
+ marker::{PhantomData, PhantomPinned},
+ panic,
+ pin::Pin,
+};
+
+use pin_project::{pin_project, pinned_drop, UnsafeUnpin};
+
+#[test]
+fn projection() {
+ #[pin_project(
+ project = StructProj,
+ project_ref = StructProjRef,
+ project_replace = StructProjOwn,
+ )]
+ struct Struct<T, U> {
+ #[pin]
+ f1: T,
+ f2: U,
+ }
+
+ let mut s = Struct { f1: 1, f2: 2 };
+ let mut s_orig = Pin::new(&mut s);
+ let s = s_orig.as_mut().project();
+
+ let _: Pin<&mut i32> = s.f1;
+ assert_eq!(*s.f1, 1);
+ let _: &mut i32 = s.f2;
+ assert_eq!(*s.f2, 2);
+
+ assert_eq!(s_orig.as_ref().f1, 1);
+ assert_eq!(s_orig.as_ref().f2, 2);
+
+ let mut s = Struct { f1: 1, f2: 2 };
+ let mut s = Pin::new(&mut s);
+ {
+ let StructProj { f1, f2 } = s.as_mut().project();
+ let _: Pin<&mut i32> = f1;
+ let _: &mut i32 = f2;
+ }
+ {
+ let StructProjRef { f1, f2 } = s.as_ref().project_ref();
+ let _: Pin<&i32> = f1;
+ let _: &i32 = f2;
+ }
+ {
+ let StructProjOwn { f1, f2 } = s.as_mut().project_replace(Struct { f1: 3, f2: 4 });
+ let _: PhantomData<i32> = f1;
+ let _: i32 = f2;
+ assert_eq!(f2, 2);
+ assert_eq!(s.f1, 3);
+ assert_eq!(s.f2, 4);
+ }
+
+ #[pin_project(project_replace)]
+ struct TupleStruct<T, U>(#[pin] T, U);
+
+ let mut s = TupleStruct(1, 2);
+ let s = Pin::new(&mut s).project();
+
+ let _: Pin<&mut i32> = s.0;
+ assert_eq!(*s.0, 1);
+ let _: &mut i32 = s.1;
+ assert_eq!(*s.1, 2);
+
+ #[pin_project(project = EnumProj, project_ref = EnumProjRef, project_replace = EnumProjOwn)]
+ #[derive(Eq, PartialEq, Debug)]
+ enum Enum<A, B, C, D> {
+ Tuple(#[pin] A, B),
+ Struct {
+ #[pin]
+ f1: C,
+ f2: D,
+ },
+ Unit,
+ }
+
+ let mut e = Enum::Tuple(1, 2);
+ let mut e = Pin::new(&mut e);
+
+ match e.as_mut().project() {
+ EnumProj::Tuple(x, y) => {
+ let x: Pin<&mut i32> = x;
+ assert_eq!(*x, 1);
+ let y: &mut i32 = y;
+ assert_eq!(*y, 2);
+ }
+ EnumProj::Struct { f1, f2 } => {
+ let _: Pin<&mut i32> = f1;
+ let _: &mut i32 = f2;
+ unreachable!();
+ }
+ EnumProj::Unit => unreachable!(),
+ }
+
+ assert_eq!(&*e, &Enum::Tuple(1, 2));
+
+ let mut e = Enum::Struct { f1: 3, f2: 4 };
+ let mut e = Pin::new(&mut e);
+
+ match e.as_mut().project() {
+ EnumProj::Tuple(x, y) => {
+ let _: Pin<&mut i32> = x;
+ let _: &mut i32 = y;
+ unreachable!();
+ }
+ EnumProj::Struct { f1, f2 } => {
+ let _: Pin<&mut i32> = f1;
+ assert_eq!(*f1, 3);
+ let _: &mut i32 = f2;
+ assert_eq!(*f2, 4);
+ }
+ EnumProj::Unit => unreachable!(),
+ }
+
+ if let EnumProj::Struct { f1, f2 } = e.as_mut().project() {
+ let _: Pin<&mut i32> = f1;
+ assert_eq!(*f1, 3);
+ let _: &mut i32 = f2;
+ assert_eq!(*f2, 4);
+ }
+}
+
+#[test]
+fn enum_project_set() {
+ #[pin_project(project = EnumProj, project_ref = EnumProjRef, project_replace = EnumProjOwn)]
+ #[derive(Eq, PartialEq, Debug)]
+ enum Enum {
+ V1(#[pin] u8),
+ V2(bool),
+ }
+
+ let mut e = Enum::V1(25);
+ let mut e_orig = Pin::new(&mut e);
+ let e_proj = e_orig.as_mut().project();
+
+ match e_proj {
+ EnumProj::V1(val) => {
+ let new_e = Enum::V2(val.as_ref().get_ref() == &25);
+ e_orig.set(new_e);
+ }
+ EnumProj::V2(_) => unreachable!(),
+ }
+
+ assert_eq!(e, Enum::V2(true));
+}
+
+#[test]
+fn where_clause() {
+ #[pin_project]
+ struct Struct<T>
+ where
+ T: Copy,
+ {
+ f: T,
+ }
+
+ #[pin_project]
+ struct TupleStruct<T>(T)
+ where
+ T: Copy;
+
+ #[pin_project(project = EnumProj, project_ref = EnumProjRef, project_replace = EnumProjOwn)]
+ enum Enum<T>
+ where
+ T: Copy,
+ {
+ V(T),
+ }
+}
+
+#[test]
+fn where_clause_and_associated_type_field() {
+ #[pin_project(project_replace)]
+ struct Struct1<I>
+ where
+ I: Iterator,
+ {
+ #[pin]
+ f1: I,
+ f2: I::Item,
+ }
+
+ #[pin_project(project_replace)]
+ struct Struct2<I, J>
+ where
+ I: Iterator<Item = J>,
+ {
+ #[pin]
+ f1: I,
+ f2: J,
+ }
+
+ #[pin_project(project_replace)]
+ struct Struct3<T>
+ where
+ T: 'static,
+ {
+ f: T,
+ }
+
+ trait Static: 'static {}
+
+ impl<T> Static for Struct3<T> {}
+
+ #[pin_project(project_replace)]
+ struct TupleStruct<I>(#[pin] I, I::Item)
+ where
+ I: Iterator;
+
+ #[pin_project(project = EnumProj, project_ref = EnumProjRef, project_replace = EnumProjOwn)]
+ enum Enum<I>
+ where
+ I: Iterator,
+ {
+ V1(#[pin] I),
+ V2(I::Item),
+ }
+}
+
+#[test]
+fn derive_copy() {
+ #[pin_project(project_replace)]
+ #[derive(Clone, Copy)]
+ struct Struct<T> {
+ f: T,
+ }
+
+ fn is_copy<T: Copy>() {}
+
+ is_copy::<Struct<u8>>();
+}
+
+#[test]
+fn move_out() {
+ struct NotCopy;
+
+ #[pin_project(project_replace)]
+ struct Struct {
+ f: NotCopy,
+ }
+
+ let x = Struct { f: NotCopy };
+ let _val: NotCopy = x.f;
+
+ #[pin_project(project = EnumProj, project_ref = EnumProjRef, project_replace = EnumProjOwn)]
+ enum Enum {
+ V(NotCopy),
+ }
+
+ let x = Enum::V(NotCopy);
+ #[allow(clippy::infallible_destructuring_match)]
+ let _val: NotCopy = match x {
+ Enum::V(val) => val,
+ };
+}
+
+#[test]
+fn trait_bounds_on_type_generics() {
+ #[pin_project(project_replace)]
+ pub struct Struct1<'a, T: ?Sized> {
+ f: &'a mut T,
+ }
+
+ #[pin_project(project_replace)]
+ pub struct Struct2<'a, T: ::core::fmt::Debug> {
+ f: &'a mut T,
+ }
+
+ #[pin_project(project_replace)]
+ pub struct Struct3<'a, T: core::fmt::Debug> {
+ f: &'a mut T,
+ }
+
+ #[pin_project(project_replace)]
+ pub struct Struct4<'a, T: core::fmt::Debug + core::fmt::Display> {
+ f: &'a mut T,
+ }
+
+ #[pin_project(project_replace)]
+ pub struct Struct5<'a, T: core::fmt::Debug + ?Sized> {
+ f: &'a mut T,
+ }
+
+ #[pin_project(project_replace)]
+ pub struct Struct6<'a, T: core::fmt::Debug = [u8; 16]> {
+ f: &'a mut T,
+ }
+
+ let _: Struct6<'_> = Struct6 { f: &mut [0_u8; 16] };
+
+ #[pin_project(project_replace)]
+ pub struct Struct7<T: 'static> {
+ f: T,
+ }
+
+ trait Static: 'static {}
+
+ impl<T> Static for Struct7<T> {}
+
+ #[pin_project(project_replace)]
+ pub struct Struct8<'a, 'b: 'a> {
+ f1: &'a u8,
+ f2: &'b u8,
+ }
+
+ #[pin_project(project_replace)]
+ pub struct TupleStruct<'a, T: ?Sized>(&'a mut T);
+
+ #[pin_project(project = EnumProj, project_ref = EnumProjRef, project_replace = EnumProjOwn)]
+ enum Enum<'a, T: ?Sized> {
+ V(&'a mut T),
+ }
+}
+
+#[test]
+fn overlapping_lifetime_names() {
+ #[pin_project(project_replace)]
+ pub struct Struct1<'pin, T> {
+ #[pin]
+ f: &'pin mut T,
+ }
+
+ #[pin_project(project_replace)]
+ pub struct Struct2<'pin, 'pin_, 'pin__> {
+ #[pin]
+ f: &'pin &'pin_ &'pin__ (),
+ }
+
+ pub trait Trait<'a> {}
+
+ #[allow(single_use_lifetimes)] // https://github.com/rust-lang/rust/issues/55058
+ #[pin_project(project_replace)]
+ pub struct Hrtb<'pin___, T>
+ where
+ for<'pin> &'pin T: Unpin,
+ T: for<'pin> Trait<'pin>,
+ for<'pin, 'pin_, 'pin__> &'pin &'pin_ &'pin__ T: Unpin,
+ {
+ #[pin]
+ f: &'pin___ mut T,
+ }
+
+ #[pin_project(PinnedDrop)]
+ pub struct PinnedDropStruct<'pin> {
+ #[pin]
+ f: &'pin (),
+ }
+
+ #[pinned_drop]
+ impl PinnedDrop for PinnedDropStruct<'_> {
+ fn drop(self: Pin<&mut Self>) {}
+ }
+
+ #[pin_project(UnsafeUnpin)]
+ pub struct UnsafeUnpinStruct<'pin> {
+ #[pin]
+ f: &'pin (),
+ }
+
+ unsafe impl UnsafeUnpin for UnsafeUnpinStruct<'_> {}
+
+ #[pin_project(!Unpin)]
+ pub struct NotUnpinStruct<'pin> {
+ #[pin]
+ f: &'pin (),
+ }
+}
+
+#[test]
+fn combine() {
+ #[pin_project(PinnedDrop, UnsafeUnpin)]
+ pub struct PinnedDropWithUnsafeUnpin<T> {
+ #[pin]
+ f: T,
+ }
+
+ #[pinned_drop]
+ impl<T> PinnedDrop for PinnedDropWithUnsafeUnpin<T> {
+ fn drop(self: Pin<&mut Self>) {}
+ }
+
+ unsafe impl<T: Unpin> UnsafeUnpin for PinnedDropWithUnsafeUnpin<T> {}
+
+ #[pin_project(PinnedDrop, !Unpin)]
+ pub struct PinnedDropWithNotUnpin<T> {
+ #[pin]
+ f: T,
+ }
+
+ #[pinned_drop]
+ impl<T> PinnedDrop for PinnedDropWithNotUnpin<T> {
+ fn drop(self: Pin<&mut Self>) {}
+ }
+
+ #[pin_project(UnsafeUnpin, project_replace)]
+ pub struct UnsafeUnpinWithReplace<T> {
+ #[pin]
+ f: T,
+ }
+
+ unsafe impl<T: Unpin> UnsafeUnpin for UnsafeUnpinWithReplace<T> {}
+
+ #[pin_project(!Unpin, project_replace)]
+ pub struct NotUnpinWithReplace<T> {
+ #[pin]
+ f: T,
+ }
+}
+
+#[test]
+fn private_type_in_public_type() {
+ #[pin_project(project_replace)]
+ pub struct PublicStruct<T> {
+ #[pin]
+ inner: PrivateStruct<T>,
+ }
+
+ struct PrivateStruct<T>(T);
+}
+
+#[allow(clippy::needless_lifetimes)]
+#[test]
+fn lifetime_project() {
+ #[pin_project(project_replace)]
+ struct Struct1<T, U> {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+ }
+
+ #[pin_project(project_replace)]
+ struct Struct2<'a, T, U> {
+ #[pin]
+ pinned: &'a T,
+ unpinned: U,
+ }
+
+ #[pin_project(project = EnumProj, project_ref = EnumProjRef, project_replace = EnumProjOwn)]
+ enum Enum<T, U> {
+ V {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+ },
+ }
+
+ impl<T, U> Struct1<T, U> {
+ fn get_pin_ref<'a>(self: Pin<&'a Self>) -> Pin<&'a T> {
+ self.project_ref().pinned
+ }
+ fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut T> {
+ self.project().pinned
+ }
+ fn get_pin_ref_elided(self: Pin<&Self>) -> Pin<&T> {
+ self.project_ref().pinned
+ }
+ fn get_pin_mut_elided(self: Pin<&mut Self>) -> Pin<&mut T> {
+ self.project().pinned
+ }
+ }
+
+ impl<'b, T, U> Struct2<'b, T, U> {
+ fn get_pin_ref<'a>(self: Pin<&'a Self>) -> Pin<&'a &'b T> {
+ self.project_ref().pinned
+ }
+ fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut &'b T> {
+ self.project().pinned
+ }
+ fn get_pin_ref_elided(self: Pin<&Self>) -> Pin<&&'b T> {
+ self.project_ref().pinned
+ }
+ fn get_pin_mut_elided(self: Pin<&mut Self>) -> Pin<&mut &'b T> {
+ self.project().pinned
+ }
+ }
+
+ impl<T, U> Enum<T, U> {
+ fn get_pin_ref<'a>(self: Pin<&'a Self>) -> Pin<&'a T> {
+ match self.project_ref() {
+ EnumProjRef::V { pinned, .. } => pinned,
+ }
+ }
+ fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut T> {
+ match self.project() {
+ EnumProj::V { pinned, .. } => pinned,
+ }
+ }
+ fn get_pin_ref_elided(self: Pin<&Self>) -> Pin<&T> {
+ match self.project_ref() {
+ EnumProjRef::V { pinned, .. } => pinned,
+ }
+ }
+ fn get_pin_mut_elided(self: Pin<&mut Self>) -> Pin<&mut T> {
+ match self.project() {
+ EnumProj::V { pinned, .. } => pinned,
+ }
+ }
+ }
+}
+
+mod visibility {
+ use pin_project::pin_project;
+
+ #[pin_project(project_replace)]
+ pub(crate) struct S {
+ pub f: u8,
+ }
+}
+
+#[test]
+fn visibility() {
+ let mut x = visibility::S { f: 0 };
+ let x = Pin::new(&mut x);
+ let y = x.as_ref().project_ref();
+ let _: &u8 = y.f;
+ let y = x.project();
+ let _: &mut u8 = y.f;
+}
+
+#[test]
+fn trivial_bounds() {
+ #[pin_project(project_replace)]
+ pub struct NoGenerics {
+ #[pin]
+ f: PhantomPinned,
+ }
+
+ assert_not_unpin!(NoGenerics);
+}
+
+#[test]
+fn dst() {
+ #[pin_project]
+ struct Struct1<T: ?Sized> {
+ f: T,
+ }
+
+ let mut x = Struct1 { f: 0_u8 };
+ let x: Pin<&mut Struct1<dyn core::fmt::Debug>> = Pin::new(&mut x as _);
+ let _: &mut (dyn core::fmt::Debug) = x.project().f;
+
+ #[pin_project]
+ struct Struct2<T: ?Sized> {
+ #[pin]
+ f: T,
+ }
+
+ let mut x = Struct2 { f: 0_u8 };
+ let x: Pin<&mut Struct2<dyn core::fmt::Debug + Unpin>> = Pin::new(&mut x as _);
+ let _: Pin<&mut (dyn core::fmt::Debug + Unpin)> = x.project().f;
+
+ #[allow(explicit_outlives_requirements)] // https://github.com/rust-lang/rust/issues/60993
+ #[pin_project]
+ struct Struct3<T>
+ where
+ T: ?Sized,
+ {
+ f: T,
+ }
+
+ #[allow(explicit_outlives_requirements)] // https://github.com/rust-lang/rust/issues/60993
+ #[pin_project]
+ struct Struct4<T>
+ where
+ T: ?Sized,
+ {
+ #[pin]
+ f: T,
+ }
+
+ #[pin_project(UnsafeUnpin)]
+ struct Struct5<T: ?Sized> {
+ f: T,
+ }
+
+ #[pin_project(UnsafeUnpin)]
+ struct Struct6<T: ?Sized> {
+ #[pin]
+ f: T,
+ }
+
+ #[pin_project(PinnedDrop)]
+ struct Struct7<T: ?Sized> {
+ f: T,
+ }
+
+ #[pinned_drop]
+ impl<T: ?Sized> PinnedDrop for Struct7<T> {
+ fn drop(self: Pin<&mut Self>) {}
+ }
+
+ #[pin_project(PinnedDrop)]
+ struct Struct8<T: ?Sized> {
+ #[pin]
+ f: T,
+ }
+
+ #[pinned_drop]
+ impl<T: ?Sized> PinnedDrop for Struct8<T> {
+ fn drop(self: Pin<&mut Self>) {}
+ }
+
+ #[pin_project(!Unpin)]
+ struct Struct9<T: ?Sized> {
+ f: T,
+ }
+
+ #[pin_project(!Unpin)]
+ struct Struct10<T: ?Sized> {
+ #[pin]
+ f: T,
+ }
+
+ #[pin_project]
+ struct Struct11<'a, T: ?Sized, U: ?Sized> {
+ f1: &'a mut T,
+ f2: U,
+ }
+
+ #[pin_project]
+ struct TupleStruct1<T: ?Sized>(T);
+
+ #[pin_project]
+ struct TupleStruct2<T: ?Sized>(#[pin] T);
+
+ #[allow(explicit_outlives_requirements)] // https://github.com/rust-lang/rust/issues/60993
+ #[pin_project]
+ struct TupleStruct3<T>(T)
+ where
+ T: ?Sized;
+
+ #[allow(explicit_outlives_requirements)] // https://github.com/rust-lang/rust/issues/60993
+ #[pin_project]
+ struct TupleStruct4<T>(#[pin] T)
+ where
+ T: ?Sized;
+
+ #[pin_project(UnsafeUnpin)]
+ struct TupleStruct5<T: ?Sized>(T);
+
+ #[pin_project(UnsafeUnpin)]
+ struct TupleStruct6<T: ?Sized>(#[pin] T);
+
+ #[pin_project(PinnedDrop)]
+ struct TupleStruct7<T: ?Sized>(T);
+
+ #[pinned_drop]
+ impl<T: ?Sized> PinnedDrop for TupleStruct7<T> {
+ fn drop(self: Pin<&mut Self>) {}
+ }
+
+ #[pin_project(PinnedDrop)]
+ struct TupleStruct8<T: ?Sized>(#[pin] T);
+
+ #[pinned_drop]
+ impl<T: ?Sized> PinnedDrop for TupleStruct8<T> {
+ fn drop(self: Pin<&mut Self>) {}
+ }
+
+ #[pin_project(!Unpin)]
+ struct TupleStruct9<T: ?Sized>(T);
+
+ #[pin_project(!Unpin)]
+ struct TupleStruct10<T: ?Sized>(#[pin] T);
+
+ #[pin_project]
+ struct TupleStruct11<'a, T: ?Sized, U: ?Sized>(&'a mut T, U);
+}
+
+#[test]
+fn dyn_type() {
+ #[pin_project]
+ struct Struct1 {
+ f: dyn core::fmt::Debug,
+ }
+
+ #[pin_project]
+ struct Struct2 {
+ #[pin]
+ f: dyn core::fmt::Debug,
+ }
+
+ #[pin_project]
+ struct Struct3 {
+ f: dyn core::fmt::Debug + Send,
+ }
+
+ #[pin_project]
+ struct Struct4 {
+ #[pin]
+ f: dyn core::fmt::Debug + Send,
+ }
+
+ #[pin_project]
+ struct TupleStruct1(dyn core::fmt::Debug);
+
+ #[pin_project]
+ struct TupleStruct2(#[pin] dyn core::fmt::Debug);
+
+ #[pin_project]
+ struct TupleStruct3(dyn core::fmt::Debug + Send);
+
+ #[pin_project]
+ struct TupleStruct4(#[pin] dyn core::fmt::Debug + Send);
+}
+
+#[allow(clippy::trailing_empty_array)] // TODO: how do we handle this? Should propagate #[repr(...)] to ProjectionOwned?
+#[test]
+fn parse_self() {
+ macro_rules! mac {
+ ($($tt:tt)*) => {
+ $($tt)*
+ };
+ }
+
+ pub trait Trait {
+ type Assoc;
+ }
+
+ #[allow(clippy::type_repetition_in_bounds)]
+ #[pin_project(project_replace)]
+ pub struct Generics<T: Trait<Assoc = Self>>
+ where
+ Self: Trait<Assoc = Self>,
+ <Self as Trait>::Assoc: Sized,
+ mac!(Self): Trait<Assoc = mac!(Self)>,
+ {
+ _f: T,
+ }
+
+ impl<T: Trait<Assoc = Self>> Trait for Generics<T> {
+ type Assoc = Self;
+ }
+
+ #[pin_project(project_replace)]
+ pub struct Struct {
+ _f1: Box<Self>,
+ _f2: Box<<Self as Trait>::Assoc>,
+ _f3: Box<mac!(Self)>,
+ _f4: [(); Self::ASSOC],
+ _f5: [(); Self::assoc()],
+ _f6: [(); mac!(Self::assoc())],
+ }
+
+ impl Struct {
+ const ASSOC: usize = 1;
+ const fn assoc() -> usize {
+ 0
+ }
+ }
+
+ impl Trait for Struct {
+ type Assoc = Self;
+ }
+
+ #[pin_project(project_replace)]
+ struct Tuple(
+ Box<Self>,
+ Box<<Self as Trait>::Assoc>,
+ Box<mac!(Self)>,
+ [(); Self::ASSOC],
+ [(); Self::assoc()],
+ [(); mac!(Self::assoc())],
+ );
+
+ impl Tuple {
+ const ASSOC: usize = 1;
+ const fn assoc() -> usize {
+ 0
+ }
+ }
+
+ impl Trait for Tuple {
+ type Assoc = Self;
+ }
+
+ #[pin_project(project = EnumProj, project_ref = EnumProjRef, project_replace = EnumProjOwn)]
+ enum Enum {
+ Struct {
+ _f1: Box<Self>,
+ _f2: Box<<Self as Trait>::Assoc>,
+ _f3: Box<mac!(Self)>,
+ _f4: [(); Self::ASSOC],
+ _f5: [(); Self::assoc()],
+ _f6: [(); mac!(Self::assoc())],
+ },
+ Tuple(
+ Box<Self>,
+ Box<<Self as Trait>::Assoc>,
+ Box<mac!(Self)>,
+ [(); Self::ASSOC],
+ [(); Self::assoc()],
+ [(); mac!(Self::assoc())],
+ ),
+ }
+
+ impl Enum {
+ const ASSOC: usize = 1;
+ const fn assoc() -> usize {
+ 0
+ }
+ }
+
+ impl Trait for Enum {
+ type Assoc = Self;
+ }
+}
+
+#[test]
+fn no_infer_outlives() {
+ trait Trait<X> {
+ type Y;
+ }
+
+ struct Struct1<A>(A);
+
+ impl<X, T> Trait<X> for Struct1<T> {
+ type Y = Option<T>;
+ }
+
+ #[pin_project(project_replace)]
+ struct Struct2<A, B> {
+ _f: <Struct1<A> as Trait<B>>::Y,
+ }
+}
+
+// https://github.com/rust-lang/rust/issues/47949
+// https://github.com/taiki-e/pin-project/pull/194#discussion_r419098111
+#[allow(clippy::many_single_char_names)]
+#[test]
+fn project_replace_panic() {
+ #[pin_project(project_replace)]
+ struct S<T, U> {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+ }
+
+ struct D<'a>(&'a mut bool, bool);
+ impl Drop for D<'_> {
+ fn drop(&mut self) {
+ *self.0 = true;
+ if self.1 {
+ panic!();
+ }
+ }
+ }
+
+ let (mut a, mut b, mut c, mut d) = (false, false, false, false);
+ let res = panic::catch_unwind(panic::AssertUnwindSafe(|| {
+ let mut x = S { pinned: D(&mut a, true), unpinned: D(&mut b, false) };
+ let _y = Pin::new(&mut x)
+ .project_replace(S { pinned: D(&mut c, false), unpinned: D(&mut d, false) });
+ // Previous `x.pinned` was dropped and panicked when `project_replace` is
+ // called, so this is unreachable.
+ unreachable!();
+ }));
+ assert!(res.is_err());
+ assert!(a);
+ assert!(b);
+ assert!(c);
+ assert!(d);
+
+ let (mut a, mut b, mut c, mut d) = (false, false, false, false);
+ let res = panic::catch_unwind(panic::AssertUnwindSafe(|| {
+ let mut x = S { pinned: D(&mut a, false), unpinned: D(&mut b, true) };
+ {
+ let _y = Pin::new(&mut x)
+ .project_replace(S { pinned: D(&mut c, false), unpinned: D(&mut d, false) });
+ // `_y` (previous `x.unpinned`) live to the end of this scope, so
+ // this is not unreachable.
+ // unreachable!();
+ }
+ unreachable!();
+ }));
+ assert!(res.is_err());
+ assert!(a);
+ assert!(b);
+ assert!(c);
+ assert!(d);
+}
diff --git a/third_party/rust/pin-project/tests/pinned_drop.rs b/third_party/rust/pin-project/tests/pinned_drop.rs
new file mode 100644
index 0000000000..99273c4234
--- /dev/null
+++ b/third_party/rust/pin-project/tests/pinned_drop.rs
@@ -0,0 +1,284 @@
+#![warn(rust_2018_idioms, single_use_lifetimes)]
+
+use std::pin::Pin;
+
+use pin_project::{pin_project, pinned_drop};
+
+#[test]
+fn safe_project() {
+ #[pin_project(PinnedDrop)]
+ pub struct Struct<'a> {
+ was_dropped: &'a mut bool,
+ #[pin]
+ field: u8,
+ }
+
+ #[pinned_drop]
+ impl PinnedDrop for Struct<'_> {
+ fn drop(self: Pin<&mut Self>) {
+ **self.project().was_dropped = true;
+ }
+ }
+
+ let mut was_dropped = false;
+ drop(Struct { was_dropped: &mut was_dropped, field: 42 });
+ assert!(was_dropped);
+}
+
+#[test]
+fn self_call() {
+ #[pin_project(PinnedDrop)]
+ pub struct S<T>(T);
+
+ trait Trait {
+ fn self_ref(&self) {}
+ fn self_pin_ref(self: Pin<&Self>) {}
+ fn self_mut(&mut self) {}
+ fn self_pin_mut(self: Pin<&mut Self>) {}
+ fn assoc_fn(_this: Pin<&mut Self>) {}
+ }
+
+ impl<T> Trait for S<T> {}
+
+ #[pinned_drop]
+ impl<T> PinnedDrop for S<T> {
+ fn drop(mut self: Pin<&mut Self>) {
+ self.self_ref();
+ self.as_ref().self_pin_ref();
+ self.self_mut();
+ self.as_mut().self_pin_mut();
+ Self::assoc_fn(self.as_mut());
+ <Self>::assoc_fn(self.as_mut());
+ }
+ }
+}
+
+#[test]
+fn self_ty() {
+ #[pin_project(PinnedDrop)]
+ pub struct Struct {
+ pub f: (),
+ }
+
+ #[pinned_drop]
+ impl PinnedDrop for Struct {
+ #[allow(irrefutable_let_patterns)]
+ #[allow(clippy::match_single_binding)]
+ fn drop(mut self: Pin<&mut Self>) {
+ // expr
+ let _: Self = Self { f: () };
+
+ // pat
+ match *self {
+ Self { f: () } => {}
+ }
+ if let Self { f: () } = *self {}
+ let Self { f: () } = *self;
+ }
+ }
+
+ #[pin_project(PinnedDrop)]
+ pub struct TupleStruct(());
+
+ #[pinned_drop]
+ impl PinnedDrop for TupleStruct {
+ #[allow(irrefutable_let_patterns)]
+ fn drop(mut self: Pin<&mut Self>) {
+ // expr
+ let _: Self = Self(());
+
+ // pat
+ match *self {
+ Self(_) => {}
+ }
+ if let Self(_) = *self {}
+ let Self(_) = *self;
+ }
+ }
+
+ #[pin_project(PinnedDrop, project = EnumProj, project_ref = EnumProjRef)]
+ pub enum Enum {
+ Struct { f: () },
+ Tuple(()),
+ Unit,
+ }
+
+ #[pinned_drop]
+ impl PinnedDrop for Enum {
+ fn drop(mut self: Pin<&mut Self>) {
+ // expr
+ let _: Self = Self::Struct { f: () };
+ let _: Self = Self::Tuple(());
+ let _: Self = Self::Unit;
+
+ // pat
+ match *self {
+ Self::Struct { f: () } => {}
+ Self::Tuple(_) => {}
+ Self::Unit => {}
+ }
+ if let Self::Struct { f: () } = *self {}
+ if let Self::Tuple(_) = *self {}
+ if let Self::Unit = *self {}
+ }
+ }
+}
+
+#[test]
+fn self_inside_macro_containing_fn() {
+ macro_rules! mac {
+ ($($tt:tt)*) => {
+ $($tt)*
+ };
+ }
+
+ #[pin_project(PinnedDrop)]
+ pub struct S(());
+
+ #[pinned_drop]
+ impl PinnedDrop for S {
+ fn drop(self: Pin<&mut Self>) {
+ mac!({
+ impl S {
+ pub fn _f(self) -> Self {
+ self
+ }
+ }
+ });
+ }
+ }
+}
+
+// See also `ui/pinned_drop/self.rs`.
+#[rustversion::since(1.40)] // https://github.com/rust-lang/rust/pull/64690
+#[test]
+fn self_inside_macro_def() {
+ #[pin_project(PinnedDrop)]
+ pub struct S(());
+
+ #[pinned_drop]
+ impl PinnedDrop for S {
+ fn drop(self: Pin<&mut Self>) {
+ macro_rules! mac {
+ () => {{
+ let _ = self;
+ let _ = Self(());
+ }};
+ }
+ mac!();
+ }
+ }
+}
+
+#[test]
+fn self_arg_inside_macro_call() {
+ #[pin_project(PinnedDrop)]
+ struct Struct {
+ f: (),
+ }
+
+ #[pinned_drop]
+ impl PinnedDrop for Struct {
+ fn drop(self: Pin<&mut Self>) {
+ let _: Vec<_> = vec![self.f];
+ }
+ }
+}
+
+#[test]
+fn self_ty_inside_macro_call() {
+ macro_rules! mac {
+ ($($tt:tt)*) => {
+ $($tt)*
+ };
+ }
+
+ #[pin_project(PinnedDrop)]
+ pub struct Struct<T: Send>
+ where
+ mac!(Self): Send,
+ {
+ _f: T,
+ }
+
+ impl<T: Send> Struct<T> {
+ const ASSOC1: usize = 1;
+ fn assoc1() {}
+ }
+
+ trait Trait {
+ type Assoc2;
+ const ASSOC2: usize;
+ fn assoc2();
+ }
+
+ impl<T: Send> Trait for Struct<T> {
+ type Assoc2 = u8;
+ const ASSOC2: usize = 2;
+ fn assoc2() {}
+ }
+
+ #[pinned_drop]
+ impl<T: Send> PinnedDrop for Struct<T>
+ where
+ mac!(Self): Send,
+ {
+ #[allow(path_statements)]
+ #[allow(clippy::no_effect)]
+ fn drop(self: Pin<&mut Self>) {
+ // inherent items
+ mac!(Self::ASSOC1;);
+ mac!(<Self>::ASSOC1;);
+ mac!(Self::assoc1(););
+ mac!(<Self>::assoc1(););
+
+ // trait items
+ mac!(let _: <Self as Trait>::Assoc2;);
+ mac!(Self::ASSOC2;);
+ mac!(<Self>::ASSOC2;);
+ mac!(<Self as Trait>::ASSOC2;);
+ mac!(Self::assoc2(););
+ mac!(<Self>::assoc2(););
+ mac!(<Self as Trait>::assoc2(););
+ }
+ }
+}
+
+#[test]
+fn inside_macro() {
+ #[pin_project(PinnedDrop)]
+ struct S(());
+
+ macro_rules! mac {
+ ($expr:expr) => {
+ #[pinned_drop]
+ impl PinnedDrop for S {
+ fn drop(self: Pin<&mut Self>) {
+ let _ = $expr;
+ }
+ }
+ };
+ }
+
+ mac!(1);
+}
+
+pub mod self_path {
+ use super::*;
+
+ #[pin_project(PinnedDrop)]
+ pub struct S<T: Unpin>(T);
+
+ fn f() {}
+
+ #[pinned_drop]
+ impl<T: Unpin> PinnedDrop for self::S<T> {
+ fn drop(mut self: Pin<&mut Self>) {
+ self::f();
+ let _: self::S<()> = self::S(());
+ let _: self::S<Pin<&mut Self>> = self::S(self.as_mut());
+ let self::S(()) = self::S(());
+ let self::S(&mut Self(_)) = self::S(&mut *self);
+ }
+ }
+}
diff --git a/third_party/rust/pin-project/tests/proper_unpin.rs b/third_party/rust/pin-project/tests/proper_unpin.rs
new file mode 100644
index 0000000000..0ba3ce3b5d
--- /dev/null
+++ b/third_party/rust/pin-project/tests/proper_unpin.rs
@@ -0,0 +1,153 @@
+#![warn(rust_2018_idioms, single_use_lifetimes)]
+#![allow(dead_code)]
+
+#[macro_use]
+mod auxiliary;
+
+pub mod default {
+ use std::marker::PhantomPinned;
+
+ use pin_project::pin_project;
+
+ struct Inner<T> {
+ f: T,
+ }
+
+ assert_unpin!(Inner<()>);
+ assert_not_unpin!(Inner<PhantomPinned>);
+
+ #[pin_project]
+ struct Struct<T, U> {
+ #[pin]
+ f1: Inner<T>,
+ f2: U,
+ }
+
+ assert_unpin!(Struct<(), ()>);
+ assert_unpin!(Struct<(), PhantomPinned>);
+ assert_not_unpin!(Struct<PhantomPinned, ()>);
+ assert_not_unpin!(Struct<PhantomPinned, PhantomPinned>);
+
+ #[pin_project(project = EnumProj, project_ref = EnumProjRef)]
+ enum Enum<T, U> {
+ V1 {
+ #[pin]
+ f1: Inner<T>,
+ f2: U,
+ },
+ }
+
+ assert_unpin!(Enum<(), ()>);
+ assert_unpin!(Enum<(), PhantomPinned>);
+ assert_not_unpin!(Enum<PhantomPinned, ()>);
+ assert_not_unpin!(Enum<PhantomPinned, PhantomPinned>);
+
+ #[pin_project]
+ struct TrivialBounds {
+ #[pin]
+ f: PhantomPinned,
+ }
+
+ assert_not_unpin!(TrivialBounds);
+
+ #[pin_project]
+ struct PinRef<'a, T, U> {
+ #[pin]
+ f1: &'a mut Inner<T>,
+ f2: U,
+ }
+
+ assert_unpin!(PinRef<'_, PhantomPinned, PhantomPinned>);
+}
+
+pub mod cfg {
+ use std::marker::PhantomPinned;
+
+ use pin_project::pin_project;
+
+ #[pin_project]
+ struct Foo<T> {
+ #[cfg(any())]
+ #[pin]
+ f: T,
+ #[cfg(not(any()))]
+ f: T,
+ }
+
+ assert_unpin!(Foo<PhantomPinned>);
+
+ #[pin_project]
+ struct Bar<T> {
+ #[cfg(any())]
+ f: T,
+ #[cfg(not(any()))]
+ #[pin]
+ f: T,
+ }
+
+ assert_unpin!(Bar<()>);
+ assert_not_unpin!(Bar<PhantomPinned>);
+}
+
+pub mod cfg_attr {
+ use std::marker::PhantomPinned;
+
+ use pin_project::pin_project;
+
+ #[cfg_attr(any(), pin_project)]
+ struct Foo<T> {
+ f: T,
+ }
+
+ assert_unpin!(Foo<()>);
+ assert_not_unpin!(Foo<PhantomPinned>);
+
+ #[cfg_attr(not(any()), pin_project)]
+ struct Bar<T> {
+ #[cfg_attr(not(any()), pin)]
+ f: T,
+ }
+
+ assert_unpin!(Bar<()>);
+ assert_not_unpin!(Bar<PhantomPinned>);
+}
+
+// pin_project(!Unpin)
+pub mod not_unpin {
+ use std::marker::PhantomPinned;
+
+ use pin_project::pin_project;
+
+ struct Inner<T> {
+ f: T,
+ }
+
+ #[pin_project(!Unpin)]
+ struct Struct<T, U> {
+ #[pin]
+ inner: Inner<T>,
+ other: U,
+ }
+
+ assert_not_unpin!(Struct<(), ()>);
+ assert_not_unpin!(Struct<(), PhantomPinned>);
+ assert_not_unpin!(Struct<PhantomPinned, ()>);
+ assert_not_unpin!(Struct<PhantomPinned, PhantomPinned>);
+
+ #[pin_project(!Unpin)]
+ struct TrivialBounds {
+ #[pin]
+ f: PhantomPinned,
+ }
+
+ assert_not_unpin!(TrivialBounds);
+
+ #[pin_project(!Unpin)]
+ struct PinRef<'a, T, U> {
+ #[pin]
+ inner: &'a mut Inner<T>,
+ other: U,
+ }
+
+ assert_not_unpin!(PinRef<'_, (), ()>);
+}
diff --git a/third_party/rust/pin-project/tests/repr_packed.rs b/third_party/rust/pin-project/tests/repr_packed.rs
new file mode 100644
index 0000000000..be7cab975f
--- /dev/null
+++ b/third_party/rust/pin-project/tests/repr_packed.rs
@@ -0,0 +1,52 @@
+#![warn(rust_2018_idioms, single_use_lifetimes)]
+// unaligned_references did not exist in older compilers and safe_packed_borrows was removed in the latest compilers.
+// https://github.com/rust-lang/rust/pull/82525
+#![allow(unknown_lints, renamed_and_removed_lints)]
+#![forbid(unaligned_references, safe_packed_borrows)]
+
+use std::cell::Cell;
+
+// Ensure that the compiler doesn't copy the fields
+// of #[repr(packed)] types during drop, if the field has alignment 1
+// (that is, any reference to the field is guaranteed to have proper alignment)
+// We are currently unable to statically prevent the usage of #[pin_project]
+// on #[repr(packed)] types composed entirely of fields of alignment 1.
+// This shouldn't lead to undefined behavior, as long as the compiler doesn't
+// try to move the field anyway during drop.
+//
+// This tests validates that the compiler is doing what we expect.
+#[test]
+fn weird_repr_packed() {
+ // We keep track of the field address during
+ // drop using a thread local, to avoid changing
+ // the layout of our #[repr(packed)] type.
+ thread_local! {
+ static FIELD_ADDR: Cell<usize> = Cell::new(0);
+ }
+
+ #[repr(packed)]
+ struct Struct {
+ field: u8,
+ }
+
+ impl Drop for Struct {
+ fn drop(&mut self) {
+ FIELD_ADDR.with(|f| {
+ f.set(&self.field as *const u8 as usize);
+ });
+ }
+ }
+
+ #[allow(clippy::let_and_return)]
+ let field_addr = {
+ // We let this field drop by going out of scope,
+ // rather than explicitly calling drop(foo).
+ // Calling drop(foo) causes 'foo' to be moved
+ // into the 'drop' function, resulting in a different
+ // address.
+ let x = Struct { field: 27 };
+ let field_addr = &x.field as *const u8 as usize;
+ field_addr
+ };
+ assert_eq!(field_addr, FIELD_ADDR.with(Cell::get));
+}
diff --git a/third_party/rust/pin-project/tests/ui/cfg/cfg_attr-resolve.rs b/third_party/rust/pin-project/tests/ui/cfg/cfg_attr-resolve.rs
new file mode 100644
index 0000000000..e36cc9593a
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/cfg/cfg_attr-resolve.rs
@@ -0,0 +1,11 @@
+use std::pin::Pin;
+
+#[cfg_attr(any(), pin_project::pin_project)]
+struct Foo<T> {
+ f: T,
+}
+
+fn main() {
+ let mut x = Foo { f: 0_u8 };
+ let _ = Pin::new(&mut x).project(); //~ ERROR E0599
+}
diff --git a/third_party/rust/pin-project/tests/ui/cfg/cfg_attr-resolve.stderr b/third_party/rust/pin-project/tests/ui/cfg/cfg_attr-resolve.stderr
new file mode 100644
index 0000000000..0393c143fe
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/cfg/cfg_attr-resolve.stderr
@@ -0,0 +1,5 @@
+error[E0599]: no method named `project` found for struct `Pin<&mut Foo<u8>>` in the current scope
+ --> tests/ui/cfg/cfg_attr-resolve.rs:10:30
+ |
+10 | let _ = Pin::new(&mut x).project(); //~ ERROR E0599
+ | ^^^^^^^ method not found in `Pin<&mut Foo<u8>>`
diff --git a/third_party/rust/pin-project/tests/ui/cfg/cfg_attr-type-mismatch.rs b/third_party/rust/pin-project/tests/ui/cfg/cfg_attr-type-mismatch.rs
new file mode 100644
index 0000000000..1b9664b544
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/cfg/cfg_attr-type-mismatch.rs
@@ -0,0 +1,25 @@
+use std::pin::Pin;
+
+use pin_project::pin_project;
+
+#[cfg_attr(not(any()), pin_project)]
+struct Foo<T> {
+ #[cfg_attr(any(), pin)]
+ f: T,
+}
+
+#[cfg_attr(not(any()), pin_project)]
+struct Bar<T> {
+ #[cfg_attr(not(any()), pin)]
+ f: T,
+}
+
+fn main() {
+ let mut x = Foo { f: 0_u8 };
+ let x = Pin::new(&mut x).project();
+ let _: Pin<&mut u8> = x.f; //~ ERROR E0308
+
+ let mut x = Bar { f: 0_u8 };
+ let x = Pin::new(&mut x).project();
+ let _: &mut u8 = x.f; //~ ERROR E0308
+}
diff --git a/third_party/rust/pin-project/tests/ui/cfg/cfg_attr-type-mismatch.stderr b/third_party/rust/pin-project/tests/ui/cfg/cfg_attr-type-mismatch.stderr
new file mode 100644
index 0000000000..081504c53f
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/cfg/cfg_attr-type-mismatch.stderr
@@ -0,0 +1,25 @@
+error[E0308]: mismatched types
+ --> tests/ui/cfg/cfg_attr-type-mismatch.rs:20:27
+ |
+20 | let _: Pin<&mut u8> = x.f; //~ ERROR E0308
+ | ------------ ^^^ expected `Pin<&mut u8>`, found `&mut u8`
+ | |
+ | expected due to this
+ |
+ = note: expected struct `Pin<&mut u8>`
+ found mutable reference `&mut u8`
+
+error[E0308]: mismatched types
+ --> tests/ui/cfg/cfg_attr-type-mismatch.rs:24:22
+ |
+24 | let _: &mut u8 = x.f; //~ ERROR E0308
+ | ------- ^^^ expected `&mut u8`, found `Pin<&mut u8>`
+ | |
+ | expected due to this
+ |
+ = note: expected mutable reference `&mut u8`
+ found struct `Pin<&mut u8>`
+help: consider mutably borrowing here
+ |
+24 | let _: &mut u8 = &mut x.f; //~ ERROR E0308
+ | ++++
diff --git a/third_party/rust/pin-project/tests/ui/cfg/packed_sneaky-span-issue-1.rs b/third_party/rust/pin-project/tests/ui/cfg/packed_sneaky-span-issue-1.rs
new file mode 100644
index 0000000000..7e19952b6d
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/cfg/packed_sneaky-span-issue-1.rs
@@ -0,0 +1,15 @@
+use auxiliary_macro::hidden_repr;
+use pin_project::pin_project;
+
+#[pin_project]
+#[hidden_repr(packed)] //~ ERROR may not be used on #[repr(packed)] types
+struct S {
+ #[cfg(not(any()))]
+ #[pin]
+ f: u32,
+ #[cfg(any())]
+ #[pin]
+ f: u8,
+}
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/ui/cfg/packed_sneaky-span-issue-1.stderr b/third_party/rust/pin-project/tests/ui/cfg/packed_sneaky-span-issue-1.stderr
new file mode 100644
index 0000000000..4f3acc3494
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/cfg/packed_sneaky-span-issue-1.stderr
@@ -0,0 +1,5 @@
+error: #[pin_project] attribute may not be used on #[repr(packed)] types
+ --> tests/ui/cfg/packed_sneaky-span-issue-1.rs:5:15
+ |
+5 | #[hidden_repr(packed)] //~ ERROR may not be used on #[repr(packed)] types
+ | ^^^^^^
diff --git a/third_party/rust/pin-project/tests/ui/cfg/packed_sneaky-span-issue-2.rs b/third_party/rust/pin-project/tests/ui/cfg/packed_sneaky-span-issue-2.rs
new file mode 100644
index 0000000000..fcea76bab8
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/cfg/packed_sneaky-span-issue-2.rs
@@ -0,0 +1,15 @@
+use auxiliary_macro::hidden_repr;
+use pin_project::pin_project;
+
+#[pin_project]
+#[hidden_repr(packed)] //~ ERROR may not be used on #[repr(packed)] types
+struct S {
+ #[cfg(any())]
+ #[pin]
+ f: u32,
+ #[cfg(not(any()))]
+ #[pin]
+ f: u8,
+}
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/ui/cfg/packed_sneaky-span-issue-2.stderr b/third_party/rust/pin-project/tests/ui/cfg/packed_sneaky-span-issue-2.stderr
new file mode 100644
index 0000000000..cc2795ac68
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/cfg/packed_sneaky-span-issue-2.stderr
@@ -0,0 +1,5 @@
+error: #[pin_project] attribute may not be used on #[repr(packed)] types
+ --> tests/ui/cfg/packed_sneaky-span-issue-2.rs:5:15
+ |
+5 | #[hidden_repr(packed)] //~ ERROR may not be used on #[repr(packed)] types
+ | ^^^^^^
diff --git a/third_party/rust/pin-project/tests/ui/cfg/packed_sneaky.rs b/third_party/rust/pin-project/tests/ui/cfg/packed_sneaky.rs
new file mode 100644
index 0000000000..0b01dc90e2
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/cfg/packed_sneaky.rs
@@ -0,0 +1,12 @@
+use auxiliary_macro::hidden_repr_cfg_not_any;
+use pin_project::pin_project;
+
+// `#[hidden_repr_cfg_not_any(packed)]` generates `#[cfg_attr(not(any()), repr(packed))]`.
+#[pin_project]
+#[hidden_repr_cfg_not_any(packed)] //~ ERROR may not be used on #[repr(packed)] types
+struct S {
+ #[pin]
+ f: u32,
+}
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/ui/cfg/packed_sneaky.stderr b/third_party/rust/pin-project/tests/ui/cfg/packed_sneaky.stderr
new file mode 100644
index 0000000000..a54c2ec2d2
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/cfg/packed_sneaky.stderr
@@ -0,0 +1,5 @@
+error: #[pin_project] attribute may not be used on #[repr(packed)] types
+ --> tests/ui/cfg/packed_sneaky.rs:6:27
+ |
+6 | #[hidden_repr_cfg_not_any(packed)] //~ ERROR may not be used on #[repr(packed)] types
+ | ^^^^^^
diff --git a/third_party/rust/pin-project/tests/ui/cfg/unsupported.rs b/third_party/rust/pin-project/tests/ui/cfg/unsupported.rs
new file mode 100644
index 0000000000..b950d4b828
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/cfg/unsupported.rs
@@ -0,0 +1,11 @@
+use pin_project::pin_project;
+
+#[pin_project]
+struct S {
+ //~^ ERROR may not be used on structs with zero fields
+ #[cfg(any())]
+ #[pin]
+ f: u8,
+}
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/ui/cfg/unsupported.stderr b/third_party/rust/pin-project/tests/ui/cfg/unsupported.stderr
new file mode 100644
index 0000000000..e1c871c011
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/cfg/unsupported.stderr
@@ -0,0 +1,11 @@
+error: #[pin_project] attribute may not be used on structs with zero fields
+ --> tests/ui/cfg/unsupported.rs:4:10
+ |
+4 | struct S {
+ | __________^
+5 | | //~^ ERROR may not be used on structs with zero fields
+6 | | #[cfg(any())]
+7 | | #[pin]
+8 | | f: u8,
+9 | | }
+ | |_^
diff --git a/third_party/rust/pin-project/tests/ui/not_unpin/conflict-unpin.rs b/third_party/rust/pin-project/tests/ui/not_unpin/conflict-unpin.rs
new file mode 100644
index 0000000000..8985f37103
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/not_unpin/conflict-unpin.rs
@@ -0,0 +1,30 @@
+use pin_project::pin_project;
+
+#[pin_project(!Unpin)] //~ ERROR E0119
+struct Foo<T, U> {
+ #[pin]
+ f1: T,
+ f2: U,
+}
+
+impl<T, U> Unpin for Foo<T, U> where T: Unpin {}
+
+#[pin_project(!Unpin)] //~ ERROR E0119
+struct Bar<T, U> {
+ #[pin]
+ f1: T,
+ f2: U,
+}
+
+impl<T, U> Unpin for Bar<T, U> {}
+
+#[pin_project(!Unpin)] //~ ERROR E0119
+struct Baz<T, U> {
+ #[pin]
+ f1: T,
+ f2: U,
+}
+
+impl<T: Unpin, U: Unpin> Unpin for Baz<T, U> {}
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/ui/not_unpin/conflict-unpin.stderr b/third_party/rust/pin-project/tests/ui/not_unpin/conflict-unpin.stderr
new file mode 100644
index 0000000000..4bd72bbdbf
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/not_unpin/conflict-unpin.stderr
@@ -0,0 +1,26 @@
+error[E0119]: conflicting implementations of trait `Unpin` for type `Foo<_, _>`
+ --> tests/ui/not_unpin/conflict-unpin.rs:3:15
+ |
+3 | #[pin_project(!Unpin)] //~ ERROR E0119
+ | ^^^^^^ conflicting implementation for `Foo<_, _>`
+...
+10 | impl<T, U> Unpin for Foo<T, U> where T: Unpin {}
+ | ------------------------------ first implementation here
+
+error[E0119]: conflicting implementations of trait `Unpin` for type `Bar<_, _>`
+ --> tests/ui/not_unpin/conflict-unpin.rs:12:15
+ |
+12 | #[pin_project(!Unpin)] //~ ERROR E0119
+ | ^^^^^^ conflicting implementation for `Bar<_, _>`
+...
+19 | impl<T, U> Unpin for Bar<T, U> {}
+ | ------------------------------ first implementation here
+
+error[E0119]: conflicting implementations of trait `Unpin` for type `Baz<_, _>`
+ --> tests/ui/not_unpin/conflict-unpin.rs:21:15
+ |
+21 | #[pin_project(!Unpin)] //~ ERROR E0119
+ | ^^^^^^ conflicting implementation for `Baz<_, _>`
+...
+28 | impl<T: Unpin, U: Unpin> Unpin for Baz<T, U> {}
+ | -------------------------------------------- first implementation here
diff --git a/third_party/rust/pin-project/tests/ui/not_unpin/impl-unsafe-unpin.rs b/third_party/rust/pin-project/tests/ui/not_unpin/impl-unsafe-unpin.rs
new file mode 100644
index 0000000000..2c078c71ff
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/not_unpin/impl-unsafe-unpin.rs
@@ -0,0 +1,30 @@
+use pin_project::{pin_project, UnsafeUnpin};
+
+#[pin_project(!Unpin)] //~ ERROR E0119
+struct Foo<T, U> {
+ #[pin]
+ f1: T,
+ f2: U,
+}
+
+unsafe impl<T, U> UnsafeUnpin for Foo<T, U> where T: Unpin {}
+
+#[pin_project(!Unpin)] //~ ERROR E0119
+struct Bar<T, U> {
+ #[pin]
+ f1: T,
+ f2: U,
+}
+
+unsafe impl<T, U> UnsafeUnpin for Bar<T, U> {}
+
+#[pin_project(!Unpin)] //~ ERROR E0119
+struct Baz<T, U> {
+ #[pin]
+ f1: T,
+ f2: U,
+}
+
+unsafe impl<T: Unpin, U: Unpin> UnsafeUnpin for Baz<T, U> {}
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/ui/not_unpin/impl-unsafe-unpin.stderr b/third_party/rust/pin-project/tests/ui/not_unpin/impl-unsafe-unpin.stderr
new file mode 100644
index 0000000000..f116eac673
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/not_unpin/impl-unsafe-unpin.stderr
@@ -0,0 +1,32 @@
+error[E0119]: conflicting implementations of trait `UnsafeUnpin` for type `Foo<_, _>`
+ --> tests/ui/not_unpin/impl-unsafe-unpin.rs:3:1
+ |
+3 | #[pin_project(!Unpin)] //~ ERROR E0119
+ | ^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `Foo<_, _>`
+...
+10 | unsafe impl<T, U> UnsafeUnpin for Foo<T, U> where T: Unpin {}
+ | ------------------------------------------- first implementation here
+ |
+ = note: this error originates in the derive macro `::pin_project::__private::__PinProjectInternalDerive` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0119]: conflicting implementations of trait `UnsafeUnpin` for type `Bar<_, _>`
+ --> tests/ui/not_unpin/impl-unsafe-unpin.rs:12:1
+ |
+12 | #[pin_project(!Unpin)] //~ ERROR E0119
+ | ^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `Bar<_, _>`
+...
+19 | unsafe impl<T, U> UnsafeUnpin for Bar<T, U> {}
+ | ------------------------------------------- first implementation here
+ |
+ = note: this error originates in the derive macro `::pin_project::__private::__PinProjectInternalDerive` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0119]: conflicting implementations of trait `UnsafeUnpin` for type `Baz<_, _>`
+ --> tests/ui/not_unpin/impl-unsafe-unpin.rs:21:1
+ |
+21 | #[pin_project(!Unpin)] //~ ERROR E0119
+ | ^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `Baz<_, _>`
+...
+28 | unsafe impl<T: Unpin, U: Unpin> UnsafeUnpin for Baz<T, U> {}
+ | --------------------------------------------------------- first implementation here
+ |
+ = note: this error originates in the derive macro `::pin_project::__private::__PinProjectInternalDerive` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/third_party/rust/pin-project/tests/ui/pin_project/add-attr-to-struct.rs b/third_party/rust/pin-project/tests/ui/pin_project/add-attr-to-struct.rs
new file mode 100644
index 0000000000..32253d70f5
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pin_project/add-attr-to-struct.rs
@@ -0,0 +1,20 @@
+use std::marker::PhantomPinned;
+
+use auxiliary_macro::add_pin_attr;
+use pin_project::pin_project;
+
+#[pin_project]
+#[add_pin_attr(struct)] //~ ERROR expected attribute arguments in parentheses
+struct Foo {
+ #[pin]
+ f: PhantomPinned,
+}
+
+#[add_pin_attr(struct)] //~ ERROR #[pin] attribute may only be used on fields of structs or variants
+#[pin_project]
+struct Bar {
+ #[pin]
+ f: PhantomPinned,
+}
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/ui/pin_project/add-attr-to-struct.stderr b/third_party/rust/pin-project/tests/ui/pin_project/add-attr-to-struct.stderr
new file mode 100644
index 0000000000..bb76c62d95
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pin_project/add-attr-to-struct.stderr
@@ -0,0 +1,15 @@
+error: expected attribute arguments in parentheses: `pin(...)`
+ --> tests/ui/pin_project/add-attr-to-struct.rs:7:1
+ |
+7 | #[add_pin_attr(struct)] //~ ERROR expected attribute arguments in parentheses
+ | ^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = note: this error originates in the attribute macro `add_pin_attr` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: #[pin] attribute may only be used on fields of structs or variants
+ --> tests/ui/pin_project/add-attr-to-struct.rs:13:1
+ |
+13 | #[add_pin_attr(struct)] //~ ERROR #[pin] attribute may only be used on fields of structs or variants
+ | ^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = note: this error originates in the attribute macro `add_pin_attr` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/third_party/rust/pin-project/tests/ui/pin_project/add-pinned-field.rs b/third_party/rust/pin-project/tests/ui/pin_project/add-pinned-field.rs
new file mode 100644
index 0000000000..c415f9c904
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pin_project/add-pinned-field.rs
@@ -0,0 +1,23 @@
+use auxiliary_macro::add_pinned_field;
+use pin_project::pin_project;
+
+fn is_unpin<T: Unpin>() {}
+
+#[pin_project]
+#[add_pinned_field]
+struct Foo {
+ #[pin]
+ f: u32,
+}
+
+#[add_pinned_field]
+#[pin_project]
+struct Bar {
+ #[pin]
+ f: u32,
+}
+
+fn main() {
+ is_unpin::<Foo>(); //~ ERROR E0277
+ is_unpin::<Bar>(); //~ ERROR E0277
+}
diff --git a/third_party/rust/pin-project/tests/ui/pin_project/add-pinned-field.stderr b/third_party/rust/pin-project/tests/ui/pin_project/add-pinned-field.stderr
new file mode 100644
index 0000000000..a38329d39b
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pin_project/add-pinned-field.stderr
@@ -0,0 +1,54 @@
+error[E0277]: `PhantomPinned` cannot be unpinned
+ --> tests/ui/pin_project/add-pinned-field.rs:21:16
+ |
+21 | is_unpin::<Foo>(); //~ ERROR E0277
+ | ^^^ within `__Foo<'_>`, the trait `Unpin` is not implemented for `PhantomPinned`
+ |
+ = note: consider using the `pin!` macro
+ consider using `Box::pin` if you need to access the pinned value outside of the current scope
+note: required because it appears within the type `__Foo<'_>`
+ --> tests/ui/pin_project/add-pinned-field.rs:8:8
+ |
+8 | struct Foo {
+ | ^^^
+note: required for `Foo` to implement `Unpin`
+ --> tests/ui/pin_project/add-pinned-field.rs:6:1
+ |
+6 | #[pin_project]
+ | ^^^^^^^^^^^^^^ unsatisfied trait bound introduced in this `derive` macro
+7 | #[add_pinned_field]
+8 | struct Foo {
+ | ^^^
+note: required by a bound in `is_unpin`
+ --> tests/ui/pin_project/add-pinned-field.rs:4:16
+ |
+4 | fn is_unpin<T: Unpin>() {}
+ | ^^^^^ required by this bound in `is_unpin`
+ = note: this error originates in the derive macro `::pin_project::__private::__PinProjectInternalDerive` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0277]: `PhantomPinned` cannot be unpinned
+ --> tests/ui/pin_project/add-pinned-field.rs:22:16
+ |
+22 | is_unpin::<Bar>(); //~ ERROR E0277
+ | ^^^ within `__Bar<'_>`, the trait `Unpin` is not implemented for `PhantomPinned`
+ |
+ = note: consider using the `pin!` macro
+ consider using `Box::pin` if you need to access the pinned value outside of the current scope
+note: required because it appears within the type `__Bar<'_>`
+ --> tests/ui/pin_project/add-pinned-field.rs:15:8
+ |
+15 | struct Bar {
+ | ^^^
+note: required for `Bar` to implement `Unpin`
+ --> tests/ui/pin_project/add-pinned-field.rs:14:1
+ |
+14 | #[pin_project]
+ | ^^^^^^^^^^^^^^ unsatisfied trait bound introduced in this `derive` macro
+15 | struct Bar {
+ | ^^^
+note: required by a bound in `is_unpin`
+ --> tests/ui/pin_project/add-pinned-field.rs:4:16
+ |
+4 | fn is_unpin<T: Unpin>() {}
+ | ^^^^^ required by this bound in `is_unpin`
+ = note: this error originates in the derive macro `::pin_project::__private::__PinProjectInternalDerive` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/third_party/rust/pin-project/tests/ui/pin_project/conflict-drop.rs b/third_party/rust/pin-project/tests/ui/pin_project/conflict-drop.rs
new file mode 100644
index 0000000000..4fdb118d06
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pin_project/conflict-drop.rs
@@ -0,0 +1,32 @@
+use std::pin::Pin;
+
+use pin_project::{pin_project, pinned_drop};
+
+#[pin_project] //~ ERROR E0119
+struct Foo<T, U> {
+ #[pin]
+ f1: T,
+ f2: U,
+}
+
+impl<T, U> Drop for Foo<T, U> {
+ fn drop(&mut self) {}
+}
+
+#[pin_project(PinnedDrop)] //~ ERROR E0119
+struct Bar<T, U> {
+ #[pin]
+ f1: T,
+ f2: U,
+}
+
+#[pinned_drop]
+impl<T, U> PinnedDrop for Bar<T, U> {
+ fn drop(self: Pin<&mut Self>) {}
+}
+
+impl<T, U> Drop for Bar<T, U> {
+ fn drop(&mut self) {}
+}
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/ui/pin_project/conflict-drop.stderr b/third_party/rust/pin-project/tests/ui/pin_project/conflict-drop.stderr
new file mode 100644
index 0000000000..79d4ca7ab1
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pin_project/conflict-drop.stderr
@@ -0,0 +1,19 @@
+error[E0119]: conflicting implementations of trait `FooMustNotImplDrop` for type `Foo<_, _>`
+ --> tests/ui/pin_project/conflict-drop.rs:5:1
+ |
+5 | #[pin_project] //~ ERROR E0119
+ | ^^^^^^^^^^^^^^
+ | |
+ | first implementation here
+ | conflicting implementation for `Foo<_, _>`
+ |
+ = note: this error originates in the derive macro `::pin_project::__private::__PinProjectInternalDerive` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0119]: conflicting implementations of trait `Drop` for type `Bar<_, _>`
+ --> tests/ui/pin_project/conflict-drop.rs:16:15
+ |
+16 | #[pin_project(PinnedDrop)] //~ ERROR E0119
+ | ^^^^^^^^^^ conflicting implementation for `Bar<_, _>`
+...
+28 | impl<T, U> Drop for Bar<T, U> {
+ | ----------------------------- first implementation here
diff --git a/third_party/rust/pin-project/tests/ui/pin_project/conflict-unpin.rs b/third_party/rust/pin-project/tests/ui/pin_project/conflict-unpin.rs
new file mode 100644
index 0000000000..f58c45e09f
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pin_project/conflict-unpin.rs
@@ -0,0 +1,37 @@
+use pin_project::pin_project;
+
+// The same implementation.
+
+#[pin_project] //~ ERROR E0119
+struct Foo<T, U> {
+ #[pin]
+ f1: T,
+ f2: U,
+}
+
+// conflicting implementations
+impl<T, U> Unpin for Foo<T, U> where T: Unpin {} // Conditional Unpin impl
+
+// The implementation that under different conditions.
+
+#[pin_project] //~ ERROR E0119
+struct Bar<T, U> {
+ #[pin]
+ f1: T,
+ f2: U,
+}
+
+// conflicting implementations
+impl<T, U> Unpin for Bar<T, U> {} // Non-conditional Unpin impl
+
+#[pin_project] //~ ERROR E0119
+struct Baz<T, U> {
+ #[pin]
+ f1: T,
+ f2: U,
+}
+
+// conflicting implementations
+impl<T: Unpin, U: Unpin> Unpin for Baz<T, U> {} // Conditional Unpin impl
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/ui/pin_project/conflict-unpin.stderr b/third_party/rust/pin-project/tests/ui/pin_project/conflict-unpin.stderr
new file mode 100644
index 0000000000..0f26b68ce9
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pin_project/conflict-unpin.stderr
@@ -0,0 +1,32 @@
+error[E0119]: conflicting implementations of trait `Unpin` for type `Foo<_, _>`
+ --> tests/ui/pin_project/conflict-unpin.rs:5:1
+ |
+5 | #[pin_project] //~ ERROR E0119
+ | ^^^^^^^^^^^^^^ conflicting implementation for `Foo<_, _>`
+...
+13 | impl<T, U> Unpin for Foo<T, U> where T: Unpin {} // Conditional Unpin impl
+ | ------------------------------ first implementation here
+ |
+ = note: this error originates in the derive macro `::pin_project::__private::__PinProjectInternalDerive` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0119]: conflicting implementations of trait `Unpin` for type `Bar<_, _>`
+ --> tests/ui/pin_project/conflict-unpin.rs:17:1
+ |
+17 | #[pin_project] //~ ERROR E0119
+ | ^^^^^^^^^^^^^^ conflicting implementation for `Bar<_, _>`
+...
+25 | impl<T, U> Unpin for Bar<T, U> {} // Non-conditional Unpin impl
+ | ------------------------------ first implementation here
+ |
+ = note: this error originates in the derive macro `::pin_project::__private::__PinProjectInternalDerive` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0119]: conflicting implementations of trait `Unpin` for type `Baz<_, _>`
+ --> tests/ui/pin_project/conflict-unpin.rs:27:1
+ |
+27 | #[pin_project] //~ ERROR E0119
+ | ^^^^^^^^^^^^^^ conflicting implementation for `Baz<_, _>`
+...
+35 | impl<T: Unpin, U: Unpin> Unpin for Baz<T, U> {} // Conditional Unpin impl
+ | -------------------------------------------- first implementation here
+ |
+ = note: this error originates in the derive macro `::pin_project::__private::__PinProjectInternalDerive` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/third_party/rust/pin-project/tests/ui/pin_project/impl-unsafe-unpin.rs b/third_party/rust/pin-project/tests/ui/pin_project/impl-unsafe-unpin.rs
new file mode 100644
index 0000000000..562c9b64f6
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pin_project/impl-unsafe-unpin.rs
@@ -0,0 +1,30 @@
+use pin_project::{pin_project, UnsafeUnpin};
+
+#[pin_project] //~ ERROR E0119
+struct Foo<T, U> {
+ #[pin]
+ f1: T,
+ f2: U,
+}
+
+unsafe impl<T, U> UnsafeUnpin for Foo<T, U> where T: Unpin {}
+
+#[pin_project] //~ ERROR E0119
+struct Bar<T, U> {
+ #[pin]
+ f1: T,
+ f2: U,
+}
+
+unsafe impl<T, U> UnsafeUnpin for Bar<T, U> {}
+
+#[pin_project] //~ ERROR E0119
+struct Baz<T, U> {
+ #[pin]
+ f1: T,
+ f2: U,
+}
+
+unsafe impl<T: Unpin, U: Unpin> UnsafeUnpin for Baz<T, U> {}
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/ui/pin_project/impl-unsafe-unpin.stderr b/third_party/rust/pin-project/tests/ui/pin_project/impl-unsafe-unpin.stderr
new file mode 100644
index 0000000000..7e66b9e892
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pin_project/impl-unsafe-unpin.stderr
@@ -0,0 +1,32 @@
+error[E0119]: conflicting implementations of trait `UnsafeUnpin` for type `Foo<_, _>`
+ --> tests/ui/pin_project/impl-unsafe-unpin.rs:3:1
+ |
+3 | #[pin_project] //~ ERROR E0119
+ | ^^^^^^^^^^^^^^ conflicting implementation for `Foo<_, _>`
+...
+10 | unsafe impl<T, U> UnsafeUnpin for Foo<T, U> where T: Unpin {}
+ | ------------------------------------------- first implementation here
+ |
+ = note: this error originates in the derive macro `::pin_project::__private::__PinProjectInternalDerive` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0119]: conflicting implementations of trait `UnsafeUnpin` for type `Bar<_, _>`
+ --> tests/ui/pin_project/impl-unsafe-unpin.rs:12:1
+ |
+12 | #[pin_project] //~ ERROR E0119
+ | ^^^^^^^^^^^^^^ conflicting implementation for `Bar<_, _>`
+...
+19 | unsafe impl<T, U> UnsafeUnpin for Bar<T, U> {}
+ | ------------------------------------------- first implementation here
+ |
+ = note: this error originates in the derive macro `::pin_project::__private::__PinProjectInternalDerive` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0119]: conflicting implementations of trait `UnsafeUnpin` for type `Baz<_, _>`
+ --> tests/ui/pin_project/impl-unsafe-unpin.rs:21:1
+ |
+21 | #[pin_project] //~ ERROR E0119
+ | ^^^^^^^^^^^^^^ conflicting implementation for `Baz<_, _>`
+...
+28 | unsafe impl<T: Unpin, U: Unpin> UnsafeUnpin for Baz<T, U> {}
+ | --------------------------------------------------------- first implementation here
+ |
+ = note: this error originates in the derive macro `::pin_project::__private::__PinProjectInternalDerive` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/third_party/rust/pin-project/tests/ui/pin_project/import_unnamed.rs b/third_party/rust/pin-project/tests/ui/pin_project/import_unnamed.rs
new file mode 100644
index 0000000000..7926e61a63
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pin_project/import_unnamed.rs
@@ -0,0 +1,30 @@
+/// Only named projected types can be imported.
+/// See visibility.rs for named projected types.
+
+mod pub_ {
+ use pin_project::pin_project;
+
+ #[pin_project]
+ pub struct Default(());
+
+ #[pin_project(project_replace)]
+ pub struct Replace(());
+}
+#[allow(unused_imports)]
+pub mod use_ {
+ #[rustfmt::skip]
+ use crate::pub_::__DefaultProjection; //~ ERROR E0432
+ #[rustfmt::skip]
+ use crate::pub_::__DefaultProjectionRef; //~ ERROR E0432
+ #[rustfmt::skip]
+ use crate::pub_::__ReplaceProjection; //~ ERROR E0432
+ #[rustfmt::skip]
+ use crate::pub_::__ReplaceProjectionOwned; //~ ERROR E0432
+ #[rustfmt::skip]
+ use crate::pub_::__ReplaceProjectionRef; //~ ERROR E0432
+
+ // Confirm that the visibility of the original type is not changed.
+ pub use crate::pub_::{Default, Replace};
+}
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/ui/pin_project/import_unnamed.stderr b/third_party/rust/pin-project/tests/ui/pin_project/import_unnamed.stderr
new file mode 100644
index 0000000000..260a35a5c0
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pin_project/import_unnamed.stderr
@@ -0,0 +1,29 @@
+error[E0432]: unresolved import `crate::pub_::__DefaultProjection`
+ --> tests/ui/pin_project/import_unnamed.rs:16:9
+ |
+16 | use crate::pub_::__DefaultProjection; //~ ERROR E0432
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `__DefaultProjection` in `pub_`
+
+error[E0432]: unresolved import `crate::pub_::__DefaultProjectionRef`
+ --> tests/ui/pin_project/import_unnamed.rs:18:9
+ |
+18 | use crate::pub_::__DefaultProjectionRef; //~ ERROR E0432
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `__DefaultProjectionRef` in `pub_`
+
+error[E0432]: unresolved import `crate::pub_::__ReplaceProjection`
+ --> tests/ui/pin_project/import_unnamed.rs:20:9
+ |
+20 | use crate::pub_::__ReplaceProjection; //~ ERROR E0432
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `__ReplaceProjection` in `pub_`
+
+error[E0432]: unresolved import `crate::pub_::__ReplaceProjectionOwned`
+ --> tests/ui/pin_project/import_unnamed.rs:22:9
+ |
+22 | use crate::pub_::__ReplaceProjectionOwned; //~ ERROR E0432
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `__ReplaceProjectionOwned` in `pub_`
+
+error[E0432]: unresolved import `crate::pub_::__ReplaceProjectionRef`
+ --> tests/ui/pin_project/import_unnamed.rs:24:9
+ |
+24 | use crate::pub_::__ReplaceProjectionRef; //~ ERROR E0432
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `__ReplaceProjectionRef` in `pub_`
diff --git a/third_party/rust/pin-project/tests/ui/pin_project/invalid.rs b/third_party/rust/pin-project/tests/ui/pin_project/invalid.rs
new file mode 100644
index 0000000000..a850c57170
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pin_project/invalid.rs
@@ -0,0 +1,280 @@
+mod pin_argument {
+ use pin_project::pin_project;
+
+ #[pin_project]
+ struct Struct {
+ #[pin()] //~ ERROR unexpected token in attribute
+ f: (),
+ }
+
+ #[pin_project]
+ struct TupleStruct(#[pin(foo)] ()); //~ ERROR unexpected token in attribute
+
+ #[pin_project]
+ enum EnumTuple {
+ V(#[pin(foo)] ()), //~ ERROR unexpected token in attribute
+ }
+
+ #[pin_project]
+ enum EnumStruct {
+ V {
+ #[pin(foo)] //~ ERROR unexpected token in attribute
+ f: (),
+ },
+ }
+}
+
+mod pin_attribute {
+ use pin_project::pin_project;
+
+ #[pin_project]
+ struct DuplicateStruct {
+ #[pin]
+ #[pin] //~ ERROR duplicate #[pin] attribute
+ f: (),
+ }
+
+ #[pin_project]
+ struct DuplicateTupleStruct(
+ #[pin]
+ #[pin]
+ (),
+ //~^^ ERROR duplicate #[pin] attribute
+ );
+
+ #[pin_project]
+ enum DuplicateEnumTuple {
+ V(
+ #[pin]
+ #[pin]
+ (),
+ //~^^ ERROR duplicate #[pin] attribute
+ ),
+ }
+
+ #[pin_project]
+ enum DuplicateEnumStruct {
+ V {
+ #[pin]
+ #[pin] //~ ERROR duplicate #[pin] attribute
+ f: (),
+ },
+ }
+}
+
+mod pin_item {
+ use pin_project::pin_project;
+
+ #[pin_project]
+ #[pin] //~ ERROR may only be used on fields of structs or variants
+ struct Struct {
+ #[pin]
+ f: (),
+ }
+
+ #[pin_project]
+ enum Variant {
+ #[pin] //~ ERROR may only be used on fields of structs or variants
+ V(()),
+ }
+
+ #[pin_project]
+ #[pin] //~ ERROR may only be used on fields of structs or variants
+ enum Enum {
+ V(()),
+ }
+}
+
+mod pin_project_argument {
+ use pin_project::pin_project;
+
+ #[pin_project(Replace)] //~ ERROR `Replace` argument was removed, use `project_replace` argument instead
+ struct RemovedReplace(#[pin] ());
+
+ #[pin_project(UnsafeUnpin,,)] //~ ERROR expected identifier
+ struct Unexpected1(#[pin] ());
+
+ #[pin_project(Foo)] //~ ERROR unexpected argument
+ struct Unexpected2(#[pin] ());
+
+ #[pin_project(,UnsafeUnpin)] //~ ERROR expected identifier
+ struct Unexpected3(#[pin] ());
+
+ #[pin_project()] // Ok
+ struct Unexpected4(#[pin] ());
+
+ #[pin_project(PinnedDrop PinnedDrop)] //~ ERROR expected `,`
+ struct Unexpected5(#[pin] ());
+
+ #[pin_project(PinnedDrop, PinnedDrop)] //~ ERROR duplicate `PinnedDrop` argument
+ struct DuplicatePinnedDrop(#[pin] ());
+
+ #[pin_project(UnsafeUnpin, UnsafeUnpin)] //~ ERROR duplicate `UnsafeUnpin` argument
+ struct DuplicateUnsafeUnpin(#[pin] ());
+
+ #[pin_project(!Unpin, !Unpin)] //~ ERROR duplicate `!Unpin` argument
+ struct DuplicateNotUnpin(#[pin] ());
+
+ #[pin_project(PinnedDrop, UnsafeUnpin, UnsafeUnpin)] //~ ERROR duplicate `UnsafeUnpin` argument
+ struct Duplicate3(#[pin] ());
+
+ #[pin_project(PinnedDrop, UnsafeUnpin, PinnedDrop, UnsafeUnpin)] //~ ERROR duplicate `PinnedDrop` argument
+ struct Duplicate4(#[pin] ());
+
+ #[pin_project(project = A, project = B)] //~ ERROR duplicate `project` argument
+ struct DuplicateProject(#[pin] ());
+
+ #[pin_project(project = A, project_ref = A, project = B)] //~ ERROR duplicate `project` argument
+ struct DuplicateProject2(#[pin] ());
+
+ #[pin_project(project_ref = A, project_ref = B)] //~ ERROR duplicate `project_ref` argument
+ struct DuplicateProjectRef(#[pin] ());
+
+ #[pin_project(project_replace = A, project_replace = B)] //~ ERROR duplicate `project_replace` argument
+ struct DuplicateProjectReplace1(#[pin] ());
+
+ #[pin_project(project_replace, project_replace = B)] //~ ERROR duplicate `project_replace` argument
+ struct DuplicateProjectReplace2(#[pin] ());
+
+ #[pin_project(project_replace = A, project_replace)] //~ ERROR duplicate `project_replace` argument
+ struct DuplicateProjectReplace3(#[pin] ());
+
+ #[pin_project(project_replace = A)] // Ok
+ struct ProjectReplaceWithoutReplace(#[pin] ());
+
+ #[pin_project(PinnedDrop, project_replace)] //~ ERROR arguments `PinnedDrop` and `project_replace` are mutually exclusive
+ struct PinnedDropWithProjectReplace1(#[pin] ());
+
+ #[pin_project(project_replace, UnsafeUnpin, PinnedDrop)] //~ ERROR arguments `PinnedDrop` and `project_replace` are mutually exclusive
+ struct PinnedDropWithProjectReplace2(#[pin] ());
+
+ #[pin_project(UnsafeUnpin, !Unpin)] //~ ERROR arguments `UnsafeUnpin` and `!Unpin` are mutually exclusive
+ struct UnsafeUnpinWithNotUnpin1(#[pin] ());
+
+ #[pin_project(!Unpin, PinnedDrop, UnsafeUnpin)] //~ ERROR arguments `UnsafeUnpin` and `!Unpin` are mutually exclusive
+ struct UnsafeUnpinWithNotUnpin2(#[pin] ());
+
+ #[pin_project(!)] //~ ERROR expected `!Unpin`, found `!`
+ struct NotUnpin1(#[pin] ());
+
+ #[pin_project(Unpin)] //~ ERROR unexpected argument
+ struct NotUnpin2(#[pin] ());
+
+ #[pin_project(project)] //~ ERROR expected `project = <identifier>`, found `project`
+ struct Project1(#[pin] ());
+
+ #[pin_project(project = )] //~ ERROR expected `project = <identifier>`, found `project =`
+ struct Project2(#[pin] ());
+
+ #[pin_project(project = !)] //~ ERROR expected identifier
+ struct Project3(#[pin] ());
+
+ #[pin_project(project_ref)] //~ ERROR expected `project_ref = <identifier>`, found `project_ref`
+ struct ProjectRef1(#[pin] ());
+
+ #[pin_project(project_ref = )] //~ ERROR expected `project_ref = <identifier>`, found `project_ref =`
+ struct ProjectRef2(#[pin] ());
+
+ #[pin_project(project_ref = !)] //~ ERROR expected identifier
+ struct ProjectRef3(#[pin] ());
+
+ #[pin_project(project_replace)] // Ok
+ struct ProjectReplace1(#[pin] ());
+
+ #[pin_project(project_replace = )] //~ ERROR expected `project_replace = <identifier>`, found `project_replace =`
+ struct ProjectReplace2(#[pin] ());
+
+ #[pin_project(project_replace = !)] //~ ERROR expected identifier
+ struct ProjectReplace3(#[pin] ());
+
+ #[pin_project(project_replace)] //~ ERROR `project_replace` argument requires a value when used on enums
+ enum ProjectReplaceEnum {
+ V(#[pin] ()),
+ }
+}
+
+mod pin_project_conflict_naming {
+ use pin_project::pin_project;
+
+ #[pin_project(project = OrigAndProj)] //~ ERROR name `OrigAndProj` is the same as the original type name
+ struct OrigAndProj(#[pin] ());
+
+ #[pin_project(project_ref = OrigAndProjRef)] //~ ERROR name `OrigAndProjRef` is the same as the original type name
+ struct OrigAndProjRef(#[pin] ());
+
+ #[pin_project(project_replace = OrigAndProjOwn)] //~ ERROR name `OrigAndProjOwn` is the same as the original type name
+ struct OrigAndProjOwn(#[pin] ());
+
+ #[pin_project(project = A, project_ref = A)] //~ ERROR name `A` is already specified by `project` argument
+ struct ProjAndProjRef(#[pin] ());
+
+ #[pin_project(project = A, project_replace = A)] //~ ERROR name `A` is already specified by `project` argument
+ struct ProjAndProjOwn(#[pin] ());
+
+ #[pin_project(project_ref = A, project_replace = A)] //~ ERROR name `A` is already specified by `project_ref` argument
+ struct ProjRefAndProjOwn(#[pin] ());
+}
+
+mod pin_project_attribute {
+ use pin_project::pin_project;
+
+ #[pin_project]
+ #[pin_project] //~ ERROR duplicate #[pin_project] attribute
+ struct Duplicate(#[pin] ());
+}
+
+mod pin_project_item {
+ use pin_project::pin_project;
+
+ #[pin_project]
+ struct Struct {} //~ ERROR may not be used on structs with zero fields
+
+ #[pin_project]
+ struct TupleStruct(); //~ ERROR may not be used on structs with zero fields
+
+ #[pin_project]
+ struct UnitStruct; //~ ERROR may not be used on structs with zero fields
+
+ #[pin_project]
+ enum EnumEmpty {} //~ ERROR may not be used on enums without variants
+
+ #[pin_project]
+ enum EnumDiscriminant {
+ V = 2, //~ ERROR may not be used on enums with discriminants
+ }
+
+ #[pin_project]
+ enum EnumZeroFields {
+ Unit, //~ ERROR may not be used on enums with zero fields
+ Tuple(),
+ Struct {},
+ }
+
+ #[pin_project]
+ union Union {
+ //~^ ERROR may only be used on structs or enums
+ f: (),
+ }
+
+ #[pin_project]
+ impl Impl {} //~ ERROR may only be used on structs or enums
+}
+
+// #[repr(packed)] is always detected first, even on unsupported structs.
+mod pin_project_item_packed {
+ use pin_project::pin_project;
+
+ #[pin_project]
+ #[repr(packed)]
+ struct Struct {} //~ ERROR may not be used on #[repr(packed)] types
+
+ #[pin_project]
+ #[repr(packed)]
+ struct TupleStruct(); //~ ERROR may not be used on #[repr(packed)] types
+
+ #[pin_project]
+ #[repr(packed)]
+ struct UnitStruct; //~ ERROR may not be used on #[repr(packed)] types
+}
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/ui/pin_project/invalid.stderr b/third_party/rust/pin-project/tests/ui/pin_project/invalid.stderr
new file mode 100644
index 0000000000..ec5205f564
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pin_project/invalid.stderr
@@ -0,0 +1,364 @@
+error: unexpected token in attribute
+ --> tests/ui/pin_project/invalid.rs:6:14
+ |
+6 | #[pin()] //~ ERROR unexpected token in attribute
+ | ^
+
+error: unexpected token in attribute
+ --> tests/ui/pin_project/invalid.rs:11:29
+ |
+11 | struct TupleStruct(#[pin(foo)] ()); //~ ERROR unexpected token in attribute
+ | ^
+
+error: unexpected token in attribute
+ --> tests/ui/pin_project/invalid.rs:15:16
+ |
+15 | V(#[pin(foo)] ()), //~ ERROR unexpected token in attribute
+ | ^
+
+error: unexpected token in attribute
+ --> tests/ui/pin_project/invalid.rs:21:18
+ |
+21 | #[pin(foo)] //~ ERROR unexpected token in attribute
+ | ^
+
+error: duplicate #[pin] attribute
+ --> tests/ui/pin_project/invalid.rs:33:9
+ |
+33 | #[pin] //~ ERROR duplicate #[pin] attribute
+ | ^^^^^^
+
+error: duplicate #[pin] attribute
+ --> tests/ui/pin_project/invalid.rs:40:9
+ |
+40 | #[pin]
+ | ^^^^^^
+
+error: duplicate #[pin] attribute
+ --> tests/ui/pin_project/invalid.rs:49:13
+ |
+49 | #[pin]
+ | ^^^^^^
+
+error: duplicate #[pin] attribute
+ --> tests/ui/pin_project/invalid.rs:59:13
+ |
+59 | #[pin] //~ ERROR duplicate #[pin] attribute
+ | ^^^^^^
+
+error: #[pin] attribute may only be used on fields of structs or variants
+ --> tests/ui/pin_project/invalid.rs:69:5
+ |
+69 | #[pin] //~ ERROR may only be used on fields of structs or variants
+ | ^^^^^^
+
+error: #[pin] attribute may only be used on fields of structs or variants
+ --> tests/ui/pin_project/invalid.rs:77:9
+ |
+77 | #[pin] //~ ERROR may only be used on fields of structs or variants
+ | ^^^^^^
+
+error: #[pin] attribute may only be used on fields of structs or variants
+ --> tests/ui/pin_project/invalid.rs:82:5
+ |
+82 | #[pin] //~ ERROR may only be used on fields of structs or variants
+ | ^^^^^^
+
+error: `Replace` argument was removed, use `project_replace` argument instead
+ --> tests/ui/pin_project/invalid.rs:91:19
+ |
+91 | #[pin_project(Replace)] //~ ERROR `Replace` argument was removed, use `project_replace` argument instead
+ | ^^^^^^^
+
+error: expected identifier
+ --> tests/ui/pin_project/invalid.rs:94:31
+ |
+94 | #[pin_project(UnsafeUnpin,,)] //~ ERROR expected identifier
+ | ^
+
+error: unexpected argument: Foo
+ --> tests/ui/pin_project/invalid.rs:97:19
+ |
+97 | #[pin_project(Foo)] //~ ERROR unexpected argument
+ | ^^^
+
+error: expected identifier
+ --> tests/ui/pin_project/invalid.rs:100:19
+ |
+100 | #[pin_project(,UnsafeUnpin)] //~ ERROR expected identifier
+ | ^
+
+error: expected `,`
+ --> tests/ui/pin_project/invalid.rs:106:30
+ |
+106 | #[pin_project(PinnedDrop PinnedDrop)] //~ ERROR expected `,`
+ | ^^^^^^^^^^
+
+error: duplicate `PinnedDrop` argument
+ --> tests/ui/pin_project/invalid.rs:109:31
+ |
+109 | #[pin_project(PinnedDrop, PinnedDrop)] //~ ERROR duplicate `PinnedDrop` argument
+ | ^^^^^^^^^^
+
+error: duplicate `UnsafeUnpin` argument
+ --> tests/ui/pin_project/invalid.rs:112:32
+ |
+112 | #[pin_project(UnsafeUnpin, UnsafeUnpin)] //~ ERROR duplicate `UnsafeUnpin` argument
+ | ^^^^^^^^^^^
+
+error: duplicate `!Unpin` argument
+ --> tests/ui/pin_project/invalid.rs:115:27
+ |
+115 | #[pin_project(!Unpin, !Unpin)] //~ ERROR duplicate `!Unpin` argument
+ | ^^^^^^
+
+error: duplicate `UnsafeUnpin` argument
+ --> tests/ui/pin_project/invalid.rs:118:44
+ |
+118 | #[pin_project(PinnedDrop, UnsafeUnpin, UnsafeUnpin)] //~ ERROR duplicate `UnsafeUnpin` argument
+ | ^^^^^^^^^^^
+
+error: duplicate `PinnedDrop` argument
+ --> tests/ui/pin_project/invalid.rs:121:44
+ |
+121 | #[pin_project(PinnedDrop, UnsafeUnpin, PinnedDrop, UnsafeUnpin)] //~ ERROR duplicate `PinnedDrop` argument
+ | ^^^^^^^^^^
+
+error: duplicate `project` argument
+ --> tests/ui/pin_project/invalid.rs:124:32
+ |
+124 | #[pin_project(project = A, project = B)] //~ ERROR duplicate `project` argument
+ | ^^^^^^^^^^^
+
+error: duplicate `project` argument
+ --> tests/ui/pin_project/invalid.rs:127:49
+ |
+127 | #[pin_project(project = A, project_ref = A, project = B)] //~ ERROR duplicate `project` argument
+ | ^^^^^^^^^^^
+
+error: duplicate `project_ref` argument
+ --> tests/ui/pin_project/invalid.rs:130:36
+ |
+130 | #[pin_project(project_ref = A, project_ref = B)] //~ ERROR duplicate `project_ref` argument
+ | ^^^^^^^^^^^^^^^
+
+error: duplicate `project_replace` argument
+ --> tests/ui/pin_project/invalid.rs:133:40
+ |
+133 | #[pin_project(project_replace = A, project_replace = B)] //~ ERROR duplicate `project_replace` argument
+ | ^^^^^^^^^^^^^^^^^^^
+
+error: duplicate `project_replace` argument
+ --> tests/ui/pin_project/invalid.rs:136:36
+ |
+136 | #[pin_project(project_replace, project_replace = B)] //~ ERROR duplicate `project_replace` argument
+ | ^^^^^^^^^^^^^^^^^^^
+
+error: duplicate `project_replace` argument
+ --> tests/ui/pin_project/invalid.rs:139:40
+ |
+139 | #[pin_project(project_replace = A, project_replace)] //~ ERROR duplicate `project_replace` argument
+ | ^^^^^^^^^^^^^^^
+
+error: arguments `PinnedDrop` and `project_replace` are mutually exclusive
+ --> tests/ui/pin_project/invalid.rs:145:19
+ |
+145 | #[pin_project(PinnedDrop, project_replace)] //~ ERROR arguments `PinnedDrop` and `project_replace` are mutually exclusive
+ | ^^^^^^^^^^
+
+error: arguments `PinnedDrop` and `project_replace` are mutually exclusive
+ --> tests/ui/pin_project/invalid.rs:148:49
+ |
+148 | #[pin_project(project_replace, UnsafeUnpin, PinnedDrop)] //~ ERROR arguments `PinnedDrop` and `project_replace` are mutually exclusive
+ | ^^^^^^^^^^
+
+error: arguments `UnsafeUnpin` and `!Unpin` are mutually exclusive
+ --> tests/ui/pin_project/invalid.rs:151:19
+ |
+151 | #[pin_project(UnsafeUnpin, !Unpin)] //~ ERROR arguments `UnsafeUnpin` and `!Unpin` are mutually exclusive
+ | ^^^^^^^^^^^
+
+error: arguments `UnsafeUnpin` and `!Unpin` are mutually exclusive
+ --> tests/ui/pin_project/invalid.rs:154:39
+ |
+154 | #[pin_project(!Unpin, PinnedDrop, UnsafeUnpin)] //~ ERROR arguments `UnsafeUnpin` and `!Unpin` are mutually exclusive
+ | ^^^^^^^^^^^
+
+error: expected `!Unpin`, found `!`
+ --> tests/ui/pin_project/invalid.rs:157:19
+ |
+157 | #[pin_project(!)] //~ ERROR expected `!Unpin`, found `!`
+ | ^
+
+error: unexpected argument: Unpin
+ --> tests/ui/pin_project/invalid.rs:160:19
+ |
+160 | #[pin_project(Unpin)] //~ ERROR unexpected argument
+ | ^^^^^
+
+error: expected `project = <identifier>`, found `project`
+ --> tests/ui/pin_project/invalid.rs:163:19
+ |
+163 | #[pin_project(project)] //~ ERROR expected `project = <identifier>`, found `project`
+ | ^^^^^^^
+
+error: expected `project = <identifier>`, found `project =`
+ --> tests/ui/pin_project/invalid.rs:166:19
+ |
+166 | #[pin_project(project = )] //~ ERROR expected `project = <identifier>`, found `project =`
+ | ^^^^^^^^^
+
+error: expected identifier
+ --> tests/ui/pin_project/invalid.rs:169:29
+ |
+169 | #[pin_project(project = !)] //~ ERROR expected identifier
+ | ^
+
+error: expected `project_ref = <identifier>`, found `project_ref`
+ --> tests/ui/pin_project/invalid.rs:172:19
+ |
+172 | #[pin_project(project_ref)] //~ ERROR expected `project_ref = <identifier>`, found `project_ref`
+ | ^^^^^^^^^^^
+
+error: expected `project_ref = <identifier>`, found `project_ref =`
+ --> tests/ui/pin_project/invalid.rs:175:19
+ |
+175 | #[pin_project(project_ref = )] //~ ERROR expected `project_ref = <identifier>`, found `project_ref =`
+ | ^^^^^^^^^^^^^
+
+error: expected identifier
+ --> tests/ui/pin_project/invalid.rs:178:33
+ |
+178 | #[pin_project(project_ref = !)] //~ ERROR expected identifier
+ | ^
+
+error: expected `project_replace = <identifier>`, found `project_replace =`
+ --> tests/ui/pin_project/invalid.rs:184:19
+ |
+184 | #[pin_project(project_replace = )] //~ ERROR expected `project_replace = <identifier>`, found `project_replace =`
+ | ^^^^^^^^^^^^^^^^^
+
+error: expected identifier
+ --> tests/ui/pin_project/invalid.rs:187:37
+ |
+187 | #[pin_project(project_replace = !)] //~ ERROR expected identifier
+ | ^
+
+error: `project_replace` argument requires a value when used on enums
+ --> tests/ui/pin_project/invalid.rs:190:19
+ |
+190 | #[pin_project(project_replace)] //~ ERROR `project_replace` argument requires a value when used on enums
+ | ^^^^^^^^^^^^^^^
+
+error: name `OrigAndProj` is the same as the original type name
+ --> tests/ui/pin_project/invalid.rs:199:29
+ |
+199 | #[pin_project(project = OrigAndProj)] //~ ERROR name `OrigAndProj` is the same as the original type name
+ | ^^^^^^^^^^^
+
+error: name `OrigAndProjRef` is the same as the original type name
+ --> tests/ui/pin_project/invalid.rs:202:33
+ |
+202 | #[pin_project(project_ref = OrigAndProjRef)] //~ ERROR name `OrigAndProjRef` is the same as the original type name
+ | ^^^^^^^^^^^^^^
+
+error: name `OrigAndProjOwn` is the same as the original type name
+ --> tests/ui/pin_project/invalid.rs:205:37
+ |
+205 | #[pin_project(project_replace = OrigAndProjOwn)] //~ ERROR name `OrigAndProjOwn` is the same as the original type name
+ | ^^^^^^^^^^^^^^
+
+error: name `A` is already specified by `project` argument
+ --> tests/ui/pin_project/invalid.rs:208:46
+ |
+208 | #[pin_project(project = A, project_ref = A)] //~ ERROR name `A` is already specified by `project` argument
+ | ^
+
+error: name `A` is already specified by `project` argument
+ --> tests/ui/pin_project/invalid.rs:211:50
+ |
+211 | #[pin_project(project = A, project_replace = A)] //~ ERROR name `A` is already specified by `project` argument
+ | ^
+
+error: name `A` is already specified by `project_ref` argument
+ --> tests/ui/pin_project/invalid.rs:214:54
+ |
+214 | #[pin_project(project_ref = A, project_replace = A)] //~ ERROR name `A` is already specified by `project_ref` argument
+ | ^
+
+error: duplicate #[pin_project] attribute
+ --> tests/ui/pin_project/invalid.rs:222:5
+ |
+222 | #[pin_project] //~ ERROR duplicate #[pin_project] attribute
+ | ^^^^^^^^^^^^^^
+
+error: #[pin_project] attribute may not be used on structs with zero fields
+ --> tests/ui/pin_project/invalid.rs:230:19
+ |
+230 | struct Struct {} //~ ERROR may not be used on structs with zero fields
+ | ^^
+
+error: #[pin_project] attribute may not be used on structs with zero fields
+ --> tests/ui/pin_project/invalid.rs:233:23
+ |
+233 | struct TupleStruct(); //~ ERROR may not be used on structs with zero fields
+ | ^^
+
+error: #[pin_project] attribute may not be used on structs with zero fields
+ --> tests/ui/pin_project/invalid.rs:236:12
+ |
+236 | struct UnitStruct; //~ ERROR may not be used on structs with zero fields
+ | ^^^^^^^^^^
+
+error: #[pin_project] attribute may not be used on enums without variants
+ --> tests/ui/pin_project/invalid.rs:239:20
+ |
+239 | enum EnumEmpty {} //~ ERROR may not be used on enums without variants
+ | ^^
+
+error: #[pin_project] attribute may not be used on enums with discriminants
+ --> tests/ui/pin_project/invalid.rs:243:13
+ |
+243 | V = 2, //~ ERROR may not be used on enums with discriminants
+ | ^
+
+error: #[pin_project] attribute may not be used on enums with zero fields
+ --> tests/ui/pin_project/invalid.rs:248:9
+ |
+248 | / Unit, //~ ERROR may not be used on enums with zero fields
+249 | | Tuple(),
+250 | | Struct {},
+ | |__________________^
+
+error: #[pin_project] attribute may only be used on structs or enums
+ --> tests/ui/pin_project/invalid.rs:254:5
+ |
+254 | / union Union {
+255 | | //~^ ERROR may only be used on structs or enums
+256 | | f: (),
+257 | | }
+ | |_____^
+
+error: #[pin_project] attribute may only be used on structs or enums
+ --> tests/ui/pin_project/invalid.rs:260:5
+ |
+260 | impl Impl {} //~ ERROR may only be used on structs or enums
+ | ^^^^^^^^^^^^
+
+error: #[pin_project] attribute may not be used on #[repr(packed)] types
+ --> tests/ui/pin_project/invalid.rs:268:12
+ |
+268 | #[repr(packed)]
+ | ^^^^^^
+
+error: #[pin_project] attribute may not be used on #[repr(packed)] types
+ --> tests/ui/pin_project/invalid.rs:272:12
+ |
+272 | #[repr(packed)]
+ | ^^^^^^
+
+error: #[pin_project] attribute may not be used on #[repr(packed)] types
+ --> tests/ui/pin_project/invalid.rs:276:12
+ |
+276 | #[repr(packed)]
+ | ^^^^^^
diff --git a/third_party/rust/pin-project/tests/ui/pin_project/overlapping_unpin_struct.rs b/third_party/rust/pin-project/tests/ui/pin_project/overlapping_unpin_struct.rs
new file mode 100644
index 0000000000..abfd5d1344
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pin_project/overlapping_unpin_struct.rs
@@ -0,0 +1,19 @@
+use std::marker::PhantomPinned;
+
+use pin_project::pin_project;
+
+#[pin_project]
+struct S<T> {
+ #[pin]
+ f: T,
+}
+
+struct __S {}
+
+impl Unpin for __S {}
+
+fn is_unpin<T: Unpin>() {}
+
+fn main() {
+ is_unpin::<S<PhantomPinned>>(); //~ ERROR E0277
+}
diff --git a/third_party/rust/pin-project/tests/ui/pin_project/overlapping_unpin_struct.stderr b/third_party/rust/pin-project/tests/ui/pin_project/overlapping_unpin_struct.stderr
new file mode 100644
index 0000000000..b9efd727f2
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pin_project/overlapping_unpin_struct.stderr
@@ -0,0 +1,26 @@
+error[E0277]: `PhantomPinned` cannot be unpinned
+ --> tests/ui/pin_project/overlapping_unpin_struct.rs:18:16
+ |
+18 | is_unpin::<S<PhantomPinned>>(); //~ ERROR E0277
+ | ^^^^^^^^^^^^^^^^ within `_::__S<'_, PhantomPinned>`, the trait `Unpin` is not implemented for `PhantomPinned`
+ |
+ = note: consider using the `pin!` macro
+ consider using `Box::pin` if you need to access the pinned value outside of the current scope
+note: required because it appears within the type `__S<'_, PhantomPinned>`
+ --> tests/ui/pin_project/overlapping_unpin_struct.rs:6:8
+ |
+6 | struct S<T> {
+ | ^
+note: required for `S<PhantomPinned>` to implement `Unpin`
+ --> tests/ui/pin_project/overlapping_unpin_struct.rs:5:1
+ |
+5 | #[pin_project]
+ | ^^^^^^^^^^^^^^ unsatisfied trait bound introduced in this `derive` macro
+6 | struct S<T> {
+ | ^^^^
+note: required by a bound in `is_unpin`
+ --> tests/ui/pin_project/overlapping_unpin_struct.rs:15:16
+ |
+15 | fn is_unpin<T: Unpin>() {}
+ | ^^^^^ required by this bound in `is_unpin`
+ = note: this error originates in the derive macro `::pin_project::__private::__PinProjectInternalDerive` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/third_party/rust/pin-project/tests/ui/pin_project/override-priv-mod.rs b/third_party/rust/pin-project/tests/ui/pin_project/override-priv-mod.rs
new file mode 100644
index 0000000000..890fd5b8de
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pin_project/override-priv-mod.rs
@@ -0,0 +1,32 @@
+// https://discord.com/channels/273534239310479360/512792629516173323/870075511009857617
+
+extern crate pin_project as pin_project_orig;
+extern crate self as pin_project;
+
+pub use ::pin_project_orig::*;
+mod __private {
+ pub use ::pin_project_orig::__private::*;
+ pub trait Drop {}
+}
+
+use std::{marker::PhantomPinned, mem};
+
+#[pin_project] //~ ERROR conflicting implementations of trait `_::FooMustNotImplDrop`
+struct S {
+ #[pin]
+ f: (u8, PhantomPinned),
+}
+
+impl Drop for S {
+ fn drop(&mut self) {
+ let prev = &self.f.0 as *const _ as usize;
+ let moved = mem::take(&mut self.f); // move pinned field
+ let moved = &moved.0 as *const _ as usize;
+ assert_eq!(prev, moved); // panic
+ }
+}
+
+fn main() {
+ let mut x = Box::pin(S { f: (1, PhantomPinned) });
+ let _f = x.as_mut().project().f; // first mutable access
+}
diff --git a/third_party/rust/pin-project/tests/ui/pin_project/override-priv-mod.stderr b/third_party/rust/pin-project/tests/ui/pin_project/override-priv-mod.stderr
new file mode 100644
index 0000000000..0c4825b506
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pin_project/override-priv-mod.stderr
@@ -0,0 +1,10 @@
+error[E0119]: conflicting implementations of trait `SMustNotImplDrop` for type `S`
+ --> tests/ui/pin_project/override-priv-mod.rs:14:1
+ |
+14 | #[pin_project] //~ ERROR conflicting implementations of trait `_::FooMustNotImplDrop`
+ | ^^^^^^^^^^^^^^
+ | |
+ | first implementation here
+ | conflicting implementation for `S`
+ |
+ = note: this error originates in the derive macro `::pin_project::__private::__PinProjectInternalDerive` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/third_party/rust/pin-project/tests/ui/pin_project/packed-enum.rs b/third_party/rust/pin-project/tests/ui/pin_project/packed-enum.rs
new file mode 100644
index 0000000000..023c08d14f
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pin_project/packed-enum.rs
@@ -0,0 +1,24 @@
+use pin_project::pin_project;
+
+// #[repr(packed)] cannot be apply on enums and will be rejected by rustc.
+// However, we should not rely on the behavior of rustc that rejects this.
+// https://github.com/taiki-e/pin-project/pull/324#discussion_r612388001
+
+#[repr(packed)] //~ ERROR E0517
+enum E1 {
+ V(()),
+}
+
+#[pin_project]
+#[repr(packed)] //~ ERROR E0517
+enum E2 {
+ V(()),
+}
+
+#[repr(packed)] //~ ERROR E0517
+#[pin_project]
+enum E3 {
+ V(()),
+}
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/ui/pin_project/packed-enum.stderr b/third_party/rust/pin-project/tests/ui/pin_project/packed-enum.stderr
new file mode 100644
index 0000000000..1872211206
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pin_project/packed-enum.stderr
@@ -0,0 +1,42 @@
+error: #[repr(packed)] attribute should be applied to a struct or union
+ --> tests/ui/pin_project/packed-enum.rs:13:8
+ |
+13 | #[repr(packed)] //~ ERROR E0517
+ | ^^^^^^
+
+error: #[repr(packed)] attribute should be applied to a struct or union
+ --> tests/ui/pin_project/packed-enum.rs:18:8
+ |
+18 | #[repr(packed)] //~ ERROR E0517
+ | ^^^^^^
+
+error[E0517]: attribute should be applied to a struct or union
+ --> tests/ui/pin_project/packed-enum.rs:7:8
+ |
+7 | #[repr(packed)] //~ ERROR E0517
+ | ^^^^^^
+8 | / enum E1 {
+9 | | V(()),
+10 | | }
+ | |_- not a struct or union
+
+error[E0517]: attribute should be applied to a struct or union
+ --> tests/ui/pin_project/packed-enum.rs:13:8
+ |
+13 | #[repr(packed)] //~ ERROR E0517
+ | ^^^^^^
+14 | / enum E2 {
+15 | | V(()),
+16 | | }
+ | |_- not a struct or union
+
+error[E0517]: attribute should be applied to a struct or union
+ --> tests/ui/pin_project/packed-enum.rs:18:8
+ |
+18 | #[repr(packed)] //~ ERROR E0517
+ | ^^^^^^
+19 | #[pin_project]
+20 | / enum E3 {
+21 | | V(()),
+22 | | }
+ | |_- not a struct or union
diff --git a/third_party/rust/pin-project/tests/ui/pin_project/packed-name-value.rs b/third_party/rust/pin-project/tests/ui/pin_project/packed-name-value.rs
new file mode 100644
index 0000000000..dedc4030fa
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pin_project/packed-name-value.rs
@@ -0,0 +1,27 @@
+use pin_project::pin_project;
+
+// #[repr(packed = "")] is not valid format of #[repr(packed)] and will be
+// rejected by rustc.
+// However, we should not rely on the behavior of rustc that rejects this.
+// https://github.com/taiki-e/pin-project/pull/324#discussion_r612388001
+
+// https://github.com/taiki-e/pin-project/pull/324#discussion_r612388001
+// https://github.com/rust-lang/rust/issues/83921
+// #[repr(packed = "")] //~ ERROR E0552
+// struct S1 {
+// f: (),
+// }
+
+#[pin_project]
+#[repr(packed = "")] //~ ERROR attribute should not be name-value pair
+struct S2 {
+ f: (),
+}
+
+#[repr(packed = "")] //~ ERROR attribute should not be name-value pair
+#[pin_project]
+struct S3 {
+ f: (),
+}
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/ui/pin_project/packed-name-value.stderr b/third_party/rust/pin-project/tests/ui/pin_project/packed-name-value.stderr
new file mode 100644
index 0000000000..d8b2194713
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pin_project/packed-name-value.stderr
@@ -0,0 +1,23 @@
+error: #[repr(packed)] attribute should not be name-value pair
+ --> tests/ui/pin_project/packed-name-value.rs:16:8
+ |
+16 | #[repr(packed = "")] //~ ERROR attribute should not be name-value pair
+ | ^^^^^^^^^^^
+
+error: #[repr(packed)] attribute should not be name-value pair
+ --> tests/ui/pin_project/packed-name-value.rs:21:8
+ |
+21 | #[repr(packed = "")] //~ ERROR attribute should not be name-value pair
+ | ^^^^^^^^^^^
+
+error[E0693]: incorrect `repr(packed)` attribute format
+ --> tests/ui/pin_project/packed-name-value.rs:16:8
+ |
+16 | #[repr(packed = "")] //~ ERROR attribute should not be name-value pair
+ | ^^^^^^^^^^^ help: use parentheses instead: `packed()`
+
+error[E0693]: incorrect `repr(packed)` attribute format
+ --> tests/ui/pin_project/packed-name-value.rs:21:8
+ |
+21 | #[repr(packed = "")] //~ ERROR attribute should not be name-value pair
+ | ^^^^^^^^^^^ help: use parentheses instead: `packed()`
diff --git a/third_party/rust/pin-project/tests/ui/pin_project/packed.rs b/third_party/rust/pin-project/tests/ui/pin_project/packed.rs
new file mode 100644
index 0000000000..dd3ebfd638
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pin_project/packed.rs
@@ -0,0 +1,33 @@
+use pin_project::pin_project;
+
+#[pin_project]
+#[repr(packed, C)] //~ ERROR may not be used on #[repr(packed)] types
+struct Packed1 {
+ #[pin]
+ f: u8,
+}
+
+// Test putting 'repr' before the 'pin_project' attribute
+#[repr(packed, C)] //~ ERROR may not be used on #[repr(packed)] types
+#[pin_project]
+struct Packed2 {
+ #[pin]
+ f: u8,
+}
+
+#[pin_project]
+#[repr(packed(2))] //~ ERROR may not be used on #[repr(packed)] types
+struct PackedN1 {
+ #[pin]
+ f: u32,
+}
+
+// Test putting 'repr' before the 'pin_project' attribute
+#[repr(packed(2))] //~ ERROR may not be used on #[repr(packed)] types
+#[pin_project]
+struct PackedN2 {
+ #[pin]
+ f: u32,
+}
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/ui/pin_project/packed.stderr b/third_party/rust/pin-project/tests/ui/pin_project/packed.stderr
new file mode 100644
index 0000000000..25ea5f43e4
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pin_project/packed.stderr
@@ -0,0 +1,23 @@
+error: #[pin_project] attribute may not be used on #[repr(packed)] types
+ --> tests/ui/pin_project/packed.rs:4:8
+ |
+4 | #[repr(packed, C)] //~ ERROR may not be used on #[repr(packed)] types
+ | ^^^^^^
+
+error: #[pin_project] attribute may not be used on #[repr(packed)] types
+ --> tests/ui/pin_project/packed.rs:11:8
+ |
+11 | #[repr(packed, C)] //~ ERROR may not be used on #[repr(packed)] types
+ | ^^^^^^
+
+error: #[pin_project] attribute may not be used on #[repr(packed)] types
+ --> tests/ui/pin_project/packed.rs:19:8
+ |
+19 | #[repr(packed(2))] //~ ERROR may not be used on #[repr(packed)] types
+ | ^^^^^^^^^
+
+error: #[pin_project] attribute may not be used on #[repr(packed)] types
+ --> tests/ui/pin_project/packed.rs:26:8
+ |
+26 | #[repr(packed(2))] //~ ERROR may not be used on #[repr(packed)] types
+ | ^^^^^^^^^
diff --git a/third_party/rust/pin-project/tests/ui/pin_project/packed_sneaky-1.rs b/third_party/rust/pin-project/tests/ui/pin_project/packed_sneaky-1.rs
new file mode 100644
index 0000000000..83a46122cc
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pin_project/packed_sneaky-1.rs
@@ -0,0 +1,41 @@
+use std::pin::Pin;
+
+use auxiliary_macro::{hidden_repr, hidden_repr2};
+use pin_project::{pin_project, pinned_drop, UnsafeUnpin};
+
+#[pin_project] //~ ERROR may not be used on #[repr(packed)] types
+#[hidden_repr(packed)]
+struct A {
+ #[pin]
+ f: u32,
+}
+
+#[hidden_repr2]
+#[pin_project] //~ ERROR may not be used on #[repr(packed)] types
+struct B {
+ #[pin]
+ f: u32,
+}
+
+#[pin_project(UnsafeUnpin)] //~ ERROR may not be used on #[repr(packed)] types
+#[hidden_repr(packed)]
+struct C {
+ #[pin]
+ f: u32,
+}
+
+unsafe impl UnsafeUnpin for C {}
+
+#[pin_project(PinnedDrop)] //~ ERROR may not be used on #[repr(packed)] types
+#[hidden_repr(packed)]
+struct D {
+ #[pin]
+ f: u32,
+}
+
+#[pinned_drop]
+impl PinnedDrop for D {
+ fn drop(self: Pin<&mut Self>) {}
+}
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/ui/pin_project/packed_sneaky-1.stderr b/third_party/rust/pin-project/tests/ui/pin_project/packed_sneaky-1.stderr
new file mode 100644
index 0000000000..0746e1a21c
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pin_project/packed_sneaky-1.stderr
@@ -0,0 +1,25 @@
+error: #[pin_project] attribute may not be used on #[repr(packed)] types
+ --> tests/ui/pin_project/packed_sneaky-1.rs:7:15
+ |
+7 | #[hidden_repr(packed)]
+ | ^^^^^^
+
+error: #[pin_project] attribute may not be used on #[repr(packed)] types
+ --> tests/ui/pin_project/packed_sneaky-1.rs:13:1
+ |
+13 | #[hidden_repr2]
+ | ^^^^^^^^^^^^^^^
+ |
+ = note: this error originates in the attribute macro `hidden_repr2` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: #[pin_project] attribute may not be used on #[repr(packed)] types
+ --> tests/ui/pin_project/packed_sneaky-1.rs:21:15
+ |
+21 | #[hidden_repr(packed)]
+ | ^^^^^^
+
+error: #[pin_project] attribute may not be used on #[repr(packed)] types
+ --> tests/ui/pin_project/packed_sneaky-1.rs:30:15
+ |
+30 | #[hidden_repr(packed)]
+ | ^^^^^^
diff --git a/third_party/rust/pin-project/tests/ui/pin_project/packed_sneaky-2.rs b/third_party/rust/pin-project/tests/ui/pin_project/packed_sneaky-2.rs
new file mode 100644
index 0000000000..b098358e6f
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pin_project/packed_sneaky-2.rs
@@ -0,0 +1,12 @@
+use auxiliary_macro::hidden_repr_macro;
+use pin_project::pin_project;
+
+hidden_repr_macro! { //~ ERROR may not be used on #[repr(packed)] types
+ #[pin_project]
+ struct B {
+ #[pin]
+ f: u32,
+ }
+}
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/ui/pin_project/packed_sneaky-2.stderr b/third_party/rust/pin-project/tests/ui/pin_project/packed_sneaky-2.stderr
new file mode 100644
index 0000000000..d643052fda
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pin_project/packed_sneaky-2.stderr
@@ -0,0 +1,13 @@
+error: #[pin_project] attribute may not be used on #[repr(packed)] types
+ --> tests/ui/pin_project/packed_sneaky-2.rs:4:1
+ |
+4 | / hidden_repr_macro! { //~ ERROR may not be used on #[repr(packed)] types
+5 | | #[pin_project]
+6 | | struct B {
+7 | | #[pin]
+8 | | f: u32,
+9 | | }
+10 | | }
+ | |_^
+ |
+ = note: this error originates in the macro `hidden_repr_macro` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/third_party/rust/pin-project/tests/ui/pin_project/packed_sneaky-3.rs b/third_party/rust/pin-project/tests/ui/pin_project/packed_sneaky-3.rs
new file mode 100644
index 0000000000..d3f00f3d23
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pin_project/packed_sneaky-3.rs
@@ -0,0 +1,32 @@
+use auxiliary_macro::{hidden_repr_macro, HiddenRepr};
+use pin_project::pin_project;
+
+hidden_repr_macro! {} //~ ERROR expected item after attributes
+#[pin_project]
+struct S1 {
+ #[pin]
+ f: u32,
+}
+
+macro_rules! hidden_repr_macro2 {
+ () => {
+ #[repr(packed)] //~ ERROR expected item after attributes
+ };
+}
+
+hidden_repr_macro2! {}
+#[pin_project]
+struct S2 {
+ #[pin]
+ f: u32,
+}
+
+#[derive(HiddenRepr)] //~ ERROR expected item after attributes
+struct S3 {}
+#[pin_project]
+struct S4 {
+ #[pin]
+ f: u32,
+}
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/ui/pin_project/packed_sneaky-3.stderr b/third_party/rust/pin-project/tests/ui/pin_project/packed_sneaky-3.stderr
new file mode 100644
index 0000000000..c181bb3152
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pin_project/packed_sneaky-3.stderr
@@ -0,0 +1,32 @@
+error: expected item after attributes
+ --> tests/ui/pin_project/packed_sneaky-3.rs:4:1
+ |
+4 | hidden_repr_macro! {} //~ ERROR expected item after attributes
+ | ^^^^^^^^^^^^^^^^^^^^^
+ |
+ = note: this error originates in the macro `hidden_repr_macro` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: expected item after attributes
+ --> tests/ui/pin_project/packed_sneaky-3.rs:13:9
+ |
+13 | #[repr(packed)] //~ ERROR expected item after attributes
+ | ^^^^^^^^^^^^^^^
+...
+17 | hidden_repr_macro2! {}
+ | ---------------------- in this macro invocation
+ |
+ = note: this error originates in the macro `hidden_repr_macro2` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: expected item after attributes
+ --> tests/ui/pin_project/packed_sneaky-3.rs:24:10
+ |
+24 | #[derive(HiddenRepr)] //~ ERROR expected item after attributes
+ | ^^^^^^^^^^
+ |
+ = note: this error originates in the derive macro `HiddenRepr` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: proc-macro derive produced unparsable tokens
+ --> tests/ui/pin_project/packed_sneaky-3.rs:24:10
+ |
+24 | #[derive(HiddenRepr)] //~ ERROR expected item after attributes
+ | ^^^^^^^^^^
diff --git a/third_party/rust/pin-project/tests/ui/pin_project/packed_sneaky-4.rs b/third_party/rust/pin-project/tests/ui/pin_project/packed_sneaky-4.rs
new file mode 100644
index 0000000000..4f409071ea
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pin_project/packed_sneaky-4.rs
@@ -0,0 +1,13 @@
+// https://github.com/taiki-e/pin-project/issues/342
+
+use auxiliary_macro::hidden_repr2;
+use pin_project::pin_project;
+
+#[pin_project] //~ ERROR reference to packed field is unaligned
+#[hidden_repr2]
+struct A {
+ #[pin]
+ f: u32,
+}
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/ui/pin_project/packed_sneaky-4.stderr b/third_party/rust/pin-project/tests/ui/pin_project/packed_sneaky-4.stderr
new file mode 100644
index 0000000000..2c24367c44
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pin_project/packed_sneaky-4.stderr
@@ -0,0 +1,20 @@
+error[E0793]: reference to packed field is unaligned
+ --> tests/ui/pin_project/packed_sneaky-4.rs:10:5
+ |
+10 | f: u32,
+ | ^
+ |
+ = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
+ = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
+ = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
+
+error[E0793]: reference to packed field is unaligned
+ --> tests/ui/pin_project/packed_sneaky-4.rs:6:1
+ |
+6 | #[pin_project] //~ ERROR reference to packed field is unaligned
+ | ^^^^^^^^^^^^^^
+ |
+ = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
+ = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
+ = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
+ = note: this error originates in the derive macro `::pin_project::__private::__PinProjectInternalDerive` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/third_party/rust/pin-project/tests/ui/pin_project/private_in_public-enum.rs b/third_party/rust/pin-project/tests/ui/pin_project/private_in_public-enum.rs
new file mode 100644
index 0000000000..d55baebad1
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pin_project/private_in_public-enum.rs
@@ -0,0 +1,23 @@
+// Even if allows private_in_public, these are errors.
+
+#![allow(private_in_public, dead_code)]
+
+pub enum PublicEnum {
+ V(PrivateEnum), //~ ERROR E0446
+}
+
+enum PrivateEnum {
+ V(u8),
+}
+
+mod foo {
+ pub(crate) enum CrateEnum {
+ V(PrivateEnum), //~ ERROR E0446
+ }
+
+ enum PrivateEnum {
+ V(u8),
+ }
+}
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/ui/pin_project/private_in_public-enum.stderr b/third_party/rust/pin-project/tests/ui/pin_project/private_in_public-enum.stderr
new file mode 100644
index 0000000000..c93b265916
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pin_project/private_in_public-enum.stderr
@@ -0,0 +1,17 @@
+error[E0446]: private type `PrivateEnum` in public interface
+ --> tests/ui/pin_project/private_in_public-enum.rs:6:7
+ |
+6 | V(PrivateEnum), //~ ERROR E0446
+ | ^^^^^^^^^^^ can't leak private type
+...
+9 | enum PrivateEnum {
+ | ---------------- `PrivateEnum` declared as private
+
+error[E0446]: private type `foo::PrivateEnum` in public interface
+ --> tests/ui/pin_project/private_in_public-enum.rs:15:11
+ |
+15 | V(PrivateEnum), //~ ERROR E0446
+ | ^^^^^^^^^^^ can't leak private type
+...
+18 | enum PrivateEnum {
+ | ---------------- `foo::PrivateEnum` declared as private
diff --git a/third_party/rust/pin-project/tests/ui/pin_project/project_replace_unsized.rs b/third_party/rust/pin-project/tests/ui/pin_project/project_replace_unsized.rs
new file mode 100644
index 0000000000..20dde12bd3
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pin_project/project_replace_unsized.rs
@@ -0,0 +1,11 @@
+use pin_project::pin_project;
+
+#[pin_project(project_replace)] //~ ERROR E0277
+struct Struct<T: ?Sized> {
+ f: T,
+}
+
+#[pin_project(project_replace)] //~ ERROR E0277
+struct TupleStruct<T: ?Sized>(T);
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/ui/pin_project/project_replace_unsized.stderr b/third_party/rust/pin-project/tests/ui/pin_project/project_replace_unsized.stderr
new file mode 100644
index 0000000000..b6c6da322d
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pin_project/project_replace_unsized.stderr
@@ -0,0 +1,124 @@
+error[E0277]: the size for values of type `T` cannot be known at compilation time
+ --> tests/ui/pin_project/project_replace_unsized.rs:3:15
+ |
+3 | #[pin_project(project_replace)] //~ ERROR E0277
+ | ^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
+4 | struct Struct<T: ?Sized> {
+ | - this type parameter needs to be `std::marker::Sized`
+ |
+note: required because it appears within the type `Struct<T>`
+ --> tests/ui/pin_project/project_replace_unsized.rs:4:8
+ |
+4 | struct Struct<T: ?Sized> {
+ | ^^^^^^
+ = help: unsized fn params are gated as an unstable feature
+help: consider removing the `?Sized` bound to make the type parameter `Sized`
+ |
+4 - struct Struct<T: ?Sized> {
+4 + struct Struct<T> {
+ |
+help: function arguments must have a statically known size, borrowed types always have a known size
+ |
+3 | #[pin_project(&project_replace)] //~ ERROR E0277
+ | +
+
+error[E0277]: the size for values of type `T` cannot be known at compilation time
+ --> tests/ui/pin_project/project_replace_unsized.rs:3:1
+ |
+3 | #[pin_project(project_replace)] //~ ERROR E0277
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
+4 | struct Struct<T: ?Sized> {
+ | - this type parameter needs to be `std::marker::Sized`
+ |
+note: required because it appears within the type `Struct<T>`
+ --> tests/ui/pin_project/project_replace_unsized.rs:4:8
+ |
+4 | struct Struct<T: ?Sized> {
+ | ^^^^^^
+note: required by a bound in `UnsafeOverwriteGuard::<T>::new`
+ --> src/lib.rs
+ |
+ | impl<T> UnsafeOverwriteGuard<T> {
+ | ^ required by this bound in `UnsafeOverwriteGuard::<T>::new`
+ | #[doc(hidden)]
+ | pub unsafe fn new(target: *mut T, value: T) -> Self {
+ | --- required by a bound in this associated function
+ = note: this error originates in the derive macro `::pin_project::__private::__PinProjectInternalDerive` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: consider removing the `?Sized` bound to make the type parameter `Sized`
+ |
+4 - struct Struct<T: ?Sized> {
+4 + struct Struct<T> {
+ |
+
+error[E0277]: the size for values of type `T` cannot be known at compilation time
+ --> tests/ui/pin_project/project_replace_unsized.rs:5:5
+ |
+3 | #[pin_project(project_replace)] //~ ERROR E0277
+ | ------------------------------- required by a bound introduced by this call
+4 | struct Struct<T: ?Sized> {
+ | - this type parameter needs to be `std::marker::Sized`
+5 | f: T,
+ | ^ doesn't have a size known at compile-time
+ |
+note: required by a bound in `std::ptr::read`
+ --> $RUST/core/src/ptr/mod.rs
+ |
+ | pub const unsafe fn read<T>(src: *const T) -> T {
+ | ^ required by this bound in `read`
+help: consider removing the `?Sized` bound to make the type parameter `Sized`
+ |
+4 - struct Struct<T: ?Sized> {
+4 + struct Struct<T> {
+ |
+
+error[E0277]: the size for values of type `T` cannot be known at compilation time
+ --> tests/ui/pin_project/project_replace_unsized.rs:8:15
+ |
+8 | #[pin_project(project_replace)] //~ ERROR E0277
+ | ^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
+9 | struct TupleStruct<T: ?Sized>(T);
+ | - this type parameter needs to be `std::marker::Sized`
+ |
+note: required because it appears within the type `TupleStruct<T>`
+ --> tests/ui/pin_project/project_replace_unsized.rs:9:8
+ |
+9 | struct TupleStruct<T: ?Sized>(T);
+ | ^^^^^^^^^^^
+ = help: unsized fn params are gated as an unstable feature
+help: consider removing the `?Sized` bound to make the type parameter `Sized`
+ |
+9 - struct TupleStruct<T: ?Sized>(T);
+9 + struct TupleStruct<T>(T);
+ |
+help: function arguments must have a statically known size, borrowed types always have a known size
+ |
+8 | #[pin_project(&project_replace)] //~ ERROR E0277
+ | +
+
+error[E0277]: the size for values of type `T` cannot be known at compilation time
+ --> tests/ui/pin_project/project_replace_unsized.rs:8:1
+ |
+8 | #[pin_project(project_replace)] //~ ERROR E0277
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
+9 | struct TupleStruct<T: ?Sized>(T);
+ | - this type parameter needs to be `std::marker::Sized`
+ |
+note: required because it appears within the type `TupleStruct<T>`
+ --> tests/ui/pin_project/project_replace_unsized.rs:9:8
+ |
+9 | struct TupleStruct<T: ?Sized>(T);
+ | ^^^^^^^^^^^
+note: required by a bound in `UnsafeOverwriteGuard::<T>::new`
+ --> src/lib.rs
+ |
+ | impl<T> UnsafeOverwriteGuard<T> {
+ | ^ required by this bound in `UnsafeOverwriteGuard::<T>::new`
+ | #[doc(hidden)]
+ | pub unsafe fn new(target: *mut T, value: T) -> Self {
+ | --- required by a bound in this associated function
+ = note: this error originates in the derive macro `::pin_project::__private::__PinProjectInternalDerive` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: consider removing the `?Sized` bound to make the type parameter `Sized`
+ |
+9 - struct TupleStruct<T: ?Sized>(T);
+9 + struct TupleStruct<T>(T);
+ |
diff --git a/third_party/rust/pin-project/tests/ui/pin_project/project_replace_unsized_fn_params.rs b/third_party/rust/pin-project/tests/ui/pin_project/project_replace_unsized_fn_params.rs
new file mode 100644
index 0000000000..e0fa25bf7d
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pin_project/project_replace_unsized_fn_params.rs
@@ -0,0 +1,13 @@
+#![feature(unsized_fn_params)]
+
+use pin_project::pin_project;
+
+#[pin_project(project_replace)] //~ ERROR E0277
+struct Struct<T: ?Sized> {
+ f: T,
+}
+
+#[pin_project(project_replace)] //~ ERROR E0277
+struct TupleStruct<T: ?Sized>(T);
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/ui/pin_project/project_replace_unsized_fn_params.stderr b/third_party/rust/pin-project/tests/ui/pin_project/project_replace_unsized_fn_params.stderr
new file mode 100644
index 0000000000..bef6ff9ebc
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pin_project/project_replace_unsized_fn_params.stderr
@@ -0,0 +1,118 @@
+error[E0277]: the size for values of type `T` cannot be known at compilation time
+ --> tests/ui/pin_project/project_replace_unsized_fn_params.rs:6:8
+ |
+6 | struct Struct<T: ?Sized> {
+ | ^^^^^^^-^^^^^^^^^
+ | | |
+ | | this type parameter needs to be `std::marker::Sized`
+ | doesn't have a size known at compile-time
+ |
+note: required because it appears within the type `__StructProjectionOwned<T>`
+ --> tests/ui/pin_project/project_replace_unsized_fn_params.rs:6:8
+ |
+6 | struct Struct<T: ?Sized> {
+ | ^^^^^^
+ = note: the return type of a function must have a statically known size
+help: consider removing the `?Sized` bound to make the type parameter `Sized`
+ |
+6 - struct Struct<T: ?Sized> {
+6 + struct Struct<T> {
+ |
+
+error[E0277]: the size for values of type `T` cannot be known at compilation time
+ --> tests/ui/pin_project/project_replace_unsized_fn_params.rs:5:1
+ |
+5 | #[pin_project(project_replace)] //~ ERROR E0277
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
+6 | struct Struct<T: ?Sized> {
+ | - this type parameter needs to be `std::marker::Sized`
+ |
+note: required because it appears within the type `Struct<T>`
+ --> tests/ui/pin_project/project_replace_unsized_fn_params.rs:6:8
+ |
+6 | struct Struct<T: ?Sized> {
+ | ^^^^^^
+note: required by a bound in `UnsafeOverwriteGuard::<T>::new`
+ --> src/lib.rs
+ |
+ | impl<T> UnsafeOverwriteGuard<T> {
+ | ^ required by this bound in `UnsafeOverwriteGuard::<T>::new`
+ | #[doc(hidden)]
+ | pub unsafe fn new(target: *mut T, value: T) -> Self {
+ | --- required by a bound in this associated function
+ = note: this error originates in the derive macro `::pin_project::__private::__PinProjectInternalDerive` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: consider removing the `?Sized` bound to make the type parameter `Sized`
+ |
+6 - struct Struct<T: ?Sized> {
+6 + struct Struct<T> {
+ |
+
+error[E0277]: the size for values of type `T` cannot be known at compilation time
+ --> tests/ui/pin_project/project_replace_unsized_fn_params.rs:7:5
+ |
+5 | #[pin_project(project_replace)] //~ ERROR E0277
+ | ------------------------------- required by a bound introduced by this call
+6 | struct Struct<T: ?Sized> {
+ | - this type parameter needs to be `std::marker::Sized`
+7 | f: T,
+ | ^ doesn't have a size known at compile-time
+ |
+note: required by a bound in `std::ptr::read`
+ --> $RUST/core/src/ptr/mod.rs
+ |
+ | pub const unsafe fn read<T>(src: *const T) -> T {
+ | ^ required by this bound in `read`
+help: consider removing the `?Sized` bound to make the type parameter `Sized`
+ |
+6 - struct Struct<T: ?Sized> {
+6 + struct Struct<T> {
+ |
+
+error[E0277]: the size for values of type `T` cannot be known at compilation time
+ --> tests/ui/pin_project/project_replace_unsized_fn_params.rs:11:8
+ |
+11 | struct TupleStruct<T: ?Sized>(T);
+ | ^^^^^^^^^^^^-^^^^^^^^^
+ | | |
+ | | this type parameter needs to be `std::marker::Sized`
+ | doesn't have a size known at compile-time
+ |
+note: required because it appears within the type `__TupleStructProjectionOwned<T>`
+ --> tests/ui/pin_project/project_replace_unsized_fn_params.rs:11:8
+ |
+11 | struct TupleStruct<T: ?Sized>(T);
+ | ^^^^^^^^^^^
+ = note: the return type of a function must have a statically known size
+help: consider removing the `?Sized` bound to make the type parameter `Sized`
+ |
+11 - struct TupleStruct<T: ?Sized>(T);
+11 + struct TupleStruct<T>(T);
+ |
+
+error[E0277]: the size for values of type `T` cannot be known at compilation time
+ --> tests/ui/pin_project/project_replace_unsized_fn_params.rs:10:1
+ |
+10 | #[pin_project(project_replace)] //~ ERROR E0277
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
+11 | struct TupleStruct<T: ?Sized>(T);
+ | - this type parameter needs to be `std::marker::Sized`
+ |
+note: required because it appears within the type `TupleStruct<T>`
+ --> tests/ui/pin_project/project_replace_unsized_fn_params.rs:11:8
+ |
+11 | struct TupleStruct<T: ?Sized>(T);
+ | ^^^^^^^^^^^
+note: required by a bound in `UnsafeOverwriteGuard::<T>::new`
+ --> src/lib.rs
+ |
+ | impl<T> UnsafeOverwriteGuard<T> {
+ | ^ required by this bound in `UnsafeOverwriteGuard::<T>::new`
+ | #[doc(hidden)]
+ | pub unsafe fn new(target: *mut T, value: T) -> Self {
+ | --- required by a bound in this associated function
+ = note: this error originates in the derive macro `::pin_project::__private::__PinProjectInternalDerive` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: consider removing the `?Sized` bound to make the type parameter `Sized`
+ |
+11 - struct TupleStruct<T: ?Sized>(T);
+11 + struct TupleStruct<T>(T);
+ |
diff --git a/third_party/rust/pin-project/tests/ui/pin_project/remove-attr-from-field.rs b/third_party/rust/pin-project/tests/ui/pin_project/remove-attr-from-field.rs
new file mode 100644
index 0000000000..fd14da37c1
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pin_project/remove-attr-from-field.rs
@@ -0,0 +1,33 @@
+use std::{marker::PhantomPinned, pin::Pin};
+
+use auxiliary_macro::remove_attr;
+use pin_project::pin_project;
+
+fn is_unpin<T: Unpin>() {}
+
+#[pin_project]
+#[remove_attr(field_all)]
+struct A {
+ #[pin]
+ f: PhantomPinned,
+}
+
+#[remove_attr(field_all)]
+#[pin_project]
+struct B {
+ #[pin]
+ f: PhantomPinned,
+}
+
+fn main() {
+ is_unpin::<A>();
+ is_unpin::<B>();
+
+ let mut x = A { f: PhantomPinned };
+ let x = Pin::new(&mut x).project();
+ let _: Pin<&mut PhantomPinned> = x.f; //~ ERROR E0308
+
+ let mut x = B { f: PhantomPinned };
+ let x = Pin::new(&mut x).project();
+ let _: Pin<&mut PhantomPinned> = x.f; //~ ERROR E0308
+}
diff --git a/third_party/rust/pin-project/tests/ui/pin_project/remove-attr-from-field.stderr b/third_party/rust/pin-project/tests/ui/pin_project/remove-attr-from-field.stderr
new file mode 100644
index 0000000000..f693261ad7
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pin_project/remove-attr-from-field.stderr
@@ -0,0 +1,21 @@
+error[E0308]: mismatched types
+ --> tests/ui/pin_project/remove-attr-from-field.rs:28:38
+ |
+28 | let _: Pin<&mut PhantomPinned> = x.f; //~ ERROR E0308
+ | ----------------------- ^^^ expected `Pin<&mut PhantomPinned>`, found `&mut PhantomPinned`
+ | |
+ | expected due to this
+ |
+ = note: expected struct `Pin<&mut PhantomPinned>`
+ found mutable reference `&mut PhantomPinned`
+
+error[E0308]: mismatched types
+ --> tests/ui/pin_project/remove-attr-from-field.rs:32:38
+ |
+32 | let _: Pin<&mut PhantomPinned> = x.f; //~ ERROR E0308
+ | ----------------------- ^^^ expected `Pin<&mut PhantomPinned>`, found `&mut PhantomPinned`
+ | |
+ | expected due to this
+ |
+ = note: expected struct `Pin<&mut PhantomPinned>`
+ found mutable reference `&mut PhantomPinned`
diff --git a/third_party/rust/pin-project/tests/ui/pin_project/remove-attr-from-struct.rs b/third_party/rust/pin-project/tests/ui/pin_project/remove-attr-from-struct.rs
new file mode 100644
index 0000000000..cbe5aba234
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pin_project/remove-attr-from-struct.rs
@@ -0,0 +1,47 @@
+use std::{marker::PhantomPinned, pin::Pin};
+
+use auxiliary_macro::remove_attr;
+use pin_project::pin_project;
+
+fn is_unpin<T: Unpin>() {}
+
+#[pin_project]
+#[remove_attr(struct_all)]
+struct A {
+ #[pin] //~ ERROR cannot find attribute `pin` in this scope
+ f: PhantomPinned,
+}
+
+#[remove_attr(struct_all)]
+#[pin_project]
+struct B {
+ #[pin] //~ ERROR cannot find attribute `pin` in this scope
+ f: PhantomPinned,
+}
+
+#[pin_project] //~ ERROR has been removed
+#[remove_attr(struct_pin)]
+struct C {
+ f: PhantomPinned,
+}
+
+#[remove_attr(struct_pin)]
+#[pin_project] // Ok
+struct D {
+ f: PhantomPinned,
+}
+
+fn main() {
+ is_unpin::<A>(); //~ ERROR E0277
+ is_unpin::<B>(); //~ ERROR E0277
+ is_unpin::<D>(); // Ok
+
+ let mut x = A { f: PhantomPinned };
+ let _ = Pin::new(&mut x).project(); //~ ERROR E0277,E0599
+
+ let mut x = B { f: PhantomPinned };
+ let _ = Pin::new(&mut x).project(); //~ ERROR E0277,E0599
+
+ let mut x = D { f: PhantomPinned };
+ let _ = Pin::new(&mut x).project(); //~ Ok
+}
diff --git a/third_party/rust/pin-project/tests/ui/pin_project/remove-attr-from-struct.stderr b/third_party/rust/pin-project/tests/ui/pin_project/remove-attr-from-struct.stderr
new file mode 100644
index 0000000000..0b440dd9f9
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pin_project/remove-attr-from-struct.stderr
@@ -0,0 +1,117 @@
+error: #[pin_project] attribute has been removed
+ --> tests/ui/pin_project/remove-attr-from-struct.rs:22:1
+ |
+22 | #[pin_project] //~ ERROR has been removed
+ | ^^^^^^^^^^^^^^
+ |
+ = note: this error originates in the derive macro `::pin_project::__private::__PinProjectInternalDerive` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: cannot find attribute `pin` in this scope
+ --> tests/ui/pin_project/remove-attr-from-struct.rs:18:7
+ |
+18 | #[pin] //~ ERROR cannot find attribute `pin` in this scope
+ | ^^^
+
+error: cannot find attribute `pin` in this scope
+ --> tests/ui/pin_project/remove-attr-from-struct.rs:11:7
+ |
+11 | #[pin] //~ ERROR cannot find attribute `pin` in this scope
+ | ^^^
+
+error[E0277]: `PhantomPinned` cannot be unpinned
+ --> tests/ui/pin_project/remove-attr-from-struct.rs:35:16
+ |
+35 | is_unpin::<A>(); //~ ERROR E0277
+ | ^ within `A`, the trait `Unpin` is not implemented for `PhantomPinned`
+ |
+ = note: consider using the `pin!` macro
+ consider using `Box::pin` if you need to access the pinned value outside of the current scope
+note: required because it appears within the type `A`
+ --> tests/ui/pin_project/remove-attr-from-struct.rs:10:8
+ |
+10 | struct A {
+ | ^
+note: required by a bound in `is_unpin`
+ --> tests/ui/pin_project/remove-attr-from-struct.rs:6:16
+ |
+6 | fn is_unpin<T: Unpin>() {}
+ | ^^^^^ required by this bound in `is_unpin`
+
+error[E0277]: `PhantomPinned` cannot be unpinned
+ --> tests/ui/pin_project/remove-attr-from-struct.rs:36:16
+ |
+36 | is_unpin::<B>(); //~ ERROR E0277
+ | ^ within `B`, the trait `Unpin` is not implemented for `PhantomPinned`
+ |
+ = note: consider using the `pin!` macro
+ consider using `Box::pin` if you need to access the pinned value outside of the current scope
+note: required because it appears within the type `B`
+ --> tests/ui/pin_project/remove-attr-from-struct.rs:17:8
+ |
+17 | struct B {
+ | ^
+note: required by a bound in `is_unpin`
+ --> tests/ui/pin_project/remove-attr-from-struct.rs:6:16
+ |
+6 | fn is_unpin<T: Unpin>() {}
+ | ^^^^^ required by this bound in `is_unpin`
+
+error[E0277]: `PhantomPinned` cannot be unpinned
+ --> tests/ui/pin_project/remove-attr-from-struct.rs:40:22
+ |
+40 | let _ = Pin::new(&mut x).project(); //~ ERROR E0277,E0599
+ | -------- ^^^^^^ within `A`, the trait `Unpin` is not implemented for `PhantomPinned`
+ | |
+ | required by a bound introduced by this call
+ |
+ = note: consider using the `pin!` macro
+ consider using `Box::pin` if you need to access the pinned value outside of the current scope
+note: required because it appears within the type `A`
+ --> tests/ui/pin_project/remove-attr-from-struct.rs:10:8
+ |
+10 | struct A {
+ | ^
+note: required by a bound in `Pin::<P>::new`
+ --> $RUST/core/src/pin.rs
+ |
+ | impl<P: Deref<Target: Unpin>> Pin<P> {
+ | ^^^^^ required by this bound in `Pin::<P>::new`
+...
+ | pub const fn new(pointer: P) -> Pin<P> {
+ | --- required by a bound in this associated function
+
+error[E0599]: no method named `project` found for struct `Pin<&mut A>` in the current scope
+ --> tests/ui/pin_project/remove-attr-from-struct.rs:40:30
+ |
+40 | let _ = Pin::new(&mut x).project(); //~ ERROR E0277,E0599
+ | ^^^^^^^ method not found in `Pin<&mut A>`
+
+error[E0277]: `PhantomPinned` cannot be unpinned
+ --> tests/ui/pin_project/remove-attr-from-struct.rs:43:22
+ |
+43 | let _ = Pin::new(&mut x).project(); //~ ERROR E0277,E0599
+ | -------- ^^^^^^ within `B`, the trait `Unpin` is not implemented for `PhantomPinned`
+ | |
+ | required by a bound introduced by this call
+ |
+ = note: consider using the `pin!` macro
+ consider using `Box::pin` if you need to access the pinned value outside of the current scope
+note: required because it appears within the type `B`
+ --> tests/ui/pin_project/remove-attr-from-struct.rs:17:8
+ |
+17 | struct B {
+ | ^
+note: required by a bound in `Pin::<P>::new`
+ --> $RUST/core/src/pin.rs
+ |
+ | impl<P: Deref<Target: Unpin>> Pin<P> {
+ | ^^^^^ required by this bound in `Pin::<P>::new`
+...
+ | pub const fn new(pointer: P) -> Pin<P> {
+ | --- required by a bound in this associated function
+
+error[E0599]: no method named `project` found for struct `Pin<&mut B>` in the current scope
+ --> tests/ui/pin_project/remove-attr-from-struct.rs:43:30
+ |
+43 | let _ = Pin::new(&mut x).project(); //~ ERROR E0277,E0599
+ | ^^^^^^^ method not found in `Pin<&mut B>`
diff --git a/third_party/rust/pin-project/tests/ui/pin_project/safe_packed_borrows.rs b/third_party/rust/pin-project/tests/ui/pin_project/safe_packed_borrows.rs
new file mode 100644
index 0000000000..8ef144cce1
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pin_project/safe_packed_borrows.rs
@@ -0,0 +1,25 @@
+#![deny(renamed_and_removed_lints)]
+#![deny(safe_packed_borrows)] //~ ERROR has been renamed to `unaligned_references`
+
+// This lint was removed in https://github.com/rust-lang/rust/pull/82525 (nightly-2021-03-28).
+// Refs:
+// - https://github.com/rust-lang/rust/pull/82525
+// - https://github.com/rust-lang/rust/issues/46043
+
+#[repr(packed)]
+struct Packed {
+ f: u32,
+}
+
+#[repr(packed(2))]
+struct PackedN {
+ f: u32,
+}
+
+fn main() {
+ let a = Packed { f: 1 };
+ let _ = &a.f;
+
+ let b = PackedN { f: 1 };
+ let _ = &b.f;
+}
diff --git a/third_party/rust/pin-project/tests/ui/pin_project/safe_packed_borrows.stderr b/third_party/rust/pin-project/tests/ui/pin_project/safe_packed_borrows.stderr
new file mode 100644
index 0000000000..26e6f8d74c
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pin_project/safe_packed_borrows.stderr
@@ -0,0 +1,31 @@
+error: lint `safe_packed_borrows` has been removed: converted into hard error, see issue #82523 <https://github.com/rust-lang/rust/issues/82523> for more information
+ --> tests/ui/pin_project/safe_packed_borrows.rs:2:9
+ |
+2 | #![deny(safe_packed_borrows)] //~ ERROR has been renamed to `unaligned_references`
+ | ^^^^^^^^^^^^^^^^^^^
+ |
+note: the lint level is defined here
+ --> tests/ui/pin_project/safe_packed_borrows.rs:1:9
+ |
+1 | #![deny(renamed_and_removed_lints)]
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error[E0793]: reference to packed field is unaligned
+ --> tests/ui/pin_project/safe_packed_borrows.rs:21:13
+ |
+21 | let _ = &a.f;
+ | ^^^^
+ |
+ = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
+ = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
+ = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
+
+error[E0793]: reference to packed field is unaligned
+ --> tests/ui/pin_project/safe_packed_borrows.rs:24:13
+ |
+24 | let _ = &b.f;
+ | ^^^^
+ |
+ = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
+ = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
+ = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
diff --git a/third_party/rust/pin-project/tests/ui/pin_project/unaligned_references.rs b/third_party/rust/pin-project/tests/ui/pin_project/unaligned_references.rs
new file mode 100644
index 0000000000..5c7dc4381e
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pin_project/unaligned_references.rs
@@ -0,0 +1,19 @@
+// Refs: https://github.com/rust-lang/rust/issues/82523
+
+#[repr(packed)]
+struct Packed {
+ f: u32,
+}
+
+#[repr(packed(2))]
+struct PackedN {
+ f: u32,
+}
+
+fn main() {
+ let a = Packed { f: 1 };
+ let _ = &a.f; //~ ERROR reference to packed field is unaligned
+
+ let b = PackedN { f: 1 };
+ let _ = &b.f; //~ ERROR reference to packed field is unaligned
+}
diff --git a/third_party/rust/pin-project/tests/ui/pin_project/unaligned_references.stderr b/third_party/rust/pin-project/tests/ui/pin_project/unaligned_references.stderr
new file mode 100644
index 0000000000..617f1646c6
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pin_project/unaligned_references.stderr
@@ -0,0 +1,19 @@
+error[E0793]: reference to packed field is unaligned
+ --> tests/ui/pin_project/unaligned_references.rs:15:13
+ |
+15 | let _ = &a.f; //~ ERROR reference to packed field is unaligned
+ | ^^^^
+ |
+ = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
+ = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
+ = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
+
+error[E0793]: reference to packed field is unaligned
+ --> tests/ui/pin_project/unaligned_references.rs:18:13
+ |
+18 | let _ = &b.f; //~ ERROR reference to packed field is unaligned
+ | ^^^^
+ |
+ = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
+ = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
+ = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
diff --git a/third_party/rust/pin-project/tests/ui/pin_project/unpin_sneaky.rs b/third_party/rust/pin-project/tests/ui/pin_project/unpin_sneaky.rs
new file mode 100644
index 0000000000..3f5f32be69
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pin_project/unpin_sneaky.rs
@@ -0,0 +1,11 @@
+use pin_project::pin_project;
+
+#[pin_project]
+struct S {
+ #[pin]
+ f: u8,
+}
+
+impl Unpin for __S {} //~ ERROR E0412,E0321
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/ui/pin_project/unpin_sneaky.stderr b/third_party/rust/pin-project/tests/ui/pin_project/unpin_sneaky.stderr
new file mode 100644
index 0000000000..82c2aa5b91
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pin_project/unpin_sneaky.stderr
@@ -0,0 +1,5 @@
+error[E0412]: cannot find type `__S` in this scope
+ --> tests/ui/pin_project/unpin_sneaky.rs:9:16
+ |
+9 | impl Unpin for __S {} //~ ERROR E0412,E0321
+ | ^^^ not found in this scope
diff --git a/third_party/rust/pin-project/tests/ui/pin_project/visibility.rs b/third_party/rust/pin-project/tests/ui/pin_project/visibility.rs
new file mode 100644
index 0000000000..fdff5a6783
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pin_project/visibility.rs
@@ -0,0 +1,49 @@
+/// Only named projected types can be imported.
+/// See import_unnamed.rs for unnamed projected types.
+
+mod pub_ {
+ use pin_project::pin_project;
+
+ #[pin_project(project = DProj, project_ref = DProjRef)]
+ pub struct Default(());
+
+ #[pin_project(project = RProj, project_ref = RProjRef, project_replace = RProjOwn)]
+ pub struct Replace(());
+}
+pub mod pub_use {
+ #[rustfmt::skip]
+ pub use crate::pub_::DProj; //~ ERROR E0365
+ #[rustfmt::skip]
+ pub use crate::pub_::DProjRef; //~ ERROR E0365
+ #[rustfmt::skip]
+ pub use crate::pub_::RProj; //~ ERROR E0365
+ #[rustfmt::skip]
+ pub use crate::pub_::RProjOwn; //~ ERROR E0365
+ #[rustfmt::skip]
+ pub use crate::pub_::RProjRef; //~ ERROR E0365
+
+ // Confirm that the visibility of the original type is not changed.
+ pub use crate::pub_::{Default, Replace};
+}
+pub mod pub_use2 {
+ // Ok
+ #[allow(unused_imports)]
+ pub(crate) use crate::pub_::{DProj, DProjRef, RProj, RProjOwn, RProjRef};
+}
+
+mod pub_crate {
+ use pin_project::pin_project;
+
+ #[pin_project(project = DProj, project_ref = DProjRef)]
+ pub(crate) struct Default(());
+
+ #[pin_project(project = RProj, project_ref = RProjRef, project_replace = RProjOwn)]
+ pub(crate) struct Replace(());
+}
+pub mod pub_crate_use {
+ // Ok
+ #[allow(unused_imports)]
+ pub(crate) use crate::pub_crate::{DProj, DProjRef, RProj, RProjOwn, RProjRef};
+}
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/ui/pin_project/visibility.stderr b/third_party/rust/pin-project/tests/ui/pin_project/visibility.stderr
new file mode 100644
index 0000000000..4d1b7229a6
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pin_project/visibility.stderr
@@ -0,0 +1,39 @@
+error[E0365]: `DProj` is only public within the crate, and cannot be re-exported outside
+ --> tests/ui/pin_project/visibility.rs:15:13
+ |
+15 | pub use crate::pub_::DProj; //~ ERROR E0365
+ | ^^^^^^^^^^^^^^^^^^ re-export of crate public `DProj`
+ |
+ = note: consider declaring type or module `DProj` with `pub`
+
+error[E0365]: `DProjRef` is only public within the crate, and cannot be re-exported outside
+ --> tests/ui/pin_project/visibility.rs:17:13
+ |
+17 | pub use crate::pub_::DProjRef; //~ ERROR E0365
+ | ^^^^^^^^^^^^^^^^^^^^^ re-export of crate public `DProjRef`
+ |
+ = note: consider declaring type or module `DProjRef` with `pub`
+
+error[E0365]: `RProj` is only public within the crate, and cannot be re-exported outside
+ --> tests/ui/pin_project/visibility.rs:19:13
+ |
+19 | pub use crate::pub_::RProj; //~ ERROR E0365
+ | ^^^^^^^^^^^^^^^^^^ re-export of crate public `RProj`
+ |
+ = note: consider declaring type or module `RProj` with `pub`
+
+error[E0365]: `RProjOwn` is only public within the crate, and cannot be re-exported outside
+ --> tests/ui/pin_project/visibility.rs:21:13
+ |
+21 | pub use crate::pub_::RProjOwn; //~ ERROR E0365
+ | ^^^^^^^^^^^^^^^^^^^^^ re-export of crate public `RProjOwn`
+ |
+ = note: consider declaring type or module `RProjOwn` with `pub`
+
+error[E0365]: `RProjRef` is only public within the crate, and cannot be re-exported outside
+ --> tests/ui/pin_project/visibility.rs:23:13
+ |
+23 | pub use crate::pub_::RProjRef; //~ ERROR E0365
+ | ^^^^^^^^^^^^^^^^^^^^^ re-export of crate public `RProjRef`
+ |
+ = note: consider declaring type or module `RProjRef` with `pub`
diff --git a/third_party/rust/pin-project/tests/ui/pinned_drop/call-drop-inner.rs b/third_party/rust/pin-project/tests/ui/pinned_drop/call-drop-inner.rs
new file mode 100644
index 0000000000..9f89942b21
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pinned_drop/call-drop-inner.rs
@@ -0,0 +1,17 @@
+use std::pin::Pin;
+
+use pin_project::{pin_project, pinned_drop};
+
+#[pin_project(PinnedDrop)]
+struct Struct {
+ f: bool,
+}
+
+#[pinned_drop]
+impl PinnedDrop for Struct {
+ fn drop(mut self: Pin<&mut Self>) {
+ __drop_inner(__self);
+ }
+}
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/ui/pinned_drop/call-drop-inner.stderr b/third_party/rust/pin-project/tests/ui/pinned_drop/call-drop-inner.stderr
new file mode 100644
index 0000000000..277d50f9ba
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pinned_drop/call-drop-inner.stderr
@@ -0,0 +1,15 @@
+error[E0061]: this function takes 0 arguments but 1 argument was supplied
+ --> tests/ui/pinned_drop/call-drop-inner.rs:13:9
+ |
+13 | __drop_inner(__self);
+ | ^^^^^^^^^^^^ ------
+ | |
+ | unexpected argument of type `Pin<&mut Struct>`
+ | help: remove the extra argument
+ |
+note: function defined here
+ --> tests/ui/pinned_drop/call-drop-inner.rs:10:1
+ |
+10 | #[pinned_drop]
+ | ^^^^^^^^^^^^^^
+ = note: this error originates in the attribute macro `pinned_drop` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/third_party/rust/pin-project/tests/ui/pinned_drop/conditional-drop-impl.rs b/third_party/rust/pin-project/tests/ui/pinned_drop/conditional-drop-impl.rs
new file mode 100644
index 0000000000..23d756d4dc
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pinned_drop/conditional-drop-impl.rs
@@ -0,0 +1,27 @@
+use std::pin::Pin;
+
+use pin_project::{pin_project, pinned_drop};
+
+// In `Drop` impl, the implementor must specify the same requirement as type definition.
+
+struct DropImpl<T> {
+ f: T,
+}
+
+impl<T: Unpin> Drop for DropImpl<T> {
+ //~^ ERROR E0367
+ fn drop(&mut self) {}
+}
+
+#[pin_project(PinnedDrop)] //~ ERROR E0277
+struct PinnedDropImpl<T> {
+ #[pin]
+ f: T,
+}
+
+#[pinned_drop]
+impl<T: Unpin> PinnedDrop for PinnedDropImpl<T> {
+ fn drop(self: Pin<&mut Self>) {}
+}
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/ui/pinned_drop/conditional-drop-impl.stderr b/third_party/rust/pin-project/tests/ui/pinned_drop/conditional-drop-impl.stderr
new file mode 100644
index 0000000000..837b1db0f2
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pinned_drop/conditional-drop-impl.stderr
@@ -0,0 +1,31 @@
+error[E0367]: `Drop` impl requires `T: Unpin` but the struct it is implemented for does not
+ --> tests/ui/pinned_drop/conditional-drop-impl.rs:11:9
+ |
+11 | impl<T: Unpin> Drop for DropImpl<T> {
+ | ^^^^^
+ |
+note: the implementor must specify the same requirement
+ --> tests/ui/pinned_drop/conditional-drop-impl.rs:7:1
+ |
+7 | struct DropImpl<T> {
+ | ^^^^^^^^^^^^^^^^^^
+
+error[E0277]: `T` cannot be unpinned
+ --> tests/ui/pinned_drop/conditional-drop-impl.rs:16:15
+ |
+16 | #[pin_project(PinnedDrop)] //~ ERROR E0277
+ | ^^^^^^^^^^ the trait `Unpin` is not implemented for `T`
+ |
+ = note: consider using the `pin!` macro
+ consider using `Box::pin` if you need to access the pinned value outside of the current scope
+note: required for `PinnedDropImpl<T>` to implement `PinnedDrop`
+ --> tests/ui/pinned_drop/conditional-drop-impl.rs:23:16
+ |
+23 | impl<T: Unpin> PinnedDrop for PinnedDropImpl<T> {
+ | ----- ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^
+ | |
+ | unsatisfied trait bound introduced here
+help: consider restricting type parameter `T`
+ |
+17 | struct PinnedDropImpl<T: std::marker::Unpin> {
+ | ++++++++++++++++++++
diff --git a/third_party/rust/pin-project/tests/ui/pinned_drop/forget-pinned-drop-impl.rs b/third_party/rust/pin-project/tests/ui/pinned_drop/forget-pinned-drop-impl.rs
new file mode 100644
index 0000000000..e31f46f262
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pinned_drop/forget-pinned-drop-impl.rs
@@ -0,0 +1,9 @@
+use pin_project::pin_project;
+
+#[pin_project(PinnedDrop)] //~ ERROR E0277
+struct Struct {
+ #[pin]
+ f: u8,
+}
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/ui/pinned_drop/forget-pinned-drop-impl.stderr b/third_party/rust/pin-project/tests/ui/pinned_drop/forget-pinned-drop-impl.stderr
new file mode 100644
index 0000000000..ef8a7bf4b4
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pinned_drop/forget-pinned-drop-impl.stderr
@@ -0,0 +1,5 @@
+error[E0277]: the trait bound `Struct: PinnedDrop` is not satisfied
+ --> tests/ui/pinned_drop/forget-pinned-drop-impl.rs:3:15
+ |
+3 | #[pin_project(PinnedDrop)] //~ ERROR E0277
+ | ^^^^^^^^^^ the trait `PinnedDrop` is not implemented for `Struct`
diff --git a/third_party/rust/pin-project/tests/ui/pinned_drop/invalid-self.rs b/third_party/rust/pin-project/tests/ui/pinned_drop/invalid-self.rs
new file mode 100644
index 0000000000..783167fc0d
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pinned_drop/invalid-self.rs
@@ -0,0 +1,14 @@
+// by-ref binding `ref (mut) self` and sub-patterns `@` are not allowed in receivers (rejected by rustc).
+
+use std::pin::Pin;
+
+struct S {}
+
+impl S {
+ fn take_ref_self(ref self: Pin<&mut Self>) {} //~ ERROR expected identifier, found keyword `self`
+ fn take_ref_mut_self(ref mut self: Pin<&mut Self>) {} //~ ERROR expected identifier, found keyword `self`
+
+ fn self_subpat(self @ S {}: Self) {} //~ ERROR expected one of `)`, `,`, or `:`, found `@`
+}
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/ui/pinned_drop/invalid-self.stderr b/third_party/rust/pin-project/tests/ui/pinned_drop/invalid-self.stderr
new file mode 100644
index 0000000000..464be5e5b5
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pinned_drop/invalid-self.stderr
@@ -0,0 +1,25 @@
+error: expected identifier, found keyword `self`
+ --> tests/ui/pinned_drop/invalid-self.rs:8:26
+ |
+8 | fn take_ref_self(ref self: Pin<&mut Self>) {} //~ ERROR expected identifier, found keyword `self`
+ | ^^^^ expected identifier, found keyword
+
+error: expected identifier, found keyword `self`
+ --> tests/ui/pinned_drop/invalid-self.rs:9:34
+ |
+9 | fn take_ref_mut_self(ref mut self: Pin<&mut Self>) {} //~ ERROR expected identifier, found keyword `self`
+ | ^^^^ expected identifier, found keyword
+
+error: expected parameter name, found `@`
+ --> tests/ui/pinned_drop/invalid-self.rs:11:25
+ |
+11 | fn self_subpat(self @ S {}: Self) {} //~ ERROR expected one of `)`, `,`, or `:`, found `@`
+ | ^ expected parameter name
+
+error: expected one of `)`, `,`, or `:`, found `@`
+ --> tests/ui/pinned_drop/invalid-self.rs:11:25
+ |
+11 | fn self_subpat(self @ S {}: Self) {} //~ ERROR expected one of `)`, `,`, or `:`, found `@`
+ | -^ expected one of `)`, `,`, or `:`
+ | |
+ | help: missing `,`
diff --git a/third_party/rust/pin-project/tests/ui/pinned_drop/invalid.rs b/third_party/rust/pin-project/tests/ui/pinned_drop/invalid.rs
new file mode 100644
index 0000000000..b2c25265d0
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pinned_drop/invalid.rs
@@ -0,0 +1,231 @@
+mod argument {
+ use std::pin::Pin;
+
+ use pin_project::{pin_project, pinned_drop};
+
+ #[pin_project(PinnedDrop)]
+ struct UnexpectedArg1(());
+
+ #[pinned_drop(foo)] //~ ERROR unexpected argument
+ impl PinnedDrop for UnexpectedArg1 {
+ fn drop(self: Pin<&mut Self>) {}
+ }
+
+ #[pin_project(PinnedDrop)]
+ struct UnexpectedArg2(());
+
+ #[pinned_drop()] // Ok
+ impl PinnedDrop for UnexpectedArg2 {
+ fn drop(self: Pin<&mut Self>) {}
+ }
+}
+
+mod attribute {
+ use pin_project::{pin_project, pinned_drop};
+
+ #[pin_project(PinnedDrop)]
+ struct Duplicate(());
+
+ #[pinned_drop]
+ #[pinned_drop] //~ ERROR duplicate #[pinned_drop] attribute
+ impl PinnedDrop for Duplicate {
+ fn drop(self: Pin<&mut Self>) {}
+ }
+}
+
+mod item {
+ use pin_project::{pin_project, pinned_drop};
+
+ #[pin_project(PinnedDrop)]
+ struct TraitImpl(());
+
+ #[pinned_drop]
+ impl Drop for TraitImpl {} //~ ERROR may only be used on implementation for the `PinnedDrop` trait
+
+ #[pin_project(PinnedDrop)]
+ struct InherentImpl(());
+
+ #[pinned_drop]
+ impl InherentImpl {} //~ ERROR may only be used on implementation for the `PinnedDrop` trait
+
+ #[pinned_drop]
+ fn func(_: Pin<&mut ()>) {} //~ ERROR expected `impl`
+}
+
+mod unsafety {
+ use pin_project::{pin_project, pinned_drop};
+
+ #[pin_project(PinnedDrop)]
+ struct Impl(());
+
+ #[pinned_drop]
+ unsafe impl PinnedDrop for Impl {
+ //~^ ERROR implementing the trait `PinnedDrop` is not unsafe
+ fn drop(self: Pin<&mut Self>) {}
+ }
+
+ #[pin_project(PinnedDrop)]
+ struct Method(());
+
+ #[pinned_drop]
+ impl PinnedDrop for Method {
+ unsafe fn drop(self: Pin<&mut Self>) {} //~ ERROR implementing the method `drop` is not unsafe
+ }
+}
+
+mod assoc_item {
+ use pin_project::{pin_project, pinned_drop};
+
+ #[pin_project(PinnedDrop)]
+ struct Empty(());
+
+ #[pinned_drop]
+ impl PinnedDrop for Empty {} //~ ERROR not all trait items implemented, missing: `drop`
+
+ #[pin_project(PinnedDrop)]
+ struct Const1(());
+
+ #[pinned_drop]
+ impl PinnedDrop for Const1 {
+ const A: u8 = 0; //~ ERROR const `A` is not a member of trait `PinnedDrop`
+ fn drop(self: Pin<&mut Self>) {}
+ }
+
+ #[pin_project(PinnedDrop)]
+ struct Const2(());
+
+ #[pinned_drop]
+ impl PinnedDrop for Const2 {
+ fn drop(self: Pin<&mut Self>) {}
+ const A: u8 = 0; //~ ERROR const `A` is not a member of trait `PinnedDrop`
+ }
+
+ #[pin_project(PinnedDrop)]
+ struct Type1(());
+
+ #[pinned_drop]
+ impl PinnedDrop for Type1 {
+ type A = u8; //~ ERROR type `A` is not a member of trait `PinnedDrop`
+ fn drop(self: Pin<&mut Self>) {}
+ }
+
+ #[pin_project(PinnedDrop)]
+ struct Type2(());
+
+ #[pinned_drop]
+ impl PinnedDrop for Type2 {
+ fn drop(self: Pin<&mut Self>) {}
+ type A = u8; //~ ERROR type `A` is not a member of trait `PinnedDrop`
+ }
+
+ #[pin_project(PinnedDrop)]
+ struct Duplicate(());
+
+ #[pinned_drop]
+ impl PinnedDrop for Duplicate {
+ fn drop(self: Pin<&mut Self>) {}
+ fn drop(self: Pin<&mut Self>) {} //~ ERROR duplicate definitions with name `drop`
+ }
+}
+
+mod method {
+ use std::pin::Pin;
+
+ use pin_project::{pin_project, pinned_drop};
+
+ #[pin_project(PinnedDrop)]
+ struct RetUnit(());
+
+ #[pinned_drop]
+ impl PinnedDrop for RetUnit {
+ fn drop(self: Pin<&mut Self>) -> () {} // Ok
+ }
+
+ #[pin_project(PinnedDrop)]
+ struct RetTy(());
+
+ #[pinned_drop]
+ impl PinnedDrop for RetTy {
+ fn drop(self: Pin<&mut Self>) -> Self {} //~ ERROR method `drop` must return the unit type
+ }
+
+ #[pin_project(PinnedDrop)]
+ struct NoArg(());
+
+ #[pinned_drop]
+ impl PinnedDrop for NoArg {
+ fn drop() {} //~ ERROR method `drop` must take an argument `self: Pin<&mut Self>`
+ }
+
+ #[pin_project(PinnedDrop)]
+ struct MultiArg(());
+
+ #[pinned_drop]
+ impl PinnedDrop for MultiArg {
+ fn drop(self: Pin<&mut Self>, _: ()) {} //~ ERROR method `drop` must take an argument `self: Pin<&mut Self>`
+ }
+
+ #[pin_project(PinnedDrop)]
+ struct InvalidArg1(());
+
+ #[pinned_drop]
+ impl PinnedDrop for InvalidArg1 {
+ fn drop(&mut self) {} //~ ERROR method `drop` must take an argument `self: Pin<&mut Self>`
+ }
+
+ #[pin_project(PinnedDrop)]
+ struct InvalidArg2(());
+
+ #[pinned_drop]
+ impl PinnedDrop for InvalidArg2 {
+ fn drop(_: Pin<&mut Self>) {} //~ ERROR method `drop` must take an argument `self: Pin<&mut Self>`
+ }
+
+ #[pin_project(PinnedDrop)]
+ struct InvalidArg3(());
+
+ #[pinned_drop]
+ impl PinnedDrop for InvalidArg3 {
+ fn drop(self: Pin<&Self>) {} //~ ERROR method `drop` must take an argument `self: Pin<&mut Self>`
+ }
+
+ #[pin_project(PinnedDrop)]
+ struct InvalidArg4(());
+
+ #[pinned_drop]
+ impl PinnedDrop for InvalidArg4 {
+ fn drop(self: Pin<&mut ()>) {} //~ ERROR method `drop` must take an argument `self: Pin<&mut Self>`
+ }
+
+ #[pin_project(PinnedDrop)]
+ struct InvalidName(());
+
+ #[pinned_drop]
+ impl PinnedDrop for InvalidName {
+ fn pinned_drop(self: Pin<&mut Self>) {} //~ ERROR method `pinned_drop` is not a member of trait `PinnedDrop
+ }
+}
+
+mod self_ty {
+ use pin_project::pinned_drop;
+
+ #[pinned_drop]
+ impl PinnedDrop for () {
+ //~^ ERROR implementing the trait `PinnedDrop` on this type is unsupported
+ fn drop(self: Pin<&mut Self>) {}
+ }
+
+ #[pinned_drop]
+ impl PinnedDrop for &mut A {
+ //~^ ERROR implementing the trait `PinnedDrop` on this type is unsupported
+ fn drop(self: Pin<&mut Self>) {}
+ }
+
+ #[pinned_drop]
+ impl PinnedDrop for [A] {
+ //~^ ERROR implementing the trait `PinnedDrop` on this type is unsupported
+ fn drop(self: Pin<&mut Self>) {}
+ }
+}
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/ui/pinned_drop/invalid.stderr b/third_party/rust/pin-project/tests/ui/pinned_drop/invalid.stderr
new file mode 100644
index 0000000000..264def08f5
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pinned_drop/invalid.stderr
@@ -0,0 +1,143 @@
+error: unexpected argument: `foo`
+ --> tests/ui/pinned_drop/invalid.rs:9:19
+ |
+9 | #[pinned_drop(foo)] //~ ERROR unexpected argument
+ | ^^^
+
+error: duplicate #[pinned_drop] attribute
+ --> tests/ui/pinned_drop/invalid.rs:30:5
+ |
+30 | #[pinned_drop] //~ ERROR duplicate #[pinned_drop] attribute
+ | ^^^^^^^^^^^^^^
+
+error: #[pinned_drop] may only be used on implementation for the `PinnedDrop` trait
+ --> tests/ui/pinned_drop/invalid.rs:43:10
+ |
+43 | impl Drop for TraitImpl {} //~ ERROR may only be used on implementation for the `PinnedDrop` trait
+ | ^^^^
+
+error: #[pinned_drop] may only be used on implementation for the `PinnedDrop` trait
+ --> tests/ui/pinned_drop/invalid.rs:49:10
+ |
+49 | impl InherentImpl {} //~ ERROR may only be used on implementation for the `PinnedDrop` trait
+ | ^^^^^^^^^^^^
+
+error: expected `impl`
+ --> tests/ui/pinned_drop/invalid.rs:52:5
+ |
+52 | fn func(_: Pin<&mut ()>) {} //~ ERROR expected `impl`
+ | ^^
+
+error: implementing the trait `PinnedDrop` is not unsafe
+ --> tests/ui/pinned_drop/invalid.rs:62:5
+ |
+62 | unsafe impl PinnedDrop for Impl {
+ | ^^^^^^
+
+error: implementing the method `drop` is not unsafe
+ --> tests/ui/pinned_drop/invalid.rs:72:9
+ |
+72 | unsafe fn drop(self: Pin<&mut Self>) {} //~ ERROR implementing the method `drop` is not unsafe
+ | ^^^^^^
+
+error: not all trait items implemented, missing: `drop`
+ --> tests/ui/pinned_drop/invalid.rs:83:5
+ |
+83 | impl PinnedDrop for Empty {} //~ ERROR not all trait items implemented, missing: `drop`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: const `A` is not a member of trait `PinnedDrop`
+ --> tests/ui/pinned_drop/invalid.rs:90:9
+ |
+90 | const A: u8 = 0; //~ ERROR const `A` is not a member of trait `PinnedDrop`
+ | ^^^^^^^^^^^^^^^^
+
+error: const `A` is not a member of trait `PinnedDrop`
+ --> tests/ui/pinned_drop/invalid.rs:100:9
+ |
+100 | const A: u8 = 0; //~ ERROR const `A` is not a member of trait `PinnedDrop`
+ | ^^^^^^^^^^^^^^^^
+
+error: type `A` is not a member of trait `PinnedDrop`
+ --> tests/ui/pinned_drop/invalid.rs:108:9
+ |
+108 | type A = u8; //~ ERROR type `A` is not a member of trait `PinnedDrop`
+ | ^^^^^^^^^^^^
+
+error: type `A` is not a member of trait `PinnedDrop`
+ --> tests/ui/pinned_drop/invalid.rs:118:9
+ |
+118 | type A = u8; //~ ERROR type `A` is not a member of trait `PinnedDrop`
+ | ^^^^^^^^^^^^
+
+error: duplicate definitions with name `drop`
+ --> tests/ui/pinned_drop/invalid.rs:127:9
+ |
+127 | fn drop(self: Pin<&mut Self>) {} //~ ERROR duplicate definitions with name `drop`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: method `drop` must return the unit type
+ --> tests/ui/pinned_drop/invalid.rs:149:42
+ |
+149 | fn drop(self: Pin<&mut Self>) -> Self {} //~ ERROR method `drop` must return the unit type
+ | ^^^^
+
+error: method `drop` must take an argument `self: Pin<&mut Self>`
+ --> tests/ui/pinned_drop/invalid.rs:157:16
+ |
+157 | fn drop() {} //~ ERROR method `drop` must take an argument `self: Pin<&mut Self>`
+ | ^^
+
+error: method `drop` must take an argument `self: Pin<&mut Self>`
+ --> tests/ui/pinned_drop/invalid.rs:165:17
+ |
+165 | fn drop(self: Pin<&mut Self>, _: ()) {} //~ ERROR method `drop` must take an argument `self: Pin<&mut Self>`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: method `drop` must take an argument `self: Pin<&mut Self>`
+ --> tests/ui/pinned_drop/invalid.rs:173:17
+ |
+173 | fn drop(&mut self) {} //~ ERROR method `drop` must take an argument `self: Pin<&mut Self>`
+ | ^^^^^^^^^
+
+error: method `drop` must take an argument `self: Pin<&mut Self>`
+ --> tests/ui/pinned_drop/invalid.rs:181:17
+ |
+181 | fn drop(_: Pin<&mut Self>) {} //~ ERROR method `drop` must take an argument `self: Pin<&mut Self>`
+ | ^^^^^^^^^^^^^^^^^
+
+error: method `drop` must take an argument `self: Pin<&mut Self>`
+ --> tests/ui/pinned_drop/invalid.rs:189:17
+ |
+189 | fn drop(self: Pin<&Self>) {} //~ ERROR method `drop` must take an argument `self: Pin<&mut Self>`
+ | ^^^^^^^^^^^^^^^^
+
+error: method `drop` must take an argument `self: Pin<&mut Self>`
+ --> tests/ui/pinned_drop/invalid.rs:197:17
+ |
+197 | fn drop(self: Pin<&mut ()>) {} //~ ERROR method `drop` must take an argument `self: Pin<&mut Self>`
+ | ^^^^^^^^^^^^^^^^^^
+
+error: method `pinned_drop` is not a member of trait `PinnedDrop
+ --> tests/ui/pinned_drop/invalid.rs:205:12
+ |
+205 | fn pinned_drop(self: Pin<&mut Self>) {} //~ ERROR method `pinned_drop` is not a member of trait `PinnedDrop
+ | ^^^^^^^^^^^
+
+error: implementing the trait `PinnedDrop` on this type is unsupported
+ --> tests/ui/pinned_drop/invalid.rs:213:25
+ |
+213 | impl PinnedDrop for () {
+ | ^^
+
+error: implementing the trait `PinnedDrop` on this type is unsupported
+ --> tests/ui/pinned_drop/invalid.rs:219:25
+ |
+219 | impl PinnedDrop for &mut A {
+ | ^^^^^^
+
+error: implementing the trait `PinnedDrop` on this type is unsupported
+ --> tests/ui/pinned_drop/invalid.rs:225:25
+ |
+225 | impl PinnedDrop for [A] {
+ | ^^^
diff --git a/third_party/rust/pin-project/tests/ui/pinned_drop/pinned-drop-no-attr-arg.rs b/third_party/rust/pin-project/tests/ui/pinned_drop/pinned-drop-no-attr-arg.rs
new file mode 100644
index 0000000000..391f2901ed
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pinned_drop/pinned-drop-no-attr-arg.rs
@@ -0,0 +1,17 @@
+use std::pin::Pin;
+
+use pin_project::{pin_project, pinned_drop};
+
+#[pin_project]
+struct S {
+ #[pin]
+ f: u8,
+}
+
+#[pinned_drop]
+impl PinnedDrop for S {
+ //~^ ERROR E0119
+ fn drop(self: Pin<&mut Self>) {}
+}
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/ui/pinned_drop/pinned-drop-no-attr-arg.stderr b/third_party/rust/pin-project/tests/ui/pinned_drop/pinned-drop-no-attr-arg.stderr
new file mode 100644
index 0000000000..a07ba99e96
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pinned_drop/pinned-drop-no-attr-arg.stderr
@@ -0,0 +1,8 @@
+error[E0119]: conflicting implementations of trait `PinnedDrop` for type `S`
+ --> tests/ui/pinned_drop/pinned-drop-no-attr-arg.rs:12:1
+ |
+5 | #[pin_project]
+ | -------------- first implementation here
+...
+12 | impl PinnedDrop for S {
+ | ^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `S`
diff --git a/third_party/rust/pin-project/tests/ui/pinned_drop/self.rs b/third_party/rust/pin-project/tests/ui/pinned_drop/self.rs
new file mode 100644
index 0000000000..ff634022e5
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pinned_drop/self.rs
@@ -0,0 +1,58 @@
+pub mod self_in_macro_def {
+ use std::pin::Pin;
+
+ use pin_project::{pin_project, pinned_drop};
+
+ #[pin_project(PinnedDrop)]
+ pub struct S {
+ f: (),
+ }
+
+ #[pinned_drop]
+ impl PinnedDrop for S {
+ fn drop(self: Pin<&mut Self>) {
+ macro_rules! t {
+ () => {{
+ let _ = self; //~ ERROR E0434
+
+ fn f(self: ()) {} //~ ERROR `self` parameter is only allowed in associated functions
+ }};
+ }
+ t!();
+ }
+ }
+}
+
+pub mod self_span {
+ use std::pin::Pin;
+
+ use pin_project::{pin_project, pinned_drop};
+
+ #[pin_project(PinnedDrop)]
+ pub struct S {
+ f: (),
+ }
+
+ #[pinned_drop]
+ impl PinnedDrop for S {
+ fn drop(self: Pin<&mut Self>) {
+ let _: () = self; //~ ERROR E0308
+ let _: Self = Self; //~ ERROR E0423
+ }
+ }
+
+ #[pin_project(PinnedDrop)]
+ pub enum E {
+ V { f: () },
+ }
+
+ #[pinned_drop]
+ impl PinnedDrop for E {
+ fn drop(self: Pin<&mut Self>) {
+ let _: () = self; //~ ERROR E0308
+ let _: Self = Self::V; //~ ERROR E0533
+ }
+ }
+}
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/ui/pinned_drop/self.stderr b/third_party/rust/pin-project/tests/ui/pinned_drop/self.stderr
new file mode 100644
index 0000000000..ad506a54fd
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pinned_drop/self.stderr
@@ -0,0 +1,62 @@
+error: `self` parameter is only allowed in associated functions
+ --> tests/ui/pinned_drop/self.rs:18:26
+ |
+18 | fn f(self: ()) {} //~ ERROR `self` parameter is only allowed in associated functions
+ | ^^^^ not semantically valid as function parameter
+...
+21 | t!();
+ | ---- in this macro invocation
+ |
+ = note: associated functions are those in `impl` or `trait` definitions
+ = note: this error originates in the macro `t` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0434]: can't capture dynamic environment in a fn item
+ --> tests/ui/pinned_drop/self.rs:16:29
+ |
+16 | let _ = self; //~ ERROR E0434
+ | ^^^^
+...
+21 | t!();
+ | ---- in this macro invocation
+ |
+ = help: use the `|| { ... }` closure form instead
+ = note: this error originates in the macro `t` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0423]: expected value, found struct `S`
+ --> tests/ui/pinned_drop/self.rs:40:27
+ |
+32 | / pub struct S {
+33 | | f: (),
+34 | | }
+ | |_____- `S` defined here
+...
+40 | let _: Self = Self; //~ ERROR E0423
+ | ^^^^ help: use struct literal syntax instead: `S { f: val }`
+
+error[E0308]: mismatched types
+ --> tests/ui/pinned_drop/self.rs:39:25
+ |
+39 | let _: () = self; //~ ERROR E0308
+ | -- ^^^^ expected `()`, found `Pin<&mut S>`
+ | |
+ | expected due to this
+ |
+ = note: expected unit type `()`
+ found struct `Pin<&mut self_span::S>`
+
+error[E0308]: mismatched types
+ --> tests/ui/pinned_drop/self.rs:52:25
+ |
+52 | let _: () = self; //~ ERROR E0308
+ | -- ^^^^ expected `()`, found `Pin<&mut E>`
+ | |
+ | expected due to this
+ |
+ = note: expected unit type `()`
+ found struct `Pin<&mut E>`
+
+error[E0533]: expected value, found struct variant `E::V`
+ --> tests/ui/pinned_drop/self.rs:53:27
+ |
+53 | let _: Self = Self::V; //~ ERROR E0533
+ | ^^^^^^^ not a value
diff --git a/third_party/rust/pin-project/tests/ui/pinned_drop/unsafe-call.rs b/third_party/rust/pin-project/tests/ui/pinned_drop/unsafe-call.rs
new file mode 100644
index 0000000000..3ee2b56c37
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pinned_drop/unsafe-call.rs
@@ -0,0 +1,18 @@
+use std::pin::Pin;
+
+use pin_project::{pin_project, pinned_drop};
+
+#[pin_project(PinnedDrop)]
+struct S {
+ #[pin]
+ f: u8,
+}
+
+#[pinned_drop]
+impl PinnedDrop for S {
+ fn drop(self: Pin<&mut Self>) {
+ self.project().f.get_unchecked_mut(); //~ ERROR call to unsafe function is unsafe and requires unsafe function or block [E0133]
+ }
+}
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/ui/pinned_drop/unsafe-call.stderr b/third_party/rust/pin-project/tests/ui/pinned_drop/unsafe-call.stderr
new file mode 100644
index 0000000000..911a58ef74
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/pinned_drop/unsafe-call.stderr
@@ -0,0 +1,10 @@
+error[E0133]: call to unsafe function is unsafe and requires unsafe function or block
+ --> tests/ui/pinned_drop/unsafe-call.rs:14:9
+ |
+11 | #[pinned_drop]
+ | -------------- items do not inherit unsafety from separate enclosing items
+...
+14 | self.project().f.get_unchecked_mut(); //~ ERROR call to unsafe function is unsafe and requires unsafe function or block [E0133]
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
+ |
+ = note: consult the function's documentation for information on how to avoid undefined behavior
diff --git a/third_party/rust/pin-project/tests/ui/unsafe_unpin/conflict-unpin.rs b/third_party/rust/pin-project/tests/ui/unsafe_unpin/conflict-unpin.rs
new file mode 100644
index 0000000000..ac9d1f8682
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/unsafe_unpin/conflict-unpin.rs
@@ -0,0 +1,30 @@
+use pin_project::pin_project;
+
+#[pin_project(UnsafeUnpin)] //~ ERROR E0119
+struct Foo<T, U> {
+ #[pin]
+ f1: T,
+ f2: U,
+}
+
+impl<T, U> Unpin for Foo<T, U> where T: Unpin {}
+
+#[pin_project(UnsafeUnpin)] //~ ERROR E0119
+struct Bar<T, U> {
+ #[pin]
+ f1: T,
+ f2: U,
+}
+
+impl<T, U> Unpin for Bar<T, U> {}
+
+#[pin_project(UnsafeUnpin)] //~ ERROR E0119
+struct Baz<T, U> {
+ #[pin]
+ f1: T,
+ f2: U,
+}
+
+impl<T: Unpin, U: Unpin> Unpin for Baz<T, U> {}
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/ui/unsafe_unpin/conflict-unpin.stderr b/third_party/rust/pin-project/tests/ui/unsafe_unpin/conflict-unpin.stderr
new file mode 100644
index 0000000000..cdf0d507af
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/unsafe_unpin/conflict-unpin.stderr
@@ -0,0 +1,32 @@
+error[E0119]: conflicting implementations of trait `Unpin` for type `Foo<_, _>`
+ --> tests/ui/unsafe_unpin/conflict-unpin.rs:3:15
+ |
+3 | #[pin_project(UnsafeUnpin)] //~ ERROR E0119
+ | ^^^^^^^^^^^ conflicting implementation for `Foo<_, _>`
+...
+10 | impl<T, U> Unpin for Foo<T, U> where T: Unpin {}
+ | ------------------------------ first implementation here
+ |
+ = note: upstream crates may add a new impl of trait `_::_pin_project::UnsafeUnpin` for type `_::_pin_project::__private::Wrapper<'_, Foo<_, _>>` in future versions
+
+error[E0119]: conflicting implementations of trait `Unpin` for type `Bar<_, _>`
+ --> tests/ui/unsafe_unpin/conflict-unpin.rs:12:15
+ |
+12 | #[pin_project(UnsafeUnpin)] //~ ERROR E0119
+ | ^^^^^^^^^^^ conflicting implementation for `Bar<_, _>`
+...
+19 | impl<T, U> Unpin for Bar<T, U> {}
+ | ------------------------------ first implementation here
+ |
+ = note: upstream crates may add a new impl of trait `_::_pin_project::UnsafeUnpin` for type `_::_pin_project::__private::Wrapper<'_, Bar<_, _>>` in future versions
+
+error[E0119]: conflicting implementations of trait `Unpin` for type `Baz<_, _>`
+ --> tests/ui/unsafe_unpin/conflict-unpin.rs:21:15
+ |
+21 | #[pin_project(UnsafeUnpin)] //~ ERROR E0119
+ | ^^^^^^^^^^^ conflicting implementation for `Baz<_, _>`
+...
+28 | impl<T: Unpin, U: Unpin> Unpin for Baz<T, U> {}
+ | -------------------------------------------- first implementation here
+ |
+ = note: upstream crates may add a new impl of trait `_::_pin_project::UnsafeUnpin` for type `_::_pin_project::__private::Wrapper<'_, Baz<_, _>>` in future versions
diff --git a/third_party/rust/pin-project/tests/ui/unstable-features/README.md b/third_party/rust/pin-project/tests/ui/unstable-features/README.md
new file mode 100644
index 0000000000..96f370ca77
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/unstable-features/README.md
@@ -0,0 +1,7 @@
+# UI tests for unstable features
+
+These tests check how the guarantees and features provided by pin-project
+interact with unstable language features.
+
+The names of the files contained in this directory need to begin with the name
+of the feature.
diff --git a/third_party/rust/pin-project/tests/ui/unstable-features/marker_trait_attr-feature-gate.rs b/third_party/rust/pin-project/tests/ui/unstable-features/marker_trait_attr-feature-gate.rs
new file mode 100644
index 0000000000..542250bd90
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/unstable-features/marker_trait_attr-feature-gate.rs
@@ -0,0 +1,20 @@
+// Note: If you change this test, change 'marker_trait_attr.rs' at the same time.
+
+use std::marker::PhantomPinned;
+
+use pin_project::pin_project;
+
+#[pin_project] //~ ERROR E0119
+struct Struct<T> {
+ #[pin]
+ f: T,
+}
+
+// unsound Unpin impl
+impl<T> Unpin for Struct<T> {}
+
+fn is_unpin<T: Unpin>() {}
+
+fn main() {
+ is_unpin::<Struct<PhantomPinned>>()
+}
diff --git a/third_party/rust/pin-project/tests/ui/unstable-features/marker_trait_attr-feature-gate.stderr b/third_party/rust/pin-project/tests/ui/unstable-features/marker_trait_attr-feature-gate.stderr
new file mode 100644
index 0000000000..fcb9185328
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/unstable-features/marker_trait_attr-feature-gate.stderr
@@ -0,0 +1,10 @@
+error[E0119]: conflicting implementations of trait `Unpin` for type `Struct<_>`
+ --> tests/ui/unstable-features/marker_trait_attr-feature-gate.rs:7:1
+ |
+7 | #[pin_project] //~ ERROR E0119
+ | ^^^^^^^^^^^^^^ conflicting implementation for `Struct<_>`
+...
+14 | impl<T> Unpin for Struct<T> {}
+ | --------------------------- first implementation here
+ |
+ = note: this error originates in the derive macro `::pin_project::__private::__PinProjectInternalDerive` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/third_party/rust/pin-project/tests/ui/unstable-features/marker_trait_attr.rs b/third_party/rust/pin-project/tests/ui/unstable-features/marker_trait_attr.rs
new file mode 100644
index 0000000000..9c8e6643e0
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/unstable-features/marker_trait_attr.rs
@@ -0,0 +1,26 @@
+// Note: If you change this test, change 'marker_trait_attr-feature-gate.rs' at the same time.
+
+// marker_trait_attr
+// Tracking issue: https://github.com/rust-lang/rust/issues/29864
+#![feature(marker_trait_attr)]
+
+// See https://github.com/taiki-e/pin-project/issues/105#issuecomment-535355974
+
+use std::marker::PhantomPinned;
+
+use pin_project::pin_project;
+
+#[pin_project] //~ ERROR E0119
+struct Struct<T> {
+ #[pin]
+ f: T,
+}
+
+// unsound Unpin impl
+impl<T> Unpin for Struct<T> {}
+
+fn is_unpin<T: Unpin>() {}
+
+fn main() {
+ is_unpin::<Struct<PhantomPinned>>()
+}
diff --git a/third_party/rust/pin-project/tests/ui/unstable-features/marker_trait_attr.stderr b/third_party/rust/pin-project/tests/ui/unstable-features/marker_trait_attr.stderr
new file mode 100644
index 0000000000..85949d5c41
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/unstable-features/marker_trait_attr.stderr
@@ -0,0 +1,10 @@
+error[E0119]: conflicting implementations of trait `Unpin` for type `Struct<_>`
+ --> tests/ui/unstable-features/marker_trait_attr.rs:13:1
+ |
+13 | #[pin_project] //~ ERROR E0119
+ | ^^^^^^^^^^^^^^ conflicting implementation for `Struct<_>`
+...
+20 | impl<T> Unpin for Struct<T> {}
+ | --------------------------- first implementation here
+ |
+ = note: this error originates in the derive macro `::pin_project::__private::__PinProjectInternalDerive` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/third_party/rust/pin-project/tests/ui/unstable-features/negative_impls.rs b/third_party/rust/pin-project/tests/ui/unstable-features/negative_impls.rs
new file mode 100644
index 0000000000..96056423a0
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/unstable-features/negative_impls.rs
@@ -0,0 +1,23 @@
+#![feature(negative_impls)]
+#![deny(suspicious_auto_trait_impls)]
+
+// https://rust-lang.zulipchat.com/#narrow/stream/213817-t-lang/topic/design.20meeting.3A.20backlog.20bonanza/near/269471299
+// https://github.com/taiki-e/pin-project/issues/340
+
+#[pin_project::pin_project]
+struct Foo<Pinned, Unpinned> {
+ #[pin]
+ pinned: Pinned,
+
+ unpinned: Unpinned,
+}
+
+struct MyPhantomPinned {}
+impl !Unpin for MyPhantomPinned {}
+impl Unpin for Foo<MyPhantomPinned, ()> {}
+
+fn is_unpin<T: Unpin>() {}
+
+fn main() {
+ is_unpin::<Foo<MyPhantomPinned, ()>>()
+}
diff --git a/third_party/rust/pin-project/tests/ui/unstable-features/negative_impls.stderr b/third_party/rust/pin-project/tests/ui/unstable-features/negative_impls.stderr
new file mode 100644
index 0000000000..145716dd09
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/unstable-features/negative_impls.stderr
@@ -0,0 +1,19 @@
+error: cross-crate traits with a default impl, like `Unpin`, should not be specialized
+ --> tests/ui/unstable-features/negative_impls.rs:17:1
+ |
+17 | impl Unpin for Foo<MyPhantomPinned, ()> {}
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = warning: this will change its meaning in a future release!
+ = note: for more information, see issue #93367 <https://github.com/rust-lang/rust/issues/93367>
+ = note: `MyPhantomPinned` is not a generic parameter
+note: try using the same sequence of generic parameters as the struct definition
+ --> tests/ui/unstable-features/negative_impls.rs:8:1
+ |
+8 | struct Foo<Pinned, Unpinned> {
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+note: the lint level is defined here
+ --> tests/ui/unstable-features/negative_impls.rs:2:9
+ |
+2 | #![deny(suspicious_auto_trait_impls)]
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/third_party/rust/pin-project/tests/ui/unstable-features/overlapping_marker_traits-feature-gate.rs b/third_party/rust/pin-project/tests/ui/unstable-features/overlapping_marker_traits-feature-gate.rs
new file mode 100644
index 0000000000..012c8709bd
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/unstable-features/overlapping_marker_traits-feature-gate.rs
@@ -0,0 +1,20 @@
+// Note: If you change this test, change 'overlapping_marker_traits.rs' at the same time.
+
+use std::marker::PhantomPinned;
+
+use pin_project::pin_project;
+
+#[pin_project] //~ ERROR E0119
+struct Struct<T> {
+ #[pin]
+ f: T,
+}
+
+// unsound Unpin impl
+impl<T> Unpin for Struct<T> {}
+
+fn is_unpin<T: Unpin>() {}
+
+fn main() {
+ is_unpin::<Struct<PhantomPinned>>()
+}
diff --git a/third_party/rust/pin-project/tests/ui/unstable-features/overlapping_marker_traits-feature-gate.stderr b/third_party/rust/pin-project/tests/ui/unstable-features/overlapping_marker_traits-feature-gate.stderr
new file mode 100644
index 0000000000..0783be047c
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/unstable-features/overlapping_marker_traits-feature-gate.stderr
@@ -0,0 +1,10 @@
+error[E0119]: conflicting implementations of trait `Unpin` for type `Struct<_>`
+ --> tests/ui/unstable-features/overlapping_marker_traits-feature-gate.rs:7:1
+ |
+7 | #[pin_project] //~ ERROR E0119
+ | ^^^^^^^^^^^^^^ conflicting implementation for `Struct<_>`
+...
+14 | impl<T> Unpin for Struct<T> {}
+ | --------------------------- first implementation here
+ |
+ = note: this error originates in the derive macro `::pin_project::__private::__PinProjectInternalDerive` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/third_party/rust/pin-project/tests/ui/unstable-features/overlapping_marker_traits.rs b/third_party/rust/pin-project/tests/ui/unstable-features/overlapping_marker_traits.rs
new file mode 100644
index 0000000000..8dc27c1dba
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/unstable-features/overlapping_marker_traits.rs
@@ -0,0 +1,30 @@
+// Note: If you change this test, change 'overlapping_marker_traits-feature-gate.rs' at the same time.
+
+// This feature could break the guarantee for Unpin provided by pin-project,
+// but was removed in https://github.com/rust-lang/rust/pull/68544 (nightly-2020-02-06).
+// Refs:
+// - https://github.com/rust-lang/rust/issues/29864#issuecomment-515780867
+// - https://github.com/taiki-e/pin-project/issues/105
+
+// overlapping_marker_traits
+// Tracking issue: https://github.com/rust-lang/rust/issues/29864
+#![feature(overlapping_marker_traits)]
+
+use std::marker::PhantomPinned;
+
+use pin_project::pin_project;
+
+#[pin_project]
+struct Struct<T> {
+ #[pin]
+ f: T,
+}
+
+// unsound Unpin impl
+impl<T> Unpin for Struct<T> {}
+
+fn is_unpin<T: Unpin>() {}
+
+fn main() {
+ is_unpin::<Struct<PhantomPinned>>()
+}
diff --git a/third_party/rust/pin-project/tests/ui/unstable-features/overlapping_marker_traits.stderr b/third_party/rust/pin-project/tests/ui/unstable-features/overlapping_marker_traits.stderr
new file mode 100644
index 0000000000..1c8e7e7040
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/unstable-features/overlapping_marker_traits.stderr
@@ -0,0 +1,18 @@
+error[E0557]: feature has been removed
+ --> tests/ui/unstable-features/overlapping_marker_traits.rs:11:12
+ |
+11 | #![feature(overlapping_marker_traits)]
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^ feature has been removed
+ |
+ = note: removed in favor of `#![feature(marker_trait_attr)]`
+
+error[E0119]: conflicting implementations of trait `Unpin` for type `Struct<_>`
+ --> tests/ui/unstable-features/overlapping_marker_traits.rs:17:1
+ |
+17 | #[pin_project]
+ | ^^^^^^^^^^^^^^ conflicting implementation for `Struct<_>`
+...
+24 | impl<T> Unpin for Struct<T> {}
+ | --------------------------- first implementation here
+ |
+ = note: this error originates in the derive macro `::pin_project::__private::__PinProjectInternalDerive` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/third_party/rust/pin-project/tests/ui/unstable-features/trivial_bounds-feature-gate.rs b/third_party/rust/pin-project/tests/ui/unstable-features/trivial_bounds-feature-gate.rs
new file mode 100644
index 0000000000..f8467b082e
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/unstable-features/trivial_bounds-feature-gate.rs
@@ -0,0 +1,53 @@
+// Note: If you change this test, change 'trivial_bounds.rs' at the same time.
+
+mod phantom_pinned {
+ use std::marker::{PhantomData, PhantomPinned};
+
+ struct A(PhantomPinned);
+
+ impl Unpin for A where PhantomPinned: Unpin {} //~ ERROR E0277
+
+ struct Wrapper<T>(T);
+
+ impl<T> Unpin for Wrapper<T> where T: Unpin {}
+
+ struct B(PhantomPinned);
+
+ impl Unpin for B where Wrapper<PhantomPinned>: Unpin {} //~ ERROR E0277
+
+ struct WrapperWithLifetime<'a, T>(PhantomData<&'a ()>, T);
+
+ impl<T> Unpin for WrapperWithLifetime<'_, T> where T: Unpin {}
+
+ struct C(PhantomPinned);
+
+ impl<'a> Unpin for C where WrapperWithLifetime<'a, PhantomPinned>: Unpin {} // Ok
+}
+
+mod inner {
+ use std::marker::{PhantomData, PhantomPinned};
+
+ struct Inner(PhantomPinned);
+
+ struct A(Inner);
+
+ impl Unpin for A where Inner: Unpin {} //~ ERROR E0277
+
+ struct Wrapper<T>(T);
+
+ impl<T> Unpin for Wrapper<T> where T: Unpin {}
+
+ struct B(Inner);
+
+ impl Unpin for B where Wrapper<Inner>: Unpin {} //~ ERROR E0277
+
+ struct WrapperWithLifetime<'a, T>(PhantomData<&'a ()>, T);
+
+ impl<T> Unpin for WrapperWithLifetime<'_, T> where T: Unpin {}
+
+ struct C(Inner);
+
+ impl<'a> Unpin for C where WrapperWithLifetime<'a, Inner>: Unpin {} // Ok
+}
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/ui/unstable-features/trivial_bounds-feature-gate.stderr b/third_party/rust/pin-project/tests/ui/unstable-features/trivial_bounds-feature-gate.stderr
new file mode 100644
index 0000000000..ccf1ae8d94
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/unstable-features/trivial_bounds-feature-gate.stderr
@@ -0,0 +1,63 @@
+error[E0277]: `PhantomPinned` cannot be unpinned
+ --> tests/ui/unstable-features/trivial_bounds-feature-gate.rs:8:28
+ |
+8 | impl Unpin for A where PhantomPinned: Unpin {} //~ ERROR E0277
+ | ^^^^^^^^^^^^^^^^^^^^ the trait `Unpin` is not implemented for `PhantomPinned`
+ |
+ = note: consider using the `pin!` macro
+ consider using `Box::pin` if you need to access the pinned value outside of the current scope
+ = help: see issue #48214
+ = help: add `#![feature(trivial_bounds)]` to the crate attributes to enable
+
+error[E0277]: `PhantomPinned` cannot be unpinned
+ --> tests/ui/unstable-features/trivial_bounds-feature-gate.rs:16:28
+ |
+16 | impl Unpin for B where Wrapper<PhantomPinned>: Unpin {} //~ ERROR E0277
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Unpin` is not implemented for `PhantomPinned`
+ |
+ = note: consider using the `pin!` macro
+ consider using `Box::pin` if you need to access the pinned value outside of the current scope
+note: required for `phantom_pinned::Wrapper<PhantomPinned>` to implement `Unpin`
+ --> tests/ui/unstable-features/trivial_bounds-feature-gate.rs:12:13
+ |
+12 | impl<T> Unpin for Wrapper<T> where T: Unpin {}
+ | ^^^^^ ^^^^^^^^^^ ----- unsatisfied trait bound introduced here
+ = help: see issue #48214
+ = help: add `#![feature(trivial_bounds)]` to the crate attributes to enable
+
+error[E0277]: `PhantomPinned` cannot be unpinned
+ --> tests/ui/unstable-features/trivial_bounds-feature-gate.rs:34:28
+ |
+34 | impl Unpin for A where Inner: Unpin {} //~ ERROR E0277
+ | ^^^^^^^^^^^^ within `Inner`, the trait `Unpin` is not implemented for `PhantomPinned`
+ |
+ = note: consider using the `pin!` macro
+ consider using `Box::pin` if you need to access the pinned value outside of the current scope
+note: required because it appears within the type `Inner`
+ --> tests/ui/unstable-features/trivial_bounds-feature-gate.rs:30:12
+ |
+30 | struct Inner(PhantomPinned);
+ | ^^^^^
+ = help: see issue #48214
+ = help: add `#![feature(trivial_bounds)]` to the crate attributes to enable
+
+error[E0277]: `PhantomPinned` cannot be unpinned
+ --> tests/ui/unstable-features/trivial_bounds-feature-gate.rs:42:28
+ |
+42 | impl Unpin for B where Wrapper<Inner>: Unpin {} //~ ERROR E0277
+ | ^^^^^^^^^^^^^^^^^^^^^ within `Inner`, the trait `Unpin` is not implemented for `PhantomPinned`
+ |
+ = note: consider using the `pin!` macro
+ consider using `Box::pin` if you need to access the pinned value outside of the current scope
+note: required because it appears within the type `Inner`
+ --> tests/ui/unstable-features/trivial_bounds-feature-gate.rs:30:12
+ |
+30 | struct Inner(PhantomPinned);
+ | ^^^^^
+note: required for `inner::Wrapper<Inner>` to implement `Unpin`
+ --> tests/ui/unstable-features/trivial_bounds-feature-gate.rs:38:13
+ |
+38 | impl<T> Unpin for Wrapper<T> where T: Unpin {}
+ | ^^^^^ ^^^^^^^^^^ ----- unsatisfied trait bound introduced here
+ = help: see issue #48214
+ = help: add `#![feature(trivial_bounds)]` to the crate attributes to enable
diff --git a/third_party/rust/pin-project/tests/ui/unstable-features/trivial_bounds.rs b/third_party/rust/pin-project/tests/ui/unstable-features/trivial_bounds.rs
new file mode 100644
index 0000000000..d98ef60e6d
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/unstable-features/trivial_bounds.rs
@@ -0,0 +1,39 @@
+// Note: If you change this test, change 'trivial_bounds-feature-gate.rs' at the same time.
+
+// trivial_bounds
+// Tracking issue: https://github.com/rust-lang/rust/issues/48214
+#![feature(trivial_bounds)]
+#![deny(trivial_bounds)]
+#![allow(dead_code)]
+
+use std::marker::{PhantomData, PhantomPinned};
+
+fn inner() {
+ struct Inner(PhantomPinned);
+
+ struct A(PhantomPinned);
+
+ impl Unpin for A where PhantomPinned: Unpin {} //~ ERROR Unpin does not depend on any type or lifetime parameters
+
+ struct B(Inner);
+
+ impl Unpin for B where Inner: Unpin {} //~ ERROR Unpin does not depend on any type or lifetime parameters
+
+ struct Wrapper<T>(T);
+
+ impl<T> Unpin for Wrapper<T> where T: Unpin {}
+
+ struct C(Inner);
+
+ impl Unpin for C where Wrapper<Inner>: Unpin {} //~ ERROR Unpin does not depend on any type or lifetime parameters
+
+ struct WrapperWithLifetime<'a, T>(PhantomData<&'a ()>, T);
+
+ impl<T> Unpin for WrapperWithLifetime<'_, T> where T: Unpin {}
+
+ struct D(Inner);
+
+ impl<'a> Unpin for D where WrapperWithLifetime<'a, Inner>: Unpin {} // Ok
+}
+
+fn main() {}
diff --git a/third_party/rust/pin-project/tests/ui/unstable-features/trivial_bounds.stderr b/third_party/rust/pin-project/tests/ui/unstable-features/trivial_bounds.stderr
new file mode 100644
index 0000000000..ab07a102ec
--- /dev/null
+++ b/third_party/rust/pin-project/tests/ui/unstable-features/trivial_bounds.stderr
@@ -0,0 +1,23 @@
+error: trait bound PhantomPinned: Unpin does not depend on any type or lifetime parameters
+ --> tests/ui/unstable-features/trivial_bounds.rs:16:43
+ |
+16 | impl Unpin for A where PhantomPinned: Unpin {} //~ ERROR Unpin does not depend on any type or lifetime parameters
+ | ^^^^^
+ |
+note: the lint level is defined here
+ --> tests/ui/unstable-features/trivial_bounds.rs:6:9
+ |
+6 | #![deny(trivial_bounds)]
+ | ^^^^^^^^^^^^^^
+
+error: trait bound Inner: Unpin does not depend on any type or lifetime parameters
+ --> tests/ui/unstable-features/trivial_bounds.rs:20:35
+ |
+20 | impl Unpin for B where Inner: Unpin {} //~ ERROR Unpin does not depend on any type or lifetime parameters
+ | ^^^^^
+
+error: trait bound Wrapper<Inner>: Unpin does not depend on any type or lifetime parameters
+ --> tests/ui/unstable-features/trivial_bounds.rs:28:44
+ |
+28 | impl Unpin for C where Wrapper<Inner>: Unpin {} //~ ERROR Unpin does not depend on any type or lifetime parameters
+ | ^^^^^
diff --git a/third_party/rust/pin-project/tests/unsafe_unpin.rs b/third_party/rust/pin-project/tests/unsafe_unpin.rs
new file mode 100644
index 0000000000..72f40f9221
--- /dev/null
+++ b/third_party/rust/pin-project/tests/unsafe_unpin.rs
@@ -0,0 +1,50 @@
+#![warn(rust_2018_idioms, single_use_lifetimes)]
+#![allow(dead_code)]
+
+#[macro_use]
+mod auxiliary;
+
+use std::marker::PhantomPinned;
+
+use pin_project::{pin_project, UnsafeUnpin};
+
+#[pin_project(UnsafeUnpin)]
+pub struct Blah<T, U> {
+ f1: U,
+ #[pin]
+ f2: T,
+}
+
+unsafe impl<T: Unpin, U> UnsafeUnpin for Blah<T, U> {}
+
+assert_unpin!(Blah<(), ()>);
+assert_unpin!(Blah<(), PhantomPinned>);
+assert_not_unpin!(Blah<PhantomPinned, ()>);
+assert_not_unpin!(Blah<PhantomPinned, PhantomPinned>);
+
+#[pin_project(UnsafeUnpin)]
+struct OverlappingLifetimeNames<'pin, T, U> {
+ #[pin]
+ f1: U,
+ #[pin]
+ f2: Option<T>,
+ f3: &'pin (),
+}
+
+unsafe impl<T: Unpin, U: Unpin> UnsafeUnpin for OverlappingLifetimeNames<'_, T, U> {}
+
+assert_unpin!(OverlappingLifetimeNames<'_, (), ()>);
+assert_not_unpin!(OverlappingLifetimeNames<'_, PhantomPinned, ()>);
+assert_not_unpin!(OverlappingLifetimeNames<'_, (), PhantomPinned>);
+assert_not_unpin!(OverlappingLifetimeNames<'_, PhantomPinned, PhantomPinned>);
+
+#[test]
+fn trivial_bounds() {
+ #[pin_project(UnsafeUnpin)]
+ pub struct NotImplementUnsafeUnpin {
+ #[pin]
+ f: PhantomPinned,
+ }
+
+ assert_not_unpin!(NotImplementUnsafeUnpin);
+}