From 26a029d407be480d791972afb5975cf62c9360a6 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Fri, 19 Apr 2024 02:47:55 +0200 Subject: Adding upstream version 124.0.1. Signed-off-by: Daniel Baumann --- .../rust/pin-project/tests/auxiliary/mod.rs | 12 + third_party/rust/pin-project/tests/cfg.rs | 184 +++ third_party/rust/pin-project/tests/compiletest.rs | 17 + third_party/rust/pin-project/tests/drop_order.rs | 162 +++ .../tests/expand/default/enum.expanded.rs | 145 +++ .../rust/pin-project/tests/expand/default/enum.rs | 14 + .../tests/expand/default/struct.expanded.rs | 104 ++ .../pin-project/tests/expand/default/struct.rs | 10 + .../tests/expand/default/tuple_struct.expanded.rs | 98 ++ .../tests/expand/default/tuple_struct.rs | 6 + .../tests/expand/multifields/enum.expanded.rs | 268 +++++ .../pin-project/tests/expand/multifields/enum.rs | 17 + .../tests/expand/multifields/struct.expanded.rs | 155 +++ .../pin-project/tests/expand/multifields/struct.rs | 13 + .../expand/multifields/tuple_struct.expanded.rs | 145 +++ .../tests/expand/multifields/tuple_struct.rs | 6 + .../tests/expand/naming/enum-all.expanded.rs | 204 ++++ .../pin-project/tests/expand/naming/enum-all.rs | 14 + .../tests/expand/naming/enum-mut.expanded.rs | 99 ++ .../pin-project/tests/expand/naming/enum-mut.rs | 14 + .../tests/expand/naming/enum-none.expanded.rs | 56 + .../pin-project/tests/expand/naming/enum-none.rs | 14 + .../tests/expand/naming/enum-own.expanded.rs | 119 ++ .../pin-project/tests/expand/naming/enum-own.rs | 14 + .../tests/expand/naming/enum-ref.expanded.rs | 100 ++ .../pin-project/tests/expand/naming/enum-ref.rs | 14 + .../tests/expand/naming/struct-all.expanded.rs | 163 +++ .../pin-project/tests/expand/naming/struct-all.rs | 10 + .../tests/expand/naming/struct-mut.expanded.rs | 114 ++ .../pin-project/tests/expand/naming/struct-mut.rs | 10 + .../tests/expand/naming/struct-none.expanded.rs | 104 ++ .../pin-project/tests/expand/naming/struct-none.rs | 10 + .../tests/expand/naming/struct-own.expanded.rs | 143 +++ .../pin-project/tests/expand/naming/struct-own.rs | 10 + .../tests/expand/naming/struct-ref.expanded.rs | 114 ++ .../pin-project/tests/expand/naming/struct-ref.rs | 10 + .../expand/naming/tuple_struct-all.expanded.rs | 148 +++ .../tests/expand/naming/tuple_struct-all.rs | 6 + .../expand/naming/tuple_struct-mut.expanded.rs | 105 ++ .../tests/expand/naming/tuple_struct-mut.rs | 6 + .../expand/naming/tuple_struct-none.expanded.rs | 98 ++ .../tests/expand/naming/tuple_struct-none.rs | 6 + .../expand/naming/tuple_struct-own.expanded.rs | 134 +++ .../tests/expand/naming/tuple_struct-own.rs | 6 + .../expand/naming/tuple_struct-ref.expanded.rs | 105 ++ .../tests/expand/naming/tuple_struct-ref.rs | 6 + .../tests/expand/not_unpin/enum.expanded.rs | 139 +++ .../pin-project/tests/expand/not_unpin/enum.rs | 14 + .../tests/expand/not_unpin/struct.expanded.rs | 99 ++ .../pin-project/tests/expand/not_unpin/struct.rs | 10 + .../expand/not_unpin/tuple_struct.expanded.rs | 93 ++ .../tests/expand/not_unpin/tuple_struct.rs | 6 + .../tests/expand/pinned_drop/enum.expanded.rs | 157 +++ .../pin-project/tests/expand/pinned_drop/enum.rs | 23 + .../tests/expand/pinned_drop/struct.expanded.rs | 116 ++ .../pin-project/tests/expand/pinned_drop/struct.rs | 19 + .../expand/pinned_drop/tuple_struct.expanded.rs | 110 ++ .../tests/expand/pinned_drop/tuple_struct.rs | 15 + .../tests/expand/project_replace/enum.expanded.rs | 119 ++ .../tests/expand/project_replace/enum.rs | 14 + .../expand/project_replace/struct.expanded.rs | 133 +++ .../tests/expand/project_replace/struct.rs | 10 + .../project_replace/tuple_struct.expanded.rs | 127 +++ .../tests/expand/project_replace/tuple_struct.rs | 6 + .../pin-project/tests/expand/pub/enum.expanded.rs | 145 +++ .../rust/pin-project/tests/expand/pub/enum.rs | 14 + .../tests/expand/pub/struct.expanded.rs | 104 ++ .../rust/pin-project/tests/expand/pub/struct.rs | 10 + .../tests/expand/pub/tuple_struct.expanded.rs | 98 ++ .../pin-project/tests/expand/pub/tuple_struct.rs | 6 + .../tests/expand/unsafe_unpin/enum.expanded.rs | 129 +++ .../pin-project/tests/expand/unsafe_unpin/enum.rs | 16 + .../tests/expand/unsafe_unpin/struct.expanded.rs | 89 ++ .../tests/expand/unsafe_unpin/struct.rs | 12 + .../expand/unsafe_unpin/tuple_struct.expanded.rs | 83 ++ .../tests/expand/unsafe_unpin/tuple_struct.rs | 8 + third_party/rust/pin-project/tests/expandtest.rs | 44 + .../pin-project/tests/include/basic-safe-part.rs | 193 ++++ .../rust/pin-project/tests/include/basic.rs | 17 + third_party/rust/pin-project/tests/lint.rs | 1191 ++++++++++++++++++++ third_party/rust/pin-project/tests/pin_project.rs | 888 +++++++++++++++ third_party/rust/pin-project/tests/pinned_drop.rs | 284 +++++ third_party/rust/pin-project/tests/proper_unpin.rs | 153 +++ third_party/rust/pin-project/tests/repr_packed.rs | 52 + .../pin-project/tests/ui/cfg/cfg_attr-resolve.rs | 11 + .../tests/ui/cfg/cfg_attr-resolve.stderr | 5 + .../tests/ui/cfg/cfg_attr-type-mismatch.rs | 25 + .../tests/ui/cfg/cfg_attr-type-mismatch.stderr | 25 + .../tests/ui/cfg/packed_sneaky-span-issue-1.rs | 15 + .../tests/ui/cfg/packed_sneaky-span-issue-1.stderr | 5 + .../tests/ui/cfg/packed_sneaky-span-issue-2.rs | 15 + .../tests/ui/cfg/packed_sneaky-span-issue-2.stderr | 5 + .../rust/pin-project/tests/ui/cfg/packed_sneaky.rs | 12 + .../pin-project/tests/ui/cfg/packed_sneaky.stderr | 5 + .../rust/pin-project/tests/ui/cfg/unsupported.rs | 11 + .../pin-project/tests/ui/cfg/unsupported.stderr | 11 + .../tests/ui/not_unpin/conflict-unpin.rs | 30 + .../tests/ui/not_unpin/conflict-unpin.stderr | 26 + .../tests/ui/not_unpin/impl-unsafe-unpin.rs | 30 + .../tests/ui/not_unpin/impl-unsafe-unpin.stderr | 32 + .../tests/ui/pin_project/add-attr-to-struct.rs | 20 + .../tests/ui/pin_project/add-attr-to-struct.stderr | 15 + .../tests/ui/pin_project/add-pinned-field.rs | 23 + .../tests/ui/pin_project/add-pinned-field.stderr | 54 + .../tests/ui/pin_project/conflict-drop.rs | 32 + .../tests/ui/pin_project/conflict-drop.stderr | 19 + .../tests/ui/pin_project/conflict-unpin.rs | 37 + .../tests/ui/pin_project/conflict-unpin.stderr | 32 + .../tests/ui/pin_project/impl-unsafe-unpin.rs | 30 + .../tests/ui/pin_project/impl-unsafe-unpin.stderr | 32 + .../tests/ui/pin_project/import_unnamed.rs | 30 + .../tests/ui/pin_project/import_unnamed.stderr | 29 + .../pin-project/tests/ui/pin_project/invalid.rs | 280 +++++ .../tests/ui/pin_project/invalid.stderr | 364 ++++++ .../ui/pin_project/overlapping_unpin_struct.rs | 19 + .../ui/pin_project/overlapping_unpin_struct.stderr | 26 + .../tests/ui/pin_project/override-priv-mod.rs | 32 + .../tests/ui/pin_project/override-priv-mod.stderr | 10 + .../tests/ui/pin_project/packed-enum.rs | 24 + .../tests/ui/pin_project/packed-enum.stderr | 42 + .../tests/ui/pin_project/packed-name-value.rs | 27 + .../tests/ui/pin_project/packed-name-value.stderr | 23 + .../pin-project/tests/ui/pin_project/packed.rs | 33 + .../pin-project/tests/ui/pin_project/packed.stderr | 23 + .../tests/ui/pin_project/packed_sneaky-1.rs | 41 + .../tests/ui/pin_project/packed_sneaky-1.stderr | 25 + .../tests/ui/pin_project/packed_sneaky-2.rs | 12 + .../tests/ui/pin_project/packed_sneaky-2.stderr | 13 + .../tests/ui/pin_project/packed_sneaky-3.rs | 32 + .../tests/ui/pin_project/packed_sneaky-3.stderr | 32 + .../tests/ui/pin_project/packed_sneaky-4.rs | 13 + .../tests/ui/pin_project/packed_sneaky-4.stderr | 20 + .../tests/ui/pin_project/private_in_public-enum.rs | 23 + .../ui/pin_project/private_in_public-enum.stderr | 17 + .../ui/pin_project/project_replace_unsized.rs | 11 + .../ui/pin_project/project_replace_unsized.stderr | 124 ++ .../project_replace_unsized_fn_params.rs | 13 + .../project_replace_unsized_fn_params.stderr | 118 ++ .../tests/ui/pin_project/remove-attr-from-field.rs | 33 + .../ui/pin_project/remove-attr-from-field.stderr | 21 + .../ui/pin_project/remove-attr-from-struct.rs | 47 + .../ui/pin_project/remove-attr-from-struct.stderr | 117 ++ .../tests/ui/pin_project/safe_packed_borrows.rs | 25 + .../ui/pin_project/safe_packed_borrows.stderr | 31 + .../tests/ui/pin_project/unaligned_references.rs | 19 + .../ui/pin_project/unaligned_references.stderr | 19 + .../tests/ui/pin_project/unpin_sneaky.rs | 11 + .../tests/ui/pin_project/unpin_sneaky.stderr | 5 + .../pin-project/tests/ui/pin_project/visibility.rs | 49 + .../tests/ui/pin_project/visibility.stderr | 39 + .../tests/ui/pinned_drop/call-drop-inner.rs | 17 + .../tests/ui/pinned_drop/call-drop-inner.stderr | 15 + .../tests/ui/pinned_drop/conditional-drop-impl.rs | 27 + .../ui/pinned_drop/conditional-drop-impl.stderr | 31 + .../ui/pinned_drop/forget-pinned-drop-impl.rs | 9 + .../ui/pinned_drop/forget-pinned-drop-impl.stderr | 5 + .../tests/ui/pinned_drop/invalid-self.rs | 14 + .../tests/ui/pinned_drop/invalid-self.stderr | 25 + .../pin-project/tests/ui/pinned_drop/invalid.rs | 231 ++++ .../tests/ui/pinned_drop/invalid.stderr | 143 +++ .../ui/pinned_drop/pinned-drop-no-attr-arg.rs | 17 + .../ui/pinned_drop/pinned-drop-no-attr-arg.stderr | 8 + .../rust/pin-project/tests/ui/pinned_drop/self.rs | 58 + .../pin-project/tests/ui/pinned_drop/self.stderr | 62 + .../tests/ui/pinned_drop/unsafe-call.rs | 18 + .../tests/ui/pinned_drop/unsafe-call.stderr | 10 + .../tests/ui/unsafe_unpin/conflict-unpin.rs | 30 + .../tests/ui/unsafe_unpin/conflict-unpin.stderr | 32 + .../tests/ui/unstable-features/README.md | 7 + .../marker_trait_attr-feature-gate.rs | 20 + .../marker_trait_attr-feature-gate.stderr | 10 + .../ui/unstable-features/marker_trait_attr.rs | 26 + .../ui/unstable-features/marker_trait_attr.stderr | 10 + .../tests/ui/unstable-features/negative_impls.rs | 23 + .../ui/unstable-features/negative_impls.stderr | 19 + .../overlapping_marker_traits-feature-gate.rs | 20 + .../overlapping_marker_traits-feature-gate.stderr | 10 + .../unstable-features/overlapping_marker_traits.rs | 30 + .../overlapping_marker_traits.stderr | 18 + .../trivial_bounds-feature-gate.rs | 53 + .../trivial_bounds-feature-gate.stderr | 63 ++ .../tests/ui/unstable-features/trivial_bounds.rs | 39 + .../ui/unstable-features/trivial_bounds.stderr | 23 + third_party/rust/pin-project/tests/unsafe_unpin.rs | 50 + 184 files changed, 11660 insertions(+) create mode 100644 third_party/rust/pin-project/tests/auxiliary/mod.rs create mode 100644 third_party/rust/pin-project/tests/cfg.rs create mode 100644 third_party/rust/pin-project/tests/compiletest.rs create mode 100644 third_party/rust/pin-project/tests/drop_order.rs create mode 100644 third_party/rust/pin-project/tests/expand/default/enum.expanded.rs create mode 100644 third_party/rust/pin-project/tests/expand/default/enum.rs create mode 100644 third_party/rust/pin-project/tests/expand/default/struct.expanded.rs create mode 100644 third_party/rust/pin-project/tests/expand/default/struct.rs create mode 100644 third_party/rust/pin-project/tests/expand/default/tuple_struct.expanded.rs create mode 100644 third_party/rust/pin-project/tests/expand/default/tuple_struct.rs create mode 100644 third_party/rust/pin-project/tests/expand/multifields/enum.expanded.rs create mode 100644 third_party/rust/pin-project/tests/expand/multifields/enum.rs create mode 100644 third_party/rust/pin-project/tests/expand/multifields/struct.expanded.rs create mode 100644 third_party/rust/pin-project/tests/expand/multifields/struct.rs create mode 100644 third_party/rust/pin-project/tests/expand/multifields/tuple_struct.expanded.rs create mode 100644 third_party/rust/pin-project/tests/expand/multifields/tuple_struct.rs create mode 100644 third_party/rust/pin-project/tests/expand/naming/enum-all.expanded.rs create mode 100644 third_party/rust/pin-project/tests/expand/naming/enum-all.rs create mode 100644 third_party/rust/pin-project/tests/expand/naming/enum-mut.expanded.rs create mode 100644 third_party/rust/pin-project/tests/expand/naming/enum-mut.rs create mode 100644 third_party/rust/pin-project/tests/expand/naming/enum-none.expanded.rs create mode 100644 third_party/rust/pin-project/tests/expand/naming/enum-none.rs create mode 100644 third_party/rust/pin-project/tests/expand/naming/enum-own.expanded.rs create mode 100644 third_party/rust/pin-project/tests/expand/naming/enum-own.rs create mode 100644 third_party/rust/pin-project/tests/expand/naming/enum-ref.expanded.rs create mode 100644 third_party/rust/pin-project/tests/expand/naming/enum-ref.rs create mode 100644 third_party/rust/pin-project/tests/expand/naming/struct-all.expanded.rs create mode 100644 third_party/rust/pin-project/tests/expand/naming/struct-all.rs create mode 100644 third_party/rust/pin-project/tests/expand/naming/struct-mut.expanded.rs create mode 100644 third_party/rust/pin-project/tests/expand/naming/struct-mut.rs create mode 100644 third_party/rust/pin-project/tests/expand/naming/struct-none.expanded.rs create mode 100644 third_party/rust/pin-project/tests/expand/naming/struct-none.rs create mode 100644 third_party/rust/pin-project/tests/expand/naming/struct-own.expanded.rs create mode 100644 third_party/rust/pin-project/tests/expand/naming/struct-own.rs create mode 100644 third_party/rust/pin-project/tests/expand/naming/struct-ref.expanded.rs create mode 100644 third_party/rust/pin-project/tests/expand/naming/struct-ref.rs create mode 100644 third_party/rust/pin-project/tests/expand/naming/tuple_struct-all.expanded.rs create mode 100644 third_party/rust/pin-project/tests/expand/naming/tuple_struct-all.rs create mode 100644 third_party/rust/pin-project/tests/expand/naming/tuple_struct-mut.expanded.rs create mode 100644 third_party/rust/pin-project/tests/expand/naming/tuple_struct-mut.rs create mode 100644 third_party/rust/pin-project/tests/expand/naming/tuple_struct-none.expanded.rs create mode 100644 third_party/rust/pin-project/tests/expand/naming/tuple_struct-none.rs create mode 100644 third_party/rust/pin-project/tests/expand/naming/tuple_struct-own.expanded.rs create mode 100644 third_party/rust/pin-project/tests/expand/naming/tuple_struct-own.rs create mode 100644 third_party/rust/pin-project/tests/expand/naming/tuple_struct-ref.expanded.rs create mode 100644 third_party/rust/pin-project/tests/expand/naming/tuple_struct-ref.rs create mode 100644 third_party/rust/pin-project/tests/expand/not_unpin/enum.expanded.rs create mode 100644 third_party/rust/pin-project/tests/expand/not_unpin/enum.rs create mode 100644 third_party/rust/pin-project/tests/expand/not_unpin/struct.expanded.rs create mode 100644 third_party/rust/pin-project/tests/expand/not_unpin/struct.rs create mode 100644 third_party/rust/pin-project/tests/expand/not_unpin/tuple_struct.expanded.rs create mode 100644 third_party/rust/pin-project/tests/expand/not_unpin/tuple_struct.rs create mode 100644 third_party/rust/pin-project/tests/expand/pinned_drop/enum.expanded.rs create mode 100644 third_party/rust/pin-project/tests/expand/pinned_drop/enum.rs create mode 100644 third_party/rust/pin-project/tests/expand/pinned_drop/struct.expanded.rs create mode 100644 third_party/rust/pin-project/tests/expand/pinned_drop/struct.rs create mode 100644 third_party/rust/pin-project/tests/expand/pinned_drop/tuple_struct.expanded.rs create mode 100644 third_party/rust/pin-project/tests/expand/pinned_drop/tuple_struct.rs create mode 100644 third_party/rust/pin-project/tests/expand/project_replace/enum.expanded.rs create mode 100644 third_party/rust/pin-project/tests/expand/project_replace/enum.rs create mode 100644 third_party/rust/pin-project/tests/expand/project_replace/struct.expanded.rs create mode 100644 third_party/rust/pin-project/tests/expand/project_replace/struct.rs create mode 100644 third_party/rust/pin-project/tests/expand/project_replace/tuple_struct.expanded.rs create mode 100644 third_party/rust/pin-project/tests/expand/project_replace/tuple_struct.rs create mode 100644 third_party/rust/pin-project/tests/expand/pub/enum.expanded.rs create mode 100644 third_party/rust/pin-project/tests/expand/pub/enum.rs create mode 100644 third_party/rust/pin-project/tests/expand/pub/struct.expanded.rs create mode 100644 third_party/rust/pin-project/tests/expand/pub/struct.rs create mode 100644 third_party/rust/pin-project/tests/expand/pub/tuple_struct.expanded.rs create mode 100644 third_party/rust/pin-project/tests/expand/pub/tuple_struct.rs create mode 100644 third_party/rust/pin-project/tests/expand/unsafe_unpin/enum.expanded.rs create mode 100644 third_party/rust/pin-project/tests/expand/unsafe_unpin/enum.rs create mode 100644 third_party/rust/pin-project/tests/expand/unsafe_unpin/struct.expanded.rs create mode 100644 third_party/rust/pin-project/tests/expand/unsafe_unpin/struct.rs create mode 100644 third_party/rust/pin-project/tests/expand/unsafe_unpin/tuple_struct.expanded.rs create mode 100644 third_party/rust/pin-project/tests/expand/unsafe_unpin/tuple_struct.rs create mode 100644 third_party/rust/pin-project/tests/expandtest.rs create mode 100644 third_party/rust/pin-project/tests/include/basic-safe-part.rs create mode 100644 third_party/rust/pin-project/tests/include/basic.rs create mode 100644 third_party/rust/pin-project/tests/lint.rs create mode 100644 third_party/rust/pin-project/tests/pin_project.rs create mode 100644 third_party/rust/pin-project/tests/pinned_drop.rs create mode 100644 third_party/rust/pin-project/tests/proper_unpin.rs create mode 100644 third_party/rust/pin-project/tests/repr_packed.rs create mode 100644 third_party/rust/pin-project/tests/ui/cfg/cfg_attr-resolve.rs create mode 100644 third_party/rust/pin-project/tests/ui/cfg/cfg_attr-resolve.stderr create mode 100644 third_party/rust/pin-project/tests/ui/cfg/cfg_attr-type-mismatch.rs create mode 100644 third_party/rust/pin-project/tests/ui/cfg/cfg_attr-type-mismatch.stderr create mode 100644 third_party/rust/pin-project/tests/ui/cfg/packed_sneaky-span-issue-1.rs create mode 100644 third_party/rust/pin-project/tests/ui/cfg/packed_sneaky-span-issue-1.stderr create mode 100644 third_party/rust/pin-project/tests/ui/cfg/packed_sneaky-span-issue-2.rs create mode 100644 third_party/rust/pin-project/tests/ui/cfg/packed_sneaky-span-issue-2.stderr create mode 100644 third_party/rust/pin-project/tests/ui/cfg/packed_sneaky.rs create mode 100644 third_party/rust/pin-project/tests/ui/cfg/packed_sneaky.stderr create mode 100644 third_party/rust/pin-project/tests/ui/cfg/unsupported.rs create mode 100644 third_party/rust/pin-project/tests/ui/cfg/unsupported.stderr create mode 100644 third_party/rust/pin-project/tests/ui/not_unpin/conflict-unpin.rs create mode 100644 third_party/rust/pin-project/tests/ui/not_unpin/conflict-unpin.stderr create mode 100644 third_party/rust/pin-project/tests/ui/not_unpin/impl-unsafe-unpin.rs create mode 100644 third_party/rust/pin-project/tests/ui/not_unpin/impl-unsafe-unpin.stderr create mode 100644 third_party/rust/pin-project/tests/ui/pin_project/add-attr-to-struct.rs create mode 100644 third_party/rust/pin-project/tests/ui/pin_project/add-attr-to-struct.stderr create mode 100644 third_party/rust/pin-project/tests/ui/pin_project/add-pinned-field.rs create mode 100644 third_party/rust/pin-project/tests/ui/pin_project/add-pinned-field.stderr create mode 100644 third_party/rust/pin-project/tests/ui/pin_project/conflict-drop.rs create mode 100644 third_party/rust/pin-project/tests/ui/pin_project/conflict-drop.stderr create mode 100644 third_party/rust/pin-project/tests/ui/pin_project/conflict-unpin.rs create mode 100644 third_party/rust/pin-project/tests/ui/pin_project/conflict-unpin.stderr create mode 100644 third_party/rust/pin-project/tests/ui/pin_project/impl-unsafe-unpin.rs create mode 100644 third_party/rust/pin-project/tests/ui/pin_project/impl-unsafe-unpin.stderr create mode 100644 third_party/rust/pin-project/tests/ui/pin_project/import_unnamed.rs create mode 100644 third_party/rust/pin-project/tests/ui/pin_project/import_unnamed.stderr create mode 100644 third_party/rust/pin-project/tests/ui/pin_project/invalid.rs create mode 100644 third_party/rust/pin-project/tests/ui/pin_project/invalid.stderr create mode 100644 third_party/rust/pin-project/tests/ui/pin_project/overlapping_unpin_struct.rs create mode 100644 third_party/rust/pin-project/tests/ui/pin_project/overlapping_unpin_struct.stderr create mode 100644 third_party/rust/pin-project/tests/ui/pin_project/override-priv-mod.rs create mode 100644 third_party/rust/pin-project/tests/ui/pin_project/override-priv-mod.stderr create mode 100644 third_party/rust/pin-project/tests/ui/pin_project/packed-enum.rs create mode 100644 third_party/rust/pin-project/tests/ui/pin_project/packed-enum.stderr create mode 100644 third_party/rust/pin-project/tests/ui/pin_project/packed-name-value.rs create mode 100644 third_party/rust/pin-project/tests/ui/pin_project/packed-name-value.stderr create mode 100644 third_party/rust/pin-project/tests/ui/pin_project/packed.rs create mode 100644 third_party/rust/pin-project/tests/ui/pin_project/packed.stderr create mode 100644 third_party/rust/pin-project/tests/ui/pin_project/packed_sneaky-1.rs create mode 100644 third_party/rust/pin-project/tests/ui/pin_project/packed_sneaky-1.stderr create mode 100644 third_party/rust/pin-project/tests/ui/pin_project/packed_sneaky-2.rs create mode 100644 third_party/rust/pin-project/tests/ui/pin_project/packed_sneaky-2.stderr create mode 100644 third_party/rust/pin-project/tests/ui/pin_project/packed_sneaky-3.rs create mode 100644 third_party/rust/pin-project/tests/ui/pin_project/packed_sneaky-3.stderr create mode 100644 third_party/rust/pin-project/tests/ui/pin_project/packed_sneaky-4.rs create mode 100644 third_party/rust/pin-project/tests/ui/pin_project/packed_sneaky-4.stderr create mode 100644 third_party/rust/pin-project/tests/ui/pin_project/private_in_public-enum.rs create mode 100644 third_party/rust/pin-project/tests/ui/pin_project/private_in_public-enum.stderr create mode 100644 third_party/rust/pin-project/tests/ui/pin_project/project_replace_unsized.rs create mode 100644 third_party/rust/pin-project/tests/ui/pin_project/project_replace_unsized.stderr create mode 100644 third_party/rust/pin-project/tests/ui/pin_project/project_replace_unsized_fn_params.rs create mode 100644 third_party/rust/pin-project/tests/ui/pin_project/project_replace_unsized_fn_params.stderr create mode 100644 third_party/rust/pin-project/tests/ui/pin_project/remove-attr-from-field.rs create mode 100644 third_party/rust/pin-project/tests/ui/pin_project/remove-attr-from-field.stderr create mode 100644 third_party/rust/pin-project/tests/ui/pin_project/remove-attr-from-struct.rs create mode 100644 third_party/rust/pin-project/tests/ui/pin_project/remove-attr-from-struct.stderr create mode 100644 third_party/rust/pin-project/tests/ui/pin_project/safe_packed_borrows.rs create mode 100644 third_party/rust/pin-project/tests/ui/pin_project/safe_packed_borrows.stderr create mode 100644 third_party/rust/pin-project/tests/ui/pin_project/unaligned_references.rs create mode 100644 third_party/rust/pin-project/tests/ui/pin_project/unaligned_references.stderr create mode 100644 third_party/rust/pin-project/tests/ui/pin_project/unpin_sneaky.rs create mode 100644 third_party/rust/pin-project/tests/ui/pin_project/unpin_sneaky.stderr create mode 100644 third_party/rust/pin-project/tests/ui/pin_project/visibility.rs create mode 100644 third_party/rust/pin-project/tests/ui/pin_project/visibility.stderr create mode 100644 third_party/rust/pin-project/tests/ui/pinned_drop/call-drop-inner.rs create mode 100644 third_party/rust/pin-project/tests/ui/pinned_drop/call-drop-inner.stderr create mode 100644 third_party/rust/pin-project/tests/ui/pinned_drop/conditional-drop-impl.rs create mode 100644 third_party/rust/pin-project/tests/ui/pinned_drop/conditional-drop-impl.stderr create mode 100644 third_party/rust/pin-project/tests/ui/pinned_drop/forget-pinned-drop-impl.rs create mode 100644 third_party/rust/pin-project/tests/ui/pinned_drop/forget-pinned-drop-impl.stderr create mode 100644 third_party/rust/pin-project/tests/ui/pinned_drop/invalid-self.rs create mode 100644 third_party/rust/pin-project/tests/ui/pinned_drop/invalid-self.stderr create mode 100644 third_party/rust/pin-project/tests/ui/pinned_drop/invalid.rs create mode 100644 third_party/rust/pin-project/tests/ui/pinned_drop/invalid.stderr create mode 100644 third_party/rust/pin-project/tests/ui/pinned_drop/pinned-drop-no-attr-arg.rs create mode 100644 third_party/rust/pin-project/tests/ui/pinned_drop/pinned-drop-no-attr-arg.stderr create mode 100644 third_party/rust/pin-project/tests/ui/pinned_drop/self.rs create mode 100644 third_party/rust/pin-project/tests/ui/pinned_drop/self.stderr create mode 100644 third_party/rust/pin-project/tests/ui/pinned_drop/unsafe-call.rs create mode 100644 third_party/rust/pin-project/tests/ui/pinned_drop/unsafe-call.stderr create mode 100644 third_party/rust/pin-project/tests/ui/unsafe_unpin/conflict-unpin.rs create mode 100644 third_party/rust/pin-project/tests/ui/unsafe_unpin/conflict-unpin.stderr create mode 100644 third_party/rust/pin-project/tests/ui/unstable-features/README.md create mode 100644 third_party/rust/pin-project/tests/ui/unstable-features/marker_trait_attr-feature-gate.rs create mode 100644 third_party/rust/pin-project/tests/ui/unstable-features/marker_trait_attr-feature-gate.stderr create mode 100644 third_party/rust/pin-project/tests/ui/unstable-features/marker_trait_attr.rs create mode 100644 third_party/rust/pin-project/tests/ui/unstable-features/marker_trait_attr.stderr create mode 100644 third_party/rust/pin-project/tests/ui/unstable-features/negative_impls.rs create mode 100644 third_party/rust/pin-project/tests/ui/unstable-features/negative_impls.stderr create mode 100644 third_party/rust/pin-project/tests/ui/unstable-features/overlapping_marker_traits-feature-gate.rs create mode 100644 third_party/rust/pin-project/tests/ui/unstable-features/overlapping_marker_traits-feature-gate.stderr create mode 100644 third_party/rust/pin-project/tests/ui/unstable-features/overlapping_marker_traits.rs create mode 100644 third_party/rust/pin-project/tests/ui/unstable-features/overlapping_marker_traits.stderr create mode 100644 third_party/rust/pin-project/tests/ui/unstable-features/trivial_bounds-feature-gate.rs create mode 100644 third_party/rust/pin-project/tests/ui/unstable-features/trivial_bounds-feature-gate.stderr create mode 100644 third_party/rust/pin-project/tests/ui/unstable-features/trivial_bounds.rs create mode 100644 third_party/rust/pin-project/tests/ui/unstable-features/trivial_bounds.stderr create mode 100644 third_party/rust/pin-project/tests/unsafe_unpin.rs (limited to 'third_party/rust/pin-project/tests') 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 { + #[cfg_attr(not(any()), pin)] + inner: T, + } + + assert_unpin!(Foo<()>); + assert_not_unpin!(Foo); + + 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); + +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 { + 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: '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: '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 Enum { + #[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, + _pin_project::__private::PhantomData, + ), + >, + __field0: T, + __field1: T, + } + impl<'pin, T, U> _pin_project::__private::Unpin for Enum + where + __Enum<'pin, T, U>: _pin_project::__private::Unpin, + {} + #[doc(hidden)] + unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Enum + where + __Enum<'pin, T, U>: _pin_project::__private::Unpin, + {} + trait EnumMustNotImplDrop {} + #[allow(clippy::drop_bounds, drop_bounds)] + impl EnumMustNotImplDrop for T {} + impl EnumMustNotImplDrop for Enum {} + #[doc(hidden)] + impl _pin_project::__private::PinnedDrop for Enum { + 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 { + 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 { + #[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: '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: 'pin, + { + pinned: ::pin_project::__private::Pin<&'pin (T)>, + unpinned: &'pin (U), + } + impl Struct { + #[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(this: &Struct) { + 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, + _pin_project::__private::PhantomData, + ), + >, + __field0: T, + } + impl<'pin, T, U> _pin_project::__private::Unpin for Struct + where + __Struct<'pin, T, U>: _pin_project::__private::Unpin, + {} + #[doc(hidden)] + unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Struct + where + __Struct<'pin, T, U>: _pin_project::__private::Unpin, + {} + trait StructMustNotImplDrop {} + #[allow(clippy::drop_bounds, drop_bounds)] + impl StructMustNotImplDrop for T {} + impl StructMustNotImplDrop for Struct {} + #[doc(hidden)] + impl _pin_project::__private::PinnedDrop for Struct { + 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 { + #[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(#[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: 'pin; + #[allow(dead_code)] + #[allow(clippy::ref_option_ref)] + struct __TupleStructProjectionRef<'pin, T, U>( + ::pin_project::__private::Pin<&'pin (T)>, + &'pin (U), + ) + where + TupleStruct: 'pin; + impl TupleStruct { + #[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(this: &TupleStruct) { + 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, + _pin_project::__private::PhantomData, + ), + >, + __field0: T, + } + impl<'pin, T, U> _pin_project::__private::Unpin for TupleStruct + where + __TupleStruct<'pin, T, U>: _pin_project::__private::Unpin, + {} + #[doc(hidden)] + unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for TupleStruct + where + __TupleStruct<'pin, T, U>: _pin_project::__private::Unpin, + {} + trait TupleStructMustNotImplDrop {} + #[allow(clippy::drop_bounds, drop_bounds)] + impl TupleStructMustNotImplDrop for T {} + impl TupleStructMustNotImplDrop for TupleStruct {} + #[doc(hidden)] + impl _pin_project::__private::PinnedDrop for TupleStruct { + 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(#[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 { + 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: '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: '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 { + Struct { + pinned1: ::pin_project::__private::PhantomData, + pinned2: ::pin_project::__private::PhantomData, + unpinned1: U, + unpinned2: U, + }, + Tuple( + ::pin_project::__private::PhantomData, + ::pin_project::__private::PhantomData, + 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 Enum { + #[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 { + 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, + _pin_project::__private::PhantomData, + ), + >, + __field0: T, + __field1: T, + __field2: T, + __field3: T, + } + impl<'pin, T, U> _pin_project::__private::Unpin for Enum + where + __Enum<'pin, T, U>: _pin_project::__private::Unpin, + {} + #[doc(hidden)] + unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Enum + where + __Enum<'pin, T, U>: _pin_project::__private::Unpin, + {} + trait EnumMustNotImplDrop {} + #[allow(clippy::drop_bounds, drop_bounds)] + impl EnumMustNotImplDrop for T {} + impl EnumMustNotImplDrop for Enum {} + #[doc(hidden)] + impl _pin_project::__private::PinnedDrop for Enum { + 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 { + 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 { + #[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: '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: '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 { + pinned1: ::pin_project::__private::PhantomData, + pinned2: ::pin_project::__private::PhantomData, + unpinned1: U, + unpinned2: U, + } + impl Struct { + #[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 { + 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(this: &Struct) { + 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, + _pin_project::__private::PhantomData, + ), + >, + __field0: T, + __field1: T, + } + impl<'pin, T, U> _pin_project::__private::Unpin for Struct + where + __Struct<'pin, T, U>: _pin_project::__private::Unpin, + {} + #[doc(hidden)] + unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Struct + where + __Struct<'pin, T, U>: _pin_project::__private::Unpin, + {} + trait StructMustNotImplDrop {} + #[allow(clippy::drop_bounds, drop_bounds)] + impl StructMustNotImplDrop for T {} + impl StructMustNotImplDrop for Struct {} + #[doc(hidden)] + impl _pin_project::__private::PinnedDrop for Struct { + 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 { + #[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(#[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: '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: 'pin; + #[allow(dead_code)] + struct __TupleStructProjectionOwned( + ::pin_project::__private::PhantomData, + ::pin_project::__private::PhantomData, + U, + U, + ); + impl TupleStruct { + #[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 { + 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(this: &TupleStruct) { + 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, + _pin_project::__private::PhantomData, + ), + >, + __field0: T, + __field1: T, + } + impl<'pin, T, U> _pin_project::__private::Unpin for TupleStruct + where + __TupleStruct<'pin, T, U>: _pin_project::__private::Unpin, + {} + #[doc(hidden)] + unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for TupleStruct + where + __TupleStruct<'pin, T, U>: _pin_project::__private::Unpin, + {} + trait TupleStructMustNotImplDrop {} + #[allow(clippy::drop_bounds, drop_bounds)] + impl TupleStructMustNotImplDrop for T {} + impl TupleStructMustNotImplDrop for TupleStruct {} + #[doc(hidden)] + impl _pin_project::__private::PinnedDrop for TupleStruct { + 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(#[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 { + 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: '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: '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 { + Struct { pinned: ::pin_project::__private::PhantomData, unpinned: U }, + Tuple(::pin_project::__private::PhantomData, 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 Enum { + #[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 { + 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, + _pin_project::__private::PhantomData, + ), + >, + __field0: T, + __field1: T, + } + impl<'pin, T, U> _pin_project::__private::Unpin for Enum + where + __Enum<'pin, T, U>: _pin_project::__private::Unpin, + {} + #[doc(hidden)] + unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Enum + where + __Enum<'pin, T, U>: _pin_project::__private::Unpin, + {} + trait EnumMustNotImplDrop {} + #[allow(clippy::drop_bounds, drop_bounds)] + impl EnumMustNotImplDrop for T {} + impl EnumMustNotImplDrop for Enum {} + #[doc(hidden)] + impl _pin_project::__private::PinnedDrop for Enum { + 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 { + 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 { + 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: '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 Enum { + #[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, + _pin_project::__private::PhantomData, + ), + >, + __field0: T, + __field1: T, + } + impl<'pin, T, U> _pin_project::__private::Unpin for Enum + where + __Enum<'pin, T, U>: _pin_project::__private::Unpin, + {} + #[doc(hidden)] + unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Enum + where + __Enum<'pin, T, U>: _pin_project::__private::Unpin, + {} + trait EnumMustNotImplDrop {} + #[allow(clippy::drop_bounds, drop_bounds)] + impl EnumMustNotImplDrop for T {} + impl EnumMustNotImplDrop for Enum {} + #[doc(hidden)] + impl _pin_project::__private::PinnedDrop for Enum { + 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 { + 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 { + 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 Enum {} + #[allow(missing_debug_implementations)] + struct __Enum<'pin, T, U> { + __pin_project_use_generics: _pin_project::__private::AlwaysUnpin< + 'pin, + ( + _pin_project::__private::PhantomData, + _pin_project::__private::PhantomData, + ), + >, + __field0: T, + __field1: T, + } + impl<'pin, T, U> _pin_project::__private::Unpin for Enum + where + __Enum<'pin, T, U>: _pin_project::__private::Unpin, + {} + #[doc(hidden)] + unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Enum + where + __Enum<'pin, T, U>: _pin_project::__private::Unpin, + {} + trait EnumMustNotImplDrop {} + #[allow(clippy::drop_bounds, drop_bounds)] + impl EnumMustNotImplDrop for T {} + impl EnumMustNotImplDrop for Enum {} + #[doc(hidden)] + impl _pin_project::__private::PinnedDrop for Enum { + 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 { + 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 { + 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 { + Struct { pinned: ::pin_project::__private::PhantomData, unpinned: U }, + Tuple(::pin_project::__private::PhantomData, 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 Enum { + #[allow(dead_code)] + fn project_replace( + self: _pin_project::__private::Pin<&mut Self>, + __replacement: Self, + ) -> ProjOwn { + 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, + _pin_project::__private::PhantomData, + ), + >, + __field0: T, + __field1: T, + } + impl<'pin, T, U> _pin_project::__private::Unpin for Enum + where + __Enum<'pin, T, U>: _pin_project::__private::Unpin, + {} + #[doc(hidden)] + unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Enum + where + __Enum<'pin, T, U>: _pin_project::__private::Unpin, + {} + trait EnumMustNotImplDrop {} + #[allow(clippy::drop_bounds, drop_bounds)] + impl EnumMustNotImplDrop for T {} + impl EnumMustNotImplDrop for Enum {} + #[doc(hidden)] + impl _pin_project::__private::PinnedDrop for Enum { + 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 { + 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 { + 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: '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 Enum { + #[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, + _pin_project::__private::PhantomData, + ), + >, + __field0: T, + __field1: T, + } + impl<'pin, T, U> _pin_project::__private::Unpin for Enum + where + __Enum<'pin, T, U>: _pin_project::__private::Unpin, + {} + #[doc(hidden)] + unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Enum + where + __Enum<'pin, T, U>: _pin_project::__private::Unpin, + {} + trait EnumMustNotImplDrop {} + #[allow(clippy::drop_bounds, drop_bounds)] + impl EnumMustNotImplDrop for T {} + impl EnumMustNotImplDrop for Enum {} + #[doc(hidden)] + impl _pin_project::__private::PinnedDrop for Enum { + 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 { + 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 { + #[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: '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: '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 { + pinned: ::pin_project::__private::PhantomData, + 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 Struct { + #[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 { + 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(this: &Struct) { + 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, + _pin_project::__private::PhantomData, + ), + >, + __field0: T, + } + impl<'pin, T, U> _pin_project::__private::Unpin for Struct + where + __Struct<'pin, T, U>: _pin_project::__private::Unpin, + {} + #[doc(hidden)] + unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Struct + where + __Struct<'pin, T, U>: _pin_project::__private::Unpin, + {} + trait StructMustNotImplDrop {} + #[allow(clippy::drop_bounds, drop_bounds)] + impl StructMustNotImplDrop for T {} + impl StructMustNotImplDrop for Struct {} + #[doc(hidden)] + impl _pin_project::__private::PinnedDrop for Struct { + 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 { + #[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 { + #[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: '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: 'pin, + { + pinned: ::pin_project::__private::Pin<&'pin (T)>, + unpinned: &'pin (U), + } + impl Struct { + #[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(this: &Struct) { + 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, + _pin_project::__private::PhantomData, + ), + >, + __field0: T, + } + impl<'pin, T, U> _pin_project::__private::Unpin for Struct + where + __Struct<'pin, T, U>: _pin_project::__private::Unpin, + {} + #[doc(hidden)] + unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Struct + where + __Struct<'pin, T, U>: _pin_project::__private::Unpin, + {} + trait StructMustNotImplDrop {} + #[allow(clippy::drop_bounds, drop_bounds)] + impl StructMustNotImplDrop for T {} + impl StructMustNotImplDrop for Struct {} + #[doc(hidden)] + impl _pin_project::__private::PinnedDrop for Struct { + 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 { + #[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 { + #[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: '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: 'pin, + { + pinned: ::pin_project::__private::Pin<&'pin (T)>, + unpinned: &'pin (U), + } + impl Struct { + #[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(this: &Struct) { + 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, + _pin_project::__private::PhantomData, + ), + >, + __field0: T, + } + impl<'pin, T, U> _pin_project::__private::Unpin for Struct + where + __Struct<'pin, T, U>: _pin_project::__private::Unpin, + {} + #[doc(hidden)] + unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Struct + where + __Struct<'pin, T, U>: _pin_project::__private::Unpin, + {} + trait StructMustNotImplDrop {} + #[allow(clippy::drop_bounds, drop_bounds)] + impl StructMustNotImplDrop for T {} + impl StructMustNotImplDrop for Struct {} + #[doc(hidden)] + impl _pin_project::__private::PinnedDrop for Struct { + 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 { + #[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 { + #[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 { + pinned: ::pin_project::__private::PhantomData, + 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: '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: 'pin, + { + pinned: ::pin_project::__private::Pin<&'pin (T)>, + unpinned: &'pin (U), + } + impl Struct { + #[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 { + 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(this: &Struct) { + 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, + _pin_project::__private::PhantomData, + ), + >, + __field0: T, + } + impl<'pin, T, U> _pin_project::__private::Unpin for Struct + where + __Struct<'pin, T, U>: _pin_project::__private::Unpin, + {} + #[doc(hidden)] + unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Struct + where + __Struct<'pin, T, U>: _pin_project::__private::Unpin, + {} + trait StructMustNotImplDrop {} + #[allow(clippy::drop_bounds, drop_bounds)] + impl StructMustNotImplDrop for T {} + impl StructMustNotImplDrop for Struct {} + #[doc(hidden)] + impl _pin_project::__private::PinnedDrop for Struct { + 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 { + #[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 { + #[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: '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: 'pin, + { + pinned: ::pin_project::__private::Pin<&'pin mut (T)>, + unpinned: &'pin mut (U), + } + impl Struct { + #[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(this: &Struct) { + 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, + _pin_project::__private::PhantomData, + ), + >, + __field0: T, + } + impl<'pin, T, U> _pin_project::__private::Unpin for Struct + where + __Struct<'pin, T, U>: _pin_project::__private::Unpin, + {} + #[doc(hidden)] + unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Struct + where + __Struct<'pin, T, U>: _pin_project::__private::Unpin, + {} + trait StructMustNotImplDrop {} + #[allow(clippy::drop_bounds, drop_bounds)] + impl StructMustNotImplDrop for T {} + impl StructMustNotImplDrop for Struct {} + #[doc(hidden)] + impl _pin_project::__private::PinnedDrop for Struct { + 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 { + #[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(#[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: '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: '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(::pin_project::__private::PhantomData, 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 TupleStruct { + #[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 { + 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(this: &TupleStruct) { + 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, + _pin_project::__private::PhantomData, + ), + >, + __field0: T, + } + impl<'pin, T, U> _pin_project::__private::Unpin for TupleStruct + where + __TupleStruct<'pin, T, U>: _pin_project::__private::Unpin, + {} + #[doc(hidden)] + unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for TupleStruct + where + __TupleStruct<'pin, T, U>: _pin_project::__private::Unpin, + {} + trait TupleStructMustNotImplDrop {} + #[allow(clippy::drop_bounds, drop_bounds)] + impl TupleStructMustNotImplDrop for T {} + impl TupleStructMustNotImplDrop for TupleStruct {} + #[doc(hidden)] + impl _pin_project::__private::PinnedDrop for TupleStruct { + 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(#[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(#[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: '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: 'pin; + impl TupleStruct { + #[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(this: &TupleStruct) { + 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, + _pin_project::__private::PhantomData, + ), + >, + __field0: T, + } + impl<'pin, T, U> _pin_project::__private::Unpin for TupleStruct + where + __TupleStruct<'pin, T, U>: _pin_project::__private::Unpin, + {} + #[doc(hidden)] + unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for TupleStruct + where + __TupleStruct<'pin, T, U>: _pin_project::__private::Unpin, + {} + trait TupleStructMustNotImplDrop {} + #[allow(clippy::drop_bounds, drop_bounds)] + impl TupleStructMustNotImplDrop for T {} + impl TupleStructMustNotImplDrop for TupleStruct {} + #[doc(hidden)] + impl _pin_project::__private::PinnedDrop for TupleStruct { + 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(#[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(#[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: 'pin; + #[allow(dead_code)] + #[allow(clippy::ref_option_ref)] + struct __TupleStructProjectionRef<'pin, T, U>( + ::pin_project::__private::Pin<&'pin (T)>, + &'pin (U), + ) + where + TupleStruct: 'pin; + impl TupleStruct { + #[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(this: &TupleStruct) { + 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, + _pin_project::__private::PhantomData, + ), + >, + __field0: T, + } + impl<'pin, T, U> _pin_project::__private::Unpin for TupleStruct + where + __TupleStruct<'pin, T, U>: _pin_project::__private::Unpin, + {} + #[doc(hidden)] + unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for TupleStruct + where + __TupleStruct<'pin, T, U>: _pin_project::__private::Unpin, + {} + trait TupleStructMustNotImplDrop {} + #[allow(clippy::drop_bounds, drop_bounds)] + impl TupleStructMustNotImplDrop for T {} + impl TupleStructMustNotImplDrop for TupleStruct {} + #[doc(hidden)] + impl _pin_project::__private::PinnedDrop for TupleStruct { + 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(#[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(#[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(::pin_project::__private::PhantomData, 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: 'pin; + #[allow(dead_code)] + #[allow(clippy::ref_option_ref)] + struct __TupleStructProjectionRef<'pin, T, U>( + ::pin_project::__private::Pin<&'pin (T)>, + &'pin (U), + ) + where + TupleStruct: 'pin; + impl TupleStruct { + #[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 { + 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(this: &TupleStruct) { + 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, + _pin_project::__private::PhantomData, + ), + >, + __field0: T, + } + impl<'pin, T, U> _pin_project::__private::Unpin for TupleStruct + where + __TupleStruct<'pin, T, U>: _pin_project::__private::Unpin, + {} + #[doc(hidden)] + unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for TupleStruct + where + __TupleStruct<'pin, T, U>: _pin_project::__private::Unpin, + {} + trait TupleStructMustNotImplDrop {} + #[allow(clippy::drop_bounds, drop_bounds)] + impl TupleStructMustNotImplDrop for T {} + impl TupleStructMustNotImplDrop for TupleStruct {} + #[doc(hidden)] + impl _pin_project::__private::PinnedDrop for TupleStruct { + 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(#[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(#[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: '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: 'pin; + impl TupleStruct { + #[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(this: &TupleStruct) { + 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, + _pin_project::__private::PhantomData, + ), + >, + __field0: T, + } + impl<'pin, T, U> _pin_project::__private::Unpin for TupleStruct + where + __TupleStruct<'pin, T, U>: _pin_project::__private::Unpin, + {} + #[doc(hidden)] + unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for TupleStruct + where + __TupleStruct<'pin, T, U>: _pin_project::__private::Unpin, + {} + trait TupleStructMustNotImplDrop {} + #[allow(clippy::drop_bounds, drop_bounds)] + impl TupleStructMustNotImplDrop for T {} + impl TupleStructMustNotImplDrop for TupleStruct {} + #[doc(hidden)] + impl _pin_project::__private::PinnedDrop for TupleStruct { + 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(#[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 { + 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: '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: '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 Enum { + #[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 + 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 + where + _pin_project::__private::Wrapper< + 'pin, + _pin_project::__private::PhantomPinned, + >: _pin_project::__private::Unpin, + {} + trait EnumMustNotImplDrop {} + #[allow(clippy::drop_bounds, drop_bounds)] + impl EnumMustNotImplDrop for T {} + impl EnumMustNotImplDrop for Enum {} + #[doc(hidden)] + impl _pin_project::__private::PinnedDrop for Enum { + 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 { + 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 { + #[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: '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: 'pin, + { + pinned: ::pin_project::__private::Pin<&'pin (T)>, + unpinned: &'pin (U), + } + impl Struct { + #[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(this: &Struct) { + let _ = &this.pinned; + let _ = &this.unpinned; + } + impl<'pin, T, U> _pin_project::__private::Unpin for Struct + 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 + where + _pin_project::__private::Wrapper< + 'pin, + _pin_project::__private::PhantomPinned, + >: _pin_project::__private::Unpin, + {} + trait StructMustNotImplDrop {} + #[allow(clippy::drop_bounds, drop_bounds)] + impl StructMustNotImplDrop for T {} + impl StructMustNotImplDrop for Struct {} + #[doc(hidden)] + impl _pin_project::__private::PinnedDrop for Struct { + 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 { + #[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(#[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: 'pin; + #[allow(dead_code)] + #[allow(clippy::ref_option_ref)] + struct __TupleStructProjectionRef<'pin, T, U>( + ::pin_project::__private::Pin<&'pin (T)>, + &'pin (U), + ) + where + TupleStruct: 'pin; + impl TupleStruct { + #[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(this: &TupleStruct) { + let _ = &this.0; + let _ = &this.1; + } + impl<'pin, T, U> _pin_project::__private::Unpin for TupleStruct + 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 + where + _pin_project::__private::Wrapper< + 'pin, + _pin_project::__private::PhantomPinned, + >: _pin_project::__private::Unpin, + {} + trait TupleStructMustNotImplDrop {} + #[allow(clippy::drop_bounds, drop_bounds)] + impl TupleStructMustNotImplDrop for T {} + impl TupleStructMustNotImplDrop for TupleStruct {} + #[doc(hidden)] + impl _pin_project::__private::PinnedDrop for TupleStruct { + 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(#[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 { + 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: '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: '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 Enum { + #[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, + _pin_project::__private::PhantomData, + ), + >, + __field0: T, + __field1: T, + } + impl<'pin, T, U> _pin_project::__private::Unpin for Enum + where + __Enum<'pin, T, U>: _pin_project::__private::Unpin, + {} + #[doc(hidden)] + unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Enum + where + __Enum<'pin, T, U>: _pin_project::__private::Unpin, + {} + impl _pin_project::__private::Drop for Enum { + 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 ::pin_project::__private::PinnedDrop for Enum { + unsafe fn drop(self: Pin<&mut Self>) { + #[allow(clippy::needless_pass_by_value)] + fn __drop_inner(__self: Pin<&mut Enum>) { + 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 { + Struct { + #[pin] + pinned: T, + unpinned: U, + }, + Tuple(#[pin] T, U), + Unit, +} + +#[pinned_drop] +impl PinnedDrop for Enum { + 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 { + #[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: '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: 'pin, + { + pinned: ::pin_project::__private::Pin<&'pin (T)>, + unpinned: &'pin (U), + } + impl Struct { + #[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(this: &Struct) { + 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, + _pin_project::__private::PhantomData, + ), + >, + __field0: T, + } + impl<'pin, T, U> _pin_project::__private::Unpin for Struct + where + __Struct<'pin, T, U>: _pin_project::__private::Unpin, + {} + #[doc(hidden)] + unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Struct + where + __Struct<'pin, T, U>: _pin_project::__private::Unpin, + {} + impl _pin_project::__private::Drop for Struct { + 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 ::pin_project::__private::PinnedDrop for Struct { + unsafe fn drop(self: Pin<&mut Self>) { + #[allow(clippy::needless_pass_by_value)] + fn __drop_inner(__self: Pin<&mut Struct>) { + 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 { + #[pin] + pinned: T, + unpinned: U, +} + +#[pinned_drop] +impl PinnedDrop for Struct { + 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(#[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: 'pin; + #[allow(dead_code)] + #[allow(clippy::ref_option_ref)] + struct __TupleStructProjectionRef<'pin, T, U>( + ::pin_project::__private::Pin<&'pin (T)>, + &'pin (U), + ) + where + TupleStruct: 'pin; + impl TupleStruct { + #[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(this: &TupleStruct) { + 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, + _pin_project::__private::PhantomData, + ), + >, + __field0: T, + } + impl<'pin, T, U> _pin_project::__private::Unpin for TupleStruct + where + __TupleStruct<'pin, T, U>: _pin_project::__private::Unpin, + {} + #[doc(hidden)] + unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for TupleStruct + where + __TupleStruct<'pin, T, U>: _pin_project::__private::Unpin, + {} + impl _pin_project::__private::Drop for TupleStruct { + 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 ::pin_project::__private::PinnedDrop for TupleStruct { + unsafe fn drop(self: Pin<&mut Self>) { + #[allow(clippy::needless_pass_by_value)] + fn __drop_inner(__self: Pin<&mut TupleStruct>) { + 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(#[pin] T, U); + +#[pinned_drop] +impl PinnedDrop for TupleStruct { + 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 { + 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 { + Struct { pinned: ::pin_project::__private::PhantomData, unpinned: U }, + Tuple(::pin_project::__private::PhantomData, 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 Enum { + #[allow(dead_code)] + fn project_replace( + self: _pin_project::__private::Pin<&mut Self>, + __replacement: Self, + ) -> EnumProjOwn { + 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, + _pin_project::__private::PhantomData, + ), + >, + __field0: T, + __field1: T, + } + impl<'pin, T, U> _pin_project::__private::Unpin for Enum + where + __Enum<'pin, T, U>: _pin_project::__private::Unpin, + {} + #[doc(hidden)] + unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Enum + where + __Enum<'pin, T, U>: _pin_project::__private::Unpin, + {} + trait EnumMustNotImplDrop {} + #[allow(clippy::drop_bounds, drop_bounds)] + impl EnumMustNotImplDrop for T {} + impl EnumMustNotImplDrop for Enum {} + #[doc(hidden)] + impl _pin_project::__private::PinnedDrop for Enum { + 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 { + 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 { + #[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: '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: 'pin, + { + pinned: ::pin_project::__private::Pin<&'pin (T)>, + unpinned: &'pin (U), + } + #[allow(dead_code)] + struct __StructProjectionOwned { + pinned: ::pin_project::__private::PhantomData, + unpinned: U, + } + impl Struct { + #[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 { + 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(this: &Struct) { + 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, + _pin_project::__private::PhantomData, + ), + >, + __field0: T, + } + impl<'pin, T, U> _pin_project::__private::Unpin for Struct + where + __Struct<'pin, T, U>: _pin_project::__private::Unpin, + {} + #[doc(hidden)] + unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Struct + where + __Struct<'pin, T, U>: _pin_project::__private::Unpin, + {} + trait StructMustNotImplDrop {} + #[allow(clippy::drop_bounds, drop_bounds)] + impl StructMustNotImplDrop for T {} + impl StructMustNotImplDrop for Struct {} + #[doc(hidden)] + impl _pin_project::__private::PinnedDrop for Struct { + 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 { + #[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(#[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: 'pin; + #[allow(dead_code)] + #[allow(clippy::ref_option_ref)] + struct __TupleStructProjectionRef<'pin, T, U>( + ::pin_project::__private::Pin<&'pin (T)>, + &'pin (U), + ) + where + TupleStruct: 'pin; + #[allow(dead_code)] + struct __TupleStructProjectionOwned( + ::pin_project::__private::PhantomData, + U, + ); + impl TupleStruct { + #[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 { + 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(this: &TupleStruct) { + 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, + _pin_project::__private::PhantomData, + ), + >, + __field0: T, + } + impl<'pin, T, U> _pin_project::__private::Unpin for TupleStruct + where + __TupleStruct<'pin, T, U>: _pin_project::__private::Unpin, + {} + #[doc(hidden)] + unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for TupleStruct + where + __TupleStruct<'pin, T, U>: _pin_project::__private::Unpin, + {} + trait TupleStructMustNotImplDrop {} + #[allow(clippy::drop_bounds, drop_bounds)] + impl TupleStructMustNotImplDrop for T {} + impl TupleStructMustNotImplDrop for TupleStruct {} + #[doc(hidden)] + impl _pin_project::__private::PinnedDrop for TupleStruct { + 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(#[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 { + 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: '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: '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 Enum { + #[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, + _pin_project::__private::PhantomData, + ), + >, + __field0: T, + __field1: T, + } + impl<'pin, T, U> _pin_project::__private::Unpin for Enum + where + __Enum<'pin, T, U>: _pin_project::__private::Unpin, + {} + #[doc(hidden)] + unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Enum + where + __Enum<'pin, T, U>: _pin_project::__private::Unpin, + {} + trait EnumMustNotImplDrop {} + #[allow(clippy::drop_bounds, drop_bounds)] + impl EnumMustNotImplDrop for T {} + impl EnumMustNotImplDrop for Enum {} + #[doc(hidden)] + impl _pin_project::__private::PinnedDrop for Enum { + 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 { + 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 { + #[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: '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: 'pin, + { + pub pinned: ::pin_project::__private::Pin<&'pin (T)>, + pub unpinned: &'pin (U), + } + impl Struct { + #[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(this: &Struct) { + 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, + _pin_project::__private::PhantomData, + ), + >, + __field0: T, + } + impl<'pin, T, U> _pin_project::__private::Unpin for Struct + where + __Struct<'pin, T, U>: _pin_project::__private::Unpin, + {} + #[doc(hidden)] + unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Struct + where + __Struct<'pin, T, U>: _pin_project::__private::Unpin, + {} + trait StructMustNotImplDrop {} + #[allow(clippy::drop_bounds, drop_bounds)] + impl StructMustNotImplDrop for T {} + impl StructMustNotImplDrop for Struct {} + #[doc(hidden)] + impl _pin_project::__private::PinnedDrop for Struct { + 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 { + #[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(#[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: '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: 'pin; + impl TupleStruct { + #[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(this: &TupleStruct) { + 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, + _pin_project::__private::PhantomData, + ), + >, + __field0: T, + } + impl<'pin, T, U> _pin_project::__private::Unpin for TupleStruct + where + __TupleStruct<'pin, T, U>: _pin_project::__private::Unpin, + {} + #[doc(hidden)] + unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for TupleStruct + where + __TupleStruct<'pin, T, U>: _pin_project::__private::Unpin, + {} + trait TupleStructMustNotImplDrop {} + #[allow(clippy::drop_bounds, drop_bounds)] + impl TupleStructMustNotImplDrop for T {} + impl TupleStructMustNotImplDrop for TupleStruct {} + #[doc(hidden)] + impl _pin_project::__private::PinnedDrop for TupleStruct { + 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(#[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 { + 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: '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: '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 Enum { + #[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 + where + _pin_project::__private::Wrapper<'pin, Self>: _pin_project::UnsafeUnpin, + {} + trait EnumMustNotImplDrop {} + #[allow(clippy::drop_bounds, drop_bounds)] + impl EnumMustNotImplDrop for T {} + impl EnumMustNotImplDrop for Enum {} + #[doc(hidden)] + impl _pin_project::__private::PinnedDrop for Enum { + unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {} + } +}; +unsafe impl UnsafeUnpin for Enum {} +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 { + Struct { + #[pin] + pinned: T, + unpinned: U, + }, + Tuple(#[pin] T, U), + Unit, +} + +unsafe impl UnsafeUnpin for Enum {} + +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 { + #[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: '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: 'pin, + { + pinned: ::pin_project::__private::Pin<&'pin (T)>, + unpinned: &'pin (U), + } + impl Struct { + #[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(this: &Struct) { + let _ = &this.pinned; + let _ = &this.unpinned; + } + impl<'pin, T, U> _pin_project::__private::Unpin for Struct + where + _pin_project::__private::Wrapper<'pin, Self>: _pin_project::UnsafeUnpin, + {} + trait StructMustNotImplDrop {} + #[allow(clippy::drop_bounds, drop_bounds)] + impl StructMustNotImplDrop for T {} + impl StructMustNotImplDrop for Struct {} + #[doc(hidden)] + impl _pin_project::__private::PinnedDrop for Struct { + unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {} + } +}; +unsafe impl UnsafeUnpin for Struct {} +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 { + #[pin] + pinned: T, + unpinned: U, +} + +unsafe impl UnsafeUnpin for Struct {} + +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(#[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: 'pin; + #[allow(dead_code)] + #[allow(clippy::ref_option_ref)] + struct __TupleStructProjectionRef<'pin, T, U>( + ::pin_project::__private::Pin<&'pin (T)>, + &'pin (U), + ) + where + TupleStruct: 'pin; + impl TupleStruct { + #[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(this: &TupleStruct) { + let _ = &this.0; + let _ = &this.1; + } + impl<'pin, T, U> _pin_project::__private::Unpin for TupleStruct + where + _pin_project::__private::Wrapper<'pin, Self>: _pin_project::UnsafeUnpin, + {} + trait TupleStructMustNotImplDrop {} + #[allow(clippy::drop_bounds, drop_bounds)] + impl TupleStructMustNotImplDrop for T {} + impl TupleStructMustNotImplDrop for TupleStruct {} + #[doc(hidden)] + impl _pin_project::__private::PinnedDrop for TupleStruct { + unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {} + } +}; +unsafe impl UnsafeUnpin for Struct {} +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(#[pin] T, U); + +unsafe impl UnsafeUnpin for Struct {} + +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 { + #[pin] + pub pinned: T, + pub unpinned: U, +} + +#[::pin_project::pin_project( + project = DefaultStructNamedProj, + project_ref = DefaultStructNamedProjRef, +)] +#[derive(Debug)] +pub struct DefaultStructNamed { + #[pin] + pub pinned: T, + pub unpinned: U, +} + +#[::pin_project::pin_project] +#[derive(Debug)] +pub struct DefaultTupleStruct(#[pin] pub T, pub U); + +#[::pin_project::pin_project( + project = DefaultTupleStructNamedProj, + project_ref = DefaultTupleStructNamedProjRef, +)] +#[derive(Debug)] +pub struct DefaultTupleStructNamed(#[pin] pub T, pub U); + +#[::pin_project::pin_project( + project = DefaultEnumProj, + project_ref = DefaultEnumProjRef, +)] +#[derive(Debug)] +pub enum DefaultEnum { + Struct { + #[pin] + pinned: T, + unpinned: U, + }, + Tuple(#[pin] T, U), + Unit, +} + +#[::pin_project::pin_project(PinnedDrop)] +#[derive(Debug)] +pub struct PinnedDropStruct { + #[pin] + pub pinned: T, + pub unpinned: U, +} + +#[::pin_project::pinned_drop] +impl PinnedDrop for PinnedDropStruct { + fn drop(self: ::pin_project::__private::Pin<&mut Self>) {} +} + +#[::pin_project::pin_project(PinnedDrop)] +#[derive(Debug)] +pub struct PinnedDropTupleStruct(#[pin] pub T, pub U); + +#[::pin_project::pinned_drop] +impl PinnedDrop for PinnedDropTupleStruct { + fn drop(self: ::pin_project::__private::Pin<&mut Self>) {} +} + +#[::pin_project::pin_project( + PinnedDrop, + project = PinnedDropEnumProj, + project_ref = PinnedDropEnumProjRef, +)] +#[derive(Debug)] +pub enum PinnedDropEnum { + Struct { + #[pin] + pinned: T, + unpinned: U, + }, + Tuple(#[pin] T, U), + Unit, +} + +#[::pin_project::pinned_drop] +impl PinnedDrop for PinnedDropEnum { + fn drop(self: ::pin_project::__private::Pin<&mut Self>) {} +} + +#[::pin_project::pin_project(project_replace)] +#[derive(Debug)] +pub struct ReplaceStruct { + #[pin] + pub pinned: T, + pub unpinned: U, +} + +#[::pin_project::pin_project( + project = ReplaceStructNamedProj, + project_ref = ReplaceStructNamedProjRef, + project_replace = ReplaceStructNamedProjOwn, +)] +#[derive(Debug)] +pub struct ReplaceStructNamed { + #[pin] + pub pinned: T, + pub unpinned: U, +} + +#[::pin_project::pin_project(project_replace)] +#[derive(Debug)] +pub struct ReplaceTupleStruct(#[pin] pub T, pub U); + +#[::pin_project::pin_project( + project = ReplaceTupleStructNamedProj, + project_ref = ReplaceTupleStructNamedProjRef, + project_replace = ReplaceTupleStructNamedProjOwn, +)] +#[derive(Debug)] +pub struct ReplaceTupleStructNamed(#[pin] pub T, pub U); + +#[::pin_project::pin_project( + project = ReplaceEnumProj, + project_ref = ReplaceEnumProjRef, + project_replace = ReplaceEnumProjOwn, +)] +#[derive(Debug)] +pub enum ReplaceEnum { + Struct { + #[pin] + pinned: T, + unpinned: U, + }, + Tuple(#[pin] T, U), + Unit, +} + +#[::pin_project::pin_project(UnsafeUnpin)] +#[derive(Debug)] +pub struct UnsafeUnpinStruct { + #[pin] + pub pinned: T, + pub unpinned: U, +} + +#[::pin_project::pin_project(UnsafeUnpin)] +#[derive(Debug)] +pub struct UnsafeUnpinTupleStruct(#[pin] pub T, pub U); + +#[::pin_project::pin_project( + UnsafeUnpin, + project = UnsafeUnpinEnumProj, + project_ref = UnsafeUnpinEnumProjRef, +)] +#[derive(Debug)] +pub enum UnsafeUnpinEnum { + Struct { + #[pin] + pinned: T, + unpinned: U, + }, + Tuple(#[pin] T, U), + Unit, +} + +#[::pin_project::pin_project(!Unpin)] +#[derive(Debug)] +pub struct NotUnpinStruct { + #[pin] + pub pinned: T, + pub unpinned: U, +} + +#[::pin_project::pin_project(!Unpin)] +#[derive(Debug)] +pub struct NotUnpinTupleStruct(#[pin] pub T, pub U); + +#[::pin_project::pin_project( + !Unpin, + project = NotUnpinEnumProj, + project_ref = NotUnpinEnumProjRef, +)] +#[derive(Debug)] +pub enum NotUnpinEnum { + 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 + ::pin_project::UnsafeUnpin for UnsafeUnpinStruct +{ +} +#[allow(clippy::undocumented_unsafe_blocks)] +unsafe impl + ::pin_project::UnsafeUnpin for UnsafeUnpinTupleStruct +{ +} +#[allow(clippy::undocumented_unsafe_blocks)] +unsafe impl + ::pin_project::UnsafeUnpin for UnsafeUnpinEnum +{ +} 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 { + #[pin] + pub pinned: T, + pub unpinned: U, + } + + #[::pin_project::pin_project( + project = DefaultStructNamedProj, + project_ref = DefaultStructNamedProjRef, + )] + #[derive(Debug)] + pub struct DefaultStructNamed { + #[pin] + pub pinned: T, + pub unpinned: U, + } + + #[::pin_project::pin_project] + #[derive(Debug)] + pub struct DefaultTupleStruct(#[pin] pub T, pub U); + + #[::pin_project::pin_project( + project = DefaultTupleStructNamedProj, + project_ref = DefaultTupleStructNamedProjRef, + )] + #[derive(Debug)] + pub struct DefaultTupleStructNamed(#[pin] pub T, pub U); + + #[::pin_project::pin_project( + project = DefaultEnumProj, + project_ref = DefaultEnumProjRef, + )] + #[derive(Debug)] + pub enum DefaultEnum { + Struct { + #[pin] + pinned: T, + unpinned: U, + }, + Tuple(#[pin] T, U), + Unit, + } + + #[::pin_project::pin_project(PinnedDrop)] + #[derive(Debug)] + pub struct PinnedDropStruct { + #[pin] + pub pinned: T, + pub unpinned: U, + } + + #[::pin_project::pinned_drop] + impl PinnedDrop for PinnedDropStruct { + fn drop(self: ::pin_project::__private::Pin<&mut Self>) {} + } + + #[::pin_project::pin_project(PinnedDrop)] + #[derive(Debug)] + pub struct PinnedDropTupleStruct(#[pin] pub T, pub U); + + #[::pin_project::pinned_drop] + impl PinnedDrop for PinnedDropTupleStruct { + fn drop(self: ::pin_project::__private::Pin<&mut Self>) {} + } + + #[::pin_project::pin_project( + PinnedDrop, + project = PinnedDropEnumProj, + project_ref = PinnedDropEnumProjRef, + )] + #[derive(Debug)] + pub enum PinnedDropEnum { + Struct { + #[pin] + pinned: T, + unpinned: U, + }, + Tuple(#[pin] T, U), + Unit, + } + + #[::pin_project::pinned_drop] + impl PinnedDrop for PinnedDropEnum { + fn drop(self: ::pin_project::__private::Pin<&mut Self>) {} + } + + #[::pin_project::pin_project(project_replace)] + #[derive(Debug)] + pub struct ReplaceStruct { + #[pin] + pub pinned: T, + pub unpinned: U, + } + + #[::pin_project::pin_project( + project = ReplaceStructNamedProj, + project_ref = ReplaceStructNamedProjRef, + project_replace = ReplaceStructNamedProjOwn, + )] + #[derive(Debug)] + pub struct ReplaceStructNamed { + #[pin] + pub pinned: T, + pub unpinned: U, + } + + #[::pin_project::pin_project(project_replace)] + #[derive(Debug)] + pub struct ReplaceTupleStruct(#[pin] pub T, pub U); + + #[::pin_project::pin_project( + project = ReplaceTupleStructNamedProj, + project_ref = ReplaceTupleStructNamedProjRef, + project_replace = ReplaceTupleStructNamedProjOwn, + )] + #[derive(Debug)] + pub struct ReplaceTupleStructNamed(#[pin] pub T, pub U); + + #[::pin_project::pin_project( + project = ReplaceEnumProj, + project_ref = ReplaceEnumProjRef, + project_replace = ReplaceEnumProjOwn, + )] + #[derive(Debug)] + pub enum ReplaceEnum { + Struct { + #[pin] + pinned: T, + unpinned: U, + }, + Tuple(#[pin] T, U), + Unit, + } + + #[::pin_project::pin_project(UnsafeUnpin)] + #[derive(Debug)] + pub struct UnsafeUnpinStruct { + #[pin] + pub pinned: T, + pub unpinned: U, + } + + #[::pin_project::pin_project(UnsafeUnpin)] + #[derive(Debug)] + pub struct UnsafeUnpinTupleStruct(#[pin] pub T, pub U); + + #[::pin_project::pin_project( + UnsafeUnpin, + project = UnsafeUnpinEnumProj, + project_ref = UnsafeUnpinEnumProjRef, + )] + #[derive(Debug)] + pub enum UnsafeUnpinEnum { + Struct { + #[pin] + pinned: T, + unpinned: U, + }, + Tuple(#[pin] T, U), + Unit, + } + + #[::pin_project::pin_project(!Unpin)] + #[derive(Debug)] + pub struct NotUnpinStruct { + #[pin] + pub pinned: T, + pub unpinned: U, + } + + #[::pin_project::pin_project(!Unpin)] + #[derive(Debug)] + pub struct NotUnpinTupleStruct(#[pin] pub T, pub U); + + #[::pin_project::pin_project( + !Unpin, + project = NotUnpinEnumProj, + project_ref = NotUnpinEnumProjRef, + )] + #[derive(Debug)] + pub enum NotUnpinEnum { + Struct { + #[pin] + pinned: T, + unpinned: U, + }, + Tuple(#[pin] T, U), + Unit, + } + + #[allow(clippy::undocumented_unsafe_blocks)] + unsafe impl + ::pin_project::UnsafeUnpin for UnsafeUnpinStruct + { + } + #[allow(clippy::undocumented_unsafe_blocks)] + unsafe impl + ::pin_project::UnsafeUnpin for UnsafeUnpinTupleStruct + { + } + #[allow(clippy::undocumented_unsafe_blocks)] + unsafe impl + ::pin_project::UnsafeUnpin for UnsafeUnpinEnum + { + } + }; + } + + 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 { + #[pin] + pub pinned: T, + pub unpinned: U, + } + + #[::pin_project::pin_project( + project = DefaultStructNamedProj, + project_ref = DefaultStructNamedProjRef, + )] + #[derive(Debug)] + pub struct DefaultStructNamed { + #[pin] + pub pinned: T, + pub unpinned: U, + } + + #[::pin_project::pin_project] + #[derive(Debug)] + pub struct DefaultTupleStruct(#[pin] pub T, pub U); + + #[::pin_project::pin_project( + project = DefaultTupleStructNamedProj, + project_ref = DefaultTupleStructNamedProjRef, + )] + #[derive(Debug)] + pub struct DefaultTupleStructNamed(#[pin] pub T, pub U); + + #[::pin_project::pin_project( + project = DefaultEnumProj, + project_ref = DefaultEnumProjRef, + )] + #[derive(Debug)] + pub enum DefaultEnum { + Struct { + #[pin] + pinned: T, + unpinned: U, + }, + Tuple(#[pin] T, U), + Unit, + } + + #[::pin_project::pin_project(PinnedDrop)] + #[derive(Debug)] + pub struct PinnedDropStruct { + #[pin] + pub pinned: T, + pub unpinned: U, + } + + #[::pin_project::pinned_drop] + impl PinnedDrop for PinnedDropStruct { + fn drop(self: ::pin_project::__private::Pin<&mut Self>) {} + } + + #[::pin_project::pin_project(PinnedDrop)] + #[derive(Debug)] + pub struct PinnedDropTupleStruct(#[pin] pub T, pub U); + + #[::pin_project::pinned_drop] + impl PinnedDrop for PinnedDropTupleStruct { + fn drop(self: ::pin_project::__private::Pin<&mut Self>) {} + } + + #[::pin_project::pin_project( + PinnedDrop, + project = PinnedDropEnumProj, + project_ref = PinnedDropEnumProjRef, + )] + #[derive(Debug)] + pub enum PinnedDropEnum { + Struct { + #[pin] + pinned: T, + unpinned: U, + }, + Tuple(#[pin] T, U), + Unit, + } + + #[::pin_project::pinned_drop] + impl PinnedDrop for PinnedDropEnum { + fn drop(self: ::pin_project::__private::Pin<&mut Self>) {} + } + + #[::pin_project::pin_project(project_replace)] + #[derive(Debug)] + pub struct ReplaceStruct { + #[pin] + pub pinned: T, + pub unpinned: U, + } + + #[::pin_project::pin_project( + project = ReplaceStructNamedProj, + project_ref = ReplaceStructNamedProjRef, + project_replace = ReplaceStructNamedProjOwn, + )] + #[derive(Debug)] + pub struct ReplaceStructNamed { + #[pin] + pub pinned: T, + pub unpinned: U, + } + + #[::pin_project::pin_project(project_replace)] + #[derive(Debug)] + pub struct ReplaceTupleStruct(#[pin] pub T, pub U); + + #[::pin_project::pin_project( + project = ReplaceTupleStructNamedProj, + project_ref = ReplaceTupleStructNamedProjRef, + project_replace = ReplaceTupleStructNamedProjOwn, + )] + #[derive(Debug)] + pub struct ReplaceTupleStructNamed(#[pin] pub T, pub U); + + #[::pin_project::pin_project( + project = ReplaceEnumProj, + project_ref = ReplaceEnumProjRef, + project_replace = ReplaceEnumProjOwn, + )] + #[derive(Debug)] + pub enum ReplaceEnum { + Struct { + #[pin] + pinned: T, + unpinned: U, + }, + Tuple(#[pin] T, U), + Unit, + } + + #[::pin_project::pin_project(UnsafeUnpin)] + #[derive(Debug)] + pub struct UnsafeUnpinStruct { + #[pin] + pub pinned: T, + pub unpinned: U, + } + + #[::pin_project::pin_project(UnsafeUnpin)] + #[derive(Debug)] + pub struct UnsafeUnpinTupleStruct(#[pin] pub T, pub U); + + #[::pin_project::pin_project( + UnsafeUnpin, + project = UnsafeUnpinEnumProj, + project_ref = UnsafeUnpinEnumProjRef, + )] + #[derive(Debug)] + pub enum UnsafeUnpinEnum { + Struct { + #[pin] + pinned: T, + unpinned: U, + }, + Tuple(#[pin] T, U), + Unit, + } + + #[::pin_project::pin_project(!Unpin)] + #[derive(Debug)] + pub struct NotUnpinStruct { + #[pin] + pub pinned: T, + pub unpinned: U, + } + + #[::pin_project::pin_project(!Unpin)] + #[derive(Debug)] + pub struct NotUnpinTupleStruct(#[pin] pub T, pub U); + + #[::pin_project::pin_project( + !Unpin, + project = NotUnpinEnumProj, + project_ref = NotUnpinEnumProjRef, + )] + #[derive(Debug)] + pub enum NotUnpinEnum { + 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, + pub u: Box, + } + + #[allow(box_pointers)] // for the type itself + #[pin_project(project_replace)] + #[derive(Debug)] + pub struct TupleStruct(#[pin] pub Box, pub Box); + + #[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, + u: Box, + }, + Tuple(#[pin] Box, Box), + 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, + pub u: Box, + } + + #[allow(box_pointers)] // for the type itself + #[pin_project(project_replace)] + #[derive(Debug)] + pub struct TupleStruct(#[pin] pub Box, pub Box); + + #[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, + u: Box, + }, + Tuple(#[pin] Box, Box), + 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 { + #[pin] + pub pinned: T, + pub unpinned: U, + } + + #[pin_project(project_replace)] + pub struct TupleStruct(#[pin] pub T, pub U); + + #[allow(dead_code)] + #[pin_project( + project = EnumProj, + project_ref = EnumProjRef, + project_replace = EnumProjOwn, + )] + pub enum Enum { + 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 { + #[pin] + pub pinned: T, + pub unpinned: U, + } + + #[pin_project(project_replace)] + pub struct TupleStruct(#[pin] pub T, pub U); + + #[allow(dead_code)] + #[pin_project( + project = EnumProj, + project_ref = EnumProjRef, + project_replace = EnumProjOwn, + )] + pub enum Enum { + 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 + where + Self: Sized, + { + #[pin] + pub pinned: T, + pub unpinned: U, + } + + #[pin_project(project_replace)] + pub struct TupleStruct(#[pin] T, U) + where + Self: Sized; + + #[pin_project( + project = EnumProj, + project_ref = EnumProjRef, + project_replace = EnumProjOwn, + )] + pub enum Enum + 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 + where + Self: Sized, + { + #[pin] + pub pinned: T, + pub unpinned: U, + } + + #[pin_project(project_replace)] + pub struct TupleStruct(#[pin] T, U) + where + Self: Sized; + + #[pin_project( + project = EnumProj, + project_ref = EnumProjRef, + project_replace = EnumProjOwn, + )] + pub enum Enum + 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> + where + Self: Trait, + { + _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> + where + Self: Trait, + { + _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 { + #[pin] + pub _pinned: T, + pub _unpinned: U, + } + + #[pin_project( + project = EnumProj, + project_ref = EnumProjRef, + project_replace = EnumProjOwn, + )] + pub enum Enum { + 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 { + #[pin] + pub _pinned: T, + pub _unpinned: U, + } + + #[pin_project( + project = EnumProj, + project_ref = EnumProjRef, + project_replace = EnumProjOwn, + )] + pub enum Enum { + 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 { + #[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 = f1; + let _: i32 = f2; + assert_eq!(f2, 2); + assert_eq!(s.f1, 3); + assert_eq!(s.f2, 4); + } + + #[pin_project(project_replace)] + struct TupleStruct(#[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 { + 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 + where + T: Copy, + { + f: T, + } + + #[pin_project] + struct TupleStruct(T) + where + T: Copy; + + #[pin_project(project = EnumProj, project_ref = EnumProjRef, project_replace = EnumProjOwn)] + enum Enum + where + T: Copy, + { + V(T), + } +} + +#[test] +fn where_clause_and_associated_type_field() { + #[pin_project(project_replace)] + struct Struct1 + where + I: Iterator, + { + #[pin] + f1: I, + f2: I::Item, + } + + #[pin_project(project_replace)] + struct Struct2 + where + I: Iterator, + { + #[pin] + f1: I, + f2: J, + } + + #[pin_project(project_replace)] + struct Struct3 + where + T: 'static, + { + f: T, + } + + trait Static: 'static {} + + impl Static for Struct3 {} + + #[pin_project(project_replace)] + struct TupleStruct(#[pin] I, I::Item) + where + I: Iterator; + + #[pin_project(project = EnumProj, project_ref = EnumProjRef, project_replace = EnumProjOwn)] + enum Enum + where + I: Iterator, + { + V1(#[pin] I), + V2(I::Item), + } +} + +#[test] +fn derive_copy() { + #[pin_project(project_replace)] + #[derive(Clone, Copy)] + struct Struct { + f: T, + } + + fn is_copy() {} + + is_copy::>(); +} + +#[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 { + f: T, + } + + trait Static: 'static {} + + impl Static for Struct7 {} + + #[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 { + #[pin] + f: T, + } + + #[pinned_drop] + impl PinnedDrop for PinnedDropWithUnsafeUnpin { + fn drop(self: Pin<&mut Self>) {} + } + + unsafe impl UnsafeUnpin for PinnedDropWithUnsafeUnpin {} + + #[pin_project(PinnedDrop, !Unpin)] + pub struct PinnedDropWithNotUnpin { + #[pin] + f: T, + } + + #[pinned_drop] + impl PinnedDrop for PinnedDropWithNotUnpin { + fn drop(self: Pin<&mut Self>) {} + } + + #[pin_project(UnsafeUnpin, project_replace)] + pub struct UnsafeUnpinWithReplace { + #[pin] + f: T, + } + + unsafe impl UnsafeUnpin for UnsafeUnpinWithReplace {} + + #[pin_project(!Unpin, project_replace)] + pub struct NotUnpinWithReplace { + #[pin] + f: T, + } +} + +#[test] +fn private_type_in_public_type() { + #[pin_project(project_replace)] + pub struct PublicStruct { + #[pin] + inner: PrivateStruct, + } + + struct PrivateStruct(T); +} + +#[allow(clippy::needless_lifetimes)] +#[test] +fn lifetime_project() { + #[pin_project(project_replace)] + struct Struct1 { + #[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 { + V { + #[pin] + pinned: T, + unpinned: U, + }, + } + + impl Struct1 { + 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 Enum { + 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 { + f: T, + } + + let mut x = Struct1 { f: 0_u8 }; + let x: Pin<&mut Struct1> = Pin::new(&mut x as _); + let _: &mut (dyn core::fmt::Debug) = x.project().f; + + #[pin_project] + struct Struct2 { + #[pin] + f: T, + } + + let mut x = Struct2 { f: 0_u8 }; + let x: Pin<&mut Struct2> = 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 + where + T: ?Sized, + { + f: T, + } + + #[allow(explicit_outlives_requirements)] // https://github.com/rust-lang/rust/issues/60993 + #[pin_project] + struct Struct4 + where + T: ?Sized, + { + #[pin] + f: T, + } + + #[pin_project(UnsafeUnpin)] + struct Struct5 { + f: T, + } + + #[pin_project(UnsafeUnpin)] + struct Struct6 { + #[pin] + f: T, + } + + #[pin_project(PinnedDrop)] + struct Struct7 { + f: T, + } + + #[pinned_drop] + impl PinnedDrop for Struct7 { + fn drop(self: Pin<&mut Self>) {} + } + + #[pin_project(PinnedDrop)] + struct Struct8 { + #[pin] + f: T, + } + + #[pinned_drop] + impl PinnedDrop for Struct8 { + fn drop(self: Pin<&mut Self>) {} + } + + #[pin_project(!Unpin)] + struct Struct9 { + f: T, + } + + #[pin_project(!Unpin)] + struct Struct10 { + #[pin] + f: T, + } + + #[pin_project] + struct Struct11<'a, T: ?Sized, U: ?Sized> { + f1: &'a mut T, + f2: U, + } + + #[pin_project] + struct TupleStruct1(T); + + #[pin_project] + struct TupleStruct2(#[pin] T); + + #[allow(explicit_outlives_requirements)] // https://github.com/rust-lang/rust/issues/60993 + #[pin_project] + struct TupleStruct3(T) + where + T: ?Sized; + + #[allow(explicit_outlives_requirements)] // https://github.com/rust-lang/rust/issues/60993 + #[pin_project] + struct TupleStruct4(#[pin] T) + where + T: ?Sized; + + #[pin_project(UnsafeUnpin)] + struct TupleStruct5(T); + + #[pin_project(UnsafeUnpin)] + struct TupleStruct6(#[pin] T); + + #[pin_project(PinnedDrop)] + struct TupleStruct7(T); + + #[pinned_drop] + impl PinnedDrop for TupleStruct7 { + fn drop(self: Pin<&mut Self>) {} + } + + #[pin_project(PinnedDrop)] + struct TupleStruct8(#[pin] T); + + #[pinned_drop] + impl PinnedDrop for TupleStruct8 { + fn drop(self: Pin<&mut Self>) {} + } + + #[pin_project(!Unpin)] + struct TupleStruct9(T); + + #[pin_project(!Unpin)] + struct TupleStruct10(#[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> + where + Self: Trait, + ::Assoc: Sized, + mac!(Self): Trait, + { + _f: T, + } + + impl> Trait for Generics { + type Assoc = Self; + } + + #[pin_project(project_replace)] + pub struct Struct { + _f1: Box, + _f2: Box<::Assoc>, + _f3: Box, + _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, + Box<::Assoc>, + Box, + [(); 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, + _f2: Box<::Assoc>, + _f3: Box, + _f4: [(); Self::ASSOC], + _f5: [(); Self::assoc()], + _f6: [(); mac!(Self::assoc())], + }, + Tuple( + Box, + Box<::Assoc>, + Box, + [(); 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 { + type Y; + } + + struct Struct1(A); + + impl Trait for Struct1 { + type Y = Option; + } + + #[pin_project(project_replace)] + struct Struct2 { + _f: as Trait>::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 { + #[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); + + 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 Trait for S {} + + #[pinned_drop] + impl PinnedDrop for S { + 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()); + ::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 + where + mac!(Self): Send, + { + _f: T, + } + + impl Struct { + const ASSOC1: usize = 1; + fn assoc1() {} + } + + trait Trait { + type Assoc2; + const ASSOC2: usize; + fn assoc2(); + } + + impl Trait for Struct { + type Assoc2 = u8; + const ASSOC2: usize = 2; + fn assoc2() {} + } + + #[pinned_drop] + impl PinnedDrop for Struct + where + mac!(Self): Send, + { + #[allow(path_statements)] + #[allow(clippy::no_effect)] + fn drop(self: Pin<&mut Self>) { + // inherent items + mac!(Self::ASSOC1;); + mac!(::ASSOC1;); + mac!(Self::assoc1();); + mac!(::assoc1();); + + // trait items + mac!(let _: ::Assoc2;); + mac!(Self::ASSOC2;); + mac!(::ASSOC2;); + mac!(::ASSOC2;); + mac!(Self::assoc2();); + mac!(::assoc2();); + mac!(::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); + + fn f() {} + + #[pinned_drop] + impl PinnedDrop for self::S { + fn drop(mut self: Pin<&mut Self>) { + self::f(); + let _: self::S<()> = self::S(()); + let _: self::S> = 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 { + f: T, + } + + assert_unpin!(Inner<()>); + assert_not_unpin!(Inner); + + #[pin_project] + struct Struct { + #[pin] + f1: Inner, + f2: U, + } + + assert_unpin!(Struct<(), ()>); + assert_unpin!(Struct<(), PhantomPinned>); + assert_not_unpin!(Struct); + assert_not_unpin!(Struct); + + #[pin_project(project = EnumProj, project_ref = EnumProjRef)] + enum Enum { + V1 { + #[pin] + f1: Inner, + f2: U, + }, + } + + assert_unpin!(Enum<(), ()>); + assert_unpin!(Enum<(), PhantomPinned>); + assert_not_unpin!(Enum); + assert_not_unpin!(Enum); + + #[pin_project] + struct TrivialBounds { + #[pin] + f: PhantomPinned, + } + + assert_not_unpin!(TrivialBounds); + + #[pin_project] + struct PinRef<'a, T, U> { + #[pin] + f1: &'a mut Inner, + f2: U, + } + + assert_unpin!(PinRef<'_, PhantomPinned, PhantomPinned>); +} + +pub mod cfg { + use std::marker::PhantomPinned; + + use pin_project::pin_project; + + #[pin_project] + struct Foo { + #[cfg(any())] + #[pin] + f: T, + #[cfg(not(any()))] + f: T, + } + + assert_unpin!(Foo); + + #[pin_project] + struct Bar { + #[cfg(any())] + f: T, + #[cfg(not(any()))] + #[pin] + f: T, + } + + assert_unpin!(Bar<()>); + assert_not_unpin!(Bar); +} + +pub mod cfg_attr { + use std::marker::PhantomPinned; + + use pin_project::pin_project; + + #[cfg_attr(any(), pin_project)] + struct Foo { + f: T, + } + + assert_unpin!(Foo<()>); + assert_not_unpin!(Foo); + + #[cfg_attr(not(any()), pin_project)] + struct Bar { + #[cfg_attr(not(any()), pin)] + f: T, + } + + assert_unpin!(Bar<()>); + assert_not_unpin!(Bar); +} + +// pin_project(!Unpin) +pub mod not_unpin { + use std::marker::PhantomPinned; + + use pin_project::pin_project; + + struct Inner { + f: T, + } + + #[pin_project(!Unpin)] + struct Struct { + #[pin] + inner: Inner, + other: U, + } + + assert_not_unpin!(Struct<(), ()>); + assert_not_unpin!(Struct<(), PhantomPinned>); + assert_not_unpin!(Struct); + assert_not_unpin!(Struct); + + #[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, + 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 = 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 { + 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>` 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>` 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 { + #[cfg_attr(any(), pin)] + f: T, +} + +#[cfg_attr(not(any()), pin_project)] +struct Bar { + #[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 { + #[pin] + f1: T, + f2: U, +} + +impl Unpin for Foo where T: Unpin {} + +#[pin_project(!Unpin)] //~ ERROR E0119 +struct Bar { + #[pin] + f1: T, + f2: U, +} + +impl Unpin for Bar {} + +#[pin_project(!Unpin)] //~ ERROR E0119 +struct Baz { + #[pin] + f1: T, + f2: U, +} + +impl Unpin for Baz {} + +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 Unpin for Foo 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 Unpin for Bar {} + | ------------------------------ 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 Unpin for Baz {} + | -------------------------------------------- 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 { + #[pin] + f1: T, + f2: U, +} + +unsafe impl UnsafeUnpin for Foo where T: Unpin {} + +#[pin_project(!Unpin)] //~ ERROR E0119 +struct Bar { + #[pin] + f1: T, + f2: U, +} + +unsafe impl UnsafeUnpin for Bar {} + +#[pin_project(!Unpin)] //~ ERROR E0119 +struct Baz { + #[pin] + f1: T, + f2: U, +} + +unsafe impl UnsafeUnpin for Baz {} + +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 UnsafeUnpin for Foo 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 UnsafeUnpin for Bar {} + | ------------------------------------------- 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 UnsafeUnpin for Baz {} + | --------------------------------------------------------- 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() {} + +#[pin_project] +#[add_pinned_field] +struct Foo { + #[pin] + f: u32, +} + +#[add_pinned_field] +#[pin_project] +struct Bar { + #[pin] + f: u32, +} + +fn main() { + is_unpin::(); //~ ERROR E0277 + is_unpin::(); //~ 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::(); //~ 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() {} + | ^^^^^ 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::(); //~ 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() {} + | ^^^^^ 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 { + #[pin] + f1: T, + f2: U, +} + +impl Drop for Foo { + fn drop(&mut self) {} +} + +#[pin_project(PinnedDrop)] //~ ERROR E0119 +struct Bar { + #[pin] + f1: T, + f2: U, +} + +#[pinned_drop] +impl PinnedDrop for Bar { + fn drop(self: Pin<&mut Self>) {} +} + +impl Drop for Bar { + 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 Drop for Bar { + | ----------------------------- 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 { + #[pin] + f1: T, + f2: U, +} + +// conflicting implementations +impl Unpin for Foo where T: Unpin {} // Conditional Unpin impl + +// The implementation that under different conditions. + +#[pin_project] //~ ERROR E0119 +struct Bar { + #[pin] + f1: T, + f2: U, +} + +// conflicting implementations +impl Unpin for Bar {} // Non-conditional Unpin impl + +#[pin_project] //~ ERROR E0119 +struct Baz { + #[pin] + f1: T, + f2: U, +} + +// conflicting implementations +impl Unpin for Baz {} // 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 Unpin for Foo 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 Unpin for Bar {} // 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 Unpin for Baz {} // 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 { + #[pin] + f1: T, + f2: U, +} + +unsafe impl UnsafeUnpin for Foo where T: Unpin {} + +#[pin_project] //~ ERROR E0119 +struct Bar { + #[pin] + f1: T, + f2: U, +} + +unsafe impl UnsafeUnpin for Bar {} + +#[pin_project] //~ ERROR E0119 +struct Baz { + #[pin] + f1: T, + f2: U, +} + +unsafe impl UnsafeUnpin for Baz {} + +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 UnsafeUnpin for Foo 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 UnsafeUnpin for Bar {} + | ------------------------------------------- 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 UnsafeUnpin for Baz {} + | --------------------------------------------------------- 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 = `, found `project` + struct Project1(#[pin] ()); + + #[pin_project(project = )] //~ ERROR expected `project = `, found `project =` + struct Project2(#[pin] ()); + + #[pin_project(project = !)] //~ ERROR expected identifier + struct Project3(#[pin] ()); + + #[pin_project(project_ref)] //~ ERROR expected `project_ref = `, found `project_ref` + struct ProjectRef1(#[pin] ()); + + #[pin_project(project_ref = )] //~ ERROR expected `project_ref = `, 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 = `, 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 = `, found `project` + --> tests/ui/pin_project/invalid.rs:163:19 + | +163 | #[pin_project(project)] //~ ERROR expected `project = `, found `project` + | ^^^^^^^ + +error: expected `project = `, found `project =` + --> tests/ui/pin_project/invalid.rs:166:19 + | +166 | #[pin_project(project = )] //~ ERROR expected `project = `, found `project =` + | ^^^^^^^^^ + +error: expected identifier + --> tests/ui/pin_project/invalid.rs:169:29 + | +169 | #[pin_project(project = !)] //~ ERROR expected identifier + | ^ + +error: expected `project_ref = `, found `project_ref` + --> tests/ui/pin_project/invalid.rs:172:19 + | +172 | #[pin_project(project_ref)] //~ ERROR expected `project_ref = `, found `project_ref` + | ^^^^^^^^^^^ + +error: expected `project_ref = `, found `project_ref =` + --> tests/ui/pin_project/invalid.rs:175:19 + | +175 | #[pin_project(project_ref = )] //~ ERROR expected `project_ref = `, 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 = `, found `project_replace =` + --> tests/ui/pin_project/invalid.rs:184:19 + | +184 | #[pin_project(project_replace = )] //~ ERROR expected `project_replace = `, 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 { + #[pin] + f: T, +} + +struct __S {} + +impl Unpin for __S {} + +fn is_unpin() {} + +fn main() { + is_unpin::>(); //~ 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::>(); //~ 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 { + | ^ +note: required for `S` 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 { + | ^^^^ +note: required by a bound in `is_unpin` + --> tests/ui/pin_project/overlapping_unpin_struct.rs:15:16 + | +15 | fn is_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 { + f: T, +} + +#[pin_project(project_replace)] //~ ERROR E0277 +struct TupleStruct(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 { + | - this type parameter needs to be `std::marker::Sized` + | +note: required because it appears within the type `Struct` + --> tests/ui/pin_project/project_replace_unsized.rs:4:8 + | +4 | struct Struct { + | ^^^^^^ + = 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 { +4 + struct Struct { + | +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 { + | - this type parameter needs to be `std::marker::Sized` + | +note: required because it appears within the type `Struct` + --> tests/ui/pin_project/project_replace_unsized.rs:4:8 + | +4 | struct Struct { + | ^^^^^^ +note: required by a bound in `UnsafeOverwriteGuard::::new` + --> src/lib.rs + | + | impl UnsafeOverwriteGuard { + | ^ required by this bound in `UnsafeOverwriteGuard::::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 { +4 + struct Struct { + | + +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 { + | - 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(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 { +4 + struct Struct { + | + +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); + | - this type parameter needs to be `std::marker::Sized` + | +note: required because it appears within the type `TupleStruct` + --> tests/ui/pin_project/project_replace_unsized.rs:9:8 + | +9 | struct TupleStruct(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); +9 + struct TupleStruct(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); + | - this type parameter needs to be `std::marker::Sized` + | +note: required because it appears within the type `TupleStruct` + --> tests/ui/pin_project/project_replace_unsized.rs:9:8 + | +9 | struct TupleStruct(T); + | ^^^^^^^^^^^ +note: required by a bound in `UnsafeOverwriteGuard::::new` + --> src/lib.rs + | + | impl UnsafeOverwriteGuard { + | ^ required by this bound in `UnsafeOverwriteGuard::::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); +9 + struct TupleStruct(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 { + f: T, +} + +#[pin_project(project_replace)] //~ ERROR E0277 +struct TupleStruct(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 { + | ^^^^^^^-^^^^^^^^^ + | | | + | | 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` + --> tests/ui/pin_project/project_replace_unsized_fn_params.rs:6:8 + | +6 | struct Struct { + | ^^^^^^ + = 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 { +6 + struct Struct { + | + +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 { + | - this type parameter needs to be `std::marker::Sized` + | +note: required because it appears within the type `Struct` + --> tests/ui/pin_project/project_replace_unsized_fn_params.rs:6:8 + | +6 | struct Struct { + | ^^^^^^ +note: required by a bound in `UnsafeOverwriteGuard::::new` + --> src/lib.rs + | + | impl UnsafeOverwriteGuard { + | ^ required by this bound in `UnsafeOverwriteGuard::::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 { +6 + struct Struct { + | + +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 { + | - 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(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 { +6 + struct Struct { + | + +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); + | ^^^^^^^^^^^^-^^^^^^^^^ + | | | + | | 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` + --> tests/ui/pin_project/project_replace_unsized_fn_params.rs:11:8 + | +11 | struct TupleStruct(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); +11 + struct TupleStruct(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); + | - this type parameter needs to be `std::marker::Sized` + | +note: required because it appears within the type `TupleStruct` + --> tests/ui/pin_project/project_replace_unsized_fn_params.rs:11:8 + | +11 | struct TupleStruct(T); + | ^^^^^^^^^^^ +note: required by a bound in `UnsafeOverwriteGuard::::new` + --> src/lib.rs + | + | impl UnsafeOverwriteGuard { + | ^ required by this bound in `UnsafeOverwriteGuard::::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); +11 + struct TupleStruct(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() {} + +#[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::(); + is_unpin::(); + + 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() {} + +#[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::(); //~ ERROR E0277 + is_unpin::(); //~ ERROR E0277 + is_unpin::(); // 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::(); //~ 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() {} + | ^^^^^ 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::(); //~ 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() {} + | ^^^^^ 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::

::new` + --> $RUST/core/src/pin.rs + | + | impl> Pin

{ + | ^^^^^ required by this bound in `Pin::

::new` +... + | pub const fn new(pointer: P) -> Pin

{ + | --- 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::

::new` + --> $RUST/core/src/pin.rs + | + | impl> Pin

{ + | ^^^^^ required by this bound in `Pin::

::new` +... + | pub const fn new(pointer: P) -> Pin

{ + | --- 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 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 { + f: T, +} + +impl Drop for DropImpl { + //~^ ERROR E0367 + fn drop(&mut self) {} +} + +#[pin_project(PinnedDrop)] //~ ERROR E0277 +struct PinnedDropImpl { + #[pin] + f: T, +} + +#[pinned_drop] +impl PinnedDrop for PinnedDropImpl { + 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 Drop for DropImpl { + | ^^^^^ + | +note: the implementor must specify the same requirement + --> tests/ui/pinned_drop/conditional-drop-impl.rs:7:1 + | +7 | struct DropImpl { + | ^^^^^^^^^^^^^^^^^^ + +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` to implement `PinnedDrop` + --> tests/ui/pinned_drop/conditional-drop-impl.rs:23:16 + | +23 | impl PinnedDrop for PinnedDropImpl { + | ----- ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ + | | + | unsatisfied trait bound introduced here +help: consider restricting type parameter `T` + | +17 | struct PinnedDropImpl { + | ++++++++++++++++++++ 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 { + #[pin] + f1: T, + f2: U, +} + +impl Unpin for Foo where T: Unpin {} + +#[pin_project(UnsafeUnpin)] //~ ERROR E0119 +struct Bar { + #[pin] + f1: T, + f2: U, +} + +impl Unpin for Bar {} + +#[pin_project(UnsafeUnpin)] //~ ERROR E0119 +struct Baz { + #[pin] + f1: T, + f2: U, +} + +impl Unpin for Baz {} + +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 Unpin for Foo 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 Unpin for Bar {} + | ------------------------------ 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 Unpin for Baz {} + | -------------------------------------------- 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 { + #[pin] + f: T, +} + +// unsound Unpin impl +impl Unpin for Struct {} + +fn is_unpin() {} + +fn main() { + is_unpin::>() +} 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 Unpin for Struct {} + | --------------------------- 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 { + #[pin] + f: T, +} + +// unsound Unpin impl +impl Unpin for Struct {} + +fn is_unpin() {} + +fn main() { + is_unpin::>() +} 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 Unpin for Struct {} + | --------------------------- 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 { + #[pin] + pinned: Pinned, + + unpinned: Unpinned, +} + +struct MyPhantomPinned {} +impl !Unpin for MyPhantomPinned {} +impl Unpin for Foo {} + +fn is_unpin() {} + +fn main() { + is_unpin::>() +} 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 {} + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = warning: this will change its meaning in a future release! + = note: for more information, see issue #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 { + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +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 { + #[pin] + f: T, +} + +// unsound Unpin impl +impl Unpin for Struct {} + +fn is_unpin() {} + +fn main() { + is_unpin::>() +} 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 Unpin for Struct {} + | --------------------------- 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 { + #[pin] + f: T, +} + +// unsound Unpin impl +impl Unpin for Struct {} + +fn is_unpin() {} + +fn main() { + is_unpin::>() +} 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 Unpin for Struct {} + | --------------------------- 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); + + impl Unpin for Wrapper where T: Unpin {} + + struct B(PhantomPinned); + + impl Unpin for B where Wrapper: Unpin {} //~ ERROR E0277 + + struct WrapperWithLifetime<'a, T>(PhantomData<&'a ()>, T); + + impl 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); + + impl Unpin for Wrapper where T: Unpin {} + + struct B(Inner); + + impl Unpin for B where Wrapper: Unpin {} //~ ERROR E0277 + + struct WrapperWithLifetime<'a, T>(PhantomData<&'a ()>, T); + + impl 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: 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` to implement `Unpin` + --> tests/ui/unstable-features/trivial_bounds-feature-gate.rs:12:13 + | +12 | impl Unpin for Wrapper 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: 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` to implement `Unpin` + --> tests/ui/unstable-features/trivial_bounds-feature-gate.rs:38:13 + | +38 | impl Unpin for Wrapper 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); + + impl Unpin for Wrapper where T: Unpin {} + + struct C(Inner); + + impl Unpin for C where Wrapper: Unpin {} //~ ERROR Unpin does not depend on any type or lifetime parameters + + struct WrapperWithLifetime<'a, T>(PhantomData<&'a ()>, T); + + impl 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: 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: 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 { + f1: U, + #[pin] + f2: T, +} + +unsafe impl UnsafeUnpin for Blah {} + +assert_unpin!(Blah<(), ()>); +assert_unpin!(Blah<(), PhantomPinned>); +assert_not_unpin!(Blah); +assert_not_unpin!(Blah); + +#[pin_project(UnsafeUnpin)] +struct OverlappingLifetimeNames<'pin, T, U> { + #[pin] + f1: U, + #[pin] + f2: Option, + f3: &'pin (), +} + +unsafe impl 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); +} -- cgit v1.2.3