Snap for 8191477 from c9e9198c875859f1c39364f957c689523f783d88 to tm-frc-neuralnetworks-release

Change-Id: I98cc09f5ef4866c09ae53008ebc33fdc3ff8369e

80 files changed, 2432 insertions, 2131 deletions

diff --git a/.cargo_vcs_info.json b/.cargo_vcs_info.json
index 32ae14a..2ad3c7d 100644
--- a/.cargo_vcs_info.json
+++ b/.cargo_vcs_info.json
@@ -1,5 +1,5 @@
 {
   "git": {
-    "sha1": "416be96f7777862c68b567c92a91887f69a8c2b3"
+    "sha1": "d21bbea70a60718cc2ff67dc0e6a4049126ff9e6"
   }
 }
diff --git a/.clippy.toml b/.clippy.toml
deleted file mode 100644
index 983eb57..0000000
--- a/.clippy.toml
+++ /dev/null
@@ -1 +0,0 @@
-msrv = "1.37"
diff --git a/.editorconfig b/.editorconfig
deleted file mode 100644
index a73a88d..0000000
--- a/.editorconfig
+++ /dev/null
@@ -1,20 +0,0 @@
-# EditorConfig configuration
-# https://editorconfig.org
-
-root = true
-
-[*]
-charset = utf-8
-end_of_line = lf
-indent_size = 4
-indent_style = space
-insert_final_newline = true
-trim_trailing_whitespace = true
-
-[*.{json,yml,md}]
-indent_size = 2
-
-[*.sh]
-indent_size = 2
-binary_next_line = true
-switch_case_indent = true
diff --git a/.gitattributes b/.gitattributes
deleted file mode 100644
index 6313b56..0000000
--- a/.gitattributes
+++ /dev/null
@@ -1 +0,0 @@
-* text=auto eol=lf
diff --git a/.rustfmt.toml b/.rustfmt.toml
deleted file mode 100644
index 6604f5c..0000000
--- a/.rustfmt.toml
+++ /dev/null
@@ -1,34 +0,0 @@
-# Rustfmt configuration
-# https://github.com/rust-lang/rustfmt/blob/HEAD/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"
-# Rustfmt cannot format long lines inside macros, but this option detects this.
-# 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
-
-# Automatically fix deprecated style.
-use_field_init_shorthand = true
-use_try_shorthand = true
-
-# 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/Android.bp b/Android.bp
index 650535e..96f9cd6 100644
--- a/Android.bp
+++ b/Android.bp
@@ -43,12 +43,17 @@ rust_library {
     name: "libpin_project_lite",
     host_supported: true,
     crate_name: "pin_project_lite",
+    cargo_env_compat: true,
+    cargo_pkg_version: "0.2.7",
     srcs: ["src/lib.rs"],
     edition: "2018",
     apex_available: [
         "//apex_available:platform",
+        "com.android.bluetooth",
         "com.android.resolv",
+        "com.android.uwb",
         "com.android.virt",
     ],
+    vendor_available: true,
     min_sdk_version: "29",
 }
diff --git a/CHANGELOG.md b/CHANGELOG.md
index e9d1276..aaa107b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -10,24 +10,46 @@ Note: In this file, do not use the hard wrap in the middle of a sentence for com
 
 ## [Unreleased]
 
+## [0.2.7] - 2021-06-26
+
+- [Support custom Drop implementation.](https://github.com/taiki-e/pin-project-lite/pull/25) See [#25](https://github.com/taiki-e/pin-project-lite/pull/25) for details.
+
+## [0.2.6] - 2021-03-04
+
+- [Support item attributes in any order.](https://github.com/taiki-e/pin-project-lite/pull/57)
+
+## [0.2.5] - 2021-03-02
+
+- [Prepare for removal of `safe_packed_borrows` lint.](https://github.com/taiki-e/pin-project-lite/pull/55) See [#55](https://github.com/taiki-e/pin-project-lite/pull/55) for details.
+
 ## [0.2.4] - 2021-01-11
 
+**Note: This release has been yanked.** See [#55](https://github.com/taiki-e/pin-project-lite/pull/55) for details.
+
 - [Add `project_replace`.](https://github.com/taiki-e/pin-project-lite/pull/43)
 
 ## [0.2.3] - 2021-01-09
 
+**Note: This release has been yanked.** See [#55](https://github.com/taiki-e/pin-project-lite/pull/55) for details.
+
 - [Suppress `clippy::unknown_clippy_lints` lint in generated code.](https://github.com/taiki-e/pin-project-lite/pull/47)
 
 ## [0.2.2] - 2021-01-09
 
+**Note: This release has been yanked.** See [#55](https://github.com/taiki-e/pin-project-lite/pull/55) for details.
+
 - [Suppress `clippy::ref_option_ref` lint in generated code.](https://github.com/taiki-e/pin-project-lite/pull/45)
 
 ## [0.2.1] - 2021-01-05
 
+**Note: This release has been yanked.** See [#55](https://github.com/taiki-e/pin-project-lite/pull/55) for details.
+
 - Exclude unneeded files from crates.io.
 
 ## [0.2.0] - 2020-11-13
 
+**Note: This release has been yanked.** See [#55](https://github.com/taiki-e/pin-project-lite/pull/55) for details.
+
 - [`pin_project!` macro now supports enums.](https://github.com/taiki-e/pin-project-lite/pull/28)
 
   To use `pin_project!` on enums, you need to name the projection type returned from the method.
@@ -77,22 +99,34 @@ Note: In this file, do not use the hard wrap in the middle of a sentence for com
   }
   ```
 
+## [0.1.12] - 2021-03-02
+
+- [Prepare for removal of `safe_packed_borrows` lint.](https://github.com/taiki-e/pin-project-lite/pull/55) See [#55](https://github.com/taiki-e/pin-project-lite/pull/55) for details.
+
 ## [0.1.11] - 2020-10-20
 
+**Note: This release has been yanked.** See [#55](https://github.com/taiki-e/pin-project-lite/pull/55) for details.
+
 - Suppress `clippy::redundant_pub_crate` lint in generated code.
 
 - Documentation improvements.
 
 ## [0.1.10] - 2020-10-01
 
+**Note: This release has been yanked.** See [#55](https://github.com/taiki-e/pin-project-lite/pull/55) for details.
+
 - Suppress `drop_bounds` lint, which will be added to rustc in the future. See [taiki-e/pin-project#272](https://github.com/taiki-e/pin-project/issues/272) for more details.
 
 ## [0.1.9] - 2020-09-29
 
+**Note: This release has been yanked.** See [#55](https://github.com/taiki-e/pin-project-lite/pull/55) for details.
+
 - [Fix trailing comma support in generics.](https://github.com/taiki-e/pin-project-lite/pull/32)
 
 ## [0.1.8] - 2020-09-26
 
+**Note: This release has been yanked.** See [#55](https://github.com/taiki-e/pin-project-lite/pull/55) for details.
+
 - [Fix compatibility of generated code with `forbid(future_incompatible)`.](https://github.com/taiki-e/pin-project-lite/pull/30)
 
   Note: This does not guarantee compatibility with `forbid(future_incompatible)` in the future.
@@ -100,6 +134,8 @@ Note: In this file, do not use the hard wrap in the middle of a sentence for com
 
 ## [0.1.7] - 2020-06-04
 
+**Note: This release has been yanked.** See [#55](https://github.com/taiki-e/pin-project-lite/pull/55) for details.
+
 - [Support `?Sized` bounds in where clauses.](https://github.com/taiki-e/pin-project-lite/pull/22)
 
 - [Fix lifetime inference error when an associated type is used in fields.](https://github.com/taiki-e/pin-project-lite/pull/20)
@@ -110,40 +146,58 @@ Note: In this file, do not use the hard wrap in the middle of a sentence for com
 
 ## [0.1.6] - 2020-05-31
 
+**Note: This release has been yanked.** See [#55](https://github.com/taiki-e/pin-project-lite/pull/55) for details.
+
 - [Support lifetime bounds in where clauses.](https://github.com/taiki-e/pin-project-lite/pull/18)
 
 - Documentation improvements.
 
 ## [0.1.5] - 2020-05-07
 
+**Note: This release has been yanked.** See [#55](https://github.com/taiki-e/pin-project-lite/pull/55) for details.
+
 - [Support overwriting the name of `core` crate.](https://github.com/taiki-e/pin-project-lite/pull/14)
 
 ## [0.1.4] - 2020-01-20
 
+**Note: This release has been yanked.** See [#55](https://github.com/taiki-e/pin-project-lite/pull/55) for details.
+
 - [Support ?Sized bounds in generic parameters.](https://github.com/taiki-e/pin-project-lite/pull/9)
 
 ## [0.1.3] - 2020-01-20
 
+**Note: This release has been yanked.** See [#55](https://github.com/taiki-e/pin-project-lite/pull/55) for details.
+
 - [Support lifetime bounds in generic parameters.](https://github.com/taiki-e/pin-project-lite/pull/7)
 
 ## [0.1.2] - 2020-01-05
 
+**Note: This release has been yanked.** See [#55](https://github.com/taiki-e/pin-project-lite/pull/55) for details.
+
 - [Support recognizing default generic parameters.](https://github.com/taiki-e/pin-project-lite/pull/6)
 
 ## [0.1.1] - 2019-11-15
 
+**Note: This release has been yanked.** See [#55](https://github.com/taiki-e/pin-project-lite/pull/55) for details.
+
 - [`pin_project!` macro now determines the visibility of the projection type/method is based on the original type.](https://github.com/taiki-e/pin-project-lite/pull/5)
 
 ## [0.1.0] - 2019-10-22
 
+**Note: This release has been yanked.** See [#55](https://github.com/taiki-e/pin-project-lite/pull/55) for details.
+
 Initial release
 
-[Unreleased]: https://github.com/taiki-e/pin-project-lite/compare/v0.2.4...HEAD
+[Unreleased]: https://github.com/taiki-e/pin-project-lite/compare/v0.2.7...HEAD
+[0.2.7]: https://github.com/taiki-e/pin-project-lite/compare/v0.2.6...v0.2.7
+[0.2.6]: https://github.com/taiki-e/pin-project-lite/compare/v0.2.5...v0.2.6
+[0.2.5]: https://github.com/taiki-e/pin-project-lite/compare/v0.2.4...v0.2.5
 [0.2.4]: https://github.com/taiki-e/pin-project-lite/compare/v0.2.3...v0.2.4
 [0.2.3]: https://github.com/taiki-e/pin-project-lite/compare/v0.2.2...v0.2.3
 [0.2.2]: https://github.com/taiki-e/pin-project-lite/compare/v0.2.1...v0.2.2
 [0.2.1]: https://github.com/taiki-e/pin-project-lite/compare/v0.2.0...v0.2.1
 [0.2.0]: https://github.com/taiki-e/pin-project-lite/compare/v0.1.11...v0.2.0
+[0.1.12]: https://github.com/taiki-e/pin-project-lite/compare/v0.1.11...v0.1.12
 [0.1.11]: https://github.com/taiki-e/pin-project-lite/compare/v0.1.10...v0.1.11
 [0.1.10]: https://github.com/taiki-e/pin-project-lite/compare/v0.1.9...v0.1.10
 [0.1.9]: https://github.com/taiki-e/pin-project-lite/compare/v0.1.8...v0.1.9
diff --git a/Cargo.toml b/Cargo.toml
index 92774c9..fab9dbc 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -13,18 +13,20 @@
 [package]
 edition = "2018"
 name = "pin-project-lite"
-version = "0.2.4"
+version = "0.2.7"
 authors = ["Taiki Endo <te316e89@gmail.com>"]
-exclude = ["/.github", "/scripts"]
+exclude = ["/.*", "/tools"]
 description = "A lightweight version of pin-project written with declarative macros.\n"
 documentation = "https://docs.rs/pin-project-lite"
-readme = "README.md"
 keywords = ["pin", "macros"]
 categories = ["no-std", "rust-patterns"]
 license = "Apache-2.0 OR MIT"
 repository = "https://github.com/taiki-e/pin-project-lite"
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]
+[dev-dependencies.macrotest]
+version = "1.0.8"
+
 [dev-dependencies.rustversion]
 version = "1"
 
diff --git a/Cargo.toml.orig b/Cargo.toml.orig
index a909043..c22afad 100644
--- a/Cargo.toml.orig
+++ b/Cargo.toml.orig
@@ -1,6 +1,6 @@
 [package]
 name = "pin-project-lite"
-version = "0.2.4"
+version = "0.2.7"
 authors = ["Taiki Endo <te316e89@gmail.com>"]
 edition = "2018"
 license = "Apache-2.0 OR MIT"
@@ -8,24 +8,19 @@ repository = "https://github.com/taiki-e/pin-project-lite"
 documentation = "https://docs.rs/pin-project-lite"
 keywords = ["pin", "macros"]
 categories = ["no-std", "rust-patterns"]
-readme = "README.md"
-exclude = ["/.github", "/scripts"]
+exclude = ["/.*", "/tools"]
 description = """
 A lightweight version of pin-project written with declarative macros.
 """
 
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]
-
 [workspace]
-members = [
-    "tests/doc",
-    "tests/expand",
-    "tests/no-core",
-    "tests/no-std",
-]
+members = ["tests/doc", "tests/no-core", "tests/no-std"]
 
 [dev-dependencies]
+macrotest = "1.0.8"
 rustversion = "1"
 static_assertions = "1"
 trybuild = "1"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
diff --git a/METADATA b/METADATA
index 24edb01..e34ef99 100644
--- a/METADATA
+++ b/METADATA
@@ -7,13 +7,13 @@ third_party {
   }
   url {
     type: ARCHIVE
-    value: "https://static.crates.io/crates/pin-project-lite/pin-project-lite-0.2.4.crate"
+    value: "https://static.crates.io/crates/pin-project-lite/pin-project-lite-0.2.7.crate"
   }
-  version: "0.2.4"
+  version: "0.2.7"
   license_type: NOTICE
   last_upgrade_date {
     year: 2021
-    month: 1
-    day: 11
+    month: 8
+    day: 9
   }
 }
diff --git a/README.md b/README.md
index 2f93ad0..e185993 100644
--- a/README.md
+++ b/README.md
@@ -1,10 +1,10 @@
 # pin-project-lite
 
-[![crates.io](https://img.shields.io/crates/v/pin-project-lite.svg?style=flat-square&logo=rust)](https://crates.io/crates/pin-project-lite)
+[![crates.io](https://img.shields.io/crates/v/pin-project-lite?style=flat-square&logo=rust)](https://crates.io/crates/pin-project-lite)
 [![docs.rs](https://img.shields.io/badge/docs.rs-pin--project--lite-blue?style=flat-square)](https://docs.rs/pin-project-lite)
-[![license](https://img.shields.io/badge/license-Apache--2.0_OR_MIT-blue.svg?style=flat-square)](#license)
-[![rustc](https://img.shields.io/badge/rustc-1.37+-blue.svg?style=flat-square)](https://www.rust-lang.org)
-[![build status](https://img.shields.io/github/workflow/status/taiki-e/pin-project-lite/CI/master?style=flat-square)](https://github.com/taiki-e/pin-project-lite/actions?query=workflow%3ACI+branch%3Amaster)
+[![license](https://img.shields.io/badge/license-Apache--2.0_OR_MIT-blue?style=flat-square)](#license)
+[![rustc](https://img.shields.io/badge/rustc-1.37+-blue?style=flat-square&logo=rust)](https://www.rust-lang.org)
+[![build status](https://img.shields.io/github/workflow/status/taiki-e/pin-project-lite/CI/main?style=flat-square&logo=github)](https://github.com/taiki-e/pin-project-lite/actions)
 
 A lightweight version of [pin-project] written with declarative macros.
 
@@ -100,10 +100,6 @@ be useful in most cases. If you do need useful error messages, then upon
 error you can pass the same input to [pin-project] to receive a helpful
 description of the compile error.
 
-### Different: No support for custom Drop implementation
-
-pin-project supports this by [`#[pinned_drop]`][pinned-drop].
-
 ### Different: No support for custom Unpin implementation
 
 pin-project supports this by [`UnsafeUnpin`][unsafe-unpin] and [`!Unpin`][not-unpin].
@@ -115,7 +111,6 @@ pin-project supports this.
 [`pin_project!`]: https://docs.rs/pin-project-lite/0.2/pin_project_lite/macro.pin_project.html
 [not-unpin]: https://docs.rs/pin-project/1/pin_project/attr.pin_project.html#unpin
 [pin-project]: https://github.com/taiki-e/pin-project
-[pinned-drop]: https://docs.rs/pin-project/1/pin_project/attr.pin_project.html#pinned_drop
 [unsafe-unpin]: https://docs.rs/pin-project/1/pin_project/attr.pin_project.html#unsafeunpin
 
 ## License
diff --git a/TEST_MAPPING b/TEST_MAPPING
new file mode 100644
index 0000000..5688278
--- /dev/null
+++ b/TEST_MAPPING
@@ -0,0 +1,51 @@
+// Generated by update_crate_tests.py for tests that depend on this crate.
+{
+  "imports": [
+    {
+      "path": "external/rust/crates/anyhow"
+    },
+    {
+      "path": "external/rust/crates/futures-util"
+    },
+    {
+      "path": "external/rust/crates/tokio"
+    },
+    {
+      "path": "external/rust/crates/tokio-test"
+    }
+  ],
+  "presubmit": [
+    {
+      "name": "ZipFuseTest"
+    },
+    {
+      "name": "authfs_device_test_src_lib"
+    },
+    {
+      "name": "doh_unit_test"
+    },
+    {
+      "name": "rustBinderTest"
+    },
+    {
+      "name": "virtualizationservice_device_test"
+    }
+  ],
+  "presubmit-rust": [
+    {
+      "name": "ZipFuseTest"
+    },
+    {
+      "name": "authfs_device_test_src_lib"
+    },
+    {
+      "name": "doh_unit_test"
+    },
+    {
+      "name": "rustBinderTest"
+    },
+    {
+      "name": "virtualizationservice_device_test"
+    }
+  ]
+}
diff --git a/cargo2android.json b/cargo2android.json
index 01465d0..e136311 100644
--- a/cargo2android.json
+++ b/cargo2android.json
@@ -1,11 +1,14 @@
 {
   "apex-available": [
     "//apex_available:platform",
+    "com.android.bluetooth",
     "com.android.resolv",
+    "com.android.uwb",
     "com.android.virt"
   ],
-  "min_sdk_version": "29",
   "dependencies": true,
   "device": true,
-  "run": true
-}
\ No newline at end of file
+  "min-sdk-version": "29",
+  "run": true,
+  "vendor-available": true
+}
diff --git a/src/lib.rs b/src/lib.rs
index 3e3ef70..db48b92 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -5,9 +5,10 @@
 //! [`pin_project!`] macro creates a projection type covering all the fields of struct.
 //!
 //! ```rust
-//! use pin_project_lite::pin_project;
 //! use std::pin::Pin;
 //!
+//! use pin_project_lite::pin_project;
+//!
 //! pin_project! {
 //!     struct Struct<T, U> {
 //!         #[pin]
@@ -29,9 +30,10 @@
 //! returned from the method.
 //!
 //! ```rust
-//! use pin_project_lite::pin_project;
 //! use std::pin::Pin;
 //!
+//! use pin_project_lite::pin_project;
+//!
 //! pin_project! {
 //!     #[project = EnumProj]
 //!     enum Enum<T, U> {
@@ -80,10 +82,6 @@
 //! error you can pass the same input to [pin-project] to receive a helpful
 //! description of the compile error.
 //!
-//! ## Different: No support for custom Drop implementation
-//!
-//! pin-project supports this by [`#[pinned_drop]`][pinned-drop].
-//!
 //! ## Different: No support for custom Unpin implementation
 //!
 //! pin-project supports this by [`UnsafeUnpin`][unsafe-unpin] and [`!Unpin`][not-unpin].
@@ -94,7 +92,6 @@
 //!
 //! [not-unpin]: https://docs.rs/pin-project/1/pin_project/attr.pin_project.html#unpin
 //! [pin-project]: https://github.com/taiki-e/pin-project
-//! [pinned-drop]: https://docs.rs/pin-project/1/pin_project/attr.pin_project.html#pinned_drop
 //! [unsafe-unpin]: https://docs.rs/pin-project/1/pin_project/attr.pin_project.html#unsafeunpin
 
 #![no_std]
@@ -106,7 +103,7 @@
     )
 ))]
 #![warn(future_incompatible, rust_2018_idioms, single_use_lifetimes, unreachable_pub)]
-#![warn(clippy::all, clippy::default_trait_access)]
+#![warn(clippy::default_trait_access, clippy::wildcard_imports)]
 
 // ANDROID: Use std to allow building as a dylib.
 extern crate std;
@@ -168,23 +165,6 @@ extern crate std;
 /// # }
 /// ```
 ///
-/// The `#[project]` (and `#[project_ref]`) attribute must precede the other
-/// attributes except for `#[doc]`. For example, the following code will not be compiled:
-///
-/// ```rust,compile_fail
-/// # use pin_project_lite::pin_project;
-/// # use std::pin::Pin;
-/// pin_project! {
-///     /// documents (`#[doc]`) can be placed before `#[project]`.
-///     #[derive(Clone)] // <--- ERROR
-///     #[project = EnumProj]
-///     #[derive(Debug)] // <--- Ok
-///     enum Enum<T> {
-///         Variant { #[pin] field: T },
-///     }
-/// }
-/// ```
-///
 /// Also, note that the projection types returned by `project` and `project_ref` have
 /// an additional lifetime at the beginning of generics.
 ///
@@ -208,9 +188,10 @@ extern crate std;
 /// # Examples
 ///
 /// ```rust
-/// use pin_project_lite::pin_project;
 /// use std::pin::Pin;
 ///
+/// use pin_project_lite::pin_project;
+///
 /// pin_project! {
 ///     struct Struct<T, U> {
 ///         #[pin]
@@ -232,9 +213,10 @@ extern crate std;
 /// returned from the method.
 ///
 /// ```rust
-/// use pin_project_lite::pin_project;
 /// use std::pin::Pin;
 ///
+/// use pin_project_lite::pin_project;
+///
 /// pin_project! {
 ///     #[project = EnumProj]
 ///     enum Enum<T> {
@@ -263,9 +245,10 @@ extern crate std;
 /// consuming the [`Pin`].
 ///
 /// ```rust
-/// use pin_project_lite::pin_project;
 /// use std::pin::Pin;
 ///
+/// use pin_project_lite::pin_project;
+///
 /// pin_project! {
 ///     struct Struct<T> {
 ///         #[pin]
@@ -288,9 +271,10 @@ extern crate std;
 /// attribute for a [`PhantomPinned`] field.
 ///
 /// ```rust
-/// use pin_project_lite::pin_project;
 /// use std::marker::PhantomPinned;
 ///
+/// use pin_project_lite::pin_project;
+///
 /// pin_project! {
 ///     struct Struct<T> {
 ///         field: T,
@@ -308,94 +292,9 @@ extern crate std;
 /// [pin-project]: https://github.com/taiki-e/pin-project
 #[macro_export]
 macro_rules! pin_project {
-    // Parses options
-    (
-        $(#[doc $($doc:tt)*])*
-        #[project = $proj_mut_ident:ident]
-        #[project_ref = $proj_ref_ident:ident]
-        #[project_replace = $proj_replace_ident:ident]
-        $($tt:tt)*
-    ) => {
-        $crate::__pin_project_internal! {
-            [$proj_mut_ident][$proj_ref_ident][$proj_replace_ident]
-            $(#[doc $($doc)*])*
-            $($tt)*
-        }
-    };
-    (
-        $(#[doc $($doc:tt)*])*
-        #[project = $proj_mut_ident:ident]
-        #[project_ref = $proj_ref_ident:ident]
-        $($tt:tt)*
-    ) => {
-        $crate::__pin_project_internal! {
-            [$proj_mut_ident][$proj_ref_ident][]
-            $(#[doc $($doc)*])*
-            $($tt)*
-        }
-    };
-    (
-        $(#[doc $($doc:tt)*])*
-        #[project = $proj_mut_ident:ident]
-        #[project_replace = $proj_replace_ident:ident]
-        $($tt:tt)*
-    ) => {
-        $crate::__pin_project_internal! {
-            [$proj_mut_ident][][$proj_replace_ident]
-            $(#[doc $($doc)*])*
-            $($tt)*
-        }
-    };
-    (
-        $(#[doc $($doc:tt)*])*
-        #[project_ref = $proj_ref_ident:ident]
-        #[project_replace = $proj_replace_ident:ident]
-        $($tt:tt)*
-    ) => {
-        $crate::__pin_project_internal! {
-            [][$proj_ref_ident][$proj_replace_ident]
-            $(#[doc $($doc)*])*
-            $($tt)*
-        }
-    };
-    (
-        $(#[doc $($doc:tt)*])*
-        #[project = $proj_mut_ident:ident]
-        $($tt:tt)*
-    ) => {
-        $crate::__pin_project_internal! {
-            [$proj_mut_ident][][]
-            $(#[doc $($doc)*])*
-            $($tt)*
-        }
-    };
-    (
-        $(#[doc $($doc:tt)*])*
-        #[project_ref = $proj_ref_ident:ident]
-        $($tt:tt)*
-    ) => {
-        $crate::__pin_project_internal! {
-            [][$proj_ref_ident][]
-            $(#[doc $($doc)*])*
-            $($tt)*
-        }
-    };
-    (
-        $(#[doc $($doc:tt)*])*
-        #[project_replace = $proj_replace_ident:ident]
-        $($tt:tt)*
-    ) => {
-        $crate::__pin_project_internal! {
-            [][][$proj_replace_ident]
-            $(#[doc $($doc)*])*
-            $($tt)*
-        }
-    };
-    (
-        $($tt:tt)*
-    ) => {
+    ($($tt:tt)*) => {
         $crate::__pin_project_internal! {
-            [][][]
+            [][][][]
             $($tt)*
         }
     };
@@ -430,6 +329,7 @@ macro_rules! __pin_project_internal {
                 $field_vis:vis $field:ident: $field_ty:ty
             ),+
         }
+        $(impl $($pinned_drop:tt)*)?
     ) => {
         $(#[$attrs])*
         $vis struct $ident $($def_generics)*
@@ -473,6 +373,7 @@ macro_rules! __pin_project_internal {
             [make_proj_field_replace]
             [$ident]
             [$($impl_generics)*] [$($ty_generics)*] [$(where $($where_clause)*)?]
+            [$(impl $($pinned_drop)*)?]
             {
                 $(
                     $(#[$pin])?
@@ -521,6 +422,7 @@ macro_rules! __pin_project_internal {
                 [make_proj_field_replace]
                 [$ident]
                 [$($impl_generics)*] [$($ty_generics)*] [$(where $($where_clause)*)?]
+                [$(impl $($pinned_drop)*)?]
                 {
                     $(
                         $(#[$pin])?
@@ -583,14 +485,13 @@ macro_rules! __pin_project_internal {
             $crate::__pin_project_internal! { @make_drop_impl;
                 [$ident]
                 [$($impl_generics)*] [$($ty_generics)*] [$(where $($where_clause)*)?]
+                $(impl $($pinned_drop)*)?
             }
 
             // Ensure that it's impossible to use pin projections on a #[repr(packed)] struct.
             //
-            // Taking a reference to a packed field is unsafe, amd appplying
-            // #[forbid(safe_packed_borrows)] makes sure that doing this without
-            // an 'unsafe' block (which we deliberately do not generate)
-            // is a hard error.
+            // Taking a reference to a packed field is UB, and applying
+            // `#[forbid(unaligned_references)]` makes sure that doing this is a hard error.
             //
             // If the struct ends up having #[repr(packed)] applied somehow,
             // this will generate an (unfriendly) error message. Under all reasonable
@@ -598,7 +499,16 @@ macro_rules! __pin_project_internal {
             // a much nicer error above.
             //
             // See https://github.com/taiki-e/pin-project/pull/34 for more details.
-            #[forbid(safe_packed_borrows)]
+            //
+            // Note:
+            // - Lint-based tricks aren't perfect, but they're much better than nothing:
+            //   https://github.com/taiki-e/pin-project-lite/issues/26
+            //
+            // - Enable both unaligned_references and safe_packed_borrows lints
+            //   because unaligned_references lint does not exist in older compilers:
+            //   https://github.com/taiki-e/pin-project-lite/pull/55
+            //   https://github.com/rust-lang/rust/pull/82525
+            #[forbid(unaligned_references, safe_packed_borrows)]
             fn __assert_not_repr_packed <$($impl_generics)*> (this: &$ident <$($ty_generics)*>)
             $(where
                 $($where_clause)*)?
@@ -630,6 +540,7 @@ macro_rules! __pin_project_internal {
                 })?
             ),+
         }
+        $(impl $($pinned_drop:tt)*)?
     ) => {
         $(#[$attrs])*
         $vis enum $ident $($def_generics)*
@@ -686,6 +597,7 @@ macro_rules! __pin_project_internal {
             [make_proj_field_replace]
             [$ident]
             [$($impl_generics)*] [$($ty_generics)*] [$(where $($where_clause)*)?]
+            [$(impl $($pinned_drop)*)?]
             {
                 $(
                     $variant $({
@@ -774,6 +686,7 @@ macro_rules! __pin_project_internal {
             $crate::__pin_project_internal! { @make_drop_impl;
                 [$ident]
                 [$($impl_generics)*] [$($ty_generics)*] [$(where $($where_clause)*)?]
+                $(impl $($pinned_drop)*)?
             }
 
             // We don't need to check for '#[repr(packed)]',
@@ -857,6 +770,7 @@ macro_rules! __pin_project_internal {
         [$make_proj_field:ident]
         [$ident:ident]
         [$($impl_generics:tt)*] [$($ty_generics:tt)*] [$(where $($where_clause:tt)* )?]
+        [$(impl $($pinned_drop:tt)*)?]
         $($field:tt)*
     ) => {};
     (@struct=>make_proj_replace_ty=>unnamed;
@@ -865,15 +779,16 @@ macro_rules! __pin_project_internal {
         [$make_proj_field:ident]
         [$ident:ident]
         [$($impl_generics:tt)*] [$($ty_generics:tt)*] [$(where $($where_clause:tt)* )?]
+        [$(impl $($pinned_drop:tt)*)?]
         $($field:tt)*
-    ) => {
-    };
+    ) => {};
     (@struct=>make_proj_replace_ty=>named;
         [$proj_vis:vis]
         [$proj_ty_ident:ident]
         [$make_proj_field:ident]
         [$ident:ident]
         [$($impl_generics:tt)*] [$($ty_generics:tt)*] [$(where $($where_clause:tt)* )?]
+        []
         {
             $(
                 $(#[$pin:ident])?
@@ -903,6 +818,7 @@ macro_rules! __pin_project_internal {
         [$make_proj_field:ident]
         [$ident:ident]
         [$($impl_generics:tt)*] [$($ty_generics:tt)*] [$(where $($where_clause:tt)* )?]
+        [$(impl $($pinned_drop:tt)*)?]
         $($field:tt)*
     ) => {};
     // =============================================================================================
@@ -964,6 +880,7 @@ macro_rules! __pin_project_internal {
         [$make_proj_field:ident]
         [$ident:ident]
         [$($impl_generics:tt)*] [$($ty_generics:tt)*] [$(where $($where_clause:tt)* )?]
+        []
         {
             $(
                 $variant:ident $({
@@ -1001,6 +918,7 @@ macro_rules! __pin_project_internal {
         [$make_proj_field:ident]
         [$ident:ident]
         [$($impl_generics:tt)*] [$($ty_generics:tt)*] [$(where $($where_clause:tt)* )?]
+        [$(impl $($pinned_drop:tt)*)?]
         $($variant:tt)*
     ) => {};
 
@@ -1256,11 +1174,11 @@ macro_rules! __pin_project_internal {
         // 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 delcared within
+        // fields from our #[pin_project] type. This struct is declared within
         // a function, which makes it impossible to be named by user code.
-        // This guarnatees that it will use the default auto-trait impl for Unpin -
+        // 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', satisfiying the privacy
+        // This type can be safely declared as 'public', satisfying the privacy
         // checker without actually allowing user code to access it.
         //
         // This allows users to apply the #[pin_project] attribute to types
@@ -1286,6 +1204,90 @@ macro_rules! __pin_project_internal {
     // =============================================================================================
     // make_drop_impl
     (@make_drop_impl;
+        [$_ident:ident]
+        [$($_impl_generics:tt)*] [$($_ty_generics:tt)*] [$(where $($_where_clause:tt)* )?]
+        impl $(<
+            $( $lifetime:lifetime $(: $lifetime_bound:lifetime)? ),* $(,)?
+            $( $generics:ident
+                $(: $generics_bound:path)?
+                $(: ?$generics_unsized_bound:path)?
+                $(: $generics_lifetime_bound:lifetime)?
+            ),*
+        >)? PinnedDrop for $self_ty:ty
+        $(where
+            $( $where_clause_ty:ty
+                $(: $where_clause_bound:path)?
+                $(: ?$where_clause_unsized_bound:path)?
+                $(: $where_clause_lifetime_bound:lifetime)?
+            ),*
+        )?
+        {
+            fn drop($($arg:ident)+: Pin<&mut Self>) {
+                $($tt:tt)*
+            }
+        }
+    ) => {
+        impl $(<
+            $( $lifetime $(: $lifetime_bound)? ,)*
+            $( $generics
+                $(: $generics_bound)?
+                $(: ?$generics_unsized_bound)?
+                $(: $generics_lifetime_bound)?
+            ),*
+        >)? $crate::__private::Drop for $self_ty
+        $(where
+            $( $where_clause_ty
+                $(: $where_clause_bound)?
+                $(: ?$where_clause_unsized_bound)?
+                $(: $where_clause_lifetime_bound)?
+            ),*
+        )?
+        {
+            fn drop(&mut self) {
+                // Implementing `__DropInner::__drop_inner` is safe, but calling it is not safe.
+                // This is because destructors can be called multiple times in safe code and
+                // [double dropping is unsound](https://github.com/rust-lang/rust/pull/62360).
+                //
+                // `__drop_inner` is defined as a safe method, but this is fine since
+                // `__drop_inner` is not accessible by the users and we call `__drop_inner` only
+                // once.
+                //
+                // Users can implement [`Drop`] safely using `pin_project!` and can drop a
+                // type that implements `PinnedDrop` using the [`drop`] function safely.
+                fn __drop_inner $(<
+                    $( $lifetime $(: $lifetime_bound)? ,)*
+                    $( $generics
+                        $(: $generics_bound)?
+                        $(: ?$generics_unsized_bound)?
+                        $(: $generics_lifetime_bound)?
+                    ),*
+                >)? (
+                    $($arg)+: $crate::__private::Pin<&mut $self_ty>,
+                )
+                $(where
+                    $( $where_clause_ty
+                        $(: $where_clause_bound)?
+                        $(: ?$where_clause_unsized_bound)?
+                        $(: $where_clause_lifetime_bound)?
+                    ),*
+                )?
+                {
+                    // A dummy `__drop_inner` function to prevent users call outer `__drop_inner`.
+                    fn __drop_inner() {}
+                    $($tt)*
+                }
+
+                // Safety - we're in 'drop', so we know that 'self' will
+                // never move again.
+                let pinned_self: $crate::__private::Pin<&mut Self>
+                    = unsafe { $crate::__private::Pin::new_unchecked(self) };
+                // We call `__drop_inner` only once. Since `__DropInner::__drop_inner`
+                // is not accessible by the users, it is never called again.
+                __drop_inner(pinned_self);
+            }
+        }
+    };
+    (@make_drop_impl;
         [$ident:ident]
         [$($impl_generics:tt)*] [$($ty_generics:tt)*] [$(where $($where_clause:tt)* )?]
     ) => {
@@ -1296,7 +1298,7 @@ macro_rules! __pin_project_internal {
         // the first blanked impl will not apply to it. This code
         // will compile, as there is only one impl of MustNotImplDrop for the user type
         // 2. The user type does impl Drop. This will make the blanket impl applicable,
-        // which will then comflict with the explicit MustNotImplDrop impl below.
+        // which will then conflict with the explicit MustNotImplDrop impl below.
         // This will result in a compilation error, which is exactly what we want.
         trait MustNotImplDrop {}
         #[allow(clippy::drop_bounds, drop_bounds)]
@@ -1404,13 +1406,86 @@ macro_rules! __pin_project_internal {
 
     // =============================================================================================
     // Parses input and determines visibility
+
+    (
+        []
+        [$($proj_ref_ident:ident)?]
+        [$($proj_replace_ident:ident)?]
+        [$($attrs:tt)*]
+
+        #[project = $proj_mut_ident:ident]
+        $($tt:tt)*
+    ) => {
+        $crate::__pin_project_internal! {
+            [$proj_mut_ident]
+            [$($proj_ref_ident)?]
+            [$($proj_replace_ident)?]
+            [$($attrs)*]
+            $($tt)*
+        }
+    };
+
+    {
+        [$($proj_mut_ident:ident)?]
+        []
+        [$($proj_replace_ident:ident)?]
+        [$($attrs:tt)*]
+
+        #[project_ref = $proj_ref_ident:ident]
+        $($tt:tt)*
+    } => {
+        $crate::__pin_project_internal! {
+            [$($proj_mut_ident)?]
+            [$proj_ref_ident]
+            [$($proj_replace_ident)?]
+            [$($attrs)*]
+            $($tt)*
+        }
+    };
+
+    {
+        [$($proj_mut_ident:ident)?]
+        [$($proj_ref_ident:ident)?]
+        []
+        [$($attrs:tt)*]
+
+        #[project_replace = $proj_replace_ident:ident]
+        $($tt:tt)*
+    } => {
+        $crate::__pin_project_internal! {
+            [$($proj_mut_ident)?]
+            [$($proj_ref_ident)?]
+            [$proj_replace_ident]
+            [$($attrs)*]
+            $($tt)*
+        }
+    };
+
+    {
+        [$($proj_mut_ident:ident)?]
+        [$($proj_ref_ident:ident)?]
+        [$($proj_replace_ident:ident)?]
+        [$($attrs:tt)*]
+
+        #[$($attr:tt)*]
+        $($tt:tt)*
+    } => {
+        $crate::__pin_project_internal! {
+            [$($proj_mut_ident)?]
+            [$($proj_ref_ident)?]
+            [$($proj_replace_ident)?]
+            [$($attrs)* #[$($attr)*]]
+            $($tt)*
+        }
+    };
+
     // struct
     (
         [$($proj_mut_ident:ident)?]
         [$($proj_ref_ident:ident)?]
         [$($proj_replace_ident:ident)?]
+        [$($attrs:tt)*]
 
-        $(#[$attrs:meta])*
         pub struct $ident:ident $(<
             $( $lifetime:lifetime $(: $lifetime_bound:lifetime)? ),* $(,)?
             $( $generics:ident
@@ -1433,13 +1508,14 @@ macro_rules! __pin_project_internal {
                 $field_vis:vis $field:ident: $field_ty:ty
             ),+ $(,)?
         }
+        $(impl $($pinned_drop:tt)*)?
     ) => {
         $crate::__pin_project_internal! { @struct=>internal;
             [$($proj_mut_ident)?]
             [$($proj_ref_ident)?]
             [$($proj_replace_ident)?]
             [pub(crate)]
-            [$(#[$attrs])* pub struct $ident]
+            [$($attrs)* pub struct $ident]
             [$(<
                 $( $lifetime $(: $lifetime_bound)? ,)*
                 $( $generics
@@ -1469,14 +1545,15 @@ macro_rules! __pin_project_internal {
                     $field_vis $field: $field_ty
                 ),+
             }
+            $(impl $($pinned_drop)*)?
         }
     };
     (
         [$($proj_mut_ident:ident)?]
         [$($proj_ref_ident:ident)?]
         [$($proj_replace_ident:ident)?]
+        [$($attrs:tt)*]
 
-        $(#[$attrs:meta])*
         $vis:vis struct $ident:ident $(<
             $( $lifetime:lifetime $(: $lifetime_bound:lifetime)? ),* $(,)?
             $( $generics:ident
@@ -1499,13 +1576,14 @@ macro_rules! __pin_project_internal {
                 $field_vis:vis $field:ident: $field_ty:ty
             ),+ $(,)?
         }
+        $(impl $($pinned_drop:tt)*)?
     ) => {
         $crate::__pin_project_internal! { @struct=>internal;
             [$($proj_mut_ident)?]
             [$($proj_ref_ident)?]
             [$($proj_replace_ident)?]
             [$vis]
-            [$(#[$attrs])* $vis struct $ident]
+            [$($attrs)* $vis struct $ident]
             [$(<
                 $( $lifetime $(: $lifetime_bound)? ,)*
                 $( $generics
@@ -1535,6 +1613,7 @@ macro_rules! __pin_project_internal {
                     $field_vis $field: $field_ty
                 ),+
             }
+            $(impl $($pinned_drop)*)?
         }
     };
     // enum
@@ -1542,8 +1621,8 @@ macro_rules! __pin_project_internal {
         [$($proj_mut_ident:ident)?]
         [$($proj_ref_ident:ident)?]
         [$($proj_replace_ident:ident)?]
+        [$($attrs:tt)*]
 
-        $(#[$attrs:meta])*
         pub enum $ident:ident $(<
             $( $lifetime:lifetime $(: $lifetime_bound:lifetime)? ),* $(,)?
             $( $generics:ident
@@ -1571,13 +1650,14 @@ macro_rules! __pin_project_internal {
                 })?
             ),+ $(,)?
         }
+        $(impl $($pinned_drop:tt)*)?
     ) => {
         $crate::__pin_project_internal! { @enum=>internal;
             [$($proj_mut_ident)?]
             [$($proj_ref_ident)?]
             [$($proj_replace_ident)?]
             [pub(crate)]
-            [$(#[$attrs])* pub enum $ident]
+            [$($attrs)* pub enum $ident]
             [$(<
                 $( $lifetime $(: $lifetime_bound)? ,)*
                 $( $generics
@@ -1612,14 +1692,15 @@ macro_rules! __pin_project_internal {
                     })?
                 ),+
             }
+            $(impl $($pinned_drop)*)?
         }
     };
     (
         [$($proj_mut_ident:ident)?]
         [$($proj_ref_ident:ident)?]
         [$($proj_replace_ident:ident)?]
+        [$($attrs:tt)*]
 
-        $(#[$attrs:meta])*
         $vis:vis enum $ident:ident $(<
             $( $lifetime:lifetime $(: $lifetime_bound:lifetime)? ),* $(,)?
             $( $generics:ident
@@ -1647,13 +1728,14 @@ macro_rules! __pin_project_internal {
                 })?
             ),+ $(,)?
         }
+        $(impl $($pinned_drop:tt)*)?
     ) => {
         $crate::__pin_project_internal! { @enum=>internal;
             [$($proj_mut_ident)?]
             [$($proj_ref_ident)?]
             [$($proj_replace_ident)?]
             [$vis]
-            [$(#[$attrs])* $vis enum $ident]
+            [$($attrs)* $vis enum $ident]
             [$(<
                 $( $lifetime $(: $lifetime_bound)? ,)*
                 $( $generics
@@ -1688,6 +1770,7 @@ macro_rules! __pin_project_internal {
                     })?
                 ),+
             }
+            $(impl $($pinned_drop)*)?
         }
     };
 }
diff --git a/src/lib.rs.orig b/src/lib.rs.orig
deleted file mode 100644
index ff1e3bf..0000000
--- a/src/lib.rs.orig
+++ /dev/null
@@ -1,1737 +0,0 @@
-//! A lightweight version of [pin-project] written with declarative macros.
-//!
-//! # Examples
-//!
-//! [`pin_project!`] macro creates a projection type covering all the fields of struct.
-//!
-//! ```rust
-//! use pin_project_lite::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
-//!     }
-//! }
-//! ```
-//!
-//! To use [`pin_project!`] on enums, you need to name the projection type
-//! returned from the method.
-//!
-//! ```rust
-//! use pin_project_lite::pin_project;
-//! use std::pin::Pin;
-//!
-//! pin_project! {
-//!     #[project = EnumProj]
-//!     enum Enum<T, U> {
-//!         Variant { #[pin] pinned: T, unpinned: U },
-//!    }
-//! }
-//!
-//! impl<T, U> Enum<T, U> {
-//!     fn method(self: Pin<&mut Self>) {
-//!         match self.project() {
-//!             EnumProj::Variant { pinned, unpinned } => {
-//!                 let _: Pin<&mut T> = pinned;
-//!                 let _: &mut U = unpinned;
-//!             }
-//!         }
-//!     }
-//! }
-//! ```
-//!
-//! # [pin-project] vs pin-project-lite
-//!
-//! Here are some similarities and differences compared to [pin-project].
-//!
-//! ## Similar: Safety
-//!
-//! pin-project-lite guarantees safety in much the same way as [pin-project].
-//! Both are completely safe unless you write other unsafe code.
-//!
-//! ## Different: Minimal design
-//!
-//! This library does not tackle as expansive of a range of use cases as
-//! [pin-project] does. If your use case is not already covered, please use
-//! [pin-project].
-//!
-//! ## Different: No proc-macro related dependencies
-//!
-//! This is the **only** reason to use this crate. However, **if you already
-//! have proc-macro related dependencies in your crate's dependency graph, there
-//! is no benefit from using this crate.** (Note: There is almost no difference
-//! in the amount of code generated between [pin-project] and pin-project-lite.)
-//!
-//! ## Different: No useful error messages
-//!
-//! This macro does not handle any invalid input. So error messages are not to
-//! be useful in most cases. If you do need useful error messages, then upon
-//! error you can pass the same input to [pin-project] to receive a helpful
-//! description of the compile error.
-//!
-//! ## Different: No support for custom Drop implementation
-//!
-//! pin-project supports this by [`#[pinned_drop]`][pinned-drop].
-//!
-//! ## Different: No support for custom Unpin implementation
-//!
-//! pin-project supports this by [`UnsafeUnpin`][unsafe-unpin] and [`!Unpin`][not-unpin].
-//!
-//! ## Different: No support for tuple structs and tuple variants
-//!
-//! pin-project supports this.
-//!
-//! [not-unpin]: https://docs.rs/pin-project/1/pin_project/attr.pin_project.html#unpin
-//! [pin-project]: https://github.com/taiki-e/pin-project
-//! [pinned-drop]: https://docs.rs/pin-project/1/pin_project/attr.pin_project.html#pinned_drop
-//! [unsafe-unpin]: https://docs.rs/pin-project/1/pin_project/attr.pin_project.html#unsafeunpin
-
-#![no_std]
-#![doc(test(
-    no_crate_inject,
-    attr(
-        deny(warnings, rust_2018_idioms, single_use_lifetimes),
-        allow(dead_code, unused_variables)
-    )
-))]
-#![warn(future_incompatible, rust_2018_idioms, single_use_lifetimes, unreachable_pub)]
-#![warn(clippy::all, clippy::default_trait_access)]
-
-/// A macro that creates a projection type covering all the fields of struct.
-///
-/// This macro creates a projection type according to the following rules:
-///
-/// * For the field that uses `#[pin]` attribute, makes the pinned reference to the field.
-/// * For the other fields, makes the unpinned reference to the field.
-///
-/// And the following methods are implemented on the original type:
-///
-/// ```rust
-/// # use std::pin::Pin;
-/// # type Projection<'a> = &'a ();
-/// # type ProjectionRef<'a> = &'a ();
-/// # trait Dox {
-/// fn project(self: Pin<&mut Self>) -> Projection<'_>;
-/// fn project_ref(self: Pin<&Self>) -> ProjectionRef<'_>;
-/// # }
-/// ```
-///
-/// By passing an attribute with the same name as the method to the macro,
-/// you can name the projection type returned from the method. This allows you
-/// to use pattern matching on the projected types.
-///
-/// ```rust
-/// # use pin_project_lite::pin_project;
-/// # use std::pin::Pin;
-/// pin_project! {
-///     #[project = EnumProj]
-///     enum Enum<T> {
-///         Variant { #[pin] field: T },
-///     }
-/// }
-///
-/// impl<T> Enum<T> {
-///     fn method(self: Pin<&mut Self>) {
-///         let this: EnumProj<'_, T> = self.project();
-///         match this {
-///             EnumProj::Variant { field } => {
-///                 let _: Pin<&mut T> = field;
-///             }
-///         }
-///     }
-/// }
-/// ```
-///
-/// By passing the `#[project_replace = MyProjReplace]` attribute you may create an additional
-/// method which allows the contents of `Pin<&mut Self>` to be replaced while simultaneously moving
-/// out all unpinned fields in `Self`.
-///
-/// ```rust
-/// # use std::pin::Pin;
-/// # type MyProjReplace = ();
-/// # trait Dox {
-/// fn project_replace(self: Pin<&mut Self>, replacement: Self) -> MyProjReplace;
-/// # }
-/// ```
-///
-/// The `#[project]` (and `#[project_ref]`) attribute must precede the other
-/// attributes except for `#[doc]`. For example, the following code will not be compiled:
-///
-/// ```rust,compile_fail
-/// # use pin_project_lite::pin_project;
-/// # use std::pin::Pin;
-/// pin_project! {
-///     /// documents (`#[doc]`) can be placed before `#[project]`.
-///     #[derive(Clone)] // <--- ERROR
-///     #[project = EnumProj]
-///     #[derive(Debug)] // <--- Ok
-///     enum Enum<T> {
-///         Variant { #[pin] field: T },
-///     }
-/// }
-/// ```
-///
-/// Also, note that the projection types returned by `project` and `project_ref` have
-/// an additional lifetime at the beginning of generics.
-///
-/// ```text
-/// let this: EnumProj<'_, T> = self.project();
-///                    ^^
-/// ```
-///
-/// The visibility of the projected types and projection methods is based on the
-/// original type. However, if the visibility of the original type is `pub`, the
-/// visibility of the projected types and the projection methods is downgraded
-/// to `pub(crate)`.
-///
-/// # Safety
-///
-/// `pin_project!` macro guarantees safety in much the same way as [pin-project] crate.
-/// Both are completely safe unless you write other unsafe code.
-///
-/// See [pin-project] crate for more details.
-///
-/// # Examples
-///
-/// ```rust
-/// use pin_project_lite::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
-///     }
-/// }
-/// ```
-///
-/// To use `pin_project!` on enums, you need to name the projection type
-/// returned from the method.
-///
-/// ```rust
-/// use pin_project_lite::pin_project;
-/// use std::pin::Pin;
-///
-/// pin_project! {
-///     #[project = EnumProj]
-///     enum Enum<T> {
-///         Struct {
-///             #[pin]
-///             field: T,
-///         },
-///         Unit,
-///     }
-/// }
-///
-/// impl<T> Enum<T> {
-///     fn method(self: Pin<&mut Self>) {
-///         match self.project() {
-///             EnumProj::Struct { field } => {
-///                 let _: Pin<&mut T> = field;
-///             }
-///             EnumProj::Unit => {}
-///         }
-///     }
-/// }
-/// ```
-///
-/// If you want to call the `project()` method multiple times or later use the
-/// original [`Pin`] type, it needs to use [`.as_mut()`][`Pin::as_mut`] to avoid
-/// consuming the [`Pin`].
-///
-/// ```rust
-/// use pin_project_lite::pin_project;
-/// use std::pin::Pin;
-///
-/// pin_project! {
-///     struct Struct<T> {
-///         #[pin]
-///         field: T,
-///     }
-/// }
-///
-/// impl<T> Struct<T> {
-///     fn call_project_twice(mut self: Pin<&mut Self>) {
-///         // `project` consumes `self`, so reborrow the `Pin<&mut Self>` via `as_mut`.
-///         self.as_mut().project();
-///         self.as_mut().project();
-///     }
-/// }
-/// ```
-///
-/// # `!Unpin`
-///
-/// If you want to ensure that [`Unpin`] is not implemented, use `#[pin]`
-/// attribute for a [`PhantomPinned`] field.
-///
-/// ```rust
-/// use pin_project_lite::pin_project;
-/// use std::marker::PhantomPinned;
-///
-/// pin_project! {
-///     struct Struct<T> {
-///         field: T,
-///         #[pin] // <------ This `#[pin]` is required to make `Struct` to `!Unpin`.
-///         _pin: PhantomPinned,
-///     }
-/// }
-/// ```
-///
-/// Note that using [`PhantomPinned`] without `#[pin]` attribute has no effect.
-///
-/// [`PhantomPinned`]: core::marker::PhantomPinned
-/// [`Pin::as_mut`]: core::pin::Pin::as_mut
-/// [`Pin`]: core::pin::Pin
-/// [pin-project]: https://github.com/taiki-e/pin-project
-#[macro_export]
-macro_rules! pin_project {
-    // Parses options
-    (
-        $(#[doc $($doc:tt)*])*
-        #[project = $proj_mut_ident:ident]
-        #[project_ref = $proj_ref_ident:ident]
-        #[project_replace = $proj_replace_ident:ident]
-        $($tt:tt)*
-    ) => {
-        $crate::__pin_project_internal! {
-            [$proj_mut_ident][$proj_ref_ident][$proj_replace_ident]
-            $(#[doc $($doc)*])*
-            $($tt)*
-        }
-    };
-    (
-        $(#[doc $($doc:tt)*])*
-        #[project = $proj_mut_ident:ident]
-        #[project_ref = $proj_ref_ident:ident]
-        $($tt:tt)*
-    ) => {
-        $crate::__pin_project_internal! {
-            [$proj_mut_ident][$proj_ref_ident][]
-            $(#[doc $($doc)*])*
-            $($tt)*
-        }
-    };
-    (
-        $(#[doc $($doc:tt)*])*
-        #[project = $proj_mut_ident:ident]
-        #[project_replace = $proj_replace_ident:ident]
-        $($tt:tt)*
-    ) => {
-        $crate::__pin_project_internal! {
-            [$proj_mut_ident][][$proj_replace_ident]
-            $(#[doc $($doc)*])*
-            $($tt)*
-        }
-    };
-    (
-        $(#[doc $($doc:tt)*])*
-        #[project_ref = $proj_ref_ident:ident]
-        #[project_replace = $proj_replace_ident:ident]
-        $($tt:tt)*
-    ) => {
-        $crate::__pin_project_internal! {
-            [][$proj_ref_ident][$proj_replace_ident]
-            $(#[doc $($doc)*])*
-            $($tt)*
-        }
-    };
-    (
-        $(#[doc $($doc:tt)*])*
-        #[project = $proj_mut_ident:ident]
-        $($tt:tt)*
-    ) => {
-        $crate::__pin_project_internal! {
-            [$proj_mut_ident][][]
-            $(#[doc $($doc)*])*
-            $($tt)*
-        }
-    };
-    (
-        $(#[doc $($doc:tt)*])*
-        #[project_ref = $proj_ref_ident:ident]
-        $($tt:tt)*
-    ) => {
-        $crate::__pin_project_internal! {
-            [][$proj_ref_ident][]
-            $(#[doc $($doc)*])*
-            $($tt)*
-        }
-    };
-    (
-        $(#[doc $($doc:tt)*])*
-        #[project_replace = $proj_replace_ident:ident]
-        $($tt:tt)*
-    ) => {
-        $crate::__pin_project_internal! {
-            [][][$proj_replace_ident]
-            $(#[doc $($doc)*])*
-            $($tt)*
-        }
-    };
-    (
-        $($tt:tt)*
-    ) => {
-        $crate::__pin_project_internal! {
-            [][][]
-            $($tt)*
-        }
-    };
-}
-
-// limitations:
-// * no support for tuple structs and tuple variant (wontfix).
-// * no support for multiple trait/lifetime bounds.
-// * no support for `Self` in where clauses. (wontfix)
-// * no support for overlapping lifetime names. (wontfix)
-// * no interoperability with other field attributes.
-// * no useful error messages. (wontfix)
-// etc...
-
-// Not public API.
-#[doc(hidden)]
-#[macro_export]
-macro_rules! __pin_project_internal {
-    // =============================================================================================
-    // struct:main
-    (@struct=>internal;
-        [$($proj_mut_ident:ident)?]
-        [$($proj_ref_ident:ident)?]
-        [$($proj_replace_ident:ident)?]
-        [$proj_vis:vis]
-        [$(#[$attrs:meta])* $vis:vis struct $ident:ident]
-        [$($def_generics:tt)*]
-        [$($impl_generics:tt)*] [$($ty_generics:tt)*] [$(where $($where_clause:tt)*)?]
-        {
-            $(
-                $(#[$pin:ident])?
-                $field_vis:vis $field:ident: $field_ty:ty
-            ),+
-        }
-    ) => {
-        $(#[$attrs])*
-        $vis struct $ident $($def_generics)*
-        $(where
-            $($where_clause)*)?
-        {
-            $(
-                $field_vis $field: $field_ty
-            ),+
-        }
-
-        $crate::__pin_project_internal! { @struct=>make_proj_ty=>named;
-            [$proj_vis]
-            [$($proj_mut_ident)?]
-            [make_proj_field_mut]
-            [$ident]
-            [$($impl_generics)*] [$($ty_generics)*] [$(where $($where_clause)*)?]
-            {
-                $(
-                    $(#[$pin])?
-                    $field_vis $field: $field_ty
-                ),+
-            }
-        }
-        $crate::__pin_project_internal! { @struct=>make_proj_ty=>named;
-            [$proj_vis]
-            [$($proj_ref_ident)?]
-            [make_proj_field_ref]
-            [$ident]
-            [$($impl_generics)*] [$($ty_generics)*] [$(where $($where_clause)*)?]
-            {
-                $(
-                    $(#[$pin])?
-                    $field_vis $field: $field_ty
-                ),+
-            }
-        }
-        $crate::__pin_project_internal! { @struct=>make_proj_replace_ty=>named;
-            [$proj_vis]
-            [$($proj_replace_ident)?]
-            [make_proj_field_replace]
-            [$ident]
-            [$($impl_generics)*] [$($ty_generics)*] [$(where $($where_clause)*)?]
-            {
-                $(
-                    $(#[$pin])?
-                    $field_vis $field: $field_ty
-                ),+
-            }
-        }
-
-        #[allow(explicit_outlives_requirements)] // https://github.com/rust-lang/rust/issues/60993
-        #[allow(single_use_lifetimes)] // https://github.com/rust-lang/rust/issues/55058
-        // This lint warns of `clippy::*` generated by external macros.
-        // We allow this lint for compatibility with older compilers.
-        #[allow(clippy::unknown_clippy_lints)]
-        #[allow(clippy::redundant_pub_crate)] // This lint warns `pub(crate)` field in private struct.
-        #[allow(clippy::used_underscore_binding)]
-        const _: () = {
-            $crate::__pin_project_internal! { @struct=>make_proj_ty=>unnamed;
-                [$proj_vis]
-                [$($proj_mut_ident)?][Projection]
-                [make_proj_field_mut]
-                [$ident]
-                [$($impl_generics)*] [$($ty_generics)*] [$(where $($where_clause)*)?]
-                {
-                    $(
-                        $(#[$pin])?
-                        $field_vis $field: $field_ty
-                    ),+
-                }
-            }
-            $crate::__pin_project_internal! { @struct=>make_proj_ty=>unnamed;
-                [$proj_vis]
-                [$($proj_ref_ident)?][ProjectionRef]
-                [make_proj_field_ref]
-                [$ident]
-                [$($impl_generics)*] [$($ty_generics)*] [$(where $($where_clause)*)?]
-                {
-                    $(
-                        $(#[$pin])?
-                        $field_vis $field: $field_ty
-                    ),+
-                }
-            }
-            $crate::__pin_project_internal! { @struct=>make_proj_replace_ty=>unnamed;
-                [$proj_vis]
-                [$($proj_replace_ident)?][ProjectionReplace]
-                [make_proj_field_replace]
-                [$ident]
-                [$($impl_generics)*] [$($ty_generics)*] [$(where $($where_clause)*)?]
-                {
-                    $(
-                        $(#[$pin])?
-                        $field_vis $field: $field_ty
-                    ),+
-                }
-            }
-
-            impl <$($impl_generics)*> $ident <$($ty_generics)*>
-            $(where
-                $($where_clause)*)?
-            {
-                $crate::__pin_project_internal! { @struct=>make_proj_method;
-                    [$proj_vis]
-                    [$($proj_mut_ident)?][Projection]
-                    [project get_unchecked_mut mut]
-                    [$($ty_generics)*]
-                    {
-                        $(
-                            $(#[$pin])?
-                            $field_vis $field
-                        ),+
-                    }
-                }
-                $crate::__pin_project_internal! { @struct=>make_proj_method;
-                    [$proj_vis]
-                    [$($proj_ref_ident)?][ProjectionRef]
-                    [project_ref get_ref]
-                    [$($ty_generics)*]
-                    {
-                        $(
-                            $(#[$pin])?
-                            $field_vis $field
-                        ),+
-                    }
-                }
-                $crate::__pin_project_internal! { @struct=>make_proj_replace_method;
-                    [$proj_vis]
-                    [$($proj_replace_ident)?][ProjectionReplace]
-                    [$($ty_generics)*]
-                    {
-                        $(
-                            $(#[$pin])?
-                            $field_vis $field
-                        ),+
-                    }
-                }
-            }
-
-            $crate::__pin_project_internal! { @make_unpin_impl;
-                [$vis $ident]
-                [$($impl_generics)*] [$($ty_generics)*] [$(where $($where_clause)*)?]
-                $(
-                    $field: $crate::__pin_project_internal!(@make_unpin_bound;
-                        $(#[$pin])? $field_ty
-                    )
-                ),+
-            }
-
-            $crate::__pin_project_internal! { @make_drop_impl;
-                [$ident]
-                [$($impl_generics)*] [$($ty_generics)*] [$(where $($where_clause)*)?]
-            }
-
-            // Ensure that it's impossible to use pin projections on a #[repr(packed)] struct.
-            //
-            // Taking a reference to a packed field is unsafe, amd appplying
-            // #[forbid(safe_packed_borrows)] makes sure that doing this without
-            // an 'unsafe' block (which we deliberately do not generate)
-            // is a hard error.
-            //
-            // If the struct ends up having #[repr(packed)] applied somehow,
-            // this will generate an (unfriendly) error message. Under all reasonable
-            // circumstances, we'll detect the #[repr(packed)] attribute, and generate
-            // a much nicer error above.
-            //
-            // See https://github.com/taiki-e/pin-project/pull/34 for more details.
-            #[forbid(safe_packed_borrows)]
-            fn __assert_not_repr_packed <$($impl_generics)*> (this: &$ident <$($ty_generics)*>)
-            $(where
-                $($where_clause)*)?
-            {
-                $(
-                    let _ = &this.$field;
-                )+
-            }
-        };
-    };
-    // =============================================================================================
-    // enum:main
-    (@enum=>internal;
-        [$($proj_mut_ident:ident)?]
-        [$($proj_ref_ident:ident)?]
-        [$($proj_replace_ident:ident)?]
-        [$proj_vis:vis]
-        [$(#[$attrs:meta])* $vis:vis enum $ident:ident]
-        [$($def_generics:tt)*]
-        [$($impl_generics:tt)*] [$($ty_generics:tt)*] [$(where $($where_clause:tt)*)?]
-        {
-            $(
-                $(#[$variant_attrs:meta])*
-                $variant:ident $({
-                    $(
-                        $(#[$pin:ident])?
-                        $field:ident: $field_ty:ty
-                    ),+
-                })?
-            ),+
-        }
-    ) => {
-        $(#[$attrs])*
-        $vis enum $ident $($def_generics)*
-        $(where
-            $($where_clause)*)?
-        {
-            $(
-                $(#[$variant_attrs])*
-                $variant $({
-                    $(
-                        $field: $field_ty
-                    ),+
-                })?
-            ),+
-        }
-
-        $crate::__pin_project_internal! { @enum=>make_proj_ty;
-            [$proj_vis]
-            [$($proj_mut_ident)?]
-            [make_proj_field_mut]
-            [$ident]
-            [$($impl_generics)*] [$($ty_generics)*] [$(where $($where_clause)*)?]
-            {
-                $(
-                    $variant $({
-                        $(
-                            $(#[$pin])?
-                            $field: $field_ty
-                        ),+
-                    })?
-                ),+
-            }
-        }
-        $crate::__pin_project_internal! { @enum=>make_proj_ty;
-            [$proj_vis]
-            [$($proj_ref_ident)?]
-            [make_proj_field_ref]
-            [$ident]
-            [$($impl_generics)*] [$($ty_generics)*] [$(where $($where_clause)*)?]
-            {
-                $(
-                    $variant $({
-                        $(
-                            $(#[$pin])?
-                            $field: $field_ty
-                        ),+
-                    })?
-                ),+
-            }
-        }
-        $crate::__pin_project_internal! { @enum=>make_proj_replace_ty;
-            [$proj_vis]
-            [$($proj_replace_ident)?]
-            [make_proj_field_replace]
-            [$ident]
-            [$($impl_generics)*] [$($ty_generics)*] [$(where $($where_clause)*)?]
-            {
-                $(
-                    $variant $({
-                        $(
-                            $(#[$pin])?
-                            $field: $field_ty
-                        ),+
-                    })?
-                ),+
-            }
-        }
-
-        #[allow(single_use_lifetimes)] // https://github.com/rust-lang/rust/issues/55058
-        // This lint warns of `clippy::*` generated by external macros.
-        // We allow this lint for compatibility with older compilers.
-        #[allow(clippy::unknown_clippy_lints)]
-        #[allow(clippy::used_underscore_binding)]
-        const _: () = {
-            impl <$($impl_generics)*> $ident <$($ty_generics)*>
-            $(where
-                $($where_clause)*)?
-            {
-                $crate::__pin_project_internal! { @enum=>make_proj_method;
-                    [$proj_vis]
-                    [$($proj_mut_ident)?]
-                    [project get_unchecked_mut mut]
-                    [$($ty_generics)*]
-                    {
-                        $(
-                            $variant $({
-                                $(
-                                    $(#[$pin])?
-                                    $field
-                                ),+
-                            })?
-                        ),+
-                    }
-                }
-                $crate::__pin_project_internal! { @enum=>make_proj_method;
-                    [$proj_vis]
-                    [$($proj_ref_ident)?]
-                    [project_ref get_ref]
-                    [$($ty_generics)*]
-                    {
-                        $(
-                            $variant $({
-                                $(
-                                    $(#[$pin])?
-                                    $field
-                                ),+
-                            })?
-                        ),+
-                    }
-                }
-                $crate::__pin_project_internal! { @enum=>make_proj_replace_method;
-                    [$proj_vis]
-                    [$($proj_replace_ident)?]
-                    [$($ty_generics)*]
-                    {
-                        $(
-                            $variant $({
-                                $(
-                                    $(#[$pin])?
-                                    $field
-                                ),+
-                            })?
-                        ),+
-                    }
-                }
-            }
-
-            $crate::__pin_project_internal! { @make_unpin_impl;
-                [$vis $ident]
-                [$($impl_generics)*] [$($ty_generics)*] [$(where $($where_clause)*)?]
-                $(
-                    $variant: ($(
-                        $(
-                            $crate::__pin_project_internal!(@make_unpin_bound;
-                                $(#[$pin])? $field_ty
-                            )
-                        ),+
-                    )?)
-                ),+
-            }
-
-            $crate::__pin_project_internal! { @make_drop_impl;
-                [$ident]
-                [$($impl_generics)*] [$($ty_generics)*] [$(where $($where_clause)*)?]
-            }
-
-            // We don't need to check for '#[repr(packed)]',
-            // since it does not apply to enums.
-        };
-    };
-
-    // =============================================================================================
-    // struct:make_proj_ty
-    (@struct=>make_proj_ty=>unnamed;
-        [$proj_vis:vis]
-        [$_proj_ty_ident:ident][$proj_ty_ident:ident]
-        [$make_proj_field:ident]
-        [$ident:ident]
-        [$($impl_generics:tt)*] [$($ty_generics:tt)*] [$(where $($where_clause:tt)* )?]
-        $($field:tt)*
-    ) => {};
-    (@struct=>make_proj_ty=>unnamed;
-        [$proj_vis:vis]
-        [][$proj_ty_ident:ident]
-        [$make_proj_field:ident]
-        [$ident:ident]
-        [$($impl_generics:tt)*] [$($ty_generics:tt)*] [$(where $($where_clause:tt)* )?]
-        $($field:tt)*
-    ) => {
-        $crate::__pin_project_internal! { @struct=>make_proj_ty=>named;
-            [$proj_vis]
-            [$proj_ty_ident]
-            [$make_proj_field]
-            [$ident]
-            [$($impl_generics)*] [$($ty_generics)*] [$(where $($where_clause)*)?]
-            $($field)*
-        }
-    };
-    (@struct=>make_proj_ty=>named;
-        [$proj_vis:vis]
-        [$proj_ty_ident:ident]
-        [$make_proj_field:ident]
-        [$ident:ident]
-        [$($impl_generics:tt)*] [$($ty_generics:tt)*] [$(where $($where_clause:tt)* )?]
-        {
-            $(
-                $(#[$pin:ident])?
-                $field_vis:vis $field:ident: $field_ty:ty
-            ),+
-        }
-    ) => {
-        #[allow(dead_code)] // This lint warns unused fields/variants.
-        #[allow(single_use_lifetimes)] // https://github.com/rust-lang/rust/issues/55058
-        // This lint warns of `clippy::*` generated by external macros.
-        // We allow this lint for compatibility with older compilers.
-        #[allow(clippy::unknown_clippy_lints)]
-        #[allow(clippy::mut_mut)] // This lint warns `&mut &mut <ty>`. (only needed for project)
-        #[allow(clippy::redundant_pub_crate)] // This lint warns `pub(crate)` field in private struct.
-        #[allow(clippy::ref_option_ref)] // This lint warns `&Option<&<ty>>`. (only needed for project_ref)
-        #[allow(clippy::type_repetition_in_bounds)] // https://github.com/rust-lang/rust-clippy/issues/4326
-        $proj_vis struct $proj_ty_ident <'__pin, $($impl_generics)*>
-        where
-            $ident <$($ty_generics)*>: '__pin
-            $(, $($where_clause)*)?
-        {
-            $(
-                $field_vis $field: $crate::__pin_project_internal!(@$make_proj_field;
-                    $(#[$pin])? $field_ty
-                )
-            ),+
-        }
-    };
-    (@struct=>make_proj_ty=>named;
-        [$proj_vis:vis]
-        []
-        [$make_proj_field:ident]
-        [$ident:ident]
-        [$($impl_generics:tt)*] [$($ty_generics:tt)*] [$(where $($where_clause:tt)* )?]
-        $($field:tt)*
-    ) => {};
-
-    (@struct=>make_proj_replace_ty=>unnamed;
-        [$proj_vis:vis]
-        [$_proj_ty_ident:ident][$proj_ty_ident:ident]
-        [$make_proj_field:ident]
-        [$ident:ident]
-        [$($impl_generics:tt)*] [$($ty_generics:tt)*] [$(where $($where_clause:tt)* )?]
-        $($field:tt)*
-    ) => {};
-    (@struct=>make_proj_replace_ty=>unnamed;
-        [$proj_vis:vis]
-        [][$proj_ty_ident:ident]
-        [$make_proj_field:ident]
-        [$ident:ident]
-        [$($impl_generics:tt)*] [$($ty_generics:tt)*] [$(where $($where_clause:tt)* )?]
-        $($field:tt)*
-    ) => {
-    };
-    (@struct=>make_proj_replace_ty=>named;
-        [$proj_vis:vis]
-        [$proj_ty_ident:ident]
-        [$make_proj_field:ident]
-        [$ident:ident]
-        [$($impl_generics:tt)*] [$($ty_generics:tt)*] [$(where $($where_clause:tt)* )?]
-        {
-            $(
-                $(#[$pin:ident])?
-                $field_vis:vis $field:ident: $field_ty:ty
-            ),+
-        }
-    ) => {
-        #[allow(dead_code)] // This lint warns unused fields/variants.
-        #[allow(single_use_lifetimes)] // https://github.com/rust-lang/rust/issues/55058
-        #[allow(clippy::mut_mut)] // This lint warns `&mut &mut <ty>`. (only needed for project)
-        #[allow(clippy::redundant_pub_crate)] // This lint warns `pub(crate)` field in private struct.
-        #[allow(clippy::type_repetition_in_bounds)] // https://github.com/rust-lang/rust-clippy/issues/4326
-        $proj_vis struct $proj_ty_ident <$($impl_generics)*>
-        where
-            $($($where_clause)*)?
-        {
-            $(
-                $field_vis $field: $crate::__pin_project_internal!(@$make_proj_field;
-                    $(#[$pin])? $field_ty
-                )
-            ),+
-        }
-    };
-    (@struct=>make_proj_replace_ty=>named;
-        [$proj_vis:vis]
-        []
-        [$make_proj_field:ident]
-        [$ident:ident]
-        [$($impl_generics:tt)*] [$($ty_generics:tt)*] [$(where $($where_clause:tt)* )?]
-        $($field:tt)*
-    ) => {};
-    // =============================================================================================
-    // enum:make_proj_ty
-    (@enum=>make_proj_ty;
-        [$proj_vis:vis]
-        [$proj_ty_ident:ident]
-        [$make_proj_field:ident]
-        [$ident:ident]
-        [$($impl_generics:tt)*] [$($ty_generics:tt)*] [$(where $($where_clause:tt)* )?]
-        {
-            $(
-                $variant:ident $({
-                    $(
-                        $(#[$pin:ident])?
-                        $field:ident: $field_ty:ty
-                    ),+
-                })?
-            ),+
-        }
-    ) => {
-        #[allow(dead_code)] // This lint warns unused fields/variants.
-        #[allow(single_use_lifetimes)] // https://github.com/rust-lang/rust/issues/55058
-        // This lint warns of `clippy::*` generated by external macros.
-        // We allow this lint for compatibility with older compilers.
-        #[allow(clippy::unknown_clippy_lints)]
-        #[allow(clippy::mut_mut)] // This lint warns `&mut &mut <ty>`. (only needed for project)
-        #[allow(clippy::redundant_pub_crate)] // This lint warns `pub(crate)` field in private struct.
-        #[allow(clippy::ref_option_ref)] // This lint warns `&Option<&<ty>>`. (only needed for project_ref)
-        #[allow(clippy::type_repetition_in_bounds)] // https://github.com/rust-lang/rust-clippy/issues/4326
-        $proj_vis enum $proj_ty_ident <'__pin, $($impl_generics)*>
-        where
-            $ident <$($ty_generics)*>: '__pin
-            $(, $($where_clause)*)?
-        {
-            $(
-                $variant $({
-                    $(
-                        $field: $crate::__pin_project_internal!(@$make_proj_field;
-                            $(#[$pin])? $field_ty
-                        )
-                    ),+
-                })?
-            ),+
-        }
-    };
-    (@enum=>make_proj_ty;
-        [$proj_vis:vis]
-        []
-        [$make_proj_field:ident]
-        [$ident:ident]
-        [$($impl_generics:tt)*] [$($ty_generics:tt)*] [$(where $($where_clause:tt)* )?]
-        $($variant:tt)*
-    ) => {};
-
-    (@enum=>make_proj_replace_ty;
-        [$proj_vis:vis]
-        [$proj_ty_ident:ident]
-        [$make_proj_field:ident]
-        [$ident:ident]
-        [$($impl_generics:tt)*] [$($ty_generics:tt)*] [$(where $($where_clause:tt)* )?]
-        {
-            $(
-                $variant:ident $({
-                    $(
-                        $(#[$pin:ident])?
-                        $field:ident: $field_ty:ty
-                    ),+
-                })?
-            ),+
-        }
-    ) => {
-        #[allow(dead_code)] // This lint warns unused fields/variants.
-        #[allow(single_use_lifetimes)] // https://github.com/rust-lang/rust/issues/55058
-        #[allow(clippy::mut_mut)] // This lint warns `&mut &mut <ty>`. (only needed for project)
-        #[allow(clippy::redundant_pub_crate)] // This lint warns `pub(crate)` field in private struct.
-        #[allow(clippy::type_repetition_in_bounds)] // https://github.com/rust-lang/rust-clippy/issues/4326
-        $proj_vis enum $proj_ty_ident <$($impl_generics)*>
-        where
-            $($($where_clause)*)?
-        {
-            $(
-                $variant $({
-                    $(
-                        $field: $crate::__pin_project_internal!(@$make_proj_field;
-                            $(#[$pin])? $field_ty
-                        )
-                    ),+
-                })?
-            ),+
-        }
-    };
-    (@enum=>make_proj_replace_ty;
-        [$proj_vis:vis]
-        []
-        [$make_proj_field:ident]
-        [$ident:ident]
-        [$($impl_generics:tt)*] [$($ty_generics:tt)*] [$(where $($where_clause:tt)* )?]
-        $($variant:tt)*
-    ) => {};
-
-    // =============================================================================================
-    (@make_proj_replace_block;
-        [$($proj_path: tt)+]
-        {
-            $(
-                $(#[$pin:ident])?
-                $field_vis:vis $field:ident
-            ),+
-        }
-    ) => {
-        let result = $($proj_path)* {
-            $(
-                $field: $crate::__pin_project_internal!(@make_replace_field_proj;
-                    $(#[$pin])? $field
-                )
-            ),+
-        };
-
-        {
-            ( $(
-                $crate::__pin_project_internal!(@make_unsafe_drop_in_place_guard;
-                    $(#[$pin])? $field
-                ),
-            )* );
-        }
-
-        result
-    };
-    (@make_proj_replace_block;
-        [$($proj_path: tt)+]
-    ) => {
-        $($proj_path)*
-    };
-
-    // =============================================================================================
-    // struct:make_proj_method
-    (@struct=>make_proj_method;
-        [$proj_vis:vis]
-        [$proj_ty_ident:ident][$_proj_ty_ident:ident]
-        [$method_ident:ident $get_method:ident $($mut:ident)?]
-        [$($ty_generics:tt)*]
-        {
-            $(
-                $(#[$pin:ident])?
-                $field_vis:vis $field:ident
-            ),+
-        }
-    ) => {
-        $proj_vis fn $method_ident<'__pin>(
-            self: $crate::__private::Pin<&'__pin $($mut)? Self>,
-        ) -> $proj_ty_ident <'__pin, $($ty_generics)*> {
-            unsafe {
-                let Self { $($field),* } = self.$get_method();
-                $proj_ty_ident {
-                    $(
-                        $field: $crate::__pin_project_internal!(@make_unsafe_field_proj;
-                            $(#[$pin])? $field
-                        )
-                    ),+
-                }
-            }
-        }
-    };
-    (@struct=>make_proj_method;
-        [$proj_vis:vis]
-        [][$proj_ty_ident:ident]
-        [$method_ident:ident $get_method:ident $($mut:ident)?]
-        [$($ty_generics:tt)*]
-        $($variant:tt)*
-    ) => {
-        $crate::__pin_project_internal! { @struct=>make_proj_method;
-            [$proj_vis]
-            [$proj_ty_ident][$proj_ty_ident]
-            [$method_ident $get_method $($mut)?]
-            [$($ty_generics)*]
-            $($variant)*
-        }
-    };
-
-    (@struct=>make_proj_replace_method;
-        [$proj_vis:vis]
-        [$proj_ty_ident:ident][$_proj_ty_ident:ident]
-        [$($ty_generics:tt)*]
-        {
-            $(
-                $(#[$pin:ident])?
-                $field_vis:vis $field:ident
-            ),+
-        }
-    ) => {
-        $proj_vis fn project_replace(
-            self: $crate::__private::Pin<&mut Self>,
-            replacement: Self,
-        ) -> $proj_ty_ident <$($ty_generics)*> {
-            unsafe {
-                let __self_ptr: *mut Self = self.get_unchecked_mut();
-
-                // Destructors will run in reverse order, so next create a guard to overwrite
-                // `self` with the replacement value without calling destructors.
-                let __guard = $crate::__private::UnsafeOverwriteGuard {
-                    target: __self_ptr,
-                    value: $crate::__private::ManuallyDrop::new(replacement),
-                };
-
-                let Self { $($field),* } = &mut *__self_ptr;
-
-                $crate::__pin_project_internal!{@make_proj_replace_block;
-                    [$proj_ty_ident]
-                    {
-                        $(
-                            $(#[$pin])?
-                            $field
-                        ),+
-                    }
-                }
-            }
-        }
-    };
-    (@struct=>make_proj_replace_method;
-        [$proj_vis:vis]
-        [][$proj_ty_ident:ident]
-        [$($ty_generics:tt)*]
-        $($variant:tt)*
-    ) => {
-    };
-
-    // =============================================================================================
-    // enum:make_proj_method
-    (@enum=>make_proj_method;
-        [$proj_vis:vis]
-        [$proj_ty_ident:ident]
-        [$method_ident:ident $get_method:ident $($mut:ident)?]
-        [$($ty_generics:tt)*]
-        {
-            $(
-                $variant:ident $({
-                    $(
-                        $(#[$pin:ident])?
-                        $field:ident
-                    ),+
-                })?
-            ),+
-        }
-    ) => {
-        $proj_vis fn $method_ident<'__pin>(
-            self: $crate::__private::Pin<&'__pin $($mut)? Self>,
-        ) -> $proj_ty_ident <'__pin, $($ty_generics)*> {
-            unsafe {
-                match self.$get_method() {
-                    $(
-                        Self::$variant $({
-                            $($field),+
-                        })? => {
-                            $proj_ty_ident::$variant $({
-                                $(
-                                    $field: $crate::__pin_project_internal!(
-                                        @make_unsafe_field_proj;
-                                        $(#[$pin])? $field
-                                    )
-                                ),+
-                            })?
-                        }
-                    ),+
-                }
-            }
-        }
-    };
-    (@enum=>make_proj_method;
-        [$proj_vis:vis]
-        []
-        [$method_ident:ident $get_method:ident $($mut:ident)?]
-        [$($ty_generics:tt)*]
-        $($variant:tt)*
-    ) => {};
-
-    (@enum=>make_proj_replace_method;
-        [$proj_vis:vis]
-        [$proj_ty_ident:ident]
-        [$($ty_generics:tt)*]
-        {
-            $(
-                $variant:ident $({
-                    $(
-                        $(#[$pin:ident])?
-                        $field:ident
-                    ),+
-                })?
-            ),+
-        }
-    ) => {
-        $proj_vis fn project_replace(
-            self: $crate::__private::Pin<&mut Self>,
-            replacement: Self,
-        ) -> $proj_ty_ident <$($ty_generics)*> {
-            unsafe {
-                let __self_ptr: *mut Self = self.get_unchecked_mut();
-
-                // Destructors will run in reverse order, so next create a guard to overwrite
-                // `self` with the replacement value without calling destructors.
-                let __guard = $crate::__private::UnsafeOverwriteGuard {
-                    target: __self_ptr,
-                    value: $crate::__private::ManuallyDrop::new(replacement),
-                };
-
-                match &mut *__self_ptr {
-                    $(
-                        Self::$variant $({
-                            $($field),+
-                        })? => {
-                            $crate::__pin_project_internal!{@make_proj_replace_block;
-                                [$proj_ty_ident :: $variant]
-                                $({
-                                    $(
-                                        $(#[$pin])?
-                                        $field
-                                    ),+
-                                })?
-                            }
-                        }
-                    ),+
-                }
-            }
-        }
-    };
-    (@enum=>make_proj_replace_method;
-        [$proj_vis:vis]
-        []
-        [$($ty_generics:tt)*]
-        $($variant:tt)*
-    ) => {};
-
-    // =============================================================================================
-    // make_unpin_impl
-    (@make_unpin_impl;
-        [$vis:vis $ident:ident]
-        [$($impl_generics:tt)*] [$($ty_generics:tt)*] [$(where $($where_clause:tt)* )?]
-        $($field:tt)*
-    ) => {
-        // Automatically create the appropriate conditional `Unpin` implementation.
-        //
-        // Basically this is equivalent to the following code:
-        // ```rust
-        // impl<T, U> Unpin for Struct<T, U> where T: Unpin {}
-        // ```
-        //
-        // However, if struct is public and there is a private type field,
-        // this would cause an E0446 (private type in public interface).
-        //
-        // When RFC 2145 is implemented (rust-lang/rust#48054),
-        // this will become a lint, rather then a hard error.
-        //
-        // As a workaround for this, we generate a new struct, containing all of the pinned
-        // fields from our #[pin_project] type. This struct is delcared within
-        // a function, which makes it impossible to be named by user code.
-        // This guarnatees 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', satisfiying the privacy
-        // checker without actually allowing user code to access it.
-        //
-        // This allows users to apply the #[pin_project] attribute to types
-        // regardless of the privacy of the types of their fields.
-        //
-        // See also https://github.com/taiki-e/pin-project/pull/53.
-        #[allow(non_snake_case)]
-        $vis struct __Origin <'__pin, $($impl_generics)*>
-        $(where
-            $($where_clause)*)?
-        {
-            __dummy_lifetime: $crate::__private::PhantomData<&'__pin ()>,
-            $($field)*
-        }
-        impl <'__pin, $($impl_generics)*> $crate::__private::Unpin for $ident <$($ty_generics)*>
-        where
-            __Origin <'__pin, $($ty_generics)*>: $crate::__private::Unpin
-            $(, $($where_clause)*)?
-        {
-        }
-    };
-
-    // =============================================================================================
-    // make_drop_impl
-    (@make_drop_impl;
-        [$ident:ident]
-        [$($impl_generics:tt)*] [$($ty_generics:tt)*] [$(where $($where_clause:tt)* )?]
-    ) => {
-        // Ensure that struct does not implement `Drop`.
-        //
-        // There are two possible cases:
-        // 1. The user type does not implement Drop. In this case,
-        // the first blanked impl will not apply to it. This code
-        // will compile, as there is only one impl of MustNotImplDrop for the user type
-        // 2. The user type does impl Drop. This will make the blanket impl applicable,
-        // which will then comflict with the explicit MustNotImplDrop impl below.
-        // This will result in a compilation error, which is exactly what we want.
-        trait MustNotImplDrop {}
-        #[allow(clippy::drop_bounds, drop_bounds)]
-        impl<T: $crate::__private::Drop> MustNotImplDrop for T {}
-        impl <$($impl_generics)*> MustNotImplDrop for $ident <$($ty_generics)*>
-        $(where
-            $($where_clause)*)?
-        {
-        }
-    };
-
-    // =============================================================================================
-    // make_unpin_bound
-    (@make_unpin_bound;
-        #[pin]
-        $field_ty:ty
-    ) => {
-        $field_ty
-    };
-    (@make_unpin_bound;
-        $field_ty:ty
-    ) => {
-        $crate::__private::AlwaysUnpin<$field_ty>
-    };
-
-    // =============================================================================================
-    // make_unsafe_field_proj
-    (@make_unsafe_field_proj;
-        #[pin]
-        $field:ident
-    ) => {
-        $crate::__private::Pin::new_unchecked($field)
-    };
-    (@make_unsafe_field_proj;
-        $field:ident
-    ) => {
-        $field
-    };
-
-    // =============================================================================================
-    // make_replace_field_proj
-    (@make_replace_field_proj;
-        #[pin]
-        $field:ident
-    ) => {
-        $crate::__private::PhantomData
-    };
-    (@make_replace_field_proj;
-        $field:ident
-    ) => {
-        $crate::__private::ptr::read($field)
-    };
-
-
-    // =============================================================================================
-    // make_unsafe_drop_in_place_guard
-    (@make_unsafe_drop_in_place_guard;
-        #[pin]
-        $field:ident
-    ) => {
-        $crate::__private::UnsafeDropInPlaceGuard($field)
-    };
-    (@make_unsafe_drop_in_place_guard;
-        $field:ident
-    ) => {
-        ()
-    };
-
-    // =============================================================================================
-    // make_proj_field
-    (@make_proj_field_mut;
-        #[pin]
-        $field_ty:ty
-    ) => {
-        $crate::__private::Pin<&'__pin mut ($field_ty)>
-    };
-    (@make_proj_field_mut;
-        $field_ty:ty
-    ) => {
-        &'__pin mut ($field_ty)
-    };
-    (@make_proj_field_ref;
-        #[pin]
-        $field_ty:ty
-    ) => {
-        $crate::__private::Pin<&'__pin ($field_ty)>
-    };
-    (@make_proj_field_ref;
-        $field_ty:ty
-    ) => {
-        &'__pin ($field_ty)
-    };
-
-    (@make_proj_field_replace;
-        #[pin]
-        $field_ty:ty
-    ) => {
-        $crate::__private::PhantomData<$field_ty>
-    };
-    (@make_proj_field_replace;
-        $field_ty:ty
-    ) => {
-        $field_ty
-    };
-
-    // =============================================================================================
-    // Parses input and determines visibility
-    // struct
-    (
-        [$($proj_mut_ident:ident)?]
-        [$($proj_ref_ident:ident)?]
-        [$($proj_replace_ident:ident)?]
-
-        $(#[$attrs:meta])*
-        pub struct $ident:ident $(<
-            $( $lifetime:lifetime $(: $lifetime_bound:lifetime)? ),* $(,)?
-            $( $generics:ident
-                $(: $generics_bound:path)?
-                $(: ?$generics_unsized_bound:path)?
-                $(: $generics_lifetime_bound:lifetime)?
-                $(= $generics_default:ty)?
-            ),* $(,)?
-        >)?
-        $(where
-            $( $where_clause_ty:ty
-                $(: $where_clause_bound:path)?
-                $(: ?$where_clause_unsized_bound:path)?
-                $(: $where_clause_lifetime_bound:lifetime)?
-            ),* $(,)?
-        )?
-        {
-            $(
-                $(#[$pin:ident])?
-                $field_vis:vis $field:ident: $field_ty:ty
-            ),+ $(,)?
-        }
-    ) => {
-        $crate::__pin_project_internal! { @struct=>internal;
-            [$($proj_mut_ident)?]
-            [$($proj_ref_ident)?]
-            [$($proj_replace_ident)?]
-            [pub(crate)]
-            [$(#[$attrs])* pub struct $ident]
-            [$(<
-                $( $lifetime $(: $lifetime_bound)? ,)*
-                $( $generics
-                    $(: $generics_bound)?
-                    $(: ?$generics_unsized_bound)?
-                    $(: $generics_lifetime_bound)?
-                    $(= $generics_default)?
-                ),*
-            >)?]
-            [$(
-                $( $lifetime $(: $lifetime_bound)? ,)*
-                $( $generics
-                    $(: $generics_bound)?
-                    $(: ?$generics_unsized_bound)?
-                    $(: $generics_lifetime_bound)?
-                ),*
-            )?]
-            [$( $( $lifetime ,)* $( $generics ),* )?]
-            [$(where $( $where_clause_ty
-                $(: $where_clause_bound)?
-                $(: ?$where_clause_unsized_bound)?
-                $(: $where_clause_lifetime_bound)?
-            ),* )?]
-            {
-                $(
-                    $(#[$pin])?
-                    $field_vis $field: $field_ty
-                ),+
-            }
-        }
-    };
-    (
-        [$($proj_mut_ident:ident)?]
-        [$($proj_ref_ident:ident)?]
-        [$($proj_replace_ident:ident)?]
-
-        $(#[$attrs:meta])*
-        $vis:vis struct $ident:ident $(<
-            $( $lifetime:lifetime $(: $lifetime_bound:lifetime)? ),* $(,)?
-            $( $generics:ident
-                $(: $generics_bound:path)?
-                $(: ?$generics_unsized_bound:path)?
-                $(: $generics_lifetime_bound:lifetime)?
-                $(= $generics_default:ty)?
-            ),* $(,)?
-        >)?
-        $(where
-            $( $where_clause_ty:ty
-                $(: $where_clause_bound:path)?
-                $(: ?$where_clause_unsized_bound:path)?
-                $(: $where_clause_lifetime_bound:lifetime)?
-            ),* $(,)?
-        )?
-        {
-            $(
-                $(#[$pin:ident])?
-                $field_vis:vis $field:ident: $field_ty:ty
-            ),+ $(,)?
-        }
-    ) => {
-        $crate::__pin_project_internal! { @struct=>internal;
-            [$($proj_mut_ident)?]
-            [$($proj_ref_ident)?]
-            [$($proj_replace_ident)?]
-            [$vis]
-            [$(#[$attrs])* $vis struct $ident]
-            [$(<
-                $( $lifetime $(: $lifetime_bound)? ,)*
-                $( $generics
-                    $(: $generics_bound)?
-                    $(: ?$generics_unsized_bound)?
-                    $(: $generics_lifetime_bound)?
-                    $(= $generics_default)?
-                ),*
-            >)?]
-            [$(
-                $( $lifetime $(: $lifetime_bound)? ,)*
-                $( $generics
-                    $(: $generics_bound)?
-                    $(: ?$generics_unsized_bound)?
-                    $(: $generics_lifetime_bound)?
-                ),*
-            )?]
-            [$( $( $lifetime ,)* $( $generics ),* )?]
-            [$(where $( $where_clause_ty
-                $(: $where_clause_bound)?
-                $(: ?$where_clause_unsized_bound)?
-                $(: $where_clause_lifetime_bound)?
-            ),* )?]
-            {
-                $(
-                    $(#[$pin])?
-                    $field_vis $field: $field_ty
-                ),+
-            }
-        }
-    };
-    // enum
-    (
-        [$($proj_mut_ident:ident)?]
-        [$($proj_ref_ident:ident)?]
-        [$($proj_replace_ident:ident)?]
-
-        $(#[$attrs:meta])*
-        pub enum $ident:ident $(<
-            $( $lifetime:lifetime $(: $lifetime_bound:lifetime)? ),* $(,)?
-            $( $generics:ident
-                $(: $generics_bound:path)?
-                $(: ?$generics_unsized_bound:path)?
-                $(: $generics_lifetime_bound:lifetime)?
-                $(= $generics_default:ty)?
-            ),* $(,)?
-        >)?
-        $(where
-            $( $where_clause_ty:ty
-                $(: $where_clause_bound:path)?
-                $(: ?$where_clause_unsized_bound:path)?
-                $(: $where_clause_lifetime_bound:lifetime)?
-            ),* $(,)?
-        )?
-        {
-            $(
-                $(#[$variant_attrs:meta])*
-                $variant:ident $({
-                    $(
-                        $(#[$pin:ident])?
-                        $field:ident: $field_ty:ty
-                    ),+ $(,)?
-                })?
-            ),+ $(,)?
-        }
-    ) => {
-        $crate::__pin_project_internal! { @enum=>internal;
-            [$($proj_mut_ident)?]
-            [$($proj_ref_ident)?]
-            [$($proj_replace_ident)?]
-            [pub(crate)]
-            [$(#[$attrs])* pub enum $ident]
-            [$(<
-                $( $lifetime $(: $lifetime_bound)? ,)*
-                $( $generics
-                    $(: $generics_bound)?
-                    $(: ?$generics_unsized_bound)?
-                    $(: $generics_lifetime_bound)?
-                    $(= $generics_default)?
-                ),*
-            >)?]
-            [$(
-                $( $lifetime $(: $lifetime_bound)? ,)*
-                $( $generics
-                    $(: $generics_bound)?
-                    $(: ?$generics_unsized_bound)?
-                    $(: $generics_lifetime_bound)?
-                ),*
-            )?]
-            [$( $( $lifetime ,)* $( $generics ),* )?]
-            [$(where $( $where_clause_ty
-                $(: $where_clause_bound)?
-                $(: ?$where_clause_unsized_bound)?
-                $(: $where_clause_lifetime_bound)?
-            ),* )?]
-            {
-                $(
-                    $(#[$variant_attrs])*
-                    $variant $({
-                        $(
-                            $(#[$pin])?
-                            $field: $field_ty
-                        ),+
-                    })?
-                ),+
-            }
-        }
-    };
-    (
-        [$($proj_mut_ident:ident)?]
-        [$($proj_ref_ident:ident)?]
-        [$($proj_replace_ident:ident)?]
-
-        $(#[$attrs:meta])*
-        $vis:vis enum $ident:ident $(<
-            $( $lifetime:lifetime $(: $lifetime_bound:lifetime)? ),* $(,)?
-            $( $generics:ident
-                $(: $generics_bound:path)?
-                $(: ?$generics_unsized_bound:path)?
-                $(: $generics_lifetime_bound:lifetime)?
-                $(= $generics_default:ty)?
-            ),* $(,)?
-        >)?
-        $(where
-            $( $where_clause_ty:ty
-                $(: $where_clause_bound:path)?
-                $(: ?$where_clause_unsized_bound:path)?
-                $(: $where_clause_lifetime_bound:lifetime)?
-            ),* $(,)?
-        )?
-        {
-            $(
-                $(#[$variant_attrs:meta])*
-                $variant:ident $({
-                    $(
-                        $(#[$pin:ident])?
-                        $field:ident: $field_ty:ty
-                    ),+ $(,)?
-                })?
-            ),+ $(,)?
-        }
-    ) => {
-        $crate::__pin_project_internal! { @enum=>internal;
-            [$($proj_mut_ident)?]
-            [$($proj_ref_ident)?]
-            [$($proj_replace_ident)?]
-            [$vis]
-            [$(#[$attrs])* $vis enum $ident]
-            [$(<
-                $( $lifetime $(: $lifetime_bound)? ,)*
-                $( $generics
-                    $(: $generics_bound)?
-                    $(: ?$generics_unsized_bound)?
-                    $(: $generics_lifetime_bound)?
-                    $(= $generics_default)?
-                ),*
-            >)?]
-            [$(
-                $( $lifetime $(: $lifetime_bound)? ,)*
-                $( $generics
-                    $(: $generics_bound)?
-                    $(: ?$generics_unsized_bound)?
-                    $(: $generics_lifetime_bound)?
-                ),*
-            )?]
-            [$( $( $lifetime ,)* $( $generics ),* )?]
-            [$(where $( $where_clause_ty
-                $(: $where_clause_bound)?
-                $(: ?$where_clause_unsized_bound)?
-                $(: $where_clause_lifetime_bound)?
-            ),* )?]
-            {
-                $(
-                    $(#[$variant_attrs])*
-                    $variant $({
-                        $(
-                            $(#[$pin])?
-                            $field: $field_ty
-                        ),+
-                    })?
-                ),+
-            }
-        }
-    };
-}
-
-// Not public API.
-#[doc(hidden)]
-pub mod __private {
-    #[doc(hidden)]
-    pub use core::{
-        marker::{PhantomData, Unpin},
-        mem::ManuallyDrop,
-        ops::Drop,
-        pin::Pin,
-        ptr,
-    };
-
-    // This is an internal helper struct used by `pin_project!`.
-    #[doc(hidden)]
-    pub struct AlwaysUnpin<T: ?Sized>(PhantomData<T>);
-
-    impl<T: ?Sized> Unpin for AlwaysUnpin<T> {}
-
-    // This is an internal helper used to ensure a value is dropped.
-    #[doc(hidden)]
-    pub struct UnsafeDropInPlaceGuard<T: ?Sized>(pub *mut T);
-
-    impl<T: ?Sized> Drop for UnsafeDropInPlaceGuard<T> {
-        fn drop(&mut self) {
-            unsafe {
-                ptr::drop_in_place(self.0);
-            }
-        }
-    }
-
-    // This is an internal helper used to ensure a value is overwritten without
-    // its destructor being called.
-    #[doc(hidden)]
-    pub struct UnsafeOverwriteGuard<T> {
-        pub value: ManuallyDrop<T>,
-        pub target: *mut T,
-    }
-
-    impl<T> Drop for UnsafeOverwriteGuard<T> {
-        fn drop(&mut self) {
-            unsafe {
-                ptr::write(self.target, ptr::read(&*self.value));
-            }
-        }
-    }
-}
diff --git a/tests/auxiliary/mod.rs b/tests/auxiliary/mod.rs
index e39037c..1457099 100644
--- a/tests/auxiliary/mod.rs
+++ b/tests/auxiliary/mod.rs
@@ -1,6 +1,4 @@
 #![allow(dead_code, unused_macros)]
-#![allow(box_pointers, unreachable_pub)]
-#![allow(clippy::restriction)]
 
 macro_rules! assert_unpin {
     ($ty:ty) => {
diff --git a/tests/compiletest.rs b/tests/compiletest.rs
index 5a91b20..8970215 100644
--- a/tests/compiletest.rs
+++ b/tests/compiletest.rs
@@ -3,7 +3,7 @@
 
 use std::env;
 
-#[rustversion::attr(before(2020-12-03), ignore)] // Note: This date is commit-date and the day before the toolchain date.
+#[rustversion::attr(before(2021-05-15), ignore)] // Note: This date is commit-date and the day before the toolchain date.
 #[test]
 fn ui() {
     if env::var_os("CI").is_none() {
@@ -11,5 +11,5 @@ fn ui() {
     }
 
     let t = trybuild::TestCases::new();
-    t.compile_fail("tests/ui/*.rs");
+    t.compile_fail("tests/ui/*/*.rs");
 }
diff --git a/tests/drop_order.rs b/tests/drop_order.rs
index d84c324..6e5deaf 100644
--- a/tests/drop_order.rs
+++ b/tests/drop_order.rs
@@ -2,9 +2,10 @@
 
 // Refs: https://doc.rust-lang.org/reference/destructors.html
 
-use pin_project_lite::pin_project;
 use std::{cell::Cell, panic, pin::Pin, thread};
 
+use pin_project_lite::pin_project;
+
 struct D<'a>(&'a Cell<usize>, usize);
 
 impl Drop for D<'_> {
@@ -128,7 +129,7 @@ fn project_replace_panic() {
         fn drop(&mut self) {
             *self.0 = true;
             if self.1 {
-                panic!()
+                panic!();
             }
         }
     }
diff --git a/tests/expand/README.md b/tests/expand/README.md
new file mode 100644
index 0000000..1f7dcfb
--- /dev/null
+++ b/tests/expand/README.md
@@ -0,0 +1,17 @@
+# Expansion tests
+
+Similar to ui tests, but instead of checking the compiler output, this checks
+the code generated by macros.
+
+See [examples](https://github.com/taiki-e/pin-project/tree/HEAD/examples) for
+descriptions of what the generated code does, and why it needs to be generated.
+
+To run this test, run the following command:
+
+```sh
+cargo +nightly test --test expandtest
+```
+
+Locally, this test updates the files in the `expand` directory if there are
+changes to the generated code. If there are any changes to the files in the
+`expand` directory after running the test, please commit them.
diff --git a/tests/expand/default/enum.expanded.rs b/tests/expand/default/enum.expanded.rs
new file mode 100644
index 0000000..df005ad
--- /dev/null
+++ b/tests/expand/default/enum.expanded.rs
@@ -0,0 +1,127 @@
+use pin_project_lite::pin_project;
+enum Enum<T, U> {
+    Struct { pinned: T, unpinned: U },
+    Unit,
+}
+#[allow(dead_code)]
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::mut_mut)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::ref_option_ref)]
+#[allow(clippy::type_repetition_in_bounds)]
+enum EnumProj<'__pin, T, U>
+where
+    Enum<T, U>: '__pin,
+{
+    Struct {
+        pinned: ::pin_project_lite::__private::Pin<&'__pin mut (T)>,
+        unpinned: &'__pin mut (U),
+    },
+    Unit,
+}
+#[allow(dead_code)]
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::mut_mut)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::ref_option_ref)]
+#[allow(clippy::type_repetition_in_bounds)]
+enum EnumProjRef<'__pin, T, U>
+where
+    Enum<T, U>: '__pin,
+{
+    Struct {
+        pinned: ::pin_project_lite::__private::Pin<&'__pin (T)>,
+        unpinned: &'__pin (U),
+    },
+    Unit,
+}
+#[allow(dead_code)]
+#[allow(single_use_lifetimes)]
+#[allow(clippy::mut_mut)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+enum EnumProjReplace<T, U> {
+    Struct {
+        pinned: ::pin_project_lite::__private::PhantomData<T>,
+        unpinned: U,
+    },
+    Unit,
+}
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    impl<T, U> Enum<T, U> {
+        fn project<'__pin>(
+            self: ::pin_project_lite::__private::Pin<&'__pin mut Self>,
+        ) -> EnumProj<'__pin, T, U> {
+            unsafe {
+                match self.get_unchecked_mut() {
+                    Self::Struct { pinned, unpinned } => EnumProj::Struct {
+                        pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned),
+                        unpinned: unpinned,
+                    },
+                    Self::Unit => EnumProj::Unit,
+                }
+            }
+        }
+        fn project_ref<'__pin>(
+            self: ::pin_project_lite::__private::Pin<&'__pin Self>,
+        ) -> EnumProjRef<'__pin, T, U> {
+            unsafe {
+                match self.get_ref() {
+                    Self::Struct { pinned, unpinned } => EnumProjRef::Struct {
+                        pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned),
+                        unpinned: unpinned,
+                    },
+                    Self::Unit => EnumProjRef::Unit,
+                }
+            }
+        }
+        fn project_replace(
+            self: ::pin_project_lite::__private::Pin<&mut Self>,
+            replacement: Self,
+        ) -> EnumProjReplace<T, U> {
+            unsafe {
+                let __self_ptr: *mut Self = self.get_unchecked_mut();
+                let __guard = ::pin_project_lite::__private::UnsafeOverwriteGuard {
+                    target: __self_ptr,
+                    value: ::pin_project_lite::__private::ManuallyDrop::new(replacement),
+                };
+                match &mut *__self_ptr {
+                    Self::Struct { pinned, unpinned } => {
+                        let result = EnumProjReplace::Struct {
+                            pinned: ::pin_project_lite::__private::PhantomData,
+                            unpinned: ::pin_project_lite::__private::ptr::read(unpinned),
+                        };
+                        {
+                            (
+                                ::pin_project_lite::__private::UnsafeDropInPlaceGuard(pinned),
+                                (),
+                            );
+                        }
+                        result
+                    }
+                    Self::Unit => EnumProjReplace::Unit,
+                }
+            }
+        }
+    }
+    #[allow(non_snake_case)]
+    struct __Origin<'__pin, T, U> {
+        __dummy_lifetime: ::pin_project_lite::__private::PhantomData<&'__pin ()>,
+        Struct: (T, ::pin_project_lite::__private::AlwaysUnpin<U>),
+        Unit: (),
+    }
+    impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Enum<T, U> where
+        __Origin<'__pin, T, U>: ::pin_project_lite::__private::Unpin
+    {
+    }
+    trait MustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: ::pin_project_lite::__private::Drop> MustNotImplDrop for T {}
+    impl<T, U> MustNotImplDrop for Enum<T, U> {}
+};
+fn main() {}
diff --git a/tests/expand/default/enum.rs b/tests/expand/default/enum.rs
new file mode 100644
index 0000000..90d6860
--- /dev/null
+++ b/tests/expand/default/enum.rs
@@ -0,0 +1,17 @@
+use pin_project_lite::pin_project;
+
+pin_project! {
+    #[project = EnumProj]
+    #[project_ref = EnumProjRef]
+    #[project_replace = EnumProjReplace]
+    enum Enum<T, U> {
+        Struct {
+            #[pin]
+            pinned: T,
+            unpinned: U,
+        },
+        Unit,
+    }
+}
+
+fn main() {}
diff --git a/tests/expand/default/struct.expanded.rs b/tests/expand/default/struct.expanded.rs
new file mode 100644
index 0000000..8ab318c
--- /dev/null
+++ b/tests/expand/default/struct.expanded.rs
@@ -0,0 +1,84 @@
+use pin_project_lite::pin_project;
+struct Struct<T, U> {
+    pinned: T,
+    unpinned: U,
+}
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    #[allow(dead_code)]
+    #[allow(single_use_lifetimes)]
+    #[allow(clippy::unknown_clippy_lints)]
+    #[allow(clippy::mut_mut)]
+    #[allow(clippy::redundant_pub_crate)]
+    #[allow(clippy::ref_option_ref)]
+    #[allow(clippy::type_repetition_in_bounds)]
+    struct Projection<'__pin, T, U>
+    where
+        Struct<T, U>: '__pin,
+    {
+        pinned: ::pin_project_lite::__private::Pin<&'__pin mut (T)>,
+        unpinned: &'__pin mut (U),
+    }
+    #[allow(dead_code)]
+    #[allow(single_use_lifetimes)]
+    #[allow(clippy::unknown_clippy_lints)]
+    #[allow(clippy::mut_mut)]
+    #[allow(clippy::redundant_pub_crate)]
+    #[allow(clippy::ref_option_ref)]
+    #[allow(clippy::type_repetition_in_bounds)]
+    struct ProjectionRef<'__pin, T, U>
+    where
+        Struct<T, U>: '__pin,
+    {
+        pinned: ::pin_project_lite::__private::Pin<&'__pin (T)>,
+        unpinned: &'__pin (U),
+    }
+    impl<T, U> Struct<T, U> {
+        fn project<'__pin>(
+            self: ::pin_project_lite::__private::Pin<&'__pin mut Self>,
+        ) -> Projection<'__pin, T, U> {
+            unsafe {
+                let Self { pinned, unpinned } = self.get_unchecked_mut();
+                Projection {
+                    pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned),
+                    unpinned: unpinned,
+                }
+            }
+        }
+        fn project_ref<'__pin>(
+            self: ::pin_project_lite::__private::Pin<&'__pin Self>,
+        ) -> ProjectionRef<'__pin, T, U> {
+            unsafe {
+                let Self { pinned, unpinned } = self.get_ref();
+                ProjectionRef {
+                    pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned),
+                    unpinned: unpinned,
+                }
+            }
+        }
+    }
+    #[allow(non_snake_case)]
+    struct __Origin<'__pin, T, U> {
+        __dummy_lifetime: ::pin_project_lite::__private::PhantomData<&'__pin ()>,
+        pinned: T,
+        unpinned: ::pin_project_lite::__private::AlwaysUnpin<U>,
+    }
+    impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Struct<T, U> where
+        __Origin<'__pin, T, U>: ::pin_project_lite::__private::Unpin
+    {
+    }
+    trait MustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: ::pin_project_lite::__private::Drop> MustNotImplDrop for T {}
+    impl<T, U> MustNotImplDrop for Struct<T, U> {}
+    #[forbid(unaligned_references, safe_packed_borrows)]
+    fn __assert_not_repr_packed<T, U>(this: &Struct<T, U>) {
+        let _ = &this.pinned;
+        let _ = &this.unpinned;
+    }
+};
+fn main() {}
diff --git a/tests/expand/default/struct.rs b/tests/expand/default/struct.rs
new file mode 100644
index 0000000..e5447c7
--- /dev/null
+++ b/tests/expand/default/struct.rs
@@ -0,0 +1,11 @@
+use pin_project_lite::pin_project;
+
+pin_project! {
+    struct Struct<T, U> {
+        #[pin]
+        pinned: T,
+        unpinned: U,
+    }
+}
+
+fn main() {}
diff --git a/tests/expand/multifields/enum.expanded.rs b/tests/expand/multifields/enum.expanded.rs
new file mode 100644
index 0000000..a0b17cb
--- /dev/null
+++ b/tests/expand/multifields/enum.expanded.rs
@@ -0,0 +1,88 @@
+use pin_project_lite::pin_project;
+enum Enum<T, U> {
+    Struct {
+        pinned1: T,
+        pinned2: T,
+        unpinned1: U,
+        unpinned2: U,
+    },
+    Unit,
+}
+#[allow(dead_code)]
+#[allow(single_use_lifetimes)]
+#[allow(clippy::mut_mut)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+enum EnumProjReplace<T, U> {
+    Struct {
+        pinned1: ::pin_project_lite::__private::PhantomData<T>,
+        pinned2: ::pin_project_lite::__private::PhantomData<T>,
+        unpinned1: U,
+        unpinned2: U,
+    },
+    Unit,
+}
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    impl<T, U> Enum<T, U> {
+        fn project_replace(
+            self: ::pin_project_lite::__private::Pin<&mut Self>,
+            replacement: Self,
+        ) -> EnumProjReplace<T, U> {
+            unsafe {
+                let __self_ptr: *mut Self = self.get_unchecked_mut();
+                let __guard = ::pin_project_lite::__private::UnsafeOverwriteGuard {
+                    target: __self_ptr,
+                    value: ::pin_project_lite::__private::ManuallyDrop::new(replacement),
+                };
+                match &mut *__self_ptr {
+                    Self::Struct {
+                        pinned1,
+                        pinned2,
+                        unpinned1,
+                        unpinned2,
+                    } => {
+                        let result = EnumProjReplace::Struct {
+                            pinned1: ::pin_project_lite::__private::PhantomData,
+                            pinned2: ::pin_project_lite::__private::PhantomData,
+                            unpinned1: ::pin_project_lite::__private::ptr::read(unpinned1),
+                            unpinned2: ::pin_project_lite::__private::ptr::read(unpinned2),
+                        };
+                        {
+                            (
+                                ::pin_project_lite::__private::UnsafeDropInPlaceGuard(pinned1),
+                                ::pin_project_lite::__private::UnsafeDropInPlaceGuard(pinned2),
+                                (),
+                                (),
+                            );
+                        }
+                        result
+                    }
+                    Self::Unit => EnumProjReplace::Unit,
+                }
+            }
+        }
+    }
+    #[allow(non_snake_case)]
+    struct __Origin<'__pin, T, U> {
+        __dummy_lifetime: ::pin_project_lite::__private::PhantomData<&'__pin ()>,
+        Struct: (
+            T,
+            T,
+            ::pin_project_lite::__private::AlwaysUnpin<U>,
+            ::pin_project_lite::__private::AlwaysUnpin<U>,
+        ),
+        Unit: (),
+    }
+    impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Enum<T, U> where
+        __Origin<'__pin, T, U>: ::pin_project_lite::__private::Unpin
+    {
+    }
+    trait MustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: ::pin_project_lite::__private::Drop> MustNotImplDrop for T {}
+    impl<T, U> MustNotImplDrop for Enum<T, U> {}
+};
+fn main() {}
diff --git a/tests/expand/multifields/enum.rs b/tests/expand/multifields/enum.rs
new file mode 100644
index 0000000..c713362
--- /dev/null
+++ b/tests/expand/multifields/enum.rs
@@ -0,0 +1,18 @@
+use pin_project_lite::pin_project;
+
+pin_project! {
+#[project_replace = EnumProjReplace]
+enum Enum<T, U> {
+    Struct {
+        #[pin]
+        pinned1: T,
+        #[pin]
+        pinned2: T,
+        unpinned1: U,
+        unpinned2: U,
+    },
+    Unit,
+}
+}
+
+fn main() {}
diff --git a/tests/expand/multifields/struct.expanded.rs b/tests/expand/multifields/struct.expanded.rs
new file mode 100644
index 0000000..638bf56
--- /dev/null
+++ b/tests/expand/multifields/struct.expanded.rs
@@ -0,0 +1,152 @@
+use pin_project_lite::pin_project;
+struct Struct<T, U> {
+    pinned1: T,
+    pinned2: T,
+    unpinned1: U,
+    unpinned2: U,
+}
+#[allow(dead_code)]
+#[allow(single_use_lifetimes)]
+#[allow(clippy::mut_mut)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+struct StructProjReplace<T, U> {
+    pinned1: ::pin_project_lite::__private::PhantomData<T>,
+    pinned2: ::pin_project_lite::__private::PhantomData<T>,
+    unpinned1: U,
+    unpinned2: U,
+}
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    #[allow(dead_code)]
+    #[allow(single_use_lifetimes)]
+    #[allow(clippy::unknown_clippy_lints)]
+    #[allow(clippy::mut_mut)]
+    #[allow(clippy::redundant_pub_crate)]
+    #[allow(clippy::ref_option_ref)]
+    #[allow(clippy::type_repetition_in_bounds)]
+    struct Projection<'__pin, T, U>
+    where
+        Struct<T, U>: '__pin,
+    {
+        pinned1: ::pin_project_lite::__private::Pin<&'__pin mut (T)>,
+        pinned2: ::pin_project_lite::__private::Pin<&'__pin mut (T)>,
+        unpinned1: &'__pin mut (U),
+        unpinned2: &'__pin mut (U),
+    }
+    #[allow(dead_code)]
+    #[allow(single_use_lifetimes)]
+    #[allow(clippy::unknown_clippy_lints)]
+    #[allow(clippy::mut_mut)]
+    #[allow(clippy::redundant_pub_crate)]
+    #[allow(clippy::ref_option_ref)]
+    #[allow(clippy::type_repetition_in_bounds)]
+    struct ProjectionRef<'__pin, T, U>
+    where
+        Struct<T, U>: '__pin,
+    {
+        pinned1: ::pin_project_lite::__private::Pin<&'__pin (T)>,
+        pinned2: ::pin_project_lite::__private::Pin<&'__pin (T)>,
+        unpinned1: &'__pin (U),
+        unpinned2: &'__pin (U),
+    }
+    impl<T, U> Struct<T, U> {
+        fn project<'__pin>(
+            self: ::pin_project_lite::__private::Pin<&'__pin mut Self>,
+        ) -> Projection<'__pin, T, U> {
+            unsafe {
+                let Self {
+                    pinned1,
+                    pinned2,
+                    unpinned1,
+                    unpinned2,
+                } = self.get_unchecked_mut();
+                Projection {
+                    pinned1: ::pin_project_lite::__private::Pin::new_unchecked(pinned1),
+                    pinned2: ::pin_project_lite::__private::Pin::new_unchecked(pinned2),
+                    unpinned1: unpinned1,
+                    unpinned2: unpinned2,
+                }
+            }
+        }
+        fn project_ref<'__pin>(
+            self: ::pin_project_lite::__private::Pin<&'__pin Self>,
+        ) -> ProjectionRef<'__pin, T, U> {
+            unsafe {
+                let Self {
+                    pinned1,
+                    pinned2,
+                    unpinned1,
+                    unpinned2,
+                } = self.get_ref();
+                ProjectionRef {
+                    pinned1: ::pin_project_lite::__private::Pin::new_unchecked(pinned1),
+                    pinned2: ::pin_project_lite::__private::Pin::new_unchecked(pinned2),
+                    unpinned1: unpinned1,
+                    unpinned2: unpinned2,
+                }
+            }
+        }
+        fn project_replace(
+            self: ::pin_project_lite::__private::Pin<&mut Self>,
+            replacement: Self,
+        ) -> StructProjReplace<T, U> {
+            unsafe {
+                let __self_ptr: *mut Self = self.get_unchecked_mut();
+                let __guard = ::pin_project_lite::__private::UnsafeOverwriteGuard {
+                    target: __self_ptr,
+                    value: ::pin_project_lite::__private::ManuallyDrop::new(replacement),
+                };
+                let Self {
+                    pinned1,
+                    pinned2,
+                    unpinned1,
+                    unpinned2,
+                } = &mut *__self_ptr;
+                let result = StructProjReplace {
+                    pinned1: ::pin_project_lite::__private::PhantomData,
+                    pinned2: ::pin_project_lite::__private::PhantomData,
+                    unpinned1: ::pin_project_lite::__private::ptr::read(unpinned1),
+                    unpinned2: ::pin_project_lite::__private::ptr::read(unpinned2),
+                };
+                {
+                    (
+                        ::pin_project_lite::__private::UnsafeDropInPlaceGuard(pinned1),
+                        ::pin_project_lite::__private::UnsafeDropInPlaceGuard(pinned2),
+                        (),
+                        (),
+                    );
+                }
+                result
+            }
+        }
+    }
+    #[allow(non_snake_case)]
+    struct __Origin<'__pin, T, U> {
+        __dummy_lifetime: ::pin_project_lite::__private::PhantomData<&'__pin ()>,
+        pinned1: T,
+        pinned2: T,
+        unpinned1: ::pin_project_lite::__private::AlwaysUnpin<U>,
+        unpinned2: ::pin_project_lite::__private::AlwaysUnpin<U>,
+    }
+    impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Struct<T, U> where
+        __Origin<'__pin, T, U>: ::pin_project_lite::__private::Unpin
+    {
+    }
+    trait MustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: ::pin_project_lite::__private::Drop> MustNotImplDrop for T {}
+    impl<T, U> MustNotImplDrop for Struct<T, U> {}
+    #[forbid(unaligned_references, safe_packed_borrows)]
+    fn __assert_not_repr_packed<T, U>(this: &Struct<T, U>) {
+        let _ = &this.pinned1;
+        let _ = &this.pinned2;
+        let _ = &this.unpinned1;
+        let _ = &this.unpinned2;
+    }
+};
+fn main() {}
diff --git a/tests/expand/multifields/struct.rs b/tests/expand/multifields/struct.rs
new file mode 100644
index 0000000..a1d45d1
--- /dev/null
+++ b/tests/expand/multifields/struct.rs
@@ -0,0 +1,15 @@
+use pin_project_lite::pin_project;
+
+pin_project! {
+#[project_replace = StructProjReplace]
+struct Struct<T, U> {
+    #[pin]
+    pinned1: T,
+    #[pin]
+    pinned2: T,
+    unpinned1: U,
+    unpinned2: U,
+}
+}
+
+fn main() {}
diff --git a/tests/expand/naming/enum-all.expanded.rs b/tests/expand/naming/enum-all.expanded.rs
new file mode 100644
index 0000000..df005ad
--- /dev/null
+++ b/tests/expand/naming/enum-all.expanded.rs
@@ -0,0 +1,127 @@
+use pin_project_lite::pin_project;
+enum Enum<T, U> {
+    Struct { pinned: T, unpinned: U },
+    Unit,
+}
+#[allow(dead_code)]
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::mut_mut)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::ref_option_ref)]
+#[allow(clippy::type_repetition_in_bounds)]
+enum EnumProj<'__pin, T, U>
+where
+    Enum<T, U>: '__pin,
+{
+    Struct {
+        pinned: ::pin_project_lite::__private::Pin<&'__pin mut (T)>,
+        unpinned: &'__pin mut (U),
+    },
+    Unit,
+}
+#[allow(dead_code)]
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::mut_mut)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::ref_option_ref)]
+#[allow(clippy::type_repetition_in_bounds)]
+enum EnumProjRef<'__pin, T, U>
+where
+    Enum<T, U>: '__pin,
+{
+    Struct {
+        pinned: ::pin_project_lite::__private::Pin<&'__pin (T)>,
+        unpinned: &'__pin (U),
+    },
+    Unit,
+}
+#[allow(dead_code)]
+#[allow(single_use_lifetimes)]
+#[allow(clippy::mut_mut)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+enum EnumProjReplace<T, U> {
+    Struct {
+        pinned: ::pin_project_lite::__private::PhantomData<T>,
+        unpinned: U,
+    },
+    Unit,
+}
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    impl<T, U> Enum<T, U> {
+        fn project<'__pin>(
+            self: ::pin_project_lite::__private::Pin<&'__pin mut Self>,
+        ) -> EnumProj<'__pin, T, U> {
+            unsafe {
+                match self.get_unchecked_mut() {
+                    Self::Struct { pinned, unpinned } => EnumProj::Struct {
+                        pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned),
+                        unpinned: unpinned,
+                    },
+                    Self::Unit => EnumProj::Unit,
+                }
+            }
+        }
+        fn project_ref<'__pin>(
+            self: ::pin_project_lite::__private::Pin<&'__pin Self>,
+        ) -> EnumProjRef<'__pin, T, U> {
+            unsafe {
+                match self.get_ref() {
+                    Self::Struct { pinned, unpinned } => EnumProjRef::Struct {
+                        pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned),
+                        unpinned: unpinned,
+                    },
+                    Self::Unit => EnumProjRef::Unit,
+                }
+            }
+        }
+        fn project_replace(
+            self: ::pin_project_lite::__private::Pin<&mut Self>,
+            replacement: Self,
+        ) -> EnumProjReplace<T, U> {
+            unsafe {
+                let __self_ptr: *mut Self = self.get_unchecked_mut();
+                let __guard = ::pin_project_lite::__private::UnsafeOverwriteGuard {
+                    target: __self_ptr,
+                    value: ::pin_project_lite::__private::ManuallyDrop::new(replacement),
+                };
+                match &mut *__self_ptr {
+                    Self::Struct { pinned, unpinned } => {
+                        let result = EnumProjReplace::Struct {
+                            pinned: ::pin_project_lite::__private::PhantomData,
+                            unpinned: ::pin_project_lite::__private::ptr::read(unpinned),
+                        };
+                        {
+                            (
+                                ::pin_project_lite::__private::UnsafeDropInPlaceGuard(pinned),
+                                (),
+                            );
+                        }
+                        result
+                    }
+                    Self::Unit => EnumProjReplace::Unit,
+                }
+            }
+        }
+    }
+    #[allow(non_snake_case)]
+    struct __Origin<'__pin, T, U> {
+        __dummy_lifetime: ::pin_project_lite::__private::PhantomData<&'__pin ()>,
+        Struct: (T, ::pin_project_lite::__private::AlwaysUnpin<U>),
+        Unit: (),
+    }
+    impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Enum<T, U> where
+        __Origin<'__pin, T, U>: ::pin_project_lite::__private::Unpin
+    {
+    }
+    trait MustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: ::pin_project_lite::__private::Drop> MustNotImplDrop for T {}
+    impl<T, U> MustNotImplDrop for Enum<T, U> {}
+};
+fn main() {}
diff --git a/tests/expand/naming/enum-all.rs b/tests/expand/naming/enum-all.rs
new file mode 100644
index 0000000..90d6860
--- /dev/null
+++ b/tests/expand/naming/enum-all.rs
@@ -0,0 +1,17 @@
+use pin_project_lite::pin_project;
+
+pin_project! {
+    #[project = EnumProj]
+    #[project_ref = EnumProjRef]
+    #[project_replace = EnumProjReplace]
+    enum Enum<T, U> {
+        Struct {
+            #[pin]
+            pinned: T,
+            unpinned: U,
+        },
+        Unit,
+    }
+}
+
+fn main() {}
diff --git a/tests/expand/naming/enum-mut.expanded.rs b/tests/expand/naming/enum-mut.expanded.rs
new file mode 100644
index 0000000..7c4d6af
--- /dev/null
+++ b/tests/expand/naming/enum-mut.expanded.rs
@@ -0,0 +1,57 @@
+use pin_project_lite::pin_project;
+enum Enum<T, U> {
+    Struct { pinned: T, unpinned: U },
+    Unit,
+}
+#[allow(dead_code)]
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::mut_mut)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::ref_option_ref)]
+#[allow(clippy::type_repetition_in_bounds)]
+enum EnumProj<'__pin, T, U>
+where
+    Enum<T, U>: '__pin,
+{
+    Struct {
+        pinned: ::pin_project_lite::__private::Pin<&'__pin mut (T)>,
+        unpinned: &'__pin mut (U),
+    },
+    Unit,
+}
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    impl<T, U> Enum<T, U> {
+        fn project<'__pin>(
+            self: ::pin_project_lite::__private::Pin<&'__pin mut Self>,
+        ) -> EnumProj<'__pin, T, U> {
+            unsafe {
+                match self.get_unchecked_mut() {
+                    Self::Struct { pinned, unpinned } => EnumProj::Struct {
+                        pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned),
+                        unpinned: unpinned,
+                    },
+                    Self::Unit => EnumProj::Unit,
+                }
+            }
+        }
+    }
+    #[allow(non_snake_case)]
+    struct __Origin<'__pin, T, U> {
+        __dummy_lifetime: ::pin_project_lite::__private::PhantomData<&'__pin ()>,
+        Struct: (T, ::pin_project_lite::__private::AlwaysUnpin<U>),
+        Unit: (),
+    }
+    impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Enum<T, U> where
+        __Origin<'__pin, T, U>: ::pin_project_lite::__private::Unpin
+    {
+    }
+    trait MustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: ::pin_project_lite::__private::Drop> MustNotImplDrop for T {}
+    impl<T, U> MustNotImplDrop for Enum<T, U> {}
+};
+fn main() {}
diff --git a/tests/expand/naming/enum-mut.rs b/tests/expand/naming/enum-mut.rs
new file mode 100644
index 0000000..69beecd
--- /dev/null
+++ b/tests/expand/naming/enum-mut.rs
@@ -0,0 +1,15 @@
+use pin_project_lite::pin_project;
+
+pin_project! {
+    #[project = EnumProj]
+    enum Enum<T, U> {
+        Struct {
+            #[pin]
+            pinned: T,
+            unpinned: U,
+        },
+        Unit,
+    }
+}
+
+fn main() {}
diff --git a/tests/expand/naming/enum-none.expanded.rs b/tests/expand/naming/enum-none.expanded.rs
new file mode 100644
index 0000000..28ce97d
--- /dev/null
+++ b/tests/expand/naming/enum-none.expanded.rs
@@ -0,0 +1,26 @@
+use pin_project_lite::pin_project;
+enum Enum<T, U> {
+    Struct { pinned: T, unpinned: U },
+    Unit,
+}
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    impl<T, U> Enum<T, U> {}
+    #[allow(non_snake_case)]
+    struct __Origin<'__pin, T, U> {
+        __dummy_lifetime: ::pin_project_lite::__private::PhantomData<&'__pin ()>,
+        Struct: (T, ::pin_project_lite::__private::AlwaysUnpin<U>),
+        Unit: (),
+    }
+    impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Enum<T, U> where
+        __Origin<'__pin, T, U>: ::pin_project_lite::__private::Unpin
+    {
+    }
+    trait MustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: ::pin_project_lite::__private::Drop> MustNotImplDrop for T {}
+    impl<T, U> MustNotImplDrop for Enum<T, U> {}
+};
+fn main() {}
diff --git a/tests/expand/naming/enum-none.rs b/tests/expand/naming/enum-none.rs
new file mode 100644
index 0000000..b2e3f9d
--- /dev/null
+++ b/tests/expand/naming/enum-none.rs
@@ -0,0 +1,14 @@
+use pin_project_lite::pin_project;
+
+pin_project! {
+    enum Enum<T, U> {
+        Struct {
+            #[pin]
+            pinned: T,
+            unpinned: U,
+        },
+        Unit,
+    }
+}
+
+fn main() {}
diff --git a/tests/expand/naming/enum-ref.expanded.rs b/tests/expand/naming/enum-ref.expanded.rs
new file mode 100644
index 0000000..a1a013b
--- /dev/null
+++ b/tests/expand/naming/enum-ref.expanded.rs
@@ -0,0 +1,57 @@
+use pin_project_lite::pin_project;
+enum Enum<T, U> {
+    Struct { pinned: T, unpinned: U },
+    Unit,
+}
+#[allow(dead_code)]
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::mut_mut)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::ref_option_ref)]
+#[allow(clippy::type_repetition_in_bounds)]
+enum EnumProjRef<'__pin, T, U>
+where
+    Enum<T, U>: '__pin,
+{
+    Struct {
+        pinned: ::pin_project_lite::__private::Pin<&'__pin (T)>,
+        unpinned: &'__pin (U),
+    },
+    Unit,
+}
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    impl<T, U> Enum<T, U> {
+        fn project_ref<'__pin>(
+            self: ::pin_project_lite::__private::Pin<&'__pin Self>,
+        ) -> EnumProjRef<'__pin, T, U> {
+            unsafe {
+                match self.get_ref() {
+                    Self::Struct { pinned, unpinned } => EnumProjRef::Struct {
+                        pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned),
+                        unpinned: unpinned,
+                    },
+                    Self::Unit => EnumProjRef::Unit,
+                }
+            }
+        }
+    }
+    #[allow(non_snake_case)]
+    struct __Origin<'__pin, T, U> {
+        __dummy_lifetime: ::pin_project_lite::__private::PhantomData<&'__pin ()>,
+        Struct: (T, ::pin_project_lite::__private::AlwaysUnpin<U>),
+        Unit: (),
+    }
+    impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Enum<T, U> where
+        __Origin<'__pin, T, U>: ::pin_project_lite::__private::Unpin
+    {
+    }
+    trait MustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: ::pin_project_lite::__private::Drop> MustNotImplDrop for T {}
+    impl<T, U> MustNotImplDrop for Enum<T, U> {}
+};
+fn main() {}
diff --git a/tests/expand/naming/enum-ref.rs b/tests/expand/naming/enum-ref.rs
new file mode 100644
index 0000000..480d592
--- /dev/null
+++ b/tests/expand/naming/enum-ref.rs
@@ -0,0 +1,15 @@
+use pin_project_lite::pin_project;
+
+pin_project! {
+    #[project_ref = EnumProjRef]
+    enum Enum<T, U> {
+        Struct {
+            #[pin]
+            pinned: T,
+            unpinned: U,
+        },
+        Unit,
+    }
+}
+
+fn main() {}
diff --git a/tests/expand/naming/struct-all.expanded.rs b/tests/expand/naming/struct-all.expanded.rs
new file mode 100644
index 0000000..5d2f135
--- /dev/null
+++ b/tests/expand/naming/struct-all.expanded.rs
@@ -0,0 +1,117 @@
+use pin_project_lite::pin_project;
+struct Struct<T, U> {
+    pinned: T,
+    unpinned: U,
+}
+#[allow(dead_code)]
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::mut_mut)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::ref_option_ref)]
+#[allow(clippy::type_repetition_in_bounds)]
+struct StructProj<'__pin, T, U>
+where
+    Struct<T, U>: '__pin,
+{
+    pinned: ::pin_project_lite::__private::Pin<&'__pin mut (T)>,
+    unpinned: &'__pin mut (U),
+}
+#[allow(dead_code)]
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::mut_mut)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::ref_option_ref)]
+#[allow(clippy::type_repetition_in_bounds)]
+struct StructProjRef<'__pin, T, U>
+where
+    Struct<T, U>: '__pin,
+{
+    pinned: ::pin_project_lite::__private::Pin<&'__pin (T)>,
+    unpinned: &'__pin (U),
+}
+#[allow(dead_code)]
+#[allow(single_use_lifetimes)]
+#[allow(clippy::mut_mut)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+struct StructProjReplace<T, U> {
+    pinned: ::pin_project_lite::__private::PhantomData<T>,
+    unpinned: U,
+}
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    impl<T, U> Struct<T, U> {
+        fn project<'__pin>(
+            self: ::pin_project_lite::__private::Pin<&'__pin mut Self>,
+        ) -> StructProj<'__pin, T, U> {
+            unsafe {
+                let Self { pinned, unpinned } = self.get_unchecked_mut();
+                StructProj {
+                    pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned),
+                    unpinned: unpinned,
+                }
+            }
+        }
+        fn project_ref<'__pin>(
+            self: ::pin_project_lite::__private::Pin<&'__pin Self>,
+        ) -> StructProjRef<'__pin, T, U> {
+            unsafe {
+                let Self { pinned, unpinned } = self.get_ref();
+                StructProjRef {
+                    pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned),
+                    unpinned: unpinned,
+                }
+            }
+        }
+        fn project_replace(
+            self: ::pin_project_lite::__private::Pin<&mut Self>,
+            replacement: Self,
+        ) -> StructProjReplace<T, U> {
+            unsafe {
+                let __self_ptr: *mut Self = self.get_unchecked_mut();
+                let __guard = ::pin_project_lite::__private::UnsafeOverwriteGuard {
+                    target: __self_ptr,
+                    value: ::pin_project_lite::__private::ManuallyDrop::new(replacement),
+                };
+                let Self { pinned, unpinned } = &mut *__self_ptr;
+                let result = StructProjReplace {
+                    pinned: ::pin_project_lite::__private::PhantomData,
+                    unpinned: ::pin_project_lite::__private::ptr::read(unpinned),
+                };
+                {
+                    (
+                        ::pin_project_lite::__private::UnsafeDropInPlaceGuard(pinned),
+                        (),
+                    );
+                }
+                result
+            }
+        }
+    }
+    #[allow(non_snake_case)]
+    struct __Origin<'__pin, T, U> {
+        __dummy_lifetime: ::pin_project_lite::__private::PhantomData<&'__pin ()>,
+        pinned: T,
+        unpinned: ::pin_project_lite::__private::AlwaysUnpin<U>,
+    }
+    impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Struct<T, U> where
+        __Origin<'__pin, T, U>: ::pin_project_lite::__private::Unpin
+    {
+    }
+    trait MustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: ::pin_project_lite::__private::Drop> MustNotImplDrop for T {}
+    impl<T, U> MustNotImplDrop for Struct<T, U> {}
+    #[forbid(unaligned_references, safe_packed_borrows)]
+    fn __assert_not_repr_packed<T, U>(this: &Struct<T, U>) {
+        let _ = &this.pinned;
+        let _ = &this.unpinned;
+    }
+};
+fn main() {}
diff --git a/tests/expand/naming/struct-all.rs b/tests/expand/naming/struct-all.rs
new file mode 100644
index 0000000..cb08753
--- /dev/null
+++ b/tests/expand/naming/struct-all.rs
@@ -0,0 +1,14 @@
+use pin_project_lite::pin_project;
+
+pin_project! {
+    #[project = StructProj]
+    #[project_ref = StructProjRef]
+    #[project_replace = StructProjReplace]
+    struct Struct<T, U> {
+        #[pin]
+        pinned: T,
+        unpinned: U,
+    }
+}
+
+fn main() {}
diff --git a/tests/expand/naming/struct-mut.expanded.rs b/tests/expand/naming/struct-mut.expanded.rs
new file mode 100644
index 0000000..aaa41cd
--- /dev/null
+++ b/tests/expand/naming/struct-mut.expanded.rs
@@ -0,0 +1,84 @@
+use pin_project_lite::pin_project;
+struct Struct<T, U> {
+    pinned: T,
+    unpinned: U,
+}
+#[allow(dead_code)]
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::mut_mut)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::ref_option_ref)]
+#[allow(clippy::type_repetition_in_bounds)]
+struct StructProj<'__pin, T, U>
+where
+    Struct<T, U>: '__pin,
+{
+    pinned: ::pin_project_lite::__private::Pin<&'__pin mut (T)>,
+    unpinned: &'__pin mut (U),
+}
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    #[allow(dead_code)]
+    #[allow(single_use_lifetimes)]
+    #[allow(clippy::unknown_clippy_lints)]
+    #[allow(clippy::mut_mut)]
+    #[allow(clippy::redundant_pub_crate)]
+    #[allow(clippy::ref_option_ref)]
+    #[allow(clippy::type_repetition_in_bounds)]
+    struct ProjectionRef<'__pin, T, U>
+    where
+        Struct<T, U>: '__pin,
+    {
+        pinned: ::pin_project_lite::__private::Pin<&'__pin (T)>,
+        unpinned: &'__pin (U),
+    }
+    impl<T, U> Struct<T, U> {
+        fn project<'__pin>(
+            self: ::pin_project_lite::__private::Pin<&'__pin mut Self>,
+        ) -> StructProj<'__pin, T, U> {
+            unsafe {
+                let Self { pinned, unpinned } = self.get_unchecked_mut();
+                StructProj {
+                    pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned),
+                    unpinned: unpinned,
+                }
+            }
+        }
+        fn project_ref<'__pin>(
+            self: ::pin_project_lite::__private::Pin<&'__pin Self>,
+        ) -> ProjectionRef<'__pin, T, U> {
+            unsafe {
+                let Self { pinned, unpinned } = self.get_ref();
+                ProjectionRef {
+                    pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned),
+                    unpinned: unpinned,
+                }
+            }
+        }
+    }
+    #[allow(non_snake_case)]
+    struct __Origin<'__pin, T, U> {
+        __dummy_lifetime: ::pin_project_lite::__private::PhantomData<&'__pin ()>,
+        pinned: T,
+        unpinned: ::pin_project_lite::__private::AlwaysUnpin<U>,
+    }
+    impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Struct<T, U> where
+        __Origin<'__pin, T, U>: ::pin_project_lite::__private::Unpin
+    {
+    }
+    trait MustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: ::pin_project_lite::__private::Drop> MustNotImplDrop for T {}
+    impl<T, U> MustNotImplDrop for Struct<T, U> {}
+    #[forbid(unaligned_references, safe_packed_borrows)]
+    fn __assert_not_repr_packed<T, U>(this: &Struct<T, U>) {
+        let _ = &this.pinned;
+        let _ = &this.unpinned;
+    }
+};
+fn main() {}
diff --git a/tests/expand/naming/struct-mut.rs b/tests/expand/naming/struct-mut.rs
new file mode 100644
index 0000000..59db445
--- /dev/null
+++ b/tests/expand/naming/struct-mut.rs
@@ -0,0 +1,12 @@
+use pin_project_lite::pin_project;
+
+pin_project! {
+    #[project = StructProj]
+    struct Struct<T, U> {
+        #[pin]
+        pinned: T,
+        unpinned: U,
+    }
+}
+
+fn main() {}
diff --git a/tests/expand/naming/struct-none.expanded.rs b/tests/expand/naming/struct-none.expanded.rs
new file mode 100644
index 0000000..8ab318c
--- /dev/null
+++ b/tests/expand/naming/struct-none.expanded.rs
@@ -0,0 +1,84 @@
+use pin_project_lite::pin_project;
+struct Struct<T, U> {
+    pinned: T,
+    unpinned: U,
+}
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    #[allow(dead_code)]
+    #[allow(single_use_lifetimes)]
+    #[allow(clippy::unknown_clippy_lints)]
+    #[allow(clippy::mut_mut)]
+    #[allow(clippy::redundant_pub_crate)]
+    #[allow(clippy::ref_option_ref)]
+    #[allow(clippy::type_repetition_in_bounds)]
+    struct Projection<'__pin, T, U>
+    where
+        Struct<T, U>: '__pin,
+    {
+        pinned: ::pin_project_lite::__private::Pin<&'__pin mut (T)>,
+        unpinned: &'__pin mut (U),
+    }
+    #[allow(dead_code)]
+    #[allow(single_use_lifetimes)]
+    #[allow(clippy::unknown_clippy_lints)]
+    #[allow(clippy::mut_mut)]
+    #[allow(clippy::redundant_pub_crate)]
+    #[allow(clippy::ref_option_ref)]
+    #[allow(clippy::type_repetition_in_bounds)]
+    struct ProjectionRef<'__pin, T, U>
+    where
+        Struct<T, U>: '__pin,
+    {
+        pinned: ::pin_project_lite::__private::Pin<&'__pin (T)>,
+        unpinned: &'__pin (U),
+    }
+    impl<T, U> Struct<T, U> {
+        fn project<'__pin>(
+            self: ::pin_project_lite::__private::Pin<&'__pin mut Self>,
+        ) -> Projection<'__pin, T, U> {
+            unsafe {
+                let Self { pinned, unpinned } = self.get_unchecked_mut();
+                Projection {
+                    pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned),
+                    unpinned: unpinned,
+                }
+            }
+        }
+        fn project_ref<'__pin>(
+            self: ::pin_project_lite::__private::Pin<&'__pin Self>,
+        ) -> ProjectionRef<'__pin, T, U> {
+            unsafe {
+                let Self { pinned, unpinned } = self.get_ref();
+                ProjectionRef {
+                    pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned),
+                    unpinned: unpinned,
+                }
+            }
+        }
+    }
+    #[allow(non_snake_case)]
+    struct __Origin<'__pin, T, U> {
+        __dummy_lifetime: ::pin_project_lite::__private::PhantomData<&'__pin ()>,
+        pinned: T,
+        unpinned: ::pin_project_lite::__private::AlwaysUnpin<U>,
+    }
+    impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Struct<T, U> where
+        __Origin<'__pin, T, U>: ::pin_project_lite::__private::Unpin
+    {
+    }
+    trait MustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: ::pin_project_lite::__private::Drop> MustNotImplDrop for T {}
+    impl<T, U> MustNotImplDrop for Struct<T, U> {}
+    #[forbid(unaligned_references, safe_packed_borrows)]
+    fn __assert_not_repr_packed<T, U>(this: &Struct<T, U>) {
+        let _ = &this.pinned;
+        let _ = &this.unpinned;
+    }
+};
+fn main() {}
diff --git a/tests/expand/naming/struct-none.rs b/tests/expand/naming/struct-none.rs
new file mode 100644
index 0000000..e5447c7
--- /dev/null
+++ b/tests/expand/naming/struct-none.rs
@@ -0,0 +1,11 @@
+use pin_project_lite::pin_project;
+
+pin_project! {
+    struct Struct<T, U> {
+        #[pin]
+        pinned: T,
+        unpinned: U,
+    }
+}
+
+fn main() {}
diff --git a/tests/expand/naming/struct-ref.expanded.rs b/tests/expand/naming/struct-ref.expanded.rs
new file mode 100644
index 0000000..3d97ab8
--- /dev/null
+++ b/tests/expand/naming/struct-ref.expanded.rs
@@ -0,0 +1,84 @@
+use pin_project_lite::pin_project;
+struct Struct<T, U> {
+    pinned: T,
+    unpinned: U,
+}
+#[allow(dead_code)]
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::mut_mut)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::ref_option_ref)]
+#[allow(clippy::type_repetition_in_bounds)]
+struct StructProjRef<'__pin, T, U>
+where
+    Struct<T, U>: '__pin,
+{
+    pinned: ::pin_project_lite::__private::Pin<&'__pin (T)>,
+    unpinned: &'__pin (U),
+}
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    #[allow(dead_code)]
+    #[allow(single_use_lifetimes)]
+    #[allow(clippy::unknown_clippy_lints)]
+    #[allow(clippy::mut_mut)]
+    #[allow(clippy::redundant_pub_crate)]
+    #[allow(clippy::ref_option_ref)]
+    #[allow(clippy::type_repetition_in_bounds)]
+    struct Projection<'__pin, T, U>
+    where
+        Struct<T, U>: '__pin,
+    {
+        pinned: ::pin_project_lite::__private::Pin<&'__pin mut (T)>,
+        unpinned: &'__pin mut (U),
+    }
+    impl<T, U> Struct<T, U> {
+        fn project<'__pin>(
+            self: ::pin_project_lite::__private::Pin<&'__pin mut Self>,
+        ) -> Projection<'__pin, T, U> {
+            unsafe {
+                let Self { pinned, unpinned } = self.get_unchecked_mut();
+                Projection {
+                    pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned),
+                    unpinned: unpinned,
+                }
+            }
+        }
+        fn project_ref<'__pin>(
+            self: ::pin_project_lite::__private::Pin<&'__pin Self>,
+        ) -> StructProjRef<'__pin, T, U> {
+            unsafe {
+                let Self { pinned, unpinned } = self.get_ref();
+                StructProjRef {
+                    pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned),
+                    unpinned: unpinned,
+                }
+            }
+        }
+    }
+    #[allow(non_snake_case)]
+    struct __Origin<'__pin, T, U> {
+        __dummy_lifetime: ::pin_project_lite::__private::PhantomData<&'__pin ()>,
+        pinned: T,
+        unpinned: ::pin_project_lite::__private::AlwaysUnpin<U>,
+    }
+    impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Struct<T, U> where
+        __Origin<'__pin, T, U>: ::pin_project_lite::__private::Unpin
+    {
+    }
+    trait MustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: ::pin_project_lite::__private::Drop> MustNotImplDrop for T {}
+    impl<T, U> MustNotImplDrop for Struct<T, U> {}
+    #[forbid(unaligned_references, safe_packed_borrows)]
+    fn __assert_not_repr_packed<T, U>(this: &Struct<T, U>) {
+        let _ = &this.pinned;
+        let _ = &this.unpinned;
+    }
+};
+fn main() {}
diff --git a/tests/expand/naming/struct-ref.rs b/tests/expand/naming/struct-ref.rs
new file mode 100644
index 0000000..6821af8
--- /dev/null
+++ b/tests/expand/naming/struct-ref.rs
@@ -0,0 +1,12 @@
+use pin_project_lite::pin_project;
+
+pin_project! {
+    #[project_ref = StructProjRef]
+    struct Struct<T, U> {
+        #[pin]
+        pinned: T,
+        unpinned: U,
+    }
+}
+
+fn main() {}
diff --git a/tests/expand/pinned_drop/enum.expanded.rs b/tests/expand/pinned_drop/enum.expanded.rs
new file mode 100644
index 0000000..665ff63
--- /dev/null
+++ b/tests/expand/pinned_drop/enum.expanded.rs
@@ -0,0 +1,95 @@
+use pin_project_lite::pin_project;
+use std::pin::Pin;
+enum Enum<T, U> {
+    Struct { pinned: T, unpinned: U },
+    Unit,
+}
+#[allow(dead_code)]
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::mut_mut)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::ref_option_ref)]
+#[allow(clippy::type_repetition_in_bounds)]
+enum EnumProj<'__pin, T, U>
+where
+    Enum<T, U>: '__pin,
+{
+    Struct {
+        pinned: ::pin_project_lite::__private::Pin<&'__pin mut (T)>,
+        unpinned: &'__pin mut (U),
+    },
+    Unit,
+}
+#[allow(dead_code)]
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::mut_mut)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::ref_option_ref)]
+#[allow(clippy::type_repetition_in_bounds)]
+enum EnumProjRef<'__pin, T, U>
+where
+    Enum<T, U>: '__pin,
+{
+    Struct {
+        pinned: ::pin_project_lite::__private::Pin<&'__pin (T)>,
+        unpinned: &'__pin (U),
+    },
+    Unit,
+}
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    impl<T, U> Enum<T, U> {
+        fn project<'__pin>(
+            self: ::pin_project_lite::__private::Pin<&'__pin mut Self>,
+        ) -> EnumProj<'__pin, T, U> {
+            unsafe {
+                match self.get_unchecked_mut() {
+                    Self::Struct { pinned, unpinned } => EnumProj::Struct {
+                        pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned),
+                        unpinned: unpinned,
+                    },
+                    Self::Unit => EnumProj::Unit,
+                }
+            }
+        }
+        fn project_ref<'__pin>(
+            self: ::pin_project_lite::__private::Pin<&'__pin Self>,
+        ) -> EnumProjRef<'__pin, T, U> {
+            unsafe {
+                match self.get_ref() {
+                    Self::Struct { pinned, unpinned } => EnumProjRef::Struct {
+                        pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned),
+                        unpinned: unpinned,
+                    },
+                    Self::Unit => EnumProjRef::Unit,
+                }
+            }
+        }
+    }
+    #[allow(non_snake_case)]
+    struct __Origin<'__pin, T, U> {
+        __dummy_lifetime: ::pin_project_lite::__private::PhantomData<&'__pin ()>,
+        Struct: (T, ::pin_project_lite::__private::AlwaysUnpin<U>),
+        Unit: (),
+    }
+    impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Enum<T, U> where
+        __Origin<'__pin, T, U>: ::pin_project_lite::__private::Unpin
+    {
+    }
+    impl<T, U> ::pin_project_lite::__private::Drop for Enum<T, U> {
+        fn drop(&mut self) {
+            fn __drop_inner<T, U>(this: ::pin_project_lite::__private::Pin<&mut Enum<T, U>>) {
+                fn __drop_inner() {}
+                let _ = this;
+            }
+            let pinned_self: ::pin_project_lite::__private::Pin<&mut Self> =
+                unsafe { ::pin_project_lite::__private::Pin::new_unchecked(self) };
+            __drop_inner(pinned_self);
+        }
+    }
+};
+fn main() {}
diff --git a/tests/expand/pinned_drop/enum.rs b/tests/expand/pinned_drop/enum.rs
new file mode 100644
index 0000000..1855cb7
--- /dev/null
+++ b/tests/expand/pinned_drop/enum.rs
@@ -0,0 +1,22 @@
+use pin_project_lite::pin_project;
+use std::pin::Pin;
+
+pin_project! {
+    #[project = EnumProj]
+    #[project_ref = EnumProjRef]
+    enum Enum<T, U> {
+        Struct {
+            #[pin]
+            pinned: T,
+            unpinned: U,
+        },
+        Unit,
+    }
+    impl<T, U> PinnedDrop for Enum<T, U> {
+        fn drop(this: Pin<&mut Self>) {
+            let _ = this;
+        }
+    }
+}
+
+fn main() {}
diff --git a/tests/expand/pinned_drop/struct.expanded.rs b/tests/expand/pinned_drop/struct.expanded.rs
new file mode 100644
index 0000000..5b82b7a
--- /dev/null
+++ b/tests/expand/pinned_drop/struct.expanded.rs
@@ -0,0 +1,92 @@
+use pin_project_lite::pin_project;
+use std::pin::Pin;
+struct Struct<T, U> {
+    pinned: T,
+    unpinned: U,
+}
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    #[allow(dead_code)]
+    #[allow(single_use_lifetimes)]
+    #[allow(clippy::unknown_clippy_lints)]
+    #[allow(clippy::mut_mut)]
+    #[allow(clippy::redundant_pub_crate)]
+    #[allow(clippy::ref_option_ref)]
+    #[allow(clippy::type_repetition_in_bounds)]
+    struct Projection<'__pin, T, U>
+    where
+        Struct<T, U>: '__pin,
+    {
+        pinned: ::pin_project_lite::__private::Pin<&'__pin mut (T)>,
+        unpinned: &'__pin mut (U),
+    }
+    #[allow(dead_code)]
+    #[allow(single_use_lifetimes)]
+    #[allow(clippy::unknown_clippy_lints)]
+    #[allow(clippy::mut_mut)]
+    #[allow(clippy::redundant_pub_crate)]
+    #[allow(clippy::ref_option_ref)]
+    #[allow(clippy::type_repetition_in_bounds)]
+    struct ProjectionRef<'__pin, T, U>
+    where
+        Struct<T, U>: '__pin,
+    {
+        pinned: ::pin_project_lite::__private::Pin<&'__pin (T)>,
+        unpinned: &'__pin (U),
+    }
+    impl<T, U> Struct<T, U> {
+        fn project<'__pin>(
+            self: ::pin_project_lite::__private::Pin<&'__pin mut Self>,
+        ) -> Projection<'__pin, T, U> {
+            unsafe {
+                let Self { pinned, unpinned } = self.get_unchecked_mut();
+                Projection {
+                    pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned),
+                    unpinned: unpinned,
+                }
+            }
+        }
+        fn project_ref<'__pin>(
+            self: ::pin_project_lite::__private::Pin<&'__pin Self>,
+        ) -> ProjectionRef<'__pin, T, U> {
+            unsafe {
+                let Self { pinned, unpinned } = self.get_ref();
+                ProjectionRef {
+                    pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned),
+                    unpinned: unpinned,
+                }
+            }
+        }
+    }
+    #[allow(non_snake_case)]
+    struct __Origin<'__pin, T, U> {
+        __dummy_lifetime: ::pin_project_lite::__private::PhantomData<&'__pin ()>,
+        pinned: T,
+        unpinned: ::pin_project_lite::__private::AlwaysUnpin<U>,
+    }
+    impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Struct<T, U> where
+        __Origin<'__pin, T, U>: ::pin_project_lite::__private::Unpin
+    {
+    }
+    impl<T, U> ::pin_project_lite::__private::Drop for Struct<T, U> {
+        fn drop(&mut self) {
+            fn __drop_inner<T, U>(this: ::pin_project_lite::__private::Pin<&mut Struct<T, U>>) {
+                fn __drop_inner() {}
+                let _ = this;
+            }
+            let pinned_self: ::pin_project_lite::__private::Pin<&mut Self> =
+                unsafe { ::pin_project_lite::__private::Pin::new_unchecked(self) };
+            __drop_inner(pinned_self);
+        }
+    }
+    #[forbid(unaligned_references, safe_packed_borrows)]
+    fn __assert_not_repr_packed<T, U>(this: &Struct<T, U>) {
+        let _ = &this.pinned;
+        let _ = &this.unpinned;
+    }
+};
+fn main() {}
diff --git a/tests/expand/pinned_drop/struct.rs b/tests/expand/pinned_drop/struct.rs
new file mode 100644
index 0000000..0cc7567
--- /dev/null
+++ b/tests/expand/pinned_drop/struct.rs
@@ -0,0 +1,17 @@
+use pin_project_lite::pin_project;
+use std::pin::Pin;
+
+pin_project! {
+    struct Struct<T, U> {
+        #[pin]
+        pinned: T,
+        unpinned: U,
+    }
+    impl<T, U> PinnedDrop for Struct<T, U> {
+        fn drop(this: Pin<&mut Self>) {
+            let _ = this;
+        }
+    }
+}
+
+fn main() {}
diff --git a/tests/expand/pub/enum.expanded.rs b/tests/expand/pub/enum.expanded.rs
new file mode 100644
index 0000000..6f190cb
--- /dev/null
+++ b/tests/expand/pub/enum.expanded.rs
@@ -0,0 +1,87 @@
+use pin_project_lite::pin_project;
+pub enum Enum<T, U> {
+    Struct { pinned: T, unpinned: U },
+    Unit,
+}
+#[allow(dead_code)]
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::mut_mut)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::ref_option_ref)]
+#[allow(clippy::type_repetition_in_bounds)]
+pub(crate) enum EnumProj<'__pin, T, U>
+where
+    Enum<T, U>: '__pin,
+{
+    Struct {
+        pinned: ::pin_project_lite::__private::Pin<&'__pin mut (T)>,
+        unpinned: &'__pin mut (U),
+    },
+    Unit,
+}
+#[allow(dead_code)]
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::mut_mut)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::ref_option_ref)]
+#[allow(clippy::type_repetition_in_bounds)]
+pub(crate) enum EnumProjRef<'__pin, T, U>
+where
+    Enum<T, U>: '__pin,
+{
+    Struct {
+        pinned: ::pin_project_lite::__private::Pin<&'__pin (T)>,
+        unpinned: &'__pin (U),
+    },
+    Unit,
+}
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    impl<T, U> Enum<T, U> {
+        pub(crate) fn project<'__pin>(
+            self: ::pin_project_lite::__private::Pin<&'__pin mut Self>,
+        ) -> EnumProj<'__pin, T, U> {
+            unsafe {
+                match self.get_unchecked_mut() {
+                    Self::Struct { pinned, unpinned } => EnumProj::Struct {
+                        pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned),
+                        unpinned: unpinned,
+                    },
+                    Self::Unit => EnumProj::Unit,
+                }
+            }
+        }
+        pub(crate) fn project_ref<'__pin>(
+            self: ::pin_project_lite::__private::Pin<&'__pin Self>,
+        ) -> EnumProjRef<'__pin, T, U> {
+            unsafe {
+                match self.get_ref() {
+                    Self::Struct { pinned, unpinned } => EnumProjRef::Struct {
+                        pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned),
+                        unpinned: unpinned,
+                    },
+                    Self::Unit => EnumProjRef::Unit,
+                }
+            }
+        }
+    }
+    #[allow(non_snake_case)]
+    pub struct __Origin<'__pin, T, U> {
+        __dummy_lifetime: ::pin_project_lite::__private::PhantomData<&'__pin ()>,
+        Struct: (T, ::pin_project_lite::__private::AlwaysUnpin<U>),
+        Unit: (),
+    }
+    impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Enum<T, U> where
+        __Origin<'__pin, T, U>: ::pin_project_lite::__private::Unpin
+    {
+    }
+    trait MustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: ::pin_project_lite::__private::Drop> MustNotImplDrop for T {}
+    impl<T, U> MustNotImplDrop for Enum<T, U> {}
+};
+fn main() {}
diff --git a/tests/expand/pub/enum.rs b/tests/expand/pub/enum.rs
new file mode 100644
index 0000000..d3968af
--- /dev/null
+++ b/tests/expand/pub/enum.rs
@@ -0,0 +1,16 @@
+use pin_project_lite::pin_project;
+
+pin_project! {
+    #[project = EnumProj]
+    #[project_ref = EnumProjRef]
+    pub enum Enum<T, U> {
+        Struct {
+            #[pin]
+            pinned: T,
+            unpinned: U,
+        },
+        Unit,
+    }
+}
+
+fn main() {}
diff --git a/tests/expand/pub/struct.expanded.rs b/tests/expand/pub/struct.expanded.rs
new file mode 100644
index 0000000..7b5826d
--- /dev/null
+++ b/tests/expand/pub/struct.expanded.rs
@@ -0,0 +1,84 @@
+use pin_project_lite::pin_project;
+pub struct Struct<T, U> {
+    pub pinned: T,
+    pub unpinned: U,
+}
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    #[allow(dead_code)]
+    #[allow(single_use_lifetimes)]
+    #[allow(clippy::unknown_clippy_lints)]
+    #[allow(clippy::mut_mut)]
+    #[allow(clippy::redundant_pub_crate)]
+    #[allow(clippy::ref_option_ref)]
+    #[allow(clippy::type_repetition_in_bounds)]
+    pub(crate) struct Projection<'__pin, T, U>
+    where
+        Struct<T, U>: '__pin,
+    {
+        pub pinned: ::pin_project_lite::__private::Pin<&'__pin mut (T)>,
+        pub unpinned: &'__pin mut (U),
+    }
+    #[allow(dead_code)]
+    #[allow(single_use_lifetimes)]
+    #[allow(clippy::unknown_clippy_lints)]
+    #[allow(clippy::mut_mut)]
+    #[allow(clippy::redundant_pub_crate)]
+    #[allow(clippy::ref_option_ref)]
+    #[allow(clippy::type_repetition_in_bounds)]
+    pub(crate) struct ProjectionRef<'__pin, T, U>
+    where
+        Struct<T, U>: '__pin,
+    {
+        pub pinned: ::pin_project_lite::__private::Pin<&'__pin (T)>,
+        pub unpinned: &'__pin (U),
+    }
+    impl<T, U> Struct<T, U> {
+        pub(crate) fn project<'__pin>(
+            self: ::pin_project_lite::__private::Pin<&'__pin mut Self>,
+        ) -> Projection<'__pin, T, U> {
+            unsafe {
+                let Self { pinned, unpinned } = self.get_unchecked_mut();
+                Projection {
+                    pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned),
+                    unpinned: unpinned,
+                }
+            }
+        }
+        pub(crate) fn project_ref<'__pin>(
+            self: ::pin_project_lite::__private::Pin<&'__pin Self>,
+        ) -> ProjectionRef<'__pin, T, U> {
+            unsafe {
+                let Self { pinned, unpinned } = self.get_ref();
+                ProjectionRef {
+                    pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned),
+                    unpinned: unpinned,
+                }
+            }
+        }
+    }
+    #[allow(non_snake_case)]
+    pub struct __Origin<'__pin, T, U> {
+        __dummy_lifetime: ::pin_project_lite::__private::PhantomData<&'__pin ()>,
+        pinned: T,
+        unpinned: ::pin_project_lite::__private::AlwaysUnpin<U>,
+    }
+    impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Struct<T, U> where
+        __Origin<'__pin, T, U>: ::pin_project_lite::__private::Unpin
+    {
+    }
+    trait MustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: ::pin_project_lite::__private::Drop> MustNotImplDrop for T {}
+    impl<T, U> MustNotImplDrop for Struct<T, U> {}
+    #[forbid(unaligned_references, safe_packed_borrows)]
+    fn __assert_not_repr_packed<T, U>(this: &Struct<T, U>) {
+        let _ = &this.pinned;
+        let _ = &this.unpinned;
+    }
+};
+fn main() {}
diff --git a/tests/expand/pub/struct.rs b/tests/expand/pub/struct.rs
new file mode 100644
index 0000000..6659096
--- /dev/null
+++ b/tests/expand/pub/struct.rs
@@ -0,0 +1,11 @@
+use pin_project_lite::pin_project;
+
+pin_project! {
+    pub struct Struct<T, U> {
+        #[pin]
+        pub pinned: T,
+        pub unpinned: U,
+    }
+}
+
+fn main() {}
diff --git a/tests/expandtest.rs b/tests/expandtest.rs
new file mode 100644
index 0000000..3f0d5c1
--- /dev/null
+++ b/tests/expandtest.rs
@@ -0,0 +1,43 @@
+#![cfg(not(miri))]
+#![warn(rust_2018_idioms, single_use_lifetimes)]
+
+use std::{
+    env,
+    process::{Command, ExitStatus, Stdio},
+};
+
+const PATH: &str = "tests/expand/**/*.rs";
+
+#[rustversion::attr(not(nightly), ignore)]
+#[test]
+fn expandtest() {
+    let is_ci = env::var_os("CI").is_some();
+    let cargo = &*env::var("CARGO").unwrap_or_else(|_| "cargo".into());
+    if !has_command(&[cargo, "expand"]) || !has_command(&[cargo, "fmt"]) {
+        if is_ci {
+            panic!("expandtest requires rustfmt and cargo-expand");
+        }
+        return;
+    }
+
+    let args = &["--all-features"];
+    if is_ci {
+        macrotest::expand_without_refresh_args(PATH, args);
+    } else {
+        env::set_var("MACROTEST", "overwrite");
+        macrotest::expand_args(PATH, args);
+    }
+}
+
+fn has_command(command: &[&str]) -> bool {
+    Command::new(command[0])
+        .args(&command[1..])
+        .arg("--version")
+        .stdin(Stdio::null())
+        .stdout(Stdio::null())
+        .stderr(Stdio::null())
+        .status()
+        .as_ref()
+        .map(ExitStatus::success)
+        .unwrap_or(false)
+}
diff --git a/tests/lint.rs b/tests/lint.rs
index 46ec1df..2324cd5 100644
--- a/tests/lint.rs
+++ b/tests/lint.rs
@@ -1,44 +1,43 @@
-#![forbid(unsafe_code)]
-#![warn(nonstandard_style, rust_2018_idioms, rustdoc, unused)]
+// Check interoperability with rustc and clippy lints.
+
+#![warn(nonstandard_style, rust_2018_idioms, unused)]
 // Note: This does not guarantee compatibility with forbidding these lints in the future.
 // If rustc adds a new lint, we may not be able to keep this.
-#![forbid(future_incompatible, rust_2018_compatibility)]
+#![forbid(future_incompatible)]
 #![allow(unknown_lints)] // for old compilers
+#![forbid(unsafe_code)]
 #![warn(
     box_pointers,
     deprecated_in_future,
-    elided_lifetimes_in_paths,
-    explicit_outlives_requirements,
+    disjoint_capture_migration,
     macro_use_extern_crate,
     meta_variable_misuse,
+    missing_abi,
     missing_copy_implementations,
-    missing_crate_level_docs,
     missing_debug_implementations,
     missing_docs,
     non_ascii_idents,
+    noop_method_call,
     single_use_lifetimes,
     trivial_casts,
     trivial_numeric_casts,
-    unaligned_references,
     unreachable_pub,
-    unused_extern_crates,
     unused_import_braces,
     unused_lifetimes,
     unused_qualifications,
     unused_results,
     variant_size_differences
 )]
-// absolute_paths_not_starting_with_crate, anonymous_parameters, keyword_idents, pointer_structural_match: forbidden as a part of future_incompatible
-// missing_doc_code_examples, private_doc_tests, invalid_html_tags: warned as a part of rustdoc
-// unsafe_block_in_unsafe_fn: unstable
-// unsafe_code: forbidden
-// unstable_features: deprecated: https://doc.rust-lang.org/beta/rustc/lints/listing/allowed-by-default.html#unstable-features
+// rust_2018_compatibility, rust_2021_compatibility, absolute_paths_not_starting_with_crate, etc.: forbidden as a part of future_incompatible
+// elided_lifetimes_in_paths, explicit_outlives_requirements, unused_extern_crates: warned as a part of rust_2018_idioms
+// unsafe_block_in_unsafe_fn: unsafe_block_in_unsafe_fn: requires Rust 1.52. and, we don't generate unsafe fn.
+// unstable_features: no way to generate #![feature(..)] by macros, expect for unstable inner attribute. and this lint is deprecated: https://doc.rust-lang.org/rustc/lints/listing/allowed-by-default.html#unstable-features
 // unused_crate_dependencies: unrelated
+// unsafe_code: forbidden
 #![warn(clippy::all, clippy::pedantic, clippy::nursery)]
 #![warn(clippy::restriction)]
 #![allow(clippy::blanket_clippy_restriction_lints)] // this is a test, so enable all restriction lints intentionally.
-
-// Check interoperability with rustc and clippy lints.
+#![allow(clippy::exhaustive_structs, clippy::exhaustive_enums)] // TODO
 
 pub mod basic {
     include!("include/basic.rs");
diff --git a/tests/proper_unpin.rs b/tests/proper_unpin.rs
index b1c72c1..668e975 100644
--- a/tests/proper_unpin.rs
+++ b/tests/proper_unpin.rs
@@ -5,9 +5,10 @@
 mod auxiliary;
 
 pub mod default {
-    use pin_project_lite::pin_project;
     use std::marker::PhantomPinned;
 
+    use pin_project_lite::pin_project;
+
     struct Inner<T> {
         f: T,
     }
diff --git a/tests/test.rs b/tests/test.rs
index f4c29ee..162fc20 100644
--- a/tests/test.rs
+++ b/tests/test.rs
@@ -8,6 +8,7 @@ use core::{
     marker::{PhantomData, PhantomPinned},
     pin::Pin,
 };
+
 use pin_project_lite::pin_project;
 
 #[test]
@@ -51,7 +52,7 @@ fn projection() {
 
     {
         let StructProjReplace { f1: PhantomData, f2 } =
-            s.as_mut().project_replace(Default::default());
+            s.as_mut().project_replace(Struct::default());
         assert_eq!(f2, 2);
         let StructProj { f1, f2 } = s.project();
         assert_eq!(*f1, 0);
@@ -587,6 +588,21 @@ fn trailing_comma() {
 #[test]
 fn attrs() {
     pin_project! {
+        /// dox1
+        #[derive(Clone)]
+        #[project = StructProj]
+        #[project_ref = StructProjRef]
+        /// dox2
+        #[derive(Debug)]
+        /// dox3
+        struct Struct {
+            // TODO
+            // /// dox4
+            f: ()
+        }
+    }
+
+    pin_project! {
         #[project = Enum1Proj]
         #[project_ref = Enum1ProjRef]
         enum Enum1 {
@@ -599,6 +615,7 @@ fn attrs() {
 
     pin_project! {
         /// dox1
+        #[derive(Clone)]
         #[project = Enum2Proj]
         #[project_ref = Enum2ProjRef]
         /// dox2
@@ -616,3 +633,36 @@ fn attrs() {
         }
     }
 }
+
+#[test]
+fn pinned_drop() {
+    pin_project! {
+        pub struct Struct1<'a> {
+            was_dropped: &'a mut bool,
+            #[pin]
+            field: u8,
+        }
+        impl PinnedDrop for Struct1<'_> {
+            fn drop(this: Pin<&mut Self>) {
+                **this.project().was_dropped = true;
+            }
+        }
+    }
+
+    let mut was_dropped = false;
+    drop(Struct1 { was_dropped: &mut was_dropped, field: 42 });
+    assert!(was_dropped);
+
+    pin_project! {
+        pub struct Struct2<'a> {
+            was_dropped: &'a mut bool,
+            #[pin]
+            field: u8,
+        }
+        impl PinnedDrop for Struct2<'_> {
+            fn drop(mut this: Pin<&mut Self>) {
+                **this.as_mut().project().was_dropped = true;
+            }
+        }
+    }
+}
diff --git a/tests/ui/overlapping_unpin_struct.stderr b/tests/ui/overlapping_unpin_struct.stderr
deleted file mode 100644
index ab76f81..0000000
--- a/tests/ui/overlapping_unpin_struct.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-error[E0277]: `PhantomPinned` cannot be unpinned
-  --> $DIR/overlapping_unpin_struct.rs:18:5
-   |
-15 | fn is_unpin<T: Unpin>() {}
-   |                ----- required by this bound in `is_unpin`
-...
-18 |     is_unpin::<Foo<PhantomPinned>>(); //~ ERROR E0277
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ within `_::__Origin<'_, PhantomPinned>`, the trait `Unpin` is not implemented for `PhantomPinned`
-   |
-   = note: required because it appears within the type `_::__Origin<'_, PhantomPinned>`
-   = note: required because of the requirements on the impl of `Unpin` for `Foo<PhantomPinned>`
diff --git a/tests/ui/packed.rs b/tests/ui/packed.rs
deleted file mode 100644
index 0bccc1f..0000000
--- a/tests/ui/packed.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-use pin_project_lite::pin_project;
-
-pin_project! { //~ ERROR borrow of packed field is unsafe and requires unsafe function or block
-    #[repr(packed, C)]
-    struct A {
-        #[pin]
-        field: u16,
-    }
-}
-
-pin_project! { //~ ERROR borrow of packed field is unsafe and requires unsafe function or block
-    #[repr(packed(2))]
-    struct C {
-        #[pin]
-        field: u32,
-    }
-}
-
-fn main() {}
diff --git a/tests/ui/packed.stderr b/tests/ui/packed.stderr
deleted file mode 100644
index a976163..0000000
--- a/tests/ui/packed.stderr
+++ /dev/null
@@ -1,55 +0,0 @@
-error: borrow of packed field is unsafe and requires unsafe function or block (error E0133)
- --> $DIR/packed.rs:3:1
-  |
-3 | / pin_project! { //~ ERROR borrow of packed field is unsafe and requires unsafe function or block
-4 | |     #[repr(packed, C)]
-5 | |     struct A {
-6 | |         #[pin]
-7 | |         field: u16,
-8 | |     }
-9 | | }
-  | |_^
-  |
-note: the lint level is defined here
- --> $DIR/packed.rs:3:1
-  |
-3 | / pin_project! { //~ ERROR borrow of packed field is unsafe and requires unsafe function or block
-4 | |     #[repr(packed, C)]
-5 | |     struct A {
-6 | |         #[pin]
-7 | |         field: u16,
-8 | |     }
-9 | | }
-  | |_^
-  = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-  = note: for more information, see issue #46043 <https://github.com/rust-lang/rust/issues/46043>
-  = note: fields of packed structs might be misaligned: dereferencing a misaligned pointer or even just creating a misaligned reference is undefined behavior
-  = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error: borrow of packed field is unsafe and requires unsafe function or block (error E0133)
-  --> $DIR/packed.rs:11:1
-   |
-11 | / pin_project! { //~ ERROR borrow of packed field is unsafe and requires unsafe function or block
-12 | |     #[repr(packed(2))]
-13 | |     struct C {
-14 | |         #[pin]
-15 | |         field: u32,
-16 | |     }
-17 | | }
-   | |_^
-   |
-note: the lint level is defined here
-  --> $DIR/packed.rs:11:1
-   |
-11 | / pin_project! { //~ ERROR borrow of packed field is unsafe and requires unsafe function or block
-12 | |     #[repr(packed(2))]
-13 | |     struct C {
-14 | |         #[pin]
-15 | |         field: u32,
-16 | |     }
-17 | | }
-   | |_^
-   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = note: for more information, see issue #46043 <https://github.com/rust-lang/rust/issues/46043>
-   = note: fields of packed structs might be misaligned: dereferencing a misaligned pointer or even just creating a misaligned reference is undefined behavior
-   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/tests/ui/conflict-drop.rs b/tests/ui/pin_project/conflict-drop.rs
index 870059d..870059d 100644
--- a/tests/ui/conflict-drop.rs
+++ b/tests/ui/pin_project/conflict-drop.rs
diff --git a/tests/ui/conflict-drop.stderr b/tests/ui/pin_project/conflict-drop.stderr
index f97c92b..bbfc910 100644
--- a/tests/ui/conflict-drop.stderr
+++ b/tests/ui/pin_project/conflict-drop.stderr
@@ -1,4 +1,4 @@
-error[E0119]: conflicting implementations of trait `_::MustNotImplDrop` for type `Foo<_, _>`:
+error[E0119]: conflicting implementations of trait `_::MustNotImplDrop` for type `Foo<_, _>`
  --> $DIR/conflict-drop.rs:3:1
   |
 3 | / pin_project! { //~ ERROR E0119
@@ -13,4 +13,4 @@ error[E0119]: conflicting implementations of trait `_::MustNotImplDrop` for type
   | |_first implementation here
   |   conflicting implementation for `Foo<_, _>`
   |
-  = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+  = note: this error originates in the macro `$crate::__pin_project_internal` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/tests/ui/conflict-unpin.rs b/tests/ui/pin_project/conflict-unpin.rs
index f702f06..f702f06 100644
--- a/tests/ui/conflict-unpin.rs
+++ b/tests/ui/pin_project/conflict-unpin.rs
diff --git a/tests/ui/conflict-unpin.stderr b/tests/ui/pin_project/conflict-unpin.stderr
index 546dafd..18bdd92 100644
--- a/tests/ui/conflict-unpin.stderr
+++ b/tests/ui/pin_project/conflict-unpin.stderr
@@ -1,4 +1,4 @@
-error[E0119]: conflicting implementations of trait `std::marker::Unpin` for type `Foo<_, _>`:
+error[E0119]: conflicting implementations of trait `std::marker::Unpin` for type `Foo<_, _>`
   --> $DIR/conflict-unpin.rs:5:1
    |
 5  | / pin_project! { //~ ERROR E0119
@@ -13,9 +13,9 @@ error[E0119]: conflicting implementations of trait `std::marker::Unpin` for type
 14 |   impl<T, U> Unpin for Foo<T, U> where T: Unpin {} // Conditional Unpin impl
    |   --------------------------------------------- first implementation here
    |
-   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+   = note: this error originates in the macro `$crate::__pin_project_internal` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error[E0119]: conflicting implementations of trait `std::marker::Unpin` for type `Bar<_, _>`:
+error[E0119]: conflicting implementations of trait `std::marker::Unpin` for type `Bar<_, _>`
   --> $DIR/conflict-unpin.rs:18:1
    |
 18 | / pin_project! { //~ ERROR E0119
@@ -30,9 +30,9 @@ error[E0119]: conflicting implementations of trait `std::marker::Unpin` for type
 27 |   impl<T, U> Unpin for Bar<T, U> {} // Non-conditional Unpin impl
    |   ------------------------------ first implementation here
    |
-   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+   = note: this error originates in the macro `$crate::__pin_project_internal` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error[E0119]: conflicting implementations of trait `std::marker::Unpin` for type `Baz<_, _>`:
+error[E0119]: conflicting implementations of trait `std::marker::Unpin` for type `Baz<_, _>`
   --> $DIR/conflict-unpin.rs:29:1
    |
 29 | / pin_project! { //~ ERROR E0119
@@ -47,4 +47,4 @@ error[E0119]: conflicting implementations of trait `std::marker::Unpin` for type
 38 |   impl<T: Unpin, U: Unpin> Unpin for Baz<T, U> {} // Conditional Unpin impl
    |   -------------------------------------------- first implementation here
    |
-   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+   = note: this error originates in the macro `$crate::__pin_project_internal` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/tests/ui/invalid-bounds.rs b/tests/ui/pin_project/invalid-bounds.rs
index 64b397a..64b397a 100644
--- a/tests/ui/invalid-bounds.rs
+++ b/tests/ui/pin_project/invalid-bounds.rs
diff --git a/tests/ui/invalid-bounds.stderr b/tests/ui/pin_project/invalid-bounds.stderr
index a565cce..b276989 100644
--- a/tests/ui/invalid-bounds.stderr
+++ b/tests/ui/pin_project/invalid-bounds.stderr
@@ -8,7 +8,7 @@ error: no rules expected the token `[`
 7 | | }
   | |_^ no rules expected this token in macro call
   |
-  = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+  = note: this error originates in the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: no rules expected the token `[`
   --> $DIR/invalid-bounds.rs:9:1
@@ -20,7 +20,7 @@ error: no rules expected the token `[`
 13 | | }
    | |_^ no rules expected this token in macro call
    |
-   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+   = note: this error originates in the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: expected one of `+`, `,`, `=`, or `>`, found `:`
   --> $DIR/invalid-bounds.rs:15:1
@@ -36,7 +36,7 @@ error: expected one of `+`, `,`, `=`, or `>`, found `:`
    | |_unexpected token
    |   in this macro invocation
    |
-   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+   = note: this error originates in the macro `$crate::__pin_project_internal` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: expected one of `+`, `,`, `=`, or `>`, found `:`
   --> $DIR/invalid-bounds.rs:21:1
@@ -52,7 +52,7 @@ error: expected one of `+`, `,`, `=`, or `>`, found `:`
    | |_unexpected token
    |   in this macro invocation
    |
-   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+   = note: this error originates in the macro `$crate::__pin_project_internal` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: expected one of `+`, `,`, `=`, or `>`, found `:`
   --> $DIR/invalid-bounds.rs:27:1
@@ -68,7 +68,7 @@ error: expected one of `+`, `,`, `=`, or `>`, found `:`
    | |_unexpected token
    |   in this macro invocation
    |
-   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+   = note: this error originates in the macro `$crate::__pin_project_internal` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: no rules expected the token `[`
   --> $DIR/invalid-bounds.rs:33:1
@@ -80,7 +80,7 @@ error: no rules expected the token `[`
 37 | | }
    | |_^ no rules expected this token in macro call
    |
-   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+   = note: this error originates in the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: no rules expected the token `[`
   --> $DIR/invalid-bounds.rs:39:1
@@ -94,7 +94,7 @@ error: no rules expected the token `[`
 46 | | }
    | |_^ no rules expected this token in macro call
    |
-   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+   = note: this error originates in the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: no rules expected the token `[`
   --> $DIR/invalid-bounds.rs:48:1
@@ -108,7 +108,7 @@ error: no rules expected the token `[`
 55 | | }
    | |_^ no rules expected this token in macro call
    |
-   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+   = note: this error originates in the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: expected `where`, or `{` after struct name, found `:`
   --> $DIR/invalid-bounds.rs:57:1
@@ -125,7 +125,7 @@ error: expected `where`, or `{` after struct name, found `:`
    | |_expected `where`, or `{` after struct name
    |   in this macro invocation
    |
-   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+   = note: this error originates in the macro `$crate::__pin_project_internal` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: expected `where`, or `{` after struct name, found `:`
   --> $DIR/invalid-bounds.rs:66:1
@@ -142,7 +142,7 @@ error: expected `where`, or `{` after struct name, found `:`
    | |_expected `where`, or `{` after struct name
    |   in this macro invocation
    |
-   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+   = note: this error originates in the macro `$crate::__pin_project_internal` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: expected `where`, or `{` after struct name, found `:`
   --> $DIR/invalid-bounds.rs:75:1
@@ -159,7 +159,7 @@ error: expected `where`, or `{` after struct name, found `:`
    | |_expected `where`, or `{` after struct name
    |   in this macro invocation
    |
-   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+   = note: this error originates in the macro `$crate::__pin_project_internal` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: no rules expected the token `[`
   --> $DIR/invalid-bounds.rs:84:1
@@ -173,4 +173,4 @@ error: no rules expected the token `[`
 91 | | }
    | |_^ no rules expected this token in macro call
    |
-   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+   = note: this error originates in the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/tests/ui/invalid.rs b/tests/ui/pin_project/invalid.rs
index e0ea61d..e0ea61d 100644
--- a/tests/ui/invalid.rs
+++ b/tests/ui/pin_project/invalid.rs
diff --git a/tests/ui/invalid.stderr b/tests/ui/pin_project/invalid.stderr
index 06f2d79..38df517 100644
--- a/tests/ui/invalid.stderr
+++ b/tests/ui/pin_project/invalid.stderr
@@ -9,7 +9,7 @@ error: no rules expected the token `[`
 8 | | }
   | |_^ no rules expected this token in macro call
   |
-  = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+  = note: this error originates in the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: no rules expected the token `[`
   --> $DIR/invalid.rs:17:1
@@ -23,7 +23,7 @@ error: no rules expected the token `[`
 23 | | }
    | |_^ no rules expected this token in macro call
    |
-   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+   = note: this error originates in the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: cannot find attribute `pin` in this scope
   --> $DIR/invalid.rs:11:7
diff --git a/tests/ui/overlapping_lifetime_names.rs b/tests/ui/pin_project/overlapping_lifetime_names.rs
index 87a737e..117c18d 100644
--- a/tests/ui/overlapping_lifetime_names.rs
+++ b/tests/ui/pin_project/overlapping_lifetime_names.rs
@@ -1,7 +1,7 @@
 use pin_project_lite::pin_project;
 
-pin_project! { //~ ERROR E0496
-    pub struct Foo<'__pin, T> { //~ ERROR E0263
+pin_project! { //~ ERROR E0263,E0496
+    pub struct Foo<'__pin, T> {
         #[pin]
         field: &'__pin mut T,
     }
diff --git a/tests/ui/overlapping_lifetime_names.stderr b/tests/ui/pin_project/overlapping_lifetime_names.stderr
index 8a9bb4f..f87875d 100644
--- a/tests/ui/overlapping_lifetime_names.stderr
+++ b/tests/ui/pin_project/overlapping_lifetime_names.stderr
@@ -1,36 +1,32 @@
-error[E0496]: lifetime name `'__pin` shadows a lifetime name that is already in scope
- --> $DIR/overlapping_lifetime_names.rs:3:1
+error[E0263]: lifetime name `'__pin` declared twice in the same scope
+ --> $DIR/overlapping_lifetime_names.rs:4:20
   |
-3 | / pin_project! { //~ ERROR E0496
-4 | |     pub struct Foo<'__pin, T> { //~ ERROR E0263
-  | |                    ------ first declared here
+3 | / pin_project! { //~ ERROR E0263,E0496
+4 | |     pub struct Foo<'__pin, T> {
+  | |                    ^^^^^^ declared twice
 5 | |         #[pin]
 6 | |         field: &'__pin mut T,
 7 | |     }
 8 | | }
-  | |_^ lifetime `'__pin` already in scope
-  |
-  = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+  | |_- previous declaration here
 
-error[E0496]: lifetime name `'__pin` shadows a lifetime name that is already in scope
- --> $DIR/overlapping_lifetime_names.rs:3:1
+error[E0263]: lifetime name `'__pin` declared twice in the same scope
+ --> $DIR/overlapping_lifetime_names.rs:4:20
   |
-3 | / pin_project! { //~ ERROR E0496
-4 | |     pub struct Foo<'__pin, T> { //~ ERROR E0263
-  | |                    ------ first declared here
+3 | / pin_project! { //~ ERROR E0263,E0496
+4 | |     pub struct Foo<'__pin, T> {
+  | |                    ^^^^^^ declared twice
 5 | |         #[pin]
 6 | |         field: &'__pin mut T,
 7 | |     }
 8 | | }
-  | |_^ lifetime `'__pin` already in scope
-  |
-  = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+  | |_- previous declaration here
 
 error[E0263]: lifetime name `'__pin` declared twice in the same scope
  --> $DIR/overlapping_lifetime_names.rs:4:20
   |
-3 | / pin_project! { //~ ERROR E0496
-4 | |     pub struct Foo<'__pin, T> { //~ ERROR E0263
+3 | / pin_project! { //~ ERROR E0263,E0496
+4 | |     pub struct Foo<'__pin, T> {
   | |                    ^^^^^^ declared twice
 5 | |         #[pin]
 6 | |         field: &'__pin mut T,
@@ -38,35 +34,39 @@ error[E0263]: lifetime name `'__pin` declared twice in the same scope
 8 | | }
   | |_- previous declaration here
 
-error[E0263]: lifetime name `'__pin` declared twice in the same scope
- --> $DIR/overlapping_lifetime_names.rs:4:20
+error[E0496]: lifetime name `'__pin` shadows a lifetime name that is already in scope
+ --> $DIR/overlapping_lifetime_names.rs:3:1
   |
-3 | / pin_project! { //~ ERROR E0496
-4 | |     pub struct Foo<'__pin, T> { //~ ERROR E0263
-  | |                    ^^^^^^ declared twice
+3 | / pin_project! { //~ ERROR E0263,E0496
+4 | |     pub struct Foo<'__pin, T> {
+  | |                    ------ first declared here
 5 | |         #[pin]
 6 | |         field: &'__pin mut T,
 7 | |     }
 8 | | }
-  | |_- previous declaration here
+  | |_^ lifetime `'__pin` already in scope
+  |
+  = note: this error originates in the macro `$crate::__pin_project_internal` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error[E0263]: lifetime name `'__pin` declared twice in the same scope
- --> $DIR/overlapping_lifetime_names.rs:4:20
+error[E0496]: lifetime name `'__pin` shadows a lifetime name that is already in scope
+ --> $DIR/overlapping_lifetime_names.rs:3:1
   |
-3 | / pin_project! { //~ ERROR E0496
-4 | |     pub struct Foo<'__pin, T> { //~ ERROR E0263
-  | |                    ^^^^^^ declared twice
+3 | / pin_project! { //~ ERROR E0263,E0496
+4 | |     pub struct Foo<'__pin, T> {
+  | |                    ------ first declared here
 5 | |         #[pin]
 6 | |         field: &'__pin mut T,
 7 | |     }
 8 | | }
-  | |_- previous declaration here
+  | |_^ lifetime `'__pin` already in scope
+  |
+  = note: this error originates in the macro `$crate::__pin_project_internal` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0263]: lifetime name `'__pin` declared twice in the same scope
  --> $DIR/overlapping_lifetime_names.rs:4:20
   |
-3 | / pin_project! { //~ ERROR E0496
-4 | |     pub struct Foo<'__pin, T> { //~ ERROR E0263
+3 | / pin_project! { //~ ERROR E0263,E0496
+4 | |     pub struct Foo<'__pin, T> {
   | |                    ^^^^^^ declared twice
 5 | |         #[pin]
 6 | |         field: &'__pin mut T,
diff --git a/tests/ui/overlapping_unpin_struct.rs b/tests/ui/pin_project/overlapping_unpin_struct.rs
index 1338524..25131d1 100644
--- a/tests/ui/overlapping_unpin_struct.rs
+++ b/tests/ui/pin_project/overlapping_unpin_struct.rs
@@ -1,6 +1,7 @@
-use pin_project_lite::pin_project;
 use std::marker::PhantomPinned;
 
+use pin_project_lite::pin_project;
+
 pin_project! {
     struct Foo<T> {
         #[pin]
diff --git a/tests/ui/pin_project/overlapping_unpin_struct.stderr b/tests/ui/pin_project/overlapping_unpin_struct.stderr
new file mode 100644
index 0000000..9486f9d
--- /dev/null
+++ b/tests/ui/pin_project/overlapping_unpin_struct.stderr
@@ -0,0 +1,22 @@
+error[E0277]: `PhantomPinned` cannot be unpinned
+  --> $DIR/overlapping_unpin_struct.rs:19:5
+   |
+16 | fn is_unpin<T: Unpin>() {}
+   |                ----- required by this bound in `is_unpin`
+...
+19 |     is_unpin::<Foo<PhantomPinned>>(); //~ ERROR E0277
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ within `_::__Origin<'_, PhantomPinned>`, the trait `Unpin` is not implemented for `PhantomPinned`
+   |
+   = note: consider using `Box::pin`
+note: required because it appears within the type `_::__Origin<'_, PhantomPinned>`
+  --> $DIR/overlapping_unpin_struct.rs:5:1
+   |
+5  | / pin_project! {
+6  | |     struct Foo<T> {
+7  | |         #[pin]
+8  | |         inner: T,
+9  | |     }
+10 | | }
+   | |_^
+   = note: required because of the requirements on the impl of `Unpin` for `Foo<PhantomPinned>`
+   = note: this error originates in the macro `$crate::__pin_project_internal` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/tests/ui/pin_project/packed.rs b/tests/ui/pin_project/packed.rs
new file mode 100644
index 0000000..50afb11
--- /dev/null
+++ b/tests/ui/pin_project/packed.rs
@@ -0,0 +1,21 @@
+#![allow(unaligned_references)]
+
+use pin_project_lite::pin_project;
+
+pin_project! { //~ ERROR reference to packed field is unaligned
+    #[repr(packed, C)]
+    struct Packed {
+        #[pin]
+        field: u16,
+    }
+}
+
+pin_project! { //~ ERROR reference to packed field is unaligned
+    #[repr(packed(2))]
+    struct PackedN {
+        #[pin]
+        field: u32,
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/pin_project/packed.stderr b/tests/ui/pin_project/packed.stderr
new file mode 100644
index 0000000..85f84c2
--- /dev/null
+++ b/tests/ui/pin_project/packed.stderr
@@ -0,0 +1,55 @@
+error: reference to packed field is unaligned
+  --> $DIR/packed.rs:5:1
+   |
+5  | / pin_project! { //~ ERROR reference to packed field is unaligned
+6  | |     #[repr(packed, C)]
+7  | |     struct Packed {
+8  | |         #[pin]
+9  | |         field: u16,
+10 | |     }
+11 | | }
+   | |_^
+   |
+note: the lint level is defined here
+  --> $DIR/packed.rs:5:1
+   |
+5  | / pin_project! { //~ ERROR reference to packed field is unaligned
+6  | |     #[repr(packed, C)]
+7  | |     struct Packed {
+8  | |         #[pin]
+9  | |         field: u16,
+10 | |     }
+11 | | }
+   | |_^
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = note: for more information, see issue #82523 <https://github.com/rust-lang/rust/issues/82523>
+   = note: fields of packed structs are not properly aligned, and creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
+   = note: this error originates in the macro `$crate::__pin_project_internal` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: reference to packed field is unaligned
+  --> $DIR/packed.rs:13:1
+   |
+13 | / pin_project! { //~ ERROR reference to packed field is unaligned
+14 | |     #[repr(packed(2))]
+15 | |     struct PackedN {
+16 | |         #[pin]
+17 | |         field: u32,
+18 | |     }
+19 | | }
+   | |_^
+   |
+note: the lint level is defined here
+  --> $DIR/packed.rs:13:1
+   |
+13 | / pin_project! { //~ ERROR reference to packed field is unaligned
+14 | |     #[repr(packed(2))]
+15 | |     struct PackedN {
+16 | |         #[pin]
+17 | |         field: u32,
+18 | |     }
+19 | | }
+   | |_^
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = note: for more information, see issue #82523 <https://github.com/rust-lang/rust/issues/82523>
+   = note: fields of packed structs are not properly aligned, and creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
+   = note: this error originates in the macro `$crate::__pin_project_internal` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/tests/ui/unpin_sneaky.rs b/tests/ui/pin_project/unpin_sneaky.rs
index 984cc2a..984cc2a 100644
--- a/tests/ui/unpin_sneaky.rs
+++ b/tests/ui/pin_project/unpin_sneaky.rs
diff --git a/tests/ui/unpin_sneaky.stderr b/tests/ui/pin_project/unpin_sneaky.stderr
index 39a7745..39a7745 100644
--- a/tests/ui/unpin_sneaky.stderr
+++ b/tests/ui/pin_project/unpin_sneaky.stderr
diff --git a/tests/ui/unsupported.rs b/tests/ui/pin_project/unsupported.rs
index 2f80836..2f80836 100644
--- a/tests/ui/unsupported.rs
+++ b/tests/ui/pin_project/unsupported.rs
diff --git a/tests/ui/unsupported.stderr b/tests/ui/pin_project/unsupported.stderr
index 2cd17df..892e57c 100644
--- a/tests/ui/unsupported.stderr
+++ b/tests/ui/pin_project/unsupported.stderr
@@ -6,7 +6,7 @@ error: no rules expected the token `[`
 5 | | }
   | |_^ no rules expected this token in macro call
   |
-  = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+  = note: this error originates in the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: no rules expected the token `[`
  --> $DIR/unsupported.rs:7:1
@@ -16,7 +16,7 @@ error: no rules expected the token `[`
 9 | | }
   | |_^ no rules expected this token in macro call
   |
-  = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+  = note: this error originates in the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: no rules expected the token `[`
   --> $DIR/unsupported.rs:11:1
@@ -26,7 +26,7 @@ error: no rules expected the token `[`
 13 | | }
    | |_^ no rules expected this token in macro call
    |
-   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+   = note: this error originates in the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: no rules expected the token `[`
   --> $DIR/unsupported.rs:15:1
@@ -38,7 +38,7 @@ error: no rules expected the token `[`
 19 | | }
    | |_^ no rules expected this token in macro call
    |
-   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+   = note: this error originates in the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: no rules expected the token `[`
   --> $DIR/unsupported.rs:21:1
@@ -50,4 +50,4 @@ error: no rules expected the token `[`
 25 | | }
    | |_^ no rules expected this token in macro call
    |
-   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+   = note: this error originates in the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/tests/ui/pinned_drop/call-drop-inner.rs b/tests/ui/pinned_drop/call-drop-inner.rs
new file mode 100644
index 0000000..609b3be
--- /dev/null
+++ b/tests/ui/pinned_drop/call-drop-inner.rs
@@ -0,0 +1,17 @@
+use pin_project_lite::pin_project;
+
+pin_project! {
+    pub struct S {
+        #[pin]
+        field: u8,
+    }
+    impl PinnedDrop for S {
+        fn drop(this: Pin<&mut Self>) {
+            __drop_inner(this);
+        }
+    }
+}
+
+fn main() {
+    let _x = S { field: 0 };
+}
diff --git a/tests/ui/pinned_drop/call-drop-inner.stderr b/tests/ui/pinned_drop/call-drop-inner.stderr
new file mode 100644
index 0000000..576e417
--- /dev/null
+++ b/tests/ui/pinned_drop/call-drop-inner.stderr
@@ -0,0 +1,20 @@
+error[E0061]: this function takes 0 arguments but 1 argument was supplied
+  --> $DIR/call-drop-inner.rs:10:13
+   |
+10 |             __drop_inner(this);
+   |             ^^^^^^^^^^^^ ---- supplied 1 argument
+   |             |
+   |             expected 0 arguments
+   |
+note: function defined here
+  --> $DIR/call-drop-inner.rs:3:1
+   |
+3  | / pin_project! {
+4  | |     pub struct S {
+5  | |         #[pin]
+6  | |         field: u8,
+...  |
+12 | |     }
+13 | | }
+   | |_^
+   = note: this error originates in the macro `$crate::__pin_project_internal` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/tests/ui/pinned_drop/conditional-drop-impl.rs b/tests/ui/pinned_drop/conditional-drop-impl.rs
new file mode 100644
index 0000000..68b01b2
--- /dev/null
+++ b/tests/ui/pinned_drop/conditional-drop-impl.rs
@@ -0,0 +1,26 @@
+use pin_project_lite::pin_project;
+
+// In `Drop` impl, the implementor must specify the same requirement as type definition.
+
+struct DropImpl<T> {
+    f: T,
+}
+
+impl<T: Unpin> Drop for DropImpl<T> {
+    //~^ ERROR E0367
+    fn drop(&mut self) {}
+}
+
+pin_project! {
+    //~^ ERROR E0367
+    struct PinnedDropImpl<T> {
+        #[pin]
+        f: T,
+    }
+
+    impl<T: Unpin> PinnedDrop for PinnedDropImpl<T> {
+        fn drop(_this: Pin<&mut Self>) {}
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/pinned_drop/conditional-drop-impl.stderr b/tests/ui/pinned_drop/conditional-drop-impl.stderr
new file mode 100644
index 0000000..a67bc8d
--- /dev/null
+++ b/tests/ui/pinned_drop/conditional-drop-impl.stderr
@@ -0,0 +1,38 @@
+error[E0367]: `Drop` impl requires `T: Unpin` but the struct it is implemented for does not
+ --> $DIR/conditional-drop-impl.rs:9:9
+  |
+9 | impl<T: Unpin> Drop for DropImpl<T> {
+  |         ^^^^^
+  |
+note: the implementor must specify the same requirement
+ --> $DIR/conditional-drop-impl.rs:5:1
+  |
+5 | / struct DropImpl<T> {
+6 | |     f: T,
+7 | | }
+  | |_^
+
+error[E0367]: `Drop` impl requires `T: Unpin` but the struct it is implemented for does not
+  --> $DIR/conditional-drop-impl.rs:14:1
+   |
+14 | / pin_project! {
+15 | |     //~^ ERROR E0367
+16 | |     struct PinnedDropImpl<T> {
+17 | |         #[pin]
+...  |
+23 | |     }
+24 | | }
+   | |_^
+   |
+note: the implementor must specify the same requirement
+  --> $DIR/conditional-drop-impl.rs:14:1
+   |
+14 | / pin_project! {
+15 | |     //~^ ERROR E0367
+16 | |     struct PinnedDropImpl<T> {
+17 | |         #[pin]
+...  |
+23 | |     }
+24 | | }
+   | |_^
+   = note: this error originates in the macro `$crate::__pin_project_internal` (in Nightly builds, run with -Z macro-backtrace for more info)