Import 'pin-project' package version 0.4.16 am: 6f3e9271b1 am: 0d926734e2 am: c74636f6b4
Change-Id: I0c3e94e081ebe31577ff3f1ed53c0426a18e8f20
diff --git a/.editorconfig b/.editorconfig
new file mode 100644
index 0000000..c93ffc7
--- /dev/null
+++ b/.editorconfig
@@ -0,0 +1,16 @@
+# EditorConfig configuration
+# https://editorconfig.org
+
+# Top-most EditorConfig file
+root = true
+
+[*]
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true
+charset = utf-8
+indent_style = space
+indent_size = 4
+
+[*.{json,yml,md}]
+indent_size = 2
diff --git a/.gitattributes b/.gitattributes
new file mode 100644
index 0000000..45bca84
--- /dev/null
+++ b/.gitattributes
@@ -0,0 +1,4 @@
+[attr]rust text eol=lf whitespace=tab-in-indent,trailing-space,tabwidth=4
+
+* text=auto eol=lf
+*.rs rust
diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
new file mode 100644
index 0000000..2fdc28f
--- /dev/null
+++ b/.github/CODEOWNERS
@@ -0,0 +1 @@
+* @taiki-e
diff --git a/.github/bors.toml b/.github/bors.toml
new file mode 100644
index 0000000..1779788
--- /dev/null
+++ b/.github/bors.toml
@@ -0,0 +1,2 @@
+status = ["ci"]
+delete_merged_branches = true
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
new file mode 100644
index 0000000..89b20e6
--- /dev/null
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,146 @@
+name: CI
+
+on:
+ pull_request:
+ push:
+ branches:
+ - master
+ - staging
+ - trying
+ schedule:
+ - cron: '00 01 * * *'
+
+env:
+ RUSTFLAGS: -Dwarnings
+ RUST_BACKTRACE: 1
+
+defaults:
+ run:
+ shell: bash
+
+jobs:
+ test:
+ name: test
+ strategy:
+ matrix:
+ include:
+ # This is the minimum supported Rust version of this crate.
+ # When updating this, the reminder to update the minimum supported
+ # Rust version in README.md.
+ - build: 1.34.0
+ rust: 1.34.0
+ - build: 1.36.0
+ rust: 1.36.0
+ - build: 1.37.0
+ rust: 1.37.0
+ - build: stable
+ rust: stable
+ - build: beta
+ rust: beta
+ - build: nightly
+ rust: nightly
+ # pin-project itself has no platform-dependent implementation.
+ # macOS is only used to check that pin-project can interoperate
+ # correctly with `#[cfg()]`.
+ - build: macos
+ os: macos
+ rust: nightly
+ # - build: windows
+ # os: windows
+ # rust: nightly
+ runs-on: ${{ matrix.os || 'ubuntu' }}-latest
+ steps:
+ - uses: actions/checkout@master
+ - name: Install Rust
+ run: |
+ . ./ci/install-rust.sh ${{ matrix.rust }}
+ - name: Install cargo-hack
+ if: matrix.rust == 'nightly'
+ run: |
+ cargo install cargo-hack
+ - name: Install cargo-expand
+ if: matrix.rust == 'nightly' && matrix.build != 'macos'
+ run: |
+ cargo install cargo-expand
+ - name: Add targets
+ if: matrix.rust == 'nightly'
+ run: |
+ rustup target add thumbv7m-none-eabi
+ - name: cargo test (stable)
+ if: matrix.rust != 'nightly'
+ run: |
+ cargo test --all --all-features --exclude expandtest
+ - name: cargo test (nightly)
+ if: matrix.rust == 'nightly'
+ run: |
+ cargo test --all --all-features -- -Zunstable-options --include-ignored
+ - name: cargo check --target thumbv7m-none-eabi
+ if: matrix.rust == 'nightly'
+ run: |
+ cargo check --target thumbv7m-none-eabi --manifest-path tests/no-std/Cargo.toml
+ # Refs: https://github.com/rust-lang/cargo/issues/5657
+ - name: cargo check -Zminimal-versions
+ if: matrix.rust == 'nightly'
+ run: |
+ cargo update -Zminimal-versions
+ cargo hack check --all --all-features --no-dev-deps --ignore-private
+
+ style:
+ name: style
+ strategy:
+ fail-fast: false
+ matrix:
+ component:
+ - clippy
+ - rustfmt
+ - rustdoc
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@master
+ - name: Install Rust
+ run: |
+ . ./ci/install-rust.sh
+ - name: Install component
+ if: matrix.component != 'rustdoc'
+ run: |
+ . ./ci/install-component.sh ${{ matrix.component }}
+ - name: cargo clippy
+ if: matrix.component == 'clippy'
+ run: |
+ cargo clippy --all --all-features --all-targets
+ - name: cargo fmt -- --check
+ if: matrix.component == 'rustfmt'
+ run: |
+ cargo fmt --all -- --check
+ - name: cargo doc
+ if: matrix.component == 'rustdoc'
+ env:
+ # TODO: once https://github.com/rust-lang/rust/issues/70814 fixed, remove '-Aunused_braces'
+ RUSTDOCFLAGS: -Dwarnings -Aunused_braces
+ run: |
+ cargo doc --no-deps --all --all-features
+
+ # Refs: https://github.com/rust-lang/crater/blob/9ab6f9697c901c4a44025cf0a39b73ad5b37d198/.github/workflows/bors.yml#L125-L149
+ #
+ # ALL THE PREVIOUS JOBS NEEDS TO BE ADDED TO THE `needs` SECTION OF THIS JOB!
+
+ ci-success:
+ name: ci
+ if: github.event_name == 'push' && success()
+ needs:
+ - style
+ - test
+ runs-on: ubuntu-latest
+ steps:
+ - name: Mark the job as a success
+ run: exit 0
+ ci-failure:
+ name: ci
+ if: github.event_name == 'push' && !success()
+ needs:
+ - style
+ - test
+ runs-on: ubuntu-latest
+ steps:
+ - name: Mark the job as a failure
+ run: exit 1
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..214d7a8
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,6 @@
+target
+Cargo.lock
+
+# For platform and editor specific settings, it is recommended to add to
+# a global .gitignore file.
+# Refs: https://help.github.com/en/articles/ignoring-files#create-a-global-gitignore
diff --git a/.rustfmt.toml b/.rustfmt.toml
new file mode 100644
index 0000000..dc49733
--- /dev/null
+++ b/.rustfmt.toml
@@ -0,0 +1,19 @@
+# Rustfmt configuration
+# https://github.com/rust-lang/rustfmt/blob/master/Configurations.md
+
+# This is required for bug-fixes, which technically can't be made to the stable
+# first version.
+version = "Two" # Tracking issue: https://github.com/rust-lang/rustfmt/issues/3383
+
+# Refs: https://internals.rust-lang.org/t/running-rustfmt-on-rust-lang-rust-and-other-rust-lang-repositories/8732/72
+use_small_heuristics = "Max"
+
+# Apply rustfmt to more places.
+merge_imports = true # Tracking issue: https://github.com/rust-lang/rustfmt/issues/3362
+format_code_in_doc_comments = true # Tracking issue: https://github.com/rust-lang/rustfmt/issues/3348
+
+# Set the default settings again to always apply the proper formatting without
+# being affected by the editor settings.
+# Refs: https://github.com/rust-lang/rls/issues/501#issuecomment-333717736
+edition = "2018"
+tab_spaces = 4
diff --git a/Android.bp b/Android.bp
new file mode 100644
index 0000000..de06908
--- /dev/null
+++ b/Android.bp
@@ -0,0 +1,18 @@
+// This file is generated by cargo2android.py.
+
+rust_library_host_rlib {
+ name: "libpin_project",
+ crate_name: "pin_project",
+ srcs: ["src/lib.rs"],
+ edition: "2018",
+ proc_macros: [
+ "libpin_project_internal",
+ ],
+}
+
+// dependent_library ["feature_list"]
+// pin-project-internal-0.4.16
+// proc-macro2-1.0.12 "default,proc-macro"
+// quote-1.0.4 "default,proc-macro"
+// syn-1.0.19 "clone-impls,default,derive,full,parsing,printing,proc-macro,quote,visit-mut"
+// unicode-xid-0.2.0 "default"
diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 0000000..28f705c
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,461 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+This project adheres to [Semantic Versioning](https://semver.org).
+
+## [Unreleased]
+
+## [0.4.16] - 2020-05-11
+
+* [Fixed an issue that users can call internal function generated by `#[pinned_drop]`.][223]
+
+[223]: https://github.com/taiki-e/pin-project/pull/223
+
+## [0.4.15] - 2020-05-10
+
+* [`#[project]` attribute can now handle all project* attributes in that scope with one wrapper attribute.][220]
+
+[220]: https://github.com/taiki-e/pin-project/pull/220
+
+## [0.4.14] - 2020-05-09
+
+* [Added `!Unpin` option to `#[pin_project]` attribute for guarantee the type is `!Unpin`.][219]
+
+ ```rust
+ use pin_project::pin_project;
+ #[pin_project(!Unpin)]
+ struct Struct<T, U> {
+ field: T,
+ }
+ ```
+
+ This is equivalent to use `#[pin]` attribute for `PhantomPinned` field.
+
+ ```rust
+ use pin_project::pin_project;
+ use std::marker::PhantomPinned;
+ #[pin_project]
+ struct Struct<T, U> {
+ field: T,
+ #[pin] // Note that using `PhantomPinned` without `#[pin]` attribute has no effect.
+ _pin: PhantomPinned,
+ }
+ ```
+
+ *[Note: This raises the minimum supported Rust version of this crate from rustc 1.33 to rustc 1.34.](https://github.com/taiki-e/pin-project/pull/219#pullrequestreview-408644187)*
+
+* [Fixed an issue where duplicate `#[project]` attributes were ignored.][218]
+
+* [Fixed compile error and warnings with HRTB.][217]
+
+* [Hide generated items from --document-private-items.][211] See [#211][211] for more details.
+
+* Improve documentation
+
+[211]: https://github.com/taiki-e/pin-project/pull/211
+[217]: https://github.com/taiki-e/pin-project/pull/217
+[218]: https://github.com/taiki-e/pin-project/pull/218
+[219]: https://github.com/taiki-e/pin-project/pull/219
+
+## [0.4.13] - 2020-05-07
+
+* [Fixed a regression in 0.4.11.][207]
+
+ Changes from [0.4.10](https://github.com/taiki-e/pin-project/releases/tag/v0.4.10) and [0.4.12](https://github.com/taiki-e/pin-project/releases/tag/v0.4.12):
+
+ * [Fixed an issue that `#[project]` on non-statement expression does not work without unstable features.][197]
+
+ * [Support overwriting the name of core crate.][199]
+
+ * Improve documentation
+
+[207]: https://github.com/taiki-e/pin-project/pull/207
+
+## [0.4.12] - 2020-05-07
+
+* A release to avoid [a regression in 0.4.11][206]. No code changes from [0.4.10](https://github.com/taiki-e/pin-project/releases/tag/v0.4.10).
+
+[206]: https://github.com/taiki-e/pin-project/issues/206
+
+## [0.4.11] - 2020-05-07 - YANKED
+
+* [Fixed an issue that `#[project]` on non-statement expression does not work without unstable features.][197]
+
+* [Support overwriting the name of core crate.][199]
+
+* Improve documentation
+
+[197]: https://github.com/taiki-e/pin-project/pull/197
+[199]: https://github.com/taiki-e/pin-project/pull/199
+
+## [0.4.10] - 2020-05-04
+
+* [Added `project_replace` method and `#[project_replace]` attribute.][194]
+ `project_replace` method is optional and can be enabled by passing the `Replace` argument to `#[pin_project]` attribute.
+ See [the documentation](https://docs.rs/pin-project/0.4/pin_project/attr.pin_project.html#project_replace) for more details.
+
+[194]: https://github.com/taiki-e/pin-project/pull/194
+
+## [0.4.9] - 2020-04-14
+
+* [Fixed lifetime inference error when associated types are used in fields.][188]
+
+* [Fixed compile error with tuple structs with `where` clauses.][186]
+
+* [`#[project]` attribute can now be used for `if let` expressions.][181]
+
+[181]: https://github.com/taiki-e/pin-project/pull/181
+[186]: https://github.com/taiki-e/pin-project/pull/186
+[188]: https://github.com/taiki-e/pin-project/pull/188
+
+## [0.4.8] - 2020-01-27
+
+* [Ensured that users cannot implement `PinnedDrop` without proper attribute argument.][180]
+
+[180]: https://github.com/taiki-e/pin-project/pull/180
+
+## [0.4.7] - 2020-01-20
+
+* [Fixed support for lifetime bounds.][176]
+
+[176]: https://github.com/taiki-e/pin-project/pull/176
+
+## [0.4.6] - 2019-11-20
+
+* [Fixed compile error when there is `Self` in the where clause.][169]
+
+[169]: https://github.com/taiki-e/pin-project/pull/169
+
+## [0.4.5] - 2019-10-21
+
+* [Fixed compile error with `dyn` types.][158]
+
+[158]: https://github.com/taiki-e/pin-project/pull/158
+
+## [0.4.4] - 2019-10-17
+
+* [Fixed an issue where `PinnedDrop` implementations can call unsafe code without an unsafe block.][149]
+
+[149]: https://github.com/taiki-e/pin-project/pull/149
+
+## [0.4.3] - 2019-10-15 - YANKED
+
+* [`#[pin_project]` can now interoperate with `#[cfg_attr()]`.][135]
+
+* [`#[pin_project]` can now interoperate with `#[cfg()]` on tuple structs and tuple variants.][135]
+
+* [Fixed support for DSTs(Dynamically Sized Types) on `#[pin_project(UnsafeUnpin)]`][120]
+
+[120]: https://github.com/taiki-e/pin-project/pull/120
+[135]: https://github.com/taiki-e/pin-project/pull/135
+
+## [0.4.2] - 2019-09-29 - YANKED
+
+* [Fixed support for DSTs(Dynamically Sized Types).][113]
+
+[113]: https://github.com/taiki-e/pin-project/pull/113
+
+## [0.4.1] - 2019-09-26 - YANKED
+
+* [Fixed an issue that caused an error when using `#[pin_project]` on a type that has `#[pin]` + `!Unpin` field with no generics or lifetime.][111]
+
+[111]: https://github.com/taiki-e/pin-project/pull/111
+
+## [0.4.0] - 2019-09-25 - YANKED
+
+* [**Pin projection has become a safe operation.**][18] In the absence of other unsafe code that you write, it is impossible to cause undefined behavior.
+
+* `#[unsafe_project]` attribute has been replaced with `#[pin_project]` attribute. ([#18][18], [#33][33])
+
+* [The `Unpin` argument has been removed - an `Unpin` impl is now generated by default.][18]
+
+* Drop impls must be specified with `#[pinned_drop]` instead of via a normal `Drop` impl. ([#18][18], [#33][33], [#86][86])
+
+* [`Unpin` impls must be specified with an impl of `UnsafeUnpin`, instead of implementing the normal `Unpin` trait.][18]
+
+* [`#[pin_project]` attribute now determines the visibility of the projection type/method is based on the original type.][96]
+
+* [`#[pin_project]` can now be used for public type with private field types.][53]
+
+* [`#[pin_project]` can now interoperate with `#[cfg()]`.][77]
+
+* [Added `project_ref` method to `#[pin_project]` types.][93]
+
+* [Added `#[project_ref]` attribute.][93]
+
+* [Removed "project_attr" feature and always enable `#[project]` attribute.][94]
+
+* [`#[project]` attribute can now be used for `impl` blocks.][46]
+
+* [`#[project]` attribute can now be used for `use` statements.][85]
+
+* [`#[project]` attribute now supports `match` expressions at the position of the initializer expression of `let` expressions.][51]
+
+Changes since the 0.4.0-beta.1 release:
+
+* [Fixed an issue that caused an error when using `#[pin_project(UnsafeUnpin)]` and not providing a manual `UnsafeUnpin` implementation on a type with no generics or lifetime.][107]
+
+[18]: https://github.com/taiki-e/pin-project/pull/18
+[33]: https://github.com/taiki-e/pin-project/pull/107
+[107]: https://github.com/taiki-e/pin-project/pull/107
+
+## [0.4.0-beta.1] - 2019-09-21
+
+* [Changed the argument type of project method back to `self: Pin<&mut Self>`.][90]
+
+* [Removed "project_attr" feature and always enable `#[project]` attribute.][94]
+
+* [Removed "renamed" feature.][100]
+
+* [`#[project]` attribute can now be used for `use` statements.][85]
+
+* [Added `project_ref` method and `#[project_ref]` attribute.][93]
+
+* [`#[pin_project]` attribute now determines the visibility of the projection type/method is based on the original type.][96]
+
+[85]: https://github.com/taiki-e/pin-project/pull/85
+[90]: https://github.com/taiki-e/pin-project/pull/90
+[93]: https://github.com/taiki-e/pin-project/pull/93
+[94]: https://github.com/taiki-e/pin-project/pull/94
+[96]: https://github.com/taiki-e/pin-project/pull/96
+[100]: https://github.com/taiki-e/pin-project/pull/100
+
+## [0.4.0-alpha.11] - 2019-09-11
+
+* [Changed #[pinned_drop] to trait implementation.][86]
+
+ ```rust
+ #[pinned_drop]
+ impl<T> PinnedDrop for Foo<'_, T> {
+ fn drop(mut self: Pin<&mut Self>) {
+ **self.project().was_dropped = true;
+ }
+ }
+ ```
+
+* Added some examples and generated code.
+
+* Improve error messages.
+
+[86]: https://github.com/taiki-e/pin-project/pull/86
+
+## [0.4.0-alpha.10] - 2019-09-07
+
+* [`#[pin_project]` can now interoperate with `#[cfg()]`.][77]
+
+* Improved documentation.
+
+[77]: https://github.com/taiki-e/pin-project/pull/77
+
+## [0.4.0-alpha.9] - 2019-09-05
+
+* [Added 'project_into' method to #[pin_project] types][69]. This can be useful when returning a pin projection from a method.
+ ```rust
+ fn get_pin_mut(self: Pin<&mut Self>) -> Pin<&mut T> {
+ self.project_into().pinned
+ }
+ ```
+
+* [Prevented UnpinStruct from appearing in the document by default.][71] See [#71][71] for more details.
+
+[69]: https://github.com/taiki-e/pin-project/pull/69
+[71]: https://github.com/taiki-e/pin-project/pull/69
+
+## [0.4.0-alpha.8] - 2019-09-03
+
+* [Improved document of generated code.][62]. Also added an option to control the document of generated code. See [#62][62] for more details.
+
+* [Improved error messages][61]
+
+[61]: https://github.com/taiki-e/pin-project/pull/61
+[62]: https://github.com/taiki-e/pin-project/pull/62
+
+## [0.4.0-alpha.7] - 2019-09-02
+
+* [Applied `#[allow(dead_code)]` to generated types.][57]
+
+[57]: https://github.com/taiki-e/pin-project/pull/57
+
+## [0.4.0-alpha.6] - 2019-09-01
+
+* [Allowed using `#[pin_project]` type with private field types][53]
+
+[53]: https://github.com/taiki-e/pin-project/pull/53
+
+## [0.4.0-alpha.5] - 2019-08-24
+
+* [`#[project]` attribute now supports `match` expressions at the position of the initializer expression of `let` expressions.][51]
+
+[51]: https://github.com/taiki-e/pin-project/pull/51
+
+## [0.4.0-alpha.4] - 2019-08-23
+
+* Avoided clippy::drop_bounds lint in generated code.
+
+## [0.4.0-alpha.3] - 2019-08-23
+
+* [Changed `project` method generated by `#[pin_project]` attribute to take an `&mut Pin<&mut Self>` argument.][47]
+
+* [`#[project]` attribute can now be used for impl blocks.][46]
+
+* [`#[pin_project]` attribute can now detect that the type used does not have its own drop implementation without actually implementing drop.][48] This removed some restrictions.
+
+[46]: https://github.com/taiki-e/pin-project/pull/46
+[47]: https://github.com/taiki-e/pin-project/pull/47
+[48]: https://github.com/taiki-e/pin-project/pull/48
+
+## [0.4.0-alpha.2] - 2019-08-13
+
+* Updated `proc-macro2`, `syn`, and `quote` to 1.0.
+
+## [0.4.0-alpha.1] - 2019-08-11
+
+* **Pin projection has become a safe operation.**
+
+* `#[unsafe_project]` has been replaced with `#[pin_project]`.
+
+* The `Unpin` argument has been removed - an `Unpin` impl is now generated by default.
+
+* Drop impls must be specified with `#[pinned_drop]` instead of via a normal `Drop` impl.
+
+* `Unpin` impls must be specified with an impl of `UnsafeUnpin`, instead of implementing the normal `Unpin` trait.
+
+* Made `#[project]` attribute disabled by default.
+
+See also [tracking issue for 0.4 release][21].
+
+[21]: https://github.com/taiki-e/pin-project/issues/21
+
+## [0.3.5] - 2019-08-14
+
+* Updated `proc-macro2`, `syn`, and `quote` to 1.0.
+
+## [0.3.4] - 2019-07-21
+
+* Improved error messages.
+
+## [0.3.3] - 2019-07-15 - YANKED
+
+* Improved error messages.
+
+## [0.3.2] - 2019-03-30
+
+* Avoided suffixes on tuple index.
+
+## [0.3.1] - 2019-03-02
+
+* Improved documentation.
+
+* Updated minimum `syn` version to 0.15.22.
+
+## [0.3.0] - 2019-02-20
+
+* Removed `unsafe_fields` attribute.
+
+* Removed `unsafe_variants` attribute.
+
+## [0.2.2] - 2019-02-20
+
+* Fixed a bug that generates incorrect code for the some structures with trait bounds on type generics.
+
+## [0.2.1] - 2019-02-20
+
+* Fixed a bug that generates incorrect code for the structures with where clause and associated type fields.
+
+## [0.2.0] - 2019-02-11
+
+* Made `unsafe_fields` optional.
+
+* Improved documentation.
+
+## [0.1.8] - 2019-02-02
+
+* Added the feature to create projected enums to `unsafe_project`.
+
+* Added `project` attribute to support pattern matching.
+
+## [0.1.7] - 2019-01-19
+
+* Fixed documentation.
+
+## [0.1.6] - 2019-01-19
+
+* `unsafe_fields` can now opt-out.
+
+* Added `unsafe_variants` attribute. This attribute is available if pin-project is built with the "unsafe_variants" feature.
+
+## [0.1.5] - 2019-01-17
+
+* Added support for tuple struct to `unsafe_project`.
+
+## [0.1.4] - 2019-01-12
+
+* Added options for automatically implementing `Unpin` to both `unsafe_project` and `unsafe_fields`.
+
+## [0.1.3] - 2019-01-11
+
+* Fixed dependencies.
+
+* Added `unsafe_fields` attribute.
+
+## [0.1.2] - 2019-01-09
+
+* Improved documentation.
+
+## [0.1.1] - 2019-01-08
+
+* Renamed from `unsafe_pin_project` to `unsafe_project`.
+
+## [0.1.0] - 2019-01-08 - YANKED
+
+Initial release
+
+[Unreleased]: https://github.com/taiki-e/pin-project/compare/v0.4.16...HEAD
+[0.4.16]: https://github.com/taiki-e/pin-project/compare/v0.4.15...v0.4.16
+[0.4.15]: https://github.com/taiki-e/pin-project/compare/v0.4.14...v0.4.15
+[0.4.14]: https://github.com/taiki-e/pin-project/compare/v0.4.13...v0.4.14
+[0.4.13]: https://github.com/taiki-e/pin-project/compare/v0.4.11...v0.4.13
+[0.4.12]: https://github.com/taiki-e/pin-project/compare/v0.4.10...v0.4.12
+[0.4.11]: https://github.com/taiki-e/pin-project/compare/v0.4.10...v0.4.11
+[0.4.10]: https://github.com/taiki-e/pin-project/compare/v0.4.9...v0.4.10
+[0.4.9]: https://github.com/taiki-e/pin-project/compare/v0.4.8...v0.4.9
+[0.4.8]: https://github.com/taiki-e/pin-project/compare/v0.4.7...v0.4.8
+[0.4.7]: https://github.com/taiki-e/pin-project/compare/v0.4.6...v0.4.7
+[0.4.6]: https://github.com/taiki-e/pin-project/compare/v0.4.5...v0.4.6
+[0.4.5]: https://github.com/taiki-e/pin-project/compare/v0.4.4...v0.4.5
+[0.4.4]: https://github.com/taiki-e/pin-project/compare/v0.4.3...v0.4.4
+[0.4.3]: https://github.com/taiki-e/pin-project/compare/v0.4.2...v0.4.3
+[0.4.2]: https://github.com/taiki-e/pin-project/compare/v0.4.1...v0.4.2
+[0.4.1]: https://github.com/taiki-e/pin-project/compare/v0.4.0...v0.4.1
+[0.4.0]: https://github.com/taiki-e/pin-project/compare/v0.4.0-beta.1...v0.4.0
+[0.4.0-beta.1]: https://github.com/taiki-e/pin-project/compare/v0.4.0-alpha.11...v0.4.0-beta.1
+[0.4.0-alpha.11]: https://github.com/taiki-e/pin-project/compare/v0.4.0-alpha.10...v0.4.0-alpha.11
+[0.4.0-alpha.10]: https://github.com/taiki-e/pin-project/compare/v0.4.0-alpha.9...v0.4.0-alpha.10
+[0.4.0-alpha.9]: https://github.com/taiki-e/pin-project/compare/v0.4.0-alpha.8...v0.4.0-alpha.9
+[0.4.0-alpha.8]: https://github.com/taiki-e/pin-project/compare/v0.4.0-alpha.7...v0.4.0-alpha.8
+[0.4.0-alpha.7]: https://github.com/taiki-e/pin-project/compare/v0.4.0-alpha.6...v0.4.0-alpha.7
+[0.4.0-alpha.6]: https://github.com/taiki-e/pin-project/compare/v0.4.0-alpha.5...v0.4.0-alpha.6
+[0.4.0-alpha.5]: https://github.com/taiki-e/pin-project/compare/v0.4.0-alpha.4...v0.4.0-alpha.5
+[0.4.0-alpha.4]: https://github.com/taiki-e/pin-project/compare/v0.4.0-alpha.3...v0.4.0-alpha.4
+[0.4.0-alpha.3]: https://github.com/taiki-e/pin-project/compare/v0.4.0-alpha.2...v0.4.0-alpha.3
+[0.4.0-alpha.2]: https://github.com/taiki-e/pin-project/compare/v0.4.0-alpha.1...v0.4.0-alpha.2
+[0.4.0-alpha.1]: https://github.com/taiki-e/pin-project/compare/v0.3.5...v0.4.0-alpha.1
+[0.3.5]: https://github.com/taiki-e/pin-project/compare/v0.3.4...v0.3.5
+[0.3.4]: https://github.com/taiki-e/pin-project/compare/v0.3.3...v0.3.4
+[0.3.3]: https://github.com/taiki-e/pin-project/compare/v0.3.2...v0.3.3
+[0.3.2]: https://github.com/taiki-e/pin-project/compare/v0.3.1...v0.3.2
+[0.3.1]: https://github.com/taiki-e/pin-project/compare/v0.3.0...v0.3.1
+[0.3.0]: https://github.com/taiki-e/pin-project/compare/v0.2.2...v0.3.0
+[0.2.2]: https://github.com/taiki-e/pin-project/compare/v0.2.1...v0.2.2
+[0.2.1]: https://github.com/taiki-e/pin-project/compare/v0.2.0...v0.2.1
+[0.2.0]: https://github.com/taiki-e/pin-project/compare/v0.1.8...v0.2.0
+[0.1.8]: https://github.com/taiki-e/pin-project/compare/v0.1.7...v0.1.8
+[0.1.7]: https://github.com/taiki-e/pin-project/compare/v0.1.6...v0.1.7
+[0.1.6]: https://github.com/taiki-e/pin-project/compare/v0.1.5...v0.1.6
+[0.1.5]: https://github.com/taiki-e/pin-project/compare/v0.1.4...v0.1.5
+[0.1.4]: https://github.com/taiki-e/pin-project/compare/v0.1.3...v0.1.4
+[0.1.3]: https://github.com/taiki-e/pin-project/compare/v0.1.2...v0.1.3
+[0.1.2]: https://github.com/taiki-e/pin-project/compare/v0.1.1...v0.1.2
+[0.1.1]: https://github.com/taiki-e/pin-project/compare/v0.1.0...v0.1.1
+[0.1.0]: https://github.com/taiki-e/pin-project/releases/tag/v0.1.0
diff --git a/Cargo.toml b/Cargo.toml
new file mode 100644
index 0000000..39280ab
--- /dev/null
+++ b/Cargo.toml
@@ -0,0 +1,30 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies
+#
+# If you believe there's an error in this file please file an
+# issue against the rust-lang/cargo repository. If you're
+# editing this file be aware that the upstream Cargo.toml
+# will likely look very different (and much more reasonable)
+
+[package]
+edition = "2018"
+name = "pin-project"
+version = "0.4.16"
+authors = ["Taiki Endo <te316e89@gmail.com>"]
+description = "A crate for safe and ergonomic pin-projection.\n"
+homepage = "https://github.com/taiki-e/pin-project"
+documentation = "https://docs.rs/pin-project"
+readme = "README.md"
+keywords = ["pin", "macros", "attribute"]
+categories = ["no-std", "rust-patterns"]
+license = "Apache-2.0 OR MIT"
+repository = "https://github.com/taiki-e/pin-project"
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+[dependencies.pin-project-internal]
+version = "=0.4.16"
+default-features = false
diff --git a/Cargo.toml.orig b/Cargo.toml.orig
new file mode 100644
index 0000000..c886996
--- /dev/null
+++ b/Cargo.toml.orig
@@ -0,0 +1,31 @@
+[package]
+name = "pin-project"
+version = "0.4.16"
+authors = ["Taiki Endo <te316e89@gmail.com>"]
+edition = "2018"
+license = "Apache-2.0 OR MIT"
+repository = "https://github.com/taiki-e/pin-project"
+homepage = "https://github.com/taiki-e/pin-project"
+documentation = "https://docs.rs/pin-project"
+keywords = ["pin", "macros", "attribute"]
+categories = ["no-std", "rust-patterns"]
+readme = "README.md"
+description = """
+A crate for safe and ergonomic pin-projection.
+"""
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[workspace]
+members = [
+ "pin-project-internal",
+ "tests/ui/auxiliary",
+ "tests/doc",
+ "tests/expand",
+ "tests/rust-2015"
+]
+
+[dependencies]
+pin-project-internal = { version = "=0.4.16", path = "pin-project-internal", default-features = false }
+
diff --git a/LICENSE b/LICENSE
new file mode 120000
index 0000000..6b579aa
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1 @@
+LICENSE-APACHE
\ No newline at end of file
diff --git a/LICENSE-APACHE b/LICENSE-APACHE
new file mode 100644
index 0000000..d645695
--- /dev/null
+++ b/LICENSE-APACHE
@@ -0,0 +1,202 @@
+
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "[]"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+ Copyright [yyyy] [name of copyright owner]
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
diff --git a/LICENSE-MIT b/LICENSE-MIT
new file mode 100644
index 0000000..31aa793
--- /dev/null
+++ b/LICENSE-MIT
@@ -0,0 +1,23 @@
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/METADATA b/METADATA
new file mode 100644
index 0000000..7c1feb9
--- /dev/null
+++ b/METADATA
@@ -0,0 +1,19 @@
+name: "pin-project"
+description: "A crate for safe and ergonomic pin-projection."
+third_party {
+ url {
+ type: HOMEPAGE
+ value: "https://crates.io/crates/pin-project"
+ }
+ url {
+ type: GIT
+ value: "https://github.com/taiki-e/pin-project"
+ }
+ version: "0.4.16"
+ license_type: NOTICE
+ last_upgrade_date {
+ year: 2020
+ month: 5
+ day: 11
+ }
+}
diff --git a/MODULE_LICENSE_APACHE2 b/MODULE_LICENSE_APACHE2
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/MODULE_LICENSE_APACHE2
diff --git a/NOTICE b/NOTICE
new file mode 120000
index 0000000..7a694c9
--- /dev/null
+++ b/NOTICE
@@ -0,0 +1 @@
+LICENSE
\ No newline at end of file
diff --git a/OWNERS b/OWNERS
new file mode 100644
index 0000000..46fc303
--- /dev/null
+++ b/OWNERS
@@ -0,0 +1 @@
+include platform/prebuilts/rust:/OWNERS
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..840d1fa
--- /dev/null
+++ b/README.md
@@ -0,0 +1,77 @@
+# pin-project
+
+[![crates-badge]][crates-url]
+[![docs-badge]][docs-url]
+[![license-badge]][license]
+[![rustc-badge]][rustc-url]
+
+[crates-badge]: https://img.shields.io/crates/v/pin-project.svg
+[crates-url]: https://crates.io/crates/pin-project
+[docs-badge]: https://docs.rs/pin-project/badge.svg
+[docs-url]: https://docs.rs/pin-project
+[license-badge]: https://img.shields.io/crates/l/pin-project.svg
+[license]: #license
+[rustc-badge]: https://img.shields.io/badge/rustc-1.34+-lightgray.svg
+[rustc-url]: https://blog.rust-lang.org/2019/04/11/Rust-1.34.0.html
+
+A crate for safe and ergonomic pin-projection.
+
+[Documentation][docs-url]
+
+[Examples](examples/README.md)
+
+## Usage
+
+Add this to your `Cargo.toml`:
+
+```toml
+[dependencies]
+pin-project = "0.4"
+```
+
+The current pin-project requires Rust 1.34 or later.
+
+## Examples
+
+[`pin_project`] attribute creates a projection struct covering all the fields.
+
+```rust
+use pin_project::pin_project;
+use std::pin::Pin;
+
+#[pin_project]
+struct Struct<T, U> {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+}
+
+impl<T, U> Struct<T, U> {
+ fn foo(self: Pin<&mut Self>) {
+ let this = self.project();
+ let _: Pin<&mut T> = this.pinned; // Pinned reference to the field
+ let _: &mut U = this.unpinned; // Normal reference to the field
+ }
+}
+```
+
+[Code like this will be generated](examples/struct-default-expanded.rs)
+
+See [API documentation][docs-url] for more details.
+
+Also, there are examples and generated code of each feature in [examples](examples/README.md) directory.
+
+[`pin_project`]: https://docs.rs/pin-project/0.4/pin_project/attr.pin_project.html
+
+## License
+
+Licensed under either of
+
+* Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or <http://www.apache.org/licenses/LICENSE-2.0>)
+* MIT license ([LICENSE-MIT](LICENSE-MIT) or <http://opensource.org/licenses/MIT>)
+
+at your option.
+
+### Contribution
+
+Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.
diff --git a/ci.sh b/ci.sh
new file mode 100644
index 0000000..df0131e
--- /dev/null
+++ b/ci.sh
@@ -0,0 +1,29 @@
+#!/bin/bash
+
+# A script to run a simplified version of the checks done by CI.
+#
+# Usage
+#
+# ```sh
+# . ./ci.sh
+# ```
+
+echo "Running 'cargo fmt -- --check'"
+cargo +nightly fmt --all -- --check
+
+echo "Running 'cargo clippy'"
+cargo +nightly clippy --all --all-features --all-targets
+
+echo "Running 'cargo test'"
+cargo +nightly test --all --all-features
+
+echo "Running 'cargo doc'"
+cargo +nightly doc --no-deps --all --all-features
+
+echo "Running 'compiletest'"
+. ./compiletest.sh
+
+echo "Running 'expandtest'"
+# See also https://docs.rs/macrotest/1/macrotest/#updating-expandedrs
+# rm **/*.expanded.rs
+cargo +nightly test --manifest-path tests/expand/Cargo.toml
diff --git a/ci/install-component.sh b/ci/install-component.sh
new file mode 100644
index 0000000..de08b8f
--- /dev/null
+++ b/ci/install-component.sh
@@ -0,0 +1,22 @@
+#!/bin/bash
+
+set -euo pipefail
+
+component="${1}"
+
+if ! rustup component add "${component}" 2>/dev/null; then
+ # If the component is unavailable on the latest nightly,
+ # use the latest toolchain with the component available.
+ # Refs: https://github.com/rust-lang/rustup-components-history#the-web-part
+ target=$(curl -sSf "https://rust-lang.github.io/rustup-components-history/x86_64-unknown-linux-gnu/${component}")
+ echo "'${component}' is unavailable on the default toolchain, use the toolchain 'nightly-${target}' instead"
+
+ . ci/install-rust.sh "nightly-${target}"
+
+ rustup component add "${component}"
+fi
+
+case "${component}" in
+ rustfmt | rustdoc) "${component}" -V ;;
+ *) cargo "${component}" -V ;;
+esac
diff --git a/ci/install-rust.sh b/ci/install-rust.sh
new file mode 100644
index 0000000..b6625b6
--- /dev/null
+++ b/ci/install-rust.sh
@@ -0,0 +1,13 @@
+#!/bin/bash
+
+set -euo pipefail
+
+toolchain="${1:-nightly}"
+
+rustup set profile minimal
+rustup update "${toolchain}" --no-self-update
+rustup default "${toolchain}"
+
+rustup -V
+rustc -V
+cargo -V
diff --git a/compiletest.sh b/compiletest.sh
new file mode 100644
index 0000000..9af5a5f
--- /dev/null
+++ b/compiletest.sh
@@ -0,0 +1,12 @@
+#!/bin/bash
+
+# A script to run compile tests with the same condition of the checks done by CI.
+#
+# Usage
+#
+# ```sh
+# . ./compiletest.sh
+# ```
+
+TRYBUILD=overwrite cargo +nightly test -p pin-project --all-features --test compiletest -- --ignored
+# cargo +nightly test -p pin-project --all-features --test compiletest -- --ignored
diff --git a/examples/README.md b/examples/README.md
new file mode 100644
index 0000000..94f49b5
--- /dev/null
+++ b/examples/README.md
@@ -0,0 +1,35 @@
+# Examples and generated code of each feature of pin-project
+
+### Basic usage of `#[pin_project]` on structs
+
+ * [example](struct-default.rs)
+ * [generated code](struct-default-expanded.rs)
+
+### Basic usage of `#[pin_project]` on enums
+
+ * [example](enum-default.rs)
+ * [generated code](enum-default-expanded.rs)
+
+### Manual implementation of `Unpin` by `UnsafeUnpin`
+
+ * [example](unsafe_unpin.rs)
+ * [generated code](unsafe_unpin-expanded.rs)
+ * [`UnsafeUnpin` documentation](https://docs.rs/pin-project/0.4/pin_project/trait.UnsafeUnpin.html)
+
+### Manual implementation of `Drop` by `#[pinned_drop]`
+
+ * [example](pinned_drop.rs)
+ * [generated code](pinned_drop-expanded.rs)
+ * [`#[pinned_drop]` documentation](https://docs.rs/pin-project/0.4/pin_project/attr.pinned_drop.html)
+
+### `project_replace()` method
+
+ * [example](project_replace.rs)
+ * [generated code](project_replace-expanded.rs)
+ * [`project_replace()` documentation](https://docs.rs/pin-project/0.4/pin_project/attr.pin_project.html#project_replace)
+
+### Ensure `!Unpin` by `#[pin_project(!Unpin)]`
+
+ * [example](not_unpin.rs)
+ * [generated code](not_unpin-expanded.rs)
+ * [`!Unpin` documentation](https://docs.rs/pin-project/0.4/pin_project/attr.pin_project.html#unpin)
diff --git a/examples/enum-default-expanded.rs b/examples/enum-default-expanded.rs
new file mode 100644
index 0000000..036c01f
--- /dev/null
+++ b/examples/enum-default-expanded.rs
@@ -0,0 +1,109 @@
+// Original code (./enum-default.rs):
+//
+// ```rust
+// #![allow(dead_code)]
+//
+// use pin_project::pin_project;
+//
+// #[pin_project]
+// enum Enum<T, U> {
+// Pinned(#[pin] T),
+// Unpinned(U),
+// }
+//
+// fn main() {}
+// ```
+
+#![allow(dead_code, unused_imports, unused_parens)]
+#![allow(clippy::no_effect, clippy::just_underscores_and_digits)]
+
+use pin_project::pin_project;
+
+enum Enum<T, U> {
+ Pinned(/* #[pin] */ T),
+ Unpinned(U),
+}
+
+#[doc(hidden)]
+#[allow(clippy::mut_mut)] // This lint warns `&mut &mut <ty>`.
+#[allow(dead_code)] // This lint warns unused fields/variants.
+#[allow(single_use_lifetimes)]
+enum __EnumProjection<'pin, T, U>
+where
+ Enum<T, U>: 'pin,
+{
+ Pinned(::pin_project::__reexport::pin::Pin<&'pin mut (T)>),
+ Unpinned(&'pin mut (U)),
+}
+#[doc(hidden)]
+#[allow(dead_code)] // This lint warns unused fields/variants.
+#[allow(single_use_lifetimes)]
+enum __EnumProjectionRef<'pin, T, U>
+where
+ Enum<T, U>: 'pin,
+{
+ Pinned(::pin_project::__reexport::pin::Pin<&'pin (T)>),
+ Unpinned(&'pin (U)),
+}
+
+#[doc(hidden)]
+#[allow(non_upper_case_globals)]
+#[allow(single_use_lifetimes)]
+const __SCOPE_Enum: () = {
+ impl<T, U> Enum<T, U> {
+ fn project<'pin>(
+ self: ::pin_project::__reexport::pin::Pin<&'pin mut Self>,
+ ) -> __EnumProjection<'pin, T, U> {
+ unsafe {
+ match self.get_unchecked_mut() {
+ Enum::Pinned(_0) => __EnumProjection::Pinned(
+ ::pin_project::__reexport::pin::Pin::new_unchecked(_0),
+ ),
+ Enum::Unpinned(_0) => __EnumProjection::Unpinned(_0),
+ }
+ }
+ }
+ fn project_ref<'pin>(
+ self: ::pin_project::__reexport::pin::Pin<&'pin Self>,
+ ) -> __EnumProjectionRef<'pin, T, U> {
+ unsafe {
+ match self.get_ref() {
+ Enum::Pinned(_0) => __EnumProjectionRef::Pinned(
+ ::pin_project::__reexport::pin::Pin::new_unchecked(_0),
+ ),
+ Enum::Unpinned(_0) => __EnumProjectionRef::Unpinned(_0),
+ }
+ }
+ }
+ }
+
+ // Automatically create the appropriate conditional `Unpin` implementation.
+ //
+ // See ./struct-default-expanded.rs and https://github.com/taiki-e/pin-project/pull/53.
+ // for details.
+ struct __Enum<'pin, T, U> {
+ __pin_project_use_generics: ::pin_project::__private::AlwaysUnpin<'pin, (T, U)>,
+ __field0: T,
+ }
+ impl<'pin, T, U> ::pin_project::__reexport::marker::Unpin for Enum<T, U> where
+ __Enum<'pin, T, U>: ::pin_project::__reexport::marker::Unpin
+ {
+ }
+ unsafe impl<T, U> ::pin_project::UnsafeUnpin for Enum<T, U> {}
+
+ // Ensure that enum does not implement `Drop`.
+ //
+ // See ./struct-default-expanded.rs for details.
+ trait EnumMustNotImplDrop {}
+ #[allow(clippy::drop_bounds)]
+ impl<T: ::pin_project::__reexport::ops::Drop> EnumMustNotImplDrop for T {}
+ impl<T, U> EnumMustNotImplDrop for Enum<T, U> {}
+ impl<T, U> ::pin_project::__private::PinnedDrop for Enum<T, U> {
+ unsafe fn drop(self: ::pin_project::__reexport::pin::Pin<&mut Self>) {}
+ }
+
+ // We don't need to check for `#[repr(packed)]`,
+ // since it does not apply to enums.
+};
+
+fn main() {}
diff --git a/examples/enum-default.rs b/examples/enum-default.rs
new file mode 100644
index 0000000..ab5a4bc
--- /dev/null
+++ b/examples/enum-default.rs
@@ -0,0 +1,13 @@
+// See ./enum-default-expanded.rs for generated code.
+
+#![allow(dead_code)]
+
+use pin_project::pin_project;
+
+#[pin_project]
+enum Enum<T, U> {
+ Pinned(#[pin] T),
+ Unpinned(U),
+}
+
+fn main() {}
diff --git a/examples/not_unpin-expanded.rs b/examples/not_unpin-expanded.rs
new file mode 100644
index 0000000..45f1321
--- /dev/null
+++ b/examples/not_unpin-expanded.rs
@@ -0,0 +1,125 @@
+// Original code (./not_unpin.rs):
+//
+// ```rust
+// #![allow(dead_code)]
+//
+// use pin_project::pin_project;
+//
+// #[pin_project(!Unpin)]
+// pub struct Struct<T, U> {
+// #[pin]
+// pinned: T,
+// unpinned: U,
+// }
+//
+// fn main() {
+// fn _is_unpin<T: Unpin>() {}
+// // _is_unpin::<Struct<(), ()>>(); //~ ERROR `std::marker::PhantomPinned` cannot be unpinned
+// }
+// ```
+
+#![allow(dead_code, unused_imports, unused_parens)]
+#![allow(clippy::no_effect)]
+
+use pin_project::pin_project;
+
+pub struct Struct<T, U> {
+ // #[pin]
+ pinned: T,
+ unpinned: U,
+}
+
+#[doc(hidden)]
+#[allow(clippy::mut_mut)] // This lint warns `&mut &mut <ty>`.
+#[allow(dead_code)] // This lint warns unused fields/variants.
+#[allow(single_use_lifetimes)]
+pub(crate) struct __StructProjection<'pin, T, U>
+where
+ Struct<T, U>: 'pin,
+{
+ pinned: ::pin_project::__reexport::pin::Pin<&'pin mut (T)>,
+ unpinned: &'pin mut (U),
+}
+#[doc(hidden)]
+#[allow(dead_code)] // This lint warns unused fields/variants.
+#[allow(single_use_lifetimes)]
+pub(crate) struct __StructProjectionRef<'pin, T, U>
+where
+ Struct<T, U>: 'pin,
+{
+ pinned: ::pin_project::__reexport::pin::Pin<&'pin (T)>,
+ unpinned: &'pin (U),
+}
+
+#[doc(hidden)]
+#[allow(non_upper_case_globals)]
+#[allow(single_use_lifetimes)]
+const __SCOPE_Struct: () = {
+ impl<T, U> Struct<T, U> {
+ pub(crate) fn project<'pin>(
+ self: ::pin_project::__reexport::pin::Pin<&'pin mut Self>,
+ ) -> __StructProjection<'pin, T, U> {
+ unsafe {
+ let Self { pinned, unpinned } = self.get_unchecked_mut();
+ __StructProjection {
+ pinned: ::pin_project::__reexport::pin::Pin::new_unchecked(pinned),
+ unpinned,
+ }
+ }
+ }
+ pub(crate) fn project_ref<'pin>(
+ self: ::pin_project::__reexport::pin::Pin<&'pin Self>,
+ ) -> __StructProjectionRef<'pin, T, U> {
+ unsafe {
+ let Self { pinned, unpinned } = self.get_ref();
+ __StructProjectionRef {
+ pinned: ::pin_project::__reexport::pin::Pin::new_unchecked(pinned),
+ unpinned,
+ }
+ }
+ }
+ }
+
+ // Create `Unpin` impl that has trivial `Unpin` bounds.
+ //
+ // See https://github.com/taiki-e/pin-project/issues/102#issuecomment-540472282
+ // for details.
+ impl<'pin, T, U> ::pin_project::__reexport::marker::Unpin for Struct<T, U> where
+ ::pin_project::__private::Wrapper<'pin, ::pin_project::__reexport::marker::PhantomPinned>:
+ ::pin_project::__reexport::marker::Unpin
+ {
+ }
+ // A dummy impl of `UnsafeUnpin`, to ensure that the user cannot implement it.
+ //
+ // To ensure that users don't accidentally write a non-functional `UnsafeUnpin`
+ // impls, we emit one ourselves. If the user ends up writing a `UnsafeUnpin` impl,
+ // they'll get a "conflicting implementations of trait" error when coherence
+ // checks are run.
+ unsafe impl<T, U> ::pin_project::UnsafeUnpin for Struct<T, U> {}
+
+ // Ensure that struct does not implement `Drop`.
+ //
+ // See ./struct-default-expanded.rs for details.
+ trait StructMustNotImplDrop {}
+ #[allow(clippy::drop_bounds)]
+ impl<T: ::pin_project::__reexport::ops::Drop> StructMustNotImplDrop for T {}
+ impl<T, U> StructMustNotImplDrop for Struct<T, U> {}
+ impl<T, U> ::pin_project::__private::PinnedDrop for Struct<T, U> {
+ unsafe fn drop(self: ::pin_project::__reexport::pin::Pin<&mut Self>) {}
+ }
+
+ // Ensure that it's impossible to use pin projections on a #[repr(packed)] struct.
+ //
+ // See ./struct-default-expanded.rs and https://github.com/taiki-e/pin-project/pull/34
+ // for details.
+ #[deny(safe_packed_borrows)]
+ fn __assert_not_repr_packed<T, U>(val: &Struct<T, U>) {
+ &val.pinned;
+ &val.unpinned;
+ }
+};
+
+fn main() {
+ fn _is_unpin<T: Unpin>() {}
+ // _is_unpin::<Struct<(), ()>>(); //~ ERROR `std::marker::PhantomPinned` cannot be unpinned
+}
diff --git a/examples/not_unpin.rs b/examples/not_unpin.rs
new file mode 100644
index 0000000..2ad72a8
--- /dev/null
+++ b/examples/not_unpin.rs
@@ -0,0 +1,17 @@
+// See ./not_unpin-expanded.rs for generated code.
+
+#![allow(dead_code)]
+
+use pin_project::pin_project;
+
+#[pin_project(!Unpin)]
+pub struct Struct<T, U> {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+}
+
+fn main() {
+ fn _is_unpin<T: Unpin>() {}
+ // _is_unpin::<Struct<(), ()>>(); //~ ERROR `std::marker::PhantomPinned` cannot be unpinned
+}
diff --git a/examples/pinned_drop-expanded.rs b/examples/pinned_drop-expanded.rs
new file mode 100644
index 0000000..15dde89
--- /dev/null
+++ b/examples/pinned_drop-expanded.rs
@@ -0,0 +1,154 @@
+// Original code (./pinned_drop.rs):
+//
+// ```rust
+// #![allow(dead_code)]
+//
+// use pin_project::{pin_project, pinned_drop};
+// use std::pin::Pin;
+//
+// #[pin_project(PinnedDrop)]
+// pub struct Struct<'a, T> {
+// was_dropped: &'a mut bool,
+// #[pin]
+// field: T,
+// }
+//
+// #[pinned_drop]
+// fn drop_Struct<T>(mut this: Pin<&mut Struct<'_, T>>) {
+// **this.project().was_dropped = true;
+// }
+//
+// fn main() {}
+// ```
+
+#![allow(dead_code, unused_imports, unused_parens)]
+#![allow(clippy::no_effect)]
+
+use pin_project::{pin_project, pinned_drop};
+use std::pin::Pin;
+
+pub struct Struct<'a, T> {
+ was_dropped: &'a mut bool,
+ // #[pin]
+ field: T,
+}
+
+#[doc(hidden)]
+#[allow(clippy::mut_mut)] // This lint warns `&mut &mut <ty>`.
+#[allow(dead_code)] // This lint warns unused fields/variants.
+#[allow(single_use_lifetimes)]
+pub(crate) struct __StructProjection<'pin, 'a, T>
+where
+ Struct<'a, T>: 'pin,
+{
+ was_dropped: &'pin mut (&'a mut bool),
+ field: ::pin_project::__reexport::pin::Pin<&'pin mut (T)>,
+}
+#[doc(hidden)]
+#[allow(dead_code)] // This lint warns unused fields/variants.
+#[allow(single_use_lifetimes)]
+pub(crate) struct __StructProjectionRef<'pin, 'a, T>
+where
+ Struct<'a, T>: 'pin,
+{
+ was_dropped: &'pin (&'a mut bool),
+ field: ::pin_project::__reexport::pin::Pin<&'pin (T)>,
+}
+
+#[doc(hidden)]
+#[allow(non_upper_case_globals)]
+#[allow(single_use_lifetimes)]
+const __SCOPE_Struct: () = {
+ impl<'a, T> Struct<'a, T> {
+ pub(crate) fn project<'pin>(
+ self: ::pin_project::__reexport::pin::Pin<&'pin mut Self>,
+ ) -> __StructProjection<'pin, 'a, T> {
+ unsafe {
+ let Self { was_dropped, field } = self.get_unchecked_mut();
+ __StructProjection {
+ was_dropped,
+ field: ::pin_project::__reexport::pin::Pin::new_unchecked(field),
+ }
+ }
+ }
+ pub(crate) fn project_ref<'pin>(
+ self: ::pin_project::__reexport::pin::Pin<&'pin Self>,
+ ) -> __StructProjectionRef<'pin, 'a, T> {
+ unsafe {
+ let Self { was_dropped, field } = self.get_ref();
+ __StructProjectionRef {
+ was_dropped,
+ field: ::pin_project::__reexport::pin::Pin::new_unchecked(field),
+ }
+ }
+ }
+ }
+
+ impl<'a, T> ::pin_project::__reexport::ops::Drop for Struct<'a, T> {
+ fn drop(&mut self) {
+ // Safety - we're in 'drop', so we know that 'self' will
+ // never move again.
+ let pinned_self = unsafe { ::pin_project::__reexport::pin::Pin::new_unchecked(self) };
+ // We call `pinned_drop` only once. Since `PinnedDrop::drop`
+ // is an unsafe method and a private API, it is never called again in safe
+ // code *unless the user uses a maliciously crafted macro*.
+ unsafe {
+ ::pin_project::__private::PinnedDrop::drop(pinned_self);
+ }
+ }
+ }
+
+ // Automatically create the appropriate conditional `Unpin` implementation.
+ //
+ // See ./struct-default-expanded.rs and https://github.com/taiki-e/pin-project/pull/53.
+ // for details.
+ pub struct __Struct<'pin, 'a, T> {
+ __pin_project_use_generics: ::pin_project::__private::AlwaysUnpin<'pin, (T)>,
+ __field0: T,
+ __lifetime0: &'a (),
+ }
+ impl<'pin, 'a, T> ::pin_project::__reexport::marker::Unpin for Struct<'a, T> where
+ __Struct<'pin, 'a, T>: ::pin_project::__reexport::marker::Unpin
+ {
+ }
+ unsafe impl<'a, T> ::pin_project::UnsafeUnpin for Struct<'a, T> {}
+
+ // Ensure that it's impossible to use pin projections on a #[repr(packed)] struct.
+ //
+ // See ./struct-default-expanded.rs and https://github.com/taiki-e/pin-project/pull/34
+ // for details.
+ #[deny(safe_packed_borrows)]
+ fn __assert_not_repr_packed<'a, T>(val: &Struct<'a, T>) {
+ &val.was_dropped;
+ &val.field;
+ }
+};
+
+// Implementing `PinnedDrop::drop` is safe, but calling it is not safe.
+// This is because destructors can be called multiple times in safe code and
+// [double dropping is unsound](https://github.com/rust-lang/rust/pull/62360).
+//
+// Ideally, it would be desirable to be able to forbid manual calls in
+// the same way as `Drop::drop`, but the library cannot do it. So, by using
+// macros and replacing them with private traits, we prevent users from
+// calling `PinnedDrop::drop`.
+//
+// Users can implement [`Drop`] safely using `#[pinned_drop]` and can drop a
+// type that implements `PinnedDrop` using the [`drop`] function safely.
+// **Do not call or implement this trait directly.**
+impl<T> ::pin_project::__private::PinnedDrop for Struct<'_, T> {
+ // Since calling it twice on the same object would be UB,
+ // this method is unsafe.
+ unsafe fn drop(self: Pin<&mut Self>) {
+ #[allow(clippy::needless_pass_by_value)]
+ fn __drop_inner<T>(__self: Pin<&mut Struct<'_, T>>) {
+ // A dummy `__drop_inner` function to prevent users call outer `__drop_inner`.
+ fn __drop_inner() {}
+
+ **__self.project().was_dropped = true;
+ }
+ __drop_inner(self);
+ }
+}
+
+fn main() {}
diff --git a/examples/pinned_drop.rs b/examples/pinned_drop.rs
new file mode 100644
index 0000000..4dfd228
--- /dev/null
+++ b/examples/pinned_drop.rs
@@ -0,0 +1,22 @@
+// See ./pinned_drop-expanded.rs for generated code.
+
+#![allow(dead_code)]
+
+use pin_project::{pin_project, pinned_drop};
+use std::pin::Pin;
+
+#[pin_project(PinnedDrop)]
+pub struct Struct<'a, T> {
+ was_dropped: &'a mut bool,
+ #[pin]
+ field: T,
+}
+
+#[pinned_drop]
+impl<T> PinnedDrop for Struct<'_, T> {
+ fn drop(self: Pin<&mut Self>) {
+ **self.project().was_dropped = true;
+ }
+}
+
+fn main() {}
diff --git a/examples/project_replace-expanded.rs b/examples/project_replace-expanded.rs
new file mode 100644
index 0000000..ec9f00e
--- /dev/null
+++ b/examples/project_replace-expanded.rs
@@ -0,0 +1,158 @@
+// Original code (./struct-default.rs):
+//
+// ```rust
+// #![allow(dead_code)]
+//
+// use pin_project::pin_project;
+//
+// #[pin_project(Replace)]
+// struct Struct<T, U> {
+// #[pin]
+// pinned: T,
+// unpinned: U,
+// }
+//
+// fn main() {}
+// ```
+
+#![allow(dead_code, unused_imports, unused_parens)]
+#![allow(clippy::no_effect)]
+
+use pin_project::pin_project;
+
+struct Struct<T, U> {
+ // #[pin]
+ pinned: T,
+ unpinned: U,
+}
+
+#[doc(hidden)]
+#[allow(clippy::mut_mut)] // This lint warns `&mut &mut <ty>`.
+#[allow(dead_code)] // This lint warns unused fields/variants.
+#[allow(single_use_lifetimes)]
+struct __StructProjection<'pin, T, U>
+where
+ Struct<T, U>: 'pin,
+{
+ pinned: ::pin_project::__reexport::pin::Pin<&'pin mut (T)>,
+ unpinned: &'pin mut (U),
+}
+#[doc(hidden)]
+#[allow(dead_code)] // This lint warns unused fields/variants.
+#[allow(single_use_lifetimes)]
+struct __StructProjectionRef<'pin, T, U>
+where
+ Struct<T, U>: 'pin,
+{
+ pinned: ::pin_project::__reexport::pin::Pin<&'pin (T)>,
+ unpinned: &'pin (U),
+}
+
+#[doc(hidden)]
+#[allow(dead_code)] // This lint warns unused fields/variants.
+#[allow(single_use_lifetimes)]
+struct __StructProjectionOwned<T, U> {
+ pinned: ::pin_project::__reexport::marker::PhantomData<T>,
+ unpinned: U,
+}
+
+#[doc(hidden)]
+#[allow(non_upper_case_globals)]
+#[allow(single_use_lifetimes)]
+const __SCOPE_Struct: () = {
+ impl<T, U> Struct<T, U> {
+ fn project<'pin>(
+ self: ::pin_project::__reexport::pin::Pin<&'pin mut Self>,
+ ) -> __StructProjection<'pin, T, U> {
+ unsafe {
+ let Self { pinned, unpinned } = self.get_unchecked_mut();
+ __StructProjection {
+ pinned: ::pin_project::__reexport::pin::Pin::new_unchecked(pinned),
+ unpinned,
+ }
+ }
+ }
+ fn project_ref<'pin>(
+ self: ::pin_project::__reexport::pin::Pin<&'pin Self>,
+ ) -> __StructProjectionRef<'pin, T, U> {
+ unsafe {
+ let Self { pinned, unpinned } = self.get_ref();
+ __StructProjectionRef {
+ pinned: ::pin_project::__reexport::pin::Pin::new_unchecked(pinned),
+ unpinned,
+ }
+ }
+ }
+ fn project_replace(
+ self: ::pin_project::__reexport::pin::Pin<&mut Self>,
+ __replacement: Self,
+ ) -> __StructProjectionOwned<T, U> {
+ unsafe {
+ let __self_ptr: *mut Self = self.get_unchecked_mut();
+ let Self { pinned, unpinned } = &mut *__self_ptr;
+
+ // First, extract all the unpinned fields
+ let __result = __StructProjectionOwned {
+ pinned: ::pin_project::__reexport::marker::PhantomData,
+ unpinned: ::pin_project::__reexport::ptr::read(unpinned),
+ };
+
+ // Destructors will run in reverse order, so next create a guard to overwrite
+ // `self` with the replacement value without calling destructors.
+ let __guard = ::pin_project::__private::UnsafeOverwriteGuard {
+ target: __self_ptr,
+ value: ::pin_project::__reexport::mem::ManuallyDrop::new(__replacement),
+ };
+
+ // Now create guards to drop all the pinned fields
+ //
+ // Due to a compiler bug (https://github.com/rust-lang/rust/issues/47949)
+ // this must be in its own scope, or else `__result` will not be dropped
+ // if any of the destructors panic.
+ {
+ let __guard = ::pin_project::__private::UnsafeDropInPlaceGuard(pinned);
+ }
+
+ // Finally, return the result
+ __result
+ }
+ }
+ }
+
+ // Automatically create the appropriate conditional `Unpin` implementation.
+ //
+ // See ./struct-default-expanded.rs and https://github.com/taiki-e/pin-project/pull/53.
+ // for details.
+ struct __Struct<'pin, T, U> {
+ __pin_project_use_generics: ::pin_project::__private::AlwaysUnpin<'pin, (T, U)>,
+ __field0: T,
+ }
+ impl<'pin, T, U> ::pin_project::__reexport::marker::Unpin for Struct<T, U> where
+ __Struct<'pin, T, U>: ::pin_project::__reexport::marker::Unpin
+ {
+ }
+ unsafe impl<T, U> ::pin_project::UnsafeUnpin for Struct<T, U> {}
+
+ // Ensure that struct does not implement `Drop`.
+ //
+ // See ./struct-default-expanded.rs for details.
+ trait StructMustNotImplDrop {}
+ #[allow(clippy::drop_bounds)]
+ impl<T: ::pin_project::__reexport::ops::Drop> StructMustNotImplDrop for T {}
+ impl<T, U> StructMustNotImplDrop for Struct<T, U> {}
+ impl<T, U> ::pin_project::__private::PinnedDrop for Struct<T, U> {
+ unsafe fn drop(self: ::pin_project::__reexport::pin::Pin<&mut Self>) {}
+ }
+
+ // Ensure that it's impossible to use pin projections on a #[repr(packed)] struct.
+ //
+ // See ./struct-default-expanded.rs and https://github.com/taiki-e/pin-project/pull/34
+ // for details.
+ #[deny(safe_packed_borrows)]
+ fn __assert_not_repr_packed<T, U>(val: &Struct<T, U>) {
+ &val.pinned;
+ &val.unpinned;
+ }
+};
+
+fn main() {}
diff --git a/examples/project_replace.rs b/examples/project_replace.rs
new file mode 100644
index 0000000..4482625
--- /dev/null
+++ b/examples/project_replace.rs
@@ -0,0 +1,14 @@
+// See ./struct-default-expanded.rs for generated code.
+
+#![allow(dead_code)]
+
+use pin_project::pin_project;
+
+#[pin_project(Replace)]
+struct Struct<T, U> {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+}
+
+fn main() {}
diff --git a/examples/struct-default-expanded.rs b/examples/struct-default-expanded.rs
new file mode 100644
index 0000000..2bf7edd
--- /dev/null
+++ b/examples/struct-default-expanded.rs
@@ -0,0 +1,157 @@
+// Original code (./struct-default.rs):
+//
+// ```rust
+// #![allow(dead_code)]
+//
+// use pin_project::pin_project;
+//
+// #[pin_project]
+// struct Struct<T, U> {
+// #[pin]
+// pinned: T,
+// unpinned: U,
+// }
+//
+// fn main() {}
+// ```
+
+#![allow(dead_code, unused_imports, unused_parens)]
+#![allow(clippy::no_effect)]
+
+use pin_project::pin_project;
+
+struct Struct<T, U> {
+ // #[pin]
+ pinned: T,
+ unpinned: U,
+}
+
+#[doc(hidden)]
+#[allow(clippy::mut_mut)] // This lint warns `&mut &mut <ty>`.
+#[allow(dead_code)] // This lint warns unused fields/variants.
+#[allow(single_use_lifetimes)]
+struct __StructProjection<'pin, T, U>
+where
+ Struct<T, U>: 'pin,
+{
+ pinned: ::pin_project::__reexport::pin::Pin<&'pin mut (T)>,
+ unpinned: &'pin mut (U),
+}
+#[doc(hidden)]
+#[allow(dead_code)] // This lint warns unused fields/variants.
+#[allow(single_use_lifetimes)]
+struct __StructProjectionRef<'pin, T, U>
+where
+ Struct<T, U>: 'pin,
+{
+ pinned: ::pin_project::__reexport::pin::Pin<&'pin (T)>,
+ unpinned: &'pin (U),
+}
+
+#[doc(hidden)]
+#[allow(non_upper_case_globals)]
+#[allow(single_use_lifetimes)]
+const __SCOPE_Struct: () = {
+ impl<T, U> Struct<T, U> {
+ fn project<'pin>(
+ self: ::pin_project::__reexport::pin::Pin<&'pin mut Self>,
+ ) -> __StructProjection<'pin, T, U> {
+ unsafe {
+ let Self { pinned, unpinned } = self.get_unchecked_mut();
+ __StructProjection {
+ pinned: ::pin_project::__reexport::pin::Pin::new_unchecked(pinned),
+ unpinned,
+ }
+ }
+ }
+ fn project_ref<'pin>(
+ self: ::pin_project::__reexport::pin::Pin<&'pin Self>,
+ ) -> __StructProjectionRef<'pin, T, U> {
+ unsafe {
+ let Self { pinned, unpinned } = self.get_ref();
+ __StructProjectionRef {
+ pinned: ::pin_project::__reexport::pin::Pin::new_unchecked(pinned),
+ unpinned,
+ }
+ }
+ }
+ }
+
+ // Automatically create the appropriate conditional `Unpin` implementation.
+ //
+ // Basically this is equivalent to the following code:
+ //
+ // ```rust
+ // impl<T, U> Unpin for Struct<T, U> where T: Unpin {}
+ // ```
+ //
+ // However, if struct is public and there is a private type field,
+ // this would cause an E0446 (private type in public interface).
+ //
+ // When RFC 2145 is implemented (rust-lang/rust#48054),
+ // this will become a lint, rather then a hard error.
+ //
+ // As a workaround for this, we generate a new struct, containing all of the pinned
+ // fields from our #[pin_project] type. This struct is declared within
+ // a function, which makes it impossible to be named by user code.
+ // This guarantees that it will use the default auto-trait impl for Unpin -
+ // that is, it will implement Unpin iff all of its fields implement Unpin.
+ // This type can be safely declared as 'public', satisfying the privacy
+ // checker without actually allowing user code to access it.
+ //
+ // This allows users to apply the #[pin_project] attribute to types
+ // regardless of the privacy of the types of their fields.
+ //
+ // See also https://github.com/taiki-e/pin-project/pull/53.
+ struct __Struct<'pin, T, U> {
+ __pin_project_use_generics: ::pin_project::__private::AlwaysUnpin<'pin, (T, U)>,
+ __field0: T,
+ }
+ impl<'pin, T, U> ::pin_project::__reexport::marker::Unpin for Struct<T, U> where
+ __Struct<'pin, T, U>: ::pin_project::__reexport::marker::Unpin
+ {
+ }
+ // A dummy impl of `UnsafeUnpin`, to ensure that the user cannot implement it.
+ //
+ // To ensure that users don't accidentally write a non-functional `UnsafeUnpin`
+ // impls, we emit one ourselves. If the user ends up writing a `UnsafeUnpin` impl,
+ // they'll get a "conflicting implementations of trait" error when coherence
+ // checks are run.
+ unsafe impl<T, U> ::pin_project::UnsafeUnpin for Struct<T, U> {}
+
+ // Ensure that struct does not implement `Drop`.
+ //
+ // If you attempt to provide an Drop impl, the blanket impl will
+ // then apply to your type, causing a compile-time error due to
+ // the conflict with the second impl.
+ trait StructMustNotImplDrop {}
+ #[allow(clippy::drop_bounds)]
+ impl<T: ::pin_project::__reexport::ops::Drop> StructMustNotImplDrop for T {}
+ impl<T, U> StructMustNotImplDrop for Struct<T, U> {}
+ // A dummy impl of `PinnedDrop`, to ensure that users don't accidentally
+ // write a non-functional `PinnedDrop` impls.
+ impl<T, U> ::pin_project::__private::PinnedDrop for Struct<T, U> {
+ unsafe fn drop(self: ::pin_project::__reexport::pin::Pin<&mut Self>) {}
+ }
+
+ // Ensure that it's impossible to use pin projections on a #[repr(packed)] struct.
+ //
+ // Taking a reference to a packed field is unsafe, and applying
+ // #[deny(safe_packed_borrows)] makes sure that doing this without
+ // an 'unsafe' block (which we deliberately do not generate)
+ // is a hard error.
+ //
+ // If the struct ends up having #[repr(packed)] applied somehow,
+ // this will generate an (unfriendly) error message. Under all reasonable
+ // circumstances, we'll detect the #[repr(packed)] attribute, and generate
+ // a much nicer error above.
+ //
+ // See https://github.com/taiki-e/pin-project/pull/34 for more details.
+ #[deny(safe_packed_borrows)]
+ fn __assert_not_repr_packed<T, U>(val: &Struct<T, U>) {
+ &val.pinned;
+ &val.unpinned;
+ }
+};
+
+fn main() {}
diff --git a/examples/struct-default.rs b/examples/struct-default.rs
new file mode 100644
index 0000000..46808a5
--- /dev/null
+++ b/examples/struct-default.rs
@@ -0,0 +1,14 @@
+// See ./struct-default-expanded.rs for generated code.
+
+#![allow(dead_code)]
+
+use pin_project::pin_project;
+
+#[pin_project]
+struct Struct<T, U> {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+}
+
+fn main() {}
diff --git a/examples/unsafe_unpin-expanded.rs b/examples/unsafe_unpin-expanded.rs
new file mode 100644
index 0000000..7d8ad8e
--- /dev/null
+++ b/examples/unsafe_unpin-expanded.rs
@@ -0,0 +1,111 @@
+// Original code (./unsafe_unpin.rs):
+//
+// ```rust
+// #![allow(dead_code)]
+//
+// use pin_project::{pin_project, UnsafeUnpin};
+//
+// #[pin_project(UnsafeUnpin)]
+// pub struct Struct<T, U> {
+// #[pin]
+// pinned: T,
+// unpinned: U,
+// }
+//
+// unsafe impl<T: Unpin, U> UnsafeUnpin for Struct<T, U> {}
+//
+// fn main() {}
+// ```
+
+#![allow(dead_code, unused_imports, unused_parens)]
+#![allow(clippy::no_effect)]
+
+use pin_project::{pin_project, UnsafeUnpin};
+
+pub struct Struct<T, U> {
+ // #[pin]
+ pinned: T,
+ unpinned: U,
+}
+
+#[doc(hidden)]
+#[allow(clippy::mut_mut)] // This lint warns `&mut &mut <ty>`.
+#[allow(dead_code)] // This lint warns unused fields/variants.
+#[allow(single_use_lifetimes)]
+pub(crate) struct __StructProjection<'pin, T, U>
+where
+ Struct<T, U>: 'pin,
+{
+ pinned: ::pin_project::__reexport::pin::Pin<&'pin mut (T)>,
+ unpinned: &'pin mut (U),
+}
+#[doc(hidden)]
+#[allow(dead_code)] // This lint warns unused fields/variants.
+#[allow(single_use_lifetimes)]
+pub(crate) struct __StructProjectionRef<'pin, T, U>
+where
+ Struct<T, U>: 'pin,
+{
+ pinned: ::pin_project::__reexport::pin::Pin<&'pin (T)>,
+ unpinned: &'pin (U),
+}
+
+#[doc(hidden)]
+#[allow(non_upper_case_globals)]
+#[allow(single_use_lifetimes)]
+const __SCOPE_Struct: () = {
+ impl<T, U> Struct<T, U> {
+ pub(crate) fn project<'pin>(
+ self: ::pin_project::__reexport::pin::Pin<&'pin mut Self>,
+ ) -> __StructProjection<'pin, T, U> {
+ unsafe {
+ let Self { pinned, unpinned } = self.get_unchecked_mut();
+ __StructProjection {
+ pinned: ::pin_project::__reexport::pin::Pin::new_unchecked(pinned),
+ unpinned,
+ }
+ }
+ }
+ pub(crate) fn project_ref<'pin>(
+ self: ::pin_project::__reexport::pin::Pin<&'pin Self>,
+ ) -> __StructProjectionRef<'pin, T, U> {
+ unsafe {
+ let Self { pinned, unpinned } = self.get_ref();
+ __StructProjectionRef {
+ pinned: ::pin_project::__reexport::pin::Pin::new_unchecked(pinned),
+ unpinned,
+ }
+ }
+ }
+ }
+
+ impl<'pin, T, U> ::pin_project::__reexport::marker::Unpin for Struct<T, U> where
+ ::pin_project::__private::Wrapper<'pin, Self>: ::pin_project::UnsafeUnpin
+ {
+ }
+
+ // Ensure that struct does not implement `Drop`.
+ //
+ // See ./struct-default-expanded.rs for details.
+ trait StructMustNotImplDrop {}
+ #[allow(clippy::drop_bounds)]
+ impl<T: ::pin_project::__reexport::ops::Drop> StructMustNotImplDrop for T {}
+ impl<T, U> StructMustNotImplDrop for Struct<T, U> {}
+ impl<T, U> ::pin_project::__private::PinnedDrop for Struct<T, U> {
+ unsafe fn drop(self: ::pin_project::__reexport::pin::Pin<&mut Self>) {}
+ }
+
+ // Ensure that it's impossible to use pin projections on a #[repr(packed)] struct.
+ //
+ // See ./struct-default-expanded.rs and https://github.com/taiki-e/pin-project/pull/34
+ // for details.
+ #[deny(safe_packed_borrows)]
+ fn __assert_not_repr_packed<T, U>(val: &Struct<T, U>) {
+ &val.pinned;
+ &val.unpinned;
+ }
+};
+
+unsafe impl<T: Unpin, U> UnsafeUnpin for Struct<T, U> {}
+
+fn main() {}
diff --git a/examples/unsafe_unpin.rs b/examples/unsafe_unpin.rs
new file mode 100644
index 0000000..5ec0cd2
--- /dev/null
+++ b/examples/unsafe_unpin.rs
@@ -0,0 +1,16 @@
+// See ./unsafe_unpin-expanded.rs for generated code.
+
+#![allow(dead_code)]
+
+use pin_project::{pin_project, UnsafeUnpin};
+
+#[pin_project(UnsafeUnpin)]
+pub struct Struct<T, U> {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+}
+
+unsafe impl<T: Unpin, U> UnsafeUnpin for Struct<T, U> {}
+
+fn main() {}
diff --git a/src/lib.rs b/src/lib.rs
new file mode 100644
index 0000000..45c58fa
--- /dev/null
+++ b/src/lib.rs
@@ -0,0 +1,239 @@
+//! A crate for safe and ergonomic pin-projection.
+//!
+//! ## Examples
+//!
+//! [`pin_project`] attribute creates a projection type covering all the fields of struct or enum.
+//!
+//! ```rust
+//! use pin_project::pin_project;
+//! use std::pin::Pin;
+//!
+//! #[pin_project]
+//! struct Struct<T, U> {
+//! #[pin]
+//! pinned: T,
+//! unpinned: U,
+//! }
+//!
+//! impl<T, U> Struct<T, U> {
+//! fn foo(self: Pin<&mut Self>) {
+//! let this = self.project();
+//! let _: Pin<&mut T> = this.pinned; // Pinned reference to the field
+//! let _: &mut U = this.unpinned; // Normal reference to the field
+//! }
+//! }
+//! ```
+//!
+//! [Code like this will be generated](https://github.com/taiki-e/pin-project/blob/master/examples/struct-default-expanded.rs)
+//!
+//! See [`pin_project`] attribute for more details.
+//!
+//! Also, there are examples and generated code of each feature in [examples](https://github.com/taiki-e/pin-project/blob/master/examples/README.md) directory.
+//!
+//! [`pin_project`]: attr.pin_project.html
+
+#![no_std]
+#![recursion_limit = "256"]
+#![doc(html_root_url = "https://docs.rs/pin-project/0.4.16")]
+#![doc(test(
+ no_crate_inject,
+ attr(deny(warnings, rust_2018_idioms, single_use_lifetimes), allow(dead_code))
+))]
+#![warn(missing_docs, rust_2018_idioms, single_use_lifetimes, unreachable_pub)]
+#![warn(clippy::all, clippy::default_trait_access)]
+// mem::take requires Rust 1.40
+#![allow(clippy::mem_replace_with_default)]
+#![allow(clippy::needless_doctest_main)]
+
+#[doc(inline)]
+pub use pin_project_internal::pin_project;
+
+#[doc(inline)]
+pub use pin_project_internal::pinned_drop;
+
+#[doc(inline)]
+pub use pin_project_internal::project;
+
+#[doc(inline)]
+pub use pin_project_internal::project_ref;
+
+#[doc(inline)]
+pub use pin_project_internal::project_replace;
+
+/// A trait used for custom implementations of [`Unpin`].
+/// This trait is used in conjunction with the `UnsafeUnpin`
+/// argument to [`pin_project`]
+///
+/// The Rust [`Unpin`] trait is safe to implement - by itself,
+/// implementing it cannot lead to undefined behavior. Undefined
+/// behavior can only occur when other unsafe code is used.
+///
+/// It turns out that using pin projections, which requires unsafe code,
+/// imposes additional requirements on an [`Unpin`] impl. Normally, all of this
+/// unsafety is contained within this crate, ensuring that it's impossible for
+/// you to violate any of the guarantees required by pin projection.
+///
+/// However, things change if you want to provide a custom [`Unpin`] impl
+/// for your `#[pin_project]` type. As stated in [the Rust
+/// documentation](https://doc.rust-lang.org/nightly/std/pin/index.html#projections-and-structural-pinning),
+/// you must be sure to only implement [`Unpin`] when all of your `#[pin]` fields (i.e. structurally
+/// pinned fields) are also [`Unpin`].
+///
+/// To help highlight this unsafety, the `UnsafeUnpin` trait is provided.
+/// Implementing this trait is logically equivalent to implementing [`Unpin`] -
+/// this crate will generate an [`Unpin`] impl for your type that 'forwards' to
+/// your `UnsafeUnpin` impl. However, this trait is `unsafe` - since your type
+/// uses structural pinning (otherwise, you wouldn't be using this crate!),
+/// you must be sure that your `UnsafeUnpin` impls follows all of
+/// the requirements for an [`Unpin`] impl of a structurally-pinned type.
+///
+/// Note that if you specify `#[pin_project(UnsafeUnpin)]`, but do *not*
+/// provide an impl of `UnsafeUnpin`, your type will never implement [`Unpin`].
+/// This is effectively the same thing as adding a [`PhantomPinned`] to your type
+///
+/// Since this trait is `unsafe`, impls of it will be detected by the `unsafe_code` lint,
+/// and by tools like `cargo geiger`.
+///
+/// ## Examples
+///
+/// An `UnsafeUnpin` impl which, in addition to requiring that structurally pinned
+/// fields be [`Unpin`], imposes an additional requirement:
+///
+/// ```rust
+/// use pin_project::{pin_project, UnsafeUnpin};
+///
+/// #[pin_project(UnsafeUnpin)]
+/// struct Foo<K, V> {
+/// #[pin]
+/// field_1: K,
+/// field_2: V,
+/// }
+///
+/// unsafe impl<K, V> UnsafeUnpin for Foo<K, V> where K: Unpin + Clone {}
+/// ```
+///
+/// [`PhantomPinned`]: core::marker::PhantomPinned
+/// [`pin_project`]: attr.pin_project.html
+pub unsafe trait UnsafeUnpin {}
+
+// Not public API.
+#[doc(hidden)]
+pub mod __private {
+ use super::UnsafeUnpin;
+ use core::{marker::PhantomData, mem::ManuallyDrop, pin::Pin, ptr};
+
+ #[doc(hidden)]
+ pub use pin_project_internal::__PinProjectInternalDerive;
+
+ // Implementing `PinnedDrop::drop` is safe, but calling it is not safe.
+ // This is because destructors can be called multiple times in safe code and
+ // [double dropping is unsound](https://github.com/rust-lang/rust/pull/62360).
+ //
+ // Ideally, it would be desirable to be able to forbid manual calls in
+ // the same way as [`Drop::drop`], but the library cannot do it. So, by using
+ // macros and replacing them with private traits, we prevent users from
+ // calling `PinnedDrop::drop`.
+ //
+ // Users can implement [`Drop`] safely using `#[pinned_drop]` and can drop a
+ // type that implements `PinnedDrop` using the [`drop`] function safely.
+ // **Do not call or implement this trait directly.**
+ #[doc(hidden)]
+ pub trait PinnedDrop {
+ #[doc(hidden)]
+ unsafe fn drop(self: Pin<&mut Self>);
+ }
+
+ // This is an internal helper struct used by `pin-project-internal`.
+ // This allows us to force an error if the user tries to provide
+ // a regular `Unpin` impl when they specify the `UnsafeUnpin` argument.
+ // This is why we need Wrapper:
+ //
+ // Supposed we have the following code:
+ //
+ // #[pin_project(UnsafeUnpin)]
+ // struct MyStruct<T> {
+ // #[pin] field: T
+ // }
+ //
+ // impl<T> Unpin for MyStruct<T> where MyStruct<T>: UnsafeUnpin {} // generated by pin-project-internal
+ // impl<T> Unpin for MyStruct<T> where T: Copy // written by the user
+ //
+ // We want this code to be rejected - the user is completely bypassing `UnsafeUnpin`,
+ // and providing an unsound Unpin impl in safe code!
+ //
+ // Unfortunately, the Rust compiler will accept the above code.
+ // Because MyStruct is declared in the same crate as the user-provided impl,
+ // the compiler will notice that 'MyStruct<T>: UnsafeUnpin' never holds.
+ //
+ // The solution is to introduce the 'Wrapper' struct, which is defined
+ // in the 'pin-project' crate.
+ //
+ // We now have code that looks like this:
+ //
+ // impl<T> Unpin for MyStruct<T> where Wrapper<MyStruct<T>>: UnsafeUnpin {} // generated by pin-project-internal
+ // impl<T> Unpin for MyStruct<T> where T: Copy // written by the user
+ //
+ // We also have 'unsafe impl<T> UnsafeUnpin for Wrapper<T> where T: UnsafeUnpin {}' in the
+ // 'pin-project' crate.
+ //
+ // Now, our generated impl has a bound involving a type defined in another crate - Wrapper.
+ // This will cause rust to conservatively assume that 'Wrapper<MyStruct<T>>: UnsafeUnpin'
+ // holds, in the interest of preserving forwards compatibility (in case such an impl is added
+ // for Wrapper<T> in a new version of the crate).
+ //
+ // This will cause rust to reject any other Unpin impls for MyStruct<T>, since it will
+ // assume that our generated impl could potentially apply in any situation.
+ //
+ // This achieves the desired effect - when the user writes `#[pin_project(UnsafeUnpin)]`,
+ // the user must either provide no impl of `UnsafeUnpin` (which is equivalent
+ // to making the type never implement Unpin), or provide an impl of `UnsafeUnpin`.
+ // It is impossible for them to provide an impl of `Unpin`
+ #[doc(hidden)]
+ pub struct Wrapper<'a, T: ?Sized>(PhantomData<&'a ()>, T);
+
+ unsafe impl<T: ?Sized> UnsafeUnpin for Wrapper<'_, T> where T: UnsafeUnpin {}
+
+ // This is an internal helper struct used by `pin-project-internal`.
+ //
+ // See https://github.com/taiki-e/pin-project/pull/53 for more details.
+ #[doc(hidden)]
+ pub struct AlwaysUnpin<'a, T: ?Sized>(PhantomData<&'a ()>, PhantomData<T>);
+
+ impl<T: ?Sized> Unpin for AlwaysUnpin<'_, T> {}
+
+ // This is an internal helper used to ensure a value is dropped.
+ #[doc(hidden)]
+ pub struct UnsafeDropInPlaceGuard<T: ?Sized>(pub *mut T);
+
+ impl<T: ?Sized> Drop for UnsafeDropInPlaceGuard<T> {
+ fn drop(&mut self) {
+ unsafe {
+ ptr::drop_in_place(self.0);
+ }
+ }
+ }
+
+ // This is an internal helper used to ensure a value is overwritten without
+ // its destructor being called.
+ #[doc(hidden)]
+ pub struct UnsafeOverwriteGuard<T> {
+ pub value: ManuallyDrop<T>,
+ pub target: *mut T,
+ }
+
+ impl<T> Drop for UnsafeOverwriteGuard<T> {
+ fn drop(&mut self) {
+ unsafe {
+ ptr::write(self.target, ptr::read(&*self.value));
+ }
+ }
+ }
+}
+
+// Not public API.
+// See tests/overwriting_core_crate.rs for more.
+#[doc(hidden)]
+pub mod __reexport {
+ #[doc(hidden)]
+ pub use core::{marker, mem, ops, pin, ptr};
+}
diff --git a/tests/cfg.rs b/tests/cfg.rs
new file mode 100644
index 0000000..20b8472
--- /dev/null
+++ b/tests/cfg.rs
@@ -0,0 +1,242 @@
+#![warn(rust_2018_idioms, single_use_lifetimes)]
+#![allow(dead_code)]
+
+// Refs: https://doc.rust-lang.org/nightly/reference/attributes.html
+
+use pin_project::pin_project;
+use std::{marker::PhantomPinned, pin::Pin};
+
+fn is_unpin<T: Unpin>() {}
+
+#[cfg(target_os = "linux")]
+struct Linux;
+#[cfg(not(target_os = "linux"))]
+struct Other;
+
+// Use this type to check that `cfg(any())` is working properly.
+// If `cfg(any())` is not working properly, `is_unpin` will fail.
+struct Any(PhantomPinned);
+
+#[test]
+fn cfg() {
+ // structs
+
+ #[pin_project(Replace)]
+ struct SameName {
+ #[cfg(target_os = "linux")]
+ #[pin]
+ inner: Linux,
+ #[cfg(not(target_os = "linux"))]
+ #[pin]
+ inner: Other,
+ #[cfg(any())]
+ #[pin]
+ any: Any,
+ }
+
+ is_unpin::<SameName>();
+
+ #[cfg(target_os = "linux")]
+ let _x = SameName { inner: Linux };
+ #[cfg(not(target_os = "linux"))]
+ let _x = SameName { inner: Other };
+
+ #[pin_project(Replace)]
+ struct DifferentName {
+ #[cfg(target_os = "linux")]
+ #[pin]
+ l: Linux,
+ #[cfg(not(target_os = "linux"))]
+ #[pin]
+ o: Other,
+ #[cfg(any())]
+ #[pin]
+ a: Any,
+ }
+
+ is_unpin::<DifferentName>();
+
+ #[cfg(target_os = "linux")]
+ let _x = DifferentName { l: Linux };
+ #[cfg(not(target_os = "linux"))]
+ let _x = DifferentName { o: Other };
+
+ #[pin_project(Replace)]
+ struct TupleStruct(
+ #[cfg(target_os = "linux")]
+ #[pin]
+ Linux,
+ #[cfg(not(target_os = "linux"))]
+ #[pin]
+ Other,
+ #[cfg(any())]
+ #[pin]
+ Any,
+ );
+
+ is_unpin::<TupleStruct>();
+
+ #[cfg(target_os = "linux")]
+ let _x = TupleStruct(Linux);
+ #[cfg(not(target_os = "linux"))]
+ let _x = TupleStruct(Other);
+
+ // enums
+
+ #[pin_project(Replace)]
+ enum Variant {
+ #[cfg(target_os = "linux")]
+ Inner(#[pin] Linux),
+ #[cfg(not(target_os = "linux"))]
+ Inner(#[pin] Other),
+
+ #[cfg(target_os = "linux")]
+ Linux(#[pin] Linux),
+ #[cfg(not(target_os = "linux"))]
+ Other(#[pin] Other),
+ #[cfg(any())]
+ Any(#[pin] Any),
+ }
+
+ is_unpin::<Variant>();
+
+ #[cfg(target_os = "linux")]
+ let _x = Variant::Inner(Linux);
+ #[cfg(not(target_os = "linux"))]
+ let _x = Variant::Inner(Other);
+
+ #[cfg(target_os = "linux")]
+ let _x = Variant::Linux(Linux);
+ #[cfg(not(target_os = "linux"))]
+ let _x = Variant::Other(Other);
+
+ #[pin_project(Replace)]
+ enum Field {
+ SameName {
+ #[cfg(target_os = "linux")]
+ #[pin]
+ inner: Linux,
+ #[cfg(not(target_os = "linux"))]
+ #[pin]
+ inner: Other,
+ #[cfg(any())]
+ #[pin]
+ any: Any,
+ },
+ DifferentName {
+ #[cfg(target_os = "linux")]
+ #[pin]
+ l: Linux,
+ #[cfg(not(target_os = "linux"))]
+ #[pin]
+ w: Other,
+ #[cfg(any())]
+ #[pin]
+ any: Any,
+ },
+ TupleVariant(
+ #[cfg(target_os = "linux")]
+ #[pin]
+ Linux,
+ #[cfg(not(target_os = "linux"))]
+ #[pin]
+ Other,
+ #[cfg(any())]
+ #[pin]
+ Any,
+ ),
+ }
+
+ is_unpin::<Field>();
+
+ #[cfg(target_os = "linux")]
+ let _x = Field::SameName { inner: Linux };
+ #[cfg(not(target_os = "linux"))]
+ let _x = Field::SameName { inner: Other };
+
+ #[cfg(target_os = "linux")]
+ let _x = Field::DifferentName { l: Linux };
+ #[cfg(not(target_os = "linux"))]
+ let _x = Field::DifferentName { w: Other };
+
+ #[cfg(target_os = "linux")]
+ let _x = Field::TupleVariant(Linux);
+ #[cfg(not(target_os = "linux"))]
+ let _x = Field::TupleVariant(Other);
+}
+
+#[test]
+fn cfg_attr() {
+ #[pin_project(Replace)]
+ struct SameCfg {
+ #[cfg(target_os = "linux")]
+ #[cfg_attr(target_os = "linux", pin)]
+ inner: Linux,
+ #[cfg(not(target_os = "linux"))]
+ #[cfg_attr(not(target_os = "linux"), pin)]
+ inner: Other,
+ #[cfg(any())]
+ #[cfg_attr(any(), pin)]
+ any: Any,
+ }
+
+ is_unpin::<SameCfg>();
+
+ #[cfg(target_os = "linux")]
+ let mut x = SameCfg { inner: Linux };
+ #[cfg(not(target_os = "linux"))]
+ let mut x = SameCfg { inner: Other };
+
+ let x = Pin::new(&mut x).project();
+ #[cfg(target_os = "linux")]
+ let _: Pin<&mut Linux> = x.inner;
+ #[cfg(not(target_os = "linux"))]
+ let _: Pin<&mut Other> = x.inner;
+
+ #[pin_project(Replace)]
+ struct DifferentCfg {
+ #[cfg(target_os = "linux")]
+ #[cfg_attr(target_os = "linux", pin)]
+ inner: Linux,
+ #[cfg(not(target_os = "linux"))]
+ #[cfg_attr(target_os = "linux", pin)]
+ inner: Other,
+ #[cfg(any())]
+ #[cfg_attr(any(), pin)]
+ any: Any,
+ }
+
+ is_unpin::<DifferentCfg>();
+
+ #[cfg(target_os = "linux")]
+ let mut x = DifferentCfg { inner: Linux };
+ #[cfg(not(target_os = "linux"))]
+ let mut x = DifferentCfg { inner: Other };
+
+ let x = Pin::new(&mut x).project();
+ #[cfg(target_os = "linux")]
+ let _: Pin<&mut Linux> = x.inner;
+ #[cfg(not(target_os = "linux"))]
+ let _: &mut Other = x.inner;
+
+ #[cfg_attr(not(any()), pin_project)]
+ struct Foo<T> {
+ #[cfg_attr(not(any()), pin)]
+ inner: T,
+ }
+
+ 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(Replace)]
+ #[cfg_attr(any(), repr(packed))]
+ struct Struct {
+ #[pin]
+ field: u32,
+ }
+}
diff --git a/tests/compiletest.rs b/tests/compiletest.rs
new file mode 100644
index 0000000..078abaa
--- /dev/null
+++ b/tests/compiletest.rs
@@ -0,0 +1,15 @@
+#![warn(rust_2018_idioms, single_use_lifetimes)]
+
+#[ignore]
+#[test]
+fn ui() {
+ let t = trybuild::TestCases::new();
+ t.compile_fail("tests/ui/cfg/*.rs");
+ t.compile_fail("tests/ui/not_unpin/*.rs");
+ t.compile_fail("tests/ui/pin_project/*.rs");
+ t.compile_fail("tests/ui/pinned_drop/*.rs");
+ t.compile_fail("tests/ui/project/*.rs");
+ t.compile_fail("tests/ui/unsafe_unpin/*.rs");
+ t.compile_fail("tests/ui/unstable-features/*.rs");
+ t.pass("tests/ui/unstable-features/run-pass/*.rs");
+}
diff --git a/tests/forbid_unsafe.rs b/tests/forbid_unsafe.rs
new file mode 100644
index 0000000..4b2e248
--- /dev/null
+++ b/tests/forbid_unsafe.rs
@@ -0,0 +1,108 @@
+#![forbid(unsafe_code)]
+#![warn(rust_2018_idioms, single_use_lifetimes)]
+#![allow(dead_code)]
+
+// default #[pin_project], PinnedDrop, Replace, and !Unpin are completely safe.
+
+use pin_project::{pin_project, pinned_drop};
+use std::pin::Pin;
+
+#[pin_project]
+pub struct StructDefault<T, U> {
+ #[pin]
+ pub pinned: T,
+ pub unpinned: U,
+}
+
+#[pin_project(PinnedDrop)]
+pub struct StructPinnedDrop<T, U> {
+ #[pin]
+ pub pinned: T,
+ pub unpinned: U,
+}
+
+#[pinned_drop]
+impl<T, U> PinnedDrop for StructPinnedDrop<T, U> {
+ fn drop(self: Pin<&mut Self>) {}
+}
+
+#[pin_project(Replace)]
+pub struct StructReplace<T, U> {
+ #[pin]
+ pub pinned: T,
+ pub unpinned: U,
+}
+
+// UnsafeUnpin without UnsafeUnpin impl is also safe
+#[pin_project(UnsafeUnpin)]
+pub struct StructUnsafeUnpin<T, U> {
+ #[pin]
+ pub pinned: T,
+ pub unpinned: U,
+}
+
+#[pin_project(!Unpin)]
+pub struct StructNotUnpin<T, U> {
+ #[pin]
+ pub pinned: T,
+ pub unpinned: U,
+}
+
+#[pin_project]
+pub enum EnumDefault<T, U> {
+ Struct {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+ },
+ Tuple(#[pin] T, U),
+}
+
+#[pin_project(PinnedDrop)]
+pub enum EnumPinnedDrop<T, U> {
+ Struct {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+ },
+ Tuple(#[pin] T, U),
+}
+
+#[pinned_drop]
+impl<T, U> PinnedDrop for EnumPinnedDrop<T, U> {
+ fn drop(self: Pin<&mut Self>) {}
+}
+
+#[pin_project(Replace)]
+pub enum EnumReplace<T, U> {
+ Struct {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+ },
+ Tuple(#[pin] T, U),
+}
+
+// UnsafeUnpin without UnsafeUnpin impl is also safe
+#[pin_project(UnsafeUnpin)]
+pub enum EnumUnsafeUnpin<T, U> {
+ Struct {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+ },
+ Tuple(#[pin] T, U),
+}
+
+#[pin_project(!Unpin)]
+pub enum EnumNotUnpin<T, U> {
+ Struct {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+ },
+ Tuple(#[pin] T, U),
+}
+
+#[test]
+fn test() {}
diff --git a/tests/lints.rs b/tests/lints.rs
new file mode 100644
index 0000000..4009f55
--- /dev/null
+++ b/tests/lints.rs
@@ -0,0 +1,126 @@
+#![warn(rust_2018_idioms, single_use_lifetimes)]
+#![warn(unused, future_incompatible)]
+#![warn(clippy::all, clippy::pedantic, clippy::nursery)]
+
+use pin_project::{pin_project, pinned_drop, UnsafeUnpin};
+use std::pin::Pin;
+
+#[pin_project]
+pub struct StructDefault<T, U> {
+ #[pin]
+ pub pinned: T,
+ pub unpinned: U,
+}
+
+#[pin_project(PinnedDrop)]
+pub struct StructPinnedDrop<T, U> {
+ #[pin]
+ pub pinned: T,
+ pub unpinned: U,
+}
+
+#[pinned_drop]
+impl<T, U> PinnedDrop for StructPinnedDrop<T, U> {
+ fn drop(self: Pin<&mut Self>) {}
+}
+
+#[pin_project(Replace)]
+pub struct StructReplace<T, U> {
+ #[pin]
+ pub pinned: T,
+ pub unpinned: U,
+}
+
+#[pin_project(UnsafeUnpin)]
+pub struct StructUnsafeUnpin<T, U> {
+ #[pin]
+ pub pinned: T,
+ pub unpinned: U,
+}
+
+unsafe impl<T: Unpin, U> UnsafeUnpin for StructUnsafeUnpin<T, U> {}
+
+#[pin_project(!Unpin)]
+pub struct StructNotUnpin<T, U> {
+ #[pin]
+ pub pinned: T,
+ pub unpinned: U,
+}
+
+#[pin_project]
+pub struct StructMutMut<'a, T, U> {
+ #[pin]
+ pub pinned: &'a mut T,
+ pub unpinned: &'a mut U,
+}
+
+#[pin_project]
+pub enum EnumDefault<T, U> {
+ Struct {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+ },
+ Tuple(#[pin] T, U),
+}
+
+#[pin_project(PinnedDrop)]
+pub enum EnumPinnedDrop<T, U> {
+ Struct {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+ },
+ Tuple(#[pin] T, U),
+}
+
+#[pinned_drop]
+impl<T, U> PinnedDrop for EnumPinnedDrop<T, U> {
+ fn drop(self: Pin<&mut Self>) {}
+}
+
+#[pin_project(Replace)]
+pub enum EnumReplace<T, U> {
+ Struct {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+ },
+ Tuple(#[pin] T, U),
+}
+
+#[pin_project(UnsafeUnpin)]
+pub enum EnumUnsafeUnpin<T, U> {
+ Struct {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+ },
+ Tuple(#[pin] T, U),
+}
+
+unsafe impl<T: Unpin, U> UnsafeUnpin for EnumUnsafeUnpin<T, U> {}
+
+#[pin_project(!Unpin)]
+pub enum EnumNotUnpin<T, U> {
+ Struct {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+ },
+ Tuple(#[pin] T, U),
+}
+
+#[pin_project]
+pub enum EnumMutMut<'a, T, U> {
+ Struct {
+ #[pin]
+ pinned: &'a mut T,
+ unpinned: &'a mut U,
+ },
+ Tuple(#[pin] T, U),
+}
+
+#[allow(clippy::missing_const_for_fn)]
+#[test]
+fn test() {}
diff --git a/tests/overwriting_core_crate.rs b/tests/overwriting_core_crate.rs
new file mode 100644
index 0000000..121104c
--- /dev/null
+++ b/tests/overwriting_core_crate.rs
@@ -0,0 +1,116 @@
+#![warn(rust_2018_idioms, single_use_lifetimes)]
+
+// See https://github.com/rust-lang/pin-utils/pull/26#discussion_r344491597
+//
+// Note: If the proc-macro does not depend on its own items, it may be preferable not to
+// support overwriting the name of core/std crate for compatibility with reexport.
+#[allow(unused_extern_crates)]
+extern crate pin_project as core;
+
+// Dummy module to check that the expansion refers to the crate.
+mod pin_project {}
+
+use ::pin_project::{pin_project, pinned_drop, UnsafeUnpin};
+use std::pin::Pin;
+
+#[pin_project]
+pub struct StructDefault<T, U> {
+ #[pin]
+ pub pinned: T,
+ pub unpinned: U,
+}
+
+#[pin_project(PinnedDrop)]
+pub struct StructPinnedDrop<T, U> {
+ #[pin]
+ pub pinned: T,
+ pub unpinned: U,
+}
+
+#[pinned_drop]
+impl<T, U> PinnedDrop for StructPinnedDrop<T, U> {
+ fn drop(self: Pin<&mut Self>) {}
+}
+
+#[pin_project(Replace)]
+pub struct StructReplace<T, U> {
+ #[pin]
+ pub pinned: T,
+ pub unpinned: U,
+}
+
+#[pin_project(UnsafeUnpin)]
+pub struct StructUnsafeUnpin<T, U> {
+ #[pin]
+ pub pinned: T,
+ pub unpinned: U,
+}
+
+unsafe impl<T: Unpin, U> UnsafeUnpin for StructUnsafeUnpin<T, U> {}
+
+#[pin_project(!Unpin)]
+pub struct StructNotUnpin<T, U> {
+ #[pin]
+ pub pinned: T,
+ pub unpinned: U,
+}
+
+#[pin_project]
+pub enum EnumDefault<T, U> {
+ Struct {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+ },
+ Tuple(#[pin] T, U),
+}
+
+#[pin_project(PinnedDrop)]
+pub enum EnumPinnedDrop<T, U> {
+ Struct {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+ },
+ Tuple(#[pin] T, U),
+}
+
+#[pinned_drop]
+impl<T, U> PinnedDrop for EnumPinnedDrop<T, U> {
+ fn drop(self: Pin<&mut Self>) {}
+}
+
+#[pin_project(Replace)]
+pub enum EnumReplace<T, U> {
+ Struct {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+ },
+ Tuple(#[pin] T, U),
+}
+
+#[pin_project(UnsafeUnpin)]
+pub enum EnumUnsafeUnpin<T, U> {
+ Struct {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+ },
+ Tuple(#[pin] T, U),
+}
+
+unsafe impl<T: Unpin, U> UnsafeUnpin for EnumUnsafeUnpin<T, U> {}
+
+#[pin_project(!Unpin)]
+pub enum EnumNotUnpin<T, U> {
+ Struct {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+ },
+ Tuple(#[pin] T, U),
+}
+
+#[test]
+fn test() {}
diff --git a/tests/pin_project.rs b/tests/pin_project.rs
new file mode 100644
index 0000000..c84ca4b
--- /dev/null
+++ b/tests/pin_project.rs
@@ -0,0 +1,809 @@
+#![warn(rust_2018_idioms, single_use_lifetimes)]
+#![allow(dead_code)]
+
+use core::{
+ marker::{PhantomData, PhantomPinned},
+ pin::Pin,
+};
+use pin_project::{pin_project, pinned_drop, UnsafeUnpin};
+
+#[test]
+fn projection() {
+ #[pin_project(Replace)]
+ struct Struct<T, U> {
+ #[pin]
+ field1: T,
+ field2: U,
+ }
+
+ let mut s = Struct { field1: 1, field2: 2 };
+ let mut s_orig = Pin::new(&mut s);
+ let s = s_orig.as_mut().project();
+
+ let x: Pin<&mut i32> = s.field1;
+ assert_eq!(*x, 1);
+
+ let y: &mut i32 = s.field2;
+ assert_eq!(*y, 2);
+
+ assert_eq!(s_orig.as_ref().field1, 1);
+ assert_eq!(s_orig.as_ref().field2, 2);
+
+ let mut s = Struct { field1: 1, field2: 2 };
+
+ let __StructProjection { field1, field2 } = Pin::new(&mut s).project();
+ let _: Pin<&mut i32> = field1;
+ let _: &mut i32 = field2;
+
+ let __StructProjectionRef { field1, field2 } = Pin::new(&s).project_ref();
+ let _: Pin<&i32> = field1;
+ let _: &i32 = field2;
+
+ let mut s = Pin::new(&mut s);
+ let __StructProjectionOwned { field1, field2 } =
+ s.as_mut().project_replace(Struct { field1: 3, field2: 4 });
+ let _: PhantomData<i32> = field1;
+ let _: i32 = field2;
+ assert_eq!(field2, 2);
+ assert_eq!(s.field1, 3);
+ assert_eq!(s.field2, 4);
+
+ #[pin_project(Replace)]
+ struct TupleStruct<T, U>(#[pin] T, U);
+
+ let mut s = TupleStruct(1, 2);
+ let s = Pin::new(&mut s).project();
+
+ let x: Pin<&mut i32> = s.0;
+ assert_eq!(*x, 1);
+
+ let y: &mut i32 = s.1;
+ assert_eq!(*y, 2);
+
+ #[pin_project(Replace)]
+ #[derive(Eq, PartialEq, Debug)]
+ enum Enum<A, B, C, D> {
+ Variant1(#[pin] A, B),
+ Variant2 {
+ #[pin]
+ field1: C,
+ field2: D,
+ },
+ None,
+ }
+
+ let mut e = Enum::Variant1(1, 2);
+ let mut e_orig = Pin::new(&mut e);
+ let e = e_orig.as_mut().project();
+
+ match e {
+ __EnumProjection::Variant1(x, y) => {
+ let x: Pin<&mut i32> = x;
+ assert_eq!(*x, 1);
+
+ let y: &mut i32 = y;
+ assert_eq!(*y, 2);
+ }
+ __EnumProjection::Variant2 { field1, field2 } => {
+ let _x: Pin<&mut i32> = field1;
+ let _y: &mut i32 = field2;
+ }
+ __EnumProjection::None => {}
+ }
+
+ assert_eq!(Pin::into_ref(e_orig).get_ref(), &Enum::Variant1(1, 2));
+
+ let mut e = Enum::Variant2 { field1: 3, field2: 4 };
+ let mut e = Pin::new(&mut e).project();
+
+ match &mut e {
+ __EnumProjection::Variant1(x, y) => {
+ let _x: &mut Pin<&mut i32> = x;
+ let _y: &mut &mut i32 = y;
+ }
+ __EnumProjection::Variant2 { field1, field2 } => {
+ let x: &mut Pin<&mut i32> = field1;
+ assert_eq!(**x, 3);
+
+ let y: &mut &mut i32 = field2;
+ assert_eq!(**y, 4);
+ }
+ __EnumProjection::None => {}
+ }
+
+ if let __EnumProjection::Variant2 { field1, field2 } = e {
+ let x: Pin<&mut i32> = field1;
+ assert_eq!(*x, 3);
+
+ let y: &mut i32 = field2;
+ assert_eq!(*y, 4);
+ }
+}
+
+#[test]
+fn enum_project_set() {
+ #[pin_project(Replace)]
+ #[derive(Eq, PartialEq, Debug)]
+ enum Enum {
+ Variant1(#[pin] u8),
+ Variant2(bool),
+ }
+
+ let mut e = Enum::Variant1(25);
+ let mut e_orig = Pin::new(&mut e);
+ let e_proj = e_orig.as_mut().project();
+
+ match e_proj {
+ __EnumProjection::Variant1(val) => {
+ let new_e = Enum::Variant2(val.as_ref().get_ref() == &25);
+ e_orig.set(new_e);
+ }
+ _ => unreachable!(),
+ }
+
+ assert_eq!(e, Enum::Variant2(true));
+}
+
+#[test]
+fn where_clause() {
+ #[pin_project]
+ struct Struct<T>
+ where
+ T: Copy,
+ {
+ field: T,
+ }
+
+ #[pin_project]
+ struct TupleStruct<T>(T)
+ where
+ T: Copy;
+
+ #[pin_project]
+ enum EnumWhere<T>
+ where
+ T: Copy,
+ {
+ Variant(T),
+ }
+}
+
+#[test]
+fn where_clause_and_associated_type_field() {
+ #[pin_project(Replace)]
+ struct Struct1<I>
+ where
+ I: Iterator,
+ {
+ #[pin]
+ field1: I,
+ field2: I::Item,
+ }
+
+ #[pin_project(Replace)]
+ struct Struct2<I, J>
+ where
+ I: Iterator<Item = J>,
+ {
+ #[pin]
+ field1: I,
+ field2: J,
+ }
+
+ #[pin_project(Replace)]
+ struct Struct3<T>
+ where
+ T: 'static,
+ {
+ field: T,
+ }
+
+ trait Static: 'static {}
+
+ impl<T> Static for Struct3<T> {}
+
+ #[pin_project(Replace)]
+ struct TupleStruct<I>(#[pin] I, I::Item)
+ where
+ I: Iterator;
+
+ #[pin_project(Replace)]
+ enum Enum<I>
+ where
+ I: Iterator,
+ {
+ Variant1(#[pin] I),
+ Variant2(I::Item),
+ }
+}
+
+#[test]
+fn derive_copy() {
+ #[pin_project(Replace)]
+ #[derive(Clone, Copy)]
+ struct Struct<T> {
+ val: T,
+ }
+
+ fn is_copy<T: Copy>() {}
+
+ is_copy::<Struct<u8>>();
+}
+
+#[test]
+fn move_out() {
+ struct NotCopy;
+
+ #[pin_project(Replace)]
+ struct Struct {
+ val: NotCopy,
+ }
+
+ let x = Struct { val: NotCopy };
+ let _val: NotCopy = x.val;
+
+ #[pin_project(Replace)]
+ enum Enum {
+ Variant(NotCopy),
+ }
+
+ let x = Enum::Variant(NotCopy);
+ #[allow(clippy::infallible_destructuring_match)]
+ let _val: NotCopy = match x {
+ Enum::Variant(val) => val,
+ };
+}
+
+#[test]
+fn trait_bounds_on_type_generics() {
+ #[pin_project(Replace)]
+ pub struct Struct1<'a, T: ?Sized> {
+ field: &'a mut T,
+ }
+
+ #[pin_project(Replace)]
+ pub struct Struct2<'a, T: ::core::fmt::Debug> {
+ field: &'a mut T,
+ }
+
+ #[pin_project(Replace)]
+ pub struct Struct3<'a, T: core::fmt::Debug> {
+ field: &'a mut T,
+ }
+
+ #[pin_project(Replace)]
+ pub struct Struct4<'a, T: core::fmt::Debug + core::fmt::Display> {
+ field: &'a mut T,
+ }
+
+ #[pin_project(Replace)]
+ pub struct Struct5<'a, T: core::fmt::Debug + ?Sized> {
+ field: &'a mut T,
+ }
+
+ #[pin_project(Replace)]
+ pub struct Struct6<'a, T: core::fmt::Debug = [u8; 16]> {
+ field: &'a mut T,
+ }
+
+ let _: Struct6<'_> = Struct6 { field: &mut [0u8; 16] };
+
+ #[pin_project(Replace)]
+ pub struct Struct7<T: 'static> {
+ field: T,
+ }
+
+ trait Static: 'static {}
+
+ impl<T> Static for Struct7<T> {}
+
+ #[pin_project(Replace)]
+ pub struct Struct8<'a, 'b: 'a> {
+ field1: &'a u8,
+ field2: &'b u8,
+ }
+
+ #[pin_project(Replace)]
+ pub struct TupleStruct<'a, T: ?Sized>(&'a mut T);
+
+ #[pin_project(Replace)]
+ enum Enum<'a, T: ?Sized> {
+ Variant(&'a mut T),
+ }
+}
+
+#[test]
+fn overlapping_lifetime_names() {
+ #[pin_project(Replace)]
+ pub struct Struct1<'pin, T> {
+ #[pin]
+ field: &'pin mut T,
+ }
+
+ #[pin_project(Replace)]
+ pub struct Struct2<'pin, 'pin_, 'pin__> {
+ #[pin]
+ field: &'pin &'pin_ &'pin__ (),
+ }
+
+ pub trait A<'a> {}
+
+ #[allow(single_use_lifetimes)] // https://github.com/rust-lang/rust/issues/55058
+ #[pin_project(Replace)]
+ pub struct HRTB<'pin___, T>
+ where
+ for<'pin> &'pin T: Unpin,
+ T: for<'pin> A<'pin>,
+ for<'pin, 'pin_, 'pin__> &'pin &'pin_ &'pin__ T: Unpin,
+ {
+ #[pin]
+ field: &'pin___ mut T,
+ }
+}
+
+#[test]
+fn combine() {
+ #[pin_project(PinnedDrop, UnsafeUnpin)]
+ pub struct Struct1<T> {
+ #[pin]
+ field: T,
+ }
+
+ #[pinned_drop]
+ impl<T> PinnedDrop for Struct1<T> {
+ fn drop(self: Pin<&mut Self>) {}
+ }
+
+ unsafe impl<T: Unpin> UnsafeUnpin for Struct1<T> {}
+
+ #[pin_project(UnsafeUnpin, Replace)]
+ pub struct Struct2<T> {
+ #[pin]
+ field: T,
+ }
+
+ unsafe impl<T: Unpin> UnsafeUnpin for Struct2<T> {}
+
+ #[pin_project(PinnedDrop, !Unpin)]
+ pub struct Struct3<T> {
+ #[pin]
+ field: T,
+ }
+
+ #[pinned_drop]
+ impl<T> PinnedDrop for Struct3<T> {
+ fn drop(self: Pin<&mut Self>) {}
+ }
+
+ #[pin_project(!Unpin, Replace)]
+ pub struct Struct4<T> {
+ #[pin]
+ field: T,
+ }
+}
+
+#[test]
+fn private_type_in_public_type() {
+ #[pin_project(Replace)]
+ pub struct PublicStruct<T> {
+ #[pin]
+ inner: PrivateStruct<T>,
+ }
+
+ struct PrivateStruct<T>(T);
+}
+
+#[test]
+fn lifetime_project() {
+ #[pin_project(Replace)]
+ struct Struct1<T, U> {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+ }
+
+ #[pin_project(Replace)]
+ struct Struct2<'a, T, U> {
+ #[pin]
+ pinned: &'a mut T,
+ unpinned: U,
+ }
+
+ #[pin_project(Replace)]
+ enum Enum<T, U> {
+ Variant {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+ },
+ }
+
+ impl<T, U> Struct1<T, U> {
+ fn get_pin_ref<'a>(self: Pin<&'a Self>) -> Pin<&'a T> {
+ self.project_ref().pinned
+ }
+ fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut T> {
+ self.project().pinned
+ }
+ }
+
+ impl<'b, T, U> Struct2<'b, T, U> {
+ fn get_pin_ref<'a>(self: Pin<&'a Self>) -> Pin<&'a &'b mut T> {
+ self.project_ref().pinned
+ }
+ fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut &'b mut T> {
+ self.project().pinned
+ }
+ }
+
+ impl<T, U> Enum<T, U> {
+ fn get_pin_ref<'a>(self: Pin<&'a Self>) -> Pin<&'a T> {
+ match self.project_ref() {
+ __EnumProjectionRef::Variant { pinned, .. } => pinned,
+ }
+ }
+ fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut T> {
+ match self.project() {
+ __EnumProjection::Variant { pinned, .. } => pinned,
+ }
+ }
+ }
+}
+
+#[rustversion::since(1.36)] // https://github.com/rust-lang/rust/pull/61207
+#[test]
+fn lifetime_project_elided() {
+ #[pin_project(Replace)]
+ struct Struct1<T, U> {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+ }
+
+ #[pin_project(Replace)]
+ struct Struct2<'a, T, U> {
+ #[pin]
+ pinned: &'a mut T,
+ unpinned: U,
+ }
+
+ #[pin_project(Replace)]
+ enum Enum<T, U> {
+ Variant {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+ },
+ }
+
+ impl<T, U> Struct1<T, U> {
+ fn get_pin_ref(self: Pin<&Self>) -> Pin<&T> {
+ self.project_ref().pinned
+ }
+ fn get_pin_mut(self: Pin<&mut Self>) -> Pin<&mut T> {
+ self.project().pinned
+ }
+ }
+
+ impl<'b, T, U> Struct2<'b, T, U> {
+ fn get_pin_ref(self: Pin<&Self>) -> Pin<&&'b mut T> {
+ self.project_ref().pinned
+ }
+ fn get_pin_mut(self: Pin<&mut Self>) -> Pin<&mut &'b mut T> {
+ self.project().pinned
+ }
+ }
+
+ impl<T, U> Enum<T, U> {
+ fn get_pin_ref(self: Pin<&Self>) -> Pin<&T> {
+ match self.project_ref() {
+ __EnumProjectionRef::Variant { pinned, .. } => pinned,
+ }
+ }
+ fn get_pin_mut(self: Pin<&mut Self>) -> Pin<&mut T> {
+ match self.project() {
+ __EnumProjection::Variant { pinned, .. } => pinned,
+ }
+ }
+ }
+}
+
+mod visibility {
+ use pin_project::pin_project;
+
+ #[pin_project(Replace)]
+ pub(crate) struct A {
+ pub b: u8,
+ }
+}
+
+#[test]
+fn visibility() {
+ let mut x = visibility::A { b: 0 };
+ let x = Pin::new(&mut x);
+ let y = x.as_ref().project_ref();
+ let _: &u8 = y.b;
+ let y = x.project();
+ let _: &mut u8 = y.b;
+}
+
+#[test]
+fn trivial_bounds() {
+ #[pin_project(Replace)]
+ pub struct NoGenerics {
+ #[pin]
+ field: PhantomPinned,
+ }
+}
+
+#[test]
+fn dst() {
+ #[pin_project]
+ struct Struct1<T: ?Sized> {
+ x: T,
+ }
+
+ let mut x = Struct1 { x: 0_u8 };
+ let x: Pin<&mut Struct1<dyn core::fmt::Debug>> = Pin::new(&mut x as _);
+ let _y: &mut (dyn core::fmt::Debug) = x.project().x;
+
+ #[pin_project]
+ struct Struct2<T: ?Sized> {
+ #[pin]
+ x: T,
+ }
+
+ let mut x = Struct2 { x: 0_u8 };
+ let x: Pin<&mut Struct2<dyn core::fmt::Debug + Unpin>> = Pin::new(&mut x as _);
+ let _y: Pin<&mut (dyn core::fmt::Debug + Unpin)> = x.project().x;
+
+ #[pin_project(UnsafeUnpin)]
+ struct Struct5<T: ?Sized> {
+ x: T,
+ }
+
+ #[pin_project(UnsafeUnpin)]
+ struct Struct6<T: ?Sized> {
+ #[pin]
+ x: T,
+ }
+
+ #[pin_project(PinnedDrop)]
+ struct Struct7<T: ?Sized> {
+ x: T,
+ }
+
+ #[pinned_drop]
+ impl<T: ?Sized> PinnedDrop for Struct7<T> {
+ fn drop(self: Pin<&mut Self>) {}
+ }
+
+ #[pin_project(PinnedDrop)]
+ struct Struct8<T: ?Sized> {
+ #[pin]
+ x: T,
+ }
+
+ #[pinned_drop]
+ impl<T: ?Sized> PinnedDrop for Struct8<T> {
+ fn drop(self: Pin<&mut Self>) {}
+ }
+
+ #[pin_project(!Unpin)]
+ struct Struct9<T: ?Sized> {
+ x: T,
+ }
+
+ #[pin_project(!Unpin)]
+ struct Struct10<T: ?Sized> {
+ #[pin]
+ x: T,
+ }
+
+ #[pin_project]
+ struct TupleStruct1<T: ?Sized>(T);
+
+ #[pin_project]
+ struct TupleStruct2<T: ?Sized>(#[pin] T);
+
+ #[pin_project(UnsafeUnpin)]
+ struct TupleStruct5<T: ?Sized>(T);
+
+ #[pin_project(UnsafeUnpin)]
+ struct TupleStruct6<T: ?Sized>(#[pin] T);
+
+ #[pin_project(PinnedDrop)]
+ struct TupleStruct7<T: ?Sized>(T);
+
+ #[pinned_drop]
+ impl<T: ?Sized> PinnedDrop for TupleStruct7<T> {
+ fn drop(self: Pin<&mut Self>) {}
+ }
+
+ #[pin_project(PinnedDrop)]
+ struct TupleStruct8<T: ?Sized>(#[pin] T);
+
+ #[pinned_drop]
+ impl<T: ?Sized> PinnedDrop for TupleStruct8<T> {
+ fn drop(self: Pin<&mut Self>) {}
+ }
+
+ #[pin_project(!Unpin)]
+ struct TupleStruct9<T: ?Sized>(T);
+
+ #[pin_project(!Unpin)]
+ struct TupleStruct10<T: ?Sized>(#[pin] T);
+}
+
+#[allow(explicit_outlives_requirements)] // https://github.com/rust-lang/rust/issues/60993
+#[test]
+fn unsized_in_where_clause() {
+ #[pin_project]
+ struct Struct3<T>
+ where
+ T: ?Sized,
+ {
+ x: T,
+ }
+
+ #[pin_project]
+ struct Struct4<T>
+ where
+ T: ?Sized,
+ {
+ #[pin]
+ x: T,
+ }
+
+ #[pin_project]
+ struct TupleStruct3<T>(T)
+ where
+ T: ?Sized;
+
+ #[pin_project]
+ struct TupleStruct4<T>(#[pin] T)
+ where
+ T: ?Sized;
+}
+
+#[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);
+}
+
+#[test]
+fn self_in_where_clause() {
+ pub trait Trait1 {}
+
+ #[pin_project(Replace)]
+ pub struct Struct1<T>
+ where
+ Self: Trait1,
+ {
+ x: T,
+ }
+
+ impl<T> Trait1 for Struct1<T> {}
+
+ pub trait Trait2 {
+ type Assoc;
+ }
+
+ #[pin_project(Replace)]
+ pub struct Struct2<T>
+ where
+ Self: Trait2<Assoc = Struct1<T>>,
+ <Self as Trait2>::Assoc: Trait1,
+ {
+ x: T,
+ }
+
+ impl<T> Trait2 for Struct2<T> {
+ type Assoc = Struct1<T>;
+ }
+}
+
+#[test]
+fn no_infer_outlives() {
+ trait Bar<X> {
+ type Y;
+ }
+
+ struct Example<A>(A);
+
+ impl<X, T> Bar<X> for Example<T> {
+ type Y = Option<T>;
+ }
+
+ #[pin_project(Replace)]
+ struct Foo<A, B> {
+ _x: <Example<A> as Bar<B>>::Y,
+ }
+}
+
+// https://github.com/rust-lang/rust/issues/47949
+// https://github.com/taiki-e/pin-project/pull/194#discussion_r419098111
+#[test]
+fn project_replace_panic() {
+ use std::panic;
+
+ #[pin_project(Replace)]
+ struct S<T, U> {
+ #[pin]
+ pinned: T,
+ unpinned: U,
+ }
+
+ struct D<'a>(&'a mut bool, bool);
+ impl Drop for D<'_> {
+ fn drop(&mut self) {
+ *self.0 = true;
+ if self.1 {
+ panic!()
+ }
+ }
+ }
+
+ let (mut a, mut b, mut c, mut d) = (false, false, false, false);
+ let res = panic::catch_unwind(panic::AssertUnwindSafe(|| {
+ let mut x = S { pinned: D(&mut a, true), unpinned: D(&mut b, false) };
+ let _y = Pin::new(&mut x)
+ .project_replace(S { pinned: D(&mut c, false), unpinned: D(&mut d, false) });
+ // Previous `x.pinned` was dropped and panicked when `project_replace` is called, so this is unreachable.
+ unreachable!();
+ }));
+ assert!(res.is_err());
+ assert!(a);
+ assert!(b);
+ assert!(c);
+ assert!(d);
+
+ let (mut a, mut b, mut c, mut d) = (false, false, false, false);
+ let res = panic::catch_unwind(panic::AssertUnwindSafe(|| {
+ let mut x = S { pinned: D(&mut a, false), unpinned: D(&mut b, true) };
+ {
+ let _y = Pin::new(&mut x)
+ .project_replace(S { pinned: D(&mut c, false), unpinned: D(&mut d, false) });
+ // `_y` (previous `x.unpinned`) live to the end of this scope, so this is not unreachable,
+ // unreachable!();
+ }
+ unreachable!();
+ }));
+ assert!(res.is_err());
+ assert!(a);
+ assert!(b);
+ assert!(c);
+ assert!(d);
+}
diff --git a/tests/pinned_drop.rs b/tests/pinned_drop.rs
new file mode 100644
index 0000000..b0677e2
--- /dev/null
+++ b/tests/pinned_drop.rs
@@ -0,0 +1,235 @@
+#![warn(rust_2018_idioms, single_use_lifetimes)]
+#![allow(dead_code)]
+
+use pin_project::{pin_project, pinned_drop};
+use std::pin::Pin;
+
+#[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 mut_self_argument() {
+ #[pin_project(PinnedDrop)]
+ struct Struct {
+ data: usize,
+ }
+
+ #[pinned_drop]
+ impl PinnedDrop for Struct {
+ fn drop(mut self: Pin<&mut Self>) {
+ let _: &mut _ = &mut self.data;
+ }
+ }
+}
+
+#[test]
+fn self_in_vec() {
+ #[pin_project(PinnedDrop)]
+ struct Struct {
+ data: usize,
+ }
+
+ #[pinned_drop]
+ impl PinnedDrop for Struct {
+ fn drop(self: Pin<&mut Self>) {
+ let _: Vec<_> = vec![self.data];
+ }
+ }
+}
+
+#[test]
+fn self_in_macro_containing_fn() {
+ #[pin_project(PinnedDrop)]
+ pub struct Struct {
+ data: usize,
+ }
+
+ macro_rules! emit {
+ ($($tt:tt)*) => {
+ $($tt)*
+ };
+ }
+
+ #[pinned_drop]
+ impl PinnedDrop for Struct {
+ fn drop(self: Pin<&mut Self>) {
+ let _ = emit!({
+ impl Struct {
+ pub fn f(self) {}
+ }
+ });
+ let _ = self.data;
+ }
+ }
+}
+
+#[test]
+fn self_call() {
+ #[pin_project(PinnedDrop)]
+ pub struct Struct {
+ data: usize,
+ }
+
+ 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 Struct {}
+
+ #[pinned_drop]
+ impl PinnedDrop for Struct {
+ fn drop(mut self: Pin<&mut Self>) {
+ self.self_ref();
+ self.as_ref().self_pin_ref();
+ self.self_mut();
+ self.as_mut().self_pin_mut();
+ Self::assoc_fn(self.as_mut());
+ <Self>::assoc_fn(self.as_mut());
+ }
+ }
+}
+
+#[test]
+fn self_expr() {
+ #[pin_project(PinnedDrop)]
+ pub struct Struct {
+ x: usize,
+ }
+
+ #[pinned_drop]
+ impl PinnedDrop for Struct {
+ fn drop(mut self: Pin<&mut Self>) {
+ let _: Self = Self { x: 0 };
+ }
+ }
+
+ #[pin_project(PinnedDrop)]
+ pub struct TupleStruct(usize);
+
+ #[pinned_drop]
+ impl PinnedDrop for TupleStruct {
+ fn drop(mut self: Pin<&mut Self>) {
+ let _: Self = Self(0);
+ }
+ }
+}
+
+#[rustversion::since(1.37)]
+#[test]
+fn self_expr_enum() {
+ #[pin_project(PinnedDrop)]
+ pub enum Enum {
+ StructVariant { x: usize },
+ TupleVariant(usize),
+ }
+
+ #[pinned_drop]
+ impl PinnedDrop for Enum {
+ fn drop(mut self: Pin<&mut Self>) {
+ let _: Self = Self::StructVariant { x: 0 };
+ let _: Self = Self::TupleVariant(0);
+ }
+ }
+}
+
+#[test]
+fn self_pat() {
+ #[pin_project(PinnedDrop)]
+ pub struct Struct {
+ x: usize,
+ }
+
+ #[pinned_drop]
+ impl PinnedDrop for Struct {
+ #[allow(irrefutable_let_patterns)]
+ #[allow(clippy::match_single_binding)]
+ fn drop(mut self: Pin<&mut Self>) {
+ match *self {
+ Self { x: _ } => {}
+ }
+ if let Self { x: _ } = *self {}
+ let Self { x: _ } = *self;
+ }
+ }
+
+ #[pin_project(PinnedDrop)]
+ pub struct TupleStruct(usize);
+
+ #[pinned_drop]
+ impl PinnedDrop for TupleStruct {
+ #[allow(irrefutable_let_patterns)]
+ fn drop(mut self: Pin<&mut Self>) {
+ match *self {
+ Self(_) => {}
+ }
+ if let Self(_) = *self {}
+ let Self(_) = *self;
+ }
+ }
+}
+
+#[rustversion::since(1.37)]
+#[test]
+fn self_pat_enum() {
+ #[pin_project(PinnedDrop)]
+ pub enum Enum {
+ StructVariant { x: usize },
+ TupleVariant(usize),
+ }
+
+ #[pinned_drop]
+ impl PinnedDrop for Enum {
+ fn drop(mut self: Pin<&mut Self>) {
+ match *self {
+ Self::StructVariant { x: _ } => {}
+ Self::TupleVariant(_) => {}
+ }
+ if let Self::StructVariant { x: _ } = *self {}
+ if let Self::TupleVariant(_) = *self {}
+ }
+ }
+}
+
+// See also `ui/pinned_drop/self.rs`.
+#[rustversion::since(1.40)] // https://github.com/rust-lang/rust/pull/64690
+#[test]
+fn self_in_macro_def() {
+ #[pin_project(PinnedDrop)]
+ pub struct Struct {
+ x: usize,
+ }
+
+ #[pinned_drop]
+ impl PinnedDrop for Struct {
+ fn drop(self: Pin<&mut Self>) {
+ macro_rules! t {
+ () => {{
+ let _ = self;
+ }};
+ }
+ t!();
+ }
+ }
+}
diff --git a/tests/project.rs b/tests/project.rs
new file mode 100644
index 0000000..a0f8b07
--- /dev/null
+++ b/tests/project.rs
@@ -0,0 +1,297 @@
+#![warn(rust_2018_idioms, single_use_lifetimes)]
+#![allow(dead_code)]
+
+// Ceurrently, `#[attr] if true {}` doesn't even *parse* on MSRV,
+// which means that it will error even behind a `#[rustversion::since(..)]`
+//
+// This trick makes sure that we don't even attempt to parse
+// the `#[project] if let _` test on MSRV.
+#[rustversion::since(1.43)]
+include!("project_if_attr.rs.in");
+
+use pin_project::{pin_project, project, project_ref, project_replace};
+use std::pin::Pin;
+
+#[project] // Nightly does not need a dummy attribute to the function.
+#[test]
+fn project_stmt_expr() {
+ #[pin_project]
+ struct Struct<T, U> {
+ #[pin]
+ field1: T,
+ field2: U,
+ }
+
+ let mut s = Struct { field1: 1, field2: 2 };
+
+ #[project]
+ let Struct { field1, field2 } = Pin::new(&mut s).project();
+
+ let x: Pin<&mut i32> = field1;
+ assert_eq!(*x, 1);
+
+ let y: &mut i32 = field2;
+ assert_eq!(*y, 2);
+
+ #[pin_project]
+ struct TupleStruct<T, U>(#[pin] T, U);
+
+ let mut s = TupleStruct(1, 2);
+
+ #[project]
+ let TupleStruct(x, y) = Pin::new(&mut s).project();
+
+ let x: Pin<&mut i32> = x;
+ assert_eq!(*x, 1);
+
+ let y: &mut i32 = y;
+ assert_eq!(*y, 2);
+
+ #[pin_project]
+ enum Enum<A, B, C, D> {
+ Variant1(#[pin] A, B),
+ Variant2 {
+ #[pin]
+ field1: C,
+ field2: D,
+ },
+ None,
+ }
+
+ let mut e = Enum::Variant1(1, 2);
+
+ let mut e = Pin::new(&mut e).project();
+
+ #[project]
+ match &mut e {
+ Enum::Variant1(x, y) => {
+ let x: &mut Pin<&mut i32> = x;
+ assert_eq!(**x, 1);
+
+ let y: &mut &mut i32 = y;
+ assert_eq!(**y, 2);
+ }
+ Enum::Variant2 { field1, field2 } => {
+ let _x: &mut Pin<&mut i32> = field1;
+ let _y: &mut &mut i32 = field2;
+ }
+ Enum::None => {}
+ }
+
+ #[project]
+ let val = match &mut e {
+ Enum::Variant1(_, _) => true,
+ Enum::Variant2 { .. } => false,
+ Enum::None => false,
+ };
+ assert_eq!(val, true);
+}
+
+#[test]
+fn project_impl() {
+ #[pin_project]
+ struct HasGenerics<T, U> {
+ #[pin]
+ field1: T,
+ field2: U,
+ }
+
+ #[project]
+ impl<T, U> HasGenerics<T, U> {
+ fn a(self) {
+ let Self { field1, field2 } = self;
+
+ let _x: Pin<&mut T> = field1;
+ let _y: &mut U = field2;
+ }
+ }
+
+ #[pin_project]
+ struct NoneGenerics {
+ #[pin]
+ field1: i32,
+ field2: u32,
+ }
+
+ #[project]
+ impl NoneGenerics {}
+
+ #[pin_project]
+ struct HasLifetimes<'a, T, U> {
+ #[pin]
+ field1: &'a mut T,
+ field2: U,
+ }
+
+ #[project]
+ impl<T, U> HasLifetimes<'_, T, U> {}
+
+ #[pin_project]
+ struct HasOverlappingLifetimes<'pin, T, U> {
+ #[pin]
+ field1: &'pin mut T,
+ field2: U,
+ }
+
+ #[allow(single_use_lifetimes)]
+ #[project]
+ impl<'pin, T, U> HasOverlappingLifetimes<'pin, T, U> {}
+
+ #[pin_project]
+ struct HasOverlappingLifetimes2<T, U> {
+ #[pin]
+ field1: T,
+ field2: U,
+ }
+
+ #[allow(single_use_lifetimes)]
+ #[allow(clippy::needless_lifetimes)]
+ #[project]
+ impl<T, U> HasOverlappingLifetimes2<T, U> {
+ fn foo<'pin>(&'pin self) {}
+ }
+}
+
+#[pin_project]
+struct A {
+ #[pin]
+ field: u8,
+}
+
+mod project_use_1 {
+ use crate::A;
+ use core::pin::Pin;
+ use pin_project::project;
+
+ #[project]
+ use crate::A;
+
+ #[project]
+ #[test]
+ fn project_use() {
+ let mut x = A { field: 0 };
+ #[project]
+ let A { field } = Pin::new(&mut x).project();
+ let _: Pin<&mut u8> = field;
+ }
+}
+
+mod project_use_2 {
+ #[project]
+ use crate::A;
+ use pin_project::project;
+
+ #[project]
+ impl A {
+ fn project_use(self) {}
+ }
+}
+
+#[allow(clippy::unnecessary_operation, clippy::unit_arg)]
+#[test]
+#[project]
+fn non_stmt_expr_match() {
+ #[pin_project]
+ enum Enum<A> {
+ Variant(#[pin] A),
+ }
+
+ let mut x = Enum::Variant(1);
+ let x = Pin::new(&mut x).project();
+
+ Some(
+ #[project]
+ match x {
+ Enum::Variant(_x) => {}
+ },
+ );
+}
+
+// https://github.com/taiki-e/pin-project/issues/206
+#[allow(clippy::unnecessary_operation, clippy::unit_arg)]
+#[test]
+#[project]
+fn issue_206() {
+ #[pin_project]
+ enum Enum<A> {
+ Variant(#[pin] A),
+ }
+
+ let mut x = Enum::Variant(1);
+ let x = Pin::new(&mut x).project();
+
+ Some({
+ #[project]
+ match &x {
+ Enum::Variant(_) => {}
+ }
+ });
+
+ #[allow(clippy::never_loop)]
+ loop {
+ let _ = {
+ #[project]
+ match &x {
+ Enum::Variant(_) => {}
+ }
+ };
+ break;
+ }
+}
+
+#[project]
+#[test]
+fn combine() {
+ #[pin_project(Replace)]
+ enum Enum<A> {
+ V1(#[pin] A),
+ V2,
+ }
+
+ let mut x = Enum::V1(1);
+ #[project]
+ match Pin::new(&mut x).project() {
+ Enum::V1(_) => {}
+ Enum::V2 => unreachable!(),
+ }
+ #[project_ref]
+ match Pin::new(&x).project_ref() {
+ Enum::V1(_) => {}
+ Enum::V2 => unreachable!(),
+ }
+ #[project_replace]
+ match Pin::new(&mut x).project_replace(Enum::V2) {
+ Enum::V1(_) => {}
+ Enum::V2 => unreachable!(),
+ }
+}
+
+// FIXME: This should be denied, but allowed for compatibility at this time.
+#[project]
+#[project_ref]
+#[project_replace]
+#[test]
+fn combine_compat() {
+ #[pin_project(Replace)]
+ enum Enum<A> {
+ V1(#[pin] A),
+ V2,
+ }
+
+ let mut x = Enum::V1(1);
+ #[project]
+ match Pin::new(&mut x).project() {
+ Enum::V1(_) => {}
+ Enum::V2 => unreachable!(),
+ }
+ #[project_ref]
+ match Pin::new(&x).project_ref() {
+ Enum::V1(_) => {}
+ Enum::V2 => unreachable!(),
+ }
+ #[project_replace]
+ match Pin::new(&mut x).project_replace(Enum::V2) {
+ Enum::V1(_) => {}
+ Enum::V2 => unreachable!(),
+ }
+}
diff --git a/tests/project_if_attr.rs.in b/tests/project_if_attr.rs.in
new file mode 100644
index 0000000..a8ceeac
--- /dev/null
+++ b/tests/project_if_attr.rs.in
@@ -0,0 +1,44 @@
+#[test]
+#[project]
+fn project_if_let() {
+ #[pin_project]
+ enum Foo<A, B> {
+ Variant1(#[pin] A),
+ Variant2(u8),
+ Variant3 {
+ #[pin] field: B
+ }
+ }
+
+ let mut x: Foo<bool, f32> = Foo::Variant1(true);
+ let x = Pin::new(&mut x).project();
+
+ #[project]
+ if let Foo::Variant1(a) = x {
+ let a: Pin<&mut bool> = a;
+ assert_eq!(*a, true);
+ } else if let Foo::Variant2(_) = x {
+ unreachable!();
+ } else if let Foo::Variant3 { .. } = x {
+ unreachable!();
+ }
+}
+
+#[allow(clippy::unnecessary_operation, clippy::unit_arg)]
+#[test]
+#[project]
+fn non_stmt_expr_if_let() {
+ #[pin_project]
+ enum Enum<A> {
+ Variant(#[pin] A),
+ }
+
+ let mut x = Enum::Variant(1);
+ let x = Pin::new(&mut x).project();
+
+ #[allow(irrefutable_let_patterns)]
+ Some(
+ #[project]
+ if let Enum::Variant(_x) = x {},
+ );
+}
diff --git a/tests/project_ref.rs b/tests/project_ref.rs
new file mode 100644
index 0000000..e38ef83
--- /dev/null
+++ b/tests/project_ref.rs
@@ -0,0 +1,174 @@
+#![warn(rust_2018_idioms, single_use_lifetimes)]
+#![allow(dead_code)]
+
+use pin_project::{pin_project, project_ref};
+use std::pin::Pin;
+
+#[project_ref] // Nightly does not need a dummy attribute to the function.
+#[test]
+fn project_stmt_expr() {
+ #[pin_project]
+ struct Struct<T, U> {
+ #[pin]
+ field1: T,
+ field2: U,
+ }
+
+ let s = Struct { field1: 1, field2: 2 };
+
+ #[project_ref]
+ let Struct { field1, field2 } = Pin::new(&s).project_ref();
+
+ let x: Pin<&i32> = field1;
+ assert_eq!(*x, 1);
+
+ let y: &i32 = field2;
+ assert_eq!(*y, 2);
+
+ // tuple struct
+
+ #[pin_project]
+ struct TupleStruct<T, U>(#[pin] T, U);
+
+ let s = TupleStruct(1, 2);
+
+ #[project_ref]
+ let TupleStruct(x, y) = Pin::new(&s).project_ref();
+
+ let x: Pin<&i32> = x;
+ assert_eq!(*x, 1);
+
+ let y: &i32 = y;
+ assert_eq!(*y, 2);
+
+ #[pin_project]
+ enum Enum<A, B, C, D> {
+ Variant1(#[pin] A, B),
+ Variant2 {
+ #[pin]
+ field1: C,
+ field2: D,
+ },
+ None,
+ }
+
+ let e = Enum::Variant1(1, 2);
+
+ let e = Pin::new(&e).project_ref();
+
+ #[project_ref]
+ match &e {
+ Enum::Variant1(x, y) => {
+ let x: &Pin<&i32> = x;
+ assert_eq!(**x, 1);
+
+ let y: &&i32 = y;
+ assert_eq!(**y, 2);
+ }
+ Enum::Variant2 { field1, field2 } => {
+ let _x: &Pin<&i32> = field1;
+ let _y: &&i32 = field2;
+ }
+ Enum::None => {}
+ }
+
+ #[project_ref]
+ let val = match &e {
+ Enum::Variant1(_, _) => true,
+ Enum::Variant2 { .. } => false,
+ Enum::None => false,
+ };
+ assert_eq!(val, true);
+}
+
+#[test]
+fn project_impl() {
+ #[pin_project]
+ struct HasGenerics<T, U> {
+ #[pin]
+ field1: T,
+ field2: U,
+ }
+
+ #[project_ref]
+ impl<T, U> HasGenerics<T, U> {
+ fn a(self) {
+ let Self { field1, field2 } = self;
+
+ let _x: Pin<&T> = field1;
+ let _y: &U = field2;
+ }
+ }
+
+ #[pin_project]
+ struct NoneGenerics {
+ #[pin]
+ field1: i32,
+ field2: u32,
+ }
+
+ #[project_ref]
+ impl NoneGenerics {}
+
+ #[pin_project]
+ struct HasLifetimes<'a, T, U> {
+ #[pin]
+ field1: &'a mut T,
+ field2: U,
+ }
+
+ #[project_ref]
+ impl<T, U> HasLifetimes<'_, T, U> {}
+
+ #[pin_project]
+ struct HasOverlappingLifetimes<'pin, T, U> {
+ #[pin]
+ field1: &'pin mut T,
+ field2: U,
+ }
+
+ #[allow(single_use_lifetimes)]
+ #[project_ref]
+ impl<'pin, T, U> HasOverlappingLifetimes<'pin, T, U> {}
+
+ #[pin_project]
+ struct HasOverlappingLifetimes2<T, U> {
+ #[pin]
+ field1: T,
+ field2: U,
+ }
+
+ #[allow(single_use_lifetimes)]
+ #[allow(clippy::needless_lifetimes)]
+ #[project_ref]
+ impl<T, U> HasOverlappingLifetimes2<T, U> {
+ fn foo<'pin>(&'pin self) {}
+ }
+}
+
+#[project_ref]
+#[test]
+fn combine() {
+ #[pin_project(Replace)]
+ enum Enum<A> {
+ V1(#[pin] A),
+ V2,
+ }
+
+ let mut x = Enum::V1(1);
+ #[project]
+ match Pin::new(&mut x).project() {
+ Enum::V1(_) => {}
+ Enum::V2 => unreachable!(),
+ }
+ #[project_ref]
+ match Pin::new(&x).project_ref() {
+ Enum::V1(_) => {}
+ Enum::V2 => unreachable!(),
+ }
+ #[project_replace]
+ match Pin::new(&mut x).project_replace(Enum::V2) {
+ Enum::V1(_) => {}
+ Enum::V2 => unreachable!(),
+ }
+}
diff --git a/tests/project_replace.rs b/tests/project_replace.rs
new file mode 100644
index 0000000..9c8a5ab
--- /dev/null
+++ b/tests/project_replace.rs
@@ -0,0 +1,98 @@
+#![warn(rust_2018_idioms, single_use_lifetimes)]
+#![allow(dead_code)]
+
+use pin_project::{pin_project, project_replace};
+use std::{marker::PhantomData, pin::Pin};
+
+#[project_replace] // Nightly does not need a dummy attribute to the function.
+#[test]
+fn project_replace_stmt_expr() {
+ #[pin_project(Replace)]
+ struct Struct<T, U> {
+ #[pin]
+ field1: T,
+ field2: U,
+ }
+
+ let mut s = Struct { field1: 1, field2: 2 };
+
+ #[project_replace]
+ let Struct { field1, field2 } =
+ Pin::new(&mut s).project_replace(Struct { field1: 42, field2: 43 });
+
+ let _x: PhantomData<i32> = field1;
+
+ let y: i32 = field2;
+ assert_eq!(y, 2);
+
+ // tuple struct
+
+ #[pin_project(Replace)]
+ struct TupleStruct<T, U>(#[pin] T, U);
+
+ let mut s = TupleStruct(1, 2);
+
+ #[project_replace]
+ let TupleStruct(x, y) = Pin::new(&mut s).project_replace(TupleStruct(42, 43));
+
+ let _x: PhantomData<i32> = x;
+ let y: i32 = y;
+ assert_eq!(y, 2);
+
+ #[pin_project(Replace)]
+ enum Enum<A, B, C, D> {
+ Variant1(#[pin] A, B),
+ Variant2 {
+ #[pin]
+ field1: C,
+ field2: D,
+ },
+ None,
+ }
+
+ let mut e = Enum::Variant1(1, 2);
+
+ let e = Pin::new(&mut e).project_replace(Enum::None);
+
+ #[project_replace]
+ match e {
+ Enum::Variant1(x, y) => {
+ let _x: PhantomData<i32> = x;
+ let y: i32 = y;
+ assert_eq!(y, 2);
+ }
+ Enum::Variant2 { field1, field2 } => {
+ let _x: PhantomData<i32> = field1;
+ let _y: i32 = field2;
+ panic!()
+ }
+ Enum::None => panic!(),
+ }
+}
+
+#[project_replace]
+#[test]
+fn combine() {
+ #[pin_project(Replace)]
+ enum Enum<A> {
+ V1(#[pin] A),
+ V2,
+ }
+
+ let mut x = Enum::V1(1);
+ #[project]
+ match Pin::new(&mut x).project() {
+ Enum::V1(_) => {}
+ Enum::V2 => unreachable!(),
+ }
+ #[project_ref]
+ match Pin::new(&x).project_ref() {
+ Enum::V1(_) => {}
+ Enum::V2 => unreachable!(),
+ }
+ #[project_replace]
+ match Pin::new(&mut x).project_replace(Enum::V2) {
+ Enum::V1(_) => {}
+ Enum::V2 => unreachable!(),
+ }
+}
diff --git a/tests/repr_packed.rs b/tests/repr_packed.rs
new file mode 100644
index 0000000..ca56959
--- /dev/null
+++ b/tests/repr_packed.rs
@@ -0,0 +1,50 @@
+#![warn(rust_2018_idioms, single_use_lifetimes)]
+#![allow(dead_code)]
+#![deny(safe_packed_borrows)]
+
+use std::cell::Cell;
+
+// Ensure that the compiler doesn't copy the fields
+// of #[repr(packed)] types during drop, if the field has alignment 1
+// (that is, any reference to the field is guaranteed to have proper alignment)
+// We are currently unable to statically prevent the usage of #[pin_project]
+// on #[repr(packed)] types composed entirely of fields of alignment 1.
+// This shouldn't lead to undefined behavior, as long as the compiler doesn't
+// try to move the field anyway during drop.
+//
+// This tests validates that the compiler is doing what we expect.
+#[test]
+fn weird_repr_packed() {
+ // We keep track of the field address during
+ // drop using a thread local, to avoid changing
+ // the layout of our #[repr(packed)] type.
+ thread_local! {
+ static FIELD_ADDR: Cell<usize> = Cell::new(0);
+ }
+
+ #[repr(packed)]
+ struct Foo {
+ field: u8,
+ }
+
+ impl Drop for Foo {
+ 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 = Foo { field: 27 };
+ let field_addr = &x.field as *const u8 as usize;
+ field_addr
+ };
+ assert_eq!(field_addr, FIELD_ADDR.with(|f| f.get()));
+}
diff --git a/tests/ui/cfg/cfg_attr-resolve.rs b/tests/ui/cfg/cfg_attr-resolve.rs
new file mode 100644
index 0000000..e16f3e8
--- /dev/null
+++ b/tests/ui/cfg/cfg_attr-resolve.rs
@@ -0,0 +1,11 @@
+use std::pin::Pin;
+
+#[cfg_attr(any(), pin_project::pin_project)]
+struct Foo<T> {
+ inner: T,
+}
+
+fn main() {
+ let mut x = Foo { inner: 0_u8 };
+ let _x = Pin::new(&mut x).project(); //~ ERROR E0599
+}
diff --git a/tests/ui/cfg/cfg_attr-resolve.stderr b/tests/ui/cfg/cfg_attr-resolve.stderr
new file mode 100644
index 0000000..45af3ae
--- /dev/null
+++ b/tests/ui/cfg/cfg_attr-resolve.stderr
@@ -0,0 +1,5 @@
+error[E0599]: no method named `project` found for struct `std::pin::Pin<&mut Foo<u8>>` in the current scope
+ --> $DIR/cfg_attr-resolve.rs:10:31
+ |
+10 | let _x = Pin::new(&mut x).project(); //~ ERROR E0599
+ | ^^^^^^^ method not found in `std::pin::Pin<&mut Foo<u8>>`
diff --git a/tests/ui/cfg/cfg_attr-type-mismatch.rs b/tests/ui/cfg/cfg_attr-type-mismatch.rs
new file mode 100644
index 0000000..2807c87
--- /dev/null
+++ b/tests/ui/cfg/cfg_attr-type-mismatch.rs
@@ -0,0 +1,24 @@
+use pin_project::pin_project;
+use std::pin::Pin;
+
+#[cfg_attr(not(any()), pin_project)]
+struct Foo<T> {
+ #[cfg_attr(any(), pin)]
+ inner: T,
+}
+
+#[cfg_attr(not(any()), pin_project)]
+struct Bar<T> {
+ #[cfg_attr(not(any()), pin)]
+ inner: T,
+}
+
+fn main() {
+ let mut x = Foo { inner: 0_u8 };
+ let x = Pin::new(&mut x).project();
+ let _: Pin<&mut u8> = x.inner; //~ ERROR E0308
+
+ let mut x = Bar { inner: 0_u8 };
+ let x = Pin::new(&mut x).project();
+ let _: &mut u8 = x.inner; //~ ERROR E0308
+}
diff --git a/tests/ui/cfg/cfg_attr-type-mismatch.stderr b/tests/ui/cfg/cfg_attr-type-mismatch.stderr
new file mode 100644
index 0000000..2868299
--- /dev/null
+++ b/tests/ui/cfg/cfg_attr-type-mismatch.stderr
@@ -0,0 +1,23 @@
+error[E0308]: mismatched types
+ --> $DIR/cfg_attr-type-mismatch.rs:19:27
+ |
+19 | let _: Pin<&mut u8> = x.inner; //~ ERROR E0308
+ | ------------ ^^^^^^^ expected struct `std::pin::Pin`, found `&mut u8`
+ | |
+ | expected due to this
+ |
+ = note: expected struct `std::pin::Pin<&mut u8>`
+ found mutable reference `&mut u8`
+
+error[E0308]: mismatched types
+ --> $DIR/cfg_attr-type-mismatch.rs:23:22
+ |
+23 | let _: &mut u8 = x.inner; //~ ERROR E0308
+ | ------- ^^^^^^^
+ | | |
+ | | expected `&mut u8`, found struct `std::pin::Pin`
+ | | help: consider mutably borrowing here: `&mut x.inner`
+ | expected due to this
+ |
+ = note: expected mutable reference `&mut u8`
+ found struct `std::pin::Pin<&mut u8>`
diff --git a/tests/ui/cfg/cfg_attr-unpin.rs b/tests/ui/cfg/cfg_attr-unpin.rs
new file mode 100644
index 0000000..7b88205
--- /dev/null
+++ b/tests/ui/cfg/cfg_attr-unpin.rs
@@ -0,0 +1,21 @@
+use pin_project::pin_project;
+use std::marker::PhantomPinned;
+
+#[cfg_attr(any(), pin_project)]
+struct Foo<T> {
+ inner: T,
+}
+
+#[cfg_attr(not(any()), pin_project)]
+struct Bar<T> {
+ #[cfg_attr(not(any()), pin)]
+ inner: T,
+}
+
+fn is_unpin<T: Unpin>() {}
+
+fn main() {
+ is_unpin::<Foo<PhantomPinned>>(); // ERROR E0277
+ is_unpin::<Bar<()>>(); // Ok
+ is_unpin::<Bar<PhantomPinned>>(); //~ ERROR E0277
+}
diff --git a/tests/ui/cfg/cfg_attr-unpin.stderr b/tests/ui/cfg/cfg_attr-unpin.stderr
new file mode 100644
index 0000000..ce31c24
--- /dev/null
+++ b/tests/ui/cfg/cfg_attr-unpin.stderr
@@ -0,0 +1,22 @@
+error[E0277]: `std::marker::PhantomPinned` cannot be unpinned
+ --> $DIR/cfg_attr-unpin.rs:18:5
+ |
+15 | fn is_unpin<T: Unpin>() {}
+ | ----- required by this bound in `is_unpin`
+...
+18 | is_unpin::<Foo<PhantomPinned>>(); // ERROR E0277
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ within `Foo<std::marker::PhantomPinned>`, the trait `std::marker::Unpin` is not implemented for `std::marker::PhantomPinned`
+ |
+ = note: required because it appears within the type `Foo<std::marker::PhantomPinned>`
+
+error[E0277]: `std::marker::PhantomPinned` cannot be unpinned
+ --> $DIR/cfg_attr-unpin.rs:20:5
+ |
+15 | fn is_unpin<T: Unpin>() {}
+ | ----- required by this bound in `is_unpin`
+...
+20 | is_unpin::<Bar<PhantomPinned>>(); //~ ERROR E0277
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ within `__SCOPE_Bar::__Bar<'_, std::marker::PhantomPinned>`, the trait `std::marker::Unpin` is not implemented for `std::marker::PhantomPinned`
+ |
+ = note: required because it appears within the type `__SCOPE_Bar::__Bar<'_, std::marker::PhantomPinned>`
+ = note: required because of the requirements on the impl of `std::marker::Unpin` for `Bar<std::marker::PhantomPinned>`
diff --git a/tests/ui/cfg/packed_sneaky-span-issue-1.rs b/tests/ui/cfg/packed_sneaky-span-issue-1.rs
new file mode 100644
index 0000000..3776dac
--- /dev/null
+++ b/tests/ui/cfg/packed_sneaky-span-issue-1.rs
@@ -0,0 +1,18 @@
+use auxiliary_macros::hidden_repr;
+use pin_project::pin_project;
+
+//~ ERROR may not be used on #[repr(packed)] types
+// span is lost.
+// Refs: https://github.com/rust-lang/rust/issues/43081
+#[pin_project]
+#[hidden_repr(packed)]
+struct Foo {
+ #[cfg(not(any()))]
+ #[pin]
+ field: u32,
+ #[cfg(any())]
+ #[pin]
+ field: u8,
+}
+
+fn main() {}
diff --git a/tests/ui/cfg/packed_sneaky-span-issue-1.stderr b/tests/ui/cfg/packed_sneaky-span-issue-1.stderr
new file mode 100644
index 0000000..f4d7dee
--- /dev/null
+++ b/tests/ui/cfg/packed_sneaky-span-issue-1.stderr
@@ -0,0 +1 @@
+error: #[pin_project] attribute may not be used on #[repr(packed)] types
diff --git a/tests/ui/cfg/packed_sneaky-span-issue-2.rs b/tests/ui/cfg/packed_sneaky-span-issue-2.rs
new file mode 100644
index 0000000..aa65d33
--- /dev/null
+++ b/tests/ui/cfg/packed_sneaky-span-issue-2.rs
@@ -0,0 +1,18 @@
+use auxiliary_macros::hidden_repr;
+use pin_project::pin_project;
+
+//~ ERROR may not be used on #[repr(packed)] types
+// span is lost.
+// Refs: https://github.com/rust-lang/rust/issues/43081
+#[pin_project]
+#[hidden_repr(packed)]
+struct Foo {
+ #[cfg(any())]
+ #[pin]
+ field: u32,
+ #[cfg(not(any()))]
+ #[pin]
+ field: u8,
+}
+
+fn main() {}
diff --git a/tests/ui/cfg/packed_sneaky-span-issue-2.stderr b/tests/ui/cfg/packed_sneaky-span-issue-2.stderr
new file mode 100644
index 0000000..f4d7dee
--- /dev/null
+++ b/tests/ui/cfg/packed_sneaky-span-issue-2.stderr
@@ -0,0 +1 @@
+error: #[pin_project] attribute may not be used on #[repr(packed)] types
diff --git a/tests/ui/cfg/packed_sneaky.rs b/tests/ui/cfg/packed_sneaky.rs
new file mode 100644
index 0000000..3305ed3
--- /dev/null
+++ b/tests/ui/cfg/packed_sneaky.rs
@@ -0,0 +1,12 @@
+use auxiliary_macros::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 Foo {
+ #[pin]
+ field: u32,
+}
+
+fn main() {}
diff --git a/tests/ui/cfg/packed_sneaky.stderr b/tests/ui/cfg/packed_sneaky.stderr
new file mode 100644
index 0000000..5910cf4
--- /dev/null
+++ b/tests/ui/cfg/packed_sneaky.stderr
@@ -0,0 +1,7 @@
+error: #[pin_project] attribute may not be used on #[repr(packed)] types
+ --> $DIR/packed_sneaky.rs:6:1
+ |
+6 | #[hidden_repr_cfg_not_any(packed)] //~ ERROR may not be used on #[repr(packed)] types
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = note: this error originates in an attribute macro (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/tests/ui/cfg/proper_unpin.rs b/tests/ui/cfg/proper_unpin.rs
new file mode 100644
index 0000000..b7bb04d
--- /dev/null
+++ b/tests/ui/cfg/proper_unpin.rs
@@ -0,0 +1,28 @@
+use pin_project::pin_project;
+use std::marker::PhantomPinned;
+
+#[pin_project]
+struct Foo<T> {
+ #[cfg(any())]
+ #[pin]
+ inner: T,
+ #[cfg(not(any()))]
+ inner: T,
+}
+
+#[pin_project]
+struct Bar<T> {
+ #[cfg(any())]
+ inner: T,
+ #[cfg(not(any()))]
+ #[pin]
+ inner: T,
+}
+
+fn is_unpin<T: Unpin>() {}
+
+fn main() {
+ is_unpin::<Foo<PhantomPinned>>(); // Ok
+ is_unpin::<Bar<()>>(); // Ok
+ is_unpin::<Bar<PhantomPinned>>(); //~ ERROR E0277
+}
diff --git a/tests/ui/cfg/proper_unpin.stderr b/tests/ui/cfg/proper_unpin.stderr
new file mode 100644
index 0000000..407d900
--- /dev/null
+++ b/tests/ui/cfg/proper_unpin.stderr
@@ -0,0 +1,11 @@
+error[E0277]: `std::marker::PhantomPinned` cannot be unpinned
+ --> $DIR/proper_unpin.rs:27:5
+ |
+22 | fn is_unpin<T: Unpin>() {}
+ | ----- required by this bound in `is_unpin`
+...
+27 | is_unpin::<Bar<PhantomPinned>>(); //~ ERROR E0277
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ within `__SCOPE_Bar::__Bar<'_, std::marker::PhantomPinned>`, the trait `std::marker::Unpin` is not implemented for `std::marker::PhantomPinned`
+ |
+ = note: required because it appears within the type `__SCOPE_Bar::__Bar<'_, std::marker::PhantomPinned>`
+ = note: required because of the requirements on the impl of `std::marker::Unpin` for `Bar<std::marker::PhantomPinned>`
diff --git a/tests/ui/cfg/unsupported.rs b/tests/ui/cfg/unsupported.rs
new file mode 100644
index 0000000..5205307
--- /dev/null
+++ b/tests/ui/cfg/unsupported.rs
@@ -0,0 +1,13 @@
+use pin_project::pin_project;
+
+//~ ERROR may not be used on structs with zero fields
+// span is lost.
+// Refs: https://github.com/rust-lang/rust/issues/43081
+#[pin_project]
+struct Struct {
+ #[cfg(any())]
+ #[pin]
+ f: u8,
+}
+
+fn main() {}
diff --git a/tests/ui/cfg/unsupported.stderr b/tests/ui/cfg/unsupported.stderr
new file mode 100644
index 0000000..0ee8676
--- /dev/null
+++ b/tests/ui/cfg/unsupported.stderr
@@ -0,0 +1 @@
+error: #[pin_project] attribute may not be used on structs with zero fields
diff --git a/tests/ui/not_unpin/assert-not-unpin.rs b/tests/ui/not_unpin/assert-not-unpin.rs
new file mode 100644
index 0000000..b8f8238
--- /dev/null
+++ b/tests/ui/not_unpin/assert-not-unpin.rs
@@ -0,0 +1,40 @@
+use pin_project::pin_project;
+use std::marker::PhantomPinned;
+
+struct Inner<T> {
+ val: T,
+}
+
+#[pin_project(!Unpin)]
+struct Foo<T, U> {
+ #[pin]
+ inner: Inner<T>,
+ other: U,
+}
+
+#[pin_project(!Unpin)]
+struct TrivialBounds {
+ #[pin]
+ field1: PhantomPinned,
+}
+
+#[pin_project(!Unpin)]
+struct Bar<'a, T, U> {
+ #[pin]
+ inner: &'a mut Inner<T>,
+ other: U,
+}
+
+fn is_unpin<T: Unpin>() {}
+
+fn main() {
+ is_unpin::<Foo<(), ()>>(); //~ ERROR E0277
+ is_unpin::<Foo<PhantomPinned, ()>>(); //~ ERROR E0277
+ is_unpin::<Foo<(), PhantomPinned>>(); //~ ERROR E0277
+ is_unpin::<Foo<PhantomPinned, PhantomPinned>>(); //~ ERROR E0277
+
+ is_unpin::<TrivialBounds>(); //~ ERROR E0277
+
+ is_unpin::<Bar<'_, (), ()>>(); //~ ERROR E0277
+ is_unpin::<Bar<'_, PhantomPinned, PhantomPinned>>(); //~ ERROR E0277
+}
diff --git a/tests/ui/not_unpin/assert-not-unpin.stderr b/tests/ui/not_unpin/assert-not-unpin.stderr
new file mode 100644
index 0000000..5e323fc
--- /dev/null
+++ b/tests/ui/not_unpin/assert-not-unpin.stderr
@@ -0,0 +1,83 @@
+error[E0277]: `std::marker::PhantomPinned` cannot be unpinned
+ --> $DIR/assert-not-unpin.rs:31:5
+ |
+28 | fn is_unpin<T: Unpin>() {}
+ | ----- required by this bound in `is_unpin`
+...
+31 | is_unpin::<Foo<(), ()>>(); //~ ERROR E0277
+ | ^^^^^^^^^^^^^^^^^^^^^^^ within `pin_project::__private::Wrapper<'_, std::marker::PhantomPinned>`, the trait `std::marker::Unpin` is not implemented for `std::marker::PhantomPinned`
+ |
+ = note: required because it appears within the type `pin_project::__private::Wrapper<'_, std::marker::PhantomPinned>`
+ = note: required because of the requirements on the impl of `std::marker::Unpin` for `Foo<(), ()>`
+
+error[E0277]: `std::marker::PhantomPinned` cannot be unpinned
+ --> $DIR/assert-not-unpin.rs:32:5
+ |
+28 | fn is_unpin<T: Unpin>() {}
+ | ----- required by this bound in `is_unpin`
+...
+32 | is_unpin::<Foo<PhantomPinned, ()>>(); //~ ERROR E0277
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ within `pin_project::__private::Wrapper<'_, std::marker::PhantomPinned>`, the trait `std::marker::Unpin` is not implemented for `std::marker::PhantomPinned`
+ |
+ = note: required because it appears within the type `pin_project::__private::Wrapper<'_, std::marker::PhantomPinned>`
+ = note: required because of the requirements on the impl of `std::marker::Unpin` for `Foo<std::marker::PhantomPinned, ()>`
+
+error[E0277]: `std::marker::PhantomPinned` cannot be unpinned
+ --> $DIR/assert-not-unpin.rs:33:5
+ |
+28 | fn is_unpin<T: Unpin>() {}
+ | ----- required by this bound in `is_unpin`
+...
+33 | is_unpin::<Foo<(), PhantomPinned>>(); //~ ERROR E0277
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ within `pin_project::__private::Wrapper<'_, std::marker::PhantomPinned>`, the trait `std::marker::Unpin` is not implemented for `std::marker::PhantomPinned`
+ |
+ = note: required because it appears within the type `pin_project::__private::Wrapper<'_, std::marker::PhantomPinned>`
+ = note: required because of the requirements on the impl of `std::marker::Unpin` for `Foo<(), std::marker::PhantomPinned>`
+
+error[E0277]: `std::marker::PhantomPinned` cannot be unpinned
+ --> $DIR/assert-not-unpin.rs:34:5
+ |
+28 | fn is_unpin<T: Unpin>() {}
+ | ----- required by this bound in `is_unpin`
+...
+34 | is_unpin::<Foo<PhantomPinned, PhantomPinned>>(); //~ ERROR E0277
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ within `pin_project::__private::Wrapper<'_, std::marker::PhantomPinned>`, the trait `std::marker::Unpin` is not implemented for `std::marker::PhantomPinned`
+ |
+ = note: required because it appears within the type `pin_project::__private::Wrapper<'_, std::marker::PhantomPinned>`
+ = note: required because of the requirements on the impl of `std::marker::Unpin` for `Foo<std::marker::PhantomPinned, std::marker::PhantomPinned>`
+
+error[E0277]: `std::marker::PhantomPinned` cannot be unpinned
+ --> $DIR/assert-not-unpin.rs:36:5
+ |
+28 | fn is_unpin<T: Unpin>() {}
+ | ----- required by this bound in `is_unpin`
+...
+36 | is_unpin::<TrivialBounds>(); //~ ERROR E0277
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^ within `pin_project::__private::Wrapper<'_, std::marker::PhantomPinned>`, the trait `std::marker::Unpin` is not implemented for `std::marker::PhantomPinned`
+ |
+ = note: required because it appears within the type `pin_project::__private::Wrapper<'_, std::marker::PhantomPinned>`
+ = note: required because of the requirements on the impl of `std::marker::Unpin` for `TrivialBounds`
+
+error[E0277]: `std::marker::PhantomPinned` cannot be unpinned
+ --> $DIR/assert-not-unpin.rs:38:5
+ |
+28 | fn is_unpin<T: Unpin>() {}
+ | ----- required by this bound in `is_unpin`
+...
+38 | is_unpin::<Bar<'_, (), ()>>(); //~ ERROR E0277
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ within `pin_project::__private::Wrapper<'_, std::marker::PhantomPinned>`, the trait `std::marker::Unpin` is not implemented for `std::marker::PhantomPinned`
+ |
+ = note: required because it appears within the type `pin_project::__private::Wrapper<'_, std::marker::PhantomPinned>`
+ = note: required because of the requirements on the impl of `std::marker::Unpin` for `Bar<'_, (), ()>`
+
+error[E0277]: `std::marker::PhantomPinned` cannot be unpinned
+ --> $DIR/assert-not-unpin.rs:39:5
+ |
+28 | fn is_unpin<T: Unpin>() {}
+ | ----- required by this bound in `is_unpin`
+...
+39 | is_unpin::<Bar<'_, PhantomPinned, PhantomPinned>>(); //~ ERROR E0277
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ within `pin_project::__private::Wrapper<'_, std::marker::PhantomPinned>`, the trait `std::marker::Unpin` is not implemented for `std::marker::PhantomPinned`
+ |
+ = note: required because it appears within the type `pin_project::__private::Wrapper<'_, std::marker::PhantomPinned>`
+ = note: required because of the requirements on the impl of `std::marker::Unpin` for `Bar<'_, std::marker::PhantomPinned, std::marker::PhantomPinned>`
diff --git a/tests/ui/not_unpin/conflict-unpin.rs b/tests/ui/not_unpin/conflict-unpin.rs
new file mode 100644
index 0000000..f259f6c
--- /dev/null
+++ b/tests/ui/not_unpin/conflict-unpin.rs
@@ -0,0 +1,30 @@
+use pin_project::pin_project;
+
+#[pin_project(!Unpin)] //~ ERROR E0119
+struct Foo<T, U> {
+ #[pin]
+ future: T,
+ field: U,
+}
+
+impl<T, U> Unpin for Foo<T, U> where T: Unpin {}
+
+#[pin_project(!Unpin)] //~ ERROR E0119
+struct Bar<T, U> {
+ #[pin]
+ future: T,
+ field: U,
+}
+
+impl<T, U> Unpin for Bar<T, U> {}
+
+#[pin_project(!Unpin)] //~ ERROR E0119
+struct Baz<T, U> {
+ #[pin]
+ future: T,
+ field: U,
+}
+
+impl<T: Unpin, U: Unpin> Unpin for Baz<T, U> {}
+
+fn main() {}
diff --git a/tests/ui/not_unpin/conflict-unpin.stderr b/tests/ui/not_unpin/conflict-unpin.stderr
new file mode 100644
index 0000000..7407bdf
--- /dev/null
+++ b/tests/ui/not_unpin/conflict-unpin.stderr
@@ -0,0 +1,26 @@
+error[E0119]: conflicting implementations of trait `std::marker::Unpin` for type `Foo<_, _>`:
+ --> $DIR/conflict-unpin.rs:3:16
+ |
+3 | #[pin_project(!Unpin)] //~ ERROR E0119
+ | ^^^^^ conflicting implementation for `Foo<_, _>`
+...
+10 | impl<T, U> Unpin for Foo<T, U> where T: Unpin {}
+ | --------------------------------------------- first implementation here
+
+error[E0119]: conflicting implementations of trait `std::marker::Unpin` for type `Bar<_, _>`:
+ --> $DIR/conflict-unpin.rs:12:16
+ |
+12 | #[pin_project(!Unpin)] //~ ERROR E0119
+ | ^^^^^ conflicting implementation for `Bar<_, _>`
+...
+19 | impl<T, U> Unpin for Bar<T, U> {}
+ | ------------------------------ first implementation here
+
+error[E0119]: conflicting implementations of trait `std::marker::Unpin` for type `Baz<_, _>`:
+ --> $DIR/conflict-unpin.rs:21:16
+ |
+21 | #[pin_project(!Unpin)] //~ ERROR E0119
+ | ^^^^^ conflicting implementation for `Baz<_, _>`
+...
+28 | impl<T: Unpin, U: Unpin> Unpin for Baz<T, U> {}
+ | -------------------------------------------- first implementation here
diff --git a/tests/ui/not_unpin/impl-unsafe-unpin.rs b/tests/ui/not_unpin/impl-unsafe-unpin.rs
new file mode 100644
index 0000000..625dc29
--- /dev/null
+++ b/tests/ui/not_unpin/impl-unsafe-unpin.rs
@@ -0,0 +1,30 @@
+use pin_project::{pin_project, UnsafeUnpin};
+
+#[pin_project(!Unpin)] //~ ERROR E0119
+struct Foo<T, U> {
+ #[pin]
+ future: T,
+ field: U,
+}
+
+unsafe impl<T, U> UnsafeUnpin for Foo<T, U> where T: Unpin {}
+
+#[pin_project(!Unpin)] //~ ERROR E0119
+struct Bar<T, U> {
+ #[pin]
+ future: T,
+ field: U,
+}
+
+unsafe impl<T, U> UnsafeUnpin for Bar<T, U> {}
+
+#[pin_project(!Unpin)] //~ ERROR E0119
+struct Baz<T, U> {
+ #[pin]
+ future: T,
+ field: U,
+}
+
+unsafe impl<T: Unpin, U: Unpin> UnsafeUnpin for Baz<T, U> {}
+
+fn main() {}
diff --git a/tests/ui/not_unpin/impl-unsafe-unpin.stderr b/tests/ui/not_unpin/impl-unsafe-unpin.stderr
new file mode 100644
index 0000000..ba80d5e
--- /dev/null
+++ b/tests/ui/not_unpin/impl-unsafe-unpin.stderr
@@ -0,0 +1,32 @@
+error[E0119]: conflicting implementations of trait `pin_project::UnsafeUnpin` for type `Foo<_, _>`:
+ --> $DIR/impl-unsafe-unpin.rs:3:1
+ |
+3 | #[pin_project(!Unpin)] //~ ERROR E0119
+ | ^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `Foo<_, _>`
+...
+10 | unsafe impl<T, U> UnsafeUnpin for Foo<T, U> where T: Unpin {}
+ | ---------------------------------------------------------- first implementation here
+ |
+ = note: this error originates in a derive macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0119]: conflicting implementations of trait `pin_project::UnsafeUnpin` for type `Bar<_, _>`:
+ --> $DIR/impl-unsafe-unpin.rs:12:1
+ |
+12 | #[pin_project(!Unpin)] //~ ERROR E0119
+ | ^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `Bar<_, _>`
+...
+19 | unsafe impl<T, U> UnsafeUnpin for Bar<T, U> {}
+ | ------------------------------------------- first implementation here
+ |
+ = note: this error originates in a derive macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0119]: conflicting implementations of trait `pin_project::UnsafeUnpin` for type `Baz<_, _>`:
+ --> $DIR/impl-unsafe-unpin.rs:21:1
+ |
+21 | #[pin_project(!Unpin)] //~ ERROR E0119
+ | ^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `Baz<_, _>`
+...
+28 | unsafe impl<T: Unpin, U: Unpin> UnsafeUnpin for Baz<T, U> {}
+ | --------------------------------------------------------- first implementation here
+ |
+ = note: this error originates in a derive macro (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/tests/ui/pin_project/add-pin-attr-to-struct.rs b/tests/ui/pin_project/add-pin-attr-to-struct.rs
new file mode 100644
index 0000000..f5364fc
--- /dev/null
+++ b/tests/ui/pin_project/add-pin-attr-to-struct.rs
@@ -0,0 +1,19 @@
+use auxiliary_macros::add_pin_attr;
+use pin_project::pin_project;
+use std::marker::PhantomPinned;
+
+#[pin_project]
+#[add_pin_attr(struct)] //~ ERROR duplicate #[pin] attribute
+struct Foo {
+ #[pin]
+ field: PhantomPinned,
+}
+
+#[add_pin_attr(struct)] //~ ERROR #[pin] attribute may only be used on fields of structs or variants
+#[pin_project]
+struct Bar {
+ #[pin]
+ field: PhantomPinned,
+}
+
+fn main() {}
diff --git a/tests/ui/pin_project/add-pin-attr-to-struct.stderr b/tests/ui/pin_project/add-pin-attr-to-struct.stderr
new file mode 100644
index 0000000..c2adaea
--- /dev/null
+++ b/tests/ui/pin_project/add-pin-attr-to-struct.stderr
@@ -0,0 +1,15 @@
+error: duplicate #[pin] attribute
+ --> $DIR/add-pin-attr-to-struct.rs:6:1
+ |
+6 | #[add_pin_attr(struct)] //~ ERROR duplicate #[pin] attribute
+ | ^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = note: this error originates in an attribute macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: #[pin] attribute may only be used on fields of structs or variants
+ --> $DIR/add-pin-attr-to-struct.rs:12:1
+ |
+12 | #[add_pin_attr(struct)] //~ ERROR #[pin] attribute may only be used on fields of structs or variants
+ | ^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = note: this error originates in an attribute macro (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/tests/ui/pin_project/add-pinned-field.rs b/tests/ui/pin_project/add-pinned-field.rs
new file mode 100644
index 0000000..76394cf
--- /dev/null
+++ b/tests/ui/pin_project/add-pinned-field.rs
@@ -0,0 +1,23 @@
+use auxiliary_macros::add_pinned_field;
+use pin_project::pin_project;
+
+fn is_unpin<T: Unpin>() {}
+
+#[pin_project]
+#[add_pinned_field]
+struct Foo {
+ #[pin]
+ field: u32,
+}
+
+#[add_pinned_field]
+#[pin_project]
+struct Bar {
+ #[pin]
+ field: u32,
+}
+
+fn main() {
+ is_unpin::<Foo>(); //~ ERROR E0277
+ is_unpin::<Bar>(); //~ ERROR E0277
+}
diff --git a/tests/ui/pin_project/add-pinned-field.stderr b/tests/ui/pin_project/add-pinned-field.stderr
new file mode 100644
index 0000000..db07a74
--- /dev/null
+++ b/tests/ui/pin_project/add-pinned-field.stderr
@@ -0,0 +1,23 @@
+error[E0277]: `std::marker::PhantomPinned` cannot be unpinned
+ --> $DIR/add-pinned-field.rs:21:5
+ |
+4 | fn is_unpin<T: Unpin>() {}
+ | ----- required by this bound in `is_unpin`
+...
+21 | is_unpin::<Foo>(); //~ ERROR E0277
+ | ^^^^^^^^^^^^^^^ within `__SCOPE_Foo::__Foo<'_>`, the trait `std::marker::Unpin` is not implemented for `std::marker::PhantomPinned`
+ |
+ = note: required because it appears within the type `__SCOPE_Foo::__Foo<'_>`
+ = note: required because of the requirements on the impl of `std::marker::Unpin` for `Foo`
+
+error[E0277]: `std::marker::PhantomPinned` cannot be unpinned
+ --> $DIR/add-pinned-field.rs:22:5
+ |
+4 | fn is_unpin<T: Unpin>() {}
+ | ----- required by this bound in `is_unpin`
+...
+22 | is_unpin::<Bar>(); //~ ERROR E0277
+ | ^^^^^^^^^^^^^^^ within `__SCOPE_Bar::__Bar<'_>`, the trait `std::marker::Unpin` is not implemented for `std::marker::PhantomPinned`
+ |
+ = note: required because it appears within the type `__SCOPE_Bar::__Bar<'_>`
+ = note: required because of the requirements on the impl of `std::marker::Unpin` for `Bar`
diff --git a/tests/ui/pin_project/conflict-drop.rs b/tests/ui/pin_project/conflict-drop.rs
new file mode 100644
index 0000000..c965184
--- /dev/null
+++ b/tests/ui/pin_project/conflict-drop.rs
@@ -0,0 +1,31 @@
+use pin_project::{pin_project, pinned_drop};
+use std::pin::Pin;
+
+#[pin_project] //~ ERROR E0119
+struct Foo<T, U> {
+ #[pin]
+ future: T,
+ field: U,
+}
+
+impl<T, U> Drop for Foo<T, U> {
+ fn drop(&mut self) {}
+}
+
+#[pin_project(PinnedDrop)] //~ ERROR E0119
+struct Bar<T, U> {
+ #[pin]
+ future: T,
+ field: U,
+}
+
+#[pinned_drop]
+impl<T, U> PinnedDrop for Bar<T, U> {
+ fn drop(self: Pin<&mut Self>) {}
+}
+
+impl<T, U> Drop for Bar<T, U> {
+ fn drop(&mut self) {}
+}
+
+fn main() {}
diff --git a/tests/ui/pin_project/conflict-drop.stderr b/tests/ui/pin_project/conflict-drop.stderr
new file mode 100644
index 0000000..f97d060
--- /dev/null
+++ b/tests/ui/pin_project/conflict-drop.stderr
@@ -0,0 +1,19 @@
+error[E0119]: conflicting implementations of trait `__SCOPE_Foo::FooMustNotImplDrop` for type `Foo<_, _>`:
+ --> $DIR/conflict-drop.rs:4:1
+ |
+4 | #[pin_project] //~ ERROR E0119
+ | ^^^^^^^^^^^^^^
+ | |
+ | first implementation here
+ | conflicting implementation for `Foo<_, _>`
+ |
+ = note: this error originates in a derive macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0119]: conflicting implementations of trait `std::ops::Drop` for type `Bar<_, _>`:
+ --> $DIR/conflict-drop.rs:15:15
+ |
+15 | #[pin_project(PinnedDrop)] //~ ERROR E0119
+ | ^^^^^^^^^^ conflicting implementation for `Bar<_, _>`
+...
+27 | impl<T, U> Drop for Bar<T, U> {
+ | ----------------------------- first implementation here
diff --git a/tests/ui/pin_project/conflict-unpin.rs b/tests/ui/pin_project/conflict-unpin.rs
new file mode 100644
index 0000000..0c48d27
--- /dev/null
+++ b/tests/ui/pin_project/conflict-unpin.rs
@@ -0,0 +1,37 @@
+use pin_project::pin_project;
+
+// The same implementation.
+
+#[pin_project] //~ ERROR E0119
+struct Foo<T, U> {
+ #[pin]
+ future: T,
+ field: U,
+}
+
+// conflicting implementations
+impl<T, U> Unpin for Foo<T, U> where T: Unpin {} // Conditional Unpin impl
+
+// The implementation that under different conditions.
+
+#[pin_project] //~ ERROR E0119
+struct Bar<T, U> {
+ #[pin]
+ future: T,
+ field: U,
+}
+
+// conflicting implementations
+impl<T, U> Unpin for Bar<T, U> {} // Non-conditional Unpin impl
+
+#[pin_project] //~ ERROR E0119
+struct Baz<T, U> {
+ #[pin]
+ future: T,
+ field: U,
+}
+
+// conflicting implementations
+impl<T: Unpin, U: Unpin> Unpin for Baz<T, U> {} // Conditional Unpin impl
+
+fn main() {}
diff --git a/tests/ui/pin_project/conflict-unpin.stderr b/tests/ui/pin_project/conflict-unpin.stderr
new file mode 100644
index 0000000..0d6f439
--- /dev/null
+++ b/tests/ui/pin_project/conflict-unpin.stderr
@@ -0,0 +1,32 @@
+error[E0119]: conflicting implementations of trait `std::marker::Unpin` for type `Foo<_, _>`:
+ --> $DIR/conflict-unpin.rs:5:1
+ |
+5 | #[pin_project] //~ ERROR E0119
+ | ^^^^^^^^^^^^^^ conflicting implementation for `Foo<_, _>`
+...
+13 | impl<T, U> Unpin for Foo<T, U> where T: Unpin {} // Conditional Unpin impl
+ | --------------------------------------------- first implementation here
+ |
+ = note: this error originates in a derive macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0119]: conflicting implementations of trait `std::marker::Unpin` for type `Bar<_, _>`:
+ --> $DIR/conflict-unpin.rs:17:1
+ |
+17 | #[pin_project] //~ ERROR E0119
+ | ^^^^^^^^^^^^^^ conflicting implementation for `Bar<_, _>`
+...
+25 | impl<T, U> Unpin for Bar<T, U> {} // Non-conditional Unpin impl
+ | ------------------------------ first implementation here
+ |
+ = note: this error originates in a derive macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0119]: conflicting implementations of trait `std::marker::Unpin` for type `Baz<_, _>`:
+ --> $DIR/conflict-unpin.rs:27:1
+ |
+27 | #[pin_project] //~ ERROR E0119
+ | ^^^^^^^^^^^^^^ conflicting implementation for `Baz<_, _>`
+...
+35 | impl<T: Unpin, U: Unpin> Unpin for Baz<T, U> {} // Conditional Unpin impl
+ | -------------------------------------------- first implementation here
+ |
+ = note: this error originates in a derive macro (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/tests/ui/pin_project/impl-unsafe-unpin.rs b/tests/ui/pin_project/impl-unsafe-unpin.rs
new file mode 100644
index 0000000..94af322
--- /dev/null
+++ b/tests/ui/pin_project/impl-unsafe-unpin.rs
@@ -0,0 +1,30 @@
+use pin_project::{pin_project, UnsafeUnpin};
+
+#[pin_project] //~ ERROR E0119
+struct Foo<T, U> {
+ #[pin]
+ future: T,
+ field: U,
+}
+
+unsafe impl<T, U> UnsafeUnpin for Foo<T, U> where T: Unpin {}
+
+#[pin_project] //~ ERROR E0119
+struct Bar<T, U> {
+ #[pin]
+ future: T,
+ field: U,
+}
+
+unsafe impl<T, U> UnsafeUnpin for Bar<T, U> {}
+
+#[pin_project] //~ ERROR E0119
+struct Baz<T, U> {
+ #[pin]
+ future: T,
+ field: U,
+}
+
+unsafe impl<T: Unpin, U: Unpin> UnsafeUnpin for Baz<T, U> {}
+
+fn main() {}
diff --git a/tests/ui/pin_project/impl-unsafe-unpin.stderr b/tests/ui/pin_project/impl-unsafe-unpin.stderr
new file mode 100644
index 0000000..78545c2
--- /dev/null
+++ b/tests/ui/pin_project/impl-unsafe-unpin.stderr
@@ -0,0 +1,32 @@
+error[E0119]: conflicting implementations of trait `pin_project::UnsafeUnpin` for type `Foo<_, _>`:
+ --> $DIR/impl-unsafe-unpin.rs:3:1
+ |
+3 | #[pin_project] //~ ERROR E0119
+ | ^^^^^^^^^^^^^^ conflicting implementation for `Foo<_, _>`
+...
+10 | unsafe impl<T, U> UnsafeUnpin for Foo<T, U> where T: Unpin {}
+ | ---------------------------------------------------------- first implementation here
+ |
+ = note: this error originates in a derive macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0119]: conflicting implementations of trait `pin_project::UnsafeUnpin` for type `Bar<_, _>`:
+ --> $DIR/impl-unsafe-unpin.rs:12:1
+ |
+12 | #[pin_project] //~ ERROR E0119
+ | ^^^^^^^^^^^^^^ conflicting implementation for `Bar<_, _>`
+...
+19 | unsafe impl<T, U> UnsafeUnpin for Bar<T, U> {}
+ | ------------------------------------------- first implementation here
+ |
+ = note: this error originates in a derive macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0119]: conflicting implementations of trait `pin_project::UnsafeUnpin` for type `Baz<_, _>`:
+ --> $DIR/impl-unsafe-unpin.rs:21:1
+ |
+21 | #[pin_project] //~ ERROR E0119
+ | ^^^^^^^^^^^^^^ conflicting implementation for `Baz<_, _>`
+...
+28 | unsafe impl<T: Unpin, U: Unpin> UnsafeUnpin for Baz<T, U> {}
+ | --------------------------------------------------------- first implementation here
+ |
+ = note: this error originates in a derive macro (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/tests/ui/pin_project/invalid.rs b/tests/ui/pin_project/invalid.rs
new file mode 100644
index 0000000..1d05608
--- /dev/null
+++ b/tests/ui/pin_project/invalid.rs
@@ -0,0 +1,199 @@
+mod pin_argument {
+ use pin_project::pin_project;
+
+ #[pin_project]
+ struct Struct {
+ #[pin()] //~ ERROR unexpected token
+ field: (),
+ }
+
+ #[pin_project]
+ struct TupleStruct(#[pin(foo)] ()); //~ ERROR unexpected token
+
+ #[pin_project]
+ enum EnumTuple {
+ V(#[pin(foo)] ()), //~ ERROR unexpected token
+ }
+
+ #[pin_project]
+ enum EnumStruct {
+ V {
+ #[pin(foo)] //~ ERROR unexpected token
+ field: (),
+ },
+ }
+}
+
+mod pin_attribute {
+ use pin_project::pin_project;
+
+ #[pin_project]
+ struct DuplicateStruct {
+ #[pin]
+ #[pin] //~ ERROR duplicate #[pin] attribute
+ field: (),
+ }
+
+ #[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
+ field: (),
+ },
+ }
+}
+
+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]
+ field: (),
+ }
+
+ #[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(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 duplicate `PinnedDrop` argument
+ struct DuplicatePinnedDrop(#[pin] ());
+
+ #[pin_project(Replace, Replace)] //~ ERROR duplicate `Replace` argument
+ struct DuplicateReplace(#[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(PinnedDrop, Replace)] //~ ERROR arguments `PinnedDrop` and `Replace` are mutually exclusive
+ struct PinnedDropWithReplace1(#[pin] ());
+
+ #[pin_project(Replace, UnsafeUnpin, PinnedDrop)] //~ ERROR arguments `PinnedDrop` and `Replace` are mutually exclusive
+ struct PinnedDropWithReplace2(#[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 unexpected end of input, expected `Unpin`
+ struct NotUnpin1(#[pin] ());
+
+ #[pin_project(Unpin)] //~ ERROR unexpected argument
+ struct NotUnpin2(#[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: (),
+ }
+}
+
+// #[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/tests/ui/pin_project/invalid.stderr b/tests/ui/pin_project/invalid.stderr
new file mode 100644
index 0000000..95b57f0
--- /dev/null
+++ b/tests/ui/pin_project/invalid.stderr
@@ -0,0 +1,228 @@
+error: unexpected token: ()
+ --> $DIR/invalid.rs:6:14
+ |
+6 | #[pin()] //~ ERROR unexpected token
+ | ^^
+
+error: unexpected token: (foo)
+ --> $DIR/invalid.rs:11:29
+ |
+11 | struct TupleStruct(#[pin(foo)] ()); //~ ERROR unexpected token
+ | ^^^^^
+
+error: unexpected token: (foo)
+ --> $DIR/invalid.rs:15:16
+ |
+15 | V(#[pin(foo)] ()), //~ ERROR unexpected token
+ | ^^^^^
+
+error: unexpected token: (foo)
+ --> $DIR/invalid.rs:21:18
+ |
+21 | #[pin(foo)] //~ ERROR unexpected token
+ | ^^^^^
+
+error: duplicate #[pin] attribute
+ --> $DIR/invalid.rs:33:9
+ |
+33 | #[pin] //~ ERROR duplicate #[pin] attribute
+ | ^^^^^^
+
+error: duplicate #[pin] attribute
+ --> $DIR/invalid.rs:40:9
+ |
+40 | #[pin]
+ | ^^^^^^
+
+error: duplicate #[pin] attribute
+ --> $DIR/invalid.rs:49:13
+ |
+49 | #[pin]
+ | ^^^^^^
+
+error: duplicate #[pin] attribute
+ --> $DIR/invalid.rs:59:13
+ |
+59 | #[pin] //~ ERROR duplicate #[pin] attribute
+ | ^^^^^^
+
+error: #[pin] attribute may only be used on fields of structs or variants
+ --> $DIR/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
+ --> $DIR/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
+ --> $DIR/invalid.rs:82:5
+ |
+82 | #[pin] //~ ERROR may only be used on fields of structs or variants
+ | ^^^^^^
+
+error: expected identifier
+ --> $DIR/invalid.rs:91:31
+ |
+91 | #[pin_project(UnsafeUnpin,,)] //~ ERROR expected identifier
+ | ^
+
+error: unexpected argument: Foo
+ --> $DIR/invalid.rs:94:19
+ |
+94 | #[pin_project(Foo)] //~ ERROR unexpected argument
+ | ^^^
+
+error: expected identifier
+ --> $DIR/invalid.rs:97:19
+ |
+97 | #[pin_project(,UnsafeUnpin)] //~ ERROR expected identifier
+ | ^
+
+error: duplicate `PinnedDrop` argument
+ --> $DIR/invalid.rs:103:31
+ |
+103 | #[pin_project(PinnedDrop, PinnedDrop)] //~ ERROR duplicate `PinnedDrop` argument
+ | ^^^^^^^^^^
+
+error: duplicate `Replace` argument
+ --> $DIR/invalid.rs:106:28
+ |
+106 | #[pin_project(Replace, Replace)] //~ ERROR duplicate `Replace` argument
+ | ^^^^^^^
+
+error: duplicate `UnsafeUnpin` argument
+ --> $DIR/invalid.rs:109:32
+ |
+109 | #[pin_project(UnsafeUnpin, UnsafeUnpin)] //~ ERROR duplicate `UnsafeUnpin` argument
+ | ^^^^^^^^^^^
+
+error: duplicate `!Unpin` argument
+ --> $DIR/invalid.rs:112:27
+ |
+112 | #[pin_project(!Unpin, !Unpin)] //~ ERROR duplicate `!Unpin` argument
+ | ^^^^^^
+
+error: duplicate `UnsafeUnpin` argument
+ --> $DIR/invalid.rs:115:44
+ |
+115 | #[pin_project(PinnedDrop, UnsafeUnpin, UnsafeUnpin)] //~ ERROR duplicate `UnsafeUnpin` argument
+ | ^^^^^^^^^^^
+
+error: duplicate `PinnedDrop` argument
+ --> $DIR/invalid.rs:118:44
+ |
+118 | #[pin_project(PinnedDrop, UnsafeUnpin, PinnedDrop, UnsafeUnpin)] //~ ERROR duplicate `PinnedDrop` argument
+ | ^^^^^^^^^^
+
+error: arguments `PinnedDrop` and `Replace` are mutually exclusive
+ --> $DIR/invalid.rs:121:19
+ |
+121 | #[pin_project(PinnedDrop, Replace)] //~ ERROR arguments `PinnedDrop` and `Replace` are mutually exclusive
+ | ^^^^^^^^^^
+
+error: arguments `PinnedDrop` and `Replace` are mutually exclusive
+ --> $DIR/invalid.rs:124:41
+ |
+124 | #[pin_project(Replace, UnsafeUnpin, PinnedDrop)] //~ ERROR arguments `PinnedDrop` and `Replace` are mutually exclusive
+ | ^^^^^^^^^^
+
+error: arguments `UnsafeUnpin` and `!Unpin` are mutually exclusive
+ --> $DIR/invalid.rs:127:19
+ |
+127 | #[pin_project(UnsafeUnpin, !Unpin)] //~ ERROR arguments `UnsafeUnpin` and `!Unpin` are mutually exclusive
+ | ^^^^^^^^^^^
+
+error: arguments `UnsafeUnpin` and `!Unpin` are mutually exclusive
+ --> $DIR/invalid.rs:130:39
+ |
+130 | #[pin_project(!Unpin, PinnedDrop, UnsafeUnpin)] //~ ERROR arguments `UnsafeUnpin` and `!Unpin` are mutually exclusive
+ | ^^^^^^^^^^^
+
+error: unexpected end of input, expected `Unpin`
+ --> $DIR/invalid.rs:133:5
+ |
+133 | #[pin_project(!)] //~ ERROR unexpected end of input, expected `Unpin`
+ | ^^^^^^^^^^^^^^^^^
+ |
+ = note: this error originates in an attribute macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: unexpected argument: Unpin
+ --> $DIR/invalid.rs:136:19
+ |
+136 | #[pin_project(Unpin)] //~ ERROR unexpected argument
+ | ^^^^^
+
+error: duplicate #[pin_project] attribute
+ --> $DIR/invalid.rs:144:5
+ |
+144 | #[pin_project] //~ ERROR duplicate #[pin_project] attribute
+ | ^^^^^^^^^^^^^^
+
+error: #[pin_project] attribute may not be used on structs with zero fields
+ --> $DIR/invalid.rs:152:19
+ |
+152 | 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
+ --> $DIR/invalid.rs:155:23
+ |
+155 | 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
+ --> $DIR/invalid.rs:158:12
+ |
+158 | struct UnitStruct; //~ ERROR may not be used on structs with zero fields
+ | ^^^^^^^^^^
+
+error: #[pin_project] attribute may not be used on enums without variants
+ --> $DIR/invalid.rs:161:20
+ |
+161 | enum EnumEmpty {} //~ ERROR may not be used on enums without variants
+ | ^^
+
+error: #[pin_project] attribute may not be used on enums with discriminants
+ --> $DIR/invalid.rs:165:13
+ |
+165 | V = 2, //~ ERROR may not be used on enums with discriminants
+ | ^
+
+error: #[pin_project] attribute may not be used on enums with zero fields
+ --> $DIR/invalid.rs:170:9
+ |
+170 | / Unit, //~ ERROR may not be used on enums with zero fields
+171 | | Tuple(),
+172 | | Struct {},
+ | |__________________^
+
+error: #[pin_project] attribute may only be used on structs or enums
+ --> $DIR/invalid.rs:176:5
+ |
+176 | / union Union {
+177 | | //~^ ERROR may only be used on structs or enums
+178 | | f: (),
+179 | | }
+ | |_____^
+
+error: #[pin_project] attribute may not be used on #[repr(packed)] types
+ --> $DIR/invalid.rs:187:12
+ |
+187 | #[repr(packed)]
+ | ^^^^^^
+
+error: #[pin_project] attribute may not be used on #[repr(packed)] types
+ --> $DIR/invalid.rs:191:12
+ |
+191 | #[repr(packed)]
+ | ^^^^^^
+
+error: #[pin_project] attribute may not be used on #[repr(packed)] types
+ --> $DIR/invalid.rs:195:12
+ |
+195 | #[repr(packed)]
+ | ^^^^^^
diff --git a/tests/ui/pin_project/overlapping_unpin_struct.rs b/tests/ui/pin_project/overlapping_unpin_struct.rs
new file mode 100644
index 0000000..00fef3c
--- /dev/null
+++ b/tests/ui/pin_project/overlapping_unpin_struct.rs
@@ -0,0 +1,18 @@
+use pin_project::pin_project;
+use std::marker::PhantomPinned;
+
+#[pin_project]
+struct Foo<T> {
+ #[pin]
+ inner: T,
+}
+
+struct __Foo {}
+
+impl Unpin for __Foo {}
+
+fn is_unpin<T: Unpin>() {}
+
+fn main() {
+ is_unpin::<Foo<PhantomPinned>>(); //~ ERROR E0277
+}
diff --git a/tests/ui/pin_project/overlapping_unpin_struct.stderr b/tests/ui/pin_project/overlapping_unpin_struct.stderr
new file mode 100644
index 0000000..d0fd4a9
--- /dev/null
+++ b/tests/ui/pin_project/overlapping_unpin_struct.stderr
@@ -0,0 +1,11 @@
+error[E0277]: `std::marker::PhantomPinned` cannot be unpinned
+ --> $DIR/overlapping_unpin_struct.rs:17:5
+ |
+14 | fn is_unpin<T: Unpin>() {}
+ | ----- required by this bound in `is_unpin`
+...
+17 | is_unpin::<Foo<PhantomPinned>>(); //~ ERROR E0277
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ within `__SCOPE_Foo::__Foo<'_, std::marker::PhantomPinned>`, the trait `std::marker::Unpin` is not implemented for `std::marker::PhantomPinned`
+ |
+ = note: required because it appears within the type `__SCOPE_Foo::__Foo<'_, std::marker::PhantomPinned>`
+ = note: required because of the requirements on the impl of `std::marker::Unpin` for `Foo<std::marker::PhantomPinned>`
diff --git a/tests/ui/pin_project/packed-enum.rs b/tests/ui/pin_project/packed-enum.rs
new file mode 100644
index 0000000..9d4a4c3
--- /dev/null
+++ b/tests/ui/pin_project/packed-enum.rs
@@ -0,0 +1,20 @@
+use pin_project::pin_project;
+
+#[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/tests/ui/pin_project/packed-enum.stderr b/tests/ui/pin_project/packed-enum.stderr
new file mode 100644
index 0000000..0a5d31b
--- /dev/null
+++ b/tests/ui/pin_project/packed-enum.stderr
@@ -0,0 +1,30 @@
+error[E0517]: attribute should be applied to struct or union
+ --> $DIR/packed-enum.rs:3:8
+ |
+3 | #[repr(packed)] //~ ERROR E0517
+ | ^^^^^^
+4 | / enum E1 {
+5 | | V(()),
+6 | | }
+ | |_- not a struct or union
+
+error[E0517]: attribute should be applied to struct or union
+ --> $DIR/packed-enum.rs:9:8
+ |
+9 | #[repr(packed)] //~ ERROR E0517
+ | ^^^^^^
+10 | / enum E2 {
+11 | | V(()),
+12 | | }
+ | |_- not a struct or union
+
+error[E0517]: attribute should be applied to struct or union
+ --> $DIR/packed-enum.rs:14:8
+ |
+14 | #[repr(packed)] //~ ERROR E0517
+ | ^^^^^^
+15 | #[pin_project]
+16 | / enum E3 {
+17 | | V(()),
+18 | | }
+ | |_- not a struct or union
diff --git a/tests/ui/pin_project/packed-name-value.rs b/tests/ui/pin_project/packed-name-value.rs
new file mode 100644
index 0000000..ed819ca
--- /dev/null
+++ b/tests/ui/pin_project/packed-name-value.rs
@@ -0,0 +1,20 @@
+use pin_project::pin_project;
+
+#[repr(packed = "")] //~ ERROR E0552
+struct S1 {
+ f: (),
+}
+
+#[pin_project]
+#[repr(packed = "")] //~ ERROR E0552
+struct S2 {
+ f: (),
+}
+
+#[repr(packed = "")] //~ ERROR E0552
+#[pin_project]
+struct S3 {
+ f: (),
+}
+
+fn main() {}
diff --git a/tests/ui/pin_project/packed-name-value.stderr b/tests/ui/pin_project/packed-name-value.stderr
new file mode 100644
index 0000000..a3e2571
--- /dev/null
+++ b/tests/ui/pin_project/packed-name-value.stderr
@@ -0,0 +1,17 @@
+error[E0552]: unrecognized representation hint
+ --> $DIR/packed-name-value.rs:3:8
+ |
+3 | #[repr(packed = "")] //~ ERROR E0552
+ | ^^^^^^^^^^^
+
+error[E0552]: unrecognized representation hint
+ --> $DIR/packed-name-value.rs:9:8
+ |
+9 | #[repr(packed = "")] //~ ERROR E0552
+ | ^^^^^^^^^^^
+
+error[E0552]: unrecognized representation hint
+ --> $DIR/packed-name-value.rs:14:8
+ |
+14 | #[repr(packed = "")] //~ ERROR E0552
+ | ^^^^^^^^^^^
diff --git a/tests/ui/pin_project/packed.rs b/tests/ui/pin_project/packed.rs
new file mode 100644
index 0000000..86f3ecf
--- /dev/null
+++ b/tests/ui/pin_project/packed.rs
@@ -0,0 +1,25 @@
+use pin_project::pin_project;
+
+#[pin_project]
+#[repr(packed, C)] //~ ERROR may not be used on #[repr(packed)] types
+struct A {
+ #[pin]
+ field: u8,
+}
+
+// Test putting 'repr' before the 'pin_project' attribute
+#[repr(packed, C)] //~ ERROR may not be used on #[repr(packed)] types
+#[pin_project]
+struct B {
+ #[pin]
+ field: u8,
+}
+
+#[pin_project]
+#[repr(packed(2))] //~ ERROR may not be used on #[repr(packed)] types
+struct C {
+ #[pin]
+ field: u32,
+}
+
+fn main() {}
diff --git a/tests/ui/pin_project/packed.stderr b/tests/ui/pin_project/packed.stderr
new file mode 100644
index 0000000..969faea
--- /dev/null
+++ b/tests/ui/pin_project/packed.stderr
@@ -0,0 +1,17 @@
+error: #[pin_project] attribute may not be used on #[repr(packed)] types
+ --> $DIR/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
+ --> $DIR/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
+ --> $DIR/packed.rs:19:8
+ |
+19 | #[repr(packed(2))] //~ ERROR may not be used on #[repr(packed)] types
+ | ^^^^^^^^^
diff --git a/tests/ui/pin_project/packed_sneaky-1.rs b/tests/ui/pin_project/packed_sneaky-1.rs
new file mode 100644
index 0000000..dcf5464
--- /dev/null
+++ b/tests/ui/pin_project/packed_sneaky-1.rs
@@ -0,0 +1,33 @@
+use auxiliary_macros::hidden_repr;
+use pin_project::{pin_project, pinned_drop, UnsafeUnpin};
+use std::pin::Pin;
+
+#[pin_project] //~ ERROR may not be used on #[repr(packed)] types
+#[hidden_repr(packed)]
+struct A {
+ #[pin]
+ field: u32,
+}
+
+#[pin_project(UnsafeUnpin)] //~ ERROR may not be used on #[repr(packed)] types
+#[hidden_repr(packed)]
+struct C {
+ #[pin]
+ field: u32,
+}
+
+unsafe impl UnsafeUnpin for C {}
+
+#[pin_project(PinnedDrop)] //~ ERROR may not be used on #[repr(packed)] types
+#[hidden_repr(packed)]
+struct D {
+ #[pin]
+ field: u32,
+}
+
+#[pinned_drop]
+impl PinnedDrop for D {
+ fn drop(self: Pin<&mut Self>) {}
+}
+
+fn main() {}
diff --git a/tests/ui/pin_project/packed_sneaky-1.stderr b/tests/ui/pin_project/packed_sneaky-1.stderr
new file mode 100644
index 0000000..06a4f62
--- /dev/null
+++ b/tests/ui/pin_project/packed_sneaky-1.stderr
@@ -0,0 +1,23 @@
+error: #[pin_project] attribute may not be used on #[repr(packed)] types
+ --> $DIR/packed_sneaky-1.rs:6:1
+ |
+6 | #[hidden_repr(packed)]
+ | ^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = note: this error originates in an attribute macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: #[pin_project] attribute may not be used on #[repr(packed)] types
+ --> $DIR/packed_sneaky-1.rs:13:1
+ |
+13 | #[hidden_repr(packed)]
+ | ^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = note: this error originates in an attribute macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: #[pin_project] attribute may not be used on #[repr(packed)] types
+ --> $DIR/packed_sneaky-1.rs:22:1
+ |
+22 | #[hidden_repr(packed)]
+ | ^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = note: this error originates in an attribute macro (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/tests/ui/pin_project/packed_sneaky-2.rs b/tests/ui/pin_project/packed_sneaky-2.rs
new file mode 100644
index 0000000..d162706
--- /dev/null
+++ b/tests/ui/pin_project/packed_sneaky-2.rs
@@ -0,0 +1,12 @@
+use auxiliary_macros::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]
+ field: u32,
+ }
+}
+
+fn main() {}
diff --git a/tests/ui/pin_project/packed_sneaky-2.stderr b/tests/ui/pin_project/packed_sneaky-2.stderr
new file mode 100644
index 0000000..d653a4d
--- /dev/null
+++ b/tests/ui/pin_project/packed_sneaky-2.stderr
@@ -0,0 +1,13 @@
+error: #[pin_project] attribute may not be used on #[repr(packed)] types
+ --> $DIR/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 | | field: u32,
+9 | | }
+10 | | }
+ | |_^
+ |
+ = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/tests/ui/pin_project/private_in_public-enum.rs b/tests/ui/pin_project/private_in_public-enum.rs
new file mode 100644
index 0000000..cbffa20
--- /dev/null
+++ b/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)]
+
+pub enum PublicEnum {
+ Variant(PrivateEnum), //~ ERROR E0446
+}
+
+enum PrivateEnum {
+ Variant(u8),
+}
+
+mod foo {
+ pub(crate) enum CrateEnum {
+ Variant(PrivateEnum), //~ ERROR E0446
+ }
+
+ enum PrivateEnum {
+ Variant(u8),
+ }
+}
+
+fn main() {}
diff --git a/tests/ui/pin_project/private_in_public-enum.stderr b/tests/ui/pin_project/private_in_public-enum.stderr
new file mode 100644
index 0000000..6f2988f
--- /dev/null
+++ b/tests/ui/pin_project/private_in_public-enum.stderr
@@ -0,0 +1,17 @@
+error[E0446]: private type `PrivateEnum` in public interface
+ --> $DIR/private_in_public-enum.rs:6:13
+ |
+6 | Variant(PrivateEnum), //~ ERROR E0446
+ | ^^^^^^^^^^^ can't leak private type
+...
+9 | enum PrivateEnum {
+ | - `PrivateEnum` declared as private
+
+error[E0446]: private type `foo::PrivateEnum` in public interface
+ --> $DIR/private_in_public-enum.rs:15:17
+ |
+15 | Variant(PrivateEnum), //~ ERROR E0446
+ | ^^^^^^^^^^^ can't leak private type
+...
+18 | enum PrivateEnum {
+ | - `foo::PrivateEnum` declared as private
diff --git a/tests/ui/pin_project/proper_unpin.rs b/tests/ui/pin_project/proper_unpin.rs
new file mode 100644
index 0000000..e61789b
--- /dev/null
+++ b/tests/ui/pin_project/proper_unpin.rs
@@ -0,0 +1,38 @@
+use pin_project::pin_project;
+use std::marker::PhantomPinned;
+
+struct Inner<T> {
+ val: T,
+}
+
+#[pin_project]
+struct Foo<T, U> {
+ #[pin]
+ inner: Inner<T>,
+ other: U,
+}
+
+#[pin_project]
+struct TrivialBounds {
+ #[pin]
+ field1: PhantomPinned,
+}
+
+#[pin_project]
+struct Bar<'a, T, U> {
+ #[pin]
+ inner: &'a mut Inner<T>,
+ other: U,
+}
+
+fn is_unpin<T: Unpin>() {}
+
+fn main() {
+ is_unpin::<Foo<PhantomPinned, ()>>(); //~ ERROR E0277
+ is_unpin::<Foo<(), PhantomPinned>>(); // Ok
+ is_unpin::<Foo<PhantomPinned, PhantomPinned>>(); //~ ERROR E0277
+
+ is_unpin::<TrivialBounds>(); //~ ERROR E0277
+
+ is_unpin::<Bar<'_, PhantomPinned, PhantomPinned>>(); // Ok
+}
diff --git a/tests/ui/pin_project/proper_unpin.stderr b/tests/ui/pin_project/proper_unpin.stderr
new file mode 100644
index 0000000..9142887
--- /dev/null
+++ b/tests/ui/pin_project/proper_unpin.stderr
@@ -0,0 +1,37 @@
+error[E0277]: `std::marker::PhantomPinned` cannot be unpinned
+ --> $DIR/proper_unpin.rs:31:5
+ |
+28 | fn is_unpin<T: Unpin>() {}
+ | ----- required by this bound in `is_unpin`
+...
+31 | is_unpin::<Foo<PhantomPinned, ()>>(); //~ ERROR E0277
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ within `__SCOPE_Foo::__Foo<'_, std::marker::PhantomPinned, ()>`, the trait `std::marker::Unpin` is not implemented for `std::marker::PhantomPinned`
+ |
+ = note: required because it appears within the type `Inner<std::marker::PhantomPinned>`
+ = note: required because it appears within the type `__SCOPE_Foo::__Foo<'_, std::marker::PhantomPinned, ()>`
+ = note: required because of the requirements on the impl of `std::marker::Unpin` for `Foo<std::marker::PhantomPinned, ()>`
+
+error[E0277]: `std::marker::PhantomPinned` cannot be unpinned
+ --> $DIR/proper_unpin.rs:33:5
+ |
+28 | fn is_unpin<T: Unpin>() {}
+ | ----- required by this bound in `is_unpin`
+...
+33 | is_unpin::<Foo<PhantomPinned, PhantomPinned>>(); //~ ERROR E0277
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ within `__SCOPE_Foo::__Foo<'_, std::marker::PhantomPinned, std::marker::PhantomPinned>`, the trait `std::marker::Unpin` is not implemented for `std::marker::PhantomPinned`
+ |
+ = note: required because it appears within the type `Inner<std::marker::PhantomPinned>`
+ = note: required because it appears within the type `__SCOPE_Foo::__Foo<'_, std::marker::PhantomPinned, std::marker::PhantomPinned>`
+ = note: required because of the requirements on the impl of `std::marker::Unpin` for `Foo<std::marker::PhantomPinned, std::marker::PhantomPinned>`
+
+error[E0277]: `std::marker::PhantomPinned` cannot be unpinned
+ --> $DIR/proper_unpin.rs:35:5
+ |
+28 | fn is_unpin<T: Unpin>() {}
+ | ----- required by this bound in `is_unpin`
+...
+35 | is_unpin::<TrivialBounds>(); //~ ERROR E0277
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^ within `__SCOPE_TrivialBounds::__TrivialBounds<'_>`, the trait `std::marker::Unpin` is not implemented for `std::marker::PhantomPinned`
+ |
+ = note: required because it appears within the type `__SCOPE_TrivialBounds::__TrivialBounds<'_>`
+ = note: required because of the requirements on the impl of `std::marker::Unpin` for `TrivialBounds`
diff --git a/tests/ui/pin_project/remove-attr-from-field.rs b/tests/ui/pin_project/remove-attr-from-field.rs
new file mode 100644
index 0000000..eebd3cd
--- /dev/null
+++ b/tests/ui/pin_project/remove-attr-from-field.rs
@@ -0,0 +1,32 @@
+use auxiliary_macros::remove_attr;
+use pin_project::pin_project;
+use std::{marker::PhantomPinned, pin::Pin};
+
+fn is_unpin<T: Unpin>() {}
+
+#[pin_project]
+#[remove_attr(field)]
+struct Foo {
+ #[pin]
+ field: PhantomPinned,
+}
+
+#[remove_attr(field)]
+#[pin_project]
+struct Bar {
+ #[pin]
+ field: PhantomPinned,
+}
+
+fn main() {
+ is_unpin::<Foo>();
+ is_unpin::<Bar>();
+
+ let mut x = Foo { field: PhantomPinned };
+ let x = Pin::new(&mut x).project();
+ let _: Pin<&mut PhantomPinned> = x.field; //~ ERROR E0308
+
+ let mut x = Bar { field: PhantomPinned };
+ let x = Pin::new(&mut x).project();
+ let _: Pin<&mut PhantomPinned> = x.field; //~ ERROR E0308
+}
diff --git a/tests/ui/pin_project/remove-attr-from-field.stderr b/tests/ui/pin_project/remove-attr-from-field.stderr
new file mode 100644
index 0000000..15195e7
--- /dev/null
+++ b/tests/ui/pin_project/remove-attr-from-field.stderr
@@ -0,0 +1,21 @@
+error[E0308]: mismatched types
+ --> $DIR/remove-attr-from-field.rs:27:38
+ |
+27 | let _: Pin<&mut PhantomPinned> = x.field; //~ ERROR E0308
+ | ----------------------- ^^^^^^^ expected struct `std::pin::Pin`, found `&mut std::marker::PhantomPinned`
+ | |
+ | expected due to this
+ |
+ = note: expected struct `std::pin::Pin<&mut std::marker::PhantomPinned>`
+ found mutable reference `&mut std::marker::PhantomPinned`
+
+error[E0308]: mismatched types
+ --> $DIR/remove-attr-from-field.rs:31:38
+ |
+31 | let _: Pin<&mut PhantomPinned> = x.field; //~ ERROR E0308
+ | ----------------------- ^^^^^^^ expected struct `std::pin::Pin`, found `&mut std::marker::PhantomPinned`
+ | |
+ | expected due to this
+ |
+ = note: expected struct `std::pin::Pin<&mut std::marker::PhantomPinned>`
+ found mutable reference `&mut std::marker::PhantomPinned`
diff --git a/tests/ui/pin_project/remove-attr-from-struct.rs b/tests/ui/pin_project/remove-attr-from-struct.rs
new file mode 100644
index 0000000..b395a42
--- /dev/null
+++ b/tests/ui/pin_project/remove-attr-from-struct.rs
@@ -0,0 +1,30 @@
+use auxiliary_macros::remove_attr;
+use pin_project::pin_project;
+use std::{marker::PhantomPinned, pin::Pin};
+
+fn is_unpin<T: Unpin>() {}
+
+#[pin_project]
+#[remove_attr(struct)]
+struct Foo {
+ #[pin] //~ ERROR cannot find attribute `pin` in this scope
+ field: PhantomPinned,
+}
+
+#[remove_attr(struct)]
+#[pin_project]
+struct Bar {
+ #[pin] //~ ERROR cannot find attribute `pin` in this scope
+ field: PhantomPinned,
+}
+
+fn main() {
+ is_unpin::<Foo>(); //~ ERROR E0277
+ is_unpin::<Bar>(); //~ ERROR E0277
+
+ let mut x = Foo { field: PhantomPinned };
+ let _x = Pin::new(&mut x).project(); //~ ERROR E0277,E0599
+
+ let mut x = Bar { field: PhantomPinned };
+ let _x = Pin::new(&mut x).project(); //~ ERROR E0277,E0599
+}
diff --git a/tests/ui/pin_project/remove-attr-from-struct.stderr b/tests/ui/pin_project/remove-attr-from-struct.stderr
new file mode 100644
index 0000000..3173248
--- /dev/null
+++ b/tests/ui/pin_project/remove-attr-from-struct.stderr
@@ -0,0 +1,63 @@
+error: cannot find attribute `pin` in this scope
+ --> $DIR/remove-attr-from-struct.rs:10:7
+ |
+10 | #[pin] //~ ERROR cannot find attribute `pin` in this scope
+ | ^^^
+
+error: cannot find attribute `pin` in this scope
+ --> $DIR/remove-attr-from-struct.rs:17:7
+ |
+17 | #[pin] //~ ERROR cannot find attribute `pin` in this scope
+ | ^^^
+
+error[E0277]: `std::marker::PhantomPinned` cannot be unpinned
+ --> $DIR/remove-attr-from-struct.rs:22:5
+ |
+5 | fn is_unpin<T: Unpin>() {}
+ | ----- required by this bound in `is_unpin`
+...
+22 | is_unpin::<Foo>(); //~ ERROR E0277
+ | ^^^^^^^^^^^^^^^ within `Foo`, the trait `std::marker::Unpin` is not implemented for `std::marker::PhantomPinned`
+ |
+ = note: required because it appears within the type `Foo`
+
+error[E0277]: `std::marker::PhantomPinned` cannot be unpinned
+ --> $DIR/remove-attr-from-struct.rs:23:5
+ |
+5 | fn is_unpin<T: Unpin>() {}
+ | ----- required by this bound in `is_unpin`
+...
+23 | is_unpin::<Bar>(); //~ ERROR E0277
+ | ^^^^^^^^^^^^^^^ within `Bar`, the trait `std::marker::Unpin` is not implemented for `std::marker::PhantomPinned`
+ |
+ = note: required because it appears within the type `Bar`
+
+error[E0277]: `std::marker::PhantomPinned` cannot be unpinned
+ --> $DIR/remove-attr-from-struct.rs:26:14
+ |
+26 | let _x = Pin::new(&mut x).project(); //~ ERROR E0277,E0599
+ | ^^^^^^^^ within `Foo`, the trait `std::marker::Unpin` is not implemented for `std::marker::PhantomPinned`
+ |
+ = note: required because it appears within the type `Foo`
+ = note: required by `std::pin::Pin::<P>::new`
+
+error[E0599]: no method named `project` found for struct `std::pin::Pin<&mut Foo>` in the current scope
+ --> $DIR/remove-attr-from-struct.rs:26:31
+ |
+26 | let _x = Pin::new(&mut x).project(); //~ ERROR E0277,E0599
+ | ^^^^^^^ method not found in `std::pin::Pin<&mut Foo>`
+
+error[E0277]: `std::marker::PhantomPinned` cannot be unpinned
+ --> $DIR/remove-attr-from-struct.rs:29:14
+ |
+29 | let _x = Pin::new(&mut x).project(); //~ ERROR E0277,E0599
+ | ^^^^^^^^ within `Bar`, the trait `std::marker::Unpin` is not implemented for `std::marker::PhantomPinned`
+ |
+ = note: required because it appears within the type `Bar`
+ = note: required by `std::pin::Pin::<P>::new`
+
+error[E0599]: no method named `project` found for struct `std::pin::Pin<&mut Bar>` in the current scope
+ --> $DIR/remove-attr-from-struct.rs:29:31
+ |
+29 | let _x = Pin::new(&mut x).project(); //~ ERROR E0277,E0599
+ | ^^^^^^^ method not found in `std::pin::Pin<&mut Bar>`
diff --git a/tests/ui/pin_project/safe_packed_borrows.rs b/tests/ui/pin_project/safe_packed_borrows.rs
new file mode 100644
index 0000000..c1a7d55
--- /dev/null
+++ b/tests/ui/pin_project/safe_packed_borrows.rs
@@ -0,0 +1,21 @@
+#![deny(safe_packed_borrows)]
+
+// Refs: https://github.com/rust-lang/rust/issues/46043
+
+#[repr(packed)]
+struct A {
+ field: u32,
+}
+
+#[repr(packed(2))]
+struct B {
+ field: u32,
+}
+
+fn main() {
+ let a = A { field: 1 };
+ &a.field; //~ ERROR borrow of packed field is unsafe and requires unsafe function or block
+
+ let b = B { field: 1 };
+ &b.field; //~ ERROR borrow of packed field is unsafe and requires unsafe function or block
+}
diff --git a/tests/ui/pin_project/safe_packed_borrows.stderr b/tests/ui/pin_project/safe_packed_borrows.stderr
new file mode 100644
index 0000000..7b4cc08
--- /dev/null
+++ b/tests/ui/pin_project/safe_packed_borrows.stderr
@@ -0,0 +1,24 @@
+error: borrow of packed field is unsafe and requires unsafe function or block (error E0133)
+ --> $DIR/safe_packed_borrows.rs:17:5
+ |
+17 | &a.field; //~ ERROR borrow of packed field is unsafe and requires unsafe function or block
+ | ^^^^^^^^
+ |
+note: the lint level is defined here
+ --> $DIR/safe_packed_borrows.rs:1:9
+ |
+1 | #![deny(safe_packed_borrows)]
+ | ^^^^^^^^^^^^^^^^^^^
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+ = note: for more information, see issue #46043 <https://github.com/rust-lang/rust/issues/46043>
+ = note: fields of packed structs might be misaligned: dereferencing a misaligned pointer or even just creating a misaligned reference is undefined behavior
+
+error: borrow of packed field is unsafe and requires unsafe function or block (error E0133)
+ --> $DIR/safe_packed_borrows.rs:20:5
+ |
+20 | &b.field; //~ ERROR borrow of packed field is unsafe and requires unsafe function or block
+ | ^^^^^^^^
+ |
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+ = note: for more information, see issue #46043 <https://github.com/rust-lang/rust/issues/46043>
+ = note: fields of packed structs might be misaligned: dereferencing a misaligned pointer or even just creating a misaligned reference is undefined behavior
diff --git a/tests/ui/pin_project/unpin_sneaky.rs b/tests/ui/pin_project/unpin_sneaky.rs
new file mode 100644
index 0000000..3ccb1a9
--- /dev/null
+++ b/tests/ui/pin_project/unpin_sneaky.rs
@@ -0,0 +1,11 @@
+use pin_project::pin_project;
+
+#[pin_project]
+struct Foo {
+ #[pin]
+ inner: u8,
+}
+
+impl Unpin for __Foo {} //~ ERROR E0412,E0321
+
+fn main() {}
diff --git a/tests/ui/pin_project/unpin_sneaky.stderr b/tests/ui/pin_project/unpin_sneaky.stderr
new file mode 100644
index 0000000..0637a66
--- /dev/null
+++ b/tests/ui/pin_project/unpin_sneaky.stderr
@@ -0,0 +1,11 @@
+error[E0412]: cannot find type `__Foo` in this scope
+ --> $DIR/unpin_sneaky.rs:9:16
+ |
+9 | impl Unpin for __Foo {} //~ ERROR E0412,E0321
+ | ^^^^^ not found in this scope
+
+error[E0321]: cross-crate traits with a default impl, like `std::marker::Unpin`, can only be implemented for a struct/enum type, not `[type error]`
+ --> $DIR/unpin_sneaky.rs:9:1
+ |
+9 | impl Unpin for __Foo {} //~ ERROR E0412,E0321
+ | ^^^^^^^^^^^^^^^^^^^^ can't implement cross-crate trait with a default impl for non-struct/enum type
diff --git a/tests/ui/pin_project/visibility.rs b/tests/ui/pin_project/visibility.rs
new file mode 100644
index 0000000..4f0cb1b
--- /dev/null
+++ b/tests/ui/pin_project/visibility.rs
@@ -0,0 +1,52 @@
+mod pub_ {
+ use pin_project::pin_project;
+
+ #[pin_project]
+ pub struct Default(());
+
+ #[pin_project(Replace)]
+ pub struct Replace(());
+}
+pub mod pub_use {
+ #[rustfmt::skip]
+ pub use crate::pub_::__DefaultProjection; //~ ERROR E0365
+ #[rustfmt::skip]
+ pub use crate::pub_::__DefaultProjectionRef; //~ ERROR E0365
+ #[rustfmt::skip]
+ pub use crate::pub_::__ReplaceProjection; //~ ERROR E0365
+ #[rustfmt::skip]
+ pub use crate::pub_::__ReplaceProjectionOwned; //~ ERROR E0365
+ #[rustfmt::skip]
+ pub use crate::pub_::__ReplaceProjectionRef; //~ 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_::{
+ __DefaultProjection, __DefaultProjectionRef, __ReplaceProjection, __ReplaceProjectionOwned,
+ __ReplaceProjectionRef,
+ };
+}
+
+mod pub_crate {
+ use pin_project::pin_project;
+
+ #[pin_project]
+ pub(crate) struct Default(());
+
+ #[pin_project(Replace)]
+ pub(crate) struct Replace(());
+}
+pub mod pub_crate_use {
+ // Ok
+ #[allow(unused_imports)]
+ pub(crate) use crate::pub_crate::{
+ __DefaultProjection, __DefaultProjectionRef, __ReplaceProjection, __ReplaceProjectionOwned,
+ __ReplaceProjectionRef,
+ };
+}
+
+fn main() {}
diff --git a/tests/ui/pin_project/visibility.stderr b/tests/ui/pin_project/visibility.stderr
new file mode 100644
index 0000000..1ea60d7
--- /dev/null
+++ b/tests/ui/pin_project/visibility.stderr
@@ -0,0 +1,39 @@
+error[E0365]: `__DefaultProjection` is private, and cannot be re-exported
+ --> $DIR/visibility.rs:12:13
+ |
+12 | pub use crate::pub_::__DefaultProjection; //~ ERROR E0365
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ re-export of private `__DefaultProjection`
+ |
+ = note: consider declaring type or module `__DefaultProjection` with `pub`
+
+error[E0365]: `__DefaultProjectionRef` is private, and cannot be re-exported
+ --> $DIR/visibility.rs:14:13
+ |
+14 | pub use crate::pub_::__DefaultProjectionRef; //~ ERROR E0365
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ re-export of private `__DefaultProjectionRef`
+ |
+ = note: consider declaring type or module `__DefaultProjectionRef` with `pub`
+
+error[E0365]: `__ReplaceProjection` is private, and cannot be re-exported
+ --> $DIR/visibility.rs:16:13
+ |
+16 | pub use crate::pub_::__ReplaceProjection; //~ ERROR E0365
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ re-export of private `__ReplaceProjection`
+ |
+ = note: consider declaring type or module `__ReplaceProjection` with `pub`
+
+error[E0365]: `__ReplaceProjectionOwned` is private, and cannot be re-exported
+ --> $DIR/visibility.rs:18:13
+ |
+18 | pub use crate::pub_::__ReplaceProjectionOwned; //~ ERROR E0365
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ re-export of private `__ReplaceProjectionOwned`
+ |
+ = note: consider declaring type or module `__ReplaceProjectionOwned` with `pub`
+
+error[E0365]: `__ReplaceProjectionRef` is private, and cannot be re-exported
+ --> $DIR/visibility.rs:20:13
+ |
+20 | pub use crate::pub_::__ReplaceProjectionRef; //~ ERROR E0365
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ re-export of private `__ReplaceProjectionRef`
+ |
+ = note: consider declaring type or module `__ReplaceProjectionRef` with `pub`
diff --git a/tests/ui/pinned_drop/call-drop-inner.rs b/tests/ui/pinned_drop/call-drop-inner.rs
new file mode 100644
index 0000000..c953acb
--- /dev/null
+++ b/tests/ui/pinned_drop/call-drop-inner.rs
@@ -0,0 +1,16 @@
+use pin_project::{pin_project, pinned_drop};
+use std::pin::Pin;
+
+#[pin_project(PinnedDrop)]
+struct Struct {
+ dropped: bool,
+}
+
+#[pinned_drop]
+impl PinnedDrop for Struct {
+ fn drop(mut self: Pin<&mut Self>) {
+ __drop_inner(__self);
+ }
+}
+
+fn main() {}
diff --git a/tests/ui/pinned_drop/call-drop-inner.stderr b/tests/ui/pinned_drop/call-drop-inner.stderr
new file mode 100644
index 0000000..eb55ce7
--- /dev/null
+++ b/tests/ui/pinned_drop/call-drop-inner.stderr
@@ -0,0 +1,10 @@
+error[E0061]: this function takes 0 arguments but 1 argument was supplied
+ --> $DIR/call-drop-inner.rs:12:9
+ |
+9 | #[pinned_drop]
+ | -------------- defined here
+...
+12 | __drop_inner(__self);
+ | ^^^^^^^^^^^^ ------ supplied 1 argument
+ | |
+ | expected 0 arguments
diff --git a/tests/ui/pinned_drop/conditional-drop-impl.rs b/tests/ui/pinned_drop/conditional-drop-impl.rs
new file mode 100644
index 0000000..42d18b7
--- /dev/null
+++ b/tests/ui/pinned_drop/conditional-drop-impl.rs
@@ -0,0 +1,26 @@
+use pin_project::{pin_project, pinned_drop};
+use std::pin::Pin;
+
+// In `Drop` impl, the implementor must specify the same requirement as type definition.
+
+struct DropImpl<T> {
+ field: T,
+}
+
+impl<T: Unpin> Drop for DropImpl<T> {
+ //~^ ERROR E0367
+ fn drop(&mut self) {}
+}
+
+#[pin_project(PinnedDrop)] //~ ERROR E0277
+struct PinnedDropImpl<T> {
+ #[pin]
+ field: T,
+}
+
+#[pinned_drop]
+impl<T: Unpin> PinnedDrop for PinnedDropImpl<T> {
+ fn drop(self: Pin<&mut Self>) {}
+}
+
+fn main() {}
diff --git a/tests/ui/pinned_drop/conditional-drop-impl.stderr b/tests/ui/pinned_drop/conditional-drop-impl.stderr
new file mode 100644
index 0000000..ad8fb69
--- /dev/null
+++ b/tests/ui/pinned_drop/conditional-drop-impl.stderr
@@ -0,0 +1,26 @@
+error[E0367]: `Drop` impl requires `T: std::marker::Unpin` but the struct it is implemented for does not
+ --> $DIR/conditional-drop-impl.rs:10:9
+ |
+10 | impl<T: Unpin> Drop for DropImpl<T> {
+ | ^^^^^
+ |
+note: the implementor must specify the same requirement
+ --> $DIR/conditional-drop-impl.rs:6:1
+ |
+6 | / struct DropImpl<T> {
+7 | | field: T,
+8 | | }
+ | |_^
+
+error[E0277]: `T` cannot be unpinned
+ --> $DIR/conditional-drop-impl.rs:15:15
+ |
+15 | #[pin_project(PinnedDrop)] //~ ERROR E0277
+ | ^^^^^^^^^^ the trait `std::marker::Unpin` is not implemented for `T`
+ |
+ = note: required because of the requirements on the impl of `pin_project::__private::PinnedDrop` for `PinnedDropImpl<T>`
+ = note: required by `pin_project::__private::PinnedDrop::drop`
+help: consider restricting type parameter `T`
+ |
+16 | struct PinnedDropImpl<T: std::marker::Unpin> {
+ | ^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/pinned_drop/forget-pinned-drop-impl.rs b/tests/ui/pinned_drop/forget-pinned-drop-impl.rs
new file mode 100644
index 0000000..6c9f718
--- /dev/null
+++ b/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]
+ field: u8,
+}
+
+fn main() {}
diff --git a/tests/ui/pinned_drop/forget-pinned-drop-impl.stderr b/tests/ui/pinned_drop/forget-pinned-drop-impl.stderr
new file mode 100644
index 0000000..67bdbe1
--- /dev/null
+++ b/tests/ui/pinned_drop/forget-pinned-drop-impl.stderr
@@ -0,0 +1,7 @@
+error[E0277]: the trait bound `Struct: pin_project::__private::PinnedDrop` is not satisfied
+ --> $DIR/forget-pinned-drop-impl.rs:3:15
+ |
+3 | #[pin_project(PinnedDrop)] //~ ERROR E0277
+ | ^^^^^^^^^^ the trait `pin_project::__private::PinnedDrop` is not implemented for `Struct`
+ |
+ = note: required by `pin_project::__private::PinnedDrop::drop`
diff --git a/tests/ui/pinned_drop/invalid-self.rs b/tests/ui/pinned_drop/invalid-self.rs
new file mode 100644
index 0000000..73d3b43
--- /dev/null
+++ b/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 Struct {}
+
+impl Struct {
+ 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 @ Struct {}: Self) {} //~ ERROR expected one of `)`, `,`, or `:`, found `@`
+}
+
+fn main() {}
diff --git a/tests/ui/pinned_drop/invalid-self.stderr b/tests/ui/pinned_drop/invalid-self.stderr
new file mode 100644
index 0000000..a43e91d
--- /dev/null
+++ b/tests/ui/pinned_drop/invalid-self.stderr
@@ -0,0 +1,25 @@
+error: expected identifier, found keyword `self`
+ --> $DIR/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`
+ --> $DIR/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 `@`
+ --> $DIR/invalid-self.rs:11:25
+ |
+11 | fn self_subpat(self @ Struct {}: Self) {} //~ ERROR expected one of `)`, `,`, or `:`, found `@`
+ | ^ expected parameter name
+
+error: expected one of `)`, `,`, or `:`, found `@`
+ --> $DIR/invalid-self.rs:11:25
+ |
+11 | fn self_subpat(self @ Struct {}: Self) {} //~ ERROR expected one of `)`, `,`, or `:`, found `@`
+ | -^ expected one of `)`, `,`, or `:`
+ | |
+ | help: missing `,`
diff --git a/tests/ui/pinned_drop/invalid.rs b/tests/ui/pinned_drop/invalid.rs
new file mode 100644
index 0000000..9ff5de2
--- /dev/null
+++ b/tests/ui/pinned_drop/invalid.rs
@@ -0,0 +1,207 @@
+mod argument {
+ use pin_project::{pin_project, pinned_drop};
+ use std::pin::Pin;
+
+ #[pin_project(PinnedDrop)]
+ struct UnexpectedArg1(());
+
+ #[pinned_drop(foo)] //~ ERROR unexpected token
+ 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 drop(_: 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 pin_project::{pin_project, pinned_drop};
+ use std::pin::Pin;
+
+ #[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(&mut self) {} //~ ERROR method `pinned_drop` is not a member of trait `PinnedDrop
+ }
+}
+
+fn main() {}
diff --git a/tests/ui/pinned_drop/invalid.stderr b/tests/ui/pinned_drop/invalid.stderr
new file mode 100644
index 0000000..8046903
--- /dev/null
+++ b/tests/ui/pinned_drop/invalid.stderr
@@ -0,0 +1,125 @@
+error: unexpected token: foo
+ --> $DIR/invalid.rs:8:19
+ |
+8 | #[pinned_drop(foo)] //~ ERROR unexpected token
+ | ^^^
+
+error: duplicate #[pinned_drop] attribute
+ --> $DIR/invalid.rs:29:5
+ |
+29 | #[pinned_drop] //~ ERROR duplicate #[pinned_drop] attribute
+ | ^^^^^^^^^^^^^^
+
+error: #[pinned_drop] may only be used on implementation for the `PinnedDrop` trait
+ --> $DIR/invalid.rs:42:10
+ |
+42 | 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
+ --> $DIR/invalid.rs:48:10
+ |
+48 | impl InherentImpl {} //~ ERROR may only be used on implementation for the `PinnedDrop` trait
+ | ^^^^^^^^^^^^
+
+error: expected `impl`
+ --> $DIR/invalid.rs:51:5
+ |
+51 | fn drop(_: Pin<&mut ()>) {} //~ ERROR expected `impl`
+ | ^^
+
+error: implementing the trait `PinnedDrop` is not unsafe
+ --> $DIR/invalid.rs:61:5
+ |
+61 | unsafe impl PinnedDrop for Impl {
+ | ^^^^^^
+
+error: implementing the method `drop` is not unsafe
+ --> $DIR/invalid.rs:71:9
+ |
+71 | unsafe fn drop(self: Pin<&mut Self>) {} //~ ERROR implementing the method `drop` is not unsafe
+ | ^^^^^^
+
+error: not all trait items implemented, missing: `drop`
+ --> $DIR/invalid.rs:82:5
+ |
+82 | impl PinnedDrop for Empty {} //~ ERROR not all trait items implemented, missing: `drop`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: const `A` is not a member of trait `PinnedDrop`
+ --> $DIR/invalid.rs:89:9
+ |
+89 | const A: u8 = 0; //~ ERROR const `A` is not a member of trait `PinnedDrop`
+ | ^^^^^^^^^^^^^^^^
+
+error: const `A` is not a member of trait `PinnedDrop`
+ --> $DIR/invalid.rs:99:9
+ |
+99 | const A: u8 = 0; //~ ERROR const `A` is not a member of trait `PinnedDrop`
+ | ^^^^^^^^^^^^^^^^
+
+error: type `A` is not a member of trait `PinnedDrop`
+ --> $DIR/invalid.rs:107:9
+ |
+107 | type A = u8; //~ ERROR type `A` is not a member of trait `PinnedDrop`
+ | ^^^^^^^^^^^^
+
+error: type `A` is not a member of trait `PinnedDrop`
+ --> $DIR/invalid.rs:117:9
+ |
+117 | type A = u8; //~ ERROR type `A` is not a member of trait `PinnedDrop`
+ | ^^^^^^^^^^^^
+
+error: duplicate definitions with name `drop`
+ --> $DIR/invalid.rs:126:9
+ |
+126 | fn drop(self: Pin<&mut Self>) {} //~ ERROR duplicate definitions with name `drop`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: method `drop` must return the unit type
+ --> $DIR/invalid.rs:147:42
+ |
+147 | 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>`
+ --> $DIR/invalid.rs:155:16
+ |
+155 | fn drop() {} //~ ERROR method `drop` must take an argument `self: Pin<&mut Self>`
+ | ^^
+
+error: method `drop` must take an argument `self: Pin<&mut Self>`
+ --> $DIR/invalid.rs:163:17
+ |
+163 | 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>`
+ --> $DIR/invalid.rs:171:17
+ |
+171 | 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>`
+ --> $DIR/invalid.rs:179:17
+ |
+179 | 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>`
+ --> $DIR/invalid.rs:187:17
+ |
+187 | 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>`
+ --> $DIR/invalid.rs:195:17
+ |
+195 | 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
+ --> $DIR/invalid.rs:203:12
+ |
+203 | fn pinned_drop(&mut self) {} //~ ERROR method `pinned_drop` is not a member of trait `PinnedDrop
+ | ^^^^^^^^^^^
diff --git a/tests/ui/pinned_drop/pinned-drop-no-attr-arg.rs b/tests/ui/pinned_drop/pinned-drop-no-attr-arg.rs
new file mode 100644
index 0000000..1241b5b
--- /dev/null
+++ b/tests/ui/pinned_drop/pinned-drop-no-attr-arg.rs
@@ -0,0 +1,15 @@
+use pin_project::{pin_project, pinned_drop};
+use std::pin::Pin;
+
+#[pin_project]
+struct Foo {
+ #[pin]
+ field: u8,
+}
+
+#[pinned_drop]
+impl PinnedDrop for Foo { //~ ERROR E0119
+ fn drop(self: Pin<&mut Self>) {}
+}
+
+fn main() {}
diff --git a/tests/ui/pinned_drop/pinned-drop-no-attr-arg.stderr b/tests/ui/pinned_drop/pinned-drop-no-attr-arg.stderr
new file mode 100644
index 0000000..7353dc4
--- /dev/null
+++ b/tests/ui/pinned_drop/pinned-drop-no-attr-arg.stderr
@@ -0,0 +1,8 @@
+error[E0119]: conflicting implementations of trait `pin_project::__private::PinnedDrop` for type `Foo`:
+ --> $DIR/pinned-drop-no-attr-arg.rs:11:1
+ |
+4 | #[pin_project]
+ | -------------- first implementation here
+...
+11 | impl PinnedDrop for Foo { //~ ERROR E0119
+ | ^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `Foo`
diff --git a/tests/ui/pinned_drop/self.rs b/tests/ui/pinned_drop/self.rs
new file mode 100644
index 0000000..cd53b04
--- /dev/null
+++ b/tests/ui/pinned_drop/self.rs
@@ -0,0 +1,28 @@
+use pin_project::{pin_project, pinned_drop};
+use std::pin::Pin;
+
+fn self_in_macro_def() {
+ #[pin_project(PinnedDrop)]
+ pub struct Struct {
+ x: usize,
+ }
+
+ #[pinned_drop]
+ impl PinnedDrop for Struct {
+ fn drop(self: Pin<&mut Self>) {
+ macro_rules! t {
+ () => {{
+ let _ = self; //~ ERROR can't capture dynamic environment in a fn item
+
+ fn f(self: ()) {
+ //~^ ERROR `self` parameter is only allowed in associated functions
+ let _ = self;
+ }
+ }};
+ }
+ t!();
+ }
+ }
+}
+
+fn main() {}
diff --git a/tests/ui/pinned_drop/self.stderr b/tests/ui/pinned_drop/self.stderr
new file mode 100644
index 0000000..3ba333b
--- /dev/null
+++ b/tests/ui/pinned_drop/self.stderr
@@ -0,0 +1,23 @@
+error: `self` parameter is only allowed in associated functions
+ --> $DIR/self.rs:17:26
+ |
+17 | fn f(self: ()) {
+ | ^^^^ not semantically valid as function parameter
+...
+23 | t!();
+ | ----- in this macro invocation
+ |
+ = note: associated functions are those in `impl` or `trait` definitions
+ = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0434]: can't capture dynamic environment in a fn item
+ --> $DIR/self.rs:15:29
+ |
+15 | let _ = self; //~ ERROR can't capture dynamic environment in a fn item
+ | ^^^^
+...
+23 | t!();
+ | ----- in this macro invocation
+ |
+ = help: use the `|| { ... }` closure form instead
+ = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/tests/ui/pinned_drop/unsafe-call.rs b/tests/ui/pinned_drop/unsafe-call.rs
new file mode 100644
index 0000000..2f400c1
--- /dev/null
+++ b/tests/ui/pinned_drop/unsafe-call.rs
@@ -0,0 +1,17 @@
+use pin_project::{pin_project, pinned_drop};
+use std::pin::Pin;
+
+#[pin_project(PinnedDrop)]
+struct Struct {
+ #[pin]
+ field: u8,
+}
+
+#[pinned_drop]
+impl PinnedDrop for Struct {
+ fn drop(self: Pin<&mut Self>) {
+ self.project().field.get_unchecked_mut(); //~ ERROR call to unsafe function is unsafe and requires unsafe function or block [E0133]
+ }
+}
+
+fn main() {}
diff --git a/tests/ui/pinned_drop/unsafe-call.stderr b/tests/ui/pinned_drop/unsafe-call.stderr
new file mode 100644
index 0000000..4e8e00b
--- /dev/null
+++ b/tests/ui/pinned_drop/unsafe-call.stderr
@@ -0,0 +1,7 @@
+error[E0133]: call to unsafe function is unsafe and requires unsafe function or block
+ --> $DIR/unsafe-call.rs:13:9
+ |
+13 | self.project().field.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/tests/ui/project/ambiguous-let.rs b/tests/ui/project/ambiguous-let.rs
new file mode 100644
index 0000000..a706749
--- /dev/null
+++ b/tests/ui/project/ambiguous-let.rs
@@ -0,0 +1,24 @@
+use pin_project::{pin_project, project};
+
+#[pin_project]
+enum Enum<A, B> {
+ A(#[pin] A),
+ B(B),
+}
+
+struct Struct<T>(T);
+
+#[project]
+fn foo() {
+ let mut foo: Enum<bool, bool> = Enum::A(true);
+
+ #[project]
+ let Struct(x) = match Pin::new(&mut foo).project() {
+ //~^ ERROR Both initializer expression and pattern are replaceable, you need to split the initializer expression into separate let bindings to avoid ambiguity
+ Enum::A(_) => Struct(true),
+ Enum::B(_) => unreachable!(),
+ };
+ assert!(x);
+}
+
+fn main() {}
diff --git a/tests/ui/project/ambiguous-let.stderr b/tests/ui/project/ambiguous-let.stderr
new file mode 100644
index 0000000..e6552c8
--- /dev/null
+++ b/tests/ui/project/ambiguous-let.stderr
@@ -0,0 +1,5 @@
+error: Both initializer expression and pattern are replaceable, you need to split the initializer expression into separate let bindings to avoid ambiguity
+ --> $DIR/ambiguous-let.rs:16:9
+ |
+16 | let Struct(x) = match Pin::new(&mut foo).project() {
+ | ^^^^^^^^^
diff --git a/tests/ui/project/invalid.rs b/tests/ui/project/invalid.rs
new file mode 100644
index 0000000..07e9970
--- /dev/null
+++ b/tests/ui/project/invalid.rs
@@ -0,0 +1,190 @@
+mod argument {
+ use pin_project::{pin_project, project};
+
+ #[pin_project]
+ struct A(#[pin] ());
+
+ #[project]
+ fn unexpected_local1() {
+ let mut x = A(());
+ #[project()] //~ ERROR unexpected token
+ let A(_) = Pin::new(&mut x).project();
+ }
+
+ #[project]
+ fn unexpected_local1() {
+ let mut x = A(());
+ #[project(foo)] //~ ERROR unexpected token
+ let A(_) = Pin::new(&mut x).project();
+ }
+
+ #[project]
+ fn unexpected_expr1() {
+ let mut x = A(());
+ #[project()] //~ ERROR unexpected token
+ match Pin::new(&mut x).project() {
+ A(_) => {}
+ }
+ }
+
+ #[project]
+ fn unexpected_expr1() {
+ let mut x = A(());
+ #[project(foo)] //~ ERROR unexpected token
+ match Pin::new(&mut x).project() {
+ A(_) => {}
+ }
+ }
+
+ #[project()] // Ok
+ fn unexpected_item1() {}
+
+ #[project(foo)] //~ ERROR unexpected token
+ fn unexpected_item2() {}
+}
+
+mod attribute {
+ use pin_project::{pin_project, project, project_ref, project_replace};
+
+ #[pin_project(Replace)]
+ struct A(#[pin] ());
+
+ #[project]
+ fn duplicate_stmt_project() {
+ let mut x = A(());
+ #[project]
+ #[project] //~ ERROR duplicate #[project] attribute
+ let A(_) = Pin::new(&mut x).project();
+ }
+
+ #[project_ref]
+ fn duplicate_stmt_project_ref() {
+ let mut x = A(());
+ #[project_ref]
+ #[project_ref] //~ ERROR duplicate #[project_ref] attribute
+ let A(_) = Pin::new(&mut x).project();
+ }
+
+ #[project_replace]
+ fn duplicate_stmt_project_replace() {
+ let mut x = A(());
+ #[project_replace]
+ #[project_replace] //~ ERROR duplicate #[project_replace] attribute
+ let A(_) = Pin::new(&mut x).project();
+ }
+
+ #[project]
+ fn combine_stmt_project1() {
+ let mut x = A(());
+ #[project]
+ #[project_ref] //~ ERROR are mutually exclusive
+ let A(_) = Pin::new(&mut x).project();
+ }
+
+ #[project]
+ fn combine_stmt_project2() {
+ let mut x = A(());
+ #[project]
+ #[project_replace] //~ ERROR are mutually exclusive
+ let A(_) = Pin::new(&mut x).project();
+ }
+
+ #[project]
+ fn combine_stmt_project3() {
+ let mut x = A(());
+ #[project_ref]
+ #[project_replace] //~ ERROR are mutually exclusive
+ let A(_) = Pin::new(&mut x).project();
+ }
+
+ #[project_ref]
+ fn combine_stmt_project_ref1() {
+ let mut x = A(());
+ #[project]
+ #[project_ref] //~ ERROR are mutually exclusive
+ let A(_) = Pin::new(&mut x).project();
+ }
+
+ #[project_ref]
+ fn combine_stmt_project_ref2() {
+ let mut x = A(());
+ #[project]
+ #[project_replace] //~ ERROR are mutually exclusive
+ let A(_) = Pin::new(&mut x).project();
+ }
+
+ #[project_ref]
+ fn combine_stmt_project_ref3() {
+ let mut x = A(());
+ #[project_ref]
+ #[project_replace] //~ ERROR are mutually exclusive
+ let A(_) = Pin::new(&mut x).project();
+ }
+
+ #[project_replace]
+ fn combine_stmt_project_replace1() {
+ let mut x = A(());
+ #[project]
+ #[project_ref] //~ ERROR are mutually exclusive
+ let A(_) = Pin::new(&mut x).project();
+ }
+
+ #[project_replace]
+ fn combine_stmt_project_replace2() {
+ let mut x = A(());
+ #[project]
+ #[project_replace] //~ ERROR are mutually exclusive
+ let A(_) = Pin::new(&mut x).project();
+ }
+
+ #[project_replace]
+ fn combine_stmt_project_replace3() {
+ let mut x = A(());
+ #[project_ref]
+ #[project_replace] //~ ERROR are mutually exclusive
+ let A(_) = Pin::new(&mut x).project();
+ }
+
+ #[project]
+ #[project] //~ ERROR duplicate #[project] attribute
+ fn duplicate_fn_project() {}
+
+ #[project_ref]
+ #[project_ref] //~ ERROR duplicate #[project_ref] attribute
+ fn duplicate_fn_project_ref() {}
+
+ #[project_replace]
+ #[project_replace] //~ ERROR duplicate #[project_replace] attribute
+ fn duplicate_fn_project_replace() {}
+
+ #[project]
+ #[project] //~ ERROR duplicate #[project] attribute
+ impl A {}
+
+ #[project_ref]
+ #[project_ref] //~ ERROR duplicate #[project_ref] attribute
+ impl A {}
+
+ #[project_replace]
+ #[project_replace] //~ ERROR duplicate #[project_replace] attribute
+ impl A {}
+
+ #[allow(unused_imports)]
+ mod use_ {
+ use pin_project::{project, project_ref, project_replace};
+
+ #[project]
+ #[project] //~ ERROR duplicate #[project] attribute
+ use super::A;
+
+ #[project_ref]
+ #[project_ref] //~ ERROR duplicate #[project_ref] attribute
+ use super::A;
+
+ #[project_replace]
+ #[project_replace] //~ ERROR duplicate #[project_replace] attribute
+ use super::A;
+ }
+}
+
+fn main() {}
diff --git a/tests/ui/project/invalid.stderr b/tests/ui/project/invalid.stderr
new file mode 100644
index 0000000..287cac8
--- /dev/null
+++ b/tests/ui/project/invalid.stderr
@@ -0,0 +1,155 @@
+error: unexpected token: ()
+ --> $DIR/invalid.rs:10:18
+ |
+10 | #[project()] //~ ERROR unexpected token
+ | ^^
+
+error: unexpected token: (foo)
+ --> $DIR/invalid.rs:17:18
+ |
+17 | #[project(foo)] //~ ERROR unexpected token
+ | ^^^^^
+
+error: unexpected token: ()
+ --> $DIR/invalid.rs:24:18
+ |
+24 | #[project()] //~ ERROR unexpected token
+ | ^^
+
+error: unexpected token: (foo)
+ --> $DIR/invalid.rs:33:18
+ |
+33 | #[project(foo)] //~ ERROR unexpected token
+ | ^^^^^
+
+error: unexpected token: foo
+ --> $DIR/invalid.rs:42:15
+ |
+42 | #[project(foo)] //~ ERROR unexpected token
+ | ^^^
+
+error: duplicate #[project] attribute
+ --> $DIR/invalid.rs:56:9
+ |
+56 | #[project] //~ ERROR duplicate #[project] attribute
+ | ^^^^^^^^^^
+
+error: duplicate #[project_ref] attribute
+ --> $DIR/invalid.rs:64:9
+ |
+64 | #[project_ref] //~ ERROR duplicate #[project_ref] attribute
+ | ^^^^^^^^^^^^^^
+
+error: duplicate #[project_replace] attribute
+ --> $DIR/invalid.rs:72:9
+ |
+72 | #[project_replace] //~ ERROR duplicate #[project_replace] attribute
+ | ^^^^^^^^^^^^^^^^^^
+
+error: attributes `project_ref` and `project` are mutually exclusive
+ --> $DIR/invalid.rs:79:9
+ |
+79 | #[project]
+ | ^^^^^^^^^^
+
+error: attributes `project` and `project_replace` are mutually exclusive
+ --> $DIR/invalid.rs:88:9
+ |
+88 | #[project_replace] //~ ERROR are mutually exclusive
+ | ^^^^^^^^^^^^^^^^^^
+
+error: attributes `project_ref` and `project_replace` are mutually exclusive
+ --> $DIR/invalid.rs:96:9
+ |
+96 | #[project_replace] //~ ERROR are mutually exclusive
+ | ^^^^^^^^^^^^^^^^^^
+
+error: attributes `project_ref` and `project` are mutually exclusive
+ --> $DIR/invalid.rs:103:9
+ |
+103 | #[project]
+ | ^^^^^^^^^^
+
+error: attributes `project` and `project_replace` are mutually exclusive
+ --> $DIR/invalid.rs:112:9
+ |
+112 | #[project_replace] //~ ERROR are mutually exclusive
+ | ^^^^^^^^^^^^^^^^^^
+
+error: attributes `project_ref` and `project_replace` are mutually exclusive
+ --> $DIR/invalid.rs:120:9
+ |
+120 | #[project_replace] //~ ERROR are mutually exclusive
+ | ^^^^^^^^^^^^^^^^^^
+
+error: attributes `project_ref` and `project` are mutually exclusive
+ --> $DIR/invalid.rs:127:9
+ |
+127 | #[project]
+ | ^^^^^^^^^^
+
+error: attributes `project` and `project_replace` are mutually exclusive
+ --> $DIR/invalid.rs:136:9
+ |
+136 | #[project_replace] //~ ERROR are mutually exclusive
+ | ^^^^^^^^^^^^^^^^^^
+
+error: attributes `project_ref` and `project_replace` are mutually exclusive
+ --> $DIR/invalid.rs:144:9
+ |
+144 | #[project_replace] //~ ERROR are mutually exclusive
+ | ^^^^^^^^^^^^^^^^^^
+
+error: duplicate #[project] attribute
+ --> $DIR/invalid.rs:149:5
+ |
+149 | #[project] //~ ERROR duplicate #[project] attribute
+ | ^^^^^^^^^^
+
+error: duplicate #[project_ref] attribute
+ --> $DIR/invalid.rs:153:5
+ |
+153 | #[project_ref] //~ ERROR duplicate #[project_ref] attribute
+ | ^^^^^^^^^^^^^^
+
+error: duplicate #[project_replace] attribute
+ --> $DIR/invalid.rs:157:5
+ |
+157 | #[project_replace] //~ ERROR duplicate #[project_replace] attribute
+ | ^^^^^^^^^^^^^^^^^^
+
+error: duplicate #[project] attribute
+ --> $DIR/invalid.rs:161:5
+ |
+161 | #[project] //~ ERROR duplicate #[project] attribute
+ | ^^^^^^^^^^
+
+error: duplicate #[project_ref] attribute
+ --> $DIR/invalid.rs:165:5
+ |
+165 | #[project_ref] //~ ERROR duplicate #[project_ref] attribute
+ | ^^^^^^^^^^^^^^
+
+error: duplicate #[project_replace] attribute
+ --> $DIR/invalid.rs:169:5
+ |
+169 | #[project_replace] //~ ERROR duplicate #[project_replace] attribute
+ | ^^^^^^^^^^^^^^^^^^
+
+error: duplicate #[project] attribute
+ --> $DIR/invalid.rs:177:9
+ |
+177 | #[project] //~ ERROR duplicate #[project] attribute
+ | ^^^^^^^^^^
+
+error: duplicate #[project_ref] attribute
+ --> $DIR/invalid.rs:181:9
+ |
+181 | #[project_ref] //~ ERROR duplicate #[project_ref] attribute
+ | ^^^^^^^^^^^^^^
+
+error: duplicate #[project_replace] attribute
+ --> $DIR/invalid.rs:185:9
+ |
+185 | #[project_replace] //~ ERROR duplicate #[project_replace] attribute
+ | ^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/project/type-mismatch.rs b/tests/ui/project/type-mismatch.rs
new file mode 100644
index 0000000..41a70eb
--- /dev/null
+++ b/tests/ui/project/type-mismatch.rs
@@ -0,0 +1,74 @@
+#![feature(proc_macro_hygiene, stmt_expr_attributes)]
+
+use pin_project::{pin_project, project};
+use std::pin::Pin;
+
+#[project]
+fn type_mismatch() {
+ #[pin_project]
+ enum Enum<A, B, C, D> {
+ Variant1(#[pin] A, B),
+ Variant2 {
+ #[pin]
+ field1: C,
+ field2: D,
+ },
+ None,
+ }
+
+ let mut foo = Enum::Variant1(1, 2);
+ let mut foo = Pin::new(&mut foo).project();
+
+ #[project]
+ match &mut foo {
+ Enum::Variant1(x, y) => {
+ let x: &mut Pin<&mut i32> = x;
+ assert_eq!(**x, 1);
+
+ let y: &mut &mut i32 = y;
+ assert_eq!(**y, 2);
+ }
+ Enum::Variant2 { field1, field2 } => {
+ let _x: &mut Pin<&mut i32> = field1;
+ let _y: &mut &mut i32 = field2;
+ }
+ None => {} //~ ERROR mismatched types
+ }
+}
+
+//~ ERROR mismatched types
+// span is lost.
+// Refs: https://github.com/rust-lang/rust/issues/43081
+fn type_mismatch_span_issue() {
+ #[pin_project]
+ enum Enum<A, B, C, D> {
+ Variant1(#[pin] A, B),
+ Variant2 {
+ #[pin]
+ field1: C,
+ field2: D,
+ },
+ None,
+ }
+
+ let mut foo = Enum::Variant1(1, 2);
+ let mut foo = Pin::new(&mut foo).project();
+
+ #[project]
+ match &mut foo {
+ Enum::Variant1(x, y) => {
+ let x: &mut Pin<&mut i32> = x;
+ assert_eq!(**x, 1);
+
+ let y: &mut &mut i32 = y;
+ assert_eq!(**y, 2);
+ }
+ Enum::Variant2 { field1, field2 } => {
+ let _x: &mut Pin<&mut i32> = field1;
+ let _y: &mut &mut i32 = field2;
+ }
+ None => {}
+ }
+}
+
+fn main() {}
diff --git a/tests/ui/project/type-mismatch.stderr b/tests/ui/project/type-mismatch.stderr
new file mode 100644
index 0000000..b4c97d5
--- /dev/null
+++ b/tests/ui/project/type-mismatch.stderr
@@ -0,0 +1,16 @@
+error[E0308]: mismatched types
+ --> $DIR/type-mismatch.rs:35:9
+ |
+23 | match &mut foo {
+ | -------- this expression has type `&mut type_mismatch::__EnumProjection<'_, {integer}, {integer}, _, _>`
+...
+35 | None => {} //~ ERROR mismatched types
+ | ^^^^ expected enum `type_mismatch::__EnumProjection`, found enum `std::option::Option`
+ |
+ = note: expected enum `type_mismatch::__EnumProjection<'_, {integer}, {integer}, _, _>`
+ found enum `std::option::Option<_>`
+
+error[E0308]: mismatched types
+ |
+ = note: expected enum `type_mismatch_span_issue::__EnumProjection<'_, {integer}, {integer}, _, _>`
+ found enum `std::option::Option<_>`
diff --git a/tests/ui/project/use-public.rs b/tests/ui/project/use-public.rs
new file mode 100644
index 0000000..23c9b89
--- /dev/null
+++ b/tests/ui/project/use-public.rs
@@ -0,0 +1,15 @@
+use pin_project::pin_project;
+
+#[pin_project]
+struct A {
+ field: u8,
+}
+
+pub mod b {
+ use pin_project::project;
+
+ #[project]
+ pub use crate::A; //~ ERROR E0365
+}
+
+fn main() {}
diff --git a/tests/ui/project/use-public.stderr b/tests/ui/project/use-public.stderr
new file mode 100644
index 0000000..7919d65
--- /dev/null
+++ b/tests/ui/project/use-public.stderr
@@ -0,0 +1,7 @@
+error[E0365]: `__AProjection` is private, and cannot be re-exported
+ --> $DIR/use-public.rs:12:13
+ |
+12 | pub use crate::A; //~ ERROR E0365
+ | ^^^^^^^^ re-export of private `__AProjection`
+ |
+ = note: consider declaring type or module `__AProjection` with `pub`
diff --git a/tests/ui/project/use.rs b/tests/ui/project/use.rs
new file mode 100644
index 0000000..d4b02c1
--- /dev/null
+++ b/tests/ui/project/use.rs
@@ -0,0 +1,17 @@
+use pin_project::pin_project;
+
+#[pin_project]
+struct A {
+ field: u8,
+}
+
+mod b {
+ use pin_project::project;
+
+ #[project]
+ use crate::A as B; //~ ERROR #[project] attribute may not be used on renamed imports
+ #[project]
+ use crate::*; //~ ERROR #[project] attribute may not be used on glob imports
+}
+
+fn main() {}
diff --git a/tests/ui/project/use.stderr b/tests/ui/project/use.stderr
new file mode 100644
index 0000000..07d0241
--- /dev/null
+++ b/tests/ui/project/use.stderr
@@ -0,0 +1,11 @@
+error: #[project] attribute may not be used on renamed imports
+ --> $DIR/use.rs:12:16
+ |
+12 | use crate::A as B; //~ ERROR #[project] attribute may not be used on renamed imports
+ | ^^^^^^
+
+error: #[project] attribute may not be used on glob imports
+ --> $DIR/use.rs:14:16
+ |
+14 | use crate::*; //~ ERROR #[project] attribute may not be used on glob imports
+ | ^
diff --git a/tests/ui/unsafe_unpin/conflict-unpin.rs b/tests/ui/unsafe_unpin/conflict-unpin.rs
new file mode 100644
index 0000000..e0c8a7b
--- /dev/null
+++ b/tests/ui/unsafe_unpin/conflict-unpin.rs
@@ -0,0 +1,30 @@
+use pin_project::pin_project;
+
+#[pin_project(UnsafeUnpin)] //~ ERROR E0119
+struct Foo<T, U> {
+ #[pin]
+ future: T,
+ field: U,
+}
+
+impl<T, U> Unpin for Foo<T, U> where T: Unpin {}
+
+#[pin_project(UnsafeUnpin)] //~ ERROR E0119
+struct Bar<T, U> {
+ #[pin]
+ future: T,
+ field: U,
+}
+
+impl<T, U> Unpin for Bar<T, U> {}
+
+#[pin_project(UnsafeUnpin)] //~ ERROR E0119
+struct Baz<T, U> {
+ #[pin]
+ future: T,
+ field: U,
+}
+
+impl<T: Unpin, U: Unpin> Unpin for Baz<T, U> {}
+
+fn main() {}
diff --git a/tests/ui/unsafe_unpin/conflict-unpin.stderr b/tests/ui/unsafe_unpin/conflict-unpin.stderr
new file mode 100644
index 0000000..62de016
--- /dev/null
+++ b/tests/ui/unsafe_unpin/conflict-unpin.stderr
@@ -0,0 +1,35 @@
+error[E0119]: conflicting implementations of trait `std::marker::Unpin` for type `Foo<_, _>`:
+ --> $DIR/conflict-unpin.rs:3:1
+ |
+3 | #[pin_project(UnsafeUnpin)] //~ ERROR E0119
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `Foo<_, _>`
+...
+10 | impl<T, U> Unpin for Foo<T, U> where T: Unpin {}
+ | --------------------------------------------- first implementation here
+ |
+ = note: upstream crates may add a new impl of trait `pin_project::UnsafeUnpin` for type `pin_project::__private::Wrapper<'_, Foo<_, _>>` in future versions
+ = note: this error originates in a derive macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0119]: conflicting implementations of trait `std::marker::Unpin` for type `Bar<_, _>`:
+ --> $DIR/conflict-unpin.rs:12:1
+ |
+12 | #[pin_project(UnsafeUnpin)] //~ ERROR E0119
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `Bar<_, _>`
+...
+19 | impl<T, U> Unpin for Bar<T, U> {}
+ | ------------------------------ first implementation here
+ |
+ = note: upstream crates may add a new impl of trait `pin_project::UnsafeUnpin` for type `pin_project::__private::Wrapper<'_, Bar<_, _>>` in future versions
+ = note: this error originates in a derive macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0119]: conflicting implementations of trait `std::marker::Unpin` for type `Baz<_, _>`:
+ --> $DIR/conflict-unpin.rs:21:1
+ |
+21 | #[pin_project(UnsafeUnpin)] //~ ERROR E0119
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `Baz<_, _>`
+...
+28 | impl<T: Unpin, U: Unpin> Unpin for Baz<T, U> {}
+ | -------------------------------------------- first implementation here
+ |
+ = note: upstream crates may add a new impl of trait `pin_project::UnsafeUnpin` for type `pin_project::__private::Wrapper<'_, Baz<_, _>>` in future versions
+ = note: this error originates in a derive macro (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/tests/ui/unsafe_unpin/not-implement-unsafe-unpin.rs b/tests/ui/unsafe_unpin/not-implement-unsafe-unpin.rs
new file mode 100644
index 0000000..429d60f
--- /dev/null
+++ b/tests/ui/unsafe_unpin/not-implement-unsafe-unpin.rs
@@ -0,0 +1,14 @@
+use pin_project::pin_project;
+
+#[pin_project(UnsafeUnpin)]
+struct Struct<T, U> {
+ #[pin]
+ inner: T,
+ other: U,
+}
+
+fn is_unpin<T: Unpin>() {}
+
+fn main() {
+ is_unpin::<Struct<(), ()>>(); //~ ERROR E0277
+}
diff --git a/tests/ui/unsafe_unpin/not-implement-unsafe-unpin.stderr b/tests/ui/unsafe_unpin/not-implement-unsafe-unpin.stderr
new file mode 100644
index 0000000..0baefe3
--- /dev/null
+++ b/tests/ui/unsafe_unpin/not-implement-unsafe-unpin.stderr
@@ -0,0 +1,11 @@
+error[E0277]: the trait bound `Struct<(), ()>: pin_project::UnsafeUnpin` is not satisfied
+ --> $DIR/not-implement-unsafe-unpin.rs:13:16
+ |
+10 | fn is_unpin<T: Unpin>() {}
+ | ----- required by this bound in `is_unpin`
+...
+13 | is_unpin::<Struct<(), ()>>(); //~ ERROR E0277
+ | ^^^^^^^^^^^^^^ the trait `pin_project::UnsafeUnpin` is not implemented for `Struct<(), ()>`
+ |
+ = note: required because of the requirements on the impl of `pin_project::UnsafeUnpin` for `pin_project::__private::Wrapper<'_, Struct<(), ()>>`
+ = note: required because of the requirements on the impl of `std::marker::Unpin` for `Struct<(), ()>`
diff --git a/tests/ui/unsafe_unpin/proper_unpin.rs b/tests/ui/unsafe_unpin/proper_unpin.rs
new file mode 100644
index 0000000..6573aec
--- /dev/null
+++ b/tests/ui/unsafe_unpin/proper_unpin.rs
@@ -0,0 +1,41 @@
+use pin_project::{pin_project, UnsafeUnpin};
+use std::marker::PhantomPinned;
+
+fn is_unpin<T: Unpin>() {}
+
+#[pin_project(UnsafeUnpin)]
+struct Blah<T, U> {
+ field1: U,
+ #[pin]
+ field2: T,
+}
+
+unsafe impl<T: Unpin, U> UnsafeUnpin for Blah<T, U> {}
+
+#[pin_project(UnsafeUnpin)]
+struct TrivialBounds {
+ #[pin]
+ field1: PhantomPinned,
+}
+
+#[pin_project(UnsafeUnpin)]
+struct OverlappingLifetimeNames<'pin, T, U> {
+ #[pin]
+ field1: U,
+ #[pin]
+ field2: Option<T>,
+ field3: &'pin (),
+}
+
+unsafe impl<T: Unpin, U: Unpin> UnsafeUnpin for OverlappingLifetimeNames<'_, T, U> {}
+
+fn main() {
+ is_unpin::<Blah<PhantomPinned, ()>>(); //~ ERROR E0277
+ is_unpin::<Blah<(), PhantomPinned>>(); // Ok
+ is_unpin::<Blah<PhantomPinned, PhantomPinned>>(); //~ ERROR E0277
+
+ is_unpin::<TrivialBounds>(); //~ ERROR E0277
+
+ is_unpin::<OverlappingLifetimeNames<'_, PhantomPinned, ()>>(); //~ ERROR E0277
+ is_unpin::<OverlappingLifetimeNames<'_, (), PhantomPinned>>(); //~ ERROR E0277
+}
diff --git a/tests/ui/unsafe_unpin/proper_unpin.stderr b/tests/ui/unsafe_unpin/proper_unpin.stderr
new file mode 100644
index 0000000..410dd0e
--- /dev/null
+++ b/tests/ui/unsafe_unpin/proper_unpin.stderr
@@ -0,0 +1,63 @@
+error[E0277]: `std::marker::PhantomPinned` cannot be unpinned
+ --> $DIR/proper_unpin.rs:33:5
+ |
+4 | fn is_unpin<T: Unpin>() {}
+ | ----- required by this bound in `is_unpin`
+...
+33 | is_unpin::<Blah<PhantomPinned, ()>>(); //~ ERROR E0277
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `std::marker::Unpin` is not implemented for `std::marker::PhantomPinned`
+ |
+ = note: required because of the requirements on the impl of `pin_project::UnsafeUnpin` for `Blah<std::marker::PhantomPinned, ()>`
+ = note: required because of the requirements on the impl of `pin_project::UnsafeUnpin` for `pin_project::__private::Wrapper<'_, Blah<std::marker::PhantomPinned, ()>>`
+ = note: required because of the requirements on the impl of `std::marker::Unpin` for `Blah<std::marker::PhantomPinned, ()>`
+
+error[E0277]: `std::marker::PhantomPinned` cannot be unpinned
+ --> $DIR/proper_unpin.rs:35:5
+ |
+4 | fn is_unpin<T: Unpin>() {}
+ | ----- required by this bound in `is_unpin`
+...
+35 | is_unpin::<Blah<PhantomPinned, PhantomPinned>>(); //~ ERROR E0277
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `std::marker::Unpin` is not implemented for `std::marker::PhantomPinned`
+ |
+ = note: required because of the requirements on the impl of `pin_project::UnsafeUnpin` for `Blah<std::marker::PhantomPinned, std::marker::PhantomPinned>`
+ = note: required because of the requirements on the impl of `pin_project::UnsafeUnpin` for `pin_project::__private::Wrapper<'_, Blah<std::marker::PhantomPinned, std::marker::PhantomPinned>>`
+ = note: required because of the requirements on the impl of `std::marker::Unpin` for `Blah<std::marker::PhantomPinned, std::marker::PhantomPinned>`
+
+error[E0277]: the trait bound `TrivialBounds: pin_project::UnsafeUnpin` is not satisfied
+ --> $DIR/proper_unpin.rs:37:16
+ |
+4 | fn is_unpin<T: Unpin>() {}
+ | ----- required by this bound in `is_unpin`
+...
+37 | is_unpin::<TrivialBounds>(); //~ ERROR E0277
+ | ^^^^^^^^^^^^^ the trait `pin_project::UnsafeUnpin` is not implemented for `TrivialBounds`
+ |
+ = note: required because of the requirements on the impl of `pin_project::UnsafeUnpin` for `pin_project::__private::Wrapper<'_, TrivialBounds>`
+ = note: required because of the requirements on the impl of `std::marker::Unpin` for `TrivialBounds`
+
+error[E0277]: `std::marker::PhantomPinned` cannot be unpinned
+ --> $DIR/proper_unpin.rs:39:5
+ |
+4 | fn is_unpin<T: Unpin>() {}
+ | ----- required by this bound in `is_unpin`
+...
+39 | is_unpin::<OverlappingLifetimeNames<'_, PhantomPinned, ()>>(); //~ ERROR E0277
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `std::marker::Unpin` is not implemented for `std::marker::PhantomPinned`
+ |
+ = note: required because of the requirements on the impl of `pin_project::UnsafeUnpin` for `OverlappingLifetimeNames<'_, std::marker::PhantomPinned, ()>`
+ = note: required because of the requirements on the impl of `pin_project::UnsafeUnpin` for `pin_project::__private::Wrapper<'_, OverlappingLifetimeNames<'_, std::marker::PhantomPinned, ()>>`
+ = note: required because of the requirements on the impl of `std::marker::Unpin` for `OverlappingLifetimeNames<'_, std::marker::PhantomPinned, ()>`
+
+error[E0277]: `std::marker::PhantomPinned` cannot be unpinned
+ --> $DIR/proper_unpin.rs:40:5
+ |
+4 | fn is_unpin<T: Unpin>() {}
+ | ----- required by this bound in `is_unpin`
+...
+40 | is_unpin::<OverlappingLifetimeNames<'_, (), PhantomPinned>>(); //~ ERROR E0277
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `std::marker::Unpin` is not implemented for `std::marker::PhantomPinned`
+ |
+ = note: required because of the requirements on the impl of `pin_project::UnsafeUnpin` for `OverlappingLifetimeNames<'_, (), std::marker::PhantomPinned>`
+ = note: required because of the requirements on the impl of `pin_project::UnsafeUnpin` for `pin_project::__private::Wrapper<'_, OverlappingLifetimeNames<'_, (), std::marker::PhantomPinned>>`
+ = note: required because of the requirements on the impl of `std::marker::Unpin` for `OverlappingLifetimeNames<'_, (), std::marker::PhantomPinned>`
diff --git a/tests/ui/unstable-features/README.md b/tests/ui/unstable-features/README.md
new file mode 100644
index 0000000..b9215b6
--- /dev/null
+++ b/tests/ui/unstable-features/README.md
@@ -0,0 +1,5 @@
+# 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/tests/ui/unstable-features/marker_trait_attr-feature-gate.rs b/tests/ui/unstable-features/marker_trait_attr-feature-gate.rs
new file mode 100644
index 0000000..fa4b01e
--- /dev/null
+++ b/tests/ui/unstable-features/marker_trait_attr-feature-gate.rs
@@ -0,0 +1,19 @@
+// NB: If you change this test, change 'marker_trait_attr.rs' at the same time.
+
+use pin_project::pin_project;
+use std::marker::PhantomPinned;
+
+#[pin_project] //~ ERROR E0119
+struct Struct<T> {
+ #[pin]
+ x: T,
+}
+
+// unsound Unpin impl
+impl<T> Unpin for Struct<T> {}
+
+fn is_unpin<T: Unpin>() {}
+
+fn main() {
+ is_unpin::<Struct<PhantomPinned>>()
+}
diff --git a/tests/ui/unstable-features/marker_trait_attr-feature-gate.stderr b/tests/ui/unstable-features/marker_trait_attr-feature-gate.stderr
new file mode 100644
index 0000000..bab534b
--- /dev/null
+++ b/tests/ui/unstable-features/marker_trait_attr-feature-gate.stderr
@@ -0,0 +1,10 @@
+error[E0119]: conflicting implementations of trait `std::marker::Unpin` for type `Struct<_>`:
+ --> $DIR/marker_trait_attr-feature-gate.rs:6:1
+ |
+6 | #[pin_project] //~ ERROR E0119
+ | ^^^^^^^^^^^^^^ conflicting implementation for `Struct<_>`
+...
+13 | impl<T> Unpin for Struct<T> {}
+ | --------------------------- first implementation here
+ |
+ = note: this error originates in a derive macro (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/tests/ui/unstable-features/marker_trait_attr.rs b/tests/ui/unstable-features/marker_trait_attr.rs
new file mode 100644
index 0000000..0b8b30a
--- /dev/null
+++ b/tests/ui/unstable-features/marker_trait_attr.rs
@@ -0,0 +1,25 @@
+// NB: 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 pin_project::pin_project;
+use std::marker::PhantomPinned;
+
+#[pin_project] //~ ERROR E0119
+struct Struct<T> {
+ #[pin]
+ x: T,
+}
+
+// unsound Unpin impl
+impl<T> Unpin for Struct<T> {}
+
+fn is_unpin<T: Unpin>() {}
+
+fn main() {
+ is_unpin::<Struct<PhantomPinned>>()
+}
diff --git a/tests/ui/unstable-features/marker_trait_attr.stderr b/tests/ui/unstable-features/marker_trait_attr.stderr
new file mode 100644
index 0000000..9b3ec57
--- /dev/null
+++ b/tests/ui/unstable-features/marker_trait_attr.stderr
@@ -0,0 +1,10 @@
+error[E0119]: conflicting implementations of trait `std::marker::Unpin` for type `Struct<_>`:
+ --> $DIR/marker_trait_attr.rs:12:1
+ |
+12 | #[pin_project] //~ ERROR E0119
+ | ^^^^^^^^^^^^^^ conflicting implementation for `Struct<_>`
+...
+19 | impl<T> Unpin for Struct<T> {}
+ | --------------------------- first implementation here
+ |
+ = note: this error originates in a derive macro (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/tests/ui/unstable-features/overlapping_marker_traits-feature-gate.rs b/tests/ui/unstable-features/overlapping_marker_traits-feature-gate.rs
new file mode 100644
index 0000000..0bd4a32
--- /dev/null
+++ b/tests/ui/unstable-features/overlapping_marker_traits-feature-gate.rs
@@ -0,0 +1,19 @@
+// NB: If you change this test, change 'overlapping_marker_traits.rs' at the same time.
+
+use pin_project::pin_project;
+use std::marker::PhantomPinned;
+
+#[pin_project] //~ ERROR E0119
+struct Struct<T> {
+ #[pin]
+ x: T,
+}
+
+// unsound Unpin impl
+impl<T> Unpin for Struct<T> {}
+
+fn is_unpin<T: Unpin>() {}
+
+fn main() {
+ is_unpin::<Struct<PhantomPinned>>()
+}
diff --git a/tests/ui/unstable-features/overlapping_marker_traits-feature-gate.stderr b/tests/ui/unstable-features/overlapping_marker_traits-feature-gate.stderr
new file mode 100644
index 0000000..4a8e238
--- /dev/null
+++ b/tests/ui/unstable-features/overlapping_marker_traits-feature-gate.stderr
@@ -0,0 +1,10 @@
+error[E0119]: conflicting implementations of trait `std::marker::Unpin` for type `Struct<_>`:
+ --> $DIR/overlapping_marker_traits-feature-gate.rs:6:1
+ |
+6 | #[pin_project] //~ ERROR E0119
+ | ^^^^^^^^^^^^^^ conflicting implementation for `Struct<_>`
+...
+13 | impl<T> Unpin for Struct<T> {}
+ | --------------------------- first implementation here
+ |
+ = note: this error originates in a derive macro (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/tests/ui/unstable-features/overlapping_marker_traits.rs b/tests/ui/unstable-features/overlapping_marker_traits.rs
new file mode 100644
index 0000000..27d37a3
--- /dev/null
+++ b/tests/ui/unstable-features/overlapping_marker_traits.rs
@@ -0,0 +1,29 @@
+// NB: 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 pin_project::pin_project;
+use std::marker::PhantomPinned;
+
+#[pin_project]
+struct Struct<T> {
+ #[pin]
+ x: T,
+}
+
+// unsound Unpin impl
+impl<T> Unpin for Struct<T> {}
+
+fn is_unpin<T: Unpin>() {}
+
+fn main() {
+ is_unpin::<Struct<PhantomPinned>>()
+}
diff --git a/tests/ui/unstable-features/overlapping_marker_traits.stderr b/tests/ui/unstable-features/overlapping_marker_traits.stderr
new file mode 100644
index 0000000..91aaf6c
--- /dev/null
+++ b/tests/ui/unstable-features/overlapping_marker_traits.stderr
@@ -0,0 +1,18 @@
+error[E0557]: feature has been removed
+ --> $DIR/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 `std::marker::Unpin` for type `Struct<_>`:
+ --> $DIR/overlapping_marker_traits.rs:16:1
+ |
+16 | #[pin_project]
+ | ^^^^^^^^^^^^^^ conflicting implementation for `Struct<_>`
+...
+23 | impl<T> Unpin for Struct<T> {}
+ | --------------------------- first implementation here
+ |
+ = note: this error originates in a derive macro (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/tests/ui/unstable-features/run-pass/stmt_expr_attributes.rs b/tests/ui/unstable-features/run-pass/stmt_expr_attributes.rs
new file mode 100644
index 0000000..8ad8e41
--- /dev/null
+++ b/tests/ui/unstable-features/run-pass/stmt_expr_attributes.rs
@@ -0,0 +1,62 @@
+// NB: If you change this test, change 'stmt_expr_attributes-feature-gate.rs' at the same time.
+
+// proc_macro_hygiene
+// Tracking issue: https://github.com/rust-lang/rust/issues/54727
+#![feature(proc_macro_hygiene)]
+// stmt_expr_attributes
+// Tracking issue: https://github.com/rust-lang/rust/issues/15701
+#![feature(stmt_expr_attributes)]
+
+use pin_project::{pin_project, project};
+use std::pin::Pin;
+
+fn project_stmt_expr_nightly() {
+ #[pin_project]
+ enum Baz<A, B, C, D> {
+ Variant1(#[pin] A, B),
+ Variant2 {
+ #[pin]
+ field1: C,
+ field2: D,
+ },
+ None,
+ }
+
+ let mut baz = Baz::Variant1(1, 2);
+
+ let mut baz = Pin::new(&mut baz).project();
+
+ #[project]
+ match &mut baz {
+ Baz::Variant1(x, y) => {
+ let x: &mut Pin<&mut i32> = x;
+ assert_eq!(**x, 1);
+
+ let y: &mut &mut i32 = y;
+ assert_eq!(**y, 2);
+ }
+ Baz::Variant2 { field1, field2 } => {
+ let _x: &mut Pin<&mut i32> = field1;
+ let _y: &mut &mut i32 = field2;
+ }
+ Baz::None => {}
+ }
+
+ let () = #[project]
+ match &mut baz {
+ Baz::Variant1(x, y) => {
+ let x: &mut Pin<&mut i32> = x;
+ assert_eq!(**x, 1);
+
+ let y: &mut &mut i32 = y;
+ assert_eq!(**y, 2);
+ }
+ Baz::Variant2 { field1, field2 } => {
+ let _x: &mut Pin<&mut i32> = field1;
+ let _y: &mut &mut i32 = field2;
+ }
+ Baz::None => {}
+ };
+}
+
+fn main() {}
diff --git a/tests/ui/unstable-features/stmt_expr_attributes-feature-gate.rs b/tests/ui/unstable-features/stmt_expr_attributes-feature-gate.rs
new file mode 100644
index 0000000..8226723
--- /dev/null
+++ b/tests/ui/unstable-features/stmt_expr_attributes-feature-gate.rs
@@ -0,0 +1,55 @@
+// NB: If you change this test, change 'stmt_expr_attributes.rs' at the same time.
+
+use pin_project::{pin_project, project};
+use std::pin::Pin;
+
+fn project_stmt_expr_nightly() {
+ #[pin_project]
+ enum Enum<A, B, C, D> {
+ Variant1(#[pin] A, B),
+ Variant2 {
+ #[pin]
+ field1: C,
+ field2: D,
+ },
+ None,
+ }
+
+ let mut baz = Enum::Variant1(1, 2);
+
+ let mut baz = Pin::new(&mut baz).project();
+
+ #[project] //~ ERROR E0658
+ match &mut baz {
+ Enum::Variant1(x, y) => {
+ let x: &mut Pin<&mut i32> = x;
+ assert_eq!(**x, 1);
+
+ let y: &mut &mut i32 = y;
+ assert_eq!(**y, 2);
+ }
+ Enum::Variant2 { field1, field2 } => {
+ let _x: &mut Pin<&mut i32> = field1;
+ let _y: &mut &mut i32 = field2;
+ }
+ Enum::None => {}
+ }
+
+ let () = #[project] //~ ERROR E0658
+ match &mut baz {
+ Enum::Variant1(x, y) => {
+ let x: &mut Pin<&mut i32> = x;
+ assert_eq!(**x, 1);
+
+ let y: &mut &mut i32 = y;
+ assert_eq!(**y, 2);
+ }
+ Enum::Variant2 { field1, field2 } => {
+ let _x: &mut Pin<&mut i32> = field1;
+ let _y: &mut &mut i32 = field2;
+ }
+ Enum::None => {}
+ };
+}
+
+fn main() {}
diff --git a/tests/ui/unstable-features/stmt_expr_attributes-feature-gate.stderr b/tests/ui/unstable-features/stmt_expr_attributes-feature-gate.stderr
new file mode 100644
index 0000000..6510ec7
--- /dev/null
+++ b/tests/ui/unstable-features/stmt_expr_attributes-feature-gate.stderr
@@ -0,0 +1,35 @@
+error[E0658]: attributes on expressions are experimental
+ --> $DIR/stmt_expr_attributes-feature-gate.rs:22:5
+ |
+22 | #[project] //~ ERROR E0658
+ | ^^^^^^^^^^
+ |
+ = note: see issue #15701 <https://github.com/rust-lang/rust/issues/15701> for more information
+ = help: add `#![feature(stmt_expr_attributes)]` to the crate attributes to enable
+
+error[E0658]: attributes on expressions are experimental
+ --> $DIR/stmt_expr_attributes-feature-gate.rs:38:14
+ |
+38 | let () = #[project] //~ ERROR E0658
+ | ^^^^^^^^^^
+ |
+ = note: see issue #15701 <https://github.com/rust-lang/rust/issues/15701> for more information
+ = help: add `#![feature(stmt_expr_attributes)]` to the crate attributes to enable
+
+error[E0658]: custom attributes cannot be applied to expressions
+ --> $DIR/stmt_expr_attributes-feature-gate.rs:22:5
+ |
+22 | #[project] //~ ERROR E0658
+ | ^^^^^^^^^^
+ |
+ = note: see issue #54727 <https://github.com/rust-lang/rust/issues/54727> for more information
+ = help: add `#![feature(proc_macro_hygiene)]` to the crate attributes to enable
+
+error[E0658]: custom attributes cannot be applied to expressions
+ --> $DIR/stmt_expr_attributes-feature-gate.rs:38:14
+ |
+38 | let () = #[project] //~ ERROR E0658
+ | ^^^^^^^^^^
+ |
+ = note: see issue #54727 <https://github.com/rust-lang/rust/issues/54727> for more information
+ = help: add `#![feature(proc_macro_hygiene)]` to the crate attributes to enable
diff --git a/tests/ui/unstable-features/trivial_bounds-bug.rs b/tests/ui/unstable-features/trivial_bounds-bug.rs
new file mode 100644
index 0000000..2ec4960
--- /dev/null
+++ b/tests/ui/unstable-features/trivial_bounds-bug.rs
@@ -0,0 +1,33 @@
+// NB: 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)]
+
+mod phantom_pinned {
+ use std::marker::{PhantomData, PhantomPinned};
+
+ struct A(PhantomPinned);
+
+ // bug of trivial_bounds?
+ impl Unpin for A where PhantomPinned: Unpin {} //~ ERROR E0277
+
+ struct Wrapper<T>(T);
+
+ impl<T> Unpin for Wrapper<T> where T: Unpin {}
+
+ struct B(PhantomPinned);
+
+ impl Unpin for B where Wrapper<PhantomPinned>: Unpin {} // Ok
+
+ struct WrapperWithLifetime<'a, T>(PhantomData<&'a ()>, T);
+
+ impl<T> Unpin for WrapperWithLifetime<'_, T> where T: Unpin {}
+
+ struct C(PhantomPinned);
+
+ // Ok
+ impl<'a> Unpin for C where WrapperWithLifetime<'a, PhantomPinned>: Unpin {}
+}
+
+fn main() {}
diff --git a/tests/ui/unstable-features/trivial_bounds-bug.stderr b/tests/ui/unstable-features/trivial_bounds-bug.stderr
new file mode 100644
index 0000000..7ddf10c
--- /dev/null
+++ b/tests/ui/unstable-features/trivial_bounds-bug.stderr
@@ -0,0 +1,10 @@
+error[E0277]: `std::marker::PhantomPinned` cannot be unpinned
+ --> $DIR/trivial_bounds-bug.rs:13:43
+ |
+13 | impl Unpin for A where PhantomPinned: Unpin {} //~ ERROR E0277
+ | ^^^^^ the trait `std::marker::Unpin` is not implemented for `std::marker::PhantomPinned`
+ |
+ ::: /Users/taiki/.rustup/toolchains/nightly-x86_64-apple-darwin/lib/rustlib/src/rust/src/libcore/marker.rs:736:1
+ |
+736 | pub auto trait Unpin {}
+ | -------------------- required by this bound in `std::marker::Unpin`
diff --git a/tests/ui/unstable-features/trivial_bounds-feature-gate.rs b/tests/ui/unstable-features/trivial_bounds-feature-gate.rs
new file mode 100644
index 0000000..0453a3f
--- /dev/null
+++ b/tests/ui/unstable-features/trivial_bounds-feature-gate.rs
@@ -0,0 +1,54 @@
+// NB: If you change this test, change 'trivial_bounds.rs' at the same time.
+
+mod phantom_pinned {
+ use std::marker::{PhantomData, PhantomPinned};
+
+ struct A(PhantomPinned);
+
+ impl Unpin for A where PhantomPinned: Unpin {} //~ ERROR E0277
+
+ struct Wrapper<T>(T);
+
+ impl<T> Unpin for Wrapper<T> where T: Unpin {}
+
+ struct B(PhantomPinned);
+
+ impl Unpin for B where Wrapper<PhantomPinned>: Unpin {} //~ ERROR E0277
+
+ struct WrapperWithLifetime<'a, T>(PhantomData<&'a ()>, T);
+
+ impl<T> Unpin for WrapperWithLifetime<'_, T> where T: Unpin {}
+
+ struct C(PhantomPinned);
+
+ impl<'a> Unpin for C where WrapperWithLifetime<'a, PhantomPinned>: Unpin {}
+ // Ok
+}
+
+mod inner {
+ use std::marker::{PhantomData, PhantomPinned};
+
+ struct Inner(PhantomPinned);
+
+ struct A(Inner);
+
+ impl Unpin for A where Inner: Unpin {} //~ ERROR E0277
+
+ struct Wrapper<T>(T);
+
+ impl<T> Unpin for Wrapper<T> where T: Unpin {}
+
+ struct B(Inner);
+
+ impl Unpin for B where Wrapper<Inner>: Unpin {} //~ ERROR E0277
+
+ struct WrapperWithLifetime<'a, T>(PhantomData<&'a ()>, T);
+
+ impl<T> Unpin for WrapperWithLifetime<'_, T> where T: Unpin {}
+
+ struct C(Inner);
+
+ impl<'a> Unpin for C where WrapperWithLifetime<'a, Inner>: Unpin {} // Ok
+}
+
+fn main() {}
diff --git a/tests/ui/unstable-features/trivial_bounds-feature-gate.stderr b/tests/ui/unstable-features/trivial_bounds-feature-gate.stderr
new file mode 100644
index 0000000..31196a2
--- /dev/null
+++ b/tests/ui/unstable-features/trivial_bounds-feature-gate.stderr
@@ -0,0 +1,50 @@
+error[E0277]: `std::marker::PhantomPinned` cannot be unpinned
+ --> $DIR/trivial_bounds-feature-gate.rs:8:5
+ |
+8 | impl Unpin for A where PhantomPinned: Unpin {} //~ ERROR E0277
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `std::marker::Unpin` is not implemented for `std::marker::PhantomPinned`
+ |
+ = help: see issue #48214
+ = help: add `#![feature(trivial_bounds)]` to the crate attributes to enable
+
+error[E0277]: `std::marker::PhantomPinned` cannot be unpinned
+ --> $DIR/trivial_bounds-feature-gate.rs:8:43
+ |
+8 | impl Unpin for A where PhantomPinned: Unpin {} //~ ERROR E0277
+ | ^^^^^ the trait `std::marker::Unpin` is not implemented for `std::marker::PhantomPinned`
+ |
+ ::: /Users/taiki/.rustup/toolchains/nightly-x86_64-apple-darwin/lib/rustlib/src/rust/src/libcore/marker.rs:736:1
+ |
+736 | pub auto trait Unpin {}
+ | -------------------- required by this bound in `std::marker::Unpin`
+
+error[E0277]: `std::marker::PhantomPinned` cannot be unpinned
+ --> $DIR/trivial_bounds-feature-gate.rs:16:5
+ |
+16 | impl Unpin for B where Wrapper<PhantomPinned>: Unpin {} //~ ERROR E0277
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `std::marker::Unpin` is not implemented for `std::marker::PhantomPinned`
+ |
+ = note: required because of the requirements on the impl of `std::marker::Unpin` for `phantom_pinned::Wrapper<std::marker::PhantomPinned>`
+ = help: see issue #48214
+ = help: add `#![feature(trivial_bounds)]` to the crate attributes to enable
+
+error[E0277]: `std::marker::PhantomPinned` cannot be unpinned
+ --> $DIR/trivial_bounds-feature-gate.rs:35:5
+ |
+35 | impl Unpin for A where Inner: Unpin {} //~ ERROR E0277
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ within `inner::Inner`, the trait `std::marker::Unpin` is not implemented for `std::marker::PhantomPinned`
+ |
+ = note: required because it appears within the type `inner::Inner`
+ = help: see issue #48214
+ = help: add `#![feature(trivial_bounds)]` to the crate attributes to enable
+
+error[E0277]: `std::marker::PhantomPinned` cannot be unpinned
+ --> $DIR/trivial_bounds-feature-gate.rs:43:5
+ |
+43 | impl Unpin for B where Wrapper<Inner>: Unpin {} //~ ERROR E0277
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ within `inner::Inner`, the trait `std::marker::Unpin` is not implemented for `std::marker::PhantomPinned`
+ |
+ = note: required because it appears within the type `inner::Inner`
+ = note: required because of the requirements on the impl of `std::marker::Unpin` for `inner::Wrapper<inner::Inner>`
+ = help: see issue #48214
+ = help: add `#![feature(trivial_bounds)]` to the crate attributes to enable
diff --git a/tests/ui/unstable-features/trivial_bounds.rs b/tests/ui/unstable-features/trivial_bounds.rs
new file mode 100644
index 0000000..680effe
--- /dev/null
+++ b/tests/ui/unstable-features/trivial_bounds.rs
@@ -0,0 +1,34 @@
+// NB: 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)]
+
+use std::marker::{PhantomData, PhantomPinned};
+
+fn inner() {
+ struct Inner(PhantomPinned);
+
+ struct A(Inner);
+
+ impl Unpin for A where Inner: Unpin {} //~ ERROR std::marker::Unpin does not depend on any type or lifetime parameters
+
+ struct Wrapper<T>(T);
+
+ impl<T> Unpin for Wrapper<T> where T: Unpin {}
+
+ struct B(Inner);
+
+ impl Unpin for B where Wrapper<Inner>: Unpin {} //~ ERROR std::marker::Unpin does not depend on any type or lifetime parameters
+
+ struct WrapperWithLifetime<'a, T>(PhantomData<&'a ()>, T);
+
+ impl<T> Unpin for WrapperWithLifetime<'_, T> where T: Unpin {}
+
+ struct C(Inner);
+
+ impl<'a> Unpin for C where WrapperWithLifetime<'a, Inner>: Unpin {} // Ok
+}
+
+fn main() {}
diff --git a/tests/ui/unstable-features/trivial_bounds.stderr b/tests/ui/unstable-features/trivial_bounds.stderr
new file mode 100644
index 0000000..03d0161
--- /dev/null
+++ b/tests/ui/unstable-features/trivial_bounds.stderr
@@ -0,0 +1,17 @@
+error: Trait bound inner::Inner: std::marker::Unpin does not depend on any type or lifetime parameters
+ --> $DIR/trivial_bounds.rs:15:35
+ |
+15 | impl Unpin for A where Inner: Unpin {} //~ ERROR std::marker::Unpin does not depend on any type or lifetime parameters
+ | ^^^^^
+ |
+note: the lint level is defined here
+ --> $DIR/trivial_bounds.rs:6:9
+ |
+6 | #![deny(trivial_bounds)]
+ | ^^^^^^^^^^^^^^
+
+error: Trait bound inner::Wrapper<inner::Inner>: std::marker::Unpin does not depend on any type or lifetime parameters
+ --> $DIR/trivial_bounds.rs:23:44
+ |
+23 | impl Unpin for B where Wrapper<Inner>: Unpin {} //~ ERROR std::marker::Unpin does not depend on any type or lifetime parameters
+ | ^^^^^
diff --git a/tests/unsafe_unpin.rs b/tests/unsafe_unpin.rs
new file mode 100644
index 0000000..5e0e7cf
--- /dev/null
+++ b/tests/unsafe_unpin.rs
@@ -0,0 +1,53 @@
+#![warn(rust_2018_idioms, single_use_lifetimes)]
+#![allow(dead_code)]
+
+use pin_project::{pin_project, UnsafeUnpin};
+use std::{marker::PhantomPinned, pin::Pin};
+
+fn is_unpin<T: Unpin>() {}
+
+#[pin_project(UnsafeUnpin)]
+pub struct Blah<T, U> {
+ field1: U,
+ #[pin]
+ field2: T,
+}
+
+unsafe impl<T: Unpin, U> UnsafeUnpin for Blah<T, U> {}
+
+#[pin_project(UnsafeUnpin)]
+pub struct OverlappingLifetimeNames<'pin, T, U> {
+ #[pin]
+ field1: T,
+ field2: U,
+ field3: &'pin (),
+}
+
+unsafe impl<T: Unpin, U> UnsafeUnpin for OverlappingLifetimeNames<'_, T, U> {}
+
+#[test]
+fn unsafe_unpin() {
+ is_unpin::<Blah<(), PhantomPinned>>();
+ is_unpin::<OverlappingLifetimeNames<'_, (), ()>>();
+}
+
+#[test]
+fn trivial_bounds() {
+ #[pin_project(UnsafeUnpin)]
+ pub struct NotImplementUnsafUnpin {
+ #[pin]
+ field: PhantomPinned,
+ }
+}
+
+#[test]
+fn test() {
+ let mut x = OverlappingLifetimeNames { field1: 0, field2: 1, field3: &() };
+ let x = Pin::new(&mut x);
+ let y = x.as_ref().project_ref();
+ let _: Pin<&u8> = y.field1;
+ let _: &u8 = y.field2;
+ let y = x.project();
+ let _: Pin<&mut u8> = y.field1;
+ let _: &mut u8 = y.field2;
+}
