Vendor dependencies for 0.3.0 release

vendor/pin-project-lite/CHANGELOG.md

@@ -0,0 +1,259 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+This project adheres to [Semantic Versioning](https://semver.org).
+
+Releases may yanked if there is a security bug, a soundness bug, or a regression.
+
+<!--
+Note: In this file, do not use the hard wrap in the middle of a sentence for compatibility with GitHub comment style markdown rendering.
+-->
+
+## [Unreleased]
+
+## [0.2.16] - 2025-01-06
+
+- Suppress `clippy::absolute_paths`, `clippy::min_ident_chars`, and `clippy::single_char_lifetime_names` lints in generated code.
+
+## [0.2.15] - 2024-10-24
+
+- Work around an issue on negative_impls that allows unsound overlapping `Unpin` implementations. ([#84](https://github.com/taiki-e/pin-project-lite/pull/84))
+
+## [0.2.14] - 2024-03-29
+
+- Document `PinnedDrop`. ([#83](https://github.com/taiki-e/pin-project-lite/pull/83), thanks @jbr)
+
+## [0.2.13] - 2023-08-25
+
+- Allow attributes in impl and method of `PinnedDrop` implementation.
+
+## [0.2.12] - 2023-08-09
+
+- Work around an issue where the projected types/methods appear in the documentation as if they were part of the public API if the visibility is not correctly parsed due to the rustc bug. See [#77](https://github.com/taiki-e/pin-project-lite/issues/77#issuecomment-1671540180) for details.
+
+## [0.2.11] - 2023-08-06
+
+- Add support for `#[project(!Unpin)]`. This is equivalent to pin-project's [!Unpin](https://docs.rs/pin-project/latest/pin_project/attr.pin_project.html#unpin) option. ([#76](https://github.com/taiki-e/pin-project-lite/pull/76), thanks @matheus-consoli)
+
+## [0.2.10] - 2023-07-02
+
+- Inline project methods. ([#74](https://github.com/taiki-e/pin-project-lite/pull/74), thanks @EFanZh)
+
+## [0.2.9] - 2022-04-26
+
+- Improve compile time of `pin_project!` calls. ([#71](https://github.com/taiki-e/pin-project-lite/pull/71), thanks @nnethercote)
+
+## [0.2.8] - 2021-12-31
+
+- Fix handling of trailing commas in `PinnedDrop` impl. ([#64](https://github.com/taiki-e/pin-project-lite/pull/64), thanks @Michael-J-Ward)
+
+## [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. ([#57](https://github.com/taiki-e/pin-project-lite/pull/57), thanks @SabrinaJewson)
+
+## [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`. ([#43](https://github.com/taiki-e/pin-project-lite/pull/43), thanks @Marwes)
+
+## [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.
+
+  ```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;
+              }
+          }
+      }
+  }
+  ```
+
+- [Support naming the projection types.](https://github.com/taiki-e/pin-project-lite/pull/28)
+
+  By passing an attribute with the same name as the method, you can name the projection type returned from the method:
+
+  ```rust
+  use pin_project_lite::pin_project;
+  use std::pin::Pin;
+
+  pin_project! {
+      #[project = StructProj]
+      struct Struct<T> {
+          #[pin]
+          field: T,
+      }
+  }
+
+  fn func<T>(x: Pin<&mut Struct<T>>) {
+      let StructProj { field } = x.project();
+      let _: Pin<&mut T> = field;
+  }
+  ```
+
+## [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.
+  If rustc adds a new lint, we may not be able to keep this.
+
+## [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)
+
+- Suppress `clippy::used_underscore_binding` lint in generated code.
+
+- Documentation improvements.
+
+## [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. ([#6](https://github.com/taiki-e/pin-project-lite/pull/6), thanks @kennytm)
+
+## [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.16...HEAD
+[0.2.16]: https://github.com/taiki-e/pin-project-lite/compare/v0.2.15...v0.2.16
+[0.2.15]: https://github.com/taiki-e/pin-project-lite/compare/v0.2.14...v0.2.15
+[0.2.14]: https://github.com/taiki-e/pin-project-lite/compare/v0.2.13...v0.2.14
+[0.2.13]: https://github.com/taiki-e/pin-project-lite/compare/v0.2.12...v0.2.13
+[0.2.12]: https://github.com/taiki-e/pin-project-lite/compare/v0.2.11...v0.2.12
+[0.2.11]: https://github.com/taiki-e/pin-project-lite/compare/v0.2.10...v0.2.11
+[0.2.10]: https://github.com/taiki-e/pin-project-lite/compare/v0.2.9...v0.2.10
+[0.2.9]: https://github.com/taiki-e/pin-project-lite/compare/v0.2.8...v0.2.9
+[0.2.8]: https://github.com/taiki-e/pin-project-lite/compare/v0.2.7...v0.2.8
+[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
+[0.1.8]: https://github.com/taiki-e/pin-project-lite/compare/v0.1.7...v0.1.8
+[0.1.7]: https://github.com/taiki-e/pin-project-lite/compare/v0.1.6...v0.1.7
+[0.1.6]: https://github.com/taiki-e/pin-project-lite/compare/v0.1.5...v0.1.6
+[0.1.5]: https://github.com/taiki-e/pin-project-lite/compare/v0.1.4...v0.1.5
+[0.1.4]: https://github.com/taiki-e/pin-project-lite/compare/v0.1.3...v0.1.4
+[0.1.3]: https://github.com/taiki-e/pin-project-lite/compare/v0.1.2...v0.1.3
+[0.1.2]: https://github.com/taiki-e/pin-project-lite/compare/v0.1.1...v0.1.2
+[0.1.1]: https://github.com/taiki-e/pin-project-lite/compare/v0.1.0...v0.1.1
+[0.1.0]: https://github.com/taiki-e/pin-project-lite/releases/tag/v0.1.0

vendor/pin-project-lite/Cargo.toml

@@ -0,0 +1,200 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies.
+#
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
+
+[package]
+edition = "2018"
+rust-version = "1.37"
+name = "pin-project-lite"
+version = "0.2.16"
+build = false
+exclude = [
+    "/.*",
+    "/tools",
+    "/DEVELOPMENT.md",
+]
+autolib = false
+autobins = false
+autoexamples = false
+autotests = false
+autobenches = false
+description = """
+A lightweight version of pin-project written with declarative macros.
+"""
+readme = "README.md"
+keywords = [
+    "pin",
+    "macros",
+]
+categories = [
+    "no-std",
+    "no-std::no-alloc",
+    "rust-patterns",
+]
+license = "Apache-2.0 OR MIT"
+repository = "https://github.com/taiki-e/pin-project-lite"
+
+[package.metadata.cargo_check_external_types]
+allowed_external_types = []
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[lib]
+name = "pin_project_lite"
+path = "src/lib.rs"
+doc-scrape-examples = false
+
+[[test]]
+name = "compiletest"
+path = "tests/compiletest.rs"
+
+[[test]]
+name = "drop_order"
+path = "tests/drop_order.rs"
+
+[[test]]
+name = "expandtest"
+path = "tests/expandtest.rs"
+
+[[test]]
+name = "proper_unpin"
+path = "tests/proper_unpin.rs"
+
+[[test]]
+name = "test"
+path = "tests/test.rs"
+
+[dev-dependencies.rustversion]
+version = "1"
+
+[dev-dependencies.static_assertions]
+version = "1"
+
+[lints.clippy]
+all = "warn"
+as_ptr_cast_mut = "warn"
+as_underscore = "warn"
+default_union_representation = "warn"
+inline_asm_x86_att_syntax = "warn"
+pedantic = "warn"
+trailing_empty_array = "warn"
+transmute_undefined_repr = "warn"
+undocumented_unsafe_blocks = "warn"
+
+[lints.clippy.bool_assert_comparison]
+level = "allow"
+priority = 1
+
+[lints.clippy.borrow_as_ptr]
+level = "allow"
+priority = 1
+
+[lints.clippy.cast_lossless]
+level = "allow"
+priority = 1
+
+[lints.clippy.declare_interior_mutable_const]
+level = "allow"
+priority = 1
+
+[lints.clippy.doc_markdown]
+level = "allow"
+priority = 1
+
+[lints.clippy.float_cmp]
+level = "allow"
+priority = 1
+
+[lints.clippy.incompatible_msrv]
+level = "allow"
+priority = 1
+
+[lints.clippy.lint_groups_priority]
+level = "allow"
+priority = 1
+
+[lints.clippy.manual_assert]
+level = "allow"
+priority = 1
+
+[lints.clippy.manual_range_contains]
+level = "allow"
+priority = 1
+
+[lints.clippy.missing_errors_doc]
+level = "allow"
+priority = 1
+
+[lints.clippy.module_name_repetitions]
+level = "allow"
+priority = 1
+
+[lints.clippy.naive_bytecount]
+level = "allow"
+priority = 1
+
+[lints.clippy.nonminimal_bool]
+level = "allow"
+priority = 1
+
+[lints.clippy.range_plus_one]
+level = "allow"
+priority = 1
+
+[lints.clippy.similar_names]
+level = "allow"
+priority = 1
+
+[lints.clippy.single_match]
+level = "allow"
+priority = 1
+
+[lints.clippy.single_match_else]
+level = "allow"
+priority = 1
+
+[lints.clippy.struct_excessive_bools]
+level = "allow"
+priority = 1
+
+[lints.clippy.struct_field_names]
+level = "allow"
+priority = 1
+
+[lints.clippy.too_many_arguments]
+level = "allow"
+priority = 1
+
+[lints.clippy.too_many_lines]
+level = "allow"
+priority = 1
+
+[lints.clippy.type_complexity]
+level = "allow"
+priority = 1
+
+[lints.clippy.unreadable_literal]
+level = "allow"
+priority = 1
+
+[lints.rust]
+deprecated_safe = "warn"
+improper_ctypes = "warn"
+improper_ctypes_definitions = "warn"
+non_ascii_idents = "warn"
+rust_2018_idioms = "warn"
+single_use_lifetimes = "warn"
+unreachable_pub = "warn"
+
+[lints.rust.unexpected_cfgs]
+level = "warn"
+priority = 0
+check-cfg = []

vendor/pin-project-lite/LICENSE-APACHE

@@ -0,0 +1,177 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS

vendor/pin-project-lite/LICENSE-MIT

@@ -0,0 +1,23 @@
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

vendor/pin-project-lite/README.md

@@ -0,0 +1,128 @@
+# 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&logo=docs.rs)](https://docs.rs/pin-project-lite)
+[![license](https://img.shields.io/badge/license-Apache--2.0_OR_MIT-blue?style=flat-square)](#license)
+[![msrv](https://img.shields.io/badge/msrv-1.37-blue?style=flat-square&logo=rust)](https://www.rust-lang.org)
+[![github actions](https://img.shields.io/github/actions/workflow/status/taiki-e/pin-project-lite/ci.yml?branch=main&style=flat-square&logo=github)](https://github.com/taiki-e/pin-project-lite/actions)
+
+<!-- tidy:crate-doc:start -->
+A lightweight version of [pin-project] written with declarative macros.
+
+## Usage
+
+Add this to your `Cargo.toml`:
+
+```toml
+[dependencies]
+pin-project-lite = "0.2"
+```
+
+## Examples
+
+[`pin_project!`] macro creates a projection type covering all the fields of
+struct.
+
+```rust
+use std::pin::Pin;
+
+use pin_project_lite::pin_project;
+
+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 std::pin::Pin;
+
+use pin_project_lite::pin_project;
+
+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 Unpin implementation
+
+pin-project supports this by [`UnsafeUnpin`][unsafe-unpin]. (`!Unpin` is supported by both [pin-project][not-unpin] and [pin-project-lite][not-unpin-lite].)
+
+### Different: No support for tuple structs and tuple variants
+
+pin-project supports this.
+
+[not-unpin]: https://docs.rs/pin-project/latest/pin_project/attr.pin_project.html#unpin
+[pin-project]: https://github.com/taiki-e/pin-project
+[unsafe-unpin]: https://docs.rs/pin-project/latest/pin_project/attr.pin_project.html#unsafeunpin
+
+<!-- tidy:crate-doc:end -->
+
+[not-unpin-lite]: https://docs.rs/pin-project-lite/latest/pin_project_lite/macro.pin_project.html#unpin
+[`pin_project!`]: https://docs.rs/pin-project-lite/latest/pin_project_lite/macro.pin_project.html
+
+## License
+
+Licensed under either of [Apache License, Version 2.0](LICENSE-APACHE) or
+[MIT license](LICENSE-MIT) at your option.
+
+Unless you explicitly state otherwise, any contribution intentionally submitted
+for inclusion in the work by you, as defined in the Apache-2.0 license, shall
+be dual licensed as above, without any additional terms or conditions.

vendor/pin-project-lite/tests/auxiliary/mod.rs

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+#![allow(dead_code, unused_macros)]
+
+macro_rules! assert_unpin {
+    ($ty:ty) => {
+        static_assertions::assert_impl_all!($ty: Unpin);
+    };
+}
+macro_rules! assert_not_unpin {
+    ($ty:ty) => {
+        static_assertions::assert_not_impl_all!($ty: Unpin);
+    };
+}

vendor/pin-project-lite/tests/compiletest.rs

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+#![cfg(not(miri))]
+
+#[rustversion::attr(not(nightly), ignore)]
+#[test]
+fn ui() {
+    let t = trybuild::TestCases::new();
+    t.compile_fail("tests/ui/**/*.rs");
+    t.pass("tests/run-pass/**/*.rs");
+}

vendor/pin-project-lite/tests/drop_order.rs

@@ -0,0 +1,169 @@
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+// Refs: https://doc.rust-lang.org/reference/destructors.html
+
+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<'_> {
+    fn drop(&mut self) {
+        if !thread::panicking() {
+            let old = self.0.replace(self.1);
+            assert_eq!(old, self.1 - 1);
+        }
+    }
+}
+
+pin_project! {
+#[project = StructPinnedProj]
+#[project_ref = StructPinnedProjRef]
+#[project_replace = StructPinnedProjReplace]
+struct StructPinned<'a> {
+    #[pin]
+    f1: D<'a>,
+    #[pin]
+    f2: D<'a>,
+}
+}
+
+pin_project! {
+#[project = StructUnpinnedProj]
+#[project_ref = StructUnpinnedProjRef]
+#[project_replace = StructUnpinnedProjReplace]
+struct StructUnpinned<'a> {
+    f1: D<'a>,
+    f2: D<'a>,
+}
+}
+
+pin_project! {
+#[project_replace = EnumProjReplace]
+enum Enum<'a> {
+    #[allow(dead_code)] // false positive that fixed in Rust 1.38
+    StructPinned {
+        #[pin]
+        f1: D<'a>,
+        #[pin]
+        f2: D<'a>,
+    },
+    #[allow(dead_code)] // false positive that fixed in Rust 1.38
+    StructUnpinned {
+        f1: D<'a>,
+        f2: D<'a>,
+    },
+}
+}
+
+#[test]
+fn struct_pinned() {
+    {
+        let c = Cell::new(0);
+        let _x = StructPinned { f1: D(&c, 1), f2: D(&c, 2) };
+    }
+    {
+        let c = Cell::new(0);
+        let mut x = StructPinned { f1: D(&c, 1), f2: D(&c, 2) };
+        let y = Pin::new(&mut x);
+        let _z = y.project_replace(StructPinned { f1: D(&c, 3), f2: D(&c, 4) });
+    }
+}
+
+#[test]
+fn struct_unpinned() {
+    {
+        let c = Cell::new(0);
+        let _x = StructUnpinned { f1: D(&c, 1), f2: D(&c, 2) };
+    }
+    {
+        let c = Cell::new(0);
+        let mut x = StructUnpinned { f1: D(&c, 1), f2: D(&c, 2) };
+        let y = Pin::new(&mut x);
+        let _z = y.project_replace(StructUnpinned { f1: D(&c, 3), f2: D(&c, 4) });
+    }
+}
+
+#[test]
+fn enum_struct() {
+    {
+        let c = Cell::new(0);
+        let _x = Enum::StructPinned { f1: D(&c, 1), f2: D(&c, 2) };
+    }
+    {
+        let c = Cell::new(0);
+        let mut x = Enum::StructPinned { f1: D(&c, 1), f2: D(&c, 2) };
+        let y = Pin::new(&mut x);
+        let _z = y.project_replace(Enum::StructPinned { f1: D(&c, 3), f2: D(&c, 4) });
+    }
+
+    {
+        let c = Cell::new(0);
+        let _x = Enum::StructUnpinned { f1: D(&c, 1), f2: D(&c, 2) };
+    }
+    {
+        let c = Cell::new(0);
+        let mut x = Enum::StructUnpinned { f1: D(&c, 1), f2: D(&c, 2) };
+        let y = Pin::new(&mut x);
+        let _z = y.project_replace(Enum::StructUnpinned { f1: D(&c, 3), f2: D(&c, 4) });
+    }
+}
+
+// https://github.com/rust-lang/rust/issues/47949
+// https://github.com/taiki-e/pin-project/pull/194#discussion_r419098111
+#[allow(clippy::many_single_char_names)]
+#[test]
+fn project_replace_panic() {
+    pin_project! {
+    #[project_replace = SProjReplace]
+    struct S<T, U> {
+        #[pin]
+        pinned: T,
+        unpinned: U,
+    }
+    }
+
+    struct D<'a>(&'a mut bool, bool);
+    impl Drop for D<'_> {
+        fn drop(&mut self) {
+            *self.0 = true;
+            if self.1 {
+                panic!();
+            }
+        }
+    }
+
+    let (mut a, mut b, mut c, mut d) = (false, false, false, false);
+    let res = panic::catch_unwind(panic::AssertUnwindSafe(|| {
+        let mut x = S { pinned: D(&mut a, true), unpinned: D(&mut b, false) };
+        let _y = Pin::new(&mut x)
+            .project_replace(S { pinned: D(&mut c, false), unpinned: D(&mut d, false) });
+        // Previous `x.pinned` was dropped and panicked when `project_replace` is
+        // called, so this is unreachable.
+        unreachable!();
+    }));
+    assert!(res.is_err());
+    assert!(a);
+    assert!(b);
+    assert!(c);
+    assert!(d);
+
+    let (mut a, mut b, mut c, mut d) = (false, false, false, false);
+    let res = panic::catch_unwind(panic::AssertUnwindSafe(|| {
+        let mut x = S { pinned: D(&mut a, false), unpinned: D(&mut b, true) };
+        {
+            let _y = Pin::new(&mut x)
+                .project_replace(S { pinned: D(&mut c, false), unpinned: D(&mut d, false) });
+            // `_y` (previous `x.unpinned`) live to the end of this scope, so
+            // this is not unreachable.
+            // unreachable!();
+        }
+        unreachable!();
+    }));
+    assert!(res.is_err());
+    assert!(a);
+    assert!(b);
+    assert!(c);
+    assert!(d);
+}

vendor/pin-project-lite/tests/expand/default/enum.expanded.rs

@@ -0,0 +1,166 @@
+use pin_project_lite::pin_project;
+enum Enum<T, U> {
+    Struct { pinned: T, unpinned: U },
+    Unit,
+}
+#[doc(hidden)]
+#[allow(
+    dead_code,
+    single_use_lifetimes,
+    clippy::unknown_clippy_lints,
+    clippy::absolute_paths,
+    clippy::min_ident_chars,
+    clippy::mut_mut,
+    clippy::redundant_pub_crate,
+    clippy::ref_option_ref,
+    clippy::single_char_lifetime_names,
+    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,
+}
+#[doc(hidden)]
+#[allow(
+    dead_code,
+    single_use_lifetimes,
+    clippy::unknown_clippy_lints,
+    clippy::absolute_paths,
+    clippy::min_ident_chars,
+    clippy::mut_mut,
+    clippy::redundant_pub_crate,
+    clippy::ref_option_ref,
+    clippy::single_char_lifetime_names,
+    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,
+}
+#[doc(hidden)]
+#[allow(
+    dead_code,
+    single_use_lifetimes,
+    clippy::unknown_clippy_lints,
+    clippy::absolute_paths,
+    clippy::min_ident_chars,
+    clippy::mut_mut,
+    clippy::redundant_pub_crate,
+    clippy::single_char_lifetime_names,
+    clippy::type_repetition_in_bounds
+)]
+enum EnumProjReplace<T, U> {
+    Struct { pinned: ::pin_project_lite::__private::PhantomData<T>, unpinned: U },
+    Unit,
+}
+#[allow(
+    single_use_lifetimes,
+    clippy::unknown_clippy_lints,
+    clippy::absolute_paths,
+    clippy::min_ident_chars,
+    clippy::single_char_lifetime_names,
+    clippy::used_underscore_binding
+)]
+const _: () = {
+    impl<T, U> Enum<T, U> {
+        #[doc(hidden)]
+        #[inline]
+        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,
+                }
+            }
+        }
+        #[doc(hidden)]
+        #[inline]
+        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,
+                }
+            }
+        }
+        #[doc(hidden)]
+        #[inline]
+        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::new(
+                    __self_ptr,
+                    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::new(
+                                    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
+        ::pin_project_lite::__private::PinnedFieldsOf<
+            __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() {}

vendor/pin-project-lite/tests/expand/default/enum.rs

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+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() {}

vendor/pin-project-lite/tests/expand/default/struct.expanded.rs

@@ -0,0 +1,107 @@
+use pin_project_lite::pin_project;
+struct Struct<T, U> {
+    pinned: T,
+    unpinned: U,
+}
+#[allow(
+    explicit_outlives_requirements,
+    single_use_lifetimes,
+    clippy::unknown_clippy_lints,
+    clippy::absolute_paths,
+    clippy::min_ident_chars,
+    clippy::redundant_pub_crate,
+    clippy::single_char_lifetime_names,
+    clippy::used_underscore_binding
+)]
+const _: () = {
+    #[doc(hidden)]
+    #[allow(
+        dead_code,
+        single_use_lifetimes,
+        clippy::unknown_clippy_lints,
+        clippy::absolute_paths,
+        clippy::min_ident_chars,
+        clippy::mut_mut,
+        clippy::redundant_pub_crate,
+        clippy::ref_option_ref,
+        clippy::single_char_lifetime_names,
+        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),
+    }
+    #[doc(hidden)]
+    #[allow(
+        dead_code,
+        single_use_lifetimes,
+        clippy::unknown_clippy_lints,
+        clippy::absolute_paths,
+        clippy::min_ident_chars,
+        clippy::mut_mut,
+        clippy::redundant_pub_crate,
+        clippy::ref_option_ref,
+        clippy::single_char_lifetime_names,
+        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> {
+        #[doc(hidden)]
+        #[inline]
+        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,
+                }
+            }
+        }
+        #[doc(hidden)]
+        #[inline]
+        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
+        ::pin_project_lite::__private::PinnedFieldsOf<
+            __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() {}

vendor/pin-project-lite/tests/expand/default/struct.rs

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+use pin_project_lite::pin_project;
+
+pin_project! {
+    struct Struct<T, U> {
+        #[pin]
+        pinned: T,
+        unpinned: U,
+    }
+}
+
+fn main() {}

vendor/pin-project-lite/tests/expand/multifields/enum.expanded.rs

@@ -0,0 +1,102 @@
+use pin_project_lite::pin_project;
+enum Enum<T, U> {
+    Struct { pinned1: T, pinned2: T, unpinned1: U, unpinned2: U },
+    Unit,
+}
+#[doc(hidden)]
+#[allow(
+    dead_code,
+    single_use_lifetimes,
+    clippy::unknown_clippy_lints,
+    clippy::absolute_paths,
+    clippy::min_ident_chars,
+    clippy::mut_mut,
+    clippy::redundant_pub_crate,
+    clippy::single_char_lifetime_names,
+    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,
+    clippy::unknown_clippy_lints,
+    clippy::absolute_paths,
+    clippy::min_ident_chars,
+    clippy::single_char_lifetime_names,
+    clippy::used_underscore_binding
+)]
+const _: () = {
+    impl<T, U> Enum<T, U> {
+        #[doc(hidden)]
+        #[inline]
+        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::new(
+                    __self_ptr,
+                    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::new(
+                                    pinned1,
+                                ),
+                                ::pin_project_lite::__private::UnsafeDropInPlaceGuard::new(
+                                    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
+        ::pin_project_lite::__private::PinnedFieldsOf<
+            __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() {}

vendor/pin-project-lite/tests/expand/multifields/enum.rs

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+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() {}

vendor/pin-project-lite/tests/expand/multifields/struct.expanded.rs

@@ -0,0 +1,174 @@
+use pin_project_lite::pin_project;
+struct Struct<T, U> {
+    pinned1: T,
+    pinned2: T,
+    unpinned1: U,
+    unpinned2: U,
+}
+#[doc(hidden)]
+#[allow(
+    dead_code,
+    single_use_lifetimes,
+    clippy::unknown_clippy_lints,
+    clippy::absolute_paths,
+    clippy::min_ident_chars,
+    clippy::mut_mut,
+    clippy::redundant_pub_crate,
+    clippy::single_char_lifetime_names,
+    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,
+    single_use_lifetimes,
+    clippy::unknown_clippy_lints,
+    clippy::absolute_paths,
+    clippy::min_ident_chars,
+    clippy::redundant_pub_crate,
+    clippy::single_char_lifetime_names,
+    clippy::used_underscore_binding
+)]
+const _: () = {
+    #[doc(hidden)]
+    #[allow(
+        dead_code,
+        single_use_lifetimes,
+        clippy::unknown_clippy_lints,
+        clippy::absolute_paths,
+        clippy::min_ident_chars,
+        clippy::mut_mut,
+        clippy::redundant_pub_crate,
+        clippy::ref_option_ref,
+        clippy::single_char_lifetime_names,
+        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),
+    }
+    #[doc(hidden)]
+    #[allow(
+        dead_code,
+        single_use_lifetimes,
+        clippy::unknown_clippy_lints,
+        clippy::absolute_paths,
+        clippy::min_ident_chars,
+        clippy::mut_mut,
+        clippy::redundant_pub_crate,
+        clippy::ref_option_ref,
+        clippy::single_char_lifetime_names,
+        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> {
+        #[doc(hidden)]
+        #[inline]
+        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,
+                }
+            }
+        }
+        #[doc(hidden)]
+        #[inline]
+        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,
+                }
+            }
+        }
+        #[doc(hidden)]
+        #[inline]
+        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::new(
+                    __self_ptr,
+                    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::new(
+                            pinned1,
+                        ),
+                        ::pin_project_lite::__private::UnsafeDropInPlaceGuard::new(
+                            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
+        ::pin_project_lite::__private::PinnedFieldsOf<
+            __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() {}

vendor/pin-project-lite/tests/expand/multifields/struct.rs

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+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() {}

vendor/pin-project-lite/tests/expand/naming/enum-all.expanded.rs

@@ -0,0 +1,166 @@
+use pin_project_lite::pin_project;
+enum Enum<T, U> {
+    Struct { pinned: T, unpinned: U },
+    Unit,
+}
+#[doc(hidden)]
+#[allow(
+    dead_code,
+    single_use_lifetimes,
+    clippy::unknown_clippy_lints,
+    clippy::absolute_paths,
+    clippy::min_ident_chars,
+    clippy::mut_mut,
+    clippy::redundant_pub_crate,
+    clippy::ref_option_ref,
+    clippy::single_char_lifetime_names,
+    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,
+}
+#[doc(hidden)]
+#[allow(
+    dead_code,
+    single_use_lifetimes,
+    clippy::unknown_clippy_lints,
+    clippy::absolute_paths,
+    clippy::min_ident_chars,
+    clippy::mut_mut,
+    clippy::redundant_pub_crate,
+    clippy::ref_option_ref,
+    clippy::single_char_lifetime_names,
+    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,
+}
+#[doc(hidden)]
+#[allow(
+    dead_code,
+    single_use_lifetimes,
+    clippy::unknown_clippy_lints,
+    clippy::absolute_paths,
+    clippy::min_ident_chars,
+    clippy::mut_mut,
+    clippy::redundant_pub_crate,
+    clippy::single_char_lifetime_names,
+    clippy::type_repetition_in_bounds
+)]
+enum EnumProjReplace<T, U> {
+    Struct { pinned: ::pin_project_lite::__private::PhantomData<T>, unpinned: U },
+    Unit,
+}
+#[allow(
+    single_use_lifetimes,
+    clippy::unknown_clippy_lints,
+    clippy::absolute_paths,
+    clippy::min_ident_chars,
+    clippy::single_char_lifetime_names,
+    clippy::used_underscore_binding
+)]
+const _: () = {
+    impl<T, U> Enum<T, U> {
+        #[doc(hidden)]
+        #[inline]
+        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,
+                }
+            }
+        }
+        #[doc(hidden)]
+        #[inline]
+        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,
+                }
+            }
+        }
+        #[doc(hidden)]
+        #[inline]
+        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::new(
+                    __self_ptr,
+                    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::new(
+                                    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
+        ::pin_project_lite::__private::PinnedFieldsOf<
+            __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() {}

vendor/pin-project-lite/tests/expand/naming/enum-all.rs

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+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() {}

vendor/pin-project-lite/tests/expand/naming/enum-mut.expanded.rs

@@ -0,0 +1,76 @@
+use pin_project_lite::pin_project;
+enum Enum<T, U> {
+    Struct { pinned: T, unpinned: U },
+    Unit,
+}
+#[doc(hidden)]
+#[allow(
+    dead_code,
+    single_use_lifetimes,
+    clippy::unknown_clippy_lints,
+    clippy::absolute_paths,
+    clippy::min_ident_chars,
+    clippy::mut_mut,
+    clippy::redundant_pub_crate,
+    clippy::ref_option_ref,
+    clippy::single_char_lifetime_names,
+    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,
+    clippy::unknown_clippy_lints,
+    clippy::absolute_paths,
+    clippy::min_ident_chars,
+    clippy::single_char_lifetime_names,
+    clippy::used_underscore_binding
+)]
+const _: () = {
+    impl<T, U> Enum<T, U> {
+        #[doc(hidden)]
+        #[inline]
+        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
+        ::pin_project_lite::__private::PinnedFieldsOf<
+            __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() {}

vendor/pin-project-lite/tests/expand/naming/enum-mut.rs

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+use pin_project_lite::pin_project;
+
+pin_project! {
+    #[project = EnumProj]
+    enum Enum<T, U> {
+        Struct {
+            #[pin]
+            pinned: T,
+            unpinned: U,
+        },
+        Unit,
+    }
+}
+
+fn main() {}

vendor/pin-project-lite/tests/expand/naming/enum-none.expanded.rs

@@ -0,0 +1,33 @@
+use pin_project_lite::pin_project;
+enum Enum<T, U> {
+    Struct { pinned: T, unpinned: U },
+    Unit,
+}
+#[allow(
+    single_use_lifetimes,
+    clippy::unknown_clippy_lints,
+    clippy::absolute_paths,
+    clippy::min_ident_chars,
+    clippy::single_char_lifetime_names,
+    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
+        ::pin_project_lite::__private::PinnedFieldsOf<
+            __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() {}

vendor/pin-project-lite/tests/expand/naming/enum-none.rs

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+use pin_project_lite::pin_project;
+
+pin_project! {
+    enum Enum<T, U> {
+        Struct {
+            #[pin]
+            pinned: T,
+            unpinned: U,
+        },
+        Unit,
+    }
+}
+
+fn main() {}

vendor/pin-project-lite/tests/expand/naming/enum-ref.expanded.rs

@@ -0,0 +1,76 @@
+use pin_project_lite::pin_project;
+enum Enum<T, U> {
+    Struct { pinned: T, unpinned: U },
+    Unit,
+}
+#[doc(hidden)]
+#[allow(
+    dead_code,
+    single_use_lifetimes,
+    clippy::unknown_clippy_lints,
+    clippy::absolute_paths,
+    clippy::min_ident_chars,
+    clippy::mut_mut,
+    clippy::redundant_pub_crate,
+    clippy::ref_option_ref,
+    clippy::single_char_lifetime_names,
+    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,
+    clippy::unknown_clippy_lints,
+    clippy::absolute_paths,
+    clippy::min_ident_chars,
+    clippy::single_char_lifetime_names,
+    clippy::used_underscore_binding
+)]
+const _: () = {
+    impl<T, U> Enum<T, U> {
+        #[doc(hidden)]
+        #[inline]
+        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
+        ::pin_project_lite::__private::PinnedFieldsOf<
+            __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() {}

vendor/pin-project-lite/tests/expand/naming/enum-ref.rs

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+use pin_project_lite::pin_project;
+
+pin_project! {
+    #[project_ref = EnumProjRef]
+    enum Enum<T, U> {
+        Struct {
+            #[pin]
+            pinned: T,
+            unpinned: U,
+        },
+        Unit,
+    }
+}
+
+fn main() {}

vendor/pin-project-lite/tests/expand/naming/struct-all.expanded.rs

@@ -0,0 +1,151 @@
+use pin_project_lite::pin_project;
+struct Struct<T, U> {
+    pinned: T,
+    unpinned: U,
+}
+#[doc(hidden)]
+#[allow(
+    dead_code,
+    single_use_lifetimes,
+    clippy::unknown_clippy_lints,
+    clippy::absolute_paths,
+    clippy::min_ident_chars,
+    clippy::mut_mut,
+    clippy::redundant_pub_crate,
+    clippy::ref_option_ref,
+    clippy::single_char_lifetime_names,
+    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),
+}
+#[doc(hidden)]
+#[allow(
+    dead_code,
+    single_use_lifetimes,
+    clippy::unknown_clippy_lints,
+    clippy::absolute_paths,
+    clippy::min_ident_chars,
+    clippy::mut_mut,
+    clippy::redundant_pub_crate,
+    clippy::ref_option_ref,
+    clippy::single_char_lifetime_names,
+    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),
+}
+#[doc(hidden)]
+#[allow(
+    dead_code,
+    single_use_lifetimes,
+    clippy::unknown_clippy_lints,
+    clippy::absolute_paths,
+    clippy::min_ident_chars,
+    clippy::mut_mut,
+    clippy::redundant_pub_crate,
+    clippy::single_char_lifetime_names,
+    clippy::type_repetition_in_bounds
+)]
+struct StructProjReplace<T, U> {
+    pinned: ::pin_project_lite::__private::PhantomData<T>,
+    unpinned: U,
+}
+#[allow(
+    explicit_outlives_requirements,
+    single_use_lifetimes,
+    clippy::unknown_clippy_lints,
+    clippy::absolute_paths,
+    clippy::min_ident_chars,
+    clippy::redundant_pub_crate,
+    clippy::single_char_lifetime_names,
+    clippy::used_underscore_binding
+)]
+const _: () = {
+    impl<T, U> Struct<T, U> {
+        #[doc(hidden)]
+        #[inline]
+        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,
+                }
+            }
+        }
+        #[doc(hidden)]
+        #[inline]
+        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,
+                }
+            }
+        }
+        #[doc(hidden)]
+        #[inline]
+        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::new(
+                    __self_ptr,
+                    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::new(
+                            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
+        ::pin_project_lite::__private::PinnedFieldsOf<
+            __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() {}

vendor/pin-project-lite/tests/expand/naming/struct-all.rs

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+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() {}

vendor/pin-project-lite/tests/expand/naming/struct-mut.expanded.rs

@@ -0,0 +1,107 @@
+use pin_project_lite::pin_project;
+struct Struct<T, U> {
+    pinned: T,
+    unpinned: U,
+}
+#[doc(hidden)]
+#[allow(
+    dead_code,
+    single_use_lifetimes,
+    clippy::unknown_clippy_lints,
+    clippy::absolute_paths,
+    clippy::min_ident_chars,
+    clippy::mut_mut,
+    clippy::redundant_pub_crate,
+    clippy::ref_option_ref,
+    clippy::single_char_lifetime_names,
+    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,
+    single_use_lifetimes,
+    clippy::unknown_clippy_lints,
+    clippy::absolute_paths,
+    clippy::min_ident_chars,
+    clippy::redundant_pub_crate,
+    clippy::single_char_lifetime_names,
+    clippy::used_underscore_binding
+)]
+const _: () = {
+    #[doc(hidden)]
+    #[allow(
+        dead_code,
+        single_use_lifetimes,
+        clippy::unknown_clippy_lints,
+        clippy::absolute_paths,
+        clippy::min_ident_chars,
+        clippy::mut_mut,
+        clippy::redundant_pub_crate,
+        clippy::ref_option_ref,
+        clippy::single_char_lifetime_names,
+        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> {
+        #[doc(hidden)]
+        #[inline]
+        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,
+                }
+            }
+        }
+        #[doc(hidden)]
+        #[inline]
+        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
+        ::pin_project_lite::__private::PinnedFieldsOf<
+            __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() {}

vendor/pin-project-lite/tests/expand/naming/struct-mut.rs

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+use pin_project_lite::pin_project;
+
+pin_project! {
+    #[project = StructProj]
+    struct Struct<T, U> {
+        #[pin]
+        pinned: T,
+        unpinned: U,
+    }
+}
+
+fn main() {}

vendor/pin-project-lite/tests/expand/naming/struct-none.expanded.rs

@@ -0,0 +1,107 @@
+use pin_project_lite::pin_project;
+struct Struct<T, U> {
+    pinned: T,
+    unpinned: U,
+}
+#[allow(
+    explicit_outlives_requirements,
+    single_use_lifetimes,
+    clippy::unknown_clippy_lints,
+    clippy::absolute_paths,
+    clippy::min_ident_chars,
+    clippy::redundant_pub_crate,
+    clippy::single_char_lifetime_names,
+    clippy::used_underscore_binding
+)]
+const _: () = {
+    #[doc(hidden)]
+    #[allow(
+        dead_code,
+        single_use_lifetimes,
+        clippy::unknown_clippy_lints,
+        clippy::absolute_paths,
+        clippy::min_ident_chars,
+        clippy::mut_mut,
+        clippy::redundant_pub_crate,
+        clippy::ref_option_ref,
+        clippy::single_char_lifetime_names,
+        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),
+    }
+    #[doc(hidden)]
+    #[allow(
+        dead_code,
+        single_use_lifetimes,
+        clippy::unknown_clippy_lints,
+        clippy::absolute_paths,
+        clippy::min_ident_chars,
+        clippy::mut_mut,
+        clippy::redundant_pub_crate,
+        clippy::ref_option_ref,
+        clippy::single_char_lifetime_names,
+        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> {
+        #[doc(hidden)]
+        #[inline]
+        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,
+                }
+            }
+        }
+        #[doc(hidden)]
+        #[inline]
+        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
+        ::pin_project_lite::__private::PinnedFieldsOf<
+            __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() {}

vendor/pin-project-lite/tests/expand/naming/struct-none.rs

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+use pin_project_lite::pin_project;
+
+pin_project! {
+    struct Struct<T, U> {
+        #[pin]
+        pinned: T,
+        unpinned: U,
+    }
+}
+
+fn main() {}

vendor/pin-project-lite/tests/expand/naming/struct-ref.expanded.rs

@@ -0,0 +1,107 @@
+use pin_project_lite::pin_project;
+struct Struct<T, U> {
+    pinned: T,
+    unpinned: U,
+}
+#[doc(hidden)]
+#[allow(
+    dead_code,
+    single_use_lifetimes,
+    clippy::unknown_clippy_lints,
+    clippy::absolute_paths,
+    clippy::min_ident_chars,
+    clippy::mut_mut,
+    clippy::redundant_pub_crate,
+    clippy::ref_option_ref,
+    clippy::single_char_lifetime_names,
+    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,
+    single_use_lifetimes,
+    clippy::unknown_clippy_lints,
+    clippy::absolute_paths,
+    clippy::min_ident_chars,
+    clippy::redundant_pub_crate,
+    clippy::single_char_lifetime_names,
+    clippy::used_underscore_binding
+)]
+const _: () = {
+    #[doc(hidden)]
+    #[allow(
+        dead_code,
+        single_use_lifetimes,
+        clippy::unknown_clippy_lints,
+        clippy::absolute_paths,
+        clippy::min_ident_chars,
+        clippy::mut_mut,
+        clippy::redundant_pub_crate,
+        clippy::ref_option_ref,
+        clippy::single_char_lifetime_names,
+        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> {
+        #[doc(hidden)]
+        #[inline]
+        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,
+                }
+            }
+        }
+        #[doc(hidden)]
+        #[inline]
+        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
+        ::pin_project_lite::__private::PinnedFieldsOf<
+            __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() {}

vendor/pin-project-lite/tests/expand/naming/struct-ref.rs

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+use pin_project_lite::pin_project;
+
+pin_project! {
+    #[project_ref = StructProjRef]
+    struct Struct<T, U> {
+        #[pin]
+        pinned: T,
+        unpinned: U,
+    }
+}
+
+fn main() {}

vendor/pin-project-lite/tests/expand/not_unpin/enum.expanded.rs

@@ -0,0 +1,114 @@
+use pin_project_lite::pin_project;
+enum Enum<T, U> {
+    Struct { pinned: T, unpinned: U },
+    Unit,
+}
+#[doc(hidden)]
+#[allow(
+    dead_code,
+    single_use_lifetimes,
+    clippy::unknown_clippy_lints,
+    clippy::absolute_paths,
+    clippy::min_ident_chars,
+    clippy::mut_mut,
+    clippy::redundant_pub_crate,
+    clippy::ref_option_ref,
+    clippy::single_char_lifetime_names,
+    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,
+}
+#[doc(hidden)]
+#[allow(
+    dead_code,
+    single_use_lifetimes,
+    clippy::unknown_clippy_lints,
+    clippy::absolute_paths,
+    clippy::min_ident_chars,
+    clippy::mut_mut,
+    clippy::redundant_pub_crate,
+    clippy::ref_option_ref,
+    clippy::single_char_lifetime_names,
+    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,
+    clippy::unknown_clippy_lints,
+    clippy::absolute_paths,
+    clippy::min_ident_chars,
+    clippy::single_char_lifetime_names,
+    clippy::used_underscore_binding
+)]
+const _: () = {
+    impl<T, U> Enum<T, U> {
+        #[doc(hidden)]
+        #[inline]
+        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,
+                }
+            }
+        }
+        #[doc(hidden)]
+        #[inline]
+        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,
+                }
+            }
+        }
+    }
+    #[doc(hidden)]
+    impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Enum<T, U>
+    where
+        (
+            ::pin_project_lite::__private::PhantomData<&'__pin ()>,
+            ::pin_project_lite::__private::PhantomPinned,
+        ): ::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() {}

vendor/pin-project-lite/tests/expand/not_unpin/enum.rs

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+use pin_project_lite::pin_project;
+
+pin_project! {
+    #[project(!Unpin)]
+    #[project = EnumProj]
+    #[project_ref = EnumProjRef]
+    enum Enum<T, U> {
+        Struct {
+            #[pin]
+            pinned: T,
+            unpinned: U,
+        },
+        Unit,
+    }
+}
+
+fn main() {}

vendor/pin-project-lite/tests/expand/not_unpin/struct.expanded.rs

@@ -0,0 +1,103 @@
+use pin_project_lite::pin_project;
+struct Struct<T, U> {
+    pinned: T,
+    unpinned: U,
+}
+#[doc(hidden)]
+#[allow(
+    dead_code,
+    single_use_lifetimes,
+    clippy::unknown_clippy_lints,
+    clippy::absolute_paths,
+    clippy::min_ident_chars,
+    clippy::mut_mut,
+    clippy::redundant_pub_crate,
+    clippy::ref_option_ref,
+    clippy::single_char_lifetime_names,
+    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),
+}
+#[doc(hidden)]
+#[allow(
+    dead_code,
+    single_use_lifetimes,
+    clippy::unknown_clippy_lints,
+    clippy::absolute_paths,
+    clippy::min_ident_chars,
+    clippy::mut_mut,
+    clippy::redundant_pub_crate,
+    clippy::ref_option_ref,
+    clippy::single_char_lifetime_names,
+    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,
+    single_use_lifetimes,
+    clippy::unknown_clippy_lints,
+    clippy::absolute_paths,
+    clippy::min_ident_chars,
+    clippy::redundant_pub_crate,
+    clippy::single_char_lifetime_names,
+    clippy::used_underscore_binding
+)]
+const _: () = {
+    impl<T, U> Struct<T, U> {
+        #[doc(hidden)]
+        #[inline]
+        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,
+                }
+            }
+        }
+        #[doc(hidden)]
+        #[inline]
+        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,
+                }
+            }
+        }
+    }
+    #[doc(hidden)]
+    impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Struct<T, U>
+    where
+        (
+            ::pin_project_lite::__private::PhantomData<&'__pin ()>,
+            ::pin_project_lite::__private::PhantomPinned,
+        ): ::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() {}

vendor/pin-project-lite/tests/expand/not_unpin/struct.rs

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+use pin_project_lite::pin_project;
+
+pin_project! {
+    #[project = StructProj]
+    #[project(!Unpin)]
+    #[project_ref = StructProjRef]
+    struct Struct<T, U> {
+        #[pin]
+        pinned: T,
+        unpinned: U,
+    }
+}
+
+fn main() {}

vendor/pin-project-lite/tests/expand/pinned_drop/enum.expanded.rs

@@ -0,0 +1,128 @@
+use pin_project_lite::pin_project;
+enum Enum<T, U> {
+    Struct { pinned: T, unpinned: U },
+    Unit,
+}
+#[doc(hidden)]
+#[allow(
+    dead_code,
+    single_use_lifetimes,
+    clippy::unknown_clippy_lints,
+    clippy::absolute_paths,
+    clippy::min_ident_chars,
+    clippy::mut_mut,
+    clippy::redundant_pub_crate,
+    clippy::ref_option_ref,
+    clippy::single_char_lifetime_names,
+    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,
+}
+#[doc(hidden)]
+#[allow(
+    dead_code,
+    single_use_lifetimes,
+    clippy::unknown_clippy_lints,
+    clippy::absolute_paths,
+    clippy::min_ident_chars,
+    clippy::mut_mut,
+    clippy::redundant_pub_crate,
+    clippy::ref_option_ref,
+    clippy::single_char_lifetime_names,
+    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,
+    clippy::unknown_clippy_lints,
+    clippy::absolute_paths,
+    clippy::min_ident_chars,
+    clippy::single_char_lifetime_names,
+    clippy::used_underscore_binding
+)]
+const _: () = {
+    impl<T, U> Enum<T, U> {
+        #[doc(hidden)]
+        #[inline]
+        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,
+                }
+            }
+        }
+        #[doc(hidden)]
+        #[inline]
+        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
+        ::pin_project_lite::__private::PinnedFieldsOf<
+            __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() {}

vendor/pin-project-lite/tests/expand/pinned_drop/enum.rs

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+use pin_project_lite::pin_project;
+
+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() {}

vendor/pin-project-lite/tests/expand/pinned_drop/struct.expanded.rs

@@ -0,0 +1,117 @@
+use pin_project_lite::pin_project;
+struct Struct<T, U> {
+    pinned: T,
+    unpinned: U,
+}
+#[allow(
+    explicit_outlives_requirements,
+    single_use_lifetimes,
+    clippy::unknown_clippy_lints,
+    clippy::absolute_paths,
+    clippy::min_ident_chars,
+    clippy::redundant_pub_crate,
+    clippy::single_char_lifetime_names,
+    clippy::used_underscore_binding
+)]
+const _: () = {
+    #[doc(hidden)]
+    #[allow(
+        dead_code,
+        single_use_lifetimes,
+        clippy::unknown_clippy_lints,
+        clippy::absolute_paths,
+        clippy::min_ident_chars,
+        clippy::mut_mut,
+        clippy::redundant_pub_crate,
+        clippy::ref_option_ref,
+        clippy::single_char_lifetime_names,
+        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),
+    }
+    #[doc(hidden)]
+    #[allow(
+        dead_code,
+        single_use_lifetimes,
+        clippy::unknown_clippy_lints,
+        clippy::absolute_paths,
+        clippy::min_ident_chars,
+        clippy::mut_mut,
+        clippy::redundant_pub_crate,
+        clippy::ref_option_ref,
+        clippy::single_char_lifetime_names,
+        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> {
+        #[doc(hidden)]
+        #[inline]
+        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,
+                }
+            }
+        }
+        #[doc(hidden)]
+        #[inline]
+        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
+        ::pin_project_lite::__private::PinnedFieldsOf<
+            __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() {}

vendor/pin-project-lite/tests/expand/pinned_drop/struct.rs

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+use pin_project_lite::pin_project;
+
+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() {}

vendor/pin-project-lite/tests/expand/pub/enum.expanded.rs

@@ -0,0 +1,118 @@
+use pin_project_lite::pin_project;
+pub enum Enum<T, U> {
+    Struct { pinned: T, unpinned: U },
+    Unit,
+}
+#[doc(hidden)]
+#[allow(
+    dead_code,
+    single_use_lifetimes,
+    clippy::unknown_clippy_lints,
+    clippy::absolute_paths,
+    clippy::min_ident_chars,
+    clippy::mut_mut,
+    clippy::redundant_pub_crate,
+    clippy::ref_option_ref,
+    clippy::single_char_lifetime_names,
+    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,
+}
+#[doc(hidden)]
+#[allow(
+    dead_code,
+    single_use_lifetimes,
+    clippy::unknown_clippy_lints,
+    clippy::absolute_paths,
+    clippy::min_ident_chars,
+    clippy::mut_mut,
+    clippy::redundant_pub_crate,
+    clippy::ref_option_ref,
+    clippy::single_char_lifetime_names,
+    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,
+    clippy::unknown_clippy_lints,
+    clippy::absolute_paths,
+    clippy::min_ident_chars,
+    clippy::single_char_lifetime_names,
+    clippy::used_underscore_binding
+)]
+const _: () = {
+    impl<T, U> Enum<T, U> {
+        #[doc(hidden)]
+        #[inline]
+        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,
+                }
+            }
+        }
+        #[doc(hidden)]
+        #[inline]
+        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
+        ::pin_project_lite::__private::PinnedFieldsOf<
+            __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() {}

vendor/pin-project-lite/tests/expand/pub/enum.rs

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+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() {}

vendor/pin-project-lite/tests/expand/pub/struct.expanded.rs

@@ -0,0 +1,107 @@
+use pin_project_lite::pin_project;
+pub struct Struct<T, U> {
+    pub pinned: T,
+    pub unpinned: U,
+}
+#[allow(
+    explicit_outlives_requirements,
+    single_use_lifetimes,
+    clippy::unknown_clippy_lints,
+    clippy::absolute_paths,
+    clippy::min_ident_chars,
+    clippy::redundant_pub_crate,
+    clippy::single_char_lifetime_names,
+    clippy::used_underscore_binding
+)]
+const _: () = {
+    #[doc(hidden)]
+    #[allow(
+        dead_code,
+        single_use_lifetimes,
+        clippy::unknown_clippy_lints,
+        clippy::absolute_paths,
+        clippy::min_ident_chars,
+        clippy::mut_mut,
+        clippy::redundant_pub_crate,
+        clippy::ref_option_ref,
+        clippy::single_char_lifetime_names,
+        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),
+    }
+    #[doc(hidden)]
+    #[allow(
+        dead_code,
+        single_use_lifetimes,
+        clippy::unknown_clippy_lints,
+        clippy::absolute_paths,
+        clippy::min_ident_chars,
+        clippy::mut_mut,
+        clippy::redundant_pub_crate,
+        clippy::ref_option_ref,
+        clippy::single_char_lifetime_names,
+        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> {
+        #[doc(hidden)]
+        #[inline]
+        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,
+                }
+            }
+        }
+        #[doc(hidden)]
+        #[inline]
+        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
+        ::pin_project_lite::__private::PinnedFieldsOf<
+            __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() {}

vendor/pin-project-lite/tests/expand/pub/struct.rs

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+use pin_project_lite::pin_project;
+
+pin_project! {
+    pub struct Struct<T, U> {
+        #[pin]
+        pub pinned: T,
+        pub unpinned: U,
+    }
+}
+
+fn main() {}

vendor/pin-project-lite/tests/expandtest.rs

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+#![cfg(not(miri))]
+
+#[rustversion::attr(not(nightly), ignore)]
+#[test]
+fn expandtest() {
+    let args = &["--all-features"];
+    macrotest::expand_args("tests/expand/**/*.rs", args);
+}

vendor/pin-project-lite/tests/include/basic.rs

@@ -0,0 +1,81 @@
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+// default pin_project! is completely safe.
+
+::pin_project_lite::pin_project! {
+    /// Testing default struct.
+    #[derive(Debug)]
+    #[allow(clippy::exhaustive_structs)] // for the type itself
+    pub struct DefaultStruct<T, U> {
+        #[pin]
+        pub pinned: T,
+        pub unpinned: U,
+    }
+}
+
+::pin_project_lite::pin_project! {
+    /// Testing named struct.
+    #[allow(clippy::exhaustive_structs)] // for the type itself
+    #[project = DefaultStructProj]
+    #[project_ref = DefaultStructProjRef]
+    #[derive(Debug)]
+    pub struct DefaultStructNamed<T, U> {
+        #[pin]
+        pub pinned: T,
+        pub unpinned: U,
+    }
+}
+
+::pin_project_lite::pin_project! {
+    /// Testing enum.
+    #[allow(clippy::exhaustive_enums)] // for the type itself
+    #[project = DefaultEnumProj]
+    #[project_ref = DefaultEnumProjRef]
+    #[derive(Debug)]
+    pub enum DefaultEnum<T, U> {
+        /// Struct variant.
+        Struct {
+            #[pin]
+            pinned: T,
+            unpinned: U,
+        },
+        /// Unit variant.
+        Unit,
+    }
+}
+
+::pin_project_lite::pin_project! {
+    /// Testing pinned drop struct.
+    #[allow(clippy::exhaustive_structs)] // for the type itself
+    #[derive(Debug)]
+    pub struct PinnedDropStruct<T, U> {
+        #[pin]
+        pub pinned: T,
+        pub unpinned: U,
+    }
+    impl<T, U> PinnedDrop for PinnedDropStruct<T, U> {
+        fn drop(_this: Pin<&mut Self>) {}
+    }
+}
+
+::pin_project_lite::pin_project! {
+    /// Testing pinned drop enum.
+    #[allow(clippy::absolute_paths, clippy::exhaustive_enums)] // for the type itself
+    #[project = PinnedDropEnumProj]
+    #[project_ref = PinnedDropEnumProjRef]
+    #[derive(Debug)]
+    pub enum PinnedDropEnum<T: ::pin_project_lite::__private::Unpin, U> {
+        /// Struct variant.
+        Struct {
+            #[pin]
+            pinned: T,
+            unpinned: U,
+        },
+        /// Unit variant.
+        Unit,
+    }
+    #[allow(clippy::absolute_paths)]
+    impl<T: ::pin_project_lite::__private::Unpin, U> PinnedDrop for PinnedDropEnum<T, U> {
+        fn drop(_this: Pin<&mut Self>) {}
+    }
+}

vendor/pin-project-lite/tests/proper_unpin.rs

@@ -0,0 +1,101 @@
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+#![allow(dead_code)]
+
+#[macro_use]
+mod auxiliary;
+
+pub mod default {
+    use std::marker::PhantomPinned;
+
+    use pin_project_lite::pin_project;
+
+    struct Inner<T> {
+        f: T,
+    }
+
+    assert_unpin!(Inner<()>);
+    assert_not_unpin!(Inner<PhantomPinned>);
+
+    pin_project! {
+        struct Struct<T, U> {
+            #[pin]
+            f1: Inner<T>,
+            f2: U,
+        }
+    }
+
+    assert_unpin!(Struct<(), ()>);
+    assert_unpin!(Struct<(), PhantomPinned>);
+    assert_not_unpin!(Struct<PhantomPinned, ()>);
+    assert_not_unpin!(Struct<PhantomPinned, PhantomPinned>);
+
+    pin_project! {
+        #[project = EnumProj]
+        #[project_ref = EnumProjRef]
+        enum Enum<T, U> {
+            V1 {
+                #[pin]
+                f1: Inner<T>,
+                f2: U,
+            },
+        }
+    }
+
+    assert_unpin!(Enum<(), ()>);
+    assert_unpin!(Enum<(), PhantomPinned>);
+    assert_not_unpin!(Enum<PhantomPinned, ()>);
+    assert_not_unpin!(Enum<PhantomPinned, PhantomPinned>);
+
+    pin_project! {
+        #[project(!Unpin)]
+        enum NotUnpinEnum<T, U> {
+            V1 {
+                #[pin] f1: Inner<T>,
+                f2: U,
+            }
+        }
+    }
+
+    assert_not_unpin!(NotUnpinEnum<(), ()>);
+
+    pin_project! {
+        struct TrivialBounds {
+            #[pin]
+            f: PhantomPinned,
+        }
+    }
+
+    assert_not_unpin!(TrivialBounds);
+
+    pin_project! {
+        struct PinRef<'a, T, U> {
+            #[pin]
+            f1: &'a mut Inner<T>,
+            f2: U,
+        }
+    }
+
+    assert_unpin!(PinRef<'_, PhantomPinned, PhantomPinned>);
+
+    pin_project! {
+        #[project(!Unpin)]
+        struct NotUnpin<U> {
+            #[pin]
+            u: U
+        }
+    }
+
+    assert_not_unpin!(NotUnpin<()>);
+
+    pin_project! {
+        #[project(!Unpin)]
+        struct NotUnpinRef<'a, T, U> {
+            #[pin]
+            f1: &'a mut Inner<T>,
+            f2: U
+        }
+    }
+
+    assert_not_unpin!(NotUnpinRef<'_, (), ()>);
+}

vendor/pin-project-lite/tests/test.rs

@@ -0,0 +1,699 @@
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+#![allow(dead_code, unreachable_pub, clippy::no_effect_underscore_binding)]
+
+#[macro_use]
+mod auxiliary;
+
+use core::{
+    marker::{PhantomData, PhantomPinned},
+    pin::Pin,
+};
+
+use pin_project_lite::pin_project;
+
+#[test]
+fn projection() {
+    pin_project! {
+        #[project = StructProj]
+        #[project_ref = StructProjRef]
+        #[project_replace = StructProjReplace]
+        #[derive(Default)]
+        struct Struct<T, U> {
+            #[pin]
+            f1: T,
+            f2: U,
+        }
+    }
+
+    let mut s = Struct { f1: 1, f2: 2 };
+    let mut s_orig = Pin::new(&mut s);
+    let s = s_orig.as_mut().project();
+
+    let _: Pin<&mut i32> = s.f1;
+    assert_eq!(*s.f1, 1);
+    let _: &mut i32 = s.f2;
+    assert_eq!(*s.f2, 2);
+
+    assert_eq!(s_orig.as_ref().f1, 1);
+    assert_eq!(s_orig.as_ref().f2, 2);
+
+    let mut s = Struct { f1: 1, f2: 2 };
+    let mut s = Pin::new(&mut s);
+    {
+        let StructProj { f1, f2 } = s.as_mut().project();
+        let _: Pin<&mut i32> = f1;
+        let _: &mut i32 = f2;
+    }
+    {
+        let StructProjRef { f1, f2 } = s.as_ref().project_ref();
+        let _: Pin<&i32> = f1;
+        let _: &i32 = f2;
+    }
+
+    {
+        let StructProjReplace { f1: PhantomData, f2 } =
+            s.as_mut().project_replace(Struct::default());
+        assert_eq!(f2, 2);
+        let StructProj { f1, f2 } = s.project();
+        assert_eq!(*f1, 0);
+        assert_eq!(*f2, 0);
+    }
+
+    pin_project! {
+        #[project = EnumProj]
+        #[project_ref = EnumProjRef]
+        #[project_replace = EnumProjReplace]
+        #[derive(Eq, PartialEq, Debug)]
+        enum Enum<C, D> {
+            Struct {
+                #[pin]
+                f1: C,
+                f2: D,
+            },
+            Unit,
+        }
+    }
+
+    let mut e = Enum::Struct { f1: 1, f2: 2 };
+    let mut e = Pin::new(&mut e);
+
+    match e.as_mut().project() {
+        EnumProj::Struct { f1, f2 } => {
+            let _: Pin<&mut i32> = f1;
+            assert_eq!(*f1, 1);
+            let _: &mut i32 = f2;
+            assert_eq!(*f2, 2);
+        }
+        EnumProj::Unit => unreachable!(),
+    }
+
+    assert_eq!(&*e, &Enum::Struct { f1: 1, f2: 2 });
+
+    if let EnumProj::Struct { f1, f2 } = e.as_mut().project() {
+        let _: Pin<&mut i32> = f1;
+        assert_eq!(*f1, 1);
+        let _: &mut i32 = f2;
+        assert_eq!(*f2, 2);
+    }
+
+    if let EnumProjReplace::Struct { f1: PhantomData, f2 } = e.as_mut().project_replace(Enum::Unit)
+    {
+        assert_eq!(f2, 2);
+    }
+}
+
+#[test]
+fn enum_project_set() {
+    pin_project! {
+        #[project = EnumProj]
+        #[project_ref = EnumProjRef]
+        #[derive(Eq, PartialEq, Debug)]
+        enum Enum {
+            V1 { #[pin] f: u8 },
+            V2 { f: bool },
+        }
+    }
+
+    let mut e = Enum::V1 { f: 25 };
+    let mut e_orig = Pin::new(&mut e);
+    let e_proj = e_orig.as_mut().project();
+
+    match e_proj {
+        EnumProj::V1 { f } => {
+            let new_e = Enum::V2 { f: f.as_ref().get_ref() == &25 };
+            e_orig.set(new_e);
+        }
+        EnumProj::V2 { .. } => unreachable!(),
+    }
+
+    assert_eq!(e, Enum::V2 { f: true });
+}
+
+#[test]
+fn where_clause() {
+    pin_project! {
+        struct Struct<T>
+        where
+            T: Copy,
+        {
+            f: T,
+        }
+    }
+
+    pin_project! {
+        #[project = EnumProj]
+        #[project_ref = EnumProjRef]
+        enum Enum<T>
+        where
+            T: Copy,
+        {
+            V { f: T },
+        }
+    }
+}
+
+#[test]
+fn where_clause_and_associated_type_field() {
+    pin_project! {
+        struct Struct1<I>
+        where
+            I: Iterator,
+        {
+            #[pin]
+            f1: I,
+            f2: I::Item,
+        }
+    }
+
+    pin_project! {
+        struct Struct2<I, J>
+        where
+            I: Iterator<Item = J>,
+        {
+            #[pin]
+            f1: I,
+            f2: J,
+        }
+    }
+
+    pin_project! {
+        pub struct Struct3<T>
+        where
+            T: 'static,
+        {
+            f: T,
+        }
+    }
+
+    trait Static: 'static {}
+
+    impl<T> Static for Struct3<T> {}
+
+    pin_project! {
+        #[project = EnumProj]
+        #[project_ref = EnumProjRef]
+        enum Enum<I>
+        where
+            I: Iterator,
+        {
+            V1 { #[pin] f: I },
+            V2 { f: I::Item },
+        }
+    }
+}
+
+#[test]
+fn derive_copy() {
+    pin_project! {
+        #[derive(Clone, Copy)]
+        struct Struct<T> {
+            f: T,
+        }
+    }
+
+    fn is_copy<T: Copy>() {}
+
+    is_copy::<Struct<u8>>();
+}
+
+#[test]
+fn move_out() {
+    struct NotCopy;
+
+    pin_project! {
+        struct Struct {
+            f: NotCopy,
+        }
+    }
+
+    let x = Struct { f: NotCopy };
+    let _val: NotCopy = x.f;
+
+    pin_project! {
+        #[project = EnumProj]
+        #[project_ref = EnumProjRef]
+        enum Enum {
+            V { f: NotCopy },
+        }
+    }
+
+    let x = Enum::V { f: NotCopy };
+    #[allow(clippy::infallible_destructuring_match)]
+    let _val: NotCopy = match x {
+        Enum::V { f } => f,
+    };
+}
+
+#[test]
+fn trait_bounds_on_type_generics() {
+    pin_project! {
+        pub struct Struct1<'a, T: ?Sized> {
+            f: &'a mut T,
+        }
+    }
+
+    pin_project! {
+        pub struct Struct2<'a, T: ::core::fmt::Debug> {
+            f: &'a mut T,
+        }
+    }
+
+    pin_project! {
+        pub struct Struct3<'a, T: core::fmt::Debug> {
+            f: &'a mut T,
+        }
+    }
+
+    // pin_project! {
+    //     pub struct Struct4<'a, T: core::fmt::Debug + core::fmt::Display> {
+    //         f: &'a mut T,
+    //     }
+    // }
+
+    // pin_project! {
+    //     pub struct Struct5<'a, T: core::fmt::Debug + ?Sized> {
+    //         f: &'a mut T,
+    //     }
+    // }
+
+    pin_project! {
+        pub struct Struct6<'a, T: core::fmt::Debug = [u8; 16]> {
+            f: &'a mut T,
+        }
+    }
+
+    let _: Struct6<'_> = Struct6 { f: &mut [0_u8; 16] };
+
+    pin_project! {
+        pub struct Struct7<T: 'static> {
+            f: T,
+        }
+    }
+
+    trait Static: 'static {}
+
+    impl<T> Static for Struct7<T> {}
+
+    pin_project! {
+        pub struct Struct8<'a, 'b: 'a> {
+            f1: &'a u8,
+            f2: &'b u8,
+        }
+    }
+
+    pin_project! {
+        #[project = EnumProj]
+        #[project_ref = EnumProjRef]
+        enum Enum<'a, T: ?Sized> {
+            V { f: &'a mut T },
+        }
+    }
+}
+
+#[test]
+fn private_type_in_public_type() {
+    pin_project! {
+        pub struct PublicStruct<T> {
+            #[pin]
+            inner: PrivateStruct<T>,
+        }
+    }
+
+    struct PrivateStruct<T>(T);
+}
+
+#[allow(clippy::needless_lifetimes)]
+#[test]
+fn lifetime_project() {
+    pin_project! {
+        struct Struct1<T, U> {
+            #[pin]
+            pinned: T,
+            unpinned: U,
+        }
+    }
+
+    pin_project! {
+        struct Struct2<'a, T, U> {
+            #[pin]
+            pinned: &'a T,
+            unpinned: U,
+        }
+    }
+
+    pin_project! {
+        #[project = EnumProj]
+        #[project_ref = EnumProjRef]
+        enum Enum<T, U> {
+            V {
+                #[pin]
+                pinned: T,
+                unpinned: U,
+            },
+        }
+    }
+
+    impl<T, U> Struct1<T, U> {
+        fn get_pin_ref<'a>(self: Pin<&'a Self>) -> Pin<&'a T> {
+            self.project_ref().pinned
+        }
+        fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut T> {
+            self.project().pinned
+        }
+        fn get_pin_ref_elided(self: Pin<&Self>) -> Pin<&T> {
+            self.project_ref().pinned
+        }
+        fn get_pin_mut_elided(self: Pin<&mut Self>) -> Pin<&mut T> {
+            self.project().pinned
+        }
+    }
+
+    impl<'b, T, U> Struct2<'b, T, U> {
+        fn get_pin_ref<'a>(self: Pin<&'a Self>) -> Pin<&'a &'b T> {
+            self.project_ref().pinned
+        }
+        fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut &'b T> {
+            self.project().pinned
+        }
+        fn get_pin_ref_elided(self: Pin<&Self>) -> Pin<&&'b T> {
+            self.project_ref().pinned
+        }
+        fn get_pin_mut_elided(self: Pin<&mut Self>) -> Pin<&mut &'b T> {
+            self.project().pinned
+        }
+    }
+
+    impl<T, U> Enum<T, U> {
+        fn get_pin_ref<'a>(self: Pin<&'a Self>) -> Pin<&'a T> {
+            match self.project_ref() {
+                EnumProjRef::V { pinned, .. } => pinned,
+            }
+        }
+        fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut T> {
+            match self.project() {
+                EnumProj::V { pinned, .. } => pinned,
+            }
+        }
+        fn get_pin_ref_elided(self: Pin<&Self>) -> Pin<&T> {
+            match self.project_ref() {
+                EnumProjRef::V { pinned, .. } => pinned,
+            }
+        }
+        fn get_pin_mut_elided(self: Pin<&mut Self>) -> Pin<&mut T> {
+            match self.project() {
+                EnumProj::V { pinned, .. } => pinned,
+            }
+        }
+    }
+}
+
+mod visibility {
+    use pin_project_lite::pin_project;
+
+    pin_project! {
+        pub(crate) struct S {
+            pub f: u8,
+        }
+    }
+}
+
+#[test]
+fn visibility() {
+    let mut x = visibility::S { f: 0 };
+    let x = Pin::new(&mut x);
+    let y = x.as_ref().project_ref();
+    let _: &u8 = y.f;
+    let y = x.project();
+    let _: &mut u8 = y.f;
+}
+
+#[test]
+fn trivial_bounds() {
+    pin_project! {
+        pub struct NoGenerics {
+            #[pin]
+            f: PhantomPinned,
+        }
+    }
+
+    assert_not_unpin!(NoGenerics);
+}
+
+#[test]
+fn dst() {
+    pin_project! {
+        pub struct Struct1<T: ?Sized> {
+            f: T,
+        }
+    }
+
+    let mut x = Struct1 { f: 0_u8 };
+    let x: Pin<&mut Struct1<dyn core::fmt::Debug>> = Pin::new(&mut x);
+    let _: &mut (dyn core::fmt::Debug) = x.project().f;
+
+    pin_project! {
+        pub struct Struct2<T: ?Sized> {
+            #[pin]
+            f: T,
+        }
+    }
+
+    let mut x = Struct2 { f: 0_u8 };
+    let x: Pin<&mut Struct2<dyn core::fmt::Debug + Unpin>> = Pin::new(&mut x);
+    let _: Pin<&mut (dyn core::fmt::Debug + Unpin)> = x.project().f;
+
+    pin_project! {
+        struct Struct3<T>
+        where
+            T: ?Sized,
+        {
+            f: T,
+        }
+    }
+
+    pin_project! {
+        struct Struct4<T>
+        where
+            T: ?Sized,
+        {
+            #[pin]
+            f: T,
+        }
+    }
+
+    pin_project! {
+        struct Struct11<'a, T: ?Sized, U: ?Sized> {
+            f1: &'a mut T,
+            f2: U,
+        }
+    }
+}
+
+#[test]
+fn dyn_type() {
+    pin_project! {
+        struct Struct1 {
+            f: dyn core::fmt::Debug,
+        }
+    }
+
+    pin_project! {
+        struct Struct2 {
+            #[pin]
+            f: dyn core::fmt::Debug,
+        }
+    }
+
+    pin_project! {
+        struct Struct3 {
+            f: dyn core::fmt::Debug + Send,
+        }
+    }
+
+    pin_project! {
+        struct Struct4 {
+            #[pin]
+            f: dyn core::fmt::Debug + Send,
+        }
+    }
+}
+
+#[test]
+fn no_infer_outlives() {
+    trait Trait<X> {
+        type Y;
+    }
+
+    struct Struct1<A>(A);
+
+    impl<X, T> Trait<X> for Struct1<T> {
+        type Y = Option<T>;
+    }
+
+    pin_project! {
+        struct Struct2<A, B> {
+            _f: <Struct1<A> as Trait<B>>::Y,
+        }
+    }
+}
+
+// https://github.com/taiki-e/pin-project-lite/issues/31
+#[test]
+fn trailing_comma() {
+    pub trait T {}
+
+    pin_project! {
+        pub struct S1<
+            A: T,
+            B: T,
+        > {
+            f: (A, B),
+        }
+    }
+
+    pin_project! {
+        pub struct S2<
+            A,
+            B,
+        >
+        where
+            A: T,
+            B: T,
+        {
+            f: (A, B),
+        }
+    }
+
+    pin_project! {
+        #[allow(explicit_outlives_requirements)]
+        pub struct S3<
+            'a,
+            A: 'a,
+            B: 'a,
+        > {
+            f: &'a (A, B),
+        }
+    }
+
+    // pin_project! {
+    //     pub struct S4<
+    //         'a,
+    //         'b: 'a, // <-----
+    //     > {
+    //         f: &'a &'b (),
+    //     }
+    // }
+}
+
+#[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 {
+            #[cfg(not(any()))]
+            V {
+                f: ()
+            },
+        }
+    }
+
+    pin_project! {
+        /// dox1
+        #[derive(Clone)]
+        #[project(!Unpin)]
+        #[project = Enum2Proj]
+        #[project_ref = Enum2ProjRef]
+        /// dox2
+        #[derive(Debug)]
+        /// dox3
+        enum Enum2 {
+            /// dox4
+            V1 {
+                // TODO
+                // /// dox5
+                f: ()
+            },
+            /// dox6
+            V2,
+        }
+    }
+}
+
+#[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;
+            }
+        }
+    }
+
+    trait Service<Request> {
+        type Error;
+    }
+
+    pin_project! {
+        struct Struct3<'a, T, Request>
+        where
+            T: Service<Request>,
+            T::Error: std::error::Error,
+        {
+            was_dropped: &'a mut bool,
+            #[pin]
+            field: T,
+            req: Request,
+        }
+
+        /// dox1
+        impl<T, Request> PinnedDrop for Struct3<'_, T, Request>
+        where
+            T: Service<Request>,
+            T::Error: std::error::Error,
+        {
+            /// dox2
+            fn drop(mut this: Pin<&mut Self>) {
+                **this.as_mut().project().was_dropped = true;
+            }
+        }
+    }
+}

vendor/pin-project-lite/tests/ui/not_unpin/conflict-unpin.rs

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+use pin_project_lite::pin_project;
+
+pin_project! {
+    #[project(!Unpin)]
+    struct Foo<T, U> {
+        #[pin]
+        f1: T,
+        f2: U,
+    }
+}
+
+impl<T, U> Unpin for Foo<T, U> where T: Unpin {}
+
+pin_project! {
+    #[project(!Unpin)]
+    struct Bar<T, U> {
+        #[pin]
+        f1: T,
+        f2: U,
+    }
+}
+
+impl<T, U> Unpin for Bar<T, U> {}
+
+pin_project! {
+    #[project(!Unpin)]
+    struct Baz<T, U> {
+        #[pin]
+        f1: T,
+        f2: U,
+    }
+}
+
+impl<T: Unpin, U: Unpin> Unpin for Baz<T, U> {}
+
+fn main() {}

vendor/pin-project-lite/tests/ui/not_unpin/conflict-unpin.stderr

@@ -0,0 +1,50 @@
+error[E0119]: conflicting implementations of trait `Unpin` for type `Foo<_, _>`
+  --> tests/ui/not_unpin/conflict-unpin.rs:5:1
+   |
+5  | / pin_project! {
+6  | |     #[project(!Unpin)]
+7  | |     struct Foo<T, U> {
+8  | |         #[pin]
+...  |
+12 | | }
+   | |_^ conflicting implementation for `Foo<_, _>`
+13 |
+14 |   impl<T, U> Unpin for Foo<T, U> where T: Unpin {}
+   |   --------------------------------------------- first implementation here
+   |
+   = note: upstream crates may add a new impl of trait `std::marker::Unpin` for type `(std::marker::PhantomData<&()>, std::marker::PhantomPinned)` in future versions
+   = note: this error originates in the macro `$crate::__pin_project_make_unpin_impl` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0119]: conflicting implementations of trait `Unpin` for type `Bar<_, _>`
+  --> tests/ui/not_unpin/conflict-unpin.rs:16:1
+   |
+16 | / pin_project! {
+17 | |     #[project(!Unpin)]
+18 | |     struct Bar<T, U> {
+19 | |         #[pin]
+...  |
+23 | | }
+   | |_^ conflicting implementation for `Bar<_, _>`
+24 |
+25 |   impl<T, U> Unpin for Bar<T, U> {}
+   |   ------------------------------ first implementation here
+   |
+   = note: upstream crates may add a new impl of trait `std::marker::Unpin` for type `(std::marker::PhantomData<&()>, std::marker::PhantomPinned)` in future versions
+   = note: this error originates in the macro `$crate::__pin_project_make_unpin_impl` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0119]: conflicting implementations of trait `Unpin` for type `Baz<_, _>`
+  --> tests/ui/not_unpin/conflict-unpin.rs:27:1
+   |
+27 | / pin_project! {
+28 | |     #[project(!Unpin)]
+29 | |     struct Baz<T, U> {
+30 | |         #[pin]
+...  |
+34 | | }
+   | |_^ conflicting implementation for `Baz<_, _>`
+35 |
+36 |   impl<T: Unpin, U: Unpin> Unpin for Baz<T, U> {}
+   |   -------------------------------------------- first implementation here
+   |
+   = note: upstream crates may add a new impl of trait `std::marker::Unpin` for type `(std::marker::PhantomData<&()>, std::marker::PhantomPinned)` in future versions
+   = note: this error originates in the macro `$crate::__pin_project_make_unpin_impl` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)

vendor/pin-project-lite/tests/ui/not_unpin/negative_impls_stable.rs

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+// https://github.com/taiki-e/pin-project/issues/340#issuecomment-2428002670
+
+pin_project_lite::pin_project! {
+    #[project(!Unpin)]
+    struct Foo<Pinned, Unpinned> {
+        #[pin]
+        pinned: Pinned,
+        unpinned: Unpinned,
+    }
+}
+
+struct MyPhantomPinned(::core::marker::PhantomPinned);
+impl Unpin for MyPhantomPinned where for<'cursed> str: Sized {}
+impl Unpin for Foo<MyPhantomPinned, ()> {}
+
+fn is_unpin<T: Unpin>() {}
+
+fn main() {
+    is_unpin::<Foo<MyPhantomPinned, ()>>()
+}

vendor/pin-project-lite/tests/ui/not_unpin/negative_impls_stable.stderr

@@ -0,0 +1,16 @@
+error[E0119]: conflicting implementations of trait `Unpin` for type `Foo<MyPhantomPinned, ()>`
+  --> tests/ui/not_unpin/negative_impls_stable.rs:5:1
+   |
+5  | / pin_project_lite::pin_project! {
+6  | |     #[project(!Unpin)]
+7  | |     struct Foo<Pinned, Unpinned> {
+8  | |         #[pin]
+...  |
+12 | | }
+   | |_^ conflicting implementation for `Foo<MyPhantomPinned, ()>`
+...
+16 |   impl Unpin for Foo<MyPhantomPinned, ()> {}
+   |   --------------------------------------- first implementation here
+   |
+   = note: upstream crates may add a new impl of trait `std::marker::Unpin` for type `(std::marker::PhantomData<&()>, std::marker::PhantomPinned)` in future versions
+   = note: this error originates in the macro `$crate::__pin_project_make_unpin_impl` which comes from the expansion of the macro `pin_project_lite::pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)

vendor/pin-project-lite/tests/ui/pin_project/conflict-drop.rs

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+use pin_project_lite::pin_project;
+
+pin_project! { //~ ERROR E0119
+    struct Foo<T, U> {
+        #[pin]
+        future: T,
+        field: U,
+    }
+}
+
+impl<T, U> Drop for Foo<T, U> {
+    fn drop(&mut self) {}
+}
+
+fn main() {}

vendor/pin-project-lite/tests/ui/pin_project/conflict-drop.stderr

@@ -0,0 +1,15 @@
+error[E0119]: conflicting implementations of trait `MustNotImplDrop` for type `Foo<_, _>`
+  --> tests/ui/pin_project/conflict-drop.rs:5:1
+   |
+5  | / pin_project! { //~ ERROR E0119
+6  | |     struct Foo<T, U> {
+7  | |         #[pin]
+8  | |         future: T,
+...  |
+11 | | }
+   | | ^
+   | | |
+   | |_first implementation here
+   |   conflicting implementation for `Foo<_, _>`
+   |
+   = note: this error originates in the macro `$crate::__pin_project_make_drop_impl` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)

vendor/pin-project-lite/tests/ui/pin_project/conflict-unpin.rs

@@ -0,0 +1,66 @@
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+use pin_project_lite::pin_project;
+
+// The same implementation.
+
+pin_project! { //~ ERROR E0119
+    struct Foo<T, U> {
+        #[pin]
+        future: T,
+        field: U,
+    }
+}
+
+// conflicting implementations
+impl<T, U> Unpin for Foo<T, U> where T: Unpin {} // Conditional Unpin impl
+
+// The implementation that under different conditions.
+
+pin_project! { //~ ERROR E0119
+    struct Bar<T, U> {
+        #[pin]
+        future: T,
+        field: U,
+    }
+}
+
+// conflicting implementations
+impl<T, U> Unpin for Bar<T, U> {} // Non-conditional Unpin impl
+
+pin_project! { //~ ERROR E0119
+    struct Baz<T, U> {
+        #[pin]
+        future: T,
+        field: U,
+    }
+}
+
+// conflicting implementations
+impl<T: Unpin, U: Unpin> Unpin for Baz<T, U> {} // Conditional Unpin impl
+
+pin_project! { //~ ERROR E0119
+    #[project(!Unpin)]
+    struct Qux<T, U> {
+        #[pin]
+        future: T,
+        field: U,
+    }
+}
+
+// conflicting implementations
+impl<T, U> Unpin for Qux<T, U> {} // Non-conditional Unpin impl
+
+pin_project! { //~ ERROR E0119
+    #[project(!Unpin)]
+    struct Fred<T, U> {
+        #[pin]
+        future: T,
+        field: U,
+    }
+}
+
+// conflicting implementations
+impl<T: Unpin, U: Unpin> Unpin for Fred<T, U> {} // Conditional Unpin impl
+
+fn main() {}

vendor/pin-project-lite/tests/ui/pin_project/conflict-unpin.stderr

@@ -0,0 +1,81 @@
+error[E0119]: conflicting implementations of trait `Unpin` for type `Foo<_, _>`
+  --> tests/ui/pin_project/conflict-unpin.rs:7:1
+   |
+7  | / pin_project! { //~ ERROR E0119
+8  | |     struct Foo<T, U> {
+9  | |         #[pin]
+10 | |         future: T,
+...  |
+13 | | }
+   | |_^ conflicting implementation for `Foo<_, _>`
+...
+16 |   impl<T, U> Unpin for Foo<T, U> where T: Unpin {} // Conditional Unpin impl
+   |   --------------------------------------------- first implementation here
+   |
+   = note: this error originates in the macro `$crate::__pin_project_make_unpin_impl` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0119]: conflicting implementations of trait `Unpin` for type `Bar<_, _>`
+  --> tests/ui/pin_project/conflict-unpin.rs:20:1
+   |
+20 | / pin_project! { //~ ERROR E0119
+21 | |     struct Bar<T, U> {
+22 | |         #[pin]
+23 | |         future: T,
+...  |
+26 | | }
+   | |_^ conflicting implementation for `Bar<_, _>`
+...
+29 |   impl<T, U> Unpin for Bar<T, U> {} // Non-conditional Unpin impl
+   |   ------------------------------ first implementation here
+   |
+   = note: this error originates in the macro `$crate::__pin_project_make_unpin_impl` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0119]: conflicting implementations of trait `Unpin` for type `Baz<_, _>`
+  --> tests/ui/pin_project/conflict-unpin.rs:31:1
+   |
+31 | / pin_project! { //~ ERROR E0119
+32 | |     struct Baz<T, U> {
+33 | |         #[pin]
+34 | |         future: T,
+...  |
+37 | | }
+   | |_^ conflicting implementation for `Baz<_, _>`
+...
+40 |   impl<T: Unpin, U: Unpin> Unpin for Baz<T, U> {} // Conditional Unpin impl
+   |   -------------------------------------------- first implementation here
+   |
+   = note: this error originates in the macro `$crate::__pin_project_make_unpin_impl` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0119]: conflicting implementations of trait `Unpin` for type `Qux<_, _>`
+  --> tests/ui/pin_project/conflict-unpin.rs:42:1
+   |
+42 | / pin_project! { //~ ERROR E0119
+43 | |     #[project(!Unpin)]
+44 | |     struct Qux<T, U> {
+45 | |         #[pin]
+...  |
+49 | | }
+   | |_^ conflicting implementation for `Qux<_, _>`
+...
+52 |   impl<T, U> Unpin for Qux<T, U> {} // Non-conditional Unpin impl
+   |   ------------------------------ first implementation here
+   |
+   = note: upstream crates may add a new impl of trait `std::marker::Unpin` for type `(std::marker::PhantomData<&()>, std::marker::PhantomPinned)` in future versions
+   = note: this error originates in the macro `$crate::__pin_project_make_unpin_impl` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0119]: conflicting implementations of trait `Unpin` for type `Fred<_, _>`
+  --> tests/ui/pin_project/conflict-unpin.rs:54:1
+   |
+54 | / pin_project! { //~ ERROR E0119
+55 | |     #[project(!Unpin)]
+56 | |     struct Fred<T, U> {
+57 | |         #[pin]
+...  |
+61 | | }
+   | |_^ conflicting implementation for `Fred<_, _>`
+...
+64 |   impl<T: Unpin, U: Unpin> Unpin for Fred<T, U> {} // Conditional Unpin impl
+   |   --------------------------------------------- first implementation here
+   |
+   = note: upstream crates may add a new impl of trait `std::marker::Unpin` for type `(std::marker::PhantomData<&()>, std::marker::PhantomPinned)` in future versions
+   = note: this error originates in the macro `$crate::__pin_project_make_unpin_impl` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)

vendor/pin-project-lite/tests/ui/pin_project/invalid-bounds.rs

@@ -0,0 +1,95 @@
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+use pin_project_lite::pin_project;
+
+pin_project! {
+    struct Generics1<T: 'static : Sized> { //~ ERROR no rules expected the token `:`
+        field: T,
+    }
+}
+
+pin_project! {
+    struct Generics2<T: 'static : ?Sized> { //~ ERROR no rules expected the token `:`
+        field: T,
+    }
+}
+
+pin_project! {
+    struct Generics3<T: Sized : 'static> { //~ ERROR expected one of `+`, `,`, `=`, or `>`, found `:`
+        field: T,
+    }
+}
+
+pin_project! {
+    struct Generics4<T: ?Sized : 'static> { //~ ERROR expected one of `+`, `,`, `=`, or `>`, found `:`
+        field: T,
+    }
+}
+
+pin_project! {
+    struct Generics5<T: Sized : ?Sized> { //~ ERROR expected one of `+`, `,`, `=`, or `>`, found `:`
+        field: T,
+    }
+}
+
+pin_project! {
+    struct Generics6<T: ?Sized : Sized> { //~ ERROR no rules expected the token `Sized`
+        field: T,
+    }
+}
+
+pin_project! {
+    struct WhereClause1<T>
+    where
+        T: 'static : Sized //~ ERROR no rules expected the token `:`
+    {
+        field: T,
+    }
+}
+
+pin_project! {
+    struct WhereClause2<T>
+    where
+        T: 'static : ?Sized //~ ERROR no rules expected the token `:`
+    {
+        field: T,
+    }
+}
+
+pin_project! {
+    struct WhereClause3<T>
+    where
+        T: Sized : 'static //~ ERROR expected `where`, or `{` after struct name, found `:`
+    {
+        field: T,
+    }
+}
+
+pin_project! {
+    struct WhereClause4<T>
+    where
+        T: ?Sized : 'static //~ ERROR expected `where`, or `{` after struct name, found `:`
+    {
+        field: T,
+    }
+}
+
+pin_project! {
+    struct WhereClause5<T>
+    where
+        T: Sized : ?Sized //~ ERROR expected `where`, or `{` after struct name, found `:`
+    {
+        field: T,
+    }
+}
+
+pin_project! {
+    struct WhereClause6<T>
+    where
+        T: ?Sized : Sized //~ ERROR no rules expected the token `Sized`
+    {
+        field: T,
+    }
+}
+
+fn main() {}

vendor/pin-project-lite/tests/ui/pin_project/invalid-bounds.stderr

@@ -0,0 +1,518 @@
+error: no rules expected `:`
+ --> tests/ui/pin_project/invalid-bounds.rs:6:33
+  |
+6 |     struct Generics1<T: 'static : Sized> { //~ ERROR no rules expected the token `:`
+  |                                 ^ no rules expected this token in macro call
+  |
+note: while trying to match `>`
+ --> src/lib.rs
+  |
+  |         >)?
+  |         ^
+
+error: no rules expected `:`
+  --> tests/ui/pin_project/invalid-bounds.rs:12:33
+   |
+12 |     struct Generics2<T: 'static : ?Sized> { //~ ERROR no rules expected the token `:`
+   |                                 ^ no rules expected this token in macro call
+   |
+note: while trying to match `>`
+  --> src/lib.rs
+   |
+   |         >)?
+   |         ^
+
+error: expected one of `+`, `,`, `=`, or `>`, found `:`
+  --> tests/ui/pin_project/invalid-bounds.rs:17:1
+   |
+17 | / pin_project! {
+18 | |     struct Generics3<T: Sized : 'static> { //~ ERROR expected one of `+`, `,`, `=`, or `>`, found `:`
+19 | |         field: T,
+20 | |     }
+21 | | }
+   | | ^
+   | | |
+   | | expected one of `+`, `,`, `=`, or `>`
+   | |_unexpected token
+   |   in this macro invocation
+   |
+   = note: this error originates in the macro `$crate::__pin_project_parse_generics` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: you might have meant to end the type parameters here
+  --> src/lib.rs
+   |
+   |                     $(: $generics_bound>)?
+   |                                        +
+
+error: expected one of `+`, `,`, `=`, or `>`, found `:`
+  --> tests/ui/pin_project/invalid-bounds.rs:17:1
+   |
+17 | / pin_project! {
+18 | |     struct Generics3<T: Sized : 'static> { //~ ERROR expected one of `+`, `,`, `=`, or `>`, found `:`
+19 | |         field: T,
+20 | |     }
+21 | | }
+   | | ^
+   | | |
+   | |_expected one of `+`, `,`, `=`, or `>`
+   |   unexpected token
+   |
+   = note: type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
+   = note: this error originates in the macro `$crate::__pin_project_parse_generics` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: you might have meant to end the type parameters here
+  --> src/lib.rs
+   |
+   |                     $(: $generics_bound>)?
+   |                                        +
+
+error: expected one of `+`, `,`, `=`, or `>`, found `:`
+  --> tests/ui/pin_project/invalid-bounds.rs:17:1
+   |
+17 | / pin_project! {
+18 | |     struct Generics3<T: Sized : 'static> { //~ ERROR expected one of `+`, `,`, `=`, or `>`, found `:`
+19 | |         field: T,
+20 | |     }
+21 | | }
+   | | ^
+   | | |
+   | | expected one of `+`, `,`, `=`, or `>`
+   | |_unexpected token
+   |   in this macro invocation
+   |
+   = note: this error originates in the macro `$crate::__pin_project_parse_generics` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: you might have meant to end the type parameters here
+  --> src/lib.rs
+   |
+   |                     $(: $generics_bound>)?
+   |                                        +
+
+error: expected one of `+`, `,`, `=`, or `>`, found `:`
+  --> tests/ui/pin_project/invalid-bounds.rs:17:1
+   |
+17 | / pin_project! {
+18 | |     struct Generics3<T: Sized : 'static> { //~ ERROR expected one of `+`, `,`, `=`, or `>`, found `:`
+19 | |         field: T,
+20 | |     }
+21 | | }
+   | | ^
+   | | |
+   | | expected one of `+`, `,`, `=`, or `>`
+   | |_unexpected token
+   |   in this macro invocation
+   |
+   = note: this error originates in the macro `$crate::__pin_project_parse_generics` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: you might have meant to end the type parameters here
+  --> src/lib.rs
+   |
+   |                     $(: $generics_bound>)?
+   |                                        +
+
+error: expected one of `+`, `,`, `=`, or `>`, found `:`
+  --> tests/ui/pin_project/invalid-bounds.rs:23:1
+   |
+23 | / pin_project! {
+24 | |     struct Generics4<T: ?Sized : 'static> { //~ ERROR expected one of `+`, `,`, `=`, or `>`, found `:`
+25 | |         field: T,
+26 | |     }
+27 | | }
+   | | ^
+   | | |
+   | | expected one of `+`, `,`, `=`, or `>`
+   | |_unexpected token
+   |   in this macro invocation
+   |
+   = note: this error originates in the macro `$crate::__pin_project_parse_generics` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: you might have meant to end the type parameters here
+  --> src/lib.rs
+   |
+   |                     $(: ?$generics_unsized_bound>)?
+   |                                                 +
+
+error: expected one of `+`, `,`, `=`, or `>`, found `:`
+  --> tests/ui/pin_project/invalid-bounds.rs:23:1
+   |
+23 | / pin_project! {
+24 | |     struct Generics4<T: ?Sized : 'static> { //~ ERROR expected one of `+`, `,`, `=`, or `>`, found `:`
+25 | |         field: T,
+26 | |     }
+27 | | }
+   | | ^
+   | | |
+   | |_expected one of `+`, `,`, `=`, or `>`
+   |   unexpected token
+   |
+   = note: type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
+   = note: this error originates in the macro `$crate::__pin_project_parse_generics` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: you might have meant to end the type parameters here
+  --> src/lib.rs
+   |
+   |                     $(: ?$generics_unsized_bound>)?
+   |                                                 +
+
+error: expected one of `+`, `,`, `=`, or `>`, found `:`
+  --> tests/ui/pin_project/invalid-bounds.rs:23:1
+   |
+23 | / pin_project! {
+24 | |     struct Generics4<T: ?Sized : 'static> { //~ ERROR expected one of `+`, `,`, `=`, or `>`, found `:`
+25 | |         field: T,
+26 | |     }
+27 | | }
+   | | ^
+   | | |
+   | | expected one of `+`, `,`, `=`, or `>`
+   | |_unexpected token
+   |   in this macro invocation
+   |
+   = note: this error originates in the macro `$crate::__pin_project_parse_generics` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: you might have meant to end the type parameters here
+  --> src/lib.rs
+   |
+   |                     $(: ?$generics_unsized_bound>)?
+   |                                                 +
+
+error: expected one of `+`, `,`, `=`, or `>`, found `:`
+  --> tests/ui/pin_project/invalid-bounds.rs:23:1
+   |
+23 | / pin_project! {
+24 | |     struct Generics4<T: ?Sized : 'static> { //~ ERROR expected one of `+`, `,`, `=`, or `>`, found `:`
+25 | |         field: T,
+26 | |     }
+27 | | }
+   | | ^
+   | | |
+   | | expected one of `+`, `,`, `=`, or `>`
+   | |_unexpected token
+   |   in this macro invocation
+   |
+   = note: this error originates in the macro `$crate::__pin_project_parse_generics` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: you might have meant to end the type parameters here
+  --> src/lib.rs
+   |
+   |                     $(: ?$generics_unsized_bound>)?
+   |                                                 +
+
+error: expected one of `+`, `,`, `=`, or `>`, found `:`
+  --> tests/ui/pin_project/invalid-bounds.rs:29:1
+   |
+29 | / pin_project! {
+30 | |     struct Generics5<T: Sized : ?Sized> { //~ ERROR expected one of `+`, `,`, `=`, or `>`, found `:`
+31 | |         field: T,
+32 | |     }
+33 | | }
+   | | ^
+   | | |
+   | | expected one of `+`, `,`, `=`, or `>`
+   | |_unexpected token
+   |   in this macro invocation
+   |
+   = note: this error originates in the macro `$crate::__pin_project_parse_generics` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: you might have meant to end the type parameters here
+  --> src/lib.rs
+   |
+   |                     $(: $generics_bound>)?
+   |                                        +
+
+error: expected one of `+`, `,`, `=`, or `>`, found `:`
+  --> tests/ui/pin_project/invalid-bounds.rs:29:1
+   |
+29 | / pin_project! {
+30 | |     struct Generics5<T: Sized : ?Sized> { //~ ERROR expected one of `+`, `,`, `=`, or `>`, found `:`
+31 | |         field: T,
+32 | |     }
+33 | | }
+   | | ^
+   | | |
+   | |_expected one of `+`, `,`, `=`, or `>`
+   |   unexpected token
+   |
+   = note: type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
+   = note: this error originates in the macro `$crate::__pin_project_parse_generics` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: you might have meant to end the type parameters here
+  --> src/lib.rs
+   |
+   |                     $(: $generics_bound>)?
+   |                                        +
+
+error: expected one of `+`, `,`, `=`, or `>`, found `:`
+  --> tests/ui/pin_project/invalid-bounds.rs:29:1
+   |
+29 | / pin_project! {
+30 | |     struct Generics5<T: Sized : ?Sized> { //~ ERROR expected one of `+`, `,`, `=`, or `>`, found `:`
+31 | |         field: T,
+32 | |     }
+33 | | }
+   | | ^
+   | | |
+   | | expected one of `+`, `,`, `=`, or `>`
+   | |_unexpected token
+   |   in this macro invocation
+   |
+   = note: this error originates in the macro `$crate::__pin_project_parse_generics` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: you might have meant to end the type parameters here
+  --> src/lib.rs
+   |
+   |                     $(: $generics_bound>)?
+   |                                        +
+
+error: expected one of `+`, `,`, `=`, or `>`, found `:`
+  --> tests/ui/pin_project/invalid-bounds.rs:29:1
+   |
+29 | / pin_project! {
+30 | |     struct Generics5<T: Sized : ?Sized> { //~ ERROR expected one of `+`, `,`, `=`, or `>`, found `:`
+31 | |         field: T,
+32 | |     }
+33 | | }
+   | | ^
+   | | |
+   | | expected one of `+`, `,`, `=`, or `>`
+   | |_unexpected token
+   |   in this macro invocation
+   |
+   = note: this error originates in the macro `$crate::__pin_project_parse_generics` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: you might have meant to end the type parameters here
+  --> src/lib.rs
+   |
+   |                     $(: $generics_bound>)?
+   |                                        +
+
+error: no rules expected `Sized`
+  --> tests/ui/pin_project/invalid-bounds.rs:36:34
+   |
+36 |     struct Generics6<T: ?Sized : Sized> { //~ ERROR no rules expected the token `Sized`
+   |                                  ^^^^^ no rules expected this token in macro call
+   |
+note: while trying to match meta-variable `$generics_lifetime_bound:lifetime`
+  --> src/lib.rs
+   |
+   |                 $(: $generics_lifetime_bound:lifetime)?
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: no rules expected `:`
+  --> tests/ui/pin_project/invalid-bounds.rs:44:20
+   |
+44 |         T: 'static : Sized //~ ERROR no rules expected the token `:`
+   |                    ^ no rules expected this token in macro call
+   |
+note: while trying to match `{`
+  --> src/lib.rs
+   |
+   |         {
+   |         ^
+
+error: no rules expected `:`
+  --> tests/ui/pin_project/invalid-bounds.rs:53:20
+   |
+53 |         T: 'static : ?Sized //~ ERROR no rules expected the token `:`
+   |                    ^ no rules expected this token in macro call
+   |
+note: while trying to match `{`
+  --> src/lib.rs
+   |
+   |         {
+   |         ^
+
+error: expected `{` after struct name, found `:`
+  --> tests/ui/pin_project/invalid-bounds.rs:59:1
+   |
+59 | / pin_project! {
+60 | |     struct WhereClause3<T>
+61 | |     where
+62 | |         T: Sized : 'static //~ ERROR expected `where`, or `{` after struct name, found `:`
+...  |
+66 | | }
+   | | ^
+   | | |
+   | |_expected `{` after struct name
+   |   in this macro invocation
+   |
+   = note: this error originates in the macro `$crate::__pin_project_parse_generics` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: expected one of `+`, `,`, or `{`, found `:`
+  --> tests/ui/pin_project/invalid-bounds.rs:59:1
+   |
+59 | / pin_project! {
+60 | |     struct WhereClause3<T>
+61 | |     where
+62 | |         T: Sized : 'static //~ ERROR expected `where`, or `{` after struct name, found `:`
+...  |
+66 | | }
+   | | ^
+   | | |
+   | |_expected one of `+`, `,`, or `{`
+   |   unexpected token
+   |
+   = note: type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
+   = note: this error originates in the macro `$crate::__pin_project_parse_generics` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: expected `{` after struct name, found `:`
+  --> tests/ui/pin_project/invalid-bounds.rs:59:1
+   |
+59 | / pin_project! {
+60 | |     struct WhereClause3<T>
+61 | |     where
+62 | |         T: Sized : 'static //~ ERROR expected `where`, or `{` after struct name, found `:`
+...  |
+66 | | }
+   | | ^
+   | | |
+   | |_expected `{` after struct name
+   |   in this macro invocation
+   |
+   = note: this error originates in the macro `$crate::__pin_project_parse_generics` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: expected `{` after struct name, found `:`
+  --> tests/ui/pin_project/invalid-bounds.rs:59:1
+   |
+59 | / pin_project! {
+60 | |     struct WhereClause3<T>
+61 | |     where
+62 | |         T: Sized : 'static //~ ERROR expected `where`, or `{` after struct name, found `:`
+...  |
+66 | | }
+   | | ^
+   | | |
+   | |_expected `{` after struct name
+   |   in this macro invocation
+   |
+   = note: this error originates in the macro `$crate::__pin_project_parse_generics` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: expected `{` after struct name, found `:`
+  --> tests/ui/pin_project/invalid-bounds.rs:68:1
+   |
+68 | / pin_project! {
+69 | |     struct WhereClause4<T>
+70 | |     where
+71 | |         T: ?Sized : 'static //~ ERROR expected `where`, or `{` after struct name, found `:`
+...  |
+75 | | }
+   | | ^
+   | | |
+   | |_expected `{` after struct name
+   |   in this macro invocation
+   |
+   = note: this error originates in the macro `$crate::__pin_project_parse_generics` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: expected one of `+`, `,`, or `{`, found `:`
+  --> tests/ui/pin_project/invalid-bounds.rs:68:1
+   |
+68 | / pin_project! {
+69 | |     struct WhereClause4<T>
+70 | |     where
+71 | |         T: ?Sized : 'static //~ ERROR expected `where`, or `{` after struct name, found `:`
+...  |
+75 | | }
+   | | ^
+   | | |
+   | |_expected one of `+`, `,`, or `{`
+   |   unexpected token
+   |
+   = note: type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
+   = note: this error originates in the macro `$crate::__pin_project_parse_generics` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: expected `{` after struct name, found `:`
+  --> tests/ui/pin_project/invalid-bounds.rs:68:1
+   |
+68 | / pin_project! {
+69 | |     struct WhereClause4<T>
+70 | |     where
+71 | |         T: ?Sized : 'static //~ ERROR expected `where`, or `{` after struct name, found `:`
+...  |
+75 | | }
+   | | ^
+   | | |
+   | |_expected `{` after struct name
+   |   in this macro invocation
+   |
+   = note: this error originates in the macro `$crate::__pin_project_parse_generics` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: expected `{` after struct name, found `:`
+  --> tests/ui/pin_project/invalid-bounds.rs:68:1
+   |
+68 | / pin_project! {
+69 | |     struct WhereClause4<T>
+70 | |     where
+71 | |         T: ?Sized : 'static //~ ERROR expected `where`, or `{` after struct name, found `:`
+...  |
+75 | | }
+   | | ^
+   | | |
+   | |_expected `{` after struct name
+   |   in this macro invocation
+   |
+   = note: this error originates in the macro `$crate::__pin_project_parse_generics` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: expected `{` after struct name, found `:`
+  --> tests/ui/pin_project/invalid-bounds.rs:77:1
+   |
+77 | / pin_project! {
+78 | |     struct WhereClause5<T>
+79 | |     where
+80 | |         T: Sized : ?Sized //~ ERROR expected `where`, or `{` after struct name, found `:`
+...  |
+84 | | }
+   | | ^
+   | | |
+   | |_expected `{` after struct name
+   |   in this macro invocation
+   |
+   = note: this error originates in the macro `$crate::__pin_project_parse_generics` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: expected one of `+`, `,`, or `{`, found `:`
+  --> tests/ui/pin_project/invalid-bounds.rs:77:1
+   |
+77 | / pin_project! {
+78 | |     struct WhereClause5<T>
+79 | |     where
+80 | |         T: Sized : ?Sized //~ ERROR expected `where`, or `{` after struct name, found `:`
+...  |
+84 | | }
+   | | ^
+   | | |
+   | |_expected one of `+`, `,`, or `{`
+   |   unexpected token
+   |
+   = note: type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
+   = note: this error originates in the macro `$crate::__pin_project_parse_generics` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: expected `{` after struct name, found `:`
+  --> tests/ui/pin_project/invalid-bounds.rs:77:1
+   |
+77 | / pin_project! {
+78 | |     struct WhereClause5<T>
+79 | |     where
+80 | |         T: Sized : ?Sized //~ ERROR expected `where`, or `{` after struct name, found `:`
+...  |
+84 | | }
+   | | ^
+   | | |
+   | |_expected `{` after struct name
+   |   in this macro invocation
+   |
+   = note: this error originates in the macro `$crate::__pin_project_parse_generics` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: expected `{` after struct name, found `:`
+  --> tests/ui/pin_project/invalid-bounds.rs:77:1
+   |
+77 | / pin_project! {
+78 | |     struct WhereClause5<T>
+79 | |     where
+80 | |         T: Sized : ?Sized //~ ERROR expected `where`, or `{` after struct name, found `:`
+...  |
+84 | | }
+   | | ^
+   | | |
+   | |_expected `{` after struct name
+   |   in this macro invocation
+   |
+   = note: this error originates in the macro `$crate::__pin_project_parse_generics` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: no rules expected `Sized`
+  --> tests/ui/pin_project/invalid-bounds.rs:89:21
+   |
+89 |         T: ?Sized : Sized //~ ERROR no rules expected the token `Sized`
+   |                     ^^^^^ no rules expected this token in macro call
+   |
+note: while trying to match meta-variable `$where_clause_lifetime_bound:lifetime`
+  --> src/lib.rs
+   |
+   |                 $(: $where_clause_lifetime_bound:lifetime)?
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

vendor/pin-project-lite/tests/ui/pin_project/invalid.rs

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+use pin_project_lite::pin_project;
+
+pin_project! {
+    struct A<T> {
+        #[pin()] //~ ERROR no rules expected the token `(`
+        pinned: T,
+    }
+}
+
+pin_project! {
+    #[pin] //~ ERROR cannot find attribute `pin` in this scope
+    struct B<T> {
+        pinned: T,
+    }
+}
+
+pin_project! {
+    struct C<T> {
+        #[pin]
+        #[pin] //~ ERROR no rules expected the token `#`
+        pinned: T,
+    }
+}
+
+fn main() {}

vendor/pin-project-lite/tests/ui/pin_project/invalid.stderr

@@ -0,0 +1,53 @@
+error: no rules expected `(`
+ --> tests/ui/pin_project/invalid.rs:7:14
+  |
+7 |         #[pin()] //~ ERROR no rules expected the token `(`
+  |              ^ no rules expected this token in macro call
+  |
+note: while trying to match `]`
+ --> src/lib.rs
+  |
+  |                 $(#[$pin:ident])?
+  |                               ^
+
+error: no rules expected `(`
+ --> tests/ui/pin_project/invalid.rs:7:14
+  |
+7 |         #[pin()] //~ ERROR no rules expected the token `(`
+  |              ^ no rules expected this token in macro call
+  |
+note: while trying to match `]`
+ --> src/lib.rs
+  |
+  |                 $(#[$pin:ident])?
+  |                               ^
+
+error: no rules expected `#`
+  --> tests/ui/pin_project/invalid.rs:22:9
+   |
+22 |         #[pin] //~ ERROR no rules expected the token `#`
+   |         ^ no rules expected this token in macro call
+   |
+note: while trying to match meta-variable `$field_vis:vis`
+  --> src/lib.rs
+   |
+   |                 $field_vis:vis $field:ident: $field_ty:ty
+   |                 ^^^^^^^^^^^^^^
+
+error: no rules expected `#`
+  --> tests/ui/pin_project/invalid.rs:22:9
+   |
+22 |         #[pin] //~ ERROR no rules expected the token `#`
+   |         ^ no rules expected this token in macro call
+   |
+note: while trying to match meta-variable `$field_vis:vis`
+  --> src/lib.rs
+   |
+   |                 $field_vis:vis $field:ident: $field_ty:ty
+   |                 ^^^^^^^^^^^^^^
+
+error: cannot find attribute `pin` in this scope
+  --> tests/ui/pin_project/invalid.rs:13:7
+   |
+13 |     #[pin] //~ ERROR cannot find attribute `pin` in this scope
+   |       ^^^

vendor/pin-project-lite/tests/ui/pin_project/negative_impls_stable.rs

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+// https://github.com/taiki-e/pin-project/issues/340#issuecomment-2428002670
+
+pin_project_lite::pin_project! {
+    struct Foo<Pinned, Unpinned> {
+        #[pin]
+        pinned: Pinned,
+        unpinned: Unpinned,
+    }
+}
+
+struct MyPhantomPinned(::core::marker::PhantomPinned);
+impl Unpin for MyPhantomPinned where for<'cursed> str: Sized {}
+impl Unpin for Foo<MyPhantomPinned, ()> {}
+
+fn is_unpin<T: Unpin>() {}
+
+fn main() {
+    is_unpin::<Foo<MyPhantomPinned, ()>>()
+}

vendor/pin-project-lite/tests/ui/pin_project/negative_impls_stable.stderr

@@ -0,0 +1,15 @@
+error[E0119]: conflicting implementations of trait `Unpin` for type `Foo<MyPhantomPinned, ()>`
+  --> tests/ui/pin_project/negative_impls_stable.rs:5:1
+   |
+5  | / pin_project_lite::pin_project! {
+6  | |     struct Foo<Pinned, Unpinned> {
+7  | |         #[pin]
+8  | |         pinned: Pinned,
+...  |
+11 | | }
+   | |_^ conflicting implementation for `Foo<MyPhantomPinned, ()>`
+...
+15 |   impl Unpin for Foo<MyPhantomPinned, ()> {}
+   |   --------------------------------------- first implementation here
+   |
+   = note: this error originates in the macro `$crate::__pin_project_make_unpin_impl` which comes from the expansion of the macro `pin_project_lite::pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)

vendor/pin-project-lite/tests/ui/pin_project/overlapping_lifetime_names.rs

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+use pin_project_lite::pin_project;
+
+pin_project! { //~ ERROR E0263,E0496
+    pub struct Foo<'__pin, T> {
+        #[pin]
+        field: &'__pin mut T,
+    }
+}
+
+fn main() {}

vendor/pin-project-lite/tests/ui/pin_project/overlapping_lifetime_names.stderr

@@ -0,0 +1,75 @@
+error[E0403]: the name `'__pin` is already used for a generic parameter in this item's generic parameters
+  --> tests/ui/pin_project/overlapping_lifetime_names.rs:6:20
+   |
+5  | / pin_project! { //~ ERROR E0263,E0496
+6  | |     pub struct Foo<'__pin, T> {
+   | |                    ^^^^^^ already used
+7  | |         #[pin]
+8  | |         field: &'__pin mut T,
+9  | |     }
+10 | | }
+   | |_- first use of `'__pin`
+
+error[E0403]: the name `'__pin` is already used for a generic parameter in this item's generic parameters
+  --> tests/ui/pin_project/overlapping_lifetime_names.rs:6:20
+   |
+5  | / pin_project! { //~ ERROR E0263,E0496
+6  | |     pub struct Foo<'__pin, T> {
+   | |                    ^^^^^^ already used
+7  | |         #[pin]
+8  | |         field: &'__pin mut T,
+9  | |     }
+10 | | }
+   | |_- first use of `'__pin`
+
+error[E0496]: lifetime name `'__pin` shadows a lifetime name that is already in scope
+  --> tests/ui/pin_project/overlapping_lifetime_names.rs:5:1
+   |
+5  | / pin_project! { //~ ERROR E0263,E0496
+6  | |     pub struct Foo<'__pin, T> {
+   | |                    ------ first declared here
+7  | |         #[pin]
+8  | |         field: &'__pin mut T,
+9  | |     }
+10 | | }
+   | |_^ lifetime `'__pin` already in scope
+   |
+   = note: this error originates in the macro `$crate::__pin_project_struct_make_proj_method` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0496]: lifetime name `'__pin` shadows a lifetime name that is already in scope
+  --> tests/ui/pin_project/overlapping_lifetime_names.rs:5:1
+   |
+5  | / pin_project! { //~ ERROR E0263,E0496
+6  | |     pub struct Foo<'__pin, T> {
+   | |                    ------ first declared here
+7  | |         #[pin]
+8  | |         field: &'__pin mut T,
+9  | |     }
+10 | | }
+   | |_^ lifetime `'__pin` already in scope
+   |
+   = note: this error originates in the macro `$crate::__pin_project_struct_make_proj_method` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0403]: the name `'__pin` is already used for a generic parameter in this item's generic parameters
+  --> tests/ui/pin_project/overlapping_lifetime_names.rs:6:20
+   |
+5  | / pin_project! { //~ ERROR E0263,E0496
+6  | |     pub struct Foo<'__pin, T> {
+   | |                    ^^^^^^ already used
+7  | |         #[pin]
+8  | |         field: &'__pin mut T,
+9  | |     }
+10 | | }
+   | |_- first use of `'__pin`
+
+error[E0403]: the name `'__pin` is already used for a generic parameter in this item's generic parameters
+  --> tests/ui/pin_project/overlapping_lifetime_names.rs:6:20
+   |
+5  | / pin_project! { //~ ERROR E0263,E0496
+6  | |     pub struct Foo<'__pin, T> {
+   | |                    ^^^^^^ already used
+7  | |         #[pin]
+8  | |         field: &'__pin mut T,
+9  | |     }
+10 | | }
+   | |_- first use of `'__pin`

vendor/pin-project-lite/tests/ui/pin_project/overlapping_unpin_struct.rs

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+use std::marker::PhantomPinned;
+
+use pin_project_lite::pin_project;
+
+pin_project! {
+    struct Foo<T> {
+        #[pin]
+        inner: T,
+    }
+}
+
+struct __Origin {}
+
+impl Unpin for __Origin {}
+
+fn is_unpin<T: Unpin>() {}
+
+fn main() {
+    is_unpin::<Foo<PhantomPinned>>(); //~ ERROR E0277
+}

vendor/pin-project-lite/tests/ui/pin_project/overlapping_unpin_struct.stderr

@@ -0,0 +1,34 @@
+error[E0277]: `PhantomPinned` cannot be unpinned
+  --> tests/ui/pin_project/overlapping_unpin_struct.rs:21:16
+   |
+21 |     is_unpin::<Foo<PhantomPinned>>(); //~ ERROR E0277
+   |                ^^^^^^^^^^^^^^^^^^ within `_::__Origin<'_, PhantomPinned>`, the trait `Unpin` is not implemented for `PhantomPinned`
+   |
+   = note: consider using the `pin!` macro
+           consider using `Box::pin` if you need to access the pinned value outside of the current scope
+note: required because it appears within the type `_::__Origin<'_, PhantomPinned>`
+  --> tests/ui/pin_project/overlapping_unpin_struct.rs:7:1
+   |
+7  | / pin_project! {
+8  | |     struct Foo<T> {
+9  | |         #[pin]
+10 | |         inner: T,
+11 | |     }
+12 | | }
+   | |_^
+note: required for `Foo<PhantomPinned>` to implement `Unpin`
+  --> tests/ui/pin_project/overlapping_unpin_struct.rs:7:1
+   |
+7  | / pin_project! {
+8  | |     struct Foo<T> {
+9  | |         #[pin]
+10 | |         inner: T,
+11 | |     }
+12 | | }
+   | |_^ unsatisfied trait bound introduced here
+note: required by a bound in `is_unpin`
+  --> tests/ui/pin_project/overlapping_unpin_struct.rs:18:16
+   |
+18 | fn is_unpin<T: Unpin>() {}
+   |                ^^^^^ required by this bound in `is_unpin`
+   = note: this error originates in the macro `$crate::__pin_project_make_unpin_impl` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)

vendor/pin-project-lite/tests/ui/pin_project/packed.rs

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+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() {}

vendor/pin-project-lite/tests/ui/pin_project/packed.stderr

@@ -0,0 +1,95 @@
+error[E0793]: reference to packed field is unaligned
+  --> tests/ui/pin_project/packed.rs:5:1
+   |
+5  | / pin_project! { //~ ERROR reference to packed field is unaligned
+6  | |     #[repr(packed, C)]
+7  | |     struct Packed {
+8  | |         #[pin]
+...  |
+11 | | }
+   | |_^
+   |
+   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
+   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
+   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
+   = note: this error originates in the macro `$crate::__pin_project_struct_make_proj_method` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0793]: reference to packed field is unaligned
+  --> tests/ui/pin_project/packed.rs:5:1
+   |
+5  | / pin_project! { //~ ERROR reference to packed field is unaligned
+6  | |     #[repr(packed, C)]
+7  | |     struct Packed {
+8  | |         #[pin]
+...  |
+11 | | }
+   | |_^
+   |
+   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
+   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
+   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
+   = note: this error originates in the macro `$crate::__pin_project_struct_make_proj_method` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0793]: reference to packed field is unaligned
+  --> tests/ui/pin_project/packed.rs:5:1
+   |
+5  | / pin_project! { //~ ERROR reference to packed field is unaligned
+6  | |     #[repr(packed, C)]
+7  | |     struct Packed {
+8  | |         #[pin]
+...  |
+11 | | }
+   | |_^
+   |
+   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
+   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
+   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
+   = note: this error originates in the macro `$crate::__pin_project_constant` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0793]: reference to packed field is unaligned
+  --> tests/ui/pin_project/packed.rs:13:1
+   |
+13 | / pin_project! { //~ ERROR reference to packed field is unaligned
+14 | |     #[repr(packed(2))]
+15 | |     struct PackedN {
+16 | |         #[pin]
+...  |
+19 | | }
+   | |_^
+   |
+   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
+   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
+   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
+   = note: this error originates in the macro `$crate::__pin_project_struct_make_proj_method` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0793]: reference to packed field is unaligned
+  --> tests/ui/pin_project/packed.rs:13:1
+   |
+13 | / pin_project! { //~ ERROR reference to packed field is unaligned
+14 | |     #[repr(packed(2))]
+15 | |     struct PackedN {
+16 | |         #[pin]
+...  |
+19 | | }
+   | |_^
+   |
+   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
+   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
+   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
+   = note: this error originates in the macro `$crate::__pin_project_struct_make_proj_method` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0793]: reference to packed field is unaligned
+  --> tests/ui/pin_project/packed.rs:13:1
+   |
+13 | / pin_project! { //~ ERROR reference to packed field is unaligned
+14 | |     #[repr(packed(2))]
+15 | |     struct PackedN {
+16 | |         #[pin]
+...  |
+19 | | }
+   | |_^
+   |
+   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
+   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
+   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
+   = note: this error originates in the macro `$crate::__pin_project_constant` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)

vendor/pin-project-lite/tests/ui/pin_project/unpin_sneaky.rs

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+use pin_project_lite::pin_project;
+
+pin_project! {
+    struct Foo {
+        #[pin]
+        inner: u8,
+    }
+}
+
+impl Unpin for __Origin {} //~ ERROR E0412,E0321
+
+fn main() {}

vendor/pin-project-lite/tests/ui/pin_project/unpin_sneaky.stderr

@@ -0,0 +1,5 @@
+error[E0412]: cannot find type `__Origin` in this scope
+  --> tests/ui/pin_project/unpin_sneaky.rs:12:16
+   |
+12 | impl Unpin for __Origin {} //~ ERROR E0412,E0321
+   |                ^^^^^^^^ not found in this scope

vendor/pin-project-lite/tests/ui/pin_project/unsupported.rs

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+use pin_project_lite::pin_project;
+
+pin_project! {
+    struct Struct1 {} //~ ERROR no rules expected the token `}`
+}
+
+pin_project! {
+    struct Struct2(); //~ ERROR no rules expected the token `(`
+}
+
+pin_project! {
+    struct Struct3; //~ ERROR no rules expected the token `;`
+}
+
+pin_project! {
+    enum Enum { //~ ERROR no rules expected the token `enum`
+        A(u8)
+    }
+}
+
+pin_project! {
+    union Union { //~ ERROR no rules expected the token `union`
+        x: u8,
+    }
+}
+
+fn main() {}

vendor/pin-project-lite/tests/ui/pin_project/unsupported.stderr

@@ -0,0 +1,111 @@
+error: no rules expected `}`
+ --> tests/ui/pin_project/unsupported.rs:5:1
+  |
+5 | / pin_project! {
+6 | |     struct Struct1 {} //~ ERROR no rules expected the token `}`
+7 | | }
+  | |_^ no rules expected this token in macro call
+  |
+note: while trying to match meta-variable `$field_vis:vis`
+ --> src/lib.rs
+  |
+  |                 $field_vis:vis $field:ident: $field_ty:ty
+  |                 ^^^^^^^^^^^^^^
+  = note: this error originates in the macro `$crate::__pin_project_expand` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: no rules expected `}`
+ --> tests/ui/pin_project/unsupported.rs:5:1
+  |
+5 | / pin_project! {
+6 | |     struct Struct1 {} //~ ERROR no rules expected the token `}`
+7 | | }
+  | |_^ no rules expected this token in macro call
+  |
+note: while trying to match meta-variable `$field_vis:vis`
+ --> src/lib.rs
+  |
+  |                 $field_vis:vis $field:ident: $field_ty:ty
+  |                 ^^^^^^^^^^^^^^
+  = note: this error originates in the macro `$crate::__pin_project_expand` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: no rules expected `(`
+  --> tests/ui/pin_project/unsupported.rs:10:19
+   |
+10 |     struct Struct2(); //~ ERROR no rules expected the token `(`
+   |                   ^ no rules expected this token in macro call
+   |
+note: while trying to match `{`
+  --> src/lib.rs
+   |
+   |         {
+   |         ^
+
+error: no rules expected `;`
+  --> tests/ui/pin_project/unsupported.rs:14:19
+   |
+14 |     struct Struct3; //~ ERROR no rules expected the token `;`
+   |                   ^ no rules expected this token in macro call
+   |
+note: while trying to match `{`
+  --> src/lib.rs
+   |
+   |         {
+   |         ^
+
+error: no rules expected `(`
+  --> tests/ui/pin_project/unsupported.rs:19:10
+   |
+19 |         A(u8)
+   |          ^ no rules expected this token in macro call
+   |
+note: while trying to match `}`
+  --> src/lib.rs
+   |
+   |         }
+   |         ^
+
+error: no rules expected `(`
+  --> tests/ui/pin_project/unsupported.rs:19:10
+   |
+19 |         A(u8)
+   |          ^ no rules expected this token in macro call
+   |
+note: while trying to match `}`
+  --> src/lib.rs
+   |
+   |         }
+   |         ^
+
+error: no rules expected identifier `union`
+  --> tests/ui/pin_project/unsupported.rs:23:1
+   |
+23 | / pin_project! {
+24 | |     union Union { //~ ERROR no rules expected the token `union`
+25 | |         x: u8,
+26 | |     }
+27 | | }
+   | |_^ no rules expected this token in macro call
+   |
+note: while trying to match keyword `struct`
+  --> src/lib.rs
+   |
+   |         [$(#[$attrs:meta])* $vis:vis struct $ident:ident]
+   |                                      ^^^^^^
+   = note: this error originates in the macro `$crate::__pin_project_expand` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: no rules expected identifier `union`
+  --> tests/ui/pin_project/unsupported.rs:23:1
+   |
+23 | / pin_project! {
+24 | |     union Union { //~ ERROR no rules expected the token `union`
+25 | |         x: u8,
+26 | |     }
+27 | | }
+   | |_^ no rules expected this token in macro call
+   |
+note: while trying to match keyword `struct`
+  --> src/lib.rs
+   |
+   |         [$(#[$attrs:meta])* $vis:vis struct $ident:ident]
+   |                                      ^^^^^^
+   = note: this error originates in the macro `$crate::__pin_project_expand` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)

vendor/pin-project-lite/tests/ui/pinned_drop/call-drop-inner.rs

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+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 };
+}

vendor/pin-project-lite/tests/ui/pinned_drop/call-drop-inner.stderr

@@ -0,0 +1,22 @@
+error[E0061]: this function takes 0 arguments but 1 argument was supplied
+  --> tests/ui/pinned_drop/call-drop-inner.rs:12:13
+   |
+12 |             __drop_inner(this);
+   |             ^^^^^^^^^^^^ ---- unexpected argument of type `Pin<&mut S>`
+   |
+note: function defined here
+  --> tests/ui/pinned_drop/call-drop-inner.rs:5:1
+   |
+5  | / pin_project! {
+6  | |     pub struct S {
+7  | |         #[pin]
+8  | |         field: u8,
+...  |
+15 | | }
+   | |_^
+   = note: this error originates in the macro `$crate::__pin_project_make_drop_impl` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: remove the extra argument
+   |
+12 -             __drop_inner(this);
+12 +             __drop_inner();
+   |

vendor/pin-project-lite/tests/ui/pinned_drop/conditional-drop-impl.rs

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+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() {}

vendor/pin-project-lite/tests/ui/pinned_drop/conditional-drop-impl.stderr

@@ -0,0 +1,34 @@
+error[E0367]: `Drop` impl requires `T: Unpin` but the struct it is implemented for does not
+  --> tests/ui/pinned_drop/conditional-drop-impl.rs:11:9
+   |
+11 | impl<T: Unpin> Drop for DropImpl<T> {
+   |         ^^^^^
+   |
+note: the implementor must specify the same requirement
+  --> tests/ui/pinned_drop/conditional-drop-impl.rs:7:1
+   |
+7  | struct DropImpl<T> {
+   | ^^^^^^^^^^^^^^^^^^
+
+error[E0367]: `Drop` impl requires `T: Unpin` but the struct it is implemented for does not
+  --> tests/ui/pinned_drop/conditional-drop-impl.rs:16:1
+   |
+16 | / pin_project! {
+17 | |     //~^ ERROR E0367
+18 | |     struct PinnedDropImpl<T> {
+19 | |         #[pin]
+...  |
+26 | | }
+   | |_^
+   |
+note: the implementor must specify the same requirement
+  --> tests/ui/pinned_drop/conditional-drop-impl.rs:16:1
+   |
+16 | / pin_project! {
+17 | |     //~^ ERROR E0367
+18 | |     struct PinnedDropImpl<T> {
+19 | |         #[pin]
+...  |
+26 | | }
+   | |_^
+   = note: this error originates in the macro `$crate::__pin_project_make_drop_impl` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)