diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 816bd88..c11a4ad 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -41,7 +41,7 @@
             rust: nightly
     runs-on: ${{ matrix.os || 'ubuntu' }}-latest
     steps:
-      - uses: actions/checkout@master
+      - uses: actions/checkout@v2
       - name: Install Rust
         run: |
           . ./ci/install-rust.sh ${{ matrix.rust }}
@@ -53,17 +53,19 @@
         if: matrix.rust == 'nightly'
         run: |
           rustup target add thumbv7m-none-eabi
+      - name: cargo test --tests
+        if: matrix.rust == '1.34.0' || matrix.rust == '1.36.0'
+        run: |
+          cargo test --all --all-features --exclude expandtest --tests
       - name: cargo test
+        if: matrix.rust != '1.34.0' && matrix.rust != '1.36.0'
         run: |
           cargo test --all --all-features --exclude expandtest
-      - name: cargo test (compiletest)
-        if: matrix.rust == 'nightly'
-        run: |
-          cargo test -p pin-project --all-features --test compiletest -- --ignored
       - name: cargo check (no-std)
         if: matrix.rust == 'nightly'
         run: |
           cargo check --target thumbv7m-none-eabi --manifest-path tests/no-std/Cargo.toml
+          cargo check --target thumbv7m-none-eabi --manifest-path tests/rust-2015/Cargo.toml
       - name: cargo check (minimal versions)
         if: matrix.rust == 'nightly'
         run: |
@@ -73,7 +75,7 @@
     name: expandtest
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@master
+      - uses: actions/checkout@v2
       - name: Install Rust
         run: |
           . ./ci/install-rust.sh
@@ -84,36 +86,47 @@
         run: |
           cargo test --all-features --manifest-path tests/expand/Cargo.toml
 
-  style:
-    name: style
-    strategy:
-      fail-fast: false
-      matrix:
-        component:
-          - clippy
-          - rustfmt
-          - rustdoc
+  clippy:
+    name: clippy
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@master
+      - uses: actions/checkout@v2
       - name: Install Rust
         run: |
           . ./ci/install-rust.sh
-      - name: Install component
+      - name: Install clippy
         run: |
-          . ./ci/install-component.sh ${{ matrix.component }}
+          . ./ci/install-component.sh clippy
       - name: cargo clippy
-        if: matrix.component == 'clippy'
         run: |
           cargo clippy --all --all-features --all-targets
-      - name: cargo fmt -- --check
-        if: matrix.component == 'rustfmt'
+
+  rustfmt:
+    name: rustfmt
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - name: Install Rust
+        run: |
+          . ./ci/install-rust.sh
+      - name: Install rustfmt
+        run: |
+          . ./ci/install-component.sh rustfmt
+      - name: cargo fmt --check
         run: |
           cargo fmt --all -- --check
+
+  rustdoc:
+    name: rustdoc
+    env:
+      RUSTDOCFLAGS: -Dwarnings
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - name: Install Rust
+        run: |
+          . ./ci/install-rust.sh
       - name: cargo doc
-        if: matrix.component == 'rustdoc'
-        env:
-          RUSTDOCFLAGS: -Dwarnings
         run: |
           cargo doc --no-deps --all --all-features
 
@@ -127,8 +140,10 @@
     name: ci
     if: github.event_name == 'push' && success()
     needs:
-      - style
       - test
+      - clippy
+      - rustfmt
+      - rustdoc
       - expandtest
     runs-on: ubuntu-latest
     steps:
@@ -138,8 +153,10 @@
     name: ci
     if: github.event_name == 'push' && !success()
     needs:
-      - style
       - test
+      - clippy
+      - rustfmt
+      - rustdoc
       - expandtest
     runs-on: ubuntu-latest
     steps:
diff --git a/.rustfmt.toml b/.rustfmt.toml
deleted file mode 100644
index dc49733..0000000
--- a/.rustfmt.toml
+++ /dev/null
@@ -1,19 +0,0 @@
-# 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
index 63eb84a..c7fea1d 100644
--- a/Android.bp
+++ b/Android.bp
@@ -12,7 +12,7 @@
 }
 
 // dependent_library ["feature_list"]
-//   pin-project-internal-0.4.17
+//   pin-project-internal-0.4.22
 //   proc-macro2-1.0.18 "default,proc-macro"
 //   quote-1.0.7 "default,proc-macro"
 //   syn-1.0.34 "clone-impls,default,derive,full,parsing,printing,proc-macro,quote,visit-mut"
diff --git a/CHANGELOG.md b/CHANGELOG.md
index ed7cfbc..d40af34 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,9 +6,97 @@
 
 ## [Unreleased]
 
+## [0.4.22] - 2020-06-14
+
+* Documentation improvements.
+
+## [0.4.21] - 2020-06-13
+
+* [Deprecated `#[project]`, `#[project_ref]`, and `#[project_replace]` attributes due to some unfixable limitations.][244]
+
+  Consider naming the projected type by passing an argument with the same name as the method to the #[pin_project] attribute instead.
+
+  ```rust
+  use pin_project::pin_project;
+  use std::pin::Pin;
+
+  #[pin_project(project = EnumProj)]
+  enum Enum<T> {
+      Variant(#[pin] T),
+  }
+
+  fn func<T>(x: Pin<&mut Enum<T>>) {
+      match x.project() {
+          EnumProj::Variant(y) => {
+              let _: Pin<&mut T> = y;
+          }
+      }
+  }
+  ```
+
+  See [#225][225] for more details.
+
+* [Support `Self` in fields and generics in type definitions.][245]
+
+* [Fix errors involving *"`self` value is a keyword only available in methods with `self` parameter"* in apparently correct code.][250]
+
+* Diagnostic improvements.
+
+[225]: https://github.com/taiki-e/pin-project/pull/225
+[244]: https://github.com/taiki-e/pin-project/pull/244
+[245]: https://github.com/taiki-e/pin-project/pull/245
+[250]: https://github.com/taiki-e/pin-project/pull/250
+
+## [0.4.20] - 2020-06-07
+
+* [You can now use project_replace argument without Replace argument.][243]
+  This used to require you to specify both.
+
+  ```diff
+  - #[pin_project(Replace, project_replace = EnumProjOwn)]
+  + #[pin_project(project_replace = EnumProjOwn)]
+    enum Enum<T> {
+        Variant(#[pin] T)
+    }
+  ```
+
+* [Makes `project_replace` argument an alias for `Replace` argument so that it can be used without a value.][243]
+
+  ```rust
+  #[pin_project(project_replace)]
+  enum Enum<T> {
+      Variant(#[pin] T)
+  }
+  ```
+
+  *The `Replace` argument will be deprecated in the future.*
+
+* Suppress `unreachable_pub` lint in generated code.
+
+[243]: https://github.com/taiki-e/pin-project/pull/243
+
+## [0.4.19] - 2020-06-04
+
+* [Fix `unused_results` lint in generated code.][239]
+
+[239]: https://github.com/taiki-e/pin-project/pull/239
+
+## [0.4.18] - 2020-06-04
+
+* [Support `Self` in more syntax positions inside `#[pinned_drop]` impl.][230]
+
+* [Suppress `clippy::type_repetition_in_bounds` and `clippy::used_underscore_binding` lints in generated code.][233]
+
+* Documentation improvements.
+
+* Diagnostic improvements.
+
+[230]: https://github.com/taiki-e/pin-project/pull/230
+[233]: https://github.com/taiki-e/pin-project/pull/233
+
 ## [0.4.17] - 2020-05-18
 
-* [Allowed naming the projected types.][202]
+* [Support naming the projection types.][202]
 
   By passing an argument with the same name as the method to the attribute, you can name the projection type returned from the method:
 
@@ -73,11 +161,13 @@
 
 * [Fixed an issue where duplicate `#[project]` attributes were ignored.][218]
 
-* [Fixed compile error and warnings with HRTB.][217]
+* [Suppress `single_use_lifetimes` lint in generated code.][217]
 
-* [Hide generated items from --document-private-items.][211] See [#211][211] for more details.
+* [Support overlapping lifetime names in HRTB.][217]
 
-* Improve documentation
+* [Hide generated items from --document-private-items.][211] See [#211][211] for details.
+
+* Documentation improvements.
 
 [211]: https://github.com/taiki-e/pin-project/pull/211
 [217]: https://github.com/taiki-e/pin-project/pull/217
@@ -94,7 +184,11 @@
 
   * [Support overwriting the name of core crate.][199]
 
-  * Improve documentation
+  * [Suppress `clippy::needless_pass_by_value` lint in generated code of `#[pinned_drop]`.][200]
+
+  * Documentation improvements.
+
+  * Diagnostic improvements.
 
 [207]: https://github.com/taiki-e/pin-project/pull/207
 
@@ -110,10 +204,15 @@
 
 * [Support overwriting the name of core crate.][199]
 
-* Improve documentation
+* [Suppress `clippy::needless_pass_by_value` lint in generated code of `#[pinned_drop]`.][200]
+
+* Documentation improvements.
+
+* Diagnostic improvements.
 
 [197]: https://github.com/taiki-e/pin-project/pull/197
 [199]: https://github.com/taiki-e/pin-project/pull/199
+[200]: https://github.com/taiki-e/pin-project/pull/200
 
 ## [0.4.10] - 2020-05-04
 
@@ -121,6 +220,12 @@
   `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.
 
+* [Support `Self` and `self` in more syntax positions inside `#[pinned_drop]` impl.][190]
+
+* [Hided all generated items except for projected types from calling code.][192] See [#192][192] for details.
+
+[190]: https://github.com/taiki-e/pin-project/pull/190
+[192]: https://github.com/taiki-e/pin-project/pull/192
 [194]: https://github.com/taiki-e/pin-project/pull/194
 
 ## [0.4.9] - 2020-04-14
@@ -139,6 +244,9 @@
 
 * [Ensured that users cannot implement `PinnedDrop` without proper attribute argument.][180]
 
+* [Fixed use of `Self` in expression position inside `#[pinned_drop]` impl.][177]
+
+[177]: https://github.com/taiki-e/pin-project/pull/180
 [180]: https://github.com/taiki-e/pin-project/pull/180
 
 ## [0.4.7] - 2020-01-20
@@ -173,6 +281,8 @@
 
 * [Fixed support for DSTs(Dynamically Sized Types) on `#[pin_project(UnsafeUnpin)]`][120]
 
+* Diagnostic improvements.
+
 [120]: https://github.com/taiki-e/pin-project/pull/120
 [135]: https://github.com/taiki-e/pin-project/pull/135
 
@@ -262,7 +372,7 @@
 
 * Added some examples and generated code.
 
-* Improve error messages.
+* Diagnostic improvements.
 
 [86]: https://github.com/taiki-e/pin-project/pull/86
 
@@ -270,7 +380,7 @@
 
 * [`#[pin_project]` can now interoperate with `#[cfg()]`.][77]
 
-* Improved documentation.
+* Documentation improvements.
 
 [77]: https://github.com/taiki-e/pin-project/pull/77
 
@@ -292,14 +402,14 @@
 
 * [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]
+* [Diagnostic improvements.][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]
+* [Suppress `dead_code` lint in generated types.][57]
 
 [57]: https://github.com/taiki-e/pin-project/pull/57
 
@@ -317,7 +427,7 @@
 
 ## [0.4.0-alpha.4] - 2019-08-23
 
-* Avoided clippy::drop_bounds lint in generated code.
+* Suppress `clippy::drop_bounds` lint in generated code.
 
 ## [0.4.0-alpha.3] - 2019-08-23
 
@@ -359,11 +469,11 @@
 
 ## [0.3.4] - 2019-07-21
 
-* Improved error messages.
+* Diagnostic improvements.
 
 ## [0.3.3] - 2019-07-15 - YANKED
 
-* Improved error messages.
+* Diagnostic improvements.
 
 ## [0.3.2] - 2019-03-30
 
@@ -371,7 +481,7 @@
 
 ## [0.3.1] - 2019-03-02
 
-* Improved documentation.
+* Documentation improvements.
 
 * Updated minimum `syn` version to 0.15.22.
 
@@ -393,7 +503,7 @@
 
 * Made `unsafe_fields` optional.
 
-* Improved documentation.
+* Documentation improvements.
 
 ## [0.1.8] - 2019-02-02
 
@@ -427,7 +537,7 @@
 
 ## [0.1.2] - 2019-01-09
 
-* Improved documentation.
+* Documentation improvements.
 
 ## [0.1.1] - 2019-01-08
 
@@ -437,7 +547,12 @@
 
 Initial release
 
-[Unreleased]: https://github.com/taiki-e/pin-project/compare/v0.4.17...HEAD
+[Unreleased]: https://github.com/taiki-e/pin-project/compare/v0.4.22...HEAD
+[0.4.22]: https://github.com/taiki-e/pin-project/compare/v0.4.21...v0.4.22
+[0.4.21]: https://github.com/taiki-e/pin-project/compare/v0.4.20...v0.4.21
+[0.4.20]: https://github.com/taiki-e/pin-project/compare/v0.4.19...v0.4.20
+[0.4.19]: https://github.com/taiki-e/pin-project/compare/v0.4.18...v0.4.19
+[0.4.18]: https://github.com/taiki-e/pin-project/compare/v0.4.17...v0.4.18
 [0.4.17]: https://github.com/taiki-e/pin-project/compare/v0.4.16...v0.4.17
 [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
diff --git a/Cargo.toml b/Cargo.toml
index df64f70..bca571c 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -13,7 +13,7 @@
 [package]
 edition = "2018"
 name = "pin-project"
-version = "0.4.17"
+version = "0.4.22"
 authors = ["Taiki Endo <te316e89@gmail.com>"]
 description = "A crate for safe and ergonomic pin-projection.\n"
 homepage = "https://github.com/taiki-e/pin-project"
@@ -26,5 +26,5 @@
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]
 [dependencies.pin-project-internal]
-version = "=0.4.17"
+version = "=0.4.22"
 default-features = false
diff --git a/Cargo.toml.orig b/Cargo.toml.orig
index 3c43001..86f4cab 100644
--- a/Cargo.toml.orig
+++ b/Cargo.toml.orig
@@ -1,6 +1,6 @@
 [package]
 name = "pin-project"
-version = "0.4.17"
+version = "0.4.22"
 authors = ["Taiki Endo <te316e89@gmail.com>"]
 edition = "2018"
 license = "Apache-2.0 OR MIT"
@@ -23,9 +23,11 @@
     "tests/ui/auxiliary",
     "tests/doc",
     "tests/expand",
-    "tests/rust-2015"
+    "tests/no-core",
+    "tests/no-std",
+    "tests/rust-2015",
 ]
 
 [dependencies]
-pin-project-internal = { version = "=0.4.17", path = "pin-project-internal", default-features = false }
+pin-project-internal = { version = "=0.4.22", path = "pin-project-internal", default-features = false }
 
diff --git a/METADATA b/METADATA
index 09ca0bf..50afc3f 100644
--- a/METADATA
+++ b/METADATA
@@ -9,11 +9,11 @@
     type: GIT
     value: "https://github.com/taiki-e/pin-project"
   }
-  version: "0.4.17"
+  version: "0.4.22"
   license_type: NOTICE
   last_upgrade_date {
     year: 2020
-    month: 5
-    day: 18
+    month: 7
+    day: 10
   }
 }
diff --git a/README.md b/README.md
index 840d1fa..caee4d3 100644
--- a/README.md
+++ b/README.md
@@ -9,16 +9,12 @@
 [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-badge]: https://img.shields.io/badge/license-Apache--2.0%20OR%20MIT-blue.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)
+A crate for safe and ergonomic [pin-projection].
 
 ## Usage
 
@@ -33,7 +29,8 @@
 
 ## Examples
 
-[`pin_project`] attribute creates a projection struct covering all the fields.
+[`#[pin_project]`][`pin_project`] attribute creates projection types
+covering all the fields of struct or enum.
 
 ```rust
 use pin_project::pin_project;
@@ -47,7 +44,7 @@
 }
 
 impl<T, U> Struct<T, U> {
-    fn foo(self: Pin<&mut Self>) {
+    fn method(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
@@ -55,13 +52,21 @@
 }
 ```
 
-[Code like this will be generated](examples/struct-default-expanded.rs)
+[*code like this will be generated*][struct-default-expanded]
 
-See [API documentation][docs-url] for more details.
-
-Also, there are examples and generated code of each feature in [examples](examples/README.md) directory.
+See [documentation][docs-url] for more details, and
+see [examples] directory for more examples and generated code.
 
 [`pin_project`]: https://docs.rs/pin-project/0.4/pin_project/attr.pin_project.html
+[examples]: examples/README.md
+[pin-projection]: https://doc.rust-lang.org/nightly/std/pin/index.html#projections-and-structural-pinning
+[struct-default-expanded]: examples/struct-default-expanded.rs
+
+## Related Projects
+
+* [pin-project-lite]: A lightweight version of pin-project written with declarative macros.
+
+[pin-project-lite]: https://github.com/taiki-e/pin-project-lite
 
 ## License
 
diff --git a/ci.sh b/ci.sh
index df0131e..7f82c47 100644
--- a/ci.sh
+++ b/ci.sh
@@ -8,21 +8,18 @@
 # . ./ci.sh
 # ```
 
-echo "Running 'cargo fmt -- --check'"
-cargo +nightly fmt --all -- --check
+echo "Running 'cargo fmt'"
+cargo +nightly fmt --all
 
 echo "Running 'cargo clippy'"
 cargo +nightly clippy --all --all-features --all-targets
 
 echo "Running 'cargo test'"
-cargo +nightly test --all --all-features
+cargo +nightly test --all --all-features --exclude expandtest
 
 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
diff --git a/ci/check-minimal-versions.sh b/ci/check-minimal-versions.sh
index a11d2cb..6152c15 100644
--- a/ci/check-minimal-versions.sh
+++ b/ci/check-minimal-versions.sh
@@ -1,8 +1,8 @@
 #!/bin/bash
 # Check all public crates with minimal version dependencies.
 #
-# Note that this script modifies Cargo.toml and Cargo.lock and does not restore
-# them after a run.
+# Note that this script modifies Cargo.toml and Cargo.lock while this script is
+# running, and it is an error if there are any unstaged changes.
 #
 # Refs:
 # * minimal versions: https://github.com/rust-lang/cargo/issues/5657
@@ -10,10 +10,18 @@
 
 set -euo pipefail
 
+# This script modifies Cargo.toml and Cargo.lock, so make sure there are no
+# unstaged changes.
+git diff --exit-code
+
 # Remove dev-dependencies from Cargo.toml to prevent the next `cargo update`
 # from determining minimal versions based on dev-dependencies.
 cargo hack --remove-dev-deps --workspace
+
 # Update Cargo.lock to minimal version dependencies.
 cargo update -Zminimal-versions
 # Run check for all public members of the workspace.
 cargo hack check --workspace --all-features --ignore-private -Zfeatures=all
+
+# Restore original Cargo.toml and Cargo.lock.
+git checkout .
diff --git a/ci/install-component.sh b/ci/install-component.sh
index 37ccdfa..9aaa5ce 100644
--- a/ci/install-component.sh
+++ b/ci/install-component.sh
@@ -4,7 +4,7 @@
 
 component="${1}"
 
-if [[ "${component}" != "rustdoc" ]] && ! rustup component add "${component}" 2>/dev/null; then
+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
@@ -17,6 +17,6 @@
 fi
 
 case "${component}" in
-    rustfmt | rustdoc) "${component}" -V ;;
+    rustfmt) "${component}" -V ;;
     *) cargo "${component}" -V ;;
 esac
diff --git a/compiletest.sh b/compiletest.sh
deleted file mode 100644
index 9af5a5f..0000000
--- a/compiletest.sh
+++ /dev/null
@@ -1,12 +0,0 @@
-#!/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/enum-default-expanded.rs b/examples/enum-default-expanded.rs
index 845645a..3e7cb3c 100644
--- a/examples/enum-default-expanded.rs
+++ b/examples/enum-default-expanded.rs
@@ -15,7 +15,7 @@
 // ```
 
 #![allow(dead_code, unused_imports, unused_parens)]
-#![allow(clippy::no_effect, clippy::just_underscores_and_digits)]
+#![allow(clippy::just_underscores_and_digits)]
 
 use pin_project::pin_project;
 
@@ -24,51 +24,54 @@
     Unpinned(U),
 }
 
-#[allow(clippy::mut_mut)] // This lint warns `&mut &mut <ty>`.
-#[allow(dead_code)] // This lint warns unused fields/variants.
+#[allow(dead_code)]
 #[allow(single_use_lifetimes)]
+#[allow(clippy::mut_mut)]
+#[allow(clippy::type_repetition_in_bounds)]
 enum EnumProj<'pin, T, U>
 where
     Enum<T, U>: 'pin,
 {
-    Pinned(::pin_project::__reexport::pin::Pin<&'pin mut (T)>),
+    Pinned(::pin_project::__private::Pin<&'pin mut (T)>),
     Unpinned(&'pin mut (U)),
 }
 #[doc(hidden)]
-#[allow(dead_code)] // This lint warns unused fields/variants.
+#[allow(dead_code)]
 #[allow(single_use_lifetimes)]
+#[allow(clippy::type_repetition_in_bounds)]
 enum __EnumProjectionRef<'pin, T, U>
 where
     Enum<T, U>: 'pin,
 {
-    Pinned(::pin_project::__reexport::pin::Pin<&'pin (T)>),
+    Pinned(::pin_project::__private::Pin<&'pin (T)>),
     Unpinned(&'pin (U)),
 }
 
 #[doc(hidden)]
 #[allow(non_upper_case_globals)]
 #[allow(single_use_lifetimes)]
-const __SCOPE_Enum: () = {
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
     impl<T, U> Enum<T, U> {
         fn project<'pin>(
-            self: ::pin_project::__reexport::pin::Pin<&'pin mut Self>,
+            self: ::pin_project::__private::Pin<&'pin mut Self>,
         ) -> EnumProj<'pin, T, U> {
             unsafe {
                 match self.get_unchecked_mut() {
                     Enum::Pinned(_0) => {
-                        EnumProj::Pinned(::pin_project::__reexport::pin::Pin::new_unchecked(_0))
+                        EnumProj::Pinned(::pin_project::__private::Pin::new_unchecked(_0))
                     }
                     Enum::Unpinned(_0) => EnumProj::Unpinned(_0),
                 }
             }
         }
         fn project_ref<'pin>(
-            self: ::pin_project::__reexport::pin::Pin<&'pin Self>,
+            self: ::pin_project::__private::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),
+                        ::pin_project::__private::Pin::new_unchecked(_0),
                     ),
                     Enum::Unpinned(_0) => __EnumProjectionRef::Unpinned(_0),
                 }
@@ -84,8 +87,8 @@
         __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
+    impl<'pin, T, U> ::pin_project::__private::Unpin for Enum<T, U> where
+        __Enum<'pin, T, U>: ::pin_project::__private::Unpin
     {
     }
     unsafe impl<T, U> ::pin_project::UnsafeUnpin for Enum<T, U> {}
@@ -95,10 +98,10 @@
     // 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: ::pin_project::__private::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>) {}
+        unsafe fn drop(self: ::pin_project::__private::Pin<&mut Self>) {}
     }
 
     // We don't need to check for `#[repr(packed)]`,
diff --git a/examples/not_unpin-expanded.rs b/examples/not_unpin-expanded.rs
index 45f1321..fdfe5a2 100644
--- a/examples/not_unpin-expanded.rs
+++ b/examples/not_unpin-expanded.rs
@@ -30,50 +30,53 @@
 }
 
 #[doc(hidden)]
-#[allow(clippy::mut_mut)] // This lint warns `&mut &mut <ty>`.
-#[allow(dead_code)] // This lint warns unused fields/variants.
+#[allow(dead_code)]
 #[allow(single_use_lifetimes)]
+#[allow(clippy::mut_mut)]
+#[allow(clippy::type_repetition_in_bounds)]
 pub(crate) struct __StructProjection<'pin, T, U>
 where
     Struct<T, U>: 'pin,
 {
-    pinned: ::pin_project::__reexport::pin::Pin<&'pin mut (T)>,
+    pinned: ::pin_project::__private::Pin<&'pin mut (T)>,
     unpinned: &'pin mut (U),
 }
 #[doc(hidden)]
-#[allow(dead_code)] // This lint warns unused fields/variants.
+#[allow(dead_code)]
 #[allow(single_use_lifetimes)]
+#[allow(clippy::type_repetition_in_bounds)]
 pub(crate) struct __StructProjectionRef<'pin, T, U>
 where
     Struct<T, U>: 'pin,
 {
-    pinned: ::pin_project::__reexport::pin::Pin<&'pin (T)>,
+    pinned: ::pin_project::__private::Pin<&'pin (T)>,
     unpinned: &'pin (U),
 }
 
 #[doc(hidden)]
 #[allow(non_upper_case_globals)]
 #[allow(single_use_lifetimes)]
-const __SCOPE_Struct: () = {
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
     impl<T, U> Struct<T, U> {
         pub(crate) fn project<'pin>(
-            self: ::pin_project::__reexport::pin::Pin<&'pin mut Self>,
+            self: ::pin_project::__private::Pin<&'pin mut Self>,
         ) -> __StructProjection<'pin, T, U> {
             unsafe {
                 let Self { pinned, unpinned } = self.get_unchecked_mut();
                 __StructProjection {
-                    pinned: ::pin_project::__reexport::pin::Pin::new_unchecked(pinned),
+                    pinned: ::pin_project::__private::Pin::new_unchecked(pinned),
                     unpinned,
                 }
             }
         }
         pub(crate) fn project_ref<'pin>(
-            self: ::pin_project::__reexport::pin::Pin<&'pin Self>,
+            self: ::pin_project::__private::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),
+                    pinned: ::pin_project::__private::Pin::new_unchecked(pinned),
                     unpinned,
                 }
             }
@@ -84,17 +87,17 @@
     //
     // 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
+    impl<'pin, T, U> ::pin_project::__private::Unpin for Struct<T, U> where
+        ::pin_project::__private::Wrapper<'pin, ::pin_project::__private::PhantomPinned>:
+            ::pin_project::__private::Unpin
     {
     }
     // 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.
+    // impls, we emit one ourselves. If the user ends up writing an `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`.
@@ -102,13 +105,14 @@
     // 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: ::pin_project::__private::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>) {}
+        unsafe fn drop(self: ::pin_project::__private::Pin<&mut Self>) {}
     }
 
-    // Ensure that it's impossible to use pin projections on a #[repr(packed)] struct.
+    // 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.
diff --git a/examples/pinned_drop-expanded.rs b/examples/pinned_drop-expanded.rs
index 15dde89..8f295e9 100644
--- a/examples/pinned_drop-expanded.rs
+++ b/examples/pinned_drop-expanded.rs
@@ -34,61 +34,64 @@
 }
 
 #[doc(hidden)]
-#[allow(clippy::mut_mut)] // This lint warns `&mut &mut <ty>`.
-#[allow(dead_code)] // This lint warns unused fields/variants.
+#[allow(dead_code)]
 #[allow(single_use_lifetimes)]
+#[allow(clippy::mut_mut)]
+#[allow(clippy::type_repetition_in_bounds)]
 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)>,
+    field: ::pin_project::__private::Pin<&'pin mut (T)>,
 }
 #[doc(hidden)]
-#[allow(dead_code)] // This lint warns unused fields/variants.
+#[allow(dead_code)]
 #[allow(single_use_lifetimes)]
+#[allow(clippy::type_repetition_in_bounds)]
 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)>,
+    field: ::pin_project::__private::Pin<&'pin (T)>,
 }
 
 #[doc(hidden)]
 #[allow(non_upper_case_globals)]
 #[allow(single_use_lifetimes)]
-const __SCOPE_Struct: () = {
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
     impl<'a, T> Struct<'a, T> {
         pub(crate) fn project<'pin>(
-            self: ::pin_project::__reexport::pin::Pin<&'pin mut Self>,
+            self: ::pin_project::__private::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),
+                    field: ::pin_project::__private::Pin::new_unchecked(field),
                 }
             }
         }
         pub(crate) fn project_ref<'pin>(
-            self: ::pin_project::__reexport::pin::Pin<&'pin Self>,
+            self: ::pin_project::__private::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),
+                    field: ::pin_project::__private::Pin::new_unchecked(field),
                 }
             }
         }
     }
 
-    impl<'a, T> ::pin_project::__reexport::ops::Drop for Struct<'a, T> {
+    impl<'a, T> ::pin_project::__private::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) };
+            let pinned_self = unsafe { ::pin_project::__private::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*.
@@ -107,13 +110,14 @@
         __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
+    impl<'pin, 'a, T> ::pin_project::__private::Unpin for Struct<'a, T> where
+        __Struct<'pin, 'a, T>: ::pin_project::__private::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.
+    // 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.
diff --git a/examples/project_replace-expanded.rs b/examples/project_replace-expanded.rs
index ec9f00e..661a0ac 100644
--- a/examples/project_replace-expanded.rs
+++ b/examples/project_replace-expanded.rs
@@ -5,7 +5,7 @@
 //
 // use pin_project::pin_project;
 //
-// #[pin_project(Replace)]
+// #[pin_project(project_replace)]
 // struct Struct<T, U> {
 //     #[pin]
 //     pinned: T,
@@ -27,64 +27,67 @@
 }
 
 #[doc(hidden)]
-#[allow(clippy::mut_mut)] // This lint warns `&mut &mut <ty>`.
-#[allow(dead_code)] // This lint warns unused fields/variants.
+#[allow(dead_code)]
 #[allow(single_use_lifetimes)]
+#[allow(clippy::mut_mut)]
+#[allow(clippy::type_repetition_in_bounds)]
 struct __StructProjection<'pin, T, U>
 where
     Struct<T, U>: 'pin,
 {
-    pinned: ::pin_project::__reexport::pin::Pin<&'pin mut (T)>,
+    pinned: ::pin_project::__private::Pin<&'pin mut (T)>,
     unpinned: &'pin mut (U),
 }
 #[doc(hidden)]
-#[allow(dead_code)] // This lint warns unused fields/variants.
+#[allow(dead_code)]
 #[allow(single_use_lifetimes)]
+#[allow(clippy::type_repetition_in_bounds)]
 struct __StructProjectionRef<'pin, T, U>
 where
     Struct<T, U>: 'pin,
 {
-    pinned: ::pin_project::__reexport::pin::Pin<&'pin (T)>,
+    pinned: ::pin_project::__private::Pin<&'pin (T)>,
     unpinned: &'pin (U),
 }
-
 #[doc(hidden)]
-#[allow(dead_code)] // This lint warns unused fields/variants.
+#[allow(dead_code)]
+#[allow(unreachable_pub)]
 #[allow(single_use_lifetimes)]
 struct __StructProjectionOwned<T, U> {
-    pinned: ::pin_project::__reexport::marker::PhantomData<T>,
+    pinned: ::pin_project::__private::PhantomData<T>,
     unpinned: U,
 }
 
 #[doc(hidden)]
 #[allow(non_upper_case_globals)]
 #[allow(single_use_lifetimes)]
-const __SCOPE_Struct: () = {
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
     impl<T, U> Struct<T, U> {
         fn project<'pin>(
-            self: ::pin_project::__reexport::pin::Pin<&'pin mut Self>,
+            self: ::pin_project::__private::Pin<&'pin mut Self>,
         ) -> __StructProjection<'pin, T, U> {
             unsafe {
                 let Self { pinned, unpinned } = self.get_unchecked_mut();
                 __StructProjection {
-                    pinned: ::pin_project::__reexport::pin::Pin::new_unchecked(pinned),
+                    pinned: ::pin_project::__private::Pin::new_unchecked(pinned),
                     unpinned,
                 }
             }
         }
         fn project_ref<'pin>(
-            self: ::pin_project::__reexport::pin::Pin<&'pin Self>,
+            self: ::pin_project::__private::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),
+                    pinned: ::pin_project::__private::Pin::new_unchecked(pinned),
                     unpinned,
                 }
             }
         }
         fn project_replace(
-            self: ::pin_project::__reexport::pin::Pin<&mut Self>,
+            self: ::pin_project::__private::Pin<&mut Self>,
             __replacement: Self,
         ) -> __StructProjectionOwned<T, U> {
             unsafe {
@@ -93,15 +96,15 @@
 
                 // First, extract all the unpinned fields
                 let __result = __StructProjectionOwned {
-                    pinned: ::pin_project::__reexport::marker::PhantomData,
-                    unpinned: ::pin_project::__reexport::ptr::read(unpinned),
+                    pinned: ::pin_project::__private::PhantomData,
+                    unpinned: ::pin_project::__private::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),
+                    value: ::pin_project::__private::ManuallyDrop::new(__replacement),
                 };
 
                 // Now create guards to drop all the pinned fields
@@ -127,8 +130,8 @@
         __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
+    impl<'pin, T, U> ::pin_project::__private::Unpin for Struct<T, U> where
+        __Struct<'pin, T, U>: ::pin_project::__private::Unpin
     {
     }
     unsafe impl<T, U> ::pin_project::UnsafeUnpin for Struct<T, U> {}
@@ -138,13 +141,14 @@
     // 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: ::pin_project::__private::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>) {}
+        unsafe fn drop(self: ::pin_project::__private::Pin<&mut Self>) {}
     }
 
-    // Ensure that it's impossible to use pin projections on a #[repr(packed)] struct.
+    // 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.
diff --git a/examples/project_replace.rs b/examples/project_replace.rs
index 4482625..99cec18 100644
--- a/examples/project_replace.rs
+++ b/examples/project_replace.rs
@@ -4,7 +4,7 @@
 
 use pin_project::pin_project;
 
-#[pin_project(Replace)]
+#[pin_project(project_replace)]
 struct Struct<T, U> {
     #[pin]
     pinned: T,
diff --git a/examples/struct-default-expanded.rs b/examples/struct-default-expanded.rs
index 2bf7edd..53f00c9 100644
--- a/examples/struct-default-expanded.rs
+++ b/examples/struct-default-expanded.rs
@@ -27,50 +27,53 @@
 }
 
 #[doc(hidden)]
-#[allow(clippy::mut_mut)] // This lint warns `&mut &mut <ty>`.
-#[allow(dead_code)] // This lint warns unused fields/variants.
+#[allow(dead_code)]
 #[allow(single_use_lifetimes)]
+#[allow(clippy::mut_mut)]
+#[allow(clippy::type_repetition_in_bounds)]
 struct __StructProjection<'pin, T, U>
 where
     Struct<T, U>: 'pin,
 {
-    pinned: ::pin_project::__reexport::pin::Pin<&'pin mut (T)>,
+    pinned: ::pin_project::__private::Pin<&'pin mut (T)>,
     unpinned: &'pin mut (U),
 }
 #[doc(hidden)]
-#[allow(dead_code)] // This lint warns unused fields/variants.
+#[allow(dead_code)]
 #[allow(single_use_lifetimes)]
+#[allow(clippy::type_repetition_in_bounds)]
 struct __StructProjectionRef<'pin, T, U>
 where
     Struct<T, U>: 'pin,
 {
-    pinned: ::pin_project::__reexport::pin::Pin<&'pin (T)>,
+    pinned: ::pin_project::__private::Pin<&'pin (T)>,
     unpinned: &'pin (U),
 }
 
 #[doc(hidden)]
 #[allow(non_upper_case_globals)]
 #[allow(single_use_lifetimes)]
-const __SCOPE_Struct: () = {
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
     impl<T, U> Struct<T, U> {
         fn project<'pin>(
-            self: ::pin_project::__reexport::pin::Pin<&'pin mut Self>,
+            self: ::pin_project::__private::Pin<&'pin mut Self>,
         ) -> __StructProjection<'pin, T, U> {
             unsafe {
                 let Self { pinned, unpinned } = self.get_unchecked_mut();
                 __StructProjection {
-                    pinned: ::pin_project::__reexport::pin::Pin::new_unchecked(pinned),
+                    pinned: ::pin_project::__private::Pin::new_unchecked(pinned),
                     unpinned,
                 }
             }
         }
         fn project_ref<'pin>(
-            self: ::pin_project::__reexport::pin::Pin<&'pin Self>,
+            self: ::pin_project::__private::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),
+                    pinned: ::pin_project::__private::Pin::new_unchecked(pinned),
                     unpinned,
                 }
             }
@@ -91,9 +94,9 @@
     // 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.
+    // 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
@@ -107,16 +110,16 @@
         __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
+    impl<'pin, T, U> ::pin_project::__private::Unpin for Struct<T, U> where
+        __Struct<'pin, T, U>: ::pin_project::__private::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.
+    // impls, we emit one ourselves. If the user ends up writing an `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`.
@@ -126,15 +129,16 @@
     // the conflict with the second impl.
     trait StructMustNotImplDrop {}
     #[allow(clippy::drop_bounds)]
-    impl<T: ::pin_project::__reexport::ops::Drop> StructMustNotImplDrop for T {}
+    impl<T: ::pin_project::__private::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>) {}
+        unsafe fn drop(self: ::pin_project::__private::Pin<&mut Self>) {}
     }
 
-    // Ensure that it's impossible to use pin projections on a #[repr(packed)] struct.
+    // 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
diff --git a/examples/unsafe_unpin-expanded.rs b/examples/unsafe_unpin-expanded.rs
index 7d8ad8e..e55b740 100644
--- a/examples/unsafe_unpin-expanded.rs
+++ b/examples/unsafe_unpin-expanded.rs
@@ -29,57 +29,60 @@
 }
 
 #[doc(hidden)]
-#[allow(clippy::mut_mut)] // This lint warns `&mut &mut <ty>`.
-#[allow(dead_code)] // This lint warns unused fields/variants.
+#[allow(dead_code)]
 #[allow(single_use_lifetimes)]
+#[allow(clippy::mut_mut)]
+#[allow(clippy::type_repetition_in_bounds)]
 pub(crate) struct __StructProjection<'pin, T, U>
 where
     Struct<T, U>: 'pin,
 {
-    pinned: ::pin_project::__reexport::pin::Pin<&'pin mut (T)>,
+    pinned: ::pin_project::__private::Pin<&'pin mut (T)>,
     unpinned: &'pin mut (U),
 }
 #[doc(hidden)]
-#[allow(dead_code)] // This lint warns unused fields/variants.
+#[allow(dead_code)]
 #[allow(single_use_lifetimes)]
+#[allow(clippy::type_repetition_in_bounds)]
 pub(crate) struct __StructProjectionRef<'pin, T, U>
 where
     Struct<T, U>: 'pin,
 {
-    pinned: ::pin_project::__reexport::pin::Pin<&'pin (T)>,
+    pinned: ::pin_project::__private::Pin<&'pin (T)>,
     unpinned: &'pin (U),
 }
 
 #[doc(hidden)]
 #[allow(non_upper_case_globals)]
 #[allow(single_use_lifetimes)]
-const __SCOPE_Struct: () = {
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
     impl<T, U> Struct<T, U> {
         pub(crate) fn project<'pin>(
-            self: ::pin_project::__reexport::pin::Pin<&'pin mut Self>,
+            self: ::pin_project::__private::Pin<&'pin mut Self>,
         ) -> __StructProjection<'pin, T, U> {
             unsafe {
                 let Self { pinned, unpinned } = self.get_unchecked_mut();
                 __StructProjection {
-                    pinned: ::pin_project::__reexport::pin::Pin::new_unchecked(pinned),
+                    pinned: ::pin_project::__private::Pin::new_unchecked(pinned),
                     unpinned,
                 }
             }
         }
         pub(crate) fn project_ref<'pin>(
-            self: ::pin_project::__reexport::pin::Pin<&'pin Self>,
+            self: ::pin_project::__private::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),
+                    pinned: ::pin_project::__private::Pin::new_unchecked(pinned),
                     unpinned,
                 }
             }
         }
     }
 
-    impl<'pin, T, U> ::pin_project::__reexport::marker::Unpin for Struct<T, U> where
+    impl<'pin, T, U> ::pin_project::__private::Unpin for Struct<T, U> where
         ::pin_project::__private::Wrapper<'pin, Self>: ::pin_project::UnsafeUnpin
     {
     }
@@ -89,13 +92,14 @@
     // 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: ::pin_project::__private::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>) {}
+        unsafe fn drop(self: ::pin_project::__private::Pin<&mut Self>) {}
     }
 
-    // Ensure that it's impossible to use pin projections on a #[repr(packed)] struct.
+    // 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.
diff --git a/rustfmt.toml b/rustfmt.toml
new file mode 100644
index 0000000..18c6d2a
--- /dev/null
+++ b/rustfmt.toml
@@ -0,0 +1,27 @@
+# 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.
+# This is unstable (tracking issue: https://github.com/rust-lang/rustfmt/issues/3383).
+version = "Two"
+# This is unstable (tracking issue: https://github.com/rust-lang/rustfmt/issues/3391)
+error_on_line_overflow = true
+
+# Override the default formatting style.
+# See https://internals.rust-lang.org/t/running-rustfmt-on-rust-lang-rust-and-other-rust-lang-repositories/8732/81.
+use_small_heuristics = "Max"
+# See https://github.com/rust-dev-tools/fmt-rfcs/issues/149.
+# This is unstable (tracking issue: https://github.com/rust-lang/rustfmt/issues/3370)
+overflow_delimited_expr = true
+
+# Apply rustfmt to more places.
+# This is unstable (tracking issue: https://github.com/rust-lang/rustfmt/issues/3362).
+merge_imports = true
+# This is unstable (tracking issue: https://github.com/rust-lang/rustfmt/issues/3348).
+format_code_in_doc_comments = true
+
+# Set the default settings again to always apply the proper formatting without
+# being affected by the editor settings.
+edition = "2018"
+tab_spaces = 4
diff --git a/src/lib.rs b/src/lib.rs
index b1543e1..1c4d453 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,8 +1,9 @@
-//! A crate for safe and ergonomic pin-projection.
+//! A crate for safe and ergonomic [pin-projection].
 //!
-//! ## Examples
+//! # Examples
 //!
-//! [`pin_project`] attribute creates a projection type covering all the fields of struct or enum.
+//! [`#[pin_project]`][`pin_project`] attribute creates projection types
+//! covering all the fields of struct or enum.
 //!
 //! ```rust
 //! use pin_project::pin_project;
@@ -16,7 +17,7 @@
 //! }
 //!
 //! impl<T, U> Struct<T, U> {
-//!     fn foo(self: Pin<&mut Self>) {
+//!     fn method(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
@@ -24,17 +25,18 @@
 //! }
 //! ```
 //!
-//! [Code like this will be generated](https://github.com/taiki-e/pin-project/blob/master/examples/struct-default-expanded.rs)
+//! [*code like this will be generated*][struct-default-expanded]
 //!
-//! 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.
+//! See [`#[pin_project]`][`pin_project`] attribute for more details, and
+//! see [examples] directory for more examples and generated code.
 //!
 //! [`pin_project`]: attr.pin_project.html
+//! [examples]: https://github.com/taiki-e/pin-project/blob/master/examples/README.md
+//! [pin-projection]: https://doc.rust-lang.org/nightly/std/pin/index.html#projections-and-structural-pinning
+//! [struct-default-expanded]: https://github.com/taiki-e/pin-project/blob/master/examples/struct-default-expanded.rs
 
 #![no_std]
-#![recursion_limit = "256"]
-#![doc(html_root_url = "https://docs.rs/pin-project/0.4.17")]
+#![doc(html_root_url = "https://docs.rs/pin-project/0.4.22")]
 #![doc(test(
     no_crate_inject,
     attr(deny(warnings, rust_2018_idioms, single_use_lifetimes), allow(dead_code))
@@ -44,6 +46,8 @@
 // mem::take and #[non_exhaustive] requires Rust 1.40
 #![allow(clippy::mem_replace_with_default, clippy::manual_non_exhaustive)]
 #![allow(clippy::needless_doctest_main)]
+// https://github.com/rust-lang/rust-clippy/issues/5704
+#![allow(clippy::unnested_or_patterns)]
 
 // ANDROID: Use std to allow building as a dylib.
 extern crate std;
@@ -54,18 +58,21 @@
 #[doc(inline)]
 pub use pin_project_internal::pinned_drop;
 
+#[allow(deprecated)]
 #[doc(inline)]
 pub use pin_project_internal::project;
 
+#[allow(deprecated)]
 #[doc(inline)]
 pub use pin_project_internal::project_ref;
 
+#[allow(deprecated)]
 #[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`]
+/// argument to [`#[pin_project]`][`pin_project`]
 ///
 /// The Rust [`Unpin`] trait is safe to implement - by itself,
 /// implementing it cannot lead to undefined behavior. Undefined
@@ -78,9 +85,9 @@
 ///
 /// 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`].
+/// documentation][pin-projection], 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`] -
@@ -92,15 +99,16 @@
 ///
 /// 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
+/// 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`.
+/// Since this trait is `unsafe`, impls of it will be detected by the
+/// `unsafe_code` lint, and by tools like [`cargo geiger`][cargo-geiger].
 ///
-/// ## Examples
+/// # Examples
 ///
-/// An `UnsafeUnpin` impl which, in addition to requiring that structurally pinned
-/// fields be [`Unpin`], imposes an additional requirement:
+/// 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};
@@ -117,13 +125,23 @@
 ///
 /// [`PhantomPinned`]: core::marker::PhantomPinned
 /// [`pin_project`]: attr.pin_project.html
+/// [pin-projection]: https://doc.rust-lang.org/nightly/std/pin/index.html#projections-and-structural-pinning
+/// [cargo-geiger]: https://github.com/rust-secure-code/cargo-geiger
 pub unsafe trait UnsafeUnpin {}
 
 // Not public API.
 #[doc(hidden)]
 pub mod __private {
+    #[doc(hidden)]
+    pub use core::{
+        marker::{PhantomData, PhantomPinned, Unpin},
+        mem::ManuallyDrop,
+        ops::Drop,
+        pin::Pin,
+        ptr,
+    };
+
     use super::UnsafeUnpin;
-    use core::{marker::PhantomData, mem::ManuallyDrop, pin::Pin, ptr};
 
     #[doc(hidden)]
     pub use pin_project_internal::__PinProjectInternalDerive;
@@ -153,6 +171,7 @@
     //
     // Supposed we have the following code:
     //
+    // ```rust
     // #[pin_project(UnsafeUnpin)]
     // struct MyStruct<T> {
     //     #[pin] field: T
@@ -160,37 +179,43 @@
     //
     // 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!
+    // 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 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.
+    // The solution is to introduce the `Wrapper` struct, which is defined
+    // in the `pin-project` crate.
     //
     // We now have code that looks like this:
     //
+    // ```rust
     // 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.
+    // 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).
+    // 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 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`
+    // 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);
 
@@ -232,11 +257,3 @@
         }
     }
 }
-
-// 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
index 20b8472..4133517 100644
--- a/tests/cfg.rs
+++ b/tests/cfg.rs
@@ -21,7 +21,7 @@
 fn cfg() {
     // structs
 
-    #[pin_project(Replace)]
+    #[pin_project(project_replace)]
     struct SameName {
         #[cfg(target_os = "linux")]
         #[pin]
@@ -41,7 +41,7 @@
     #[cfg(not(target_os = "linux"))]
     let _x = SameName { inner: Other };
 
-    #[pin_project(Replace)]
+    #[pin_project(project_replace)]
     struct DifferentName {
         #[cfg(target_os = "linux")]
         #[pin]
@@ -61,7 +61,7 @@
     #[cfg(not(target_os = "linux"))]
     let _x = DifferentName { o: Other };
 
-    #[pin_project(Replace)]
+    #[pin_project(project_replace)]
     struct TupleStruct(
         #[cfg(target_os = "linux")]
         #[pin]
@@ -83,7 +83,7 @@
 
     // enums
 
-    #[pin_project(Replace)]
+    #[pin_project(project_replace)]
     enum Variant {
         #[cfg(target_os = "linux")]
         Inner(#[pin] Linux),
@@ -110,7 +110,7 @@
     #[cfg(not(target_os = "linux"))]
     let _x = Variant::Other(Other);
 
-    #[pin_project(Replace)]
+    #[pin_project(project_replace)]
     enum Field {
         SameName {
             #[cfg(target_os = "linux")]
@@ -167,7 +167,7 @@
 
 #[test]
 fn cfg_attr() {
-    #[pin_project(Replace)]
+    #[pin_project(project_replace)]
     struct SameCfg {
         #[cfg(target_os = "linux")]
         #[cfg_attr(target_os = "linux", pin)]
@@ -193,7 +193,7 @@
     #[cfg(not(target_os = "linux"))]
     let _: Pin<&mut Other> = x.inner;
 
-    #[pin_project(Replace)]
+    #[pin_project(project_replace)]
     struct DifferentCfg {
         #[cfg(target_os = "linux")]
         #[cfg_attr(target_os = "linux", pin)]
@@ -233,7 +233,7 @@
 #[test]
 fn cfg_attr_any_packed() {
     // Since `cfg(any())` can never be true, it is okay for this to pass.
-    #[pin_project(Replace)]
+    #[pin_project(project_replace)]
     #[cfg_attr(any(), repr(packed))]
     struct Struct {
         #[pin]
diff --git a/tests/compiletest.rs b/tests/compiletest.rs
index 078abaa..e78b3dc 100644
--- a/tests/compiletest.rs
+++ b/tests/compiletest.rs
@@ -1,6 +1,6 @@
 #![warn(rust_2018_idioms, single_use_lifetimes)]
 
-#[ignore]
+#[rustversion::attr(not(nightly), ignore)]
 #[test]
 fn ui() {
     let t = trybuild::TestCases::new();
diff --git a/tests/forbid_unsafe.rs b/tests/forbid_unsafe.rs
deleted file mode 100644
index 4b2e248..0000000
--- a/tests/forbid_unsafe.rs
+++ /dev/null
@@ -1,108 +0,0 @@
-#![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/include/basic-safe-part.rs b/tests/include/basic-safe-part.rs
new file mode 100644
index 0000000..fefc924
--- /dev/null
+++ b/tests/include/basic-safe-part.rs
@@ -0,0 +1,136 @@
+// default #[pin_project], PinnedDrop, project_replace, !Unpin, and UnsafeUnpin without UnsafeUnpin impl are completely safe.
+
+#[::pin_project::pin_project]
+#[derive(Debug)]
+pub struct DefaultStruct<T, U> {
+    #[pin]
+    pub pinned: T,
+    pub unpinned: U,
+}
+
+#[::pin_project::pin_project]
+#[derive(Debug)]
+pub struct DefaultTupleStruct<T, U>(#[pin] pub T, pub U);
+
+#[::pin_project::pin_project]
+#[derive(Debug)]
+pub enum DefaultEnum<T, U> {
+    Struct {
+        #[pin]
+        pinned: T,
+        unpinned: U,
+    },
+    Tuple(#[pin] T, U),
+    Unit,
+}
+
+#[::pin_project::pin_project(PinnedDrop)]
+#[derive(Debug)]
+pub struct PinnedDropStruct<T, U> {
+    #[pin]
+    pub pinned: T,
+    pub unpinned: U,
+}
+
+#[::pin_project::pinned_drop]
+impl<T, U> PinnedDrop for PinnedDropStruct<T, U> {
+    fn drop(self: ::pin_project::__private::Pin<&mut Self>) {}
+}
+
+#[::pin_project::pin_project(PinnedDrop)]
+#[derive(Debug)]
+pub struct PinnedDropTupleStruct<T, U>(#[pin] pub T, pub U);
+
+#[::pin_project::pinned_drop]
+impl<T, U> PinnedDrop for PinnedDropTupleStruct<T, U> {
+    fn drop(self: ::pin_project::__private::Pin<&mut Self>) {}
+}
+
+#[::pin_project::pin_project(PinnedDrop)]
+#[derive(Debug)]
+pub enum PinnedDropEnum<T, U> {
+    Struct {
+        #[pin]
+        pinned: T,
+        unpinned: U,
+    },
+    Tuple(#[pin] T, U),
+    Unit,
+}
+
+#[::pin_project::pinned_drop]
+impl<T, U> PinnedDrop for PinnedDropEnum<T, U> {
+    fn drop(self: ::pin_project::__private::Pin<&mut Self>) {}
+}
+
+#[::pin_project::pin_project(project_replace)]
+#[derive(Debug)]
+pub struct ReplaceStruct<T, U> {
+    #[pin]
+    pub pinned: T,
+    pub unpinned: U,
+}
+
+#[::pin_project::pin_project(project_replace)]
+#[derive(Debug)]
+pub struct ReplaceTupleStruct<T, U>(#[pin] pub T, pub U);
+
+#[::pin_project::pin_project(project_replace)]
+#[derive(Debug)]
+pub enum ReplaceEnum<T, U> {
+    Struct {
+        #[pin]
+        pinned: T,
+        unpinned: U,
+    },
+    Tuple(#[pin] T, U),
+    Unit,
+}
+
+#[::pin_project::pin_project(UnsafeUnpin)]
+#[derive(Debug)]
+pub struct UnsafeUnpinStruct<T, U> {
+    #[pin]
+    pub pinned: T,
+    pub unpinned: U,
+}
+
+#[::pin_project::pin_project(UnsafeUnpin)]
+#[derive(Debug)]
+pub struct UnsafeUnpinTupleStruct<T, U>(#[pin] pub T, pub U);
+
+#[::pin_project::pin_project(UnsafeUnpin)]
+#[derive(Debug)]
+pub enum UnsafeUnpinEnum<T, U> {
+    Struct {
+        #[pin]
+        pinned: T,
+        unpinned: U,
+    },
+    Tuple(#[pin] T, U),
+    Unit,
+}
+
+#[::pin_project::pin_project(!Unpin)]
+#[derive(Debug)]
+pub struct NotUnpinStruct<T, U> {
+    #[pin]
+    pub pinned: T,
+    pub unpinned: U,
+}
+
+#[::pin_project::pin_project(!Unpin)]
+#[derive(Debug)]
+pub struct NotUnpinTupleStruct<T, U>(#[pin] pub T, pub U);
+
+#[::pin_project::pin_project(!Unpin)]
+#[derive(Debug)]
+pub enum NotUnpinEnum<T, U> {
+    Struct {
+        #[pin]
+        pinned: T,
+        unpinned: U,
+    },
+    Tuple(#[pin] T, U),
+    Unit,
+}
diff --git a/tests/include/basic.rs b/tests/include/basic.rs
new file mode 100644
index 0000000..f862c63
--- /dev/null
+++ b/tests/include/basic.rs
@@ -0,0 +1,14 @@
+include!("basic-safe-part.rs");
+
+unsafe impl<T: ::pin_project::__private::Unpin, U: ::pin_project::__private::Unpin>
+    ::pin_project::UnsafeUnpin for UnsafeUnpinStruct<T, U>
+{
+}
+unsafe impl<T: ::pin_project::__private::Unpin, U: ::pin_project::__private::Unpin>
+    ::pin_project::UnsafeUnpin for UnsafeUnpinTupleStruct<T, U>
+{
+}
+unsafe impl<T: ::pin_project::__private::Unpin, U: ::pin_project::__private::Unpin>
+    ::pin_project::UnsafeUnpin for UnsafeUnpinEnum<T, U>
+{
+}
diff --git a/tests/lint.rs b/tests/lint.rs
new file mode 100644
index 0000000..25cb649
--- /dev/null
+++ b/tests/lint.rs
@@ -0,0 +1,135 @@
+#![warn(rust_2018_idioms, single_use_lifetimes)]
+#![warn(future_incompatible, nonstandard_style, rust_2018_compatibility, unused)]
+#![warn(clippy::all, clippy::pedantic, clippy::nursery)]
+
+#[allow(unknown_lints)] // for old compilers
+#[warn(
+    absolute_paths_not_starting_with_crate,
+    anonymous_parameters,
+    box_pointers,
+    confusable_idents,
+    deprecated_in_future,
+    elided_lifetimes_in_paths,
+    explicit_outlives_requirements,
+    indirect_structural_match,
+    keyword_idents,
+    macro_use_extern_crate,
+    meta_variable_misuse,
+    missing_copy_implementations,
+    missing_crate_level_docs,
+    missing_debug_implementations,
+    missing_docs,
+    missing_doc_code_examples,
+    non_ascii_idents,
+    private_doc_tests,
+    single_use_lifetimes,
+    trivial_casts,
+    trivial_numeric_casts,
+    unaligned_references,
+    unreachable_pub,
+    unstable_features,
+    unused_extern_crates,
+    unused_import_braces,
+    unused_lifetimes,
+    unused_qualifications,
+    unused_results,
+    variant_size_differences
+)]
+// unused_crate_dependencies: unrelated
+// unsafe_code: checked in forbid_unsafe module
+// unsafe_block_in_unsafe_fn: unstable
+pub mod basic {
+    include!("include/basic.rs");
+}
+
+pub mod forbid_unsafe {
+    #![forbid(unsafe_code)]
+
+    include!("include/basic-safe-part.rs");
+}
+
+pub mod clippy {
+    use pin_project::pin_project;
+
+    #[pin_project(project_replace)]
+    pub struct MutMutStruct<'a, T, U> {
+        #[pin]
+        pub pinned: &'a mut T,
+        pub unpinned: &'a mut U,
+    }
+
+    #[pin_project(project_replace)]
+    pub struct MutMutTupleStruct<'a, T, U>(#[pin] &'a mut T, &'a mut U);
+
+    #[pin_project(project_replace)]
+    pub enum MutMutEnum<'a, T, U> {
+        Struct {
+            #[pin]
+            pinned: &'a mut T,
+            unpinned: &'a mut U,
+        },
+        Tuple(#[pin] &'a mut T, &'a mut U),
+        Unit,
+    }
+
+    #[pin_project(project_replace)]
+    pub struct TypeRepetitionInBoundsStruct<T, U>
+    where
+        Self: Sized,
+    {
+        #[pin]
+        pub pinned: T,
+        pub unpinned: U,
+    }
+
+    #[pin_project(project_replace)]
+    pub struct TypeRepetitionInBoundsTupleStruct<T, U>(#[pin] T, U)
+    where
+        Self: Sized;
+
+    #[pin_project(project_replace)]
+    pub enum TypeRepetitionInBoundsEnum<T, U>
+    where
+        Self: Sized,
+    {
+        Struct {
+            #[pin]
+            pinned: T,
+            unpinned: U,
+        },
+        Tuple(#[pin] T, U),
+        Unit,
+    }
+
+    #[pin_project(project_replace)]
+    pub struct UsedUnderscoreBindingStruct<T, U> {
+        #[pin]
+        pub _pinned: T,
+        pub _unpinned: U,
+    }
+
+    #[pin_project(project_replace)]
+    pub enum UsedUnderscoreBindingEnum<T, U> {
+        Struct {
+            #[pin]
+            _pinned: T,
+            _unpinned: U,
+        },
+    }
+}
+
+#[rustversion::attr(not(since(2020-06-12)), ignore)]
+#[test]
+fn check_lint_list() {
+    use std::{env, process::Command, str};
+
+    (|| -> Result<(), Box<dyn std::error::Error>> {
+        let current = include_str!("lint.txt");
+        let rustc = env::var_os("RUSTC").unwrap_or_else(|| "rustc".into());
+        let output = Command::new(rustc).args(&["-W", "help"]).output()?;
+        let new = str::from_utf8(&output.stdout)?;
+        assert_eq!(current, new);
+        Ok(())
+    })()
+    .unwrap_or_else(|e| panic!("{}", e));
+}
diff --git a/tests/lint.txt b/tests/lint.txt
new file mode 100644
index 0000000..5110d4b
--- /dev/null
+++ b/tests/lint.txt
@@ -0,0 +1,139 @@
+
+Available lint options:
+    -W <foo>           Warn about <foo>
+    -A <foo>           Allow <foo>
+    -D <foo>           Deny <foo>
+    -F <foo>           Forbid <foo> (deny <foo> and all attempts to override)
+
+
+Lint checks provided by rustc:
+
+                                                       name  default  meaning
+                                                       ----  -------  -------
+                     absolute-paths-not-starting-with-crate  allow    fully qualified paths that start with a module name instead of `crate`, `self`, or an extern crate name
+                                       anonymous-parameters  allow    detects anonymous parameters
+                                               box-pointers  allow    use of owned (Box type) heap memory
+                                          confusable-idents  allow    detects visually confusable pairs between identifiers
+                                       deprecated-in-future  allow    detects use of items that will be deprecated in a future version
+                                  elided-lifetimes-in-paths  allow    hidden lifetime parameters in types are deprecated
+                             explicit-outlives-requirements  allow    outlives requirements can be inferred
+                                  indirect-structural-match  allow    pattern with const indirectly referencing non-structural-match type
+                                             keyword-idents  allow    detects edition keywords being used as an identifier
+                                     macro-use-extern-crate  allow    the `#[macro_use]` attribute is now deprecated in favor of using macros via the module system
+                                       meta-variable-misuse  allow    possible meta-variable misuse at macro definition
+                               missing-copy-implementations  allow    detects potentially-forgotten implementations of `Copy`
+                                   missing-crate-level-docs  allow    detects crates with no crate-level documentation
+                              missing-debug-implementations  allow    detects missing implementations of Debug
+                                               missing-docs  allow    detects missing documentation for public members
+                                  missing-doc-code-examples  allow    detects publicly-exported items without code samples in their documentation
+                                           non-ascii-idents  allow    detects non-ASCII identifiers
+                                          private-doc-tests  allow    detects code samples in docs of private items not documented by rustdoc
+                                       single-use-lifetimes  allow    detects lifetime parameters that are only used once
+                                              trivial-casts  allow    detects trivial casts which could be removed
+                                      trivial-numeric-casts  allow    detects trivial casts of numeric types which could be removed
+                                       unaligned-references  allow    detects unaligned references to fields of packed structs
+                                            unreachable-pub  allow    `pub` items not reachable from crate root
+                                                unsafe-code  allow    usage of `unsafe` code
+                                     unsafe-op-in-unsafe-fn  allow    unsafe operations in unsafe functions without an explicit unsafe block are deprecated
+                                          unstable-features  allow    enabling unstable features (deprecated. do not use)
+                                  unused-crate-dependencies  allow    crate dependencies that are never used
+                                       unused-extern-crates  allow    extern crates that are never used
+                                       unused-import-braces  allow    unnecessary braces around an imported item
+                                           unused-lifetimes  allow    detects lifetime parameters that are never used
+                                      unused-qualifications  allow    detects unnecessarily qualified names
+                                             unused-results  allow    unused result of an expression in a statement
+                                   variant-size-differences  allow    detects enums with widely varying variant sizes
+                                            array-into-iter  warn     detects calling `into_iter` on arrays
+                                           asm-sub-register  warn     using only a subset of a register for inline asm inputs
+                                         bare-trait-objects  warn     suggest using `dyn Trait` for trait objects
+                                 bindings-with-variant-name  warn     detects pattern bindings with the same name as one of the matched variants
+                                       coherence-leak-check  warn     distinct impls distinguished only by the leak-check code
+                                                  dead-code  warn     detect unused, unexported items
+                                                 deprecated  warn     detects use of deprecated items
+                          ellipsis-inclusive-range-patterns  warn     `...` range patterns are deprecated
+                              exported-private-dependencies  warn     public interface leaks type from a private dependency
+                     illegal-floating-point-literal-pattern  warn     floating-point literals cannot be used in patterns
+                                            improper-ctypes  warn     proper use of libc types in foreign modules
+                                        incomplete-features  warn     incomplete features that may function improperly in some or all cases
+                                         inline-no-sanitize  warn     detects incompatible use of `#[inline(always)]` and `#[no_sanitize(...)]`
+                          intra-doc-link-resolution-failure  warn     failures in resolving intra-doc link targets
+                                invalid-codeblock-attribute  warn     codeblock attribute looks a lot like a known one
+                                              invalid-value  warn     an invalid value is being created (such as a NULL reference)
+                                   irrefutable-let-patterns  warn     detects irrefutable patterns in if-let and while-let statements
+                              late-bound-lifetime-arguments  warn     detects generic lifetime arguments in path segments with late bound lifetime parameters
+                        mutable-borrow-reservation-conflict  warn     reservation of a two-phased borrow conflicts with other shared borrows
+                                       non-camel-case-types  warn     types, variants, traits and type parameters should have camel case names
+                               non-shorthand-field-patterns  warn     using `Struct { x: x }` instead of `Struct { x }` in a pattern
+                                             non-snake-case  warn     variables, methods, functions, lifetime parameters and modules should have snake case names
+                                     non-upper-case-globals  warn     static constants should have uppercase identifiers
+                                    no-mangle-generic-items  warn     generic items must be mangled
+                                       overlapping-patterns  warn     detects overlapping patterns
+                                            path-statements  warn     path statements with no effect
+                                          private-in-public  warn     detect private items in public interfaces not caught by the old implementation
+                      proc-macro-derive-resolution-fallback  warn     detects proc macro derives using inaccessible names from parent modules
+                                       redundant-semicolons  warn     detects unnecessary trailing semicolons
+                                  renamed-and-removed-lints  warn     lints that have been renamed or removed
+                                        safe-packed-borrows  warn     safe borrows of fields of packed structs were erroneously allowed
+                                            stable-features  warn     stable features found in `#[feature]` directive
+                                             trivial-bounds  warn     these bounds don't depend on an type parameters
+                                          type-alias-bounds  warn     bounds in type aliases are not enforced
+                                   tyvar-behind-raw-pointer  warn     raw pointer to an inference variable
+                                        uncommon-codepoints  warn     detects uncommon Unicode codepoints in identifiers
+                                    unconditional-recursion  warn     functions that cannot return without calling themselves
+                                              unknown-lints  warn     unrecognized lint attribute
+                                      unnameable-test-items  warn     detects an item that cannot be named being marked as `#[test_case]`
+                                           unreachable-code  warn     detects unreachable code paths
+                                       unreachable-patterns  warn     detects unreachable patterns
+                                   unstable-name-collisions  warn     detects name collision with an existing but unstable method
+                                          unused-allocation  warn     detects unnecessary allocations that can be eliminated
+                                         unused-assignments  warn     detect assignments that will never be read
+                                          unused-attributes  warn     detects attributes that were not used by the compiler
+                                              unused-braces  warn     unnecessary braces around an expression
+                                         unused-comparisons  warn     comparisons made useless by limits of the types involved
+                                        unused-doc-comments  warn     detects doc comments that aren't used by rustdoc
+                                            unused-features  warn     unused features found in crate-level `#[feature]` directives
+                                             unused-imports  warn     imports that are never used
+                                              unused-labels  warn     detects labels that are never used
+                                              unused-macros  warn     detects macros that were not used
+                                            unused-must-use  warn     unused result of a type flagged as `#[must_use]`
+                                                 unused-mut  warn     detect mut variables which don't need to be mutable
+                                              unused-parens  warn     `if`, `match`, `while` and `return` do not need parentheses
+                                              unused-unsafe  warn     unnecessary use of an `unsafe` block
+                                           unused-variables  warn     detect variables which are not used in any way
+                                                   warnings  warn     mass-change the level for lints which produce warnings
+                                where-clauses-object-safety  warn     checks the object safety of where clauses
+                                                 while-true  warn     suggest using `loop { }` instead of `while true { }`
+                                 ambiguous-associated-items  deny     ambiguous associated items
+                                        arithmetic-overflow  deny     arithmetic operation overflows
+                                     conflicting-repr-hints  deny     conflicts between `#[repr(..)]` hints that were previously accepted and used in practice
+                                                  const-err  deny     constant evaluation detected erroneous expression
+                                 ill-formed-attribute-input  deny     ill-formed attribute inputs that were previously accepted and used in practice
+                                         incomplete-include  deny     trailing content in included file
+                                 invalid-type-param-default  deny     type parameter default erroneously allowed in invalid location
+    macro-expanded-macro-exports-accessed-by-absolute-paths  deny     macro-expanded `macro_export` macros from the current crate cannot be referred to by absolute paths
+                                 missing-fragment-specifier  deny     detects missing fragment specifiers in unused `macro_rules!` patterns
+                                         mutable-transmutes  deny     mutating transmuted &mut T from &T may cause undefined behavior
+                                      no-mangle-const-items  deny     const items will not have their symbols exported
+                              order-dependent-trait-objects  deny     trait-object types were treated as different depending on marker-trait order
+                                       overflowing-literals  deny     literal out of range for its type
+                               patterns-in-fns-without-body  deny     patterns in functions without body were erroneously allowed
+                            pub-use-of-private-extern-crate  deny     detect public re-exports of private extern crates
+                                              soft-unstable  deny     a feature gate that doesn't break dependent crates
+                                        unconditional-panic  deny     operation will cause a panic at runtime
+                                        unknown-crate-types  deny     unknown crate type found in `#[crate_type]` directive
+
+
+Lint groups provided by rustc:
+
+                       name  sub-lints
+                       ----  ---------
+                   warnings  all lints that are set to issue warnings
+        future-incompatible  keyword-idents, anonymous-parameters, illegal-floating-point-literal-pattern, private-in-public, pub-use-of-private-extern-crate, invalid-type-param-default, safe-packed-borrows, patterns-in-fns-without-body, missing-fragment-specifier, late-bound-lifetime-arguments, order-dependent-trait-objects, coherence-leak-check, tyvar-behind-raw-pointer, absolute-paths-not-starting-with-crate, unstable-name-collisions, where-clauses-object-safety, proc-macro-derive-resolution-fallback, macro-expanded-macro-exports-accessed-by-absolute-paths, ill-formed-attribute-input, conflicting-repr-hints, ambiguous-associated-items, mutable-borrow-reservation-conflict, indirect-structural-match, soft-unstable, array-into-iter
+          nonstandard-style  non-camel-case-types, non-snake-case, non-upper-case-globals
+    rust-2018-compatibility  keyword-idents, anonymous-parameters, tyvar-behind-raw-pointer, absolute-paths-not-starting-with-crate
+           rust-2018-idioms  bare-trait-objects, unused-extern-crates, ellipsis-inclusive-range-patterns, elided-lifetimes-in-paths, explicit-outlives-requirements
+                    rustdoc  intra-doc-link-resolution-failure, invalid-codeblock-attribute, missing-doc-code-examples, private-doc-tests
+                     unused  unused-imports, unused-variables, unused-assignments, dead-code, unused-mut, unreachable-code, unreachable-patterns, overlapping-patterns, unused-must-use, unused-unsafe, path-statements, unused-attributes, unused-macros, unused-allocation, unused-doc-comments, unused-extern-crates, unused-features, unused-labels, unused-parens, unused-braces, redundant-semicolons
+
+
+Compiler plugins can provide additional lints and lint groups. To see a listing of these, re-run `rustc -W help` with a crate filename.
diff --git a/tests/lints.rs b/tests/lints.rs
deleted file mode 100644
index 4009f55..0000000
--- a/tests/lints.rs
+++ /dev/null
@@ -1,126 +0,0 @@
-#![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
deleted file mode 100644
index 121104c..0000000
--- a/tests/overwriting_core_crate.rs
+++ /dev/null
@@ -1,116 +0,0 @@
-#![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
index 72bcd15..766887f 100644
--- a/tests/pin_project.rs
+++ b/tests/pin_project.rs
@@ -1,16 +1,15 @@
 #![warn(rust_2018_idioms, single_use_lifetimes)]
 #![allow(dead_code)]
 
-use core::{
+use pin_project::{pin_project, pinned_drop, UnsafeUnpin};
+use std::{
     marker::{PhantomData, PhantomPinned},
     pin::Pin,
 };
-use pin_project::{pin_project, pinned_drop, UnsafeUnpin};
 
 #[test]
 fn projection() {
     #[pin_project(
-        Replace,
         project = StructProj,
         project_ref = StructProjRef,
         project_replace = StructProjOwn,
@@ -53,7 +52,7 @@
     assert_eq!(s.field1, 3);
     assert_eq!(s.field2, 4);
 
-    #[pin_project(Replace)]
+    #[pin_project(project_replace)]
     struct TupleStruct<T, U>(#[pin] T, U);
 
     let mut s = TupleStruct(1, 2);
@@ -65,7 +64,7 @@
     let y: &mut i32 = s.1;
     assert_eq!(*y, 2);
 
-    #[pin_project(Replace, project = EnumProj)]
+    #[pin_project(project_replace, project = EnumProj)]
     #[derive(Eq, PartialEq, Debug)]
     enum Enum<A, B, C, D> {
         Variant1(#[pin] A, B),
@@ -127,7 +126,7 @@
 
 #[test]
 fn enum_project_set() {
-    #[pin_project(Replace, project = EnumProj)]
+    #[pin_project(project_replace, project = EnumProj)]
     #[derive(Eq, PartialEq, Debug)]
     enum Enum {
         Variant1(#[pin] u8),
@@ -175,7 +174,7 @@
 
 #[test]
 fn where_clause_and_associated_type_field() {
-    #[pin_project(Replace)]
+    #[pin_project(project_replace)]
     struct Struct1<I>
     where
         I: Iterator,
@@ -185,7 +184,7 @@
         field2: I::Item,
     }
 
-    #[pin_project(Replace)]
+    #[pin_project(project_replace)]
     struct Struct2<I, J>
     where
         I: Iterator<Item = J>,
@@ -195,7 +194,7 @@
         field2: J,
     }
 
-    #[pin_project(Replace)]
+    #[pin_project(project_replace)]
     struct Struct3<T>
     where
         T: 'static,
@@ -207,12 +206,12 @@
 
     impl<T> Static for Struct3<T> {}
 
-    #[pin_project(Replace)]
+    #[pin_project(project_replace)]
     struct TupleStruct<I>(#[pin] I, I::Item)
     where
         I: Iterator;
 
-    #[pin_project(Replace)]
+    #[pin_project(project_replace)]
     enum Enum<I>
     where
         I: Iterator,
@@ -224,7 +223,7 @@
 
 #[test]
 fn derive_copy() {
-    #[pin_project(Replace)]
+    #[pin_project(project_replace)]
     #[derive(Clone, Copy)]
     struct Struct<T> {
         val: T,
@@ -239,7 +238,7 @@
 fn move_out() {
     struct NotCopy;
 
-    #[pin_project(Replace)]
+    #[pin_project(project_replace)]
     struct Struct {
         val: NotCopy,
     }
@@ -247,7 +246,7 @@
     let x = Struct { val: NotCopy };
     let _val: NotCopy = x.val;
 
-    #[pin_project(Replace)]
+    #[pin_project(project_replace)]
     enum Enum {
         Variant(NotCopy),
     }
@@ -261,39 +260,39 @@
 
 #[test]
 fn trait_bounds_on_type_generics() {
-    #[pin_project(Replace)]
+    #[pin_project(project_replace)]
     pub struct Struct1<'a, T: ?Sized> {
         field: &'a mut T,
     }
 
-    #[pin_project(Replace)]
+    #[pin_project(project_replace)]
     pub struct Struct2<'a, T: ::core::fmt::Debug> {
         field: &'a mut T,
     }
 
-    #[pin_project(Replace)]
+    #[pin_project(project_replace)]
     pub struct Struct3<'a, T: core::fmt::Debug> {
         field: &'a mut T,
     }
 
-    #[pin_project(Replace)]
+    #[pin_project(project_replace)]
     pub struct Struct4<'a, T: core::fmt::Debug + core::fmt::Display> {
         field: &'a mut T,
     }
 
-    #[pin_project(Replace)]
+    #[pin_project(project_replace)]
     pub struct Struct5<'a, T: core::fmt::Debug + ?Sized> {
         field: &'a mut T,
     }
 
-    #[pin_project(Replace)]
+    #[pin_project(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)]
+    #[pin_project(project_replace)]
     pub struct Struct7<T: 'static> {
         field: T,
     }
@@ -302,16 +301,16 @@
 
     impl<T> Static for Struct7<T> {}
 
-    #[pin_project(Replace)]
+    #[pin_project(project_replace)]
     pub struct Struct8<'a, 'b: 'a> {
         field1: &'a u8,
         field2: &'b u8,
     }
 
-    #[pin_project(Replace)]
+    #[pin_project(project_replace)]
     pub struct TupleStruct<'a, T: ?Sized>(&'a mut T);
 
-    #[pin_project(Replace)]
+    #[pin_project(project_replace)]
     enum Enum<'a, T: ?Sized> {
         Variant(&'a mut T),
     }
@@ -319,13 +318,13 @@
 
 #[test]
 fn overlapping_lifetime_names() {
-    #[pin_project(Replace)]
+    #[pin_project(project_replace)]
     pub struct Struct1<'pin, T> {
         #[pin]
         field: &'pin mut T,
     }
 
-    #[pin_project(Replace)]
+    #[pin_project(project_replace)]
     pub struct Struct2<'pin, 'pin_, 'pin__> {
         #[pin]
         field: &'pin &'pin_ &'pin__ (),
@@ -334,7 +333,7 @@
     pub trait A<'a> {}
 
     #[allow(single_use_lifetimes)] // https://github.com/rust-lang/rust/issues/55058
-    #[pin_project(Replace)]
+    #[pin_project(project_replace)]
     pub struct HRTB<'pin___, T>
     where
         for<'pin> &'pin T: Unpin,
@@ -349,39 +348,39 @@
 #[test]
 fn combine() {
     #[pin_project(PinnedDrop, UnsafeUnpin)]
-    pub struct Struct1<T> {
+    pub struct PinnedDropWithUnsafeUnpin<T> {
         #[pin]
         field: T,
     }
 
     #[pinned_drop]
-    impl<T> PinnedDrop for Struct1<T> {
+    impl<T> PinnedDrop for PinnedDropWithUnsafeUnpin<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> {}
+    unsafe impl<T: Unpin> UnsafeUnpin for PinnedDropWithUnsafeUnpin<T> {}
 
     #[pin_project(PinnedDrop, !Unpin)]
-    pub struct Struct3<T> {
+    pub struct PinnedDropWithNotUnpin<T> {
         #[pin]
         field: T,
     }
 
     #[pinned_drop]
-    impl<T> PinnedDrop for Struct3<T> {
+    impl<T> PinnedDrop for PinnedDropWithNotUnpin<T> {
         fn drop(self: Pin<&mut Self>) {}
     }
 
-    #[pin_project(!Unpin, Replace)]
-    pub struct Struct4<T> {
+    #[pin_project(UnsafeUnpin, project_replace)]
+    pub struct UnsafeUnpinWithReplace<T> {
+        #[pin]
+        field: T,
+    }
+
+    unsafe impl<T: Unpin> UnsafeUnpin for UnsafeUnpinWithReplace<T> {}
+
+    #[pin_project(!Unpin, project_replace)]
+    pub struct NotUnpinWithReplace<T> {
         #[pin]
         field: T,
     }
@@ -389,7 +388,7 @@
 
 #[test]
 fn private_type_in_public_type() {
-    #[pin_project(Replace)]
+    #[pin_project(project_replace)]
     pub struct PublicStruct<T> {
         #[pin]
         inner: PrivateStruct<T>,
@@ -400,21 +399,21 @@
 
 #[test]
 fn lifetime_project() {
-    #[pin_project(Replace)]
+    #[pin_project(project_replace)]
     struct Struct1<T, U> {
         #[pin]
         pinned: T,
         unpinned: U,
     }
 
-    #[pin_project(Replace)]
+    #[pin_project(project_replace)]
     struct Struct2<'a, T, U> {
         #[pin]
         pinned: &'a mut T,
         unpinned: U,
     }
 
-    #[pin_project(Replace, project = EnumProj, project_ref = EnumProjRef)]
+    #[pin_project(project_replace, project = EnumProj, project_ref = EnumProjRef)]
     enum Enum<T, U> {
         Variant {
             #[pin]
@@ -458,21 +457,21 @@
 #[rustversion::since(1.36)] // https://github.com/rust-lang/rust/pull/61207
 #[test]
 fn lifetime_project_elided() {
-    #[pin_project(Replace)]
+    #[pin_project(project_replace)]
     struct Struct1<T, U> {
         #[pin]
         pinned: T,
         unpinned: U,
     }
 
-    #[pin_project(Replace)]
+    #[pin_project(project_replace)]
     struct Struct2<'a, T, U> {
         #[pin]
         pinned: &'a mut T,
         unpinned: U,
     }
 
-    #[pin_project(Replace, project = EnumProj, project_ref = EnumProjRef)]
+    #[pin_project(project_replace, project = EnumProj, project_ref = EnumProjRef)]
     enum Enum<T, U> {
         Variant {
             #[pin]
@@ -516,7 +515,7 @@
 mod visibility {
     use pin_project::pin_project;
 
-    #[pin_project(Replace)]
+    #[pin_project(project_replace)]
     pub(crate) struct A {
         pub b: u8,
     }
@@ -534,7 +533,7 @@
 
 #[test]
 fn trivial_bounds() {
-    #[pin_project(Replace)]
+    #[pin_project(project_replace)]
     pub struct NoGenerics {
         #[pin]
         field: PhantomPinned,
@@ -709,34 +708,102 @@
 }
 
 #[test]
-fn self_in_where_clause() {
-    pub trait Trait1 {}
-
-    #[pin_project(Replace)]
-    pub struct Struct1<T>
-    where
-        Self: Trait1,
-    {
-        x: T,
+fn parse_self() {
+    macro_rules! mac {
+        ($($tt:tt)*) => {
+            $($tt)*
+        };
     }
 
-    impl<T> Trait1 for Struct1<T> {}
-
-    pub trait Trait2 {
+    pub trait Trait {
         type Assoc;
     }
 
-    #[pin_project(Replace)]
-    pub struct Struct2<T>
+    #[pin_project(project_replace)]
+    pub struct Generics<T: Trait<Assoc = Self>>
     where
-        Self: Trait2<Assoc = Struct1<T>>,
-        <Self as Trait2>::Assoc: Trait1,
+        Self: Trait<Assoc = Self>,
+        <Self as Trait>::Assoc: Sized,
+        mac!(Self): Trait<Assoc = mac!(Self)>,
     {
-        x: T,
+        _f: T,
     }
 
-    impl<T> Trait2 for Struct2<T> {
-        type Assoc = Struct1<T>;
+    impl<T: Trait<Assoc = Self>> Trait for Generics<T> {
+        type Assoc = Self;
+    }
+
+    #[pin_project(project_replace)]
+    pub struct Struct {
+        _f1: Box<Self>,
+        _f2: Box<<Self as Trait>::Assoc>,
+        _f3: Box<mac!(Self)>,
+        _f4: [(); Self::ASSOC],
+        _f5: [(); Self::assoc()],
+        _f6: [(); mac!(Self::assoc())],
+    }
+
+    impl Struct {
+        const ASSOC: usize = 1;
+        const fn assoc() -> usize {
+            0
+        }
+    }
+
+    impl Trait for Struct {
+        type Assoc = Self;
+    }
+
+    #[pin_project(project_replace)]
+    struct Tuple(
+        Box<Self>,
+        Box<<Self as Trait>::Assoc>,
+        Box<mac!(Self)>,
+        [(); Self::ASSOC],
+        [(); Self::assoc()],
+        [(); mac!(Self::assoc())],
+    );
+
+    impl Tuple {
+        const ASSOC: usize = 1;
+        const fn assoc() -> usize {
+            0
+        }
+    }
+
+    impl Trait for Tuple {
+        type Assoc = Self;
+    }
+
+    #[pin_project(project_replace)]
+    enum Enum {
+        Struct {
+            _f1: Box<Self>,
+            _f2: Box<<Self as Trait>::Assoc>,
+            _f3: Box<mac!(Self)>,
+            _f4: [(); Self::ASSOC],
+            _f5: [(); Self::assoc()],
+            _f6: [(); mac!(Self::assoc())],
+        },
+        Tuple(
+            Box<Self>,
+            Box<<Self as Trait>::Assoc>,
+            Box<mac!(Self)>,
+            [(); Self::ASSOC],
+            [(); Self::assoc()],
+            [(); mac!(Self::assoc())],
+        ),
+    }
+
+    impl Enum {
+        const ASSOC: usize = 1;
+        const fn assoc() -> usize {
+            0
+        }
+    }
+
+    impl Trait for Enum {
+        type Assoc = Self;
     }
 }
 
@@ -752,7 +819,7 @@
         type Y = Option<T>;
     }
 
-    #[pin_project(Replace)]
+    #[pin_project(project_replace)]
     struct Foo<A, B> {
         _x: <Example<A> as Bar<B>>::Y,
     }
@@ -760,11 +827,12 @@
 
 // https://github.com/rust-lang/rust/issues/47949
 // https://github.com/taiki-e/pin-project/pull/194#discussion_r419098111
+#[allow(clippy::many_single_char_names)]
 #[test]
 fn project_replace_panic() {
     use std::panic;
 
-    #[pin_project(Replace)]
+    #[pin_project(project_replace)]
     struct S<T, U> {
         #[pin]
         pinned: T,
@@ -786,7 +854,8 @@
         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.
+        // Previous `x.pinned` was dropped and panicked when `project_replace` is
+        // called, so this is unreachable.
         unreachable!();
     }));
     assert!(res.is_err());
@@ -801,7 +870,8 @@
         {
             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,
+            // `_y` (previous `x.unpinned`) live to the end of this scope, so
+            // this is not unreachable.
             // unreachable!();
         }
         unreachable!();
diff --git a/tests/pinned_drop.rs b/tests/pinned_drop.rs
index b0677e2..e257758 100644
--- a/tests/pinned_drop.rs
+++ b/tests/pinned_drop.rs
@@ -1,5 +1,4 @@
 #![warn(rust_2018_idioms, single_use_lifetimes)]
-#![allow(dead_code)]
 
 use pin_project::{pin_project, pinned_drop};
 use std::pin::Pin;
@@ -26,66 +25,61 @@
 }
 
 #[test]
-fn mut_self_argument() {
+fn self_argument_in_macro() {
+    use pin_project::{pin_project, pinned_drop};
+    use std::pin::Pin;
+
     #[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,
+        x: (),
     }
 
     #[pinned_drop]
     impl PinnedDrop for Struct {
         fn drop(self: Pin<&mut Self>) {
-            let _: Vec<_> = vec![self.data];
+            let _: Vec<_> = vec![self.x];
         }
     }
 }
 
 #[test]
 fn self_in_macro_containing_fn() {
-    #[pin_project(PinnedDrop)]
-    pub struct Struct {
-        data: usize,
-    }
+    use pin_project::{pin_project, pinned_drop};
+    use std::pin::Pin;
 
-    macro_rules! emit {
+    macro_rules! mac {
         ($($tt:tt)*) => {
             $($tt)*
         };
     }
 
+    #[pin_project(PinnedDrop)]
+    pub struct Struct {
+        _x: (),
+    }
+
     #[pinned_drop]
     impl PinnedDrop for Struct {
         fn drop(self: Pin<&mut Self>) {
-            let _ = emit!({
+            let _ = mac!({
                 impl Struct {
-                    pub fn f(self) {}
+                    pub fn _f(self) -> Self {
+                        self
+                    }
                 }
             });
-            let _ = self.data;
         }
     }
 }
 
 #[test]
 fn self_call() {
+    use pin_project::{pin_project, pinned_drop};
+    use std::pin::Pin;
+
     #[pin_project(PinnedDrop)]
-    pub struct Struct {
-        data: usize,
+    pub struct Struct<T> {
+        _x: T,
     }
 
     trait Trait {
@@ -96,10 +90,10 @@
         fn assoc_fn(_this: Pin<&mut Self>) {}
     }
 
-    impl Trait for Struct {}
+    impl<T> Trait for Struct<T> {}
 
     #[pinned_drop]
-    impl PinnedDrop for Struct {
+    impl<T> PinnedDrop for Struct<T> {
         fn drop(mut self: Pin<&mut Self>) {
             self.self_ref();
             self.as_ref().self_pin_ref();
@@ -112,53 +106,13 @@
 }
 
 #[test]
-fn self_expr() {
+fn self_struct() {
+    use pin_project::{pin_project, pinned_drop};
+    use std::pin::Pin;
+
     #[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,
+        pub x: (),
     }
 
     #[pinned_drop]
@@ -166,6 +120,10 @@
         #[allow(irrefutable_let_patterns)]
         #[allow(clippy::match_single_binding)]
         fn drop(mut self: Pin<&mut Self>) {
+            // expr
+            let _: Self = Self { x: () };
+
+            // pat
             match *self {
                 Self { x: _ } => {}
             }
@@ -175,12 +133,16 @@
     }
 
     #[pin_project(PinnedDrop)]
-    pub struct TupleStruct(usize);
+    pub struct TupleStruct(());
 
     #[pinned_drop]
     impl PinnedDrop for TupleStruct {
         #[allow(irrefutable_let_patterns)]
         fn drop(mut self: Pin<&mut Self>) {
+            // expr
+            let _: Self = Self(());
+
+            // pat
             match *self {
                 Self(_) => {}
             }
@@ -190,24 +152,32 @@
     }
 }
 
-#[rustversion::since(1.37)]
+#[rustversion::since(1.37)] // type_alias_enum_variants requires Rust 1.37
 #[test]
-fn self_pat_enum() {
+fn self_enum() {
+    use pin_project::{pin_project, pinned_drop};
+    use std::pin::Pin;
+
     #[pin_project(PinnedDrop)]
     pub enum Enum {
-        StructVariant { x: usize },
-        TupleVariant(usize),
+        Struct { x: () },
+        Tuple(()),
     }
 
     #[pinned_drop]
     impl PinnedDrop for Enum {
         fn drop(mut self: Pin<&mut Self>) {
+            // expr
+            let _: Self = Self::Struct { x: () };
+            let _: Self = Self::Tuple(());
+
+            // pat
             match *self {
-                Self::StructVariant { x: _ } => {}
-                Self::TupleVariant(_) => {}
+                Self::Struct { x: _ } => {}
+                Self::Tuple(_) => {}
             }
-            if let Self::StructVariant { x: _ } = *self {}
-            if let Self::TupleVariant(_) = *self {}
+            if let Self::Struct { x: _ } = *self {}
+            if let Self::Tuple(_) = *self {}
         }
     }
 }
@@ -216,20 +186,108 @@
 #[rustversion::since(1.40)] // https://github.com/rust-lang/rust/pull/64690
 #[test]
 fn self_in_macro_def() {
+    use pin_project::{pin_project, pinned_drop};
+    use std::pin::Pin;
+
     #[pin_project(PinnedDrop)]
     pub struct Struct {
-        x: usize,
+        _x: (),
     }
 
     #[pinned_drop]
     impl PinnedDrop for Struct {
         fn drop(self: Pin<&mut Self>) {
-            macro_rules! t {
+            macro_rules! mac {
                 () => {{
                     let _ = self;
                 }};
             }
-            t!();
+            mac!();
         }
     }
 }
+
+#[test]
+fn self_inside_macro() {
+    use pin_project::{pin_project, pinned_drop};
+    use std::pin::Pin;
+
+    macro_rules! mac {
+        ($($tt:tt)*) => {
+            $($tt)*
+        };
+    }
+
+    #[pin_project(PinnedDrop)]
+    pub struct Struct<T: Send>
+    where
+        mac!(Self): Send,
+    {
+        _x: T,
+    }
+
+    impl<T: Send> Struct<T> {
+        const ASSOCIATED1: &'static str = "1";
+        fn associated1() {}
+    }
+
+    trait Trait {
+        type Associated2;
+        const ASSOCIATED2: &'static str;
+        fn associated2();
+    }
+
+    impl<T: Send> Trait for Struct<T> {
+        type Associated2 = ();
+        const ASSOCIATED2: &'static str = "2";
+        fn associated2() {}
+    }
+
+    #[pinned_drop]
+    impl<T: Send> PinnedDrop for Struct<T>
+    where
+        mac!(Self): Send,
+    {
+        #[allow(path_statements)]
+        #[allow(clippy::no_effect)]
+        fn drop(self: Pin<&mut Self>) {
+            // inherent items
+            mac!(Self::ASSOCIATED1;);
+            mac!(<Self>::ASSOCIATED1;);
+            mac!(Self::associated1(););
+            mac!(<Self>::associated1(););
+
+            // trait items
+            mac!(let _: <Self as Trait>::Associated2;);
+            mac!(Self::ASSOCIATED2;);
+            mac!(<Self>::ASSOCIATED2;);
+            mac!(<Self as Trait>::ASSOCIATED2;);
+            mac!(Self::associated2(););
+            mac!(<Self>::associated2(););
+            mac!(<Self as Trait>::associated2(););
+        }
+    }
+}
+
+#[test]
+fn inside_macro() {
+    use pin_project::{pin_project, pinned_drop};
+    use std::pin::Pin;
+
+    #[pin_project(PinnedDrop)]
+    struct Struct(());
+
+    macro_rules! mac {
+        ($expr:expr) => {
+            #[pinned_drop]
+            impl PinnedDrop for Struct {
+                #[allow(clippy::no_effect)]
+                fn drop(self: Pin<&mut Self>) {
+                    $expr;
+                }
+            }
+        };
+    }
+
+    mac!(1);
+}
diff --git a/tests/project.rs b/tests/project.rs
index a0f8b07..78a9261 100644
--- a/tests/project.rs
+++ b/tests/project.rs
@@ -1,5 +1,6 @@
 #![warn(rust_2018_idioms, single_use_lifetimes)]
 #![allow(dead_code)]
+#![allow(deprecated)]
 
 // Ceurrently, `#[attr] if true {}` doesn't even *parse* on MSRV,
 // which means that it will error even behind a `#[rustversion::since(..)]`
@@ -160,8 +161,8 @@
 
 mod project_use_1 {
     use crate::A;
-    use core::pin::Pin;
     use pin_project::project;
+    use std::pin::Pin;
 
     #[project]
     use crate::A;
@@ -242,7 +243,7 @@
 #[project]
 #[test]
 fn combine() {
-    #[pin_project(Replace)]
+    #[pin_project(project_replace)]
     enum Enum<A> {
         V1(#[pin] A),
         V2,
@@ -272,7 +273,7 @@
 #[project_replace]
 #[test]
 fn combine_compat() {
-    #[pin_project(Replace)]
+    #[pin_project(project_replace)]
     enum Enum<A> {
         V1(#[pin] A),
         V2,
diff --git a/tests/project_if_attr.rs.in b/tests/project_if_attr.rs.in
index a8ceeac..7bc236d 100644
--- a/tests/project_if_attr.rs.in
+++ b/tests/project_if_attr.rs.in
@@ -6,8 +6,9 @@
         Variant1(#[pin] A),
         Variant2(u8),
         Variant3 {
-            #[pin] field: B
-        }
+            #[pin]
+            field: B,
+        },
     }
 
     let mut x: Foo<bool, f32> = Foo::Variant1(true);
diff --git a/tests/project_ref.rs b/tests/project_ref.rs
index e38ef83..0e8ebd9 100644
--- a/tests/project_ref.rs
+++ b/tests/project_ref.rs
@@ -1,5 +1,6 @@
 #![warn(rust_2018_idioms, single_use_lifetimes)]
 #![allow(dead_code)]
+#![allow(deprecated)]
 
 use pin_project::{pin_project, project_ref};
 use std::pin::Pin;
@@ -149,7 +150,7 @@
 #[project_ref]
 #[test]
 fn combine() {
-    #[pin_project(Replace)]
+    #[pin_project(project_replace)]
     enum Enum<A> {
         V1(#[pin] A),
         V2,
diff --git a/tests/project_replace.rs b/tests/project_replace.rs
index 9c8a5ab..a97e3af 100644
--- a/tests/project_replace.rs
+++ b/tests/project_replace.rs
@@ -1,5 +1,6 @@
 #![warn(rust_2018_idioms, single_use_lifetimes)]
 #![allow(dead_code)]
+#![allow(deprecated)]
 
 use pin_project::{pin_project, project_replace};
 use std::{marker::PhantomData, pin::Pin};
@@ -7,7 +8,7 @@
 #[project_replace] // Nightly does not need a dummy attribute to the function.
 #[test]
 fn project_replace_stmt_expr() {
-    #[pin_project(Replace)]
+    #[pin_project(project_replace)]
     struct Struct<T, U> {
         #[pin]
         field1: T,
@@ -27,7 +28,7 @@
 
     // tuple struct
 
-    #[pin_project(Replace)]
+    #[pin_project(project_replace)]
     struct TupleStruct<T, U>(#[pin] T, U);
 
     let mut s = TupleStruct(1, 2);
@@ -39,7 +40,7 @@
     let y: i32 = y;
     assert_eq!(y, 2);
 
-    #[pin_project(Replace)]
+    #[pin_project(project_replace)]
     enum Enum<A, B, C, D> {
         Variant1(#[pin] A, B),
         Variant2 {
@@ -73,7 +74,7 @@
 #[project_replace]
 #[test]
 fn combine() {
-    #[pin_project(Replace)]
+    #[pin_project(project_replace)]
     enum Enum<A> {
         V1(#[pin] A),
         V2,
diff --git a/tests/repr_packed.rs b/tests/repr_packed.rs
index ca56959..73fc45c 100644
--- a/tests/repr_packed.rs
+++ b/tests/repr_packed.rs
@@ -1,5 +1,4 @@
 #![warn(rust_2018_idioms, single_use_lifetimes)]
-#![allow(dead_code)]
 #![deny(safe_packed_borrows)]
 
 use std::cell::Cell;
diff --git a/tests/ui/cfg/cfg_attr-unpin.stderr b/tests/ui/cfg/cfg_attr-unpin.stderr
index ce31c24..45789ff 100644
--- a/tests/ui/cfg/cfg_attr-unpin.stderr
+++ b/tests/ui/cfg/cfg_attr-unpin.stderr
@@ -16,7 +16,7 @@
    |                ----- 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`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ within `_::__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 it appears within the type `_::__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/proper_unpin.stderr b/tests/ui/cfg/proper_unpin.stderr
index 407d900..f1fff34 100644
--- a/tests/ui/cfg/proper_unpin.stderr
+++ b/tests/ui/cfg/proper_unpin.stderr
@@ -5,7 +5,7 @@
    |                ----- 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`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ within `_::__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 it appears within the type `_::__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/not_unpin/conflict-unpin.stderr b/tests/ui/not_unpin/conflict-unpin.stderr
index 7407bdf..e90a574 100644
--- a/tests/ui/not_unpin/conflict-unpin.stderr
+++ b/tests/ui/not_unpin/conflict-unpin.stderr
@@ -1,26 +1,26 @@
 error[E0119]: conflicting implementations of trait `std::marker::Unpin` for type `Foo<_, _>`:
-  --> $DIR/conflict-unpin.rs:3:16
+  --> $DIR/conflict-unpin.rs:3:15
    |
 3  | #[pin_project(!Unpin)] //~ ERROR E0119
-   |                ^^^^^ conflicting implementation for `Foo<_, _>`
+   |               ^^^^^^ 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
+  --> $DIR/conflict-unpin.rs:12:15
    |
 12 | #[pin_project(!Unpin)] //~ ERROR E0119
-   |                ^^^^^ conflicting implementation for `Bar<_, _>`
+   |               ^^^^^^ 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
+  --> $DIR/conflict-unpin.rs:21:15
    |
 21 | #[pin_project(!Unpin)] //~ ERROR E0119
-   |                ^^^^^ conflicting implementation for `Baz<_, _>`
+   |               ^^^^^^ conflicting implementation for `Baz<_, _>`
 ...
 28 | impl<T: Unpin, U: Unpin> Unpin for Baz<T, U> {}
    | -------------------------------------------- first implementation here
diff --git a/tests/ui/pin_project/add-pin-attr-to-struct.rs b/tests/ui/pin_project/add-attr-to-struct.rs
similarity index 100%
rename from tests/ui/pin_project/add-pin-attr-to-struct.rs
rename to tests/ui/pin_project/add-attr-to-struct.rs
diff --git a/tests/ui/pin_project/add-pin-attr-to-struct.stderr b/tests/ui/pin_project/add-attr-to-struct.stderr
similarity index 87%
rename from tests/ui/pin_project/add-pin-attr-to-struct.stderr
rename to tests/ui/pin_project/add-attr-to-struct.stderr
index c2adaea..27656d6 100644
--- a/tests/ui/pin_project/add-pin-attr-to-struct.stderr
+++ b/tests/ui/pin_project/add-attr-to-struct.stderr
@@ -1,5 +1,5 @@
 error: duplicate #[pin] attribute
- --> $DIR/add-pin-attr-to-struct.rs:6:1
+ --> $DIR/add-attr-to-struct.rs:6:1
   |
 6 | #[add_pin_attr(struct)] //~ ERROR duplicate #[pin] attribute
   | ^^^^^^^^^^^^^^^^^^^^^^^
@@ -7,7 +7,7 @@
   = 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
+  --> $DIR/add-attr-to-struct.rs:12:1
    |
 12 | #[add_pin_attr(struct)] //~ ERROR #[pin] attribute may only be used on fields of structs or variants
    | ^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/pin_project/add-pinned-field.stderr b/tests/ui/pin_project/add-pinned-field.stderr
index db07a74..d6a1dcd 100644
--- a/tests/ui/pin_project/add-pinned-field.stderr
+++ b/tests/ui/pin_project/add-pinned-field.stderr
@@ -5,9 +5,9 @@
    |                ----- 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`
+   |     ^^^^^^^^^^^^^^^ within `_::__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 it appears within the type `_::__Foo<'_>`
    = note: required because of the requirements on the impl of `std::marker::Unpin` for `Foo`
 
 error[E0277]: `std::marker::PhantomPinned` cannot be unpinned
@@ -17,7 +17,7 @@
    |                ----- 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`
+   |     ^^^^^^^^^^^^^^^ within `_::__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 it appears within the type `_::__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.stderr b/tests/ui/pin_project/conflict-drop.stderr
index f97d060..d5ca7b3 100644
--- a/tests/ui/pin_project/conflict-drop.stderr
+++ b/tests/ui/pin_project/conflict-drop.stderr
@@ -1,4 +1,4 @@
-error[E0119]: conflicting implementations of trait `__SCOPE_Foo::FooMustNotImplDrop` for type `Foo<_, _>`:
+error[E0119]: conflicting implementations of trait `_::FooMustNotImplDrop` for type `Foo<_, _>`:
  --> $DIR/conflict-drop.rs:4:1
   |
 4 | #[pin_project] //~ ERROR E0119
diff --git a/tests/ui/pin_project/conflict-naming.rs b/tests/ui/pin_project/conflict-naming.rs
deleted file mode 100644
index 1cb50b4..0000000
--- a/tests/ui/pin_project/conflict-naming.rs
+++ /dev/null
@@ -1,6 +0,0 @@
-use pin_project::pin_project;
-
-#[pin_project(project = A, project_ref = A)] //~ ERROR E0428,E0308
-struct Struct(#[pin] ());
-
-fn main() {}
diff --git a/tests/ui/pin_project/conflict-naming.stderr b/tests/ui/pin_project/conflict-naming.stderr
deleted file mode 100644
index bbac1eb..0000000
--- a/tests/ui/pin_project/conflict-naming.stderr
+++ /dev/null
@@ -1,21 +0,0 @@
-error[E0428]: the name `A` is defined multiple times
- --> $DIR/conflict-naming.rs:3:1
-  |
-3 | #[pin_project(project = A, project_ref = A)] //~ ERROR E0428,E0308
-  | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  | |
-  | `A` redefined here
-  | previous definition of the type `A` here
-  |
-  = note: `A` must be defined only once in the type namespace of this module
-  = note: this error originates in a derive macro (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error[E0308]: mismatched types
- --> $DIR/conflict-naming.rs:3:1
-  |
-3 | #[pin_project(project = A, project_ref = A)] //~ ERROR E0428,E0308
-  | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ types differ in mutability
-  |
-  = note: expected mutable reference `&mut ()`
-                     found reference `&()`
-  = 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
index d7911df..9c51bec 100644
--- a/tests/ui/pin_project/invalid.rs
+++ b/tests/ui/pin_project/invalid.rs
@@ -100,6 +100,9 @@
     #[pin_project()] // Ok
     struct Unexpected4(#[pin] ());
 
+    #[pin_project(PinnedDrop PinnedDrop)] //~ ERROR expected `,`
+    struct Unexpected5(#[pin] ());
+
     #[pin_project(PinnedDrop, PinnedDrop)] //~ ERROR duplicate `PinnedDrop` argument
     struct DuplicatePinnedDrop(#[pin] ());
 
@@ -121,13 +124,22 @@
     #[pin_project(project = A, project = B)] //~ ERROR duplicate `project` argument
     struct DuplicateProject(#[pin] ());
 
+    #[pin_project(project = A, project_ref = A, project = B)] //~ ERROR duplicate `project` argument
+    struct DuplicateProject2(#[pin] ());
+
     #[pin_project(project_ref = A, project_ref = B)] //~ ERROR duplicate `project_ref` argument
     struct DuplicateProjectRef(#[pin] ());
 
     #[pin_project(project_replace = A, project_replace = B)] //~ ERROR duplicate `project_replace` argument
-    struct DuplicateProjectReplace(#[pin] ());
+    struct DuplicateProjectReplace1(#[pin] ());
 
-    #[pin_project(project_replace = A)] //~ ERROR `project_replace` argument can only be used together with `Replace` argument
+    #[pin_project(project_replace, project_replace = B)] //~ ERROR duplicate `project_replace` argument
+    struct DuplicateProjectReplace2(#[pin] ());
+
+    #[pin_project(project_replace = A, project_replace)] //~ ERROR duplicate `project_replace` argument
+    struct DuplicateProjectReplace3(#[pin] ());
+
+    #[pin_project(project_replace = A)] // Ok
     struct ProjectReplaceWithoutReplace(#[pin] ());
 
     #[pin_project(PinnedDrop, Replace)] //~ ERROR arguments `PinnedDrop` and `Replace` are mutually exclusive
@@ -136,35 +148,69 @@
     #[pin_project(Replace, UnsafeUnpin, PinnedDrop)] //~ ERROR arguments `PinnedDrop` and `Replace` are mutually exclusive
     struct PinnedDropWithReplace2(#[pin] ());
 
+    #[pin_project(PinnedDrop, project_replace)] //~ ERROR arguments `PinnedDrop` and `project_replace` are mutually exclusive
+    struct PinnedDropWithProjectReplace1(#[pin] ());
+
+    #[pin_project(project_replace, UnsafeUnpin, PinnedDrop)] //~ ERROR arguments `PinnedDrop` and `project_replace` are mutually exclusive
+    struct PinnedDropWithProjectReplace2(#[pin] ());
+
+    #[pin_project(project_replace, Replace)] // Ok
+    struct ProjectReplaceWithReplace1(#[pin] ());
+
+    #[pin_project(project_replace = B, Replace)] // Ok
+    struct ProjectReplaceWithReplace2(#[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`
+    #[pin_project(!)] //~ ERROR expected `!Unpin`, found `!`
     struct NotUnpin1(#[pin] ());
 
     #[pin_project(Unpin)] //~ ERROR unexpected argument
     struct NotUnpin2(#[pin] ());
 
-    #[pin_project(project)] //~ ERROR expected `=`
+    #[pin_project(project)] //~ ERROR expected `project = <identifier>`, found `project`
     struct Project1(#[pin] ());
 
-    #[pin_project(project = )] //~ ERROR unexpected end of input, expected identifier
+    #[pin_project(project = )] //~ ERROR expected `project = <identifier>`, found `project =`
     struct Project2(#[pin] ());
 
-    #[pin_project(project_ref)] //~ ERROR expected `=`
+    #[pin_project(project = !)] //~ ERROR expected identifier
+    struct Project3(#[pin] ());
+
+    #[pin_project(project_ref)] //~ ERROR expected `project_ref = <identifier>`, found `project_ref`
     struct ProjectRef1(#[pin] ());
 
-    #[pin_project(project_ref = )] //~ ERROR unexpected end of input, expected identifier
+    #[pin_project(project_ref = )] //~ ERROR expected `project_ref = <identifier>`, found `project_ref =`
     struct ProjectRef2(#[pin] ());
 
-    #[pin_project(project_replace)] //~ ERROR expected `=`
+    #[pin_project(project_ref = !)] //~ ERROR expected identifier
+    struct ProjectRef3(#[pin] ());
+
+    #[pin_project(project_replace)] // Ok
     struct ProjectReplace1(#[pin] ());
 
-    #[pin_project(project_replace = )] //~ ERROR unexpected end of input, expected identifier
+    #[pin_project(project_replace = )] //~ ERROR expected `project_replace = <identifier>`, found `project_replace =`
     struct ProjectReplace2(#[pin] ());
+
+    #[pin_project(project_replace = !)] //~ ERROR expected identifier
+    struct ProjectReplace3(#[pin] ());
+}
+
+mod pin_project_conflict_naming {
+    use pin_project::pin_project;
+
+    #[pin_project(project = A, project_ref = A)] //~ ERROR name `A` is already specified by `project` argument
+    struct ProjAndProjRef(#[pin] ());
+
+    #[pin_project(project = A, project_replace = A)] //~ ERROR name `A` is already specified by `project` argument
+    struct ProjAndProjOwn(#[pin] ());
+
+    #[pin_project(project_ref = A, project_replace = A)] //~ ERROR name `A` is already specified by `project_ref` argument
+    struct ProjRefAndProjOwn(#[pin] ());
 }
 
 mod pin_project_attribute {
diff --git a/tests/ui/pin_project/invalid.stderr b/tests/ui/pin_project/invalid.stderr
index 82026aa..3c6af57 100644
--- a/tests/ui/pin_project/invalid.stderr
+++ b/tests/ui/pin_project/invalid.stderr
@@ -82,219 +82,265 @@
 97 |     #[pin_project(,UnsafeUnpin)] //~ ERROR expected identifier
    |                   ^
 
-error: duplicate `PinnedDrop` argument
-   --> $DIR/invalid.rs:103:31
+error: expected `,`
+   --> $DIR/invalid.rs:103:30
     |
-103 |     #[pin_project(PinnedDrop, PinnedDrop)] //~ ERROR duplicate `PinnedDrop` argument
+103 |     #[pin_project(PinnedDrop PinnedDrop)] //~ ERROR expected `,`
+    |                              ^^^^^^^^^^
+
+error: duplicate `PinnedDrop` argument
+   --> $DIR/invalid.rs:106:31
+    |
+106 |     #[pin_project(PinnedDrop, PinnedDrop)] //~ ERROR duplicate `PinnedDrop` argument
     |                               ^^^^^^^^^^
 
 error: duplicate `Replace` argument
-   --> $DIR/invalid.rs:106:28
+   --> $DIR/invalid.rs:109:28
     |
-106 |     #[pin_project(Replace, Replace)] //~ ERROR duplicate `Replace` argument
+109 |     #[pin_project(Replace, Replace)] //~ ERROR duplicate `Replace` argument
     |                            ^^^^^^^
 
 error: duplicate `UnsafeUnpin` argument
-   --> $DIR/invalid.rs:109:32
+   --> $DIR/invalid.rs:112:32
     |
-109 |     #[pin_project(UnsafeUnpin, UnsafeUnpin)] //~ ERROR duplicate `UnsafeUnpin` argument
+112 |     #[pin_project(UnsafeUnpin, UnsafeUnpin)] //~ ERROR duplicate `UnsafeUnpin` argument
     |                                ^^^^^^^^^^^
 
 error: duplicate `!Unpin` argument
-   --> $DIR/invalid.rs:112:27
+   --> $DIR/invalid.rs:115:27
     |
-112 |     #[pin_project(!Unpin, !Unpin)] //~ ERROR duplicate `!Unpin` argument
+115 |     #[pin_project(!Unpin, !Unpin)] //~ ERROR duplicate `!Unpin` argument
     |                           ^^^^^^
 
 error: duplicate `UnsafeUnpin` argument
-   --> $DIR/invalid.rs:115:44
+   --> $DIR/invalid.rs:118:44
     |
-115 |     #[pin_project(PinnedDrop, UnsafeUnpin, UnsafeUnpin)] //~ ERROR duplicate `UnsafeUnpin` argument
+118 |     #[pin_project(PinnedDrop, UnsafeUnpin, UnsafeUnpin)] //~ ERROR duplicate `UnsafeUnpin` argument
     |                                            ^^^^^^^^^^^
 
 error: duplicate `PinnedDrop` argument
-   --> $DIR/invalid.rs:118:44
+   --> $DIR/invalid.rs:121:44
     |
-118 |     #[pin_project(PinnedDrop, UnsafeUnpin, PinnedDrop, UnsafeUnpin)] //~ ERROR duplicate `PinnedDrop` argument
+121 |     #[pin_project(PinnedDrop, UnsafeUnpin, PinnedDrop, UnsafeUnpin)] //~ ERROR duplicate `PinnedDrop` argument
     |                                            ^^^^^^^^^^
 
 error: duplicate `project` argument
-   --> $DIR/invalid.rs:121:32
+   --> $DIR/invalid.rs:124:32
     |
-121 |     #[pin_project(project = A, project = B)] //~ ERROR duplicate `project` argument
-    |                                ^^^^^^^
+124 |     #[pin_project(project = A, project = B)] //~ ERROR duplicate `project` argument
+    |                                ^^^^^^^^^^^
+
+error: duplicate `project` argument
+   --> $DIR/invalid.rs:127:49
+    |
+127 |     #[pin_project(project = A, project_ref = A, project = B)] //~ ERROR duplicate `project` argument
+    |                                                 ^^^^^^^^^^^
 
 error: duplicate `project_ref` argument
-   --> $DIR/invalid.rs:124:36
+   --> $DIR/invalid.rs:130:36
     |
-124 |     #[pin_project(project_ref = A, project_ref = B)] //~ ERROR duplicate `project_ref` argument
-    |                                    ^^^^^^^^^^^
+130 |     #[pin_project(project_ref = A, project_ref = B)] //~ ERROR duplicate `project_ref` argument
+    |                                    ^^^^^^^^^^^^^^^
 
 error: duplicate `project_replace` argument
-   --> $DIR/invalid.rs:127:40
+   --> $DIR/invalid.rs:133:40
     |
-127 |     #[pin_project(project_replace = A, project_replace = B)] //~ ERROR duplicate `project_replace` argument
+133 |     #[pin_project(project_replace = A, project_replace = B)] //~ ERROR duplicate `project_replace` argument
+    |                                        ^^^^^^^^^^^^^^^^^^^
+
+error: duplicate `project_replace` argument
+   --> $DIR/invalid.rs:136:36
+    |
+136 |     #[pin_project(project_replace, project_replace = B)] //~ ERROR duplicate `project_replace` argument
+    |                                    ^^^^^^^^^^^^^^^^^^^
+
+error: duplicate `project_replace` argument
+   --> $DIR/invalid.rs:139:40
+    |
+139 |     #[pin_project(project_replace = A, project_replace)] //~ ERROR duplicate `project_replace` argument
     |                                        ^^^^^^^^^^^^^^^
 
-error: `project_replace` argument can only be used together with `Replace` argument
-   --> $DIR/invalid.rs:130:19
-    |
-130 |     #[pin_project(project_replace = A)] //~ ERROR `project_replace` argument can only be used together with `Replace` argument
-    |                   ^^^^^^^^^^^^^^^
-
 error: arguments `PinnedDrop` and `Replace` are mutually exclusive
-   --> $DIR/invalid.rs:133:19
+   --> $DIR/invalid.rs:145:19
     |
-133 |     #[pin_project(PinnedDrop, Replace)] //~ ERROR arguments `PinnedDrop` and `Replace` are mutually exclusive
+145 |     #[pin_project(PinnedDrop, Replace)] //~ ERROR arguments `PinnedDrop` and `Replace` are mutually exclusive
     |                   ^^^^^^^^^^
 
 error: arguments `PinnedDrop` and `Replace` are mutually exclusive
-   --> $DIR/invalid.rs:136:41
+   --> $DIR/invalid.rs:148:41
     |
-136 |     #[pin_project(Replace, UnsafeUnpin, PinnedDrop)] //~ ERROR arguments `PinnedDrop` and `Replace` are mutually exclusive
+148 |     #[pin_project(Replace, UnsafeUnpin, PinnedDrop)] //~ ERROR arguments `PinnedDrop` and `Replace` are mutually exclusive
     |                                         ^^^^^^^^^^
 
-error: arguments `UnsafeUnpin` and `!Unpin` are mutually exclusive
-   --> $DIR/invalid.rs:139:19
+error: arguments `PinnedDrop` and `project_replace` are mutually exclusive
+   --> $DIR/invalid.rs:151:19
     |
-139 |     #[pin_project(UnsafeUnpin, !Unpin)] //~ ERROR arguments `UnsafeUnpin` and `!Unpin` are mutually exclusive
+151 |     #[pin_project(PinnedDrop, project_replace)] //~ ERROR arguments `PinnedDrop` and `project_replace` are mutually exclusive
+    |                   ^^^^^^^^^^
+
+error: arguments `PinnedDrop` and `project_replace` are mutually exclusive
+   --> $DIR/invalid.rs:154:49
+    |
+154 |     #[pin_project(project_replace, UnsafeUnpin, PinnedDrop)] //~ ERROR arguments `PinnedDrop` and `project_replace` are mutually exclusive
+    |                                                 ^^^^^^^^^^
+
+error: arguments `UnsafeUnpin` and `!Unpin` are mutually exclusive
+   --> $DIR/invalid.rs:163:19
+    |
+163 |     #[pin_project(UnsafeUnpin, !Unpin)] //~ ERROR arguments `UnsafeUnpin` and `!Unpin` are mutually exclusive
     |                   ^^^^^^^^^^^
 
 error: arguments `UnsafeUnpin` and `!Unpin` are mutually exclusive
-   --> $DIR/invalid.rs:142:39
+   --> $DIR/invalid.rs:166:39
     |
-142 |     #[pin_project(!Unpin, PinnedDrop, UnsafeUnpin)] //~ ERROR arguments `UnsafeUnpin` and `!Unpin` are mutually exclusive
+166 |     #[pin_project(!Unpin, PinnedDrop, UnsafeUnpin)] //~ ERROR arguments `UnsafeUnpin` and `!Unpin` are mutually exclusive
     |                                       ^^^^^^^^^^^
 
-error: unexpected end of input, expected `Unpin`
-   --> $DIR/invalid.rs:145:5
+error: expected `!Unpin`, found `!`
+   --> $DIR/invalid.rs:169:19
     |
-145 |     #[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)
+169 |     #[pin_project(!)] //~ ERROR expected `!Unpin`, found `!`
+    |                   ^
 
 error: unexpected argument: Unpin
-   --> $DIR/invalid.rs:148:19
+   --> $DIR/invalid.rs:172:19
     |
-148 |     #[pin_project(Unpin)] //~ ERROR unexpected argument
+172 |     #[pin_project(Unpin)] //~ ERROR unexpected argument
     |                   ^^^^^
 
-error: expected `=`
-   --> $DIR/invalid.rs:151:5
+error: expected `project = <identifier>`, found `project`
+   --> $DIR/invalid.rs:175:19
     |
-151 |     #[pin_project(project)] //~ ERROR expected `=`
-    |     ^^^^^^^^^^^^^^^^^^^^^^^
-    |
-    = note: this error originates in an attribute macro (in Nightly builds, run with -Z macro-backtrace for more info)
+175 |     #[pin_project(project)] //~ ERROR expected `project = <identifier>`, found `project`
+    |                   ^^^^^^^
 
-error: unexpected end of input, expected identifier
-   --> $DIR/invalid.rs:154:5
+error: expected `project = <identifier>`, found `project =`
+   --> $DIR/invalid.rs:178:19
     |
-154 |     #[pin_project(project = )] //~ ERROR unexpected end of input, expected identifier
-    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
-    |
-    = note: this error originates in an attribute macro (in Nightly builds, run with -Z macro-backtrace for more info)
+178 |     #[pin_project(project = )] //~ ERROR expected `project = <identifier>`, found `project =`
+    |                   ^^^^^^^^^
 
-error: expected `=`
-   --> $DIR/invalid.rs:157:5
+error: expected identifier
+   --> $DIR/invalid.rs:181:29
     |
-157 |     #[pin_project(project_ref)] //~ ERROR expected `=`
-    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
-    |
-    = note: this error originates in an attribute macro (in Nightly builds, run with -Z macro-backtrace for more info)
+181 |     #[pin_project(project = !)] //~ ERROR expected identifier
+    |                             ^
 
-error: unexpected end of input, expected identifier
-   --> $DIR/invalid.rs:160:5
+error: expected `project_ref = <identifier>`, found `project_ref`
+   --> $DIR/invalid.rs:184:19
     |
-160 |     #[pin_project(project_ref = )] //~ ERROR unexpected end of input, expected identifier
-    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-    |
-    = note: this error originates in an attribute macro (in Nightly builds, run with -Z macro-backtrace for more info)
+184 |     #[pin_project(project_ref)] //~ ERROR expected `project_ref = <identifier>`, found `project_ref`
+    |                   ^^^^^^^^^^^
 
-error: expected `=`
-   --> $DIR/invalid.rs:163:5
+error: expected `project_ref = <identifier>`, found `project_ref =`
+   --> $DIR/invalid.rs:187:19
     |
-163 |     #[pin_project(project_replace)] //~ ERROR expected `=`
-    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-    |
-    = note: this error originates in an attribute macro (in Nightly builds, run with -Z macro-backtrace for more info)
+187 |     #[pin_project(project_ref = )] //~ ERROR expected `project_ref = <identifier>`, found `project_ref =`
+    |                   ^^^^^^^^^^^^^
 
-error: unexpected end of input, expected identifier
-   --> $DIR/invalid.rs:166:5
+error: expected identifier
+   --> $DIR/invalid.rs:190:33
     |
-166 |     #[pin_project(project_replace = )] //~ ERROR unexpected end of input, expected identifier
-    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+190 |     #[pin_project(project_ref = !)] //~ ERROR expected identifier
+    |                                 ^
+
+error: expected `project_replace = <identifier>`, found `project_replace =`
+   --> $DIR/invalid.rs:196:19
     |
-    = note: this error originates in an attribute macro (in Nightly builds, run with -Z macro-backtrace for more info)
+196 |     #[pin_project(project_replace = )] //~ ERROR expected `project_replace = <identifier>`, found `project_replace =`
+    |                   ^^^^^^^^^^^^^^^^^
+
+error: expected identifier
+   --> $DIR/invalid.rs:199:37
+    |
+199 |     #[pin_project(project_replace = !)] //~ ERROR expected identifier
+    |                                     ^
+
+error: name `A` is already specified by `project` argument
+   --> $DIR/invalid.rs:206:46
+    |
+206 |     #[pin_project(project = A, project_ref = A)] //~ ERROR name `A` is already specified by `project` argument
+    |                                              ^
+
+error: name `A` is already specified by `project` argument
+   --> $DIR/invalid.rs:209:50
+    |
+209 |     #[pin_project(project = A, project_replace = A)] //~ ERROR name `A` is already specified by `project` argument
+    |                                                  ^
+
+error: name `A` is already specified by `project_ref` argument
+   --> $DIR/invalid.rs:212:54
+    |
+212 |     #[pin_project(project_ref = A, project_replace = A)] //~ ERROR name `A` is already specified by `project_ref` argument
+    |                                                      ^
 
 error: duplicate #[pin_project] attribute
-   --> $DIR/invalid.rs:174:5
+   --> $DIR/invalid.rs:220:5
     |
-174 |     #[pin_project] //~ ERROR duplicate #[pin_project] attribute
+220 |     #[pin_project] //~ ERROR duplicate #[pin_project] attribute
     |     ^^^^^^^^^^^^^^
 
 error: #[pin_project] attribute may not be used on structs with zero fields
-   --> $DIR/invalid.rs:182:19
+   --> $DIR/invalid.rs:228:19
     |
-182 |     struct Struct {} //~ ERROR may not be used on structs with zero fields
+228 |     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:185:23
+   --> $DIR/invalid.rs:231:23
     |
-185 |     struct TupleStruct(); //~ ERROR may not be used on structs with zero fields
+231 |     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:188:12
+   --> $DIR/invalid.rs:234:12
     |
-188 |     struct UnitStruct; //~ ERROR may not be used on structs with zero fields
+234 |     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:191:20
+   --> $DIR/invalid.rs:237:20
     |
-191 |     enum EnumEmpty {} //~ ERROR may not be used on enums without variants
+237 |     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:195:13
+   --> $DIR/invalid.rs:241:13
     |
-195 |         V = 2, //~ ERROR may not be used on enums with discriminants
+241 |         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:200:9
+   --> $DIR/invalid.rs:246:9
     |
-200 | /         Unit, //~ ERROR may not be used on enums with zero fields
-201 | |         Tuple(),
-202 | |         Struct {},
+246 | /         Unit, //~ ERROR may not be used on enums with zero fields
+247 | |         Tuple(),
+248 | |         Struct {},
     | |__________________^
 
 error: #[pin_project] attribute may only be used on structs or enums
-   --> $DIR/invalid.rs:206:5
+   --> $DIR/invalid.rs:252:5
     |
-206 | /     union Union {
-207 | |         //~^ ERROR may only be used on structs or enums
-208 | |         f: (),
-209 | |     }
+252 | /     union Union {
+253 | |         //~^ ERROR may only be used on structs or enums
+254 | |         f: (),
+255 | |     }
     | |_____^
 
 error: #[pin_project] attribute may not be used on #[repr(packed)] types
-   --> $DIR/invalid.rs:217:12
+   --> $DIR/invalid.rs:263:12
     |
-217 |     #[repr(packed)]
+263 |     #[repr(packed)]
     |            ^^^^^^
 
 error: #[pin_project] attribute may not be used on #[repr(packed)] types
-   --> $DIR/invalid.rs:221:12
+   --> $DIR/invalid.rs:267:12
     |
-221 |     #[repr(packed)]
+267 |     #[repr(packed)]
     |            ^^^^^^
 
 error: #[pin_project] attribute may not be used on #[repr(packed)] types
-   --> $DIR/invalid.rs:225:12
+   --> $DIR/invalid.rs:271:12
     |
-225 |     #[repr(packed)]
+271 |     #[repr(packed)]
     |            ^^^^^^
diff --git a/tests/ui/pin_project/overlapping_unpin_struct.stderr b/tests/ui/pin_project/overlapping_unpin_struct.stderr
index d0fd4a9..96a9f51 100644
--- a/tests/ui/pin_project/overlapping_unpin_struct.stderr
+++ b/tests/ui/pin_project/overlapping_unpin_struct.stderr
@@ -5,7 +5,7 @@
    |                ----- 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`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 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 `__SCOPE_Foo::__Foo<'_, std::marker::PhantomPinned>`
+   = note: required because it appears within the type `_::__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/project_replace_unsized.rs b/tests/ui/pin_project/project_replace_unsized.rs
new file mode 100644
index 0000000..706a0c1
--- /dev/null
+++ b/tests/ui/pin_project/project_replace_unsized.rs
@@ -0,0 +1,11 @@
+use pin_project::pin_project;
+
+#[pin_project(project_replace)] //~ ERROR E0277
+struct Struct<T: ?Sized> {
+    x: T,
+}
+
+#[pin_project(project_replace)] //~ ERROR E0277
+struct TupleStruct<T: ?Sized>(T);
+
+fn main() {}
diff --git a/tests/ui/pin_project/project_replace_unsized.stderr b/tests/ui/pin_project/project_replace_unsized.stderr
new file mode 100644
index 0000000..c3a3be7
--- /dev/null
+++ b/tests/ui/pin_project/project_replace_unsized.stderr
@@ -0,0 +1,77 @@
+error[E0277]: the size for values of type `T` cannot be known at compilation time
+ --> $DIR/project_replace_unsized.rs:3:15
+  |
+3 | #[pin_project(project_replace)] //~ ERROR E0277
+  |               ^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
+4 | struct Struct<T: ?Sized> {
+  |               - this type parameter needs to be `std::marker::Sized`
+  |
+  = help: within `Struct<T>`, the trait `std::marker::Sized` is not implemented for `T`
+  = note: to learn more, visit <https://doc.rust-lang.org/book/ch19-04-advanced-types.html#dynamically-sized-types-and-the-sized-trait>
+  = note: required because it appears within the type `Struct<T>`
+  = note: all local variables must have a statically known size
+  = help: unsized locals are gated as an unstable feature
+
+error[E0277]: the size for values of type `T` cannot be known at compilation time
+   --> $DIR/project_replace_unsized.rs:5:5
+    |
+4   | struct Struct<T: ?Sized> {
+    |               - this type parameter needs to be `std::marker::Sized`
+5   |     x: T,
+    |     ^ doesn't have a size known at compile-time
+    |
+    = help: the trait `std::marker::Sized` is not implemented for `T`
+    = note: to learn more, visit <https://doc.rust-lang.org/book/ch19-04-advanced-types.html#dynamically-sized-types-and-the-sized-trait>
+
+error[E0277]: the size for values of type `T` cannot be known at compilation time
+ --> $DIR/project_replace_unsized.rs:3:1
+  |
+3 | #[pin_project(project_replace)] //~ ERROR E0277
+  | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
+4 | struct Struct<T: ?Sized> {
+  |               - this type parameter needs to be `std::marker::Sized`
+  |
+  = help: within `__StructProjectionOwned<T>`, the trait `std::marker::Sized` is not implemented for `T`
+  = note: to learn more, visit <https://doc.rust-lang.org/book/ch19-04-advanced-types.html#dynamically-sized-types-and-the-sized-trait>
+  = note: required because it appears within the type `__StructProjectionOwned<T>`
+  = note: structs must have a statically known size to be initialized
+  = note: this error originates in a derive macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0277]: the size for values of type `T` cannot be known at compilation time
+ --> $DIR/project_replace_unsized.rs:8:15
+  |
+8 | #[pin_project(project_replace)] //~ ERROR E0277
+  |               ^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
+9 | struct TupleStruct<T: ?Sized>(T);
+  |                    - this type parameter needs to be `std::marker::Sized`
+  |
+  = help: within `TupleStruct<T>`, the trait `std::marker::Sized` is not implemented for `T`
+  = note: to learn more, visit <https://doc.rust-lang.org/book/ch19-04-advanced-types.html#dynamically-sized-types-and-the-sized-trait>
+  = note: required because it appears within the type `TupleStruct<T>`
+  = note: all local variables must have a statically known size
+  = help: unsized locals are gated as an unstable feature
+
+error[E0277]: the size for values of type `T` cannot be known at compilation time
+   --> $DIR/project_replace_unsized.rs:8:1
+    |
+8   | #[pin_project(project_replace)] //~ ERROR E0277
+    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
+9   | struct TupleStruct<T: ?Sized>(T);
+    |                    - this type parameter needs to be `std::marker::Sized`
+    |
+    = help: the trait `std::marker::Sized` is not implemented for `T`
+    = note: to learn more, visit <https://doc.rust-lang.org/book/ch19-04-advanced-types.html#dynamically-sized-types-and-the-sized-trait>
+    = note: this error originates in a derive macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0277]: the size for values of type `T` cannot be known at compilation time
+ --> $DIR/project_replace_unsized.rs:9:8
+  |
+9 | struct TupleStruct<T: ?Sized>(T);
+  |        ^^^^^^^^^^^ - this type parameter needs to be `std::marker::Sized`
+  |        |
+  |        doesn't have a size known at compile-time
+  |
+  = help: the trait `std::marker::Sized` is not implemented for `T`
+  = note: to learn more, visit <https://doc.rust-lang.org/book/ch19-04-advanced-types.html#dynamically-sized-types-and-the-sized-trait>
+  = note: all function arguments must have a statically known size
+  = help: unsized locals are gated as an unstable feature
diff --git a/tests/ui/pin_project/project_replace_unsized_locals.rs b/tests/ui/pin_project/project_replace_unsized_locals.rs
new file mode 100644
index 0000000..2546041
--- /dev/null
+++ b/tests/ui/pin_project/project_replace_unsized_locals.rs
@@ -0,0 +1,13 @@
+#![feature(unsized_locals)]
+
+use pin_project::pin_project;
+
+#[pin_project(project_replace)] //~ ERROR E0277
+struct Struct<T: ?Sized> {
+    x: T,
+}
+
+#[pin_project(project_replace)] //~ ERROR E0277
+struct TupleStruct<T: ?Sized>(T);
+
+fn main() {}
diff --git a/tests/ui/pin_project/project_replace_unsized_locals.stderr b/tests/ui/pin_project/project_replace_unsized_locals.stderr
new file mode 100644
index 0000000..1616904
--- /dev/null
+++ b/tests/ui/pin_project/project_replace_unsized_locals.stderr
@@ -0,0 +1,64 @@
+error[E0277]: the size for values of type `T` cannot be known at compilation time
+ --> $DIR/project_replace_unsized_locals.rs:6:8
+  |
+6 | struct Struct<T: ?Sized> {
+  |        ^^^^^^^-^^^^^^^^^
+  |        |      |
+  |        |      this type parameter needs to be `std::marker::Sized`
+  |        doesn't have a size known at compile-time
+  |
+  = help: within `__StructProjectionOwned<T>`, the trait `std::marker::Sized` is not implemented for `T`
+  = note: to learn more, visit <https://doc.rust-lang.org/book/ch19-04-advanced-types.html#dynamically-sized-types-and-the-sized-trait>
+  = note: required because it appears within the type `__StructProjectionOwned<T>`
+  = note: the return type of a function must have a statically known size
+
+error[E0277]: the size for values of type `T` cannot be known at compilation time
+   --> $DIR/project_replace_unsized_locals.rs:7:5
+    |
+6   | struct Struct<T: ?Sized> {
+    |               - this type parameter needs to be `std::marker::Sized`
+7   |     x: T,
+    |     ^ doesn't have a size known at compile-time
+    |
+    = help: the trait `std::marker::Sized` is not implemented for `T`
+    = note: to learn more, visit <https://doc.rust-lang.org/book/ch19-04-advanced-types.html#dynamically-sized-types-and-the-sized-trait>
+
+error[E0277]: the size for values of type `T` cannot be known at compilation time
+ --> $DIR/project_replace_unsized_locals.rs:5:1
+  |
+5 | #[pin_project(project_replace)] //~ ERROR E0277
+  | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
+6 | struct Struct<T: ?Sized> {
+  |               - this type parameter needs to be `std::marker::Sized`
+  |
+  = help: within `__StructProjectionOwned<T>`, the trait `std::marker::Sized` is not implemented for `T`
+  = note: to learn more, visit <https://doc.rust-lang.org/book/ch19-04-advanced-types.html#dynamically-sized-types-and-the-sized-trait>
+  = note: required because it appears within the type `__StructProjectionOwned<T>`
+  = note: structs must have a statically known size to be initialized
+  = note: this error originates in a derive macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0277]: the size for values of type `T` cannot be known at compilation time
+  --> $DIR/project_replace_unsized_locals.rs:11:8
+   |
+11 | struct TupleStruct<T: ?Sized>(T);
+   |        ^^^^^^^^^^^^-^^^^^^^^^
+   |        |           |
+   |        |           this type parameter needs to be `std::marker::Sized`
+   |        doesn't have a size known at compile-time
+   |
+   = help: within `__TupleStructProjectionOwned<T>`, the trait `std::marker::Sized` is not implemented for `T`
+   = note: to learn more, visit <https://doc.rust-lang.org/book/ch19-04-advanced-types.html#dynamically-sized-types-and-the-sized-trait>
+   = note: required because it appears within the type `__TupleStructProjectionOwned<T>`
+   = note: the return type of a function must have a statically known size
+
+error[E0277]: the size for values of type `T` cannot be known at compilation time
+   --> $DIR/project_replace_unsized_locals.rs:10:1
+    |
+10  | #[pin_project(project_replace)] //~ ERROR E0277
+    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
+11  | struct TupleStruct<T: ?Sized>(T);
+    |                    - this type parameter needs to be `std::marker::Sized`
+    |
+    = help: the trait `std::marker::Sized` is not implemented for `T`
+    = note: to learn more, visit <https://doc.rust-lang.org/book/ch19-04-advanced-types.html#dynamically-sized-types-and-the-sized-trait>
+    = 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/proper_unpin.stderr b/tests/ui/pin_project/proper_unpin.stderr
index 9142887..7562597 100644
--- a/tests/ui/pin_project/proper_unpin.stderr
+++ b/tests/ui/pin_project/proper_unpin.stderr
@@ -5,10 +5,10 @@
    |                ----- 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`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 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 `Inner<std::marker::PhantomPinned>`
-   = note: required because it appears within the type `__SCOPE_Foo::__Foo<'_, std::marker::PhantomPinned, ()>`
+   = note: required because it appears within the type `_::__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
@@ -18,10 +18,10 @@
    |                ----- 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`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ within `_::__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 it appears within the type `_::__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
@@ -31,7 +31,7 @@
    |                ----- 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`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^ within `_::__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 it appears within the type `_::__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
index eebd3cd..1ecd56f 100644
--- a/tests/ui/pin_project/remove-attr-from-field.rs
+++ b/tests/ui/pin_project/remove-attr-from-field.rs
@@ -5,28 +5,28 @@
 fn is_unpin<T: Unpin>() {}
 
 #[pin_project]
-#[remove_attr(field)]
-struct Foo {
+#[remove_attr(field_all)]
+struct A {
     #[pin]
     field: PhantomPinned,
 }
 
-#[remove_attr(field)]
+#[remove_attr(field_all)]
 #[pin_project]
-struct Bar {
+struct B {
     #[pin]
     field: PhantomPinned,
 }
 
 fn main() {
-    is_unpin::<Foo>();
-    is_unpin::<Bar>();
+    is_unpin::<A>();
+    is_unpin::<B>();
 
-    let mut x = Foo { field: PhantomPinned };
+    let mut x = A { field: PhantomPinned };
     let x = Pin::new(&mut x).project();
     let _: Pin<&mut PhantomPinned> = x.field; //~ ERROR E0308
 
-    let mut x = Bar { field: PhantomPinned };
+    let mut x = B { 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-struct.rs b/tests/ui/pin_project/remove-attr-from-struct.rs
index b395a42..0c7af63 100644
--- a/tests/ui/pin_project/remove-attr-from-struct.rs
+++ b/tests/ui/pin_project/remove-attr-from-struct.rs
@@ -5,26 +5,42 @@
 fn is_unpin<T: Unpin>() {}
 
 #[pin_project]
-#[remove_attr(struct)]
-struct Foo {
+#[remove_attr(struct_all)]
+struct A {
     #[pin] //~ ERROR cannot find attribute `pin` in this scope
     field: PhantomPinned,
 }
 
-#[remove_attr(struct)]
+#[remove_attr(struct_all)]
 #[pin_project]
-struct Bar {
+struct B {
     #[pin] //~ ERROR cannot find attribute `pin` in this scope
     field: PhantomPinned,
 }
 
+#[pin_project] //~ ERROR has been removed
+#[remove_attr(struct_pin)]
+struct C {
+    field: PhantomPinned,
+}
+
+#[remove_attr(struct_pin)]
+#[pin_project] // Ok
+struct D {
+    field: PhantomPinned,
+}
+
 fn main() {
-    is_unpin::<Foo>(); //~ ERROR E0277
-    is_unpin::<Bar>(); //~ ERROR E0277
+    is_unpin::<A>(); //~ ERROR E0277
+    is_unpin::<B>(); //~ ERROR E0277
+    is_unpin::<D>(); // Ok
 
-    let mut x = Foo { field: PhantomPinned };
-    let _x = Pin::new(&mut x).project(); //~ ERROR E0277,E0599
+    let mut x = A { field: PhantomPinned };
+    let _ = Pin::new(&mut x).project(); //~ ERROR E0277,E0599
 
-    let mut x = Bar { field: PhantomPinned };
-    let _x = Pin::new(&mut x).project(); //~ ERROR E0277,E0599
+    let mut x = B { field: PhantomPinned };
+    let _ = Pin::new(&mut x).project(); //~ ERROR E0277,E0599
+
+    let mut x = D { field: PhantomPinned };
+    let _ = Pin::new(&mut x).project(); //~ Ok
 }
diff --git a/tests/ui/pin_project/remove-attr-from-struct.stderr b/tests/ui/pin_project/remove-attr-from-struct.stderr
index 3173248..112584e 100644
--- a/tests/ui/pin_project/remove-attr-from-struct.stderr
+++ b/tests/ui/pin_project/remove-attr-from-struct.stderr
@@ -1,3 +1,11 @@
+error: #[pin_project] attribute has been removed
+  --> $DIR/remove-attr-from-struct.rs:21:1
+   |
+21 | #[pin_project] //~ ERROR has been removed
+   | ^^^^^^^^^^^^^^
+   |
+   = note: this error originates in a derive macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
 error: cannot find attribute `pin` in this scope
   --> $DIR/remove-attr-from-struct.rs:10:7
    |
@@ -11,53 +19,53 @@
    |       ^^^
 
 error[E0277]: `std::marker::PhantomPinned` cannot be unpinned
-  --> $DIR/remove-attr-from-struct.rs:22:5
+  --> $DIR/remove-attr-from-struct.rs:34: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`
+34 |     is_unpin::<A>(); //~ ERROR E0277
+   |     ^^^^^^^^^^^^^ within `A`, the trait `std::marker::Unpin` is not implemented for `std::marker::PhantomPinned`
    |
-   = note: required because it appears within the type `Foo`
+   = note: required because it appears within the type `A`
 
 error[E0277]: `std::marker::PhantomPinned` cannot be unpinned
-  --> $DIR/remove-attr-from-struct.rs:23:5
+  --> $DIR/remove-attr-from-struct.rs:35: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`
+35 |     is_unpin::<B>(); //~ ERROR E0277
+   |     ^^^^^^^^^^^^^ within `B`, the trait `std::marker::Unpin` is not implemented for `std::marker::PhantomPinned`
    |
-   = note: required because it appears within the type `Bar`
+   = note: required because it appears within the type `B`
 
 error[E0277]: `std::marker::PhantomPinned` cannot be unpinned
-  --> $DIR/remove-attr-from-struct.rs:26:14
+  --> $DIR/remove-attr-from-struct.rs:39:13
    |
-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`
+39 |     let _ = Pin::new(&mut x).project(); //~ ERROR E0277,E0599
+   |             ^^^^^^^^ within `A`, the trait `std::marker::Unpin` is not implemented for `std::marker::PhantomPinned`
    |
-   = note: required because it appears within the type `Foo`
+   = note: required because it appears within the type `A`
    = 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
+error[E0599]: no method named `project` found for struct `std::pin::Pin<&mut A>` in the current scope
+  --> $DIR/remove-attr-from-struct.rs:39:30
    |
-26 |     let _x = Pin::new(&mut x).project(); //~ ERROR E0277,E0599
-   |                               ^^^^^^^ method not found in `std::pin::Pin<&mut Foo>`
+39 |     let _ = Pin::new(&mut x).project(); //~ ERROR E0277,E0599
+   |                              ^^^^^^^ method not found in `std::pin::Pin<&mut A>`
 
 error[E0277]: `std::marker::PhantomPinned` cannot be unpinned
-  --> $DIR/remove-attr-from-struct.rs:29:14
+  --> $DIR/remove-attr-from-struct.rs:42:13
    |
-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`
+42 |     let _ = Pin::new(&mut x).project(); //~ ERROR E0277,E0599
+   |             ^^^^^^^^ within `B`, the trait `std::marker::Unpin` is not implemented for `std::marker::PhantomPinned`
    |
-   = note: required because it appears within the type `Bar`
+   = note: required because it appears within the type `B`
    = 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
+error[E0599]: no method named `project` found for struct `std::pin::Pin<&mut B>` in the current scope
+  --> $DIR/remove-attr-from-struct.rs:42:30
    |
-29 |     let _x = Pin::new(&mut x).project(); //~ ERROR E0277,E0599
-   |                               ^^^^^^^ method not found in `std::pin::Pin<&mut Bar>`
+42 |     let _ = Pin::new(&mut x).project(); //~ ERROR E0277,E0599
+   |                              ^^^^^^^ method not found in `std::pin::Pin<&mut B>`
diff --git a/tests/ui/pin_project/visibility.rs b/tests/ui/pin_project/visibility.rs
index 7dce6ab..01c0831 100644
--- a/tests/ui/pin_project/visibility.rs
+++ b/tests/ui/pin_project/visibility.rs
@@ -4,7 +4,7 @@
     #[pin_project]
     pub struct Default(());
 
-    #[pin_project(Replace)]
+    #[pin_project(project_replace)]
     pub struct Replace(());
 }
 pub mod pub_use {
@@ -37,7 +37,7 @@
     #[pin_project]
     pub(crate) struct Default(());
 
-    #[pin_project(Replace)]
+    #[pin_project(project_replace)]
     pub(crate) struct Replace(());
 }
 pub mod pub_crate_use {
@@ -55,7 +55,7 @@
     #[pin_project(project = DProj, project_ref = DProjRef)]
     pub struct Default(());
 
-    #[pin_project(Replace, project = RProj, project_ref = RProjRef, project_replace = RProjOwn)]
+    #[pin_project(project = RProj, project_ref = RProjRef, project_replace = RProjOwn)]
     pub struct Replace(());
 }
 pub mod pub_renamed_use {
diff --git a/tests/ui/pinned_drop/invalid.rs b/tests/ui/pinned_drop/invalid.rs
index 9ff5de2..7065ec9 100644
--- a/tests/ui/pinned_drop/invalid.rs
+++ b/tests/ui/pinned_drop/invalid.rs
@@ -204,4 +204,26 @@
     }
 }
 
+mod self_ty {
+    use pin_project::pinned_drop;
+
+    #[pinned_drop]
+    impl PinnedDrop for () {
+        //~^ ERROR implementing the trait `PinnedDrop` on this type is unsupported
+        fn drop(self: Pin<&mut Self>) {}
+    }
+
+    #[pinned_drop]
+    impl PinnedDrop for &mut A {
+        //~^ ERROR implementing the trait `PinnedDrop` on this type is unsupported
+        fn drop(self: Pin<&mut Self>) {}
+    }
+
+    #[pinned_drop]
+    impl PinnedDrop for [A] {
+        //~^ ERROR implementing the trait `PinnedDrop` on this type is unsupported
+        fn drop(self: Pin<&mut Self>) {}
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/pinned_drop/invalid.stderr b/tests/ui/pinned_drop/invalid.stderr
index 8046903..65ef9ff 100644
--- a/tests/ui/pinned_drop/invalid.stderr
+++ b/tests/ui/pinned_drop/invalid.stderr
@@ -123,3 +123,21 @@
     |
 203 |         fn pinned_drop(&mut self) {} //~ ERROR method `pinned_drop` is not a member of trait `PinnedDrop
     |            ^^^^^^^^^^^
+
+error: implementing the trait `PinnedDrop` on this type is unsupported
+   --> $DIR/invalid.rs:211:25
+    |
+211 |     impl PinnedDrop for () {
+    |                         ^^
+
+error: implementing the trait `PinnedDrop` on this type is unsupported
+   --> $DIR/invalid.rs:217:25
+    |
+217 |     impl PinnedDrop for &mut A {
+    |                         ^^^^^^
+
+error: implementing the trait `PinnedDrop` on this type is unsupported
+   --> $DIR/invalid.rs:223:25
+    |
+223 |     impl PinnedDrop for [A] {
+    |                         ^^^
diff --git a/tests/ui/pinned_drop/self.rs b/tests/ui/pinned_drop/self.rs
index cd53b04..9176066 100644
--- a/tests/ui/pinned_drop/self.rs
+++ b/tests/ui/pinned_drop/self.rs
@@ -1,10 +1,10 @@
-use pin_project::{pin_project, pinned_drop};
-use std::pin::Pin;
+pub mod self_in_macro_def {
+    use pin_project::{pin_project, pinned_drop};
+    use std::pin::Pin;
 
-fn self_in_macro_def() {
     #[pin_project(PinnedDrop)]
     pub struct Struct {
-        x: usize,
+        x: (),
     }
 
     #[pinned_drop]
@@ -12,12 +12,9 @@
         fn drop(self: Pin<&mut Self>) {
             macro_rules! t {
                 () => {{
-                    let _ = self; //~ ERROR can't capture dynamic environment in a fn item
+                    let _ = self; //~ ERROR E0434
 
-                    fn f(self: ()) {
-                        //~^ ERROR `self` parameter is only allowed in associated functions
-                        let _ = self;
-                    }
+                    fn f(self: ()) {} //~ ERROR `self` parameter is only allowed in associated functions
                 }};
             }
             t!();
@@ -25,4 +22,35 @@
     }
 }
 
+pub mod self_span {
+    use pin_project::{pin_project, pinned_drop};
+    use std::pin::Pin;
+
+    #[pin_project(PinnedDrop)]
+    pub struct S {
+        x: (),
+    }
+
+    #[pinned_drop]
+    impl PinnedDrop for S {
+        fn drop(self: Pin<&mut Self>) {
+            let _: () = self; //~ ERROR E0308
+            let _: Self = Self; //~ ERROR E0423
+        }
+    }
+
+    #[pin_project(PinnedDrop)]
+    pub enum E {
+        V { x: () },
+    }
+
+    #[pinned_drop]
+    impl PinnedDrop for E {
+        fn drop(self: Pin<&mut Self>) {
+            let _: () = self; //~ ERROR E0308
+            let _: Self = Self::V; //~ ERROR E0533
+        }
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/pinned_drop/self.stderr b/tests/ui/pinned_drop/self.stderr
index 3ba333b..2a71b0a 100644
--- a/tests/ui/pinned_drop/self.stderr
+++ b/tests/ui/pinned_drop/self.stderr
@@ -1,10 +1,10 @@
 error: `self` parameter is only allowed in associated functions
   --> $DIR/self.rs:17:26
    |
-17 |                     fn f(self: ()) {
+17 |                     fn f(self: ()) {} //~ ERROR `self` parameter is only allowed in associated functions
    |                          ^^^^ not semantically valid as function parameter
 ...
-23 |             t!();
+20 |             t!();
    |             ----- in this macro invocation
    |
    = note: associated functions are those in `impl` or `trait` definitions
@@ -13,11 +13,50 @@
 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
+15 |                     let _ = self; //~ ERROR E0434
    |                             ^^^^
 ...
-23 |             t!();
+20 |             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)
+
+error[E0423]: expected value, found struct `S`
+  --> $DIR/self.rs:38:27
+   |
+30 | /     pub struct S {
+31 | |         x: (),
+32 | |     }
+   | |_____- `S` defined here
+...
+38 |               let _: Self = Self; //~ ERROR E0423
+   |                             ^^^^ did you mean `S { /* fields */ }`?
+
+error[E0308]: mismatched types
+  --> $DIR/self.rs:37:25
+   |
+37 |             let _: () = self; //~ ERROR E0308
+   |                    --   ^^^^ expected `()`, found struct `std::pin::Pin`
+   |                    |
+   |                    expected due to this
+   |
+   = note: expected unit type `()`
+                 found struct `std::pin::Pin<&mut self_span::S>`
+
+error[E0308]: mismatched types
+  --> $DIR/self.rs:50:25
+   |
+50 |             let _: () = self; //~ ERROR E0308
+   |                    --   ^^^^ expected `()`, found struct `std::pin::Pin`
+   |                    |
+   |                    expected due to this
+   |
+   = note: expected unit type `()`
+                 found struct `std::pin::Pin<&mut self_span::E>`
+
+error[E0533]: expected unit struct, unit variant or constant, found struct variant `Self::V`
+  --> $DIR/self.rs:51:27
+   |
+51 |             let _: Self = Self::V; //~ ERROR E0533
+   |                           ^^^^^^^
diff --git a/tests/ui/project/ambiguous-let.rs b/tests/ui/project/ambiguous-let.rs
index a706749..bbb3a2c 100644
--- a/tests/ui/project/ambiguous-let.rs
+++ b/tests/ui/project/ambiguous-let.rs
@@ -1,3 +1,5 @@
+#![allow(deprecated)]
+
 use pin_project::{pin_project, project};
 
 #[pin_project]
diff --git a/tests/ui/project/ambiguous-let.stderr b/tests/ui/project/ambiguous-let.stderr
index e6552c8..2e66484 100644
--- a/tests/ui/project/ambiguous-let.stderr
+++ b/tests/ui/project/ambiguous-let.stderr
@@ -1,5 +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
+  --> $DIR/ambiguous-let.rs:18:9
    |
-16 |     let Struct(x) = match Pin::new(&mut foo).project() {
+18 |     let Struct(x) = match Pin::new(&mut foo).project() {
    |         ^^^^^^^^^
diff --git a/tests/ui/project/deprecated.rs b/tests/ui/project/deprecated.rs
new file mode 100644
index 0000000..78d593d
--- /dev/null
+++ b/tests/ui/project/deprecated.rs
@@ -0,0 +1,8 @@
+#![deny(deprecated)]
+
+use pin_project::{project, project_ref, project_replace};
+
+#[project]
+#[project_ref]
+#[project_replace]
+fn main() {}
diff --git a/tests/ui/project/deprecated.stderr b/tests/ui/project/deprecated.stderr
new file mode 100644
index 0000000..015b8df
--- /dev/null
+++ b/tests/ui/project/deprecated.stderr
@@ -0,0 +1,23 @@
+error: use of deprecated item 'project': consider naming projected type by passing `project` argument to #[pin_project] attribute instead, see release note <https://github.com/taiki-e/pin-project/releases/tag/v0.4.21> for details
+ --> $DIR/deprecated.rs:5:3
+  |
+5 | #[project]
+  |   ^^^^^^^
+  |
+note: the lint level is defined here
+ --> $DIR/deprecated.rs:1:9
+  |
+1 | #![deny(deprecated)]
+  |         ^^^^^^^^^^
+
+error: use of deprecated item 'project_ref': consider naming projected type by passing `project_ref` argument to #[pin_project] attribute instead, see release note <https://github.com/taiki-e/pin-project/releases/tag/v0.4.21> for details
+ --> $DIR/deprecated.rs:6:3
+  |
+6 | #[project_ref]
+  |   ^^^^^^^^^^^
+
+error: use of deprecated item 'project_replace': consider naming projected type by passing `project_replace` argument to #[pin_project] attribute instead, see release note <https://github.com/taiki-e/pin-project/releases/tag/v0.4.21> for details
+ --> $DIR/deprecated.rs:7:3
+  |
+7 | #[project_replace]
+  |   ^^^^^^^^^^^^^^^
diff --git a/tests/ui/project/invalid.rs b/tests/ui/project/invalid.rs
index 07e9970..e72f84c 100644
--- a/tests/ui/project/invalid.rs
+++ b/tests/ui/project/invalid.rs
@@ -1,3 +1,5 @@
+#![allow(deprecated)]
+
 mod argument {
     use pin_project::{pin_project, project};
 
@@ -46,7 +48,7 @@
 mod attribute {
     use pin_project::{pin_project, project, project_ref, project_replace};
 
-    #[pin_project(Replace)]
+    #[pin_project(project_replace)]
     struct A(#[pin] ());
 
     #[project]
diff --git a/tests/ui/project/invalid.stderr b/tests/ui/project/invalid.stderr
index 287cac8..e1dc388 100644
--- a/tests/ui/project/invalid.stderr
+++ b/tests/ui/project/invalid.stderr
@@ -1,155 +1,155 @@
 error: unexpected token: ()
-  --> $DIR/invalid.rs:10:18
+  --> $DIR/invalid.rs:12:18
    |
-10 |         #[project()] //~ ERROR unexpected token
+12 |         #[project()] //~ ERROR unexpected token
    |                  ^^
 
 error: unexpected token: (foo)
-  --> $DIR/invalid.rs:17:18
+  --> $DIR/invalid.rs:19:18
    |
-17 |         #[project(foo)] //~ ERROR unexpected token
+19 |         #[project(foo)] //~ ERROR unexpected token
    |                  ^^^^^
 
 error: unexpected token: ()
-  --> $DIR/invalid.rs:24:18
+  --> $DIR/invalid.rs:26:18
    |
-24 |         #[project()] //~ ERROR unexpected token
+26 |         #[project()] //~ ERROR unexpected token
    |                  ^^
 
 error: unexpected token: (foo)
-  --> $DIR/invalid.rs:33:18
+  --> $DIR/invalid.rs:35:18
    |
-33 |         #[project(foo)] //~ ERROR unexpected token
+35 |         #[project(foo)] //~ ERROR unexpected token
    |                  ^^^^^
 
 error: unexpected token: foo
-  --> $DIR/invalid.rs:42:15
+  --> $DIR/invalid.rs:44:15
    |
-42 |     #[project(foo)] //~ ERROR unexpected token
+44 |     #[project(foo)] //~ ERROR unexpected token
    |               ^^^
 
 error: duplicate #[project] attribute
-  --> $DIR/invalid.rs:56:9
+  --> $DIR/invalid.rs:58:9
    |
-56 |         #[project] //~ ERROR duplicate #[project] attribute
+58 |         #[project] //~ ERROR duplicate #[project] attribute
    |         ^^^^^^^^^^
 
 error: duplicate #[project_ref] attribute
-  --> $DIR/invalid.rs:64:9
+  --> $DIR/invalid.rs:66:9
    |
-64 |         #[project_ref] //~ ERROR duplicate #[project_ref] attribute
+66 |         #[project_ref] //~ ERROR duplicate #[project_ref] attribute
    |         ^^^^^^^^^^^^^^
 
 error: duplicate #[project_replace] attribute
-  --> $DIR/invalid.rs:72:9
+  --> $DIR/invalid.rs:74:9
    |
-72 |         #[project_replace] //~ ERROR duplicate #[project_replace] attribute
+74 |         #[project_replace] //~ ERROR duplicate #[project_replace] attribute
    |         ^^^^^^^^^^^^^^^^^^
 
-error: attributes `project_ref` and `project` are mutually exclusive
-  --> $DIR/invalid.rs:79:9
+error: attributes `project` and `project_ref` are mutually exclusive
+  --> $DIR/invalid.rs:82:9
    |
-79 |         #[project]
-   |         ^^^^^^^^^^
+82 |         #[project_ref] //~ ERROR are mutually exclusive
+   |         ^^^^^^^^^^^^^^
 
 error: attributes `project` and `project_replace` are mutually exclusive
-  --> $DIR/invalid.rs:88:9
+  --> $DIR/invalid.rs:90:9
    |
-88 |         #[project_replace] //~ ERROR are mutually exclusive
+90 |         #[project_replace] //~ ERROR are mutually exclusive
    |         ^^^^^^^^^^^^^^^^^^
 
 error: attributes `project_ref` and `project_replace` are mutually exclusive
-  --> $DIR/invalid.rs:96:9
+  --> $DIR/invalid.rs:98:9
    |
-96 |         #[project_replace] //~ ERROR are mutually exclusive
+98 |         #[project_replace] //~ ERROR are mutually exclusive
    |         ^^^^^^^^^^^^^^^^^^
 
-error: attributes `project_ref` and `project` are mutually exclusive
-   --> $DIR/invalid.rs:103:9
+error: attributes `project` and `project_ref` are mutually exclusive
+   --> $DIR/invalid.rs:106:9
     |
-103 |         #[project]
-    |         ^^^^^^^^^^
+106 |         #[project_ref] //~ ERROR are mutually exclusive
+    |         ^^^^^^^^^^^^^^
 
 error: attributes `project` and `project_replace` are mutually exclusive
-   --> $DIR/invalid.rs:112:9
+   --> $DIR/invalid.rs:114:9
     |
-112 |         #[project_replace] //~ ERROR are mutually exclusive
+114 |         #[project_replace] //~ ERROR are mutually exclusive
     |         ^^^^^^^^^^^^^^^^^^
 
 error: attributes `project_ref` and `project_replace` are mutually exclusive
-   --> $DIR/invalid.rs:120:9
+   --> $DIR/invalid.rs:122:9
     |
-120 |         #[project_replace] //~ ERROR are mutually exclusive
+122 |         #[project_replace] //~ ERROR are mutually exclusive
     |         ^^^^^^^^^^^^^^^^^^
 
-error: attributes `project_ref` and `project` are mutually exclusive
-   --> $DIR/invalid.rs:127:9
+error: attributes `project` and `project_ref` are mutually exclusive
+   --> $DIR/invalid.rs:130:9
     |
-127 |         #[project]
-    |         ^^^^^^^^^^
+130 |         #[project_ref] //~ ERROR are mutually exclusive
+    |         ^^^^^^^^^^^^^^
 
 error: attributes `project` and `project_replace` are mutually exclusive
-   --> $DIR/invalid.rs:136:9
+   --> $DIR/invalid.rs:138:9
     |
-136 |         #[project_replace] //~ ERROR are mutually exclusive
+138 |         #[project_replace] //~ ERROR are mutually exclusive
     |         ^^^^^^^^^^^^^^^^^^
 
 error: attributes `project_ref` and `project_replace` are mutually exclusive
-   --> $DIR/invalid.rs:144:9
+   --> $DIR/invalid.rs:146:9
     |
-144 |         #[project_replace] //~ ERROR are mutually exclusive
+146 |         #[project_replace] //~ ERROR are mutually exclusive
     |         ^^^^^^^^^^^^^^^^^^
 
 error: duplicate #[project] attribute
-   --> $DIR/invalid.rs:149:5
+   --> $DIR/invalid.rs:151:5
     |
-149 |     #[project] //~ ERROR duplicate #[project] attribute
+151 |     #[project] //~ ERROR duplicate #[project] attribute
     |     ^^^^^^^^^^
 
 error: duplicate #[project_ref] attribute
-   --> $DIR/invalid.rs:153:5
+   --> $DIR/invalid.rs:155:5
     |
-153 |     #[project_ref] //~ ERROR duplicate #[project_ref] attribute
+155 |     #[project_ref] //~ ERROR duplicate #[project_ref] attribute
     |     ^^^^^^^^^^^^^^
 
 error: duplicate #[project_replace] attribute
-   --> $DIR/invalid.rs:157:5
+   --> $DIR/invalid.rs:159:5
     |
-157 |     #[project_replace] //~ ERROR duplicate #[project_replace] attribute
+159 |     #[project_replace] //~ ERROR duplicate #[project_replace] attribute
     |     ^^^^^^^^^^^^^^^^^^
 
 error: duplicate #[project] attribute
-   --> $DIR/invalid.rs:161:5
+   --> $DIR/invalid.rs:163:5
     |
-161 |     #[project] //~ ERROR duplicate #[project] attribute
+163 |     #[project] //~ ERROR duplicate #[project] attribute
     |     ^^^^^^^^^^
 
 error: duplicate #[project_ref] attribute
-   --> $DIR/invalid.rs:165:5
+   --> $DIR/invalid.rs:167:5
     |
-165 |     #[project_ref] //~ ERROR duplicate #[project_ref] attribute
+167 |     #[project_ref] //~ ERROR duplicate #[project_ref] attribute
     |     ^^^^^^^^^^^^^^
 
 error: duplicate #[project_replace] attribute
-   --> $DIR/invalid.rs:169:5
+   --> $DIR/invalid.rs:171:5
     |
-169 |     #[project_replace] //~ ERROR duplicate #[project_replace] attribute
+171 |     #[project_replace] //~ ERROR duplicate #[project_replace] attribute
     |     ^^^^^^^^^^^^^^^^^^
 
 error: duplicate #[project] attribute
-   --> $DIR/invalid.rs:177:9
+   --> $DIR/invalid.rs:179:9
     |
-177 |         #[project] //~ ERROR duplicate #[project] attribute
+179 |         #[project] //~ ERROR duplicate #[project] attribute
     |         ^^^^^^^^^^
 
 error: duplicate #[project_ref] attribute
-   --> $DIR/invalid.rs:181:9
+   --> $DIR/invalid.rs:183:9
     |
-181 |         #[project_ref] //~ ERROR duplicate #[project_ref] attribute
+183 |         #[project_ref] //~ ERROR duplicate #[project_ref] attribute
     |         ^^^^^^^^^^^^^^
 
 error: duplicate #[project_replace] attribute
-   --> $DIR/invalid.rs:185:9
+   --> $DIR/invalid.rs:187:9
     |
-185 |         #[project_replace] //~ ERROR duplicate #[project_replace] attribute
+187 |         #[project_replace] //~ ERROR duplicate #[project_replace] attribute
     |         ^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/project/type-mismatch.rs b/tests/ui/project/type-mismatch.rs
index 41a70eb..0e40c83 100644
--- a/tests/ui/project/type-mismatch.rs
+++ b/tests/ui/project/type-mismatch.rs
@@ -1,3 +1,4 @@
+#![allow(deprecated)]
 #![feature(proc_macro_hygiene, stmt_expr_attributes)]
 
 use pin_project::{pin_project, project};
@@ -36,9 +37,6 @@
     }
 }
 
-//~ 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> {
@@ -67,7 +65,7 @@
             let _x: &mut Pin<&mut i32> = field1;
             let _y: &mut &mut i32 = field2;
         }
-        None => {}
+        None => {} //~ ERROR mismatched types
     }
 }
 
diff --git a/tests/ui/project/type-mismatch.stderr b/tests/ui/project/type-mismatch.stderr
index b4c97d5..4199c17 100644
--- a/tests/ui/project/type-mismatch.stderr
+++ b/tests/ui/project/type-mismatch.stderr
@@ -1,16 +1,23 @@
 error[E0308]: mismatched types
-  --> $DIR/type-mismatch.rs:35:9
+  --> $DIR/type-mismatch.rs:36:9
    |
-23 |     match &mut foo {
+24 |     match &mut foo {
    |           -------- this expression has type `&mut type_mismatch::__EnumProjection<'_, {integer}, {integer}, _, _>`
 ...
-35 |         None => {} //~ ERROR mismatched types
+36 |         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<_>`
+  --> $DIR/type-mismatch.rs:68:9
+   |
+56 |     match &mut foo {
+   |           -------- this expression has type `&mut type_mismatch_span_issue::__EnumProjection<'_, {integer}, {integer}, _, _>`
+...
+68 |         None => {} //~ ERROR mismatched types
+   |         ^^^^ expected enum `type_mismatch_span_issue::__EnumProjection`, found enum `std::option::Option`
+   |
+   = 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
index 23c9b89..aa82a95 100644
--- a/tests/ui/project/use-public.rs
+++ b/tests/ui/project/use-public.rs
@@ -1,3 +1,5 @@
+#![allow(deprecated)]
+
 use pin_project::pin_project;
 
 #[pin_project]
diff --git a/tests/ui/project/use-public.stderr b/tests/ui/project/use-public.stderr
index 7919d65..6956656 100644
--- a/tests/ui/project/use-public.stderr
+++ b/tests/ui/project/use-public.stderr
@@ -1,7 +1,7 @@
 error[E0365]: `__AProjection` is private, and cannot be re-exported
-  --> $DIR/use-public.rs:12:13
+  --> $DIR/use-public.rs:14:13
    |
-12 |     pub use crate::A; //~ ERROR E0365
+14 |     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
index d4b02c1..ba56382 100644
--- a/tests/ui/project/use.rs
+++ b/tests/ui/project/use.rs
@@ -1,3 +1,5 @@
+#![allow(deprecated)]
+
 use pin_project::pin_project;
 
 #[pin_project]
diff --git a/tests/ui/project/use.stderr b/tests/ui/project/use.stderr
index 07d0241..daddb16 100644
--- a/tests/ui/project/use.stderr
+++ b/tests/ui/project/use.stderr
@@ -1,11 +1,11 @@
 error: #[project] attribute may not be used on renamed imports
-  --> $DIR/use.rs:12:16
+  --> $DIR/use.rs:14:16
    |
-12 |     use crate::A as B; //~ ERROR #[project] attribute may not be used on renamed imports
+14 |     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
+  --> $DIR/use.rs:16:16
    |
-14 |     use crate::*; //~ ERROR #[project] attribute may not be used on glob imports
+16 |     use crate::*; //~ ERROR #[project] attribute may not be used on glob imports
    |                ^
diff --git a/tests/ui/unsafe_unpin/conflict-unpin.stderr b/tests/ui/unsafe_unpin/conflict-unpin.stderr
index 62de016..916c3f2 100644
--- a/tests/ui/unsafe_unpin/conflict-unpin.stderr
+++ b/tests/ui/unsafe_unpin/conflict-unpin.stderr
@@ -1,35 +1,32 @@
 error[E0119]: conflicting implementations of trait `std::marker::Unpin` for type `Foo<_, _>`:
-  --> $DIR/conflict-unpin.rs:3:1
+  --> $DIR/conflict-unpin.rs:3:15
    |
 3  | #[pin_project(UnsafeUnpin)] //~ ERROR E0119
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `Foo<_, _>`
+   |               ^^^^^^^^^^^ 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
+  --> $DIR/conflict-unpin.rs:12:15
    |
 12 | #[pin_project(UnsafeUnpin)] //~ ERROR E0119
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `Bar<_, _>`
+   |               ^^^^^^^^^^^ 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
+  --> $DIR/conflict-unpin.rs:21:15
    |
 21 | #[pin_project(UnsafeUnpin)] //~ ERROR E0119
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `Baz<_, _>`
+   |               ^^^^^^^^^^^ 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/unstable-features/run-pass/stmt_expr_attributes.rs b/tests/ui/unstable-features/run-pass/stmt_expr_attributes.rs
index 8ad8e41..2b6377a 100644
--- a/tests/ui/unstable-features/run-pass/stmt_expr_attributes.rs
+++ b/tests/ui/unstable-features/run-pass/stmt_expr_attributes.rs
@@ -1,5 +1,6 @@
 // NB: If you change this test, change 'stmt_expr_attributes-feature-gate.rs' at the same time.
 
+#![allow(deprecated)]
 // proc_macro_hygiene
 // Tracking issue: https://github.com/rust-lang/rust/issues/54727
 #![feature(proc_macro_hygiene)]
diff --git a/tests/ui/unstable-features/stmt_expr_attributes-feature-gate.rs b/tests/ui/unstable-features/stmt_expr_attributes-feature-gate.rs
index 8226723..5dbe523 100644
--- a/tests/ui/unstable-features/stmt_expr_attributes-feature-gate.rs
+++ b/tests/ui/unstable-features/stmt_expr_attributes-feature-gate.rs
@@ -1,5 +1,7 @@
 // NB: If you change this test, change 'stmt_expr_attributes.rs' at the same time.
 
+#![allow(deprecated)]
+
 use pin_project::{pin_project, project};
 use std::pin::Pin;
 
diff --git a/tests/ui/unstable-features/stmt_expr_attributes-feature-gate.stderr b/tests/ui/unstable-features/stmt_expr_attributes-feature-gate.stderr
index 6510ec7..3c0501a 100644
--- a/tests/ui/unstable-features/stmt_expr_attributes-feature-gate.stderr
+++ b/tests/ui/unstable-features/stmt_expr_attributes-feature-gate.stderr
@@ -1,34 +1,34 @@
 error[E0658]: attributes on expressions are experimental
-  --> $DIR/stmt_expr_attributes-feature-gate.rs:22:5
+  --> $DIR/stmt_expr_attributes-feature-gate.rs:24:5
    |
-22 |     #[project] //~ ERROR E0658
+24 |     #[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
+  --> $DIR/stmt_expr_attributes-feature-gate.rs:40:14
    |
-38 |     let () = #[project] //~ ERROR E0658
+40 |     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
+  --> $DIR/stmt_expr_attributes-feature-gate.rs:24:5
    |
-22 |     #[project] //~ ERROR E0658
+24 |     #[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
+  --> $DIR/stmt_expr_attributes-feature-gate.rs:40:14
    |
-38 |     let () = #[project] //~ ERROR E0658
+40 |     let () = #[project] //~ ERROR E0658
    |              ^^^^^^^^^^
    |
    = note: see issue #54727 <https://github.com/rust-lang/rust/issues/54727> for more information