diff --git a/.cargo_vcs_info.json b/.cargo_vcs_info.json
index da3735d..9b071c7 100644
--- a/.cargo_vcs_info.json
+++ b/.cargo_vcs_info.json
@@ -1,5 +1,5 @@
 {
   "git": {
-    "sha1": "a69b3004032bfabf8cac8ac809d56ff32e66ed82"
+    "sha1": "9bdd6cf28180109a9add57d27428c66470f19c09"
   }
 }
diff --git a/.editorconfig b/.editorconfig
index c93ffc7..ea2a033 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -14,3 +14,7 @@
 
 [*.{json,yml,md}]
 indent_size = 2
+
+[*.sh]
+indent_size = 2
+switch_case_indent = true
diff --git a/.gitattributes b/.gitattributes
index 45bca84..7e4a4f0 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -1,4 +1,2 @@
-[attr]rust text eol=lf whitespace=tab-in-indent,trailing-space,tabwidth=4
-
 * text=auto eol=lf
-*.rs rust
+*.rs text eol=lf whitespace=tab-in-indent,trailing-space,tabwidth=4
diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml
new file mode 100644
index 0000000..8204219
--- /dev/null
+++ b/.github/FUNDING.yml
@@ -0,0 +1 @@
+github: taiki-e
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 8a7da1d..6932c06 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -6,12 +6,12 @@
     branches:
       - master
       - staging
-      - trying
   schedule:
     - cron: '0 1 * * *'
 
 env:
-  RUSTFLAGS: -Dwarnings
+  CARGO_INCREMENTAL: 0
+  RUSTFLAGS: -D warnings
   RUST_BACKTRACE: 1
 
 defaults:
@@ -20,7 +20,6 @@
 
 jobs:
   test:
-    name: test
     strategy:
       matrix:
         rust:
@@ -40,99 +39,82 @@
     runs-on: ${{ matrix.os || 'ubuntu-latest' }}
     steps:
       - uses: actions/checkout@v2
-      - name: Install Rust
-        run: ci/install-rust.sh ${{ matrix.rust }}
-      - name: Install cargo-hack
-        if: matrix.rust == 'nightly'
-        run: |
-          cargo install cargo-hack
-      - name: Add targets
-        if: matrix.rust == 'nightly'
-        run: |
-          rustup target add thumbv7m-none-eabi
-      - name: cargo test
-        run: |
-          cargo test --all --all-features --exclude expandtest
-      - 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: |
-          bash scripts/check-minimal-versions.sh
+      - uses: taiki-e/github-actions/install-rust@main
+        with:
+          toolchain: ${{ matrix.rust }}
+      - if: startsWith(matrix.rust, 'nightly')
+        run: cargo install cargo-hack
+      - run: rustup target add thumbv7m-none-eabi
+      - run: cargo test --all --all-features --exclude expandtest
+      - run: cargo check --manifest-path tests/no-std/Cargo.toml --target thumbv7m-none-eabi
+      - run: cargo check --manifest-path tests/rust-2015/Cargo.toml --target thumbv7m-none-eabi
+      - if: startsWith(matrix.rust, 'nightly')
+        run: bash scripts/check-minimal-versions.sh
 
   expandtest:
-    name: expandtest
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
-      - name: Install Rust and Rustfmt
-        run: ci/install-component.sh rustfmt
+      - uses: taiki-e/github-actions/install-rust@main
+        with:
+          component: rustfmt
+      - name: Fetch latest release version of cargo-expand
+        run: |
+          mkdir -p .github/caching
+          curl -LsSf https://api.github.com/repos/dtolnay/cargo-expand/releases/latest | jq -r '.name' > .github/caching/cargo-expand.lock
+      - name: Cache cargo-expand
+        id: cache-cargo-expand
+        uses: actions/cache@v2
+        with:
+          path: ${{ runner.tool_cache }}/cargo-expand/bin
+          key: cargo-expand-bin-${{ hashFiles('.github/caching/cargo-expand.lock') }}
       - name: Install cargo-expand
-        run: |
-          cargo install cargo-expand
-      - name: cargo test (expandtest)
-        run: |
-          bash scripts/expandtest.sh
+        if: steps.cache-cargo-expand.outputs.cache-hit != 'true'
+        run: cargo install -f cargo-expand --root ${{ runner.tool_cache }}/cargo-expand
+      - run: echo "${{ runner.tool_cache }}/cargo-expand/bin" >> "${GITHUB_PATH}"
+      - run: cargo test -p expandtest
 
   miri:
-    name: miri
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
-      - name: Install Rust and Miri
-        run: |
-          ci/install-component.sh miri
-          cargo miri setup
-      - name: cargo miri test
-        run: |
-          cargo miri test
+      - uses: taiki-e/github-actions/install-rust@main
+        with:
+          component: miri
+      - run: cargo miri test
 
   clippy:
-    name: clippy
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
-      - name: Install Rust and Clippy
-        run: ci/install-component.sh clippy
-      - name: cargo clippy
-        run: |
-          cargo clippy --all --all-features --all-targets
+      - uses: taiki-e/github-actions/install-rust@main
+        with:
+          component: clippy
+      - run: cargo clippy --all --all-features --all-targets
 
   rustfmt:
-    name: rustfmt
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
-      - name: Install Rust and Rustfmt
-        run: ci/install-component.sh rustfmt
-      - name: cargo fmt --check
-        run: |
-          cargo fmt --all -- --check
+      - uses: taiki-e/github-actions/install-rust@main
+        with:
+          component: rustfmt
+      - run: cargo fmt --all -- --check
 
   rustdoc:
-    name: rustdoc
     env:
-      RUSTDOCFLAGS: -Dwarnings
+      RUSTDOCFLAGS: -D warnings
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
-      - name: Install Rust
-        run: ci/install-rust.sh
-      - name: cargo doc
-        run: |
-          cargo doc --no-deps --all --all-features
+      - uses: taiki-e/github-actions/install-rust@main
+      - run: cargo doc --no-deps --all --all-features
 
   shellcheck:
-    name: shellcheck
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
-      - name: shellcheck
-        run: |
-          shellcheck ci/*.sh scripts/*.sh
+      - run: shellcheck **/*.sh
 
   # These jobs don't actually test anything, but they're used to tell bors the
   # build completed, as there is no practical way to detect when a workflow is
@@ -145,11 +127,11 @@
     if: github.event_name == 'push' && success()
     needs:
       - test
+      - expandtest
+      - miri
       - clippy
       - rustfmt
       - rustdoc
-      - expandtest
-      - miri
       - shellcheck
     runs-on: ubuntu-latest
     steps:
@@ -160,11 +142,11 @@
     if: github.event_name == 'push' && !success()
     needs:
       - test
+      - expandtest
+      - miri
       - clippy
       - rustfmt
       - rustdoc
-      - expandtest
-      - miri
       - shellcheck
     runs-on: ubuntu-latest
     steps:
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
new file mode 100644
index 0000000..5f7c998
--- /dev/null
+++ b/.github/workflows/release.yml
@@ -0,0 +1,16 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+jobs:
+  create-release:
+    if: github.repository_owner == 'taiki-e'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: taiki-e/github-actions/create-release@main
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
diff --git a/Android.bp b/Android.bp
index f20d8c1..1ed91d5 100644
--- a/Android.bp
+++ b/Android.bp
@@ -10,7 +10,7 @@
 }
 
 // dependent_library ["feature_list"]
-//   pin-project-internal-1.0.1
+//   pin-project-internal-1.0.2
 //   proc-macro2-1.0.24 "default,proc-macro"
 //   quote-1.0.7 "default,proc-macro"
 //   syn-1.0.48 "clone-impls,default,derive,full,parsing,printing,proc-macro,quote,visit,visit-mut"
diff --git a/CHANGELOG.md b/CHANGELOG.md
index f68f7b4..0810aae 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,6 +6,10 @@
 
 ## [Unreleased]
 
+## [1.0.2] - 2020-10-19
+
+* [Suppress `clippy::unknown_clippy_lints` lint in generated code.](https://github.com/taiki-e/pin-project/pull/303)
+
 ## [1.0.1] - 2020-10-15
 
 * [Fix warnings when `#[pin_project]` attribute used within `macro_rules!` macros.](https://github.com/taiki-e/pin-project/pull/298)
@@ -292,7 +296,9 @@
 
 [206]: https://github.com/taiki-e/pin-project/issues/206
 
-## [0.4.11] - 2020-05-07 - YANKED
+## [0.4.11] - 2020-05-07
+
+**Note: This release has been yanked.** See [#206][206] for details.
 
 * [Fixed an issue that `#[project]` on non-statement expression does not work without unstable features.][197]
 
@@ -367,7 +373,9 @@
 
 [149]: https://github.com/taiki-e/pin-project/pull/149
 
-## [0.4.3] - 2019-10-15 - YANKED
+## [0.4.3] - 2019-10-15
+
+**Note: This release has been yanked.** See [#148] for details.
 
 * [`#[pin_project]` can now interoperate with `#[cfg_attr()]`.][135]
 
@@ -377,22 +385,29 @@
 
 * Diagnostic improvements.
 
+[#148]: https://github.com/taiki-e/pin-project/pull/148
 [120]: https://github.com/taiki-e/pin-project/pull/120
 [135]: https://github.com/taiki-e/pin-project/pull/135
 
-## [0.4.2] - 2019-09-29 - YANKED
+## [0.4.2] - 2019-09-29
+
+**Note: This release has been yanked.** See [#148] for details.
 
 * [Fixed support for DSTs(Dynamically Sized Types).][113]
 
 [113]: https://github.com/taiki-e/pin-project/pull/113
 
-## [0.4.1] - 2019-09-26 - YANKED
+## [0.4.1] - 2019-09-26
+
+**Note: This release has been yanked.** See [#148] for details.
 
 * [Fixed an issue that caused an error when using `#[pin_project]` on a type that has `#[pin]` + `!Unpin` field with no generics or lifetime.][111]
 
 [111]: https://github.com/taiki-e/pin-project/pull/111
 
-## [0.4.0] - 2019-09-25 - YANKED
+## [0.4.0] - 2019-09-25
+
+**Note: This release has been yanked.** See [#148] for details.
 
 * [**Pin projection has become a safe operation.**][18] In the absence of other unsafe code that you write, it is impossible to cause undefined behavior.
 
@@ -481,6 +496,7 @@
 ## [0.4.0-alpha.9] - 2019-09-05
 
 * [Added 'project_into' method to `#[pin_project]` types][69]. This can be useful when returning a pin projection from a method.
+
   ```rust
   fn get_pin_mut(self: Pin<&mut Self>) -> Pin<&mut T> {
       self.project_into().pinned
@@ -565,10 +581,14 @@
 
 * Diagnostic improvements.
 
-## [0.3.3] - 2019-07-15 - YANKED
+## [0.3.3] - 2019-07-15
+
+**Note: This release has been yanked.** See [#16] for details.
 
 * Diagnostic improvements.
 
+[#16]: https://github.com/taiki-e/pin-project/issues/16
+
 ## [0.3.2] - 2019-03-30
 
 * Avoided suffixes on tuple index.
@@ -637,11 +657,14 @@
 
 * Renamed from `unsafe_pin_project` to `unsafe_project`.
 
-## [0.1.0] - 2019-01-08 - YANKED
+## [0.1.0] - 2019-01-08
+
+**Note: This release has been yanked.**
 
 Initial release
 
-[Unreleased]: https://github.com/taiki-e/pin-project/compare/v1.0.1...HEAD
+[Unreleased]: https://github.com/taiki-e/pin-project/compare/v1.0.2...HEAD
+[1.0.2]: https://github.com/taiki-e/pin-project/compare/v1.0.1...v1.0.2
 [1.0.1]: https://github.com/taiki-e/pin-project/compare/v1.0.0...v1.0.1
 [1.0.0]: https://github.com/taiki-e/pin-project/compare/v1.0.0-alpha.1...v1.0.0
 [1.0.0-alpha.1]: https://github.com/taiki-e/pin-project/compare/v0.4.23...v1.0.0-alpha.1
diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md
deleted file mode 100644
index 70c2090..0000000
--- a/CODE_OF_CONDUCT.md
+++ /dev/null
@@ -1,9 +0,0 @@
-# Code of Conduct
-
-This project adheres to the [Rust Code of Conduct].
-
-## Enforcement
-
-If you believe someone is violating the code of conduct, we ask that you report it by contacting taiki-e (te316e89@gmail.com).
-
-[Rust Code of Conduct]: https://www.rust-lang.org/policies/code-of-conduct
diff --git a/Cargo.toml b/Cargo.toml
index 5d73386..88db287 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -13,7 +13,7 @@
 [package]
 edition = "2018"
 name = "pin-project"
-version = "1.0.1"
+version = "1.0.2"
 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,7 +26,7 @@
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]
 [dependencies.pin-project-internal]
-version = "=1.0.1"
+version = "=1.0.2"
 default-features = false
 [dev-dependencies.pin-project-auxiliary-macro]
 version = "0"
diff --git a/Cargo.toml.orig b/Cargo.toml.orig
index ef428f0..7d31bb0 100644
--- a/Cargo.toml.orig
+++ b/Cargo.toml.orig
@@ -1,6 +1,6 @@
 [package]
 name = "pin-project"
-version = "1.0.1"
+version = "1.0.2"
 authors = ["Taiki Endo <te316e89@gmail.com>"]
 edition = "2018"
 license = "Apache-2.0 OR MIT"
@@ -29,7 +29,7 @@
 ]
 
 [dependencies]
-pin-project-internal = { version = "=1.0.1", path = "pin-project-internal", default-features = false }
+pin-project-internal = { version = "=1.0.2", path = "pin-project-internal", default-features = false }
 
 [dev-dependencies]
 pin-project-auxiliary-macro = { version = "0", path = "tests/auxiliary/macro" }
diff --git a/METADATA b/METADATA
index d4ac624..4490183 100644
--- a/METADATA
+++ b/METADATA
@@ -7,13 +7,13 @@
   }
   url {
     type: ARCHIVE
-    value: "https://static.crates.io/crates/pin-project/pin-project-1.0.1.crate"
+    value: "https://static.crates.io/crates/pin-project/pin-project-1.0.2.crate"
   }
-  version: "1.0.1"
+  version: "1.0.2"
   license_type: NOTICE
   last_upgrade_date {
     year: 2020
-    month: 10
-    day: 26
+    month: 11
+    day: 18
   }
 }
diff --git a/README.md b/README.md
index 0d5f5d7..689ec95 100644
--- a/README.md
+++ b/README.md
@@ -100,12 +100,7 @@
 
 ## License
 
-Licensed under either of
-
-* Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or <http://www.apache.org/licenses/LICENSE-2.0>)
-* MIT license ([LICENSE-MIT](LICENSE-MIT) or <http://opensource.org/licenses/MIT>)
-
-at your option.
+Licensed under either of [Apache License, Version 2.0](LICENSE-APACHE) or [MIT license](LICENSE-MIT) at your option.
 
 ### Contribution
 
diff --git a/ci/install-component.sh b/ci/install-component.sh
deleted file mode 100755
index dbba7b1..0000000
--- a/ci/install-component.sh
+++ /dev/null
@@ -1,27 +0,0 @@
-#!/bin/bash
-
-# Install nightly Rust with a given component.
-#
-# If the component is unavailable on the latest nightly,
-# use the latest toolchain with the component available.
-#
-# When using stable Rust, this script is basically unnecessary as almost components available.
-#
-# Refs: https://github.com/rust-lang/rustup-components-history#the-web-part
-
-set -euo pipefail
-
-package="${1:?}"
-target="${2:-x86_64-unknown-linux-gnu}"
-
-date=$(curl -sSf https://rust-lang.github.io/rustup-components-history/"${target}"/"${package}")
-
-# shellcheck disable=1090
-"$(cd "$(dirname "${0}")" && pwd)"/install-rust.sh nightly-"${date}"
-
-rustup component add "${package}"
-
-case "${package}" in
-    rustfmt) "${package}" -V ;;
-    *) cargo "${package}" -V ;;
-esac
diff --git a/ci/install-rust.sh b/ci/install-rust.sh
deleted file mode 100755
index 92c5877..0000000
--- a/ci/install-rust.sh
+++ /dev/null
@@ -1,12 +0,0 @@
-#!/bin/bash
-
-set -euo pipefail
-
-toolchain="${1:-nightly}"
-
-rustup toolchain install "${toolchain}" --no-self-update --profile minimal
-rustup default "${toolchain}"
-
-rustup -V
-rustc -V
-cargo -V
diff --git a/examples/enum-default-expanded.rs b/examples/enum-default-expanded.rs
index f234b51..2153592 100644
--- a/examples/enum-default-expanded.rs
+++ b/examples/enum-default-expanded.rs
@@ -45,10 +45,10 @@
         ) -> EnumProj<'pin, T, U> {
             unsafe {
                 match self.get_unchecked_mut() {
-                    Enum::Pinned(_0) => {
+                    Self::Pinned(_0) => {
                         EnumProj::Pinned(::pin_project::__private::Pin::new_unchecked(_0))
                     }
-                    Enum::Unpinned(_0) => EnumProj::Unpinned(_0),
+                    Self::Unpinned(_0) => EnumProj::Unpinned(_0),
                 }
             }
         }
diff --git a/rustfmt.toml b/rustfmt.toml
index 18c6d2a..75456c3 100644
--- a/rustfmt.toml
+++ b/rustfmt.toml
@@ -24,4 +24,6 @@
 # Set the default settings again to always apply the proper formatting without
 # being affected by the editor settings.
 edition = "2018"
+hard_tabs = false
+newline_style = "Unix"
 tab_spaces = 4
diff --git a/scripts/check-minimal-versions.sh b/scripts/check-minimal-versions.sh
index 6c7fa7b..56fadee 100755
--- a/scripts/check-minimal-versions.sh
+++ b/scripts/check-minimal-versions.sh
@@ -3,7 +3,7 @@
 # Check all public crates with minimal version dependencies.
 #
 # Usage:
-#    bash scripts/check-minimal-versions.sh
+#    bash scripts/check-minimal-versions.sh [+toolchain] [check|test]
 #
 # Note:
 # - This script modifies Cargo.toml and Cargo.lock while running
@@ -13,19 +13,34 @@
 # Refs: https://github.com/rust-lang/cargo/issues/5657
 
 set -euo pipefail
+IFS=$'\n\t'
 
 cd "$(cd "$(dirname "${0}")" && pwd)"/..
 
-if [[ "${1:-none}" == "+"* ]]; then
-    toolchain="${1}"
-elif [[ "${CI:-false}" != "true" ]]; then
-    cargo +nightly -V >/dev/null || exit 1
-    toolchain="+nightly"
+# Decide Rust toolchain.
+# Nightly is used by default if the `CI` environment variable is unset.
+if [[ "${1:-}" == "+"* ]]; then
+  toolchain="${1}"
+  shift
+elif [[ -z "${CI:-}" ]]; then
+  toolchain="+nightly"
+fi
+# Make sure toolchain is installed.
+cargo ${toolchain:-} -V >/dev/null
+# This script requires nightly Rust and cargo-hack
+if [[ "${toolchain:-+nightly}" != "+nightly"* ]] || ! cargo hack -V &>/dev/null; then
+  echo "error: check-minimal-versions.sh requires nightly Rust and cargo-hack"
+  exit 1
 fi
 
-if [[ "${toolchain:-+nightly}" != "+nightly"* ]] || ! cargo hack -V &>/dev/null; then
-    echo "error: check-minimal-versions.sh requires nightly Rust and cargo-hack"
-    exit 1
+# Parse subcommand.
+subcmd="${1:-check}"
+if [[ ! "${subcmd}" =~ ^(check|test)$ ]]; then
+  echo "error: invalid argument: ${1}"
+  exit 1
+elif [[ -n "${2:-}" ]]; then
+  echo "error: invalid argument: ${2}"
+  exit 1
 fi
 
 # This script modifies Cargo.toml and Cargo.lock, so make sure there are no
@@ -34,11 +49,13 @@
 # Restore original Cargo.toml and Cargo.lock on exit.
 trap 'git checkout .' EXIT
 
-# 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
+if [[ "${subcmd}" == "check" ]]; then
+  # 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
+fi
 
 # Update Cargo.lock to minimal version dependencies.
-cargo ${toolchain:-} update -Zminimal-versions
+cargo ${toolchain:-} update -Z minimal-versions
 # Run check for all public members of the workspace.
-cargo ${toolchain:-} hack check --workspace --all-features --ignore-private -Zfeatures=all
+cargo ${toolchain:-} hack "${subcmd}" --workspace --all-features --ignore-private -Z features=all
diff --git a/scripts/ci.sh b/scripts/ci.sh
index ec08568..b6a1a74 100755
--- a/scripts/ci.sh
+++ b/scripts/ci.sh
@@ -8,30 +8,30 @@
 # Note: This script requires nightly Rust, rustfmt, clippy, and cargo-expand
 
 set -euo pipefail
+IFS=$'\n\t'
 
-if [[ "${1:-none}" == "+"* ]]; then
-    toolchain="${1}"
-else
-    cargo +nightly -V >/dev/null || exit 1
-    toolchain="+nightly"
+# Decide Rust toolchain. Nightly is used by default.
+toolchain="+nightly"
+if [[ "${1:-}" == "+"* ]]; then
+  toolchain="${1}"
+  shift
 fi
+# Make sure toolchain is installed.
+cargo "${toolchain}" -V >/dev/null
 
 if [[ "${toolchain:-+nightly}" != "+nightly"* ]] || ! rustfmt -V &>/dev/null || ! cargo clippy -V &>/dev/null || ! cargo expand -V &>/dev/null; then
-    echo "error: ci.sh requires nightly Rust, rustfmt, clippy, and cargo-expand"
-    exit 1
+  echo "error: ci.sh requires nightly Rust, rustfmt, clippy, and cargo-expand"
+  exit 1
 fi
 
 echo "Running 'cargo ${toolchain} fmt --all'"
 cargo "${toolchain}" fmt --all
 
 echo "Running 'cargo ${toolchain} clippy --all --all-targets'"
-cargo "${toolchain}" clippy --all --all-features --all-targets -Zunstable-options
+cargo "${toolchain}" clippy --all --all-features --all-targets -Z unstable-options
 
-echo "Running 'cargo ${toolchain} test --all --exclude expandtest'"
-TRYBUILD=overwrite cargo "${toolchain}" test --all --all-features --exclude expandtest
-
-echo "Running 'bash scripts/expandtest.sh ${toolchain}'"
-"$(cd "$(dirname "${0}")" && pwd)"/expandtest.sh "${toolchain}"
+echo "Running 'cargo ${toolchain} test --all'"
+cargo "${toolchain}" test --all --all-features
 
 echo "Running 'cargo ${toolchain} doc --no-deps --all'"
 cargo "${toolchain}" doc --no-deps --all --all-features
diff --git a/scripts/expandtest.sh b/scripts/expandtest.sh
deleted file mode 100755
index 844ace6..0000000
--- a/scripts/expandtest.sh
+++ /dev/null
@@ -1,35 +0,0 @@
-#!/bin/bash
-
-# A script to run expandtest.
-#
-# Usage:
-#     bash scripts/expandtest.sh
-#
-# Note: This script requires nightly Rust, rustfmt, and cargo-expand
-
-set -euo pipefail
-
-script_dir="$(cd "$(dirname "${0}")" && pwd)"
-
-if [[ "${1:-none}" == "+"* ]]; then
-    toolchain="${1}"
-elif [[ "${CI:-false}" != "true" ]]; then
-    cargo +nightly -V >/dev/null || exit 1
-    toolchain="+nightly"
-fi
-
-if [[ "${toolchain:-+nightly}" != "+nightly"* ]] || ! rustfmt -V &>/dev/null || ! cargo expand -V &>/dev/null; then
-    echo "error: expandtest.sh requires nightly Rust, rustfmt, and cargo-expand"
-    exit 1
-fi
-
-if [[ "${CI:-false}" != "true" ]]; then
-    # First, check if the compile fails for another reason.
-    cargo ${toolchain} check --tests --manifest-path "${script_dir}"/../tests/expand/Cargo.toml
-
-    # Next, remove the `*.expanded.rs` files to allow updating those files.
-    # Refs: https://docs.rs/macrotest/1/macrotest/#updating-expandedrs
-    rm -rf "${script_dir}"/../tests/expand/tests/expand/*.expanded.rs
-fi
-
-cargo ${toolchain:-} test --manifest-path "${script_dir}"/../tests/expand/Cargo.toml
diff --git a/src/lib.rs b/src/lib.rs
index 016a0c7..39e8faa 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -65,7 +65,7 @@
 //! [struct-default-expanded]: https://github.com/taiki-e/pin-project/blob/master/examples/struct-default-expanded.rs
 
 #![no_std]
-#![doc(html_root_url = "https://docs.rs/pin-project/1.0.1")]
+#![doc(html_root_url = "https://docs.rs/pin-project/1.0.2")]
 #![doc(test(
     no_crate_inject,
     attr(deny(warnings, rust_2018_idioms, single_use_lifetimes), allow(dead_code))
@@ -73,11 +73,14 @@
 #![warn(future_incompatible, rust_2018_idioms, single_use_lifetimes, unreachable_pub)]
 #![warn(missing_docs)]
 #![warn(clippy::all, clippy::default_trait_access)]
-// mem::take and #[non_exhaustive] requires Rust 1.40, matches! requires Rust 1.42
+// mem::take, #[non_exhaustive], and Option::{as_deref, as_deref_mut} require Rust 1.40,
+// matches! requires Rust 1.42, str::{strip_prefix, strip_suffix} requires Rust 1.45
 #![allow(
     clippy::mem_replace_with_default,
     clippy::manual_non_exhaustive,
-    clippy::match_like_matches_macro
+    clippy::option_as_ref_deref,
+    clippy::match_like_matches_macro,
+    clippy::manual_strip
 )]
 #![allow(clippy::needless_doctest_main)]
 
diff --git a/src/lib.rs.orig b/src/lib.rs.orig
new file mode 100644
index 0000000..5750c2b
--- /dev/null
+++ b/src/lib.rs.orig
@@ -0,0 +1,288 @@
+//! A crate for safe and ergonomic [pin-projection].
+//!
+//! # Examples
+//!
+//! [`#[pin_project]`][`pin_project`] attribute creates projection types
+//! covering all the fields of struct or enum.
+//!
+//! ```rust
+//! use pin_project::pin_project;
+//! use std::pin::Pin;
+//!
+//! #[pin_project]
+//! struct Struct<T, U> {
+//!     #[pin]
+//!     pinned: T,
+//!     unpinned: U,
+//! }
+//!
+//! impl<T, U> Struct<T, U> {
+//!     fn 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
+//!     }
+//! }
+//! ```
+//!
+//! [*code like this will be generated*][struct-default-expanded]
+//!
+//! To use `#[pin_project]` on enums, you need to name the projection type
+//! returned from the method.
+//!
+//! ```rust
+//! use pin_project::pin_project;
+//! use std::pin::Pin;
+//!
+//! #[pin_project(project = EnumProj)]
+//! enum Enum<T, U> {
+//!     Pinned(#[pin] T),
+//!     Unpinned(U),
+//! }
+//!
+//! impl<T, U> Enum<T, U> {
+//!     fn method(self: Pin<&mut Self>) {
+//!         match self.project() {
+//!             EnumProj::Pinned(x) => {
+//!                 let _: Pin<&mut T> = x;
+//!             }
+//!             EnumProj::Unpinned(y) => {
+//!                 let _: &mut U = y;
+//!             }
+//!         }
+//!     }
+//! }
+//! ```
+//!
+//! [*code like this will be generated*][enum-default-expanded]
+//!
+//! See [`#[pin_project]`][`pin_project`] attribute for more details, and
+//! see [examples] directory for more examples and generated code.
+//!
+//! [examples]: https://github.com/taiki-e/pin-project/blob/master/examples/README.md
+//! [enum-default-expanded]: https://github.com/taiki-e/pin-project/blob/master/examples/enum-default-expanded.rs
+//! [pin-projection]: core::pin#projections-and-structural-pinning
+//! [struct-default-expanded]: https://github.com/taiki-e/pin-project/blob/master/examples/struct-default-expanded.rs
+
+#![no_std]
+#![doc(html_root_url = "https://docs.rs/pin-project/1.0.2")]
+#![doc(test(
+    no_crate_inject,
+    attr(deny(warnings, rust_2018_idioms, single_use_lifetimes), allow(dead_code))
+))]
+#![warn(future_incompatible, rust_2018_idioms, single_use_lifetimes, unreachable_pub)]
+#![warn(missing_docs)]
+#![warn(clippy::all, clippy::default_trait_access)]
+// mem::take, #[non_exhaustive], and Option::{as_deref, as_deref_mut} require Rust 1.40,
+// matches! requires Rust 1.42, str::{strip_prefix, strip_suffix} requires Rust 1.45
+#![allow(
+    clippy::mem_replace_with_default,
+    clippy::manual_non_exhaustive,
+    clippy::option_as_ref_deref,
+    clippy::match_like_matches_macro,
+    clippy::manual_strip
+)]
+#![allow(clippy::needless_doctest_main)]
+
+#[doc(inline)]
+pub use pin_project_internal::pin_project;
+
+#[doc(inline)]
+pub use pin_project_internal::pinned_drop;
+
+/// A trait used for custom implementations of [`Unpin`].
+///
+/// This trait is used in conjunction with the `UnsafeUnpin` argument to
+/// the [`#[pin_project]`][macro@pin_project] attribute.
+///
+/// The Rust [`Unpin`] trait is safe to implement - by itself,
+/// implementing it cannot lead to [undefined behavior][undefined-behavior].
+/// Undefined behavior can only occur when other unsafe code is used.
+///
+/// It turns out that using pin projections, which requires unsafe code,
+/// imposes additional requirements on an [`Unpin`] impl. Normally, all of this
+/// unsafety is contained within this crate, ensuring that it's impossible for
+/// you to violate any of the guarantees required by pin projection.
+///
+/// However, things change if you want to provide a custom [`Unpin`] impl
+/// for your `#[pin_project]` type. As stated in [the Rust
+/// documentation][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`] -
+/// this crate will generate an [`Unpin`] impl for your type that 'forwards' to
+/// your `UnsafeUnpin` impl. However, this trait is `unsafe` - since your type
+/// uses structural pinning (otherwise, you wouldn't be using this crate!),
+/// you must be sure that your `UnsafeUnpin` impls follows all of
+/// the requirements for an [`Unpin`] impl of a structurally-pinned type.
+///
+/// Note that if you specify `#[pin_project(UnsafeUnpin)]`, but do *not*
+/// provide an impl of `UnsafeUnpin`, your type will never implement [`Unpin`].
+/// This is effectively the same thing as adding a [`PhantomPinned`] to your
+/// type.
+///
+/// Since this trait is `unsafe`, impls of it will be detected by the
+/// `unsafe_code` lint, and by tools like [`cargo geiger`][cargo-geiger].
+///
+/// # Examples
+///
+/// An `UnsafeUnpin` impl which, in addition to requiring that structurally
+/// pinned fields be [`Unpin`], imposes an additional requirement:
+///
+/// ```rust
+/// use pin_project::{pin_project, UnsafeUnpin};
+///
+/// #[pin_project(UnsafeUnpin)]
+/// struct Struct<K, V> {
+///     #[pin]
+///     field_1: K,
+///     field_2: V,
+/// }
+///
+/// unsafe impl<K, V> UnsafeUnpin for Struct<K, V> where K: Unpin + Clone {}
+/// ```
+///
+/// [`PhantomPinned`]: core::marker::PhantomPinned
+/// [cargo-geiger]: https://github.com/rust-secure-code/cargo-geiger
+/// [pin-projection]: core::pin#projections-and-structural-pinning
+/// [undefined-behavior]: https://doc.rust-lang.org/reference/behavior-considered-undefined.html
+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;
+
+    #[doc(hidden)]
+    pub use pin_project_internal::__PinProjectInternalDerive;
+
+    // An internal trait used for custom implementations of [`Drop`].
+    //
+    // **Do not call or implement this trait directly.**
+    //
+    // # Why this trait is private and `#[pinned_drop]` attribute is needed?
+    //
+    // Implementing `PinnedDrop::drop` is safe, but calling it is not safe.
+    // This is because destructors can be called multiple times in safe code and
+    // [double dropping is unsound][rust-lang/rust#62360].
+    //
+    // Ideally, it would be desirable to be able to forbid manual calls in
+    // the same way as [`Drop::drop`], but the library cannot do it. So, by using
+    // macros and replacing them with private traits,
+    // this crate prevent users from calling `PinnedDrop::drop` in safe code.
+    //
+    // This allows implementing [`Drop`] safely using `#[pinned_drop]`.
+    // Also by using the [`drop`] function just like dropping a type that directly
+    // implements [`Drop`], can drop safely a type that implements `PinnedDrop`.
+    //
+    // [rust-lang/rust#62360]: https://github.com/rust-lang/rust/pull/62360
+    #[doc(hidden)]
+    pub trait PinnedDrop {
+        #[doc(hidden)]
+        unsafe fn drop(self: Pin<&mut Self>);
+    }
+
+    // This is an internal helper struct used by `pin-project-internal`.
+    // This allows us to force an error if the user tries to provide
+    // a regular `Unpin` impl when they specify the `UnsafeUnpin` argument.
+    // This is why we need Wrapper:
+    //
+    // Supposed we have the following code:
+    //
+    // ```rust
+    // #[pin_project(UnsafeUnpin)]
+    // struct MyStruct<T> {
+    //     #[pin] field: T
+    // }
+    //
+    // impl<T> Unpin for MyStruct<T> where MyStruct<T>: UnsafeUnpin {} // generated by pin-project-internal
+    // impl<T> Unpin for MyStruct<T> where T: Copy // written by the user
+    // ```
+    //
+    // We want this code to be rejected - the user is completely bypassing
+    // `UnsafeUnpin`, and providing an unsound Unpin impl in safe code!
+    //
+    // Unfortunately, the Rust compiler will accept the above code.
+    // Because MyStruct is declared in the same crate as the user-provided impl,
+    // the compiler will notice that `MyStruct<T>: UnsafeUnpin` never holds.
+    //
+    // The solution is to introduce the `Wrapper` struct, which is defined
+    // in the `pin-project` crate.
+    //
+    // We now have code that looks like this:
+    //
+    // ```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.
+    //
+    // Now, our generated impl has a bound involving a type defined in another
+    // crate - Wrapper. This will cause rust to conservatively assume that
+    // `Wrapper<MyStruct<T>>: UnsafeUnpin` holds, in the interest of preserving
+    // forwards compatibility (in case such an impl is added for Wrapper<T> in
+    // a new version of the crate).
+    //
+    // This will cause rust to reject any other `Unpin` impls for MyStruct<T>,
+    // since it will assume that our generated impl could potentially apply in
+    // any situation.
+    //
+    // This achieves the desired effect - when the user writes
+    // `#[pin_project(UnsafeUnpin)]`, the user must either provide no impl of
+    // `UnsafeUnpin` (which is equivalent to making the type never implement
+    // Unpin), or provide an impl of `UnsafeUnpin`. It is impossible for them to
+    // provide an impl of `Unpin`
+    #[doc(hidden)]
+    pub struct Wrapper<'a, T: ?Sized>(PhantomData<&'a ()>, T);
+
+    unsafe impl<T: ?Sized> UnsafeUnpin for Wrapper<'_, T> where T: UnsafeUnpin {}
+
+    // This is an internal helper struct used by `pin-project-internal`.
+    //
+    // See https://github.com/taiki-e/pin-project/pull/53 for more details.
+    #[doc(hidden)]
+    pub struct AlwaysUnpin<'a, T>(PhantomData<&'a ()>, PhantomData<T>);
+
+    impl<T> Unpin for AlwaysUnpin<'_, T> {}
+
+    // This is an internal helper used to ensure a value is dropped.
+    #[doc(hidden)]
+    pub struct UnsafeDropInPlaceGuard<T: ?Sized>(pub *mut T);
+
+    impl<T: ?Sized> Drop for UnsafeDropInPlaceGuard<T> {
+        fn drop(&mut self) {
+            unsafe {
+                ptr::drop_in_place(self.0);
+            }
+        }
+    }
+
+    // This is an internal helper used to ensure a value is overwritten without
+    // its destructor being called.
+    #[doc(hidden)]
+    pub struct UnsafeOverwriteGuard<T> {
+        pub value: ManuallyDrop<T>,
+        pub target: *mut T,
+    }
+
+    impl<T> Drop for UnsafeOverwriteGuard<T> {
+        fn drop(&mut self) {
+            unsafe {
+                ptr::write(self.target, ptr::read(&*self.value));
+            }
+        }
+    }
+}
diff --git a/tests/cfg.rs b/tests/cfg.rs
index 9fde697..2fdcfbb 100644
--- a/tests/cfg.rs
+++ b/tests/cfg.rs
@@ -37,9 +37,9 @@
     assert_unpin!(SameName);
 
     #[cfg(target_os = "linux")]
-    let _x = SameName { inner: Linux };
+    let _ = SameName { inner: Linux };
     #[cfg(not(target_os = "linux"))]
-    let _x = SameName { inner: Other };
+    let _ = SameName { inner: Other };
 
     #[pin_project(project_replace)]
     struct DifferentName {
@@ -57,9 +57,9 @@
     assert_unpin!(DifferentName);
 
     #[cfg(target_os = "linux")]
-    let _x = DifferentName { l: Linux };
+    let _ = DifferentName { l: Linux };
     #[cfg(not(target_os = "linux"))]
-    let _x = DifferentName { o: Other };
+    let _ = DifferentName { o: Other };
 
     #[pin_project(project_replace)]
     struct TupleStruct(
@@ -77,9 +77,9 @@
     assert_unpin!(TupleStruct);
 
     #[cfg(target_os = "linux")]
-    let _x = TupleStruct(Linux);
+    let _ = TupleStruct(Linux);
     #[cfg(not(target_os = "linux"))]
-    let _x = TupleStruct(Other);
+    let _ = TupleStruct(Other);
 
     // enums
 
@@ -105,14 +105,14 @@
     assert_unpin!(Variant);
 
     #[cfg(target_os = "linux")]
-    let _x = Variant::Inner(Linux);
+    let _ = Variant::Inner(Linux);
     #[cfg(not(target_os = "linux"))]
-    let _x = Variant::Inner(Other);
+    let _ = Variant::Inner(Other);
 
     #[cfg(target_os = "linux")]
-    let _x = Variant::Linux(Linux);
+    let _ = Variant::Linux(Linux);
     #[cfg(not(target_os = "linux"))]
-    let _x = Variant::Other(Other);
+    let _ = Variant::Other(Other);
 
     #[pin_project(
         project = FieldProj,
@@ -158,19 +158,19 @@
     assert_unpin!(Field);
 
     #[cfg(target_os = "linux")]
-    let _x = Field::SameName { inner: Linux };
+    let _ = Field::SameName { inner: Linux };
     #[cfg(not(target_os = "linux"))]
-    let _x = Field::SameName { inner: Other };
+    let _ = Field::SameName { inner: Other };
 
     #[cfg(target_os = "linux")]
-    let _x = Field::DifferentName { l: Linux };
+    let _ = Field::DifferentName { l: Linux };
     #[cfg(not(target_os = "linux"))]
-    let _x = Field::DifferentName { w: Other };
+    let _ = Field::DifferentName { w: Other };
 
     #[cfg(target_os = "linux")]
-    let _x = Field::TupleVariant(Linux);
+    let _ = Field::TupleVariant(Linux);
     #[cfg(not(target_os = "linux"))]
-    let _x = Field::TupleVariant(Other);
+    let _ = Field::TupleVariant(Other);
 }
 
 #[test]
diff --git a/tests/compiletest.rs b/tests/compiletest.rs
index be01ba8..057df7c 100644
--- a/tests/compiletest.rs
+++ b/tests/compiletest.rs
@@ -1,9 +1,16 @@
 #![cfg(not(miri))]
 #![warn(rust_2018_idioms, single_use_lifetimes)]
 
-#[rustversion::attr(not(nightly), ignore)]
+use std::env;
+
+// Run `./dev.sh +$toolchain test --test compiletest` to update this.
+#[rustversion::attr(before(2020-10-28), ignore)] // Note: This date is commit-date and the day before the toolchain date.
 #[test]
 fn ui() {
+    if env::var_os("CI").is_none() {
+        env::set_var("TRYBUILD", "overwrite");
+    }
+
     let t = trybuild::TestCases::new();
     t.compile_fail("tests/ui/cfg/*.rs");
     t.compile_fail("tests/ui/not_unpin/*.rs");
diff --git a/tests/drop_order.rs b/tests/drop_order.rs
index 1931b68..1557188 100644
--- a/tests/drop_order.rs
+++ b/tests/drop_order.rs
@@ -38,12 +38,14 @@
 
 #[pin_project(project_replace = EnumProj)]
 enum Enum<'a> {
+    #[allow(dead_code)] // false positive that fixed in Rust 1.38
     StructPinned {
         #[pin]
         f1: D<'a>,
         #[pin]
         f2: D<'a>,
     },
+    #[allow(dead_code)] // false positive that fixed in Rust 1.38
     StructUnpinned {
         f1: D<'a>,
         f2: D<'a>,
@@ -60,9 +62,9 @@
     }
     {
         let c = Cell::new(0);
-        let mut _x = StructPinned { f1: D(&c, 1), f2: D(&c, 2) };
-        let _y = Pin::new(&mut _x);
-        let _z = _y.project_replace(StructPinned { f1: D(&c, 3), f2: D(&c, 4) });
+        let mut x = StructPinned { f1: D(&c, 1), f2: D(&c, 2) };
+        let y = Pin::new(&mut x);
+        let _z = y.project_replace(StructPinned { f1: D(&c, 3), f2: D(&c, 4) });
     }
 }
 
@@ -74,9 +76,9 @@
     }
     {
         let c = Cell::new(0);
-        let mut _x = StructUnpinned { f1: D(&c, 1), f2: D(&c, 2) };
-        let _y = Pin::new(&mut _x);
-        let _z = _y.project_replace(StructUnpinned { f1: D(&c, 3), f2: D(&c, 4) });
+        let mut x = StructUnpinned { f1: D(&c, 1), f2: D(&c, 2) };
+        let y = Pin::new(&mut x);
+        let _z = y.project_replace(StructUnpinned { f1: D(&c, 3), f2: D(&c, 4) });
     }
 }
 
@@ -88,9 +90,9 @@
     }
     {
         let c = Cell::new(0);
-        let mut _x = TuplePinned(D(&c, 1), D(&c, 2));
-        let _y = Pin::new(&mut _x);
-        let _z = _y.project_replace(TuplePinned(D(&c, 3), D(&c, 4)));
+        let mut x = TuplePinned(D(&c, 1), D(&c, 2));
+        let y = Pin::new(&mut x);
+        let _z = y.project_replace(TuplePinned(D(&c, 3), D(&c, 4)));
     }
 }
 
@@ -102,9 +104,9 @@
     }
     {
         let c = Cell::new(0);
-        let mut _x = TupleUnpinned(D(&c, 1), D(&c, 2));
-        let _y = Pin::new(&mut _x);
-        let _z = _y.project_replace(TupleUnpinned(D(&c, 3), D(&c, 4)));
+        let mut x = TupleUnpinned(D(&c, 1), D(&c, 2));
+        let y = Pin::new(&mut x);
+        let _z = y.project_replace(TupleUnpinned(D(&c, 3), D(&c, 4)));
     }
 }
 
@@ -116,9 +118,9 @@
     }
     {
         let c = Cell::new(0);
-        let mut _x = Enum::StructPinned { f1: D(&c, 1), f2: D(&c, 2) };
-        let _y = Pin::new(&mut _x);
-        let _z = _y.project_replace(Enum::StructPinned { f1: D(&c, 3), f2: D(&c, 4) });
+        let mut x = Enum::StructPinned { f1: D(&c, 1), f2: D(&c, 2) };
+        let y = Pin::new(&mut x);
+        let _z = y.project_replace(Enum::StructPinned { f1: D(&c, 3), f2: D(&c, 4) });
     }
 
     {
@@ -127,9 +129,9 @@
     }
     {
         let c = Cell::new(0);
-        let mut _x = Enum::StructUnpinned { f1: D(&c, 1), f2: D(&c, 2) };
-        let _y = Pin::new(&mut _x);
-        let _z = _y.project_replace(Enum::StructUnpinned { f1: D(&c, 3), f2: D(&c, 4) });
+        let mut x = Enum::StructUnpinned { f1: D(&c, 1), f2: D(&c, 2) };
+        let y = Pin::new(&mut x);
+        let _z = y.project_replace(Enum::StructUnpinned { f1: D(&c, 3), f2: D(&c, 4) });
     }
 }
 
@@ -141,9 +143,9 @@
     }
     {
         let c = Cell::new(0);
-        let mut _x = Enum::TuplePinned(D(&c, 1), D(&c, 2));
-        let _y = Pin::new(&mut _x);
-        let _z = _y.project_replace(Enum::TuplePinned(D(&c, 3), D(&c, 4)));
+        let mut x = Enum::TuplePinned(D(&c, 1), D(&c, 2));
+        let y = Pin::new(&mut x);
+        let _z = y.project_replace(Enum::TuplePinned(D(&c, 3), D(&c, 4)));
     }
 
     {
@@ -152,8 +154,8 @@
     }
     {
         let c = Cell::new(0);
-        let mut _x = Enum::TupleUnpinned(D(&c, 1), D(&c, 2));
-        let _y = Pin::new(&mut _x);
-        let _z = _y.project_replace(Enum::TupleUnpinned(D(&c, 3), D(&c, 4)));
+        let mut x = Enum::TupleUnpinned(D(&c, 1), D(&c, 2));
+        let y = Pin::new(&mut x);
+        let _z = y.project_replace(Enum::TupleUnpinned(D(&c, 3), D(&c, 4)));
     }
 }
diff --git a/tests/include/basic-safe-part.rs b/tests/include/basic-safe-part.rs
index c8d24bd..0b7c43e 100644
--- a/tests/include/basic-safe-part.rs
+++ b/tests/include/basic-safe-part.rs
@@ -8,11 +8,29 @@
     pub unpinned: U,
 }
 
+#[::pin_project::pin_project(
+    project = DefaultStructNamedProj,
+    project_ref = DefaultStructNamedProjRef,
+)]
+#[derive(Debug)]
+pub struct DefaultStructNamed<T, U> {
+    #[pin]
+    pub pinned: T,
+    pub unpinned: U,
+}
+
 #[::pin_project::pin_project]
 #[derive(Debug)]
 pub struct DefaultTupleStruct<T, U>(#[pin] pub T, pub U);
 
 #[::pin_project::pin_project(
+    project = DefaultTupleStructNamedProj,
+    project_ref = DefaultTupleStructNamedProjRef,
+)]
+#[derive(Debug)]
+pub struct DefaultTupleStructNamed<T, U>(#[pin] pub T, pub U);
+
+#[::pin_project::pin_project(
     project = DefaultEnumProj,
     project_ref = DefaultEnumProjRef,
 )]
@@ -78,11 +96,31 @@
     pub unpinned: U,
 }
 
+#[::pin_project::pin_project(
+    project = ReplaceStructNamedProj,
+    project_ref = ReplaceStructNamedProjRef,
+    project_replace = ReplaceStructNamedProjOwn,
+)]
+#[derive(Debug)]
+pub struct ReplaceStructNamed<T, U> {
+    #[pin]
+    pub pinned: T,
+    pub unpinned: U,
+}
+
 #[::pin_project::pin_project(project_replace)]
 #[derive(Debug)]
 pub struct ReplaceTupleStruct<T, U>(#[pin] pub T, pub U);
 
 #[::pin_project::pin_project(
+    project = ReplaceTupleStructNamedProj,
+    project_ref = ReplaceTupleStructNamedProjRef,
+    project_replace = ReplaceTupleStructNamedProjOwn,
+)]
+#[derive(Debug)]
+pub struct ReplaceTupleStructNamed<T, U>(#[pin] pub T, pub U);
+
+#[::pin_project::pin_project(
     project = ReplaceEnumProj,
     project_ref = ReplaceEnumProjRef,
     project_replace = ReplaceEnumProjOwn,
diff --git a/tests/lint.rs b/tests/lint.rs
index 86cb121..c7f1380 100644
--- a/tests/lint.rs
+++ b/tests/lint.rs
@@ -54,11 +54,29 @@
                     pub unpinned: U,
                 }
 
+                #[::pin_project::pin_project(
+                    project = DefaultStructNamedProj,
+                    project_ref = DefaultStructNamedProjRef,
+                )]
+                #[derive(Debug)]
+                pub struct DefaultStructNamed<T, U> {
+                    #[pin]
+                    pub pinned: T,
+                    pub unpinned: U,
+                }
+
                 #[::pin_project::pin_project]
                 #[derive(Debug)]
                 pub struct DefaultTupleStruct<T, U>(#[pin] pub T, pub U);
 
                 #[::pin_project::pin_project(
+                    project = DefaultTupleStructNamedProj,
+                    project_ref = DefaultTupleStructNamedProjRef,
+                )]
+                #[derive(Debug)]
+                pub struct DefaultTupleStructNamed<T, U>(#[pin] pub T, pub U);
+
+                #[::pin_project::pin_project(
                     project = DefaultEnumProj,
                     project_ref = DefaultEnumProjRef,
                 )]
@@ -124,11 +142,31 @@
                     pub unpinned: U,
                 }
 
+                #[::pin_project::pin_project(
+                    project = ReplaceStructNamedProj,
+                    project_ref = ReplaceStructNamedProjRef,
+                    project_replace = ReplaceStructNamedProjOwn,
+                )]
+                #[derive(Debug)]
+                pub struct ReplaceStructNamed<T, U> {
+                    #[pin]
+                    pub pinned: T,
+                    pub unpinned: U,
+                }
+
                 #[::pin_project::pin_project(project_replace)]
                 #[derive(Debug)]
                 pub struct ReplaceTupleStruct<T, U>(#[pin] pub T, pub U);
 
                 #[::pin_project::pin_project(
+                    project = ReplaceTupleStructNamedProj,
+                    project_ref = ReplaceTupleStructNamedProjRef,
+                    project_replace = ReplaceTupleStructNamedProjOwn,
+                )]
+                #[derive(Debug)]
+                pub struct ReplaceTupleStructNamed<T, U>(#[pin] pub T, pub U);
+
+                #[::pin_project::pin_project(
                     project = ReplaceEnumProj,
                     project_ref = ReplaceEnumProjRef,
                     project_replace = ReplaceEnumProjOwn,
@@ -223,6 +261,207 @@
     #![forbid(unsafe_code)]
 
     include!("include/basic-safe-part.rs");
+
+    pub mod inside_macro {
+        #[rustfmt::skip]
+        macro_rules! mac {
+            () => {
+                #[::pin_project::pin_project]
+                #[derive(Debug)]
+                pub struct DefaultStruct<T, U> {
+                    #[pin]
+                    pub pinned: T,
+                    pub unpinned: U,
+                }
+
+                #[::pin_project::pin_project(
+                    project = DefaultStructNamedProj,
+                    project_ref = DefaultStructNamedProjRef,
+                )]
+                #[derive(Debug)]
+                pub struct DefaultStructNamed<T, U> {
+                    #[pin]
+                    pub pinned: T,
+                    pub unpinned: U,
+                }
+
+                #[::pin_project::pin_project]
+                #[derive(Debug)]
+                pub struct DefaultTupleStruct<T, U>(#[pin] pub T, pub U);
+
+                #[::pin_project::pin_project(
+                    project = DefaultTupleStructNamedProj,
+                    project_ref = DefaultTupleStructNamedProjRef,
+                )]
+                #[derive(Debug)]
+                pub struct DefaultTupleStructNamed<T, U>(#[pin] pub T, pub U);
+
+                #[::pin_project::pin_project(
+                    project = DefaultEnumProj,
+                    project_ref = DefaultEnumProjRef,
+                )]
+                #[derive(Debug)]
+                pub enum DefaultEnum<T, U> {
+                    Struct {
+                        #[pin]
+                        pinned: T,
+                        unpinned: U,
+                    },
+                    Tuple(#[pin] T, U),
+                    Unit,
+                }
+
+                #[::pin_project::pin_project(PinnedDrop)]
+                #[derive(Debug)]
+                pub struct PinnedDropStruct<T, U> {
+                    #[pin]
+                    pub pinned: T,
+                    pub unpinned: U,
+                }
+
+                #[::pin_project::pinned_drop]
+                impl<T, U> PinnedDrop for PinnedDropStruct<T, U> {
+                    fn drop(self: ::pin_project::__private::Pin<&mut Self>) {}
+                }
+
+                #[::pin_project::pin_project(PinnedDrop)]
+                #[derive(Debug)]
+                pub struct PinnedDropTupleStruct<T, U>(#[pin] pub T, pub U);
+
+                #[::pin_project::pinned_drop]
+                impl<T, U> PinnedDrop for PinnedDropTupleStruct<T, U> {
+                    fn drop(self: ::pin_project::__private::Pin<&mut Self>) {}
+                }
+
+                #[::pin_project::pin_project(
+                    PinnedDrop,
+                    project = PinnedDropEnumProj,
+                    project_ref = PinnedDropEnumProjRef,
+                )]
+                #[derive(Debug)]
+                pub enum PinnedDropEnum<T, U> {
+                    Struct {
+                        #[pin]
+                        pinned: T,
+                        unpinned: U,
+                    },
+                    Tuple(#[pin] T, U),
+                    Unit,
+                }
+
+                #[::pin_project::pinned_drop]
+                impl<T, U> PinnedDrop for PinnedDropEnum<T, U> {
+                    fn drop(self: ::pin_project::__private::Pin<&mut Self>) {}
+                }
+
+                #[::pin_project::pin_project(project_replace)]
+                #[derive(Debug)]
+                pub struct ReplaceStruct<T, U> {
+                    #[pin]
+                    pub pinned: T,
+                    pub unpinned: U,
+                }
+
+                #[::pin_project::pin_project(
+                    project = ReplaceStructNamedProj,
+                    project_ref = ReplaceStructNamedProjRef,
+                    project_replace = ReplaceStructNamedProjOwn,
+                )]
+                #[derive(Debug)]
+                pub struct ReplaceStructNamed<T, U> {
+                    #[pin]
+                    pub pinned: T,
+                    pub unpinned: U,
+                }
+
+                #[::pin_project::pin_project(project_replace)]
+                #[derive(Debug)]
+                pub struct ReplaceTupleStruct<T, U>(#[pin] pub T, pub U);
+
+                #[::pin_project::pin_project(
+                    project = ReplaceTupleStructNamedProj,
+                    project_ref = ReplaceTupleStructNamedProjRef,
+                    project_replace = ReplaceTupleStructNamedProjOwn,
+                )]
+                #[derive(Debug)]
+                pub struct ReplaceTupleStructNamed<T, U>(#[pin] pub T, pub U);
+
+                #[::pin_project::pin_project(
+                    project = ReplaceEnumProj,
+                    project_ref = ReplaceEnumProjRef,
+                    project_replace = ReplaceEnumProjOwn,
+                )]
+                #[derive(Debug)]
+                pub enum ReplaceEnum<T, U> {
+                    Struct {
+                        #[pin]
+                        pinned: T,
+                        unpinned: U,
+                    },
+                    Tuple(#[pin] T, U),
+                    Unit,
+                }
+
+                #[::pin_project::pin_project(UnsafeUnpin)]
+                #[derive(Debug)]
+                pub struct UnsafeUnpinStruct<T, U> {
+                    #[pin]
+                    pub pinned: T,
+                    pub unpinned: U,
+                }
+
+                #[::pin_project::pin_project(UnsafeUnpin)]
+                #[derive(Debug)]
+                pub struct UnsafeUnpinTupleStruct<T, U>(#[pin] pub T, pub U);
+
+                #[::pin_project::pin_project(
+                    UnsafeUnpin,
+                    project = UnsafeUnpinEnumProj,
+                    project_ref = UnsafeUnpinEnumProjRef,
+                )]
+                #[derive(Debug)]
+                pub enum UnsafeUnpinEnum<T, U> {
+                    Struct {
+                        #[pin]
+                        pinned: T,
+                        unpinned: U,
+                    },
+                    Tuple(#[pin] T, U),
+                    Unit,
+                }
+
+                #[::pin_project::pin_project(!Unpin)]
+                #[derive(Debug)]
+                pub struct NotUnpinStruct<T, U> {
+                    #[pin]
+                    pub pinned: T,
+                    pub unpinned: U,
+                }
+
+                #[::pin_project::pin_project(!Unpin)]
+                #[derive(Debug)]
+                pub struct NotUnpinTupleStruct<T, U>(#[pin] pub T, pub U);
+
+                #[::pin_project::pin_project(
+                    !Unpin,
+                    project = NotUnpinEnumProj,
+                    project_ref = NotUnpinEnumProjRef,
+                )]
+                #[derive(Debug)]
+                pub enum NotUnpinEnum<T, U> {
+                    Struct {
+                        #[pin]
+                        pinned: T,
+                        unpinned: U,
+                    },
+                    Tuple(#[pin] T, U),
+                    Unit,
+                }
+            };
+        }
+
+        mac!();
+    }
 }
 
 pub mod box_pointers {
@@ -782,32 +1021,34 @@
     }
 }
 
+// Run `./dev.sh +$toolchain test --test lint` to update this.
 #[cfg(not(miri))]
 #[allow(box_pointers)]
 #[allow(clippy::restriction)]
-#[rustversion::attr(not(nightly), ignore)]
+#[rustversion::attr(before(2020-11-08), ignore)] // Note: This date is commit-date and the day before the toolchain date.
 #[test]
 fn check_lint_list() {
-    use std::{env, fs, path::PathBuf, process::Command, str};
+    use std::{env, fs, path::Path, process::Command, str};
 
     type Result<T, E = Box<dyn std::error::Error>> = std::result::Result<T, E>;
 
     fn assert_eq(expected_path: &str, actual: &str) -> Result<()> {
-        let manifest_dir = env::var_os("CARGO_MANIFEST_DIR")
-            .map(PathBuf::from)
-            .expect("CARGO_MANIFEST_DIR not set");
-        let expected_path = manifest_dir.join(expected_path);
-        let expected = fs::read_to_string(&expected_path)?;
+        let manifest_dir = Path::new(env!("CARGO_MANIFEST_DIR"));
+        let expected_path = &manifest_dir.join(expected_path);
+        let expected = fs::read_to_string(expected_path)?;
         if expected != actual {
-            if env::var_os("CI").map_or(false, |v| v == "true") {
-                panic!(
-                    "assertion failed:\n\nEXPECTED:\n{0}\n{1}\n{0}\n\nACTUAL:\n{0}\n{2}\n{0}\n",
-                    "-".repeat(60),
-                    expected,
-                    actual,
-                );
+            if env::var_os("CI").is_some() {
+                let actual_path =
+                    &manifest_dir.join("target").join(expected_path.file_name().unwrap());
+                fs::write(actual_path, actual)?;
+                let status = Command::new("git")
+                    .args(&["--no-pager", "diff", "--no-index", "--"])
+                    .args(&[expected_path, actual_path])
+                    .status()?;
+                assert!(!status.success());
+                panic!("assertion failed");
             } else {
-                fs::write(&expected_path, actual)?;
+                fs::write(expected_path, actual)?;
             }
         }
         Ok(())
diff --git a/tests/lint.txt b/tests/lint.txt
index e4c9f98..a258fb8 100644
--- a/tests/lint.txt
+++ b/tests/lint.txt
@@ -59,6 +59,7 @@
                                                 drop-bounds  warn     bounds of the form `T: Drop` are useless
                           ellipsis-inclusive-range-patterns  warn     `...` range patterns are deprecated
                               exported-private-dependencies  warn     public interface leaks type from a private dependency
+                                   function-item-references  warn     suggest casting to a function pointer when attempting to take references to function items
                      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
                                 improper-ctypes-definitions  warn     proper use of libc types in foreign item definitions
@@ -72,6 +73,7 @@
                                    mixed-script-confusables  warn     detects Unicode scripts whose mixed script confusables codepoints are solely used
                         mutable-borrow-reservation-conflict  warn     reservation of a two-phased borrow conflicts with other shared borrows
                                 nontrivial-structural-match  warn     constant used in pattern of non-structural-match type and the constant's initializer expression contains values of non-structural-match types
+                                              non-autolinks  warn     detects URLs that could be written using only angle brackets
                                        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
@@ -79,17 +81,20 @@
                                     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-intra-doc-links  warn     linking from a public item to a private one
                                           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
+                                   temporary-cstring-as-ptr  warn     detects getting the inner pointer of a temporary `CString`
                                              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
+                                         uninhabited-static  warn     uninhabited static
                                               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
@@ -130,6 +135,7 @@
                                               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
+                                         useless-deprecated  deny     detects deprecation attributes with no effect
 
 
 Lint groups provided by rustc:
@@ -137,11 +143,11 @@
                        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, 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, pointer-structural-match, nontrivial-structural-match, soft-unstable, cenum-impl-drop-cast, const-evaluatable-unchecked, array-into-iter
+        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, 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, pointer-structural-match, nontrivial-structural-match, soft-unstable, cenum-impl-drop-cast, const-evaluatable-unchecked, uninhabited-static, 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  broken-intra-doc-links, private-intra-doc-links, invalid-codeblock-attributes, missing-doc-code-examples, private-doc-tests, invalid-html-tags
+                    rustdoc  non-autolinks, broken-intra-doc-links, private-intra-doc-links, invalid-codeblock-attributes, missing-doc-code-examples, private-doc-tests, invalid-html-tags
                      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
 
 
diff --git a/tests/pin_project.rs b/tests/pin_project.rs
index d9c37e5..17dbd2a 100644
--- a/tests/pin_project.rs
+++ b/tests/pin_project.rs
@@ -28,31 +28,34 @@
     let mut s_orig = Pin::new(&mut s);
     let s = s_orig.as_mut().project();
 
-    let x: Pin<&mut i32> = s.f1;
-    assert_eq!(*x, 1);
-    let y: &mut i32 = s.f2;
-    assert_eq!(*y, 2);
+    let _: Pin<&mut i32> = s.f1;
+    assert_eq!(*s.f1, 1);
+    let _: &mut i32 = s.f2;
+    assert_eq!(*s.f2, 2);
 
     assert_eq!(s_orig.as_ref().f1, 1);
     assert_eq!(s_orig.as_ref().f2, 2);
 
     let mut s = Struct { f1: 1, f2: 2 };
-
-    let StructProj { f1, f2 } = Pin::new(&mut s).project();
-    let _: Pin<&mut i32> = f1;
-    let _: &mut i32 = f2;
-
-    let StructProjRef { f1, f2 } = Pin::new(&s).project_ref();
-    let _: Pin<&i32> = f1;
-    let _: &i32 = f2;
-
     let mut s = Pin::new(&mut s);
-    let StructProjOwn { f1, f2 } = s.as_mut().project_replace(Struct { f1: 3, f2: 4 });
-    let _: PhantomData<i32> = f1;
-    let _: i32 = f2;
-    assert_eq!(f2, 2);
-    assert_eq!(s.f1, 3);
-    assert_eq!(s.f2, 4);
+    {
+        let StructProj { f1, f2 } = s.as_mut().project();
+        let _: Pin<&mut i32> = f1;
+        let _: &mut i32 = f2;
+    }
+    {
+        let StructProjRef { f1, f2 } = s.as_ref().project_ref();
+        let _: Pin<&i32> = f1;
+        let _: &i32 = f2;
+    }
+    {
+        let StructProjOwn { f1, f2 } = s.as_mut().project_replace(Struct { f1: 3, f2: 4 });
+        let _: PhantomData<i32> = f1;
+        let _: i32 = f2;
+        assert_eq!(f2, 2);
+        assert_eq!(s.f1, 3);
+        assert_eq!(s.f2, 4);
+    }
 
     #[pin_project(project_replace)]
     struct TupleStruct<T, U>(#[pin] T, U);
@@ -60,10 +63,10 @@
     let mut s = TupleStruct(1, 2);
     let s = Pin::new(&mut s).project();
 
-    let x: Pin<&mut i32> = s.0;
-    assert_eq!(*x, 1);
-    let y: &mut i32 = s.1;
-    assert_eq!(*y, 2);
+    let _: Pin<&mut i32> = s.0;
+    assert_eq!(*s.0, 1);
+    let _: &mut i32 = s.1;
+    assert_eq!(*s.1, 2);
 
     #[pin_project(project = EnumProj, project_ref = EnumProjRef, project_replace = EnumProjOwn)]
     #[derive(Eq, PartialEq, Debug)]
@@ -78,10 +81,9 @@
     }
 
     let mut e = Enum::Tuple(1, 2);
-    let mut e_orig = Pin::new(&mut e);
-    let e = e_orig.as_mut().project();
+    let mut e = Pin::new(&mut e);
 
-    match e {
+    match e.as_mut().project() {
         EnumProj::Tuple(x, y) => {
             let x: Pin<&mut i32> = x;
             assert_eq!(*x, 1);
@@ -91,34 +93,36 @@
         EnumProj::Struct { f1, f2 } => {
             let _: Pin<&mut i32> = f1;
             let _: &mut i32 = f2;
+            unreachable!()
         }
-        EnumProj::Unit => {}
+        EnumProj::Unit => unreachable!(),
     }
 
-    assert_eq!(Pin::into_ref(e_orig).get_ref(), &Enum::Tuple(1, 2));
+    assert_eq!(&*e, &Enum::Tuple(1, 2));
 
     let mut e = Enum::Struct { f1: 3, f2: 4 };
-    let mut e = Pin::new(&mut e).project();
+    let mut e = Pin::new(&mut e);
 
-    match &mut e {
+    match e.as_mut().project() {
         EnumProj::Tuple(x, y) => {
-            let _: &mut Pin<&mut i32> = x;
-            let _: &mut &mut i32 = y;
+            let _: Pin<&mut i32> = x;
+            let _: &mut i32 = y;
+            unreachable!()
         }
         EnumProj::Struct { f1, f2 } => {
-            let x: &mut Pin<&mut i32> = f1;
-            assert_eq!(**x, 3);
-            let y: &mut &mut i32 = f2;
-            assert_eq!(**y, 4);
+            let _: Pin<&mut i32> = f1;
+            assert_eq!(*f1, 3);
+            let _: &mut i32 = f2;
+            assert_eq!(*f2, 4);
         }
-        EnumProj::Unit => {}
+        EnumProj::Unit => unreachable!(),
     }
 
-    if let EnumProj::Struct { f1, f2 } = e {
-        let x: Pin<&mut i32> = f1;
-        assert_eq!(*x, 3);
-        let y: &mut i32 = f2;
-        assert_eq!(*y, 4);
+    if let EnumProj::Struct { f1, f2 } = e.as_mut().project() {
+        let _: Pin<&mut i32> = f1;
+        assert_eq!(*f1, 3);
+        let _: &mut i32 = f2;
+        assert_eq!(*f2, 4);
     }
 }
 
@@ -140,7 +144,7 @@
             let new_e = Enum::V2(val.as_ref().get_ref() == &25);
             e_orig.set(new_e);
         }
-        _ => unreachable!(),
+        EnumProj::V2(_) => unreachable!(),
     }
 
     assert_eq!(e, Enum::V2(true));
@@ -288,7 +292,7 @@
         f: &'a mut T,
     }
 
-    let _: Struct6<'_> = Struct6 { f: &mut [0u8; 16] };
+    let _: Struct6<'_> = Struct6 { f: &mut [0_u8; 16] };
 
     #[pin_project(project_replace)]
     pub struct Struct7<T: 'static> {
@@ -433,7 +437,7 @@
     #[pin_project(project_replace)]
     struct Struct2<'a, T, U> {
         #[pin]
-        pinned: &'a mut T,
+        pinned: &'a T,
         unpinned: U,
     }
 
@@ -462,16 +466,16 @@
     }
 
     impl<'b, T, U> Struct2<'b, T, U> {
-        fn get_pin_ref<'a>(self: Pin<&'a Self>) -> Pin<&'a &'b mut T> {
+        fn get_pin_ref<'a>(self: Pin<&'a Self>) -> Pin<&'a &'b T> {
             self.project_ref().pinned
         }
-        fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut &'b mut T> {
+        fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut &'b T> {
             self.project().pinned
         }
-        fn get_pin_ref_elided(self: Pin<&Self>) -> Pin<&&'b mut T> {
+        fn get_pin_ref_elided(self: Pin<&Self>) -> Pin<&&'b T> {
             self.project_ref().pinned
         }
-        fn get_pin_mut_elided(self: Pin<&mut Self>) -> Pin<&mut &'b mut T> {
+        fn get_pin_mut_elided(self: Pin<&mut Self>) -> Pin<&mut &'b T> {
             self.project().pinned
         }
     }
diff --git a/tests/pinned_drop.rs b/tests/pinned_drop.rs
index e369ecb..78b73dc 100644
--- a/tests/pinned_drop.rs
+++ b/tests/pinned_drop.rs
@@ -201,19 +201,19 @@
     }
 
     impl<T: Send> Struct<T> {
-        const ASSOC1: &'static str = "1";
+        const ASSOC1: usize = 1;
         fn assoc1() {}
     }
 
     trait Trait {
         type Assoc2;
-        const ASSOC2: &'static str;
+        const ASSOC2: usize;
         fn assoc2();
     }
 
     impl<T: Send> Trait for Struct<T> {
         type Assoc2 = ();
-        const ASSOC2: &'static str = "2";
+        const ASSOC2: usize = 2;
         fn assoc2() {}
     }
 
diff --git a/tests/proper_unpin.rs b/tests/proper_unpin.rs
index ce2a6c8..8873572 100644
--- a/tests/proper_unpin.rs
+++ b/tests/proper_unpin.rs
@@ -16,16 +16,30 @@
     assert_not_unpin!(Inner<PhantomPinned>);
 
     #[pin_project]
-    struct Foo<T, U> {
+    struct Struct<T, U> {
         #[pin]
         f1: Inner<T>,
         f2: U,
     }
 
-    assert_unpin!(Foo<(), ()>);
-    assert_unpin!(Foo<(), PhantomPinned>);
-    assert_not_unpin!(Foo<PhantomPinned, ()>);
-    assert_not_unpin!(Foo<PhantomPinned, PhantomPinned>);
+    assert_unpin!(Struct<(), ()>);
+    assert_unpin!(Struct<(), PhantomPinned>);
+    assert_not_unpin!(Struct<PhantomPinned, ()>);
+    assert_not_unpin!(Struct<PhantomPinned, PhantomPinned>);
+
+    #[pin_project(project = EnumProj, project_ref = EnumProjRef)]
+    enum Enum<T, U> {
+        V1 {
+            #[pin]
+            f1: Inner<T>,
+            f2: U,
+        },
+    }
+
+    assert_unpin!(Enum<(), ()>);
+    assert_unpin!(Enum<(), PhantomPinned>);
+    assert_not_unpin!(Enum<PhantomPinned, ()>);
+    assert_not_unpin!(Enum<PhantomPinned, PhantomPinned>);
 
     #[pin_project]
     struct TrivialBounds {
@@ -36,13 +50,13 @@
     assert_not_unpin!(TrivialBounds);
 
     #[pin_project]
-    struct Bar<'a, T, U> {
+    struct PinRef<'a, T, U> {
         #[pin]
         f1: &'a mut Inner<T>,
         f2: U,
     }
 
-    assert_unpin!(Bar<'_, PhantomPinned, PhantomPinned>);
+    assert_unpin!(PinRef<'_, PhantomPinned, PhantomPinned>);
 }
 
 pub mod cfg {
@@ -105,16 +119,16 @@
     }
 
     #[pin_project(!Unpin)]
-    struct Foo<T, U> {
+    struct Struct<T, U> {
         #[pin]
         inner: Inner<T>,
         other: U,
     }
 
-    assert_not_unpin!(Foo<(), ()>);
-    assert_not_unpin!(Foo<(), PhantomPinned>);
-    assert_not_unpin!(Foo<PhantomPinned, ()>);
-    assert_not_unpin!(Foo<PhantomPinned, PhantomPinned>);
+    assert_not_unpin!(Struct<(), ()>);
+    assert_not_unpin!(Struct<(), PhantomPinned>);
+    assert_not_unpin!(Struct<PhantomPinned, ()>);
+    assert_not_unpin!(Struct<PhantomPinned, PhantomPinned>);
 
     #[pin_project(!Unpin)]
     struct TrivialBounds {
@@ -125,11 +139,11 @@
     assert_not_unpin!(TrivialBounds);
 
     #[pin_project(!Unpin)]
-    struct Bar<'a, T, U> {
+    struct PinRef<'a, T, U> {
         #[pin]
         inner: &'a mut Inner<T>,
         other: U,
     }
 
-    assert_not_unpin!(Bar<'_, (), ()>);
+    assert_not_unpin!(PinRef<'_, (), ()>);
 }
diff --git a/tests/ui/cfg/cfg_attr-resolve.rs b/tests/ui/cfg/cfg_attr-resolve.rs
index c7a246a..e36cc95 100644
--- a/tests/ui/cfg/cfg_attr-resolve.rs
+++ b/tests/ui/cfg/cfg_attr-resolve.rs
@@ -7,5 +7,5 @@
 
 fn main() {
     let mut x = Foo { f: 0_u8 };
-    let _x = Pin::new(&mut x).project(); //~ ERROR E0599
+    let _ = Pin::new(&mut x).project(); //~ ERROR E0599
 }
diff --git a/tests/ui/cfg/cfg_attr-resolve.stderr b/tests/ui/cfg/cfg_attr-resolve.stderr
index ee1fa03..12bcc67 100644
--- a/tests/ui/cfg/cfg_attr-resolve.stderr
+++ b/tests/ui/cfg/cfg_attr-resolve.stderr
@@ -1,5 +1,5 @@
 error[E0599]: no method named `project` found for struct `Pin<&mut Foo<u8>>` in the current scope
-  --> $DIR/cfg_attr-resolve.rs:10:31
+  --> $DIR/cfg_attr-resolve.rs:10:30
    |
-10 |     let _x = Pin::new(&mut x).project(); //~ ERROR E0599
-   |                               ^^^^^^^ method not found in `Pin<&mut Foo<u8>>`
+10 |     let _ = Pin::new(&mut x).project(); //~ ERROR E0599
+   |                              ^^^^^^^ method not found in `Pin<&mut Foo<u8>>`
diff --git a/tests/ui/pin_project/packed-enum.stderr b/tests/ui/pin_project/packed-enum.stderr
index 0a5d31b..afc8b30 100644
--- a/tests/ui/pin_project/packed-enum.stderr
+++ b/tests/ui/pin_project/packed-enum.stderr
@@ -1,4 +1,4 @@
-error[E0517]: attribute should be applied to struct or union
+error[E0517]: attribute should be applied to a struct or union
  --> $DIR/packed-enum.rs:3:8
   |
 3 |   #[repr(packed)] //~ ERROR E0517
@@ -8,7 +8,7 @@
 6 | | }
   | |_- not a struct or union
 
-error[E0517]: attribute should be applied to struct or union
+error[E0517]: attribute should be applied to a struct or union
   --> $DIR/packed-enum.rs:9:8
    |
 9  |   #[repr(packed)] //~ ERROR E0517
@@ -18,7 +18,7 @@
 12 | | }
    | |_- not a struct or union
 
-error[E0517]: attribute should be applied to struct or union
+error[E0517]: attribute should be applied to a struct or union
   --> $DIR/packed-enum.rs:14:8
    |
 14 |   #[repr(packed)] //~ ERROR E0517
diff --git a/tests/ui/pin_project/private_in_public-enum.stderr b/tests/ui/pin_project/private_in_public-enum.stderr
index a14756b..6e3316c 100644
--- a/tests/ui/pin_project/private_in_public-enum.stderr
+++ b/tests/ui/pin_project/private_in_public-enum.stderr
@@ -5,7 +5,7 @@
   |       ^^^^^^^^^^^ can't leak private type
 ...
 9 | enum PrivateEnum {
-  | - `PrivateEnum` declared as private
+  | ---------------- `PrivateEnum` declared as private
 
 error[E0446]: private type `foo::PrivateEnum` in public interface
   --> $DIR/private_in_public-enum.rs:15:11
@@ -14,4 +14,4 @@
    |           ^^^^^^^^^^^ can't leak private type
 ...
 18 |     enum PrivateEnum {
-   |     - `foo::PrivateEnum` declared as private
+   |     ---------------- `foo::PrivateEnum` declared as private
diff --git a/tests/ui/pin_project/project_replace_unsized.stderr b/tests/ui/pin_project/project_replace_unsized.stderr
index b6ecb1b..e40db5f 100644
--- a/tests/ui/pin_project/project_replace_unsized.stderr
+++ b/tests/ui/pin_project/project_replace_unsized.stderr
@@ -7,7 +7,7 @@
   |               - this type parameter needs to be `Sized`
   |
   = note: required because it appears within the type `Struct<T>`
-  = help: unsized locals are gated as an unstable feature
+  = help: unsized fn params are gated as an unstable feature
 help: function arguments must have a statically known size, borrowed types always have a known size
   |
 3 | #[pin_project(&project_replace)] //~ ERROR E0277
@@ -42,7 +42,7 @@
   |                    - this type parameter needs to be `Sized`
   |
   = note: required because it appears within the type `TupleStruct<T>`
-  = help: unsized locals are gated as an unstable feature
+  = help: unsized fn params are gated as an unstable feature
 help: function arguments must have a statically known size, borrowed types always have a known size
   |
 8 | #[pin_project(&project_replace)] //~ ERROR E0277
@@ -67,4 +67,4 @@
   |        doesn't have a size known at compile-time
   |
   = note: all function arguments must have a statically known size
-  = help: unsized locals are gated as an unstable feature
+  = help: unsized fn params 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_fn_params.rs
similarity index 87%
rename from tests/ui/pin_project/project_replace_unsized_locals.rs
rename to tests/ui/pin_project/project_replace_unsized_fn_params.rs
index 7e28e2c..e0fa25b 100644
--- a/tests/ui/pin_project/project_replace_unsized_locals.rs
+++ b/tests/ui/pin_project/project_replace_unsized_fn_params.rs
@@ -1,4 +1,4 @@
-#![feature(unsized_locals)]
+#![feature(unsized_fn_params)]
 
 use pin_project::pin_project;
 
diff --git a/tests/ui/pin_project/project_replace_unsized_locals.stderr b/tests/ui/pin_project/project_replace_unsized_fn_params.stderr
similarity index 89%
rename from tests/ui/pin_project/project_replace_unsized_locals.stderr
rename to tests/ui/pin_project/project_replace_unsized_fn_params.stderr
index ad965e5..622d12f 100644
--- a/tests/ui/pin_project/project_replace_unsized_locals.stderr
+++ b/tests/ui/pin_project/project_replace_unsized_fn_params.stderr
@@ -1,5 +1,5 @@
 error[E0277]: the size for values of type `T` cannot be known at compilation time
- --> $DIR/project_replace_unsized_locals.rs:6:8
+ --> $DIR/project_replace_unsized_fn_params.rs:6:8
   |
 6 | struct Struct<T: ?Sized> {
   |        ^^^^^^^-^^^^^^^^^
@@ -11,7 +11,7 @@
   = 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
+   --> $DIR/project_replace_unsized_fn_params.rs:7:5
     |
 6   | struct Struct<T: ?Sized> {
     |               - this type parameter needs to be `Sized`
@@ -19,7 +19,7 @@
     |     ^ doesn't have a size known at compile-time
 
 error[E0277]: the size for values of type `T` cannot be known at compilation time
- --> $DIR/project_replace_unsized_locals.rs:5:1
+ --> $DIR/project_replace_unsized_fn_params.rs:5:1
   |
 5 | #[pin_project(project_replace)] //~ ERROR E0277
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
@@ -31,7 +31,7 @@
   = 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
+  --> $DIR/project_replace_unsized_fn_params.rs:11:8
    |
 11 | struct TupleStruct<T: ?Sized>(T);
    |        ^^^^^^^^^^^^-^^^^^^^^^
@@ -43,7 +43,7 @@
    = 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
+   --> $DIR/project_replace_unsized_fn_params.rs:10:1
     |
 10  | #[pin_project(project_replace)] //~ ERROR E0277
     | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
diff --git a/tests/ui/pinned_drop/call-drop-inner.stderr b/tests/ui/pinned_drop/call-drop-inner.stderr
index eb55ce7..53194b0 100644
--- a/tests/ui/pinned_drop/call-drop-inner.stderr
+++ b/tests/ui/pinned_drop/call-drop-inner.stderr
@@ -1,10 +1,14 @@
 error[E0061]: this function takes 0 arguments but 1 argument was supplied
   --> $DIR/call-drop-inner.rs:12:9
    |
-9  | #[pinned_drop]
-   | -------------- defined here
-...
 12 |         __drop_inner(__self);
    |         ^^^^^^^^^^^^ ------ supplied 1 argument
    |         |
    |         expected 0 arguments
+   |
+note: function defined here
+  --> $DIR/call-drop-inner.rs:9:1
+   |
+9  | #[pinned_drop]
+   | ^^^^^^^^^^^^^^
+   = note: this error originates in an attribute macro (in Nightly builds, run with -Z macro-backtrace for more info)