pin-project-lite-0.2.16/.cargo_vcs_info.json0000644000000001360000000000100143070ustar { "git": { "sha1": "cca1e8ae094ceff53e74abbfec8c9f2221ebd202" }, "path_in_vcs": "" }pin-project-lite-0.2.16/CHANGELOG.md000064400000000000000000000253361046102023000147210ustar 00000000000000# 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. ## [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 { Variant { #[pin] pinned: T, unpinned: U }, } } impl Enum { 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 { #[pin] field: T, } } fn func(x: Pin<&mut Struct>) { 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 pin-project-lite-0.2.16/Cargo.toml0000644000000072000000000000100123040ustar # 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 = [] pin-project-lite-0.2.16/Cargo.toml.orig000064400000000000000000000077731046102023000160040ustar 00000000000000[package] name = "pin-project-lite" version = "0.2.16" #publish:version edition = "2018" rust-version = "1.37" license = "Apache-2.0 OR MIT" repository = "https://github.com/taiki-e/pin-project-lite" keywords = ["pin", "macros"] categories = ["no-std", "no-std::no-alloc", "rust-patterns"] exclude = ["/.*", "/tools", "/DEVELOPMENT.md"] description = """ A lightweight version of pin-project written with declarative macros. """ [package.metadata.docs.rs] targets = ["x86_64-unknown-linux-gnu"] [package.metadata.cargo_check_external_types] # The following are external types that are allowed to be exposed in our public API. allowed_external_types = [ ] [lib] doc-scrape-examples = false [dev-dependencies] macrotest = { git = "https://github.com/taiki-e/macrotest.git", branch = "dev-old-msrv" } # adjust overwrite behavior + no cargo-expand + lower MSRV rustversion = "1" static_assertions = "1" trybuild = { git = "https://github.com/taiki-e/trybuild.git", branch = "dev-old-msrv" } # adjust overwrite behavior + lower MSRV [lints] workspace = true [workspace] members = [ "tests/no-core", "tests/no-std", "tests/lint", ] # This table is shared by projects under github.com/taiki-e. # It is not intended for manual editing. [workspace.lints.rust] deprecated_safe = "warn" improper_ctypes = "warn" improper_ctypes_definitions = "warn" non_ascii_idents = "warn" rust_2018_idioms = "warn" single_use_lifetimes = "warn" unexpected_cfgs = { level = "warn", check-cfg = [ ] } unreachable_pub = "warn" # unsafe_op_in_unsafe_fn = "warn" # Set at crate-level instead since https://github.com/rust-lang/rust/pull/100081 is not available on MSRV [workspace.lints.clippy] all = "warn" # Downgrade deny-by-default lints pedantic = "warn" as_ptr_cast_mut = "warn" as_underscore = "warn" default_union_representation = "warn" inline_asm_x86_att_syntax = "warn" trailing_empty_array = "warn" transmute_undefined_repr = "warn" undocumented_unsafe_blocks = "warn" # Suppress buggy or noisy clippy lints bool_assert_comparison = { level = "allow", priority = 1 } borrow_as_ptr = { level = "allow", priority = 1 } # https://github.com/rust-lang/rust-clippy/issues/8286 cast_lossless = { level = "allow", priority = 1 } # https://godbolt.org/z/Pv6vbGG6E declare_interior_mutable_const = { level = "allow", priority = 1 } # https://github.com/rust-lang/rust-clippy/issues/7665 doc_markdown = { level = "allow", priority = 1 } float_cmp = { level = "allow", priority = 1 } # https://github.com/rust-lang/rust-clippy/issues/7725 incompatible_msrv = { level = "allow", priority = 1 } # buggy: doesn't consider cfg, https://github.com/rust-lang/rust-clippy/issues/12280, https://github.com/rust-lang/rust-clippy/issues/12257#issuecomment-2093667187 lint_groups_priority = { level = "allow", priority = 1 } # https://github.com/rust-lang/rust-clippy/issues/12920 manual_assert = { level = "allow", priority = 1 } manual_range_contains = { level = "allow", priority = 1 } # https://github.com/rust-lang/rust-clippy/issues/6455#issuecomment-1225966395 missing_errors_doc = { level = "allow", priority = 1 } module_name_repetitions = { level = "allow", priority = 1 } # buggy: https://github.com/rust-lang/rust-clippy/issues?q=is%3Aissue+is%3Aopen+module_name_repetitions naive_bytecount = { level = "allow", priority = 1 } nonminimal_bool = { level = "allow", priority = 1 } # buggy: https://github.com/rust-lang/rust-clippy/issues?q=is%3Aissue+is%3Aopen+nonminimal_bool range_plus_one = { level = "allow", priority = 1 } # buggy: https://github.com/rust-lang/rust-clippy/issues?q=is%3Aissue+is%3Aopen+range_plus_one similar_names = { level = "allow", priority = 1 } single_match = { level = "allow", priority = 1 } single_match_else = { level = "allow", priority = 1 } struct_excessive_bools = { level = "allow", priority = 1 } struct_field_names = { level = "allow", priority = 1 } too_many_arguments = { level = "allow", priority = 1 } too_many_lines = { level = "allow", priority = 1 } type_complexity = { level = "allow", priority = 1 } unreadable_literal = { level = "allow", priority = 1 } pin-project-lite-0.2.16/LICENSE-APACHE000064400000000000000000000236761046102023000150410ustar 00000000000000 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 pin-project-lite-0.2.16/LICENSE-MIT000064400000000000000000000017771046102023000145470ustar 00000000000000Permission 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. pin-project-lite-0.2.16/README.md000064400000000000000000000102171046102023000143570ustar 00000000000000# 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) 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 { #[pin] pinned: T, unpinned: U, } } impl Struct { 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 { Variant { #[pin] pinned: T, unpinned: U }, } } impl Enum { 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 [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. pin-project-lite-0.2.16/src/lib.rs000064400000000000000000001573111046102023000150120ustar 00000000000000// SPDX-License-Identifier: Apache-2.0 OR MIT /*! 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 { #[pin] pinned: T, unpinned: U, } } impl Struct { 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 { Variant { #[pin] pinned: T, unpinned: U }, } } impl Enum { 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 [not-unpin-lite]: pin_project#unpin */ #![no_std] #![doc(test( no_crate_inject, attr( deny(warnings, rust_2018_idioms, single_use_lifetimes), allow(dead_code, unused_variables) ) ))] // #![warn(unsafe_op_in_unsafe_fn)] // requires Rust 1.52 #![warn( // Lints that may help when writing public library. missing_debug_implementations, missing_docs, clippy::alloc_instead_of_core, clippy::exhaustive_enums, clippy::exhaustive_structs, clippy::impl_trait_in_params, // clippy::missing_inline_in_public_items, clippy::std_instead_of_alloc, clippy::std_instead_of_core, )] /// A macro that creates a projection type covering all the fields of struct. /// /// This macro creates a projection type according to the following rules: /// /// - For the field that uses `#[pin]` attribute, makes the pinned reference to the field. /// - For the other fields, makes the unpinned reference to the field. /// /// And the following methods are implemented on the original type: /// /// ``` /// # use std::pin::Pin; /// # type Projection<'a> = &'a (); /// # type ProjectionRef<'a> = &'a (); /// # trait Dox { /// fn project(self: Pin<&mut Self>) -> Projection<'_>; /// fn project_ref(self: Pin<&Self>) -> ProjectionRef<'_>; /// # } /// ``` /// /// By passing an attribute with the same name as the method to the macro, /// you can name the projection type returned from the method. This allows you /// to use pattern matching on the projected types. /// /// ``` /// # use pin_project_lite::pin_project; /// # use std::pin::Pin; /// pin_project! { /// #[project = EnumProj] /// enum Enum { /// Variant { #[pin] field: T }, /// } /// } /// /// impl Enum { /// fn method(self: Pin<&mut Self>) { /// let this: EnumProj<'_, T> = self.project(); /// match this { /// EnumProj::Variant { field } => { /// let _: Pin<&mut T> = field; /// } /// } /// } /// } /// ``` /// /// By passing the `#[project_replace = MyProjReplace]` attribute you may create an additional /// method which allows the contents of `Pin<&mut Self>` to be replaced while simultaneously moving /// out all unpinned fields in `Self`. /// /// ``` /// # use std::pin::Pin; /// # type MyProjReplace = (); /// # trait Dox { /// fn project_replace(self: Pin<&mut Self>, replacement: Self) -> MyProjReplace; /// # } /// ``` /// /// Also, note that the projection types returned by `project` and `project_ref` have /// an additional lifetime at the beginning of generics. /// /// ```text /// let this: EnumProj<'_, T> = self.project(); /// ^^ /// ``` /// /// The visibility of the projected types and projection methods is based on the /// original type. However, if the visibility of the original type is `pub`, the /// visibility of the projected types and the projection methods is downgraded /// to `pub(crate)`. /// /// # Safety /// /// `pin_project!` macro guarantees safety in much the same way as [pin-project] crate. /// Both are completely safe unless you write other unsafe code. /// /// See [pin-project] crate for more details. /// /// # Examples /// /// ``` /// use std::pin::Pin; /// /// use pin_project_lite::pin_project; /// /// pin_project! { /// struct Struct { /// #[pin] /// pinned: T, /// unpinned: U, /// } /// } /// /// impl Struct { /// 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. /// /// ``` /// use std::pin::Pin; /// /// use pin_project_lite::pin_project; /// /// pin_project! { /// #[project = EnumProj] /// enum Enum { /// Struct { /// #[pin] /// field: T, /// }, /// Unit, /// } /// } /// /// impl Enum { /// fn method(self: Pin<&mut Self>) { /// match self.project() { /// EnumProj::Struct { field } => { /// let _: Pin<&mut T> = field; /// } /// EnumProj::Unit => {} /// } /// } /// } /// ``` /// /// If you want to call the `project()` method multiple times or later use the /// original [`Pin`] type, it needs to use [`.as_mut()`][`Pin::as_mut`] to avoid /// consuming the [`Pin`]. /// /// ``` /// use std::pin::Pin; /// /// use pin_project_lite::pin_project; /// /// pin_project! { /// struct Struct { /// #[pin] /// field: T, /// } /// } /// /// impl Struct { /// fn call_project_twice(mut self: Pin<&mut Self>) { /// // `project` consumes `self`, so reborrow the `Pin<&mut Self>` via `as_mut`. /// self.as_mut().project(); /// self.as_mut().project(); /// } /// } /// ``` /// /// # `!Unpin` /// /// If you want to make sure `Unpin` is not implemented, use the `#[project(!Unpin)]` /// attribute. /// /// ``` /// use pin_project_lite::pin_project; /// /// pin_project! { /// #[project(!Unpin)] /// struct Struct { /// #[pin] /// field: T, /// } /// } /// ``` /// /// This is equivalent to using `#[pin]` attribute for a [`PhantomPinned`] field. /// /// ``` /// use std::marker::PhantomPinned; /// /// use pin_project_lite::pin_project; /// /// pin_project! { /// struct Struct { /// field: T, /// #[pin] /// _pin: PhantomPinned, /// } /// } /// ``` /// /// Note that using [`PhantomPinned`] without `#[pin]` or `#[project(!Unpin)]` /// attribute has no effect. /// /// # Pinned Drop /// /// In order to correctly implement pin projections, a type’s [`Drop`] impl must not move out of any /// structurally pinned fields. Unfortunately, [`Drop::drop`] takes `&mut Self`, not `Pin<&mut /// Self>`. /// /// To implement [`Drop`] for type that has pin, add an `impl PinnedDrop` block at the end of the /// [`pin_project`] macro block. PinnedDrop has the following interface: /// /// ```rust /// # use std::pin::Pin; /// trait PinnedDrop { /// fn drop(this: Pin<&mut Self>); /// } /// ``` /// /// Note that the argument to `PinnedDrop::drop` cannot be named `self`. /// /// `pin_project!` implements the actual [`Drop`] trait via PinnedDrop you implemented. To /// explicitly drop a type that implements PinnedDrop, use the [drop] function just like dropping a /// type that directly implements [`Drop`]. /// /// `PinnedDrop::drop` will never be called more than once, just like [`Drop::drop`]. /// /// ```rust /// use pin_project_lite::pin_project; /// /// pin_project! { /// pub struct Struct<'a> { /// was_dropped: &'a mut bool, /// #[pin] /// field: u8, /// } /// /// impl PinnedDrop for Struct<'_> { /// fn drop(this: Pin<&mut Self>) { // <----- NOTE: this is not `self` /// **this.project().was_dropped = true; /// } /// } /// } /// /// let mut was_dropped = false; /// drop(Struct { was_dropped: &mut was_dropped, field: 42 }); /// assert!(was_dropped); /// ``` /// /// [`PhantomPinned`]: core::marker::PhantomPinned /// [`Pin::as_mut`]: core::pin::Pin::as_mut /// [`Pin`]: core::pin::Pin /// [pin-project]: https://github.com/taiki-e/pin-project #[macro_export] macro_rules! pin_project { ($($tt:tt)*) => { $crate::__pin_project_internal! { [][][][][] $($tt)* } }; } // limitations: // - no support for tuple structs and tuple variant (wontfix). // - no support for multiple trait/lifetime bounds. // - no support for `Self` in where clauses. (wontfix) // - no support for overlapping lifetime names. (wontfix) // - no interoperability with other field attributes. // - no useful error messages. (wontfix) // etc... #[doc(hidden)] #[macro_export] macro_rules! __pin_project_expand { ( [$($proj_mut_ident:ident)?] [$($proj_ref_ident:ident)?] [$($proj_replace_ident:ident)?] [$($proj_not_unpin_mark:ident)?] [$proj_vis:vis] [$(#[$attrs:meta])* $vis:vis $struct_ty_ident:ident $ident:ident] [$($def_generics:tt)*] [$($impl_generics:tt)*] [$($ty_generics:tt)*] [$(where $($where_clause:tt)*)?] { $($body_data:tt)* } $($(#[$drop_impl_attrs:meta])* impl $($pinned_drop:tt)*)? ) => { $crate::__pin_project_reconstruct! { [$(#[$attrs])* $vis $struct_ty_ident $ident] [$($def_generics)*] [$($impl_generics)*] [$($ty_generics)*] [$(where $($where_clause)*)?] { $($body_data)* } } $crate::__pin_project_make_proj_ty! { [$($proj_mut_ident)?] [$proj_vis $struct_ty_ident $ident] [__pin_project_make_proj_field_mut] [$($impl_generics)*] [$($ty_generics)*] [$(where $($where_clause)*)?] { $($body_data)* } } $crate::__pin_project_make_proj_ty! { [$($proj_ref_ident)?] [$proj_vis $struct_ty_ident $ident] [__pin_project_make_proj_field_ref] [$($impl_generics)*] [$($ty_generics)*] [$(where $($where_clause)*)?] { $($body_data)* } } $crate::__pin_project_make_proj_replace_ty! { [$($proj_replace_ident)?] [$proj_vis $struct_ty_ident] [__pin_project_make_proj_field_replace] [$($impl_generics)*] [$($ty_generics)*] [$(where $($where_clause)*)?] { $($body_data)* } } $crate::__pin_project_constant! { [$(#[$attrs])* $vis $struct_ty_ident $ident] [$($proj_mut_ident)?] [$($proj_ref_ident)?] [$($proj_replace_ident)?] [$($proj_not_unpin_mark)?] [$proj_vis] [$($def_generics)*] [$($impl_generics)*] [$($ty_generics)*] [$(where $($where_clause)*)?] { $($body_data)* } $($(#[$drop_impl_attrs])* impl $($pinned_drop)*)? } }; } #[doc(hidden)] #[macro_export] macro_rules! __pin_project_constant { ( [$(#[$attrs:meta])* $vis:vis struct $ident:ident] [$($proj_mut_ident:ident)?] [$($proj_ref_ident:ident)?] [$($proj_replace_ident:ident)?] [$($proj_not_unpin_mark:ident)?] [$proj_vis:vis] [$($def_generics:tt)*] [$($impl_generics:tt)*] [$($ty_generics:tt)*] [$(where $($where_clause:tt)*)?] { $( $(#[$pin:ident])? $field_vis:vis $field:ident: $field_ty:ty ),+ $(,)? } $($(#[$drop_impl_attrs:meta])* impl $($pinned_drop:tt)*)? ) => { #[allow( explicit_outlives_requirements, // https://github.com/rust-lang/rust/issues/60993 single_use_lifetimes, // https://github.com/rust-lang/rust/issues/55058 // This lint warns of `clippy::*` generated by external macros. // We allow this lint for compatibility with older compilers. clippy::unknown_clippy_lints, clippy::absolute_paths, clippy::min_ident_chars, clippy::redundant_pub_crate, // This lint warns `pub(crate)` field in private struct. clippy::single_char_lifetime_names, clippy::used_underscore_binding )] const _: () = { $crate::__pin_project_make_proj_ty! { [$($proj_mut_ident)? Projection] [$proj_vis struct $ident] [__pin_project_make_proj_field_mut] [$($impl_generics)*] [$($ty_generics)*] [$(where $($where_clause)*)?] { $( $(#[$pin])? $field_vis $field: $field_ty ),+ } } $crate::__pin_project_make_proj_ty! { [$($proj_ref_ident)? ProjectionRef] [$proj_vis struct $ident] [__pin_project_make_proj_field_ref] [$($impl_generics)*] [$($ty_generics)*] [$(where $($where_clause)*)?] { $( $(#[$pin])? $field_vis $field: $field_ty ),+ } } impl<$($impl_generics)*> $ident <$($ty_generics)*> $(where $($where_clause)*)? { $crate::__pin_project_struct_make_proj_method! { [$($proj_mut_ident)? Projection] [$proj_vis] [project get_unchecked_mut mut] [$($ty_generics)*] { $( $(#[$pin])? $field_vis $field ),+ } } $crate::__pin_project_struct_make_proj_method! { [$($proj_ref_ident)? ProjectionRef] [$proj_vis] [project_ref get_ref] [$($ty_generics)*] { $( $(#[$pin])? $field_vis $field ),+ } } $crate::__pin_project_struct_make_proj_replace_method! { [$($proj_replace_ident)?] [$proj_vis] [ProjectionReplace] [$($ty_generics)*] { $( $(#[$pin])? $field_vis $field ),+ } } } $crate::__pin_project_make_unpin_impl! { [$($proj_not_unpin_mark)?] [$vis $ident] [$($impl_generics)*] [$($ty_generics)*] [$(where $($where_clause)*)?] $( $field: $crate::__pin_project_make_unpin_bound!( $(#[$pin])? $field_ty ) ),+ } $crate::__pin_project_make_drop_impl! { [$ident] [$($impl_generics)*] [$($ty_generics)*] [$(where $($where_clause)*)?] $($(#[$drop_impl_attrs])* impl $($pinned_drop)*)? } // Ensure that it's impossible to use pin projections on a #[repr(packed)] struct. // // Taking a reference to a packed field is UB, and applying // `#[forbid(unaligned_references)]` makes sure that doing this is a hard error. // // If the struct ends up having #[repr(packed)] applied somehow, // this will generate an (unfriendly) error message. Under all reasonable // circumstances, we'll detect the #[repr(packed)] attribute, and generate // a much nicer error above. // // See https://github.com/taiki-e/pin-project/pull/34 for more details. // // Note: // - Lint-based tricks aren't perfect, but they're much better than nothing: // https://github.com/taiki-e/pin-project-lite/issues/26 // // - Enable both unaligned_references and safe_packed_borrows lints // because unaligned_references lint does not exist in older compilers: // https://github.com/taiki-e/pin-project-lite/pull/55 // https://github.com/rust-lang/rust/pull/82525 #[forbid(unaligned_references, safe_packed_borrows)] fn __assert_not_repr_packed <$($impl_generics)*> (this: &$ident <$($ty_generics)*>) $(where $($where_clause)*)? { $( let _ = &this.$field; )+ } }; }; ( [$(#[$attrs:meta])* $vis:vis enum $ident:ident] [$($proj_mut_ident:ident)?] [$($proj_ref_ident:ident)?] [$($proj_replace_ident:ident)?] [$($proj_not_unpin_mark:ident)?] [$proj_vis:vis] [$($def_generics:tt)*] [$($impl_generics:tt)*] [$($ty_generics:tt)*] [$(where $($where_clause:tt)*)?] { $( $(#[$variant_attrs:meta])* $variant:ident $({ $( $(#[$pin:ident])? $field:ident: $field_ty:ty ),+ $(,)? })? ),+ $(,)? } $($(#[$drop_impl_attrs:meta])* impl $($pinned_drop:tt)*)? ) => { #[allow( single_use_lifetimes, // https://github.com/rust-lang/rust/issues/55058 // This lint warns of `clippy::*` generated by external macros. // We allow this lint for compatibility with older compilers. clippy::unknown_clippy_lints, clippy::absolute_paths, clippy::min_ident_chars, clippy::single_char_lifetime_names, clippy::used_underscore_binding )] const _: () = { impl<$($impl_generics)*> $ident <$($ty_generics)*> $(where $($where_clause)*)? { $crate::__pin_project_enum_make_proj_method! { [$($proj_mut_ident)?] [$proj_vis] [project get_unchecked_mut mut] [$($ty_generics)*] { $( $variant $({ $( $(#[$pin])? $field ),+ })? ),+ } } $crate::__pin_project_enum_make_proj_method! { [$($proj_ref_ident)?] [$proj_vis] [project_ref get_ref] [$($ty_generics)*] { $( $variant $({ $( $(#[$pin])? $field ),+ })? ),+ } } $crate::__pin_project_enum_make_proj_replace_method! { [$($proj_replace_ident)?] [$proj_vis] [$($ty_generics)*] { $( $variant $({ $( $(#[$pin])? $field ),+ })? ),+ } } } $crate::__pin_project_make_unpin_impl! { [$($proj_not_unpin_mark)?] [$vis $ident] [$($impl_generics)*] [$($ty_generics)*] [$(where $($where_clause)*)?] $( $variant: ($( $( $crate::__pin_project_make_unpin_bound!( $(#[$pin])? $field_ty ) ),+ )?) ),+ } $crate::__pin_project_make_drop_impl! { [$ident] [$($impl_generics)*] [$($ty_generics)*] [$(where $($where_clause)*)?] $($(#[$drop_impl_attrs])* impl $($pinned_drop)*)? } // We don't need to check for '#[repr(packed)]', // since it does not apply to enums. }; }; } #[doc(hidden)] #[macro_export] macro_rules! __pin_project_reconstruct { ( [$(#[$attrs:meta])* $vis:vis struct $ident:ident] [$($def_generics:tt)*] [$($impl_generics:tt)*] [$($ty_generics:tt)*] [$(where $($where_clause:tt)*)?] { $( $(#[$pin:ident])? $field_vis:vis $field:ident: $field_ty:ty ),+ $(,)? } ) => { $(#[$attrs])* $vis struct $ident $($def_generics)* $(where $($where_clause)*)? { $( $field_vis $field: $field_ty ),+ } }; ( [$(#[$attrs:meta])* $vis:vis enum $ident:ident] [$($def_generics:tt)*] [$($impl_generics:tt)*] [$($ty_generics:tt)*] [$(where $($where_clause:tt)*)?] { $( $(#[$variant_attrs:meta])* $variant:ident $({ $( $(#[$pin:ident])? $field:ident: $field_ty:ty ),+ $(,)? })? ),+ $(,)? } ) => { $(#[$attrs])* $vis enum $ident $($def_generics)* $(where $($where_clause)*)? { $( $(#[$variant_attrs])* $variant $({ $( $field: $field_ty ),+ })? ),+ } }; } #[doc(hidden)] #[macro_export] macro_rules! __pin_project_make_proj_ty { ([] $($field:tt)*) => {}; ( [$proj_ty_ident:ident $default_ident:ident] [$proj_vis:vis struct $ident:ident] $($field:tt)* ) => {}; ( [$proj_ty_ident:ident] [$proj_vis:vis struct $ident:ident] [$__pin_project_make_proj_field:ident] [$($impl_generics:tt)*] [$($ty_generics:tt)*] [$(where $($where_clause:tt)*)?] { $( $(#[$pin:ident])? $field_vis:vis $field:ident: $field_ty:ty ),+ $(,)? } ) => { $crate::__pin_project_make_proj_ty_body! { [$proj_ty_ident] [$proj_vis struct $ident] [$($impl_generics)*] [$($ty_generics)*] [$(where $($where_clause)*)?] [ $( $field_vis $field: $crate::$__pin_project_make_proj_field!( $(#[$pin])? $field_ty ) ),+ ] } }; ( [$proj_ty_ident:ident] [$proj_vis:vis enum $ident:ident] [$__pin_project_make_proj_field:ident] [$($impl_generics:tt)*] [$($ty_generics:tt)*] [$(where $($where_clause:tt)*)?] { $( $(#[$variant_attrs:meta])* $variant:ident $({ $( $(#[$pin:ident])? $field:ident: $field_ty:ty ),+ $(,)? })? ),+ $(,)? } ) => { $crate::__pin_project_make_proj_ty_body! { [$proj_ty_ident] [$proj_vis enum $ident] [$($impl_generics)*] [$($ty_generics)*] [$(where $($where_clause)*)?] [ $( $variant $({ $( $field: $crate::$__pin_project_make_proj_field!( $(#[$pin])? $field_ty ) ),+ })? ),+ ] } }; } #[doc(hidden)] #[macro_export] macro_rules! __pin_project_make_proj_ty_body { ( [$proj_ty_ident:ident] [$proj_vis:vis $struct_ty_ident:ident $ident:ident] [$($impl_generics:tt)*] [$($ty_generics:tt)*] [$(where $($where_clause:tt)*)?] [$($body_data:tt)+] ) => { #[doc(hidden)] // Workaround for rustc bug: see https://github.com/taiki-e/pin-project-lite/issues/77#issuecomment-1671540180 for more. #[allow( dead_code, // This lint warns unused fields/variants. single_use_lifetimes, // https://github.com/rust-lang/rust/issues/55058 // This lint warns of `clippy::*` generated by external macros. // We allow this lint for compatibility with older compilers. clippy::unknown_clippy_lints, clippy::absolute_paths, clippy::min_ident_chars, clippy::mut_mut, // This lint warns `&mut &mut `. (only needed for project) clippy::redundant_pub_crate, // This lint warns `pub(crate)` field in private struct. clippy::ref_option_ref, // This lint warns `&Option<&>`. (only needed for project_ref) clippy::single_char_lifetime_names, clippy::type_repetition_in_bounds // https://github.com/rust-lang/rust-clippy/issues/4326 )] $proj_vis $struct_ty_ident $proj_ty_ident <'__pin, $($impl_generics)*> where $ident <$($ty_generics)*>: '__pin $(, $($where_clause)*)? { $($body_data)+ } }; } #[doc(hidden)] #[macro_export] macro_rules! __pin_project_make_proj_replace_ty { ([] $($field:tt)*) => {}; ( [$proj_ty_ident:ident] [$proj_vis:vis struct] [$__pin_project_make_proj_field:ident] [$($impl_generics:tt)*] [$($ty_generics:tt)*] [$(where $($where_clause:tt)*)?] { $( $(#[$pin:ident])? $field_vis:vis $field:ident: $field_ty:ty ),+ $(,)? } ) => { $crate::__pin_project_make_proj_replace_ty_body! { [$proj_ty_ident] [$proj_vis struct] [$($impl_generics)*] [$($ty_generics)*] [$(where $($where_clause)*)?] [ $( $field_vis $field: $crate::$__pin_project_make_proj_field!( $(#[$pin])? $field_ty ) ),+ ] } }; ( [$proj_ty_ident:ident] [$proj_vis:vis enum] [$__pin_project_make_proj_field:ident] [$($impl_generics:tt)*] [$($ty_generics:tt)*] [$(where $($where_clause:tt)*)?] { $( $(#[$variant_attrs:meta])* $variant:ident $({ $( $(#[$pin:ident])? $field:ident: $field_ty:ty ),+ $(,)? })? ),+ $(,)? } ) => { $crate::__pin_project_make_proj_replace_ty_body! { [$proj_ty_ident] [$proj_vis enum] [$($impl_generics)*] [$($ty_generics)*] [$(where $($where_clause)*)?] [ $( $variant $({ $( $field: $crate::$__pin_project_make_proj_field!( $(#[$pin])? $field_ty ) ),+ })? ),+ ] } }; } #[doc(hidden)] #[macro_export] macro_rules! __pin_project_make_proj_replace_ty_body { ( [$proj_ty_ident:ident] [$proj_vis:vis $struct_ty_ident:ident] [$($impl_generics:tt)*] [$($ty_generics:tt)*] [$(where $($where_clause:tt)*)?] [$($body_data:tt)+] ) => { #[doc(hidden)] // Workaround for rustc bug: see https://github.com/taiki-e/pin-project-lite/issues/77#issuecomment-1671540180 for more. #[allow( dead_code, // This lint warns unused fields/variants. single_use_lifetimes, // https://github.com/rust-lang/rust/issues/55058 // This lint warns of `clippy::*` generated by external macros. // We allow this lint for compatibility with older compilers. clippy::unknown_clippy_lints, clippy::absolute_paths, clippy::min_ident_chars, clippy::mut_mut, // This lint warns `&mut &mut `. (only needed for project) clippy::redundant_pub_crate, // This lint warns `pub(crate)` field in private struct. clippy::single_char_lifetime_names, clippy::type_repetition_in_bounds // https://github.com/rust-lang/rust-clippy/issues/4326 )] $proj_vis $struct_ty_ident $proj_ty_ident <$($impl_generics)*> where $($($where_clause)*)? { $($body_data)+ } }; } #[doc(hidden)] #[macro_export] macro_rules! __pin_project_make_proj_replace_block { ( [$($proj_path:tt)+] { $( $(#[$pin:ident])? $field_vis:vis $field:ident ),+ } ) => { let result = $($proj_path)* { $( $field: $crate::__pin_project_make_replace_field_proj!( $(#[$pin])? $field ) ),+ }; { ( $( $crate::__pin_project_make_unsafe_drop_in_place_guard!( $(#[$pin])? $field ), )* ); } result }; ([$($proj_path:tt)+]) => { $($proj_path)* }; } #[doc(hidden)] #[macro_export] macro_rules! __pin_project_struct_make_proj_method { ([] $($variant:tt)*) => {}; ( [$proj_ty_ident:ident $_ignored_default_arg:ident] [$proj_vis:vis] [$method_ident:ident $get_method:ident $($mut:ident)?] [$($ty_generics:tt)*] $($variant:tt)* ) => { $crate::__pin_project_struct_make_proj_method! { [$proj_ty_ident] [$proj_vis] [$method_ident $get_method $($mut)?] [$($ty_generics)*] $($variant)* } }; ( [$proj_ty_ident:ident] [$proj_vis:vis] [$method_ident:ident $get_method:ident $($mut:ident)?] [$($ty_generics:tt)*] { $( $(#[$pin:ident])? $field_vis:vis $field:ident ),+ } ) => { #[doc(hidden)] // Workaround for rustc bug: see https://github.com/taiki-e/pin-project-lite/issues/77#issuecomment-1671540180 for more. #[inline] $proj_vis fn $method_ident<'__pin>( self: $crate::__private::Pin<&'__pin $($mut)? Self>, ) -> $proj_ty_ident <'__pin, $($ty_generics)*> { unsafe { let Self { $($field),* } = self.$get_method(); $proj_ty_ident { $( $field: $crate::__pin_project_make_unsafe_field_proj!( $(#[$pin])? $field ) ),+ } } } }; } #[doc(hidden)] #[macro_export] macro_rules! __pin_project_struct_make_proj_replace_method { ([] $($field:tt)*) => {}; ( [$proj_ty_ident:ident] [$proj_vis:vis] [$_proj_ty_ident:ident] [$($ty_generics:tt)*] { $( $(#[$pin:ident])? $field_vis:vis $field:ident ),+ } ) => { #[doc(hidden)] // Workaround for rustc bug: see https://github.com/taiki-e/pin-project-lite/issues/77#issuecomment-1671540180 for more. #[inline] $proj_vis fn project_replace( self: $crate::__private::Pin<&mut Self>, replacement: Self, ) -> $proj_ty_ident <$($ty_generics)*> { unsafe { let __self_ptr: *mut Self = self.get_unchecked_mut(); // Destructors will run in reverse order, so next create a guard to overwrite // `self` with the replacement value without calling destructors. let __guard = $crate::__private::UnsafeOverwriteGuard::new(__self_ptr, replacement); let Self { $($field),* } = &mut *__self_ptr; $crate::__pin_project_make_proj_replace_block! { [$proj_ty_ident] { $( $(#[$pin])? $field ),+ } } } } }; } #[doc(hidden)] #[macro_export] macro_rules! __pin_project_enum_make_proj_method { ([] $($variant:tt)*) => {}; ( [$proj_ty_ident:ident] [$proj_vis:vis] [$method_ident:ident $get_method:ident $($mut:ident)?] [$($ty_generics:tt)*] { $( $variant:ident $({ $( $(#[$pin:ident])? $field:ident ),+ })? ),+ } ) => { #[doc(hidden)] // Workaround for rustc bug: see https://github.com/taiki-e/pin-project-lite/issues/77#issuecomment-1671540180 for more. #[inline] $proj_vis fn $method_ident<'__pin>( self: $crate::__private::Pin<&'__pin $($mut)? Self>, ) -> $proj_ty_ident <'__pin, $($ty_generics)*> { unsafe { match self.$get_method() { $( Self::$variant $({ $($field),+ })? => { $proj_ty_ident::$variant $({ $( $field: $crate::__pin_project_make_unsafe_field_proj!( $(#[$pin])? $field ) ),+ })? } ),+ } } } }; } #[doc(hidden)] #[macro_export] macro_rules! __pin_project_enum_make_proj_replace_method { ([] $($field:tt)*) => {}; ( [$proj_ty_ident:ident] [$proj_vis:vis] [$($ty_generics:tt)*] { $( $variant:ident $({ $( $(#[$pin:ident])? $field:ident ),+ })? ),+ } ) => { #[doc(hidden)] // Workaround for rustc bug: see https://github.com/taiki-e/pin-project-lite/issues/77#issuecomment-1671540180 for more. #[inline] $proj_vis fn project_replace( self: $crate::__private::Pin<&mut Self>, replacement: Self, ) -> $proj_ty_ident <$($ty_generics)*> { unsafe { let __self_ptr: *mut Self = self.get_unchecked_mut(); // Destructors will run in reverse order, so next create a guard to overwrite // `self` with the replacement value without calling destructors. let __guard = $crate::__private::UnsafeOverwriteGuard::new(__self_ptr, replacement); match &mut *__self_ptr { $( Self::$variant $({ $($field),+ })? => { $crate::__pin_project_make_proj_replace_block! { [$proj_ty_ident :: $variant] $({ $( $(#[$pin])? $field ),+ })? } } ),+ } } } }; } #[doc(hidden)] #[macro_export] macro_rules! __pin_project_make_unpin_impl { ( [] [$vis:vis $ident:ident] [$($impl_generics:tt)*] [$($ty_generics:tt)*] [$(where $($where_clause:tt)*)?] $($field:tt)* ) => { // Automatically create the appropriate conditional `Unpin` implementation. // // Basically this is equivalent to the following code: // ``` // impl Unpin for Struct where T: Unpin {} // ``` // // However, if struct is public and there is a private type field, // this would cause an E0446 (private type in public interface). // // When RFC 2145 is implemented (rust-lang/rust#48054), // this will become a lint, rather than a hard error. // // As a workaround for this, we generate a new struct, containing all of the pinned // fields from our #[pin_project] type. This struct is declared within // a function, which makes it impossible to be named by user code. // This guarantees that it will use the default auto-trait impl for Unpin - // that is, it will implement Unpin iff all of its fields implement Unpin. // This type can be safely declared as 'public', satisfying the privacy // checker without actually allowing user code to access it. // // This allows users to apply the #[pin_project] attribute to types // regardless of the privacy of the types of their fields. // // See also https://github.com/taiki-e/pin-project/pull/53. #[allow(non_snake_case)] $vis struct __Origin<'__pin, $($impl_generics)*> $(where $($where_clause)*)? { __dummy_lifetime: $crate::__private::PhantomData<&'__pin ()>, $($field)* } impl<'__pin, $($impl_generics)*> $crate::__private::Unpin for $ident <$($ty_generics)*> where $crate::__private::PinnedFieldsOf<__Origin<'__pin, $($ty_generics)*>>: $crate::__private::Unpin $(, $($where_clause)*)? { } }; ( [$proj_not_unpin_mark:ident] [$vis:vis $ident:ident] [$($impl_generics:tt)*] [$($ty_generics:tt)*] [$(where $($where_clause:tt)*)?] $($field:tt)* ) => { // TODO: Using `: Sized` here allow emulating real negative_impls... // https://github.com/taiki-e/pin-project/issues/340#issuecomment-2428002670 #[doc(hidden)] impl<'__pin, $($impl_generics)*> $crate::__private::Unpin for $ident <$($ty_generics)*> where ( $crate::__private::PhantomData<&'__pin ()>, $crate::__private::PhantomPinned, ): $crate::__private::Unpin $(, $($where_clause)*)? { } } } #[doc(hidden)] #[macro_export] macro_rules! __pin_project_make_drop_impl { ( [$_ident:ident] [$($_impl_generics:tt)*] [$($_ty_generics:tt)*] [$(where $($_where_clause:tt)*)?] $(#[$drop_impl_attrs:meta])* impl $(< $( $lifetime:lifetime $(: $lifetime_bound:lifetime)? ),* $(,)? $( $generics:ident $(: $generics_bound:path)? $(: ?$generics_unsized_bound:path)? $(: $generics_lifetime_bound:lifetime)? ),* >)? PinnedDrop for $self_ty:ty $(where $( $where_clause_ty:ty $(: $where_clause_bound:path)? $(: ?$where_clause_unsized_bound:path)? $(: $where_clause_lifetime_bound:lifetime)? ),* $(,)? )? { $(#[$drop_fn_attrs:meta])* fn drop($($arg:ident)+: Pin<&mut Self>) { $($tt:tt)* } } ) => { $(#[$drop_impl_attrs])* impl $(< $( $lifetime $(: $lifetime_bound)? ,)* $( $generics $(: $generics_bound)? $(: ?$generics_unsized_bound)? $(: $generics_lifetime_bound)? ),* >)? $crate::__private::Drop for $self_ty $(where $( $where_clause_ty $(: $where_clause_bound)? $(: ?$where_clause_unsized_bound)? $(: $where_clause_lifetime_bound)? ),* )? { $(#[$drop_fn_attrs])* fn drop(&mut self) { // Implementing `__DropInner::__drop_inner` is safe, but calling it is not safe. // This is because destructors can be called multiple times in safe code and // [double dropping is unsound](https://github.com/rust-lang/rust/pull/62360). // // `__drop_inner` is defined as a safe method, but this is fine since // `__drop_inner` is not accessible by the users and we call `__drop_inner` only // once. // // Users can implement [`Drop`] safely using `pin_project!` and can drop a // type that implements `PinnedDrop` using the [`drop`] function safely. fn __drop_inner $(< $( $lifetime $(: $lifetime_bound)? ,)* $( $generics $(: $generics_bound)? $(: ?$generics_unsized_bound)? $(: $generics_lifetime_bound)? ),* >)? ( $($arg)+: $crate::__private::Pin<&mut $self_ty>, ) $(where $( $where_clause_ty $(: $where_clause_bound)? $(: ?$where_clause_unsized_bound)? $(: $where_clause_lifetime_bound)? ),* )? { // A dummy `__drop_inner` function to prevent users call outer `__drop_inner`. fn __drop_inner() {} $($tt)* } // Safety - we're in 'drop', so we know that 'self' will // never move again. let pinned_self: $crate::__private::Pin<&mut Self> = unsafe { $crate::__private::Pin::new_unchecked(self) }; // We call `__drop_inner` only once. Since `__DropInner::__drop_inner` // is not accessible by the users, it is never called again. __drop_inner(pinned_self); } } }; ( [$ident:ident] [$($impl_generics:tt)*] [$($ty_generics:tt)*] [$(where $($where_clause:tt)*)?] ) => { // Ensure that struct does not implement `Drop`. // // There are two possible cases: // 1. The user type does not implement Drop. In this case, // the first blanket impl will not apply to it. This code // will compile, as there is only one impl of MustNotImplDrop for the user type // 2. The user type does impl Drop. This will make the blanket impl applicable, // which will then conflict with the explicit MustNotImplDrop impl below. // This will result in a compilation error, which is exactly what we want. trait MustNotImplDrop {} #[allow(clippy::drop_bounds, drop_bounds)] impl MustNotImplDrop for T {} impl<$($impl_generics)*> MustNotImplDrop for $ident <$($ty_generics)*> $(where $($where_clause)*)? { } }; } #[doc(hidden)] #[macro_export] macro_rules! __pin_project_make_unpin_bound { (#[pin] $field_ty:ty) => { $field_ty }; ($field_ty:ty) => { $crate::__private::AlwaysUnpin<$field_ty> }; } #[doc(hidden)] #[macro_export] macro_rules! __pin_project_make_unsafe_field_proj { (#[pin] $field:ident) => { $crate::__private::Pin::new_unchecked($field) }; ($field:ident) => { $field }; } #[doc(hidden)] #[macro_export] macro_rules! __pin_project_make_replace_field_proj { (#[pin] $field:ident) => { $crate::__private::PhantomData }; ($field:ident) => { $crate::__private::ptr::read($field) }; } #[doc(hidden)] #[macro_export] macro_rules! __pin_project_make_unsafe_drop_in_place_guard { (#[pin] $field:ident) => { $crate::__private::UnsafeDropInPlaceGuard::new($field) }; ($field:ident) => { () }; } #[doc(hidden)] #[macro_export] macro_rules! __pin_project_make_proj_field_mut { (#[pin] $field_ty:ty) => { $crate::__private::Pin<&'__pin mut ($field_ty)> }; ($field_ty:ty) => { &'__pin mut ($field_ty) }; } #[doc(hidden)] #[macro_export] macro_rules! __pin_project_make_proj_field_ref { (#[pin] $field_ty:ty) => { $crate::__private::Pin<&'__pin ($field_ty)> }; ($field_ty:ty) => { &'__pin ($field_ty) }; } #[doc(hidden)] #[macro_export] macro_rules! __pin_project_make_proj_field_replace { (#[pin] $field_ty:ty) => { $crate::__private::PhantomData<$field_ty> }; ($field_ty:ty) => { $field_ty }; } #[doc(hidden)] #[macro_export] macro_rules! __pin_project_internal { // parsing proj_mut_ident ( [] [$($proj_ref_ident:ident)?] [$($proj_replace_ident:ident)?] [$( ! $proj_not_unpin_mark:ident)?] [$($attrs:tt)*] #[project = $proj_mut_ident:ident] $($tt:tt)* ) => { $crate::__pin_project_internal! { [$proj_mut_ident] [$($proj_ref_ident)?] [$($proj_replace_ident)?] [$( ! $proj_not_unpin_mark)?] [$($attrs)*] $($tt)* } }; // parsing proj_ref_ident ( [$($proj_mut_ident:ident)?] [] [$($proj_replace_ident:ident)?] [$( ! $proj_not_unpin_mark:ident)?] [$($attrs:tt)*] #[project_ref = $proj_ref_ident:ident] $($tt:tt)* ) => { $crate::__pin_project_internal! { [$($proj_mut_ident)?] [$proj_ref_ident] [$($proj_replace_ident)?] [$( ! $proj_not_unpin_mark)?] [$($attrs)*] $($tt)* } }; // parsing proj_replace_ident ( [$($proj_mut_ident:ident)?] [$($proj_ref_ident:ident)?] [] [$( ! $proj_not_unpin_mark:ident)?] [$($attrs:tt)*] #[project_replace = $proj_replace_ident:ident] $($tt:tt)* ) => { $crate::__pin_project_internal! { [$($proj_mut_ident)?] [$($proj_ref_ident)?] [$proj_replace_ident] [$( ! $proj_not_unpin_mark)?] [$($attrs)*] $($tt)* } }; // parsing !Unpin ( [$($proj_mut_ident:ident)?] [$($proj_ref_ident:ident)?] [$($proj_replace_ident:ident)?] [] [$($attrs:tt)*] #[project( ! $proj_not_unpin_mark:ident)] $($tt:tt)* ) => { $crate::__pin_project_internal! { [$($proj_mut_ident)?] [$($proj_ref_ident)?] [$($proj_replace_ident)?] [ ! $proj_not_unpin_mark] [$($attrs)*] $($tt)* } }; // this is actually part of a recursive step that picks off a single non-`pin_project_lite` attribute // there could be more to parse ( [$($proj_mut_ident:ident)?] [$($proj_ref_ident:ident)?] [$($proj_replace_ident:ident)?] [$( ! $proj_not_unpin_mark:ident)?] [$($attrs:tt)*] #[$($attr:tt)*] $($tt:tt)* ) => { $crate::__pin_project_internal! { [$($proj_mut_ident)?] [$($proj_ref_ident)?] [$($proj_replace_ident)?] [$( ! $proj_not_unpin_mark)?] [$($attrs)* #[$($attr)*]] $($tt)* } }; // now determine visibility // if public, downgrade ( [$($proj_mut_ident:ident)?] [$($proj_ref_ident:ident)?] [$($proj_replace_ident:ident)?] [$( ! $proj_not_unpin_mark:ident)?] [$($attrs:tt)*] pub $struct_ty_ident:ident $ident:ident $($tt:tt)* ) => { $crate::__pin_project_parse_generics! { [$($proj_mut_ident)?] [$($proj_ref_ident)?] [$($proj_replace_ident)?] [$($proj_not_unpin_mark)?] [$($attrs)*] [pub $struct_ty_ident $ident pub(crate)] $($tt)* } }; ( [$($proj_mut_ident:ident)?] [$($proj_ref_ident:ident)?] [$($proj_replace_ident:ident)?] [$( ! $proj_not_unpin_mark:ident)?] [$($attrs:tt)*] $vis:vis $struct_ty_ident:ident $ident:ident $($tt:tt)* ) => { $crate::__pin_project_parse_generics! { [$($proj_mut_ident)?] [$($proj_ref_ident)?] [$($proj_replace_ident)?] [$($proj_not_unpin_mark)?] [$($attrs)*] [$vis $struct_ty_ident $ident $vis] $($tt)* } }; } #[doc(hidden)] #[macro_export] macro_rules! __pin_project_parse_generics { ( [$($proj_mut_ident:ident)?] [$($proj_ref_ident:ident)?] [$($proj_replace_ident:ident)?] [$($proj_not_unpin_mark:ident)?] [$($attrs:tt)*] [$vis:vis $struct_ty_ident:ident $ident:ident $proj_vis:vis] $(< $( $lifetime:lifetime $(: $lifetime_bound:lifetime)? ),* $(,)? $( $generics:ident $(: $generics_bound:path)? $(: ?$generics_unsized_bound:path)? $(: $generics_lifetime_bound:lifetime)? $(= $generics_default:ty)? ),* $(,)? >)? $(where $( $where_clause_ty:ty $(: $where_clause_bound:path)? $(: ?$where_clause_unsized_bound:path)? $(: $where_clause_lifetime_bound:lifetime)? ),* $(,)? )? { $($body_data:tt)* } $($(#[$drop_impl_attrs:meta])* impl $($pinned_drop:tt)*)? ) => { $crate::__pin_project_expand! { [$($proj_mut_ident)?] [$($proj_ref_ident)?] [$($proj_replace_ident)?] [$($proj_not_unpin_mark)?] [$proj_vis] [$($attrs)* $vis $struct_ty_ident $ident] [$(< $( $lifetime $(: $lifetime_bound)? ,)* $( $generics $(: $generics_bound)? $(: ?$generics_unsized_bound)? $(: $generics_lifetime_bound)? $(= $generics_default)? ),* >)?] [$( $( $lifetime $(: $lifetime_bound)? ,)* $( $generics $(: $generics_bound)? $(: ?$generics_unsized_bound)? $(: $generics_lifetime_bound)? ),* )?] [$( $( $lifetime ,)* $( $generics ),* )?] [$(where $( $where_clause_ty $(: $where_clause_bound)? $(: ?$where_clause_unsized_bound)? $(: $where_clause_lifetime_bound)? ),* )?] { $($body_data)* } $($(#[$drop_impl_attrs])* impl $($pinned_drop)*)? } }; } // Not public API. #[doc(hidden)] #[allow(missing_debug_implementations)] pub mod __private { use core::mem::ManuallyDrop; #[doc(hidden)] pub use core::{ marker::{PhantomData, PhantomPinned, Unpin}, ops::Drop, pin::Pin, ptr, }; // Workaround for issue on unstable negative_impls feature that allows unsound overlapping Unpin // implementations and rustc bug that leaks unstable negative_impls into stable. // See https://github.com/taiki-e/pin-project/issues/340#issuecomment-2432146009 for details. #[doc(hidden)] pub type PinnedFieldsOf = as PinnedFieldsOfHelperTrait>::Actual; // We cannot use as IntoIterator>::Item or similar since we should allow ?Sized in T. #[doc(hidden)] pub trait PinnedFieldsOfHelperTrait { type Actual: ?Sized; } #[doc(hidden)] pub struct PinnedFieldsOfHelperStruct(T); impl PinnedFieldsOfHelperTrait for PinnedFieldsOfHelperStruct { type Actual = T; } // This is an internal helper struct used by `pin_project!`. #[doc(hidden)] pub struct AlwaysUnpin(PhantomData); impl Unpin for AlwaysUnpin {} // This is an internal helper used to ensure a value is dropped. #[doc(hidden)] pub struct UnsafeDropInPlaceGuard(*mut T); impl UnsafeDropInPlaceGuard { #[doc(hidden)] pub unsafe fn new(ptr: *mut T) -> Self { Self(ptr) } } impl Drop for UnsafeDropInPlaceGuard { fn drop(&mut self) { // SAFETY: the caller of `UnsafeDropInPlaceGuard::new` must guarantee // that `ptr` is valid for drop when this guard is destructed. unsafe { ptr::drop_in_place(self.0); } } } // This is an internal helper used to ensure a value is overwritten without // its destructor being called. #[doc(hidden)] pub struct UnsafeOverwriteGuard { target: *mut T, value: ManuallyDrop, } impl UnsafeOverwriteGuard { #[doc(hidden)] pub unsafe fn new(target: *mut T, value: T) -> Self { Self { target, value: ManuallyDrop::new(value) } } } impl Drop for UnsafeOverwriteGuard { fn drop(&mut self) { // SAFETY: the caller of `UnsafeOverwriteGuard::new` must guarantee // that `target` is valid for writes when this guard is destructed. unsafe { ptr::write(self.target, ptr::read(&*self.value)); } } } } pin-project-lite-0.2.16/tests/auxiliary/mod.rs000064400000000000000000000004741046102023000174020ustar 00000000000000// 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); }; } pin-project-lite-0.2.16/tests/compiletest.rs000064400000000000000000000003701046102023000171370ustar 00000000000000// 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"); } pin-project-lite-0.2.16/tests/drop_order.rs000064400000000000000000000104751046102023000167550ustar 00000000000000// 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); 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 { #[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); } pin-project-lite-0.2.16/tests/expand/.rustfmt.toml000064400000000000000000000000361046102023000201760ustar 00000000000000disable_all_formatting = true pin-project-lite-0.2.16/tests/expand/default/enum.expanded.rs000064400000000000000000000120671046102023000222530ustar 00000000000000use pin_project_lite::pin_project; enum Enum { 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: '__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: '__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 { Struct { pinned: ::pin_project_lite::__private::PhantomData, 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 Enum { #[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 { 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), Unit: (), } impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Enum where ::pin_project_lite::__private::PinnedFieldsOf< __Origin<'__pin, T, U>, >: ::pin_project_lite::__private::Unpin, {} trait MustNotImplDrop {} #[allow(clippy::drop_bounds, drop_bounds)] impl MustNotImplDrop for T {} impl MustNotImplDrop for Enum {} }; fn main() {} pin-project-lite-0.2.16/tests/expand/default/enum.rs000064400000000000000000000005371046102023000204630ustar 00000000000000// 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 { Struct { #[pin] pinned: T, unpinned: U, }, Unit, } } fn main() {} pin-project-lite-0.2.16/tests/expand/default/struct.expanded.rs000064400000000000000000000064341046102023000226340ustar 00000000000000use pin_project_lite::pin_project; struct Struct { 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: '__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: '__pin, { pinned: ::pin_project_lite::__private::Pin<&'__pin (T)>, unpinned: &'__pin (U), } impl Struct { #[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, } impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Struct where ::pin_project_lite::__private::PinnedFieldsOf< __Origin<'__pin, T, U>, >: ::pin_project_lite::__private::Unpin, {} trait MustNotImplDrop {} #[allow(clippy::drop_bounds, drop_bounds)] impl MustNotImplDrop for T {} impl MustNotImplDrop for Struct {} #[forbid(unaligned_references, safe_packed_borrows)] fn __assert_not_repr_packed(this: &Struct) { let _ = &this.pinned; let _ = &this.unpinned; } }; fn main() {} pin-project-lite-0.2.16/tests/expand/default/struct.rs000064400000000000000000000003111046102023000210310ustar 00000000000000// SPDX-License-Identifier: Apache-2.0 OR MIT use pin_project_lite::pin_project; pin_project! { struct Struct { #[pin] pinned: T, unpinned: U, } } fn main() {} pin-project-lite-0.2.16/tests/expand/multifields/enum.expanded.rs000064400000000000000000000067201046102023000231470ustar 00000000000000use pin_project_lite::pin_project; enum Enum { 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 { Struct { pinned1: ::pin_project_lite::__private::PhantomData, pinned2: ::pin_project_lite::__private::PhantomData, 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 Enum { #[doc(hidden)] #[inline] fn project_replace( self: ::pin_project_lite::__private::Pin<&mut Self>, replacement: Self, ) -> EnumProjReplace { 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, ::pin_project_lite::__private::AlwaysUnpin, ), Unit: (), } impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Enum where ::pin_project_lite::__private::PinnedFieldsOf< __Origin<'__pin, T, U>, >: ::pin_project_lite::__private::Unpin, {} trait MustNotImplDrop {} #[allow(clippy::drop_bounds, drop_bounds)] impl MustNotImplDrop for T {} impl MustNotImplDrop for Enum {} }; fn main() {} pin-project-lite-0.2.16/tests/expand/multifields/enum.rs000064400000000000000000000004731046102023000213570ustar 00000000000000// SPDX-License-Identifier: Apache-2.0 OR MIT use pin_project_lite::pin_project; pin_project! { #[project_replace = EnumProjReplace] enum Enum { Struct { #[pin] pinned1: T, #[pin] pinned2: T, unpinned1: U, unpinned2: U, }, Unit, } } fn main() {} pin-project-lite-0.2.16/tests/expand/multifields/struct.expanded.rs000064400000000000000000000135441046102023000235310ustar 00000000000000use pin_project_lite::pin_project; struct Struct { 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 { pinned1: ::pin_project_lite::__private::PhantomData, pinned2: ::pin_project_lite::__private::PhantomData, 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: '__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: '__pin, { pinned1: ::pin_project_lite::__private::Pin<&'__pin (T)>, pinned2: ::pin_project_lite::__private::Pin<&'__pin (T)>, unpinned1: &'__pin (U), unpinned2: &'__pin (U), } impl Struct { #[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 { 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, unpinned2: ::pin_project_lite::__private::AlwaysUnpin, } impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Struct where ::pin_project_lite::__private::PinnedFieldsOf< __Origin<'__pin, T, U>, >: ::pin_project_lite::__private::Unpin, {} trait MustNotImplDrop {} #[allow(clippy::drop_bounds, drop_bounds)] impl MustNotImplDrop for T {} impl MustNotImplDrop for Struct {} #[forbid(unaligned_references, safe_packed_borrows)] fn __assert_not_repr_packed(this: &Struct) { let _ = &this.pinned1; let _ = &this.pinned2; let _ = &this.unpinned1; let _ = &this.unpinned2; } }; fn main() {} pin-project-lite-0.2.16/tests/expand/multifields/struct.rs000064400000000000000000000004131046102023000217310ustar 00000000000000// SPDX-License-Identifier: Apache-2.0 OR MIT use pin_project_lite::pin_project; pin_project! { #[project_replace = StructProjReplace] struct Struct { #[pin] pinned1: T, #[pin] pinned2: T, unpinned1: U, unpinned2: U, } } fn main() {} pin-project-lite-0.2.16/tests/expand/naming/enum-all.expanded.rs000064400000000000000000000120671046102023000226460ustar 00000000000000use pin_project_lite::pin_project; enum Enum { 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: '__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: '__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 { Struct { pinned: ::pin_project_lite::__private::PhantomData, 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 Enum { #[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 { 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), Unit: (), } impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Enum where ::pin_project_lite::__private::PinnedFieldsOf< __Origin<'__pin, T, U>, >: ::pin_project_lite::__private::Unpin, {} trait MustNotImplDrop {} #[allow(clippy::drop_bounds, drop_bounds)] impl MustNotImplDrop for T {} impl MustNotImplDrop for Enum {} }; fn main() {} pin-project-lite-0.2.16/tests/expand/naming/enum-all.rs000064400000000000000000000005371046102023000210560ustar 00000000000000// 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 { Struct { #[pin] pinned: T, unpinned: U, }, Unit, } } fn main() {} pin-project-lite-0.2.16/tests/expand/naming/enum-mut.expanded.rs000064400000000000000000000043211046102023000226750ustar 00000000000000use pin_project_lite::pin_project; enum Enum { 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: '__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 Enum { #[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), Unit: (), } impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Enum where ::pin_project_lite::__private::PinnedFieldsOf< __Origin<'__pin, T, U>, >: ::pin_project_lite::__private::Unpin, {} trait MustNotImplDrop {} #[allow(clippy::drop_bounds, drop_bounds)] impl MustNotImplDrop for T {} impl MustNotImplDrop for Enum {} }; fn main() {} pin-project-lite-0.2.16/tests/expand/naming/enum-mut.rs000064400000000000000000000004251046102023000211070ustar 00000000000000// SPDX-License-Identifier: Apache-2.0 OR MIT use pin_project_lite::pin_project; pin_project! { #[project = EnumProj] enum Enum { Struct { #[pin] pinned: T, unpinned: U, }, Unit, } } fn main() {} pin-project-lite-0.2.16/tests/expand/naming/enum-none.expanded.rs000064400000000000000000000020201046102023000230210ustar 00000000000000use pin_project_lite::pin_project; enum Enum { 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 Enum {} #[allow(non_snake_case)] struct __Origin<'__pin, T, U> { __dummy_lifetime: ::pin_project_lite::__private::PhantomData<&'__pin ()>, Struct: (T, ::pin_project_lite::__private::AlwaysUnpin), Unit: (), } impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Enum where ::pin_project_lite::__private::PinnedFieldsOf< __Origin<'__pin, T, U>, >: ::pin_project_lite::__private::Unpin, {} trait MustNotImplDrop {} #[allow(clippy::drop_bounds, drop_bounds)] impl MustNotImplDrop for T {} impl MustNotImplDrop for Enum {} }; fn main() {} pin-project-lite-0.2.16/tests/expand/naming/enum-none.rs000064400000000000000000000003731046102023000212430ustar 00000000000000// SPDX-License-Identifier: Apache-2.0 OR MIT use pin_project_lite::pin_project; pin_project! { enum Enum { Struct { #[pin] pinned: T, unpinned: U, }, Unit, } } fn main() {} pin-project-lite-0.2.16/tests/expand/naming/enum-ref.expanded.rs000064400000000000000000000043131046102023000226450ustar 00000000000000use pin_project_lite::pin_project; enum Enum { 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: '__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 Enum { #[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), Unit: (), } impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Enum where ::pin_project_lite::__private::PinnedFieldsOf< __Origin<'__pin, T, U>, >: ::pin_project_lite::__private::Unpin, {} trait MustNotImplDrop {} #[allow(clippy::drop_bounds, drop_bounds)] impl MustNotImplDrop for T {} impl MustNotImplDrop for Enum {} }; fn main() {} pin-project-lite-0.2.16/tests/expand/naming/enum-ref.rs000064400000000000000000000004341046102023000210560ustar 00000000000000// SPDX-License-Identifier: Apache-2.0 OR MIT use pin_project_lite::pin_project; pin_project! { #[project_ref = EnumProjRef] enum Enum { Struct { #[pin] pinned: T, unpinned: U, }, Unit, } } fn main() {} pin-project-lite-0.2.16/tests/expand/naming/struct-all.expanded.rs000064400000000000000000000110601046102023000232160ustar 00000000000000use pin_project_lite::pin_project; struct Struct { 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: '__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: '__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 { pinned: ::pin_project_lite::__private::PhantomData, 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 Struct { #[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 { 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, } impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Struct where ::pin_project_lite::__private::PinnedFieldsOf< __Origin<'__pin, T, U>, >: ::pin_project_lite::__private::Unpin, {} trait MustNotImplDrop {} #[allow(clippy::drop_bounds, drop_bounds)] impl MustNotImplDrop for T {} impl MustNotImplDrop for Struct {} #[forbid(unaligned_references, safe_packed_borrows)] fn __assert_not_repr_packed(this: &Struct) { let _ = &this.pinned; let _ = &this.unpinned; } }; fn main() {} pin-project-lite-0.2.16/tests/expand/naming/struct-all.rs000064400000000000000000000004631046102023000214340ustar 00000000000000// 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 { #[pin] pinned: T, unpinned: U, } } fn main() {} pin-project-lite-0.2.16/tests/expand/naming/struct-mut.expanded.rs000064400000000000000000000063141046102023000232610ustar 00000000000000use pin_project_lite::pin_project; struct Struct { 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: '__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: '__pin, { pinned: ::pin_project_lite::__private::Pin<&'__pin (T)>, unpinned: &'__pin (U), } impl Struct { #[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, } impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Struct where ::pin_project_lite::__private::PinnedFieldsOf< __Origin<'__pin, T, U>, >: ::pin_project_lite::__private::Unpin, {} trait MustNotImplDrop {} #[allow(clippy::drop_bounds, drop_bounds)] impl MustNotImplDrop for T {} impl MustNotImplDrop for Struct {} #[forbid(unaligned_references, safe_packed_borrows)] fn __assert_not_repr_packed(this: &Struct) { let _ = &this.pinned; let _ = &this.unpinned; } }; fn main() {} pin-project-lite-0.2.16/tests/expand/naming/struct-mut.rs000064400000000000000000000003451046102023000214700ustar 00000000000000// SPDX-License-Identifier: Apache-2.0 OR MIT use pin_project_lite::pin_project; pin_project! { #[project = StructProj] struct Struct { #[pin] pinned: T, unpinned: U, } } fn main() {} pin-project-lite-0.2.16/tests/expand/naming/struct-none.expanded.rs000064400000000000000000000064341046102023000234160ustar 00000000000000use pin_project_lite::pin_project; struct Struct { 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: '__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: '__pin, { pinned: ::pin_project_lite::__private::Pin<&'__pin (T)>, unpinned: &'__pin (U), } impl Struct { #[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, } impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Struct where ::pin_project_lite::__private::PinnedFieldsOf< __Origin<'__pin, T, U>, >: ::pin_project_lite::__private::Unpin, {} trait MustNotImplDrop {} #[allow(clippy::drop_bounds, drop_bounds)] impl MustNotImplDrop for T {} impl MustNotImplDrop for Struct {} #[forbid(unaligned_references, safe_packed_borrows)] fn __assert_not_repr_packed(this: &Struct) { let _ = &this.pinned; let _ = &this.unpinned; } }; fn main() {} pin-project-lite-0.2.16/tests/expand/naming/struct-none.rs000064400000000000000000000003111046102023000216130ustar 00000000000000// SPDX-License-Identifier: Apache-2.0 OR MIT use pin_project_lite::pin_project; pin_project! { struct Struct { #[pin] pinned: T, unpinned: U, } } fn main() {} pin-project-lite-0.2.16/tests/expand/naming/struct-ref.expanded.rs000064400000000000000000000063141046102023000232300ustar 00000000000000use pin_project_lite::pin_project; struct Struct { 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: '__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: '__pin, { pinned: ::pin_project_lite::__private::Pin<&'__pin mut (T)>, unpinned: &'__pin mut (U), } impl Struct { #[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, } impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Struct where ::pin_project_lite::__private::PinnedFieldsOf< __Origin<'__pin, T, U>, >: ::pin_project_lite::__private::Unpin, {} trait MustNotImplDrop {} #[allow(clippy::drop_bounds, drop_bounds)] impl MustNotImplDrop for T {} impl MustNotImplDrop for Struct {} #[forbid(unaligned_references, safe_packed_borrows)] fn __assert_not_repr_packed(this: &Struct) { let _ = &this.pinned; let _ = &this.unpinned; } }; fn main() {} pin-project-lite-0.2.16/tests/expand/naming/struct-ref.rs000064400000000000000000000003541046102023000214370ustar 00000000000000// SPDX-License-Identifier: Apache-2.0 OR MIT use pin_project_lite::pin_project; pin_project! { #[project_ref = StructProjRef] struct Struct { #[pin] pinned: T, unpinned: U, } } fn main() {} pin-project-lite-0.2.16/tests/expand/not_unpin/enum.expanded.rs000064400000000000000000000063301046102023000226340ustar 00000000000000use pin_project_lite::pin_project; enum Enum { 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: '__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: '__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 Enum { #[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 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 MustNotImplDrop for T {} impl MustNotImplDrop for Enum {} }; fn main() {} pin-project-lite-0.2.16/tests/expand/not_unpin/enum.rs000064400000000000000000000005151046102023000210440ustar 00000000000000// 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 { Struct { #[pin] pinned: T, unpinned: U, }, Unit, } } fn main() {} pin-project-lite-0.2.16/tests/expand/not_unpin/struct.expanded.rs000064400000000000000000000057171046102023000232240ustar 00000000000000use pin_project_lite::pin_project; struct Struct { 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: '__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: '__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 Struct { #[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 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 MustNotImplDrop for T {} impl MustNotImplDrop for Struct {} #[forbid(unaligned_references, safe_packed_borrows)] fn __assert_not_repr_packed(this: &Struct) { let _ = &this.pinned; let _ = &this.unpinned; } }; fn main() {} pin-project-lite-0.2.16/tests/expand/not_unpin/struct.rs000064400000000000000000000004371046102023000214270ustar 00000000000000// 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 { #[pin] pinned: T, unpinned: U, } } fn main() {} pin-project-lite-0.2.16/tests/expand/pinned_drop/enum.expanded.rs000064400000000000000000000073241046102023000231300ustar 00000000000000use pin_project_lite::pin_project; enum Enum { 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: '__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: '__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 Enum { #[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), Unit: (), } impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Enum where ::pin_project_lite::__private::PinnedFieldsOf< __Origin<'__pin, T, U>, >: ::pin_project_lite::__private::Unpin, {} impl ::pin_project_lite::__private::Drop for Enum { fn drop(&mut self) { fn __drop_inner( this: ::pin_project_lite::__private::Pin<&mut Enum>, ) { 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() {} pin-project-lite-0.2.16/tests/expand/pinned_drop/enum.rs000064400000000000000000000006631046102023000213400ustar 00000000000000// SPDX-License-Identifier: Apache-2.0 OR MIT use pin_project_lite::pin_project; pin_project! { #[project = EnumProj] #[project_ref = EnumProjRef] enum Enum { Struct { #[pin] pinned: T, unpinned: U, }, Unit, } impl PinnedDrop for Enum { fn drop(this: Pin<&mut Self>) { let _ = this; } } } fn main() {} pin-project-lite-0.2.16/tests/expand/pinned_drop/struct.expanded.rs000064400000000000000000000071531046102023000235100ustar 00000000000000use pin_project_lite::pin_project; struct Struct { 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: '__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: '__pin, { pinned: ::pin_project_lite::__private::Pin<&'__pin (T)>, unpinned: &'__pin (U), } impl Struct { #[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, } impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Struct where ::pin_project_lite::__private::PinnedFieldsOf< __Origin<'__pin, T, U>, >: ::pin_project_lite::__private::Unpin, {} impl ::pin_project_lite::__private::Drop for Struct { fn drop(&mut self) { fn __drop_inner( this: ::pin_project_lite::__private::Pin<&mut Struct>, ) { 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(this: &Struct) { let _ = &this.pinned; let _ = &this.unpinned; } }; fn main() {} pin-project-lite-0.2.16/tests/expand/pinned_drop/struct.rs000064400000000000000000000005101046102023000217070ustar 00000000000000// SPDX-License-Identifier: Apache-2.0 OR MIT use pin_project_lite::pin_project; pin_project! { struct Struct { #[pin] pinned: T, unpinned: U, } impl PinnedDrop for Struct { fn drop(this: Pin<&mut Self>) { let _ = this; } } } fn main() {} pin-project-lite-0.2.16/tests/expand/pub/enum.expanded.rs000064400000000000000000000066731046102023000214230ustar 00000000000000use pin_project_lite::pin_project; pub enum Enum { 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: '__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: '__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 Enum { #[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), Unit: (), } impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Enum where ::pin_project_lite::__private::PinnedFieldsOf< __Origin<'__pin, T, U>, >: ::pin_project_lite::__private::Unpin, {} trait MustNotImplDrop {} #[allow(clippy::drop_bounds, drop_bounds)] impl MustNotImplDrop for T {} impl MustNotImplDrop for Enum {} }; fn main() {} pin-project-lite-0.2.16/tests/expand/pub/enum.rs000064400000000000000000000004721046102023000176230ustar 00000000000000// SPDX-License-Identifier: Apache-2.0 OR MIT use pin_project_lite::pin_project; pin_project! { #[project = EnumProj] #[project_ref = EnumProjRef] pub enum Enum { Struct { #[pin] pinned: T, unpinned: U, }, Unit, } } fn main() {} pin-project-lite-0.2.16/tests/expand/pub/struct.expanded.rs000064400000000000000000000065501046102023000217750ustar 00000000000000use pin_project_lite::pin_project; pub struct Struct { 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: '__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: '__pin, { pub pinned: ::pin_project_lite::__private::Pin<&'__pin (T)>, pub unpinned: &'__pin (U), } impl Struct { #[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, } impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Struct where ::pin_project_lite::__private::PinnedFieldsOf< __Origin<'__pin, T, U>, >: ::pin_project_lite::__private::Unpin, {} trait MustNotImplDrop {} #[allow(clippy::drop_bounds, drop_bounds)] impl MustNotImplDrop for T {} impl MustNotImplDrop for Struct {} #[forbid(unaligned_references, safe_packed_borrows)] fn __assert_not_repr_packed(this: &Struct) { let _ = &this.pinned; let _ = &this.unpinned; } }; fn main() {} pin-project-lite-0.2.16/tests/expand/pub/struct.rs000064400000000000000000000003251046102023000202000ustar 00000000000000// SPDX-License-Identifier: Apache-2.0 OR MIT use pin_project_lite::pin_project; pin_project! { pub struct Struct { #[pin] pub pinned: T, pub unpinned: U, } } fn main() {} pin-project-lite-0.2.16/tests/expandtest.rs000064400000000000000000000003501046102023000167640ustar 00000000000000// 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); } pin-project-lite-0.2.16/tests/include/basic.rs000064400000000000000000000041571046102023000173220ustar 00000000000000// 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 { #[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 { #[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 { /// 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 { #[pin] pub pinned: T, pub unpinned: U, } impl PinnedDrop for PinnedDropStruct { 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 { /// Struct variant. Struct { #[pin] pinned: T, unpinned: U, }, /// Unit variant. Unit, } #[allow(clippy::absolute_paths)] impl PinnedDrop for PinnedDropEnum { fn drop(_this: Pin<&mut Self>) {} } } pin-project-lite-0.2.16/tests/proper_unpin.rs000064400000000000000000000037671046102023000173440ustar 00000000000000// 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 { f: T, } assert_unpin!(Inner<()>); assert_not_unpin!(Inner); pin_project! { struct Struct { #[pin] f1: Inner, f2: U, } } assert_unpin!(Struct<(), ()>); assert_unpin!(Struct<(), PhantomPinned>); assert_not_unpin!(Struct); assert_not_unpin!(Struct); pin_project! { #[project = EnumProj] #[project_ref = EnumProjRef] enum Enum { V1 { #[pin] f1: Inner, f2: U, }, } } assert_unpin!(Enum<(), ()>); assert_unpin!(Enum<(), PhantomPinned>); assert_not_unpin!(Enum); assert_not_unpin!(Enum); pin_project! { #[project(!Unpin)] enum NotUnpinEnum { V1 { #[pin] f1: Inner, 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, f2: U, } } assert_unpin!(PinRef<'_, PhantomPinned, PhantomPinned>); pin_project! { #[project(!Unpin)] struct NotUnpin { #[pin] u: U } } assert_not_unpin!(NotUnpin<()>); pin_project! { #[project(!Unpin)] struct NotUnpinRef<'a, T, U> { #[pin] f1: &'a mut Inner, f2: U } } assert_not_unpin!(NotUnpinRef<'_, (), ()>); } pin-project-lite-0.2.16/tests/test.rs000064400000000000000000000341731046102023000155760ustar 00000000000000// 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 { #[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 { 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 where T: Copy, { f: T, } } pin_project! { #[project = EnumProj] #[project_ref = EnumProjRef] enum Enum where T: Copy, { V { f: T }, } } } #[test] fn where_clause_and_associated_type_field() { pin_project! { struct Struct1 where I: Iterator, { #[pin] f1: I, f2: I::Item, } } pin_project! { struct Struct2 where I: Iterator, { #[pin] f1: I, f2: J, } } pin_project! { pub struct Struct3 where T: 'static, { f: T, } } trait Static: 'static {} impl Static for Struct3 {} pin_project! { #[project = EnumProj] #[project_ref = EnumProjRef] enum Enum where I: Iterator, { V1 { #[pin] f: I }, V2 { f: I::Item }, } } } #[test] fn derive_copy() { pin_project! { #[derive(Clone, Copy)] struct Struct { f: T, } } fn is_copy() {} is_copy::>(); } #[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 { f: T, } } trait Static: 'static {} impl Static for Struct7 {} 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 { #[pin] inner: PrivateStruct, } } struct PrivateStruct(T); } #[allow(clippy::needless_lifetimes)] #[test] fn lifetime_project() { pin_project! { struct Struct1 { #[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 { V { #[pin] pinned: T, unpinned: U, }, } } impl Struct1 { 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 Enum { 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 { f: T, } } let mut x = Struct1 { f: 0_u8 }; let x: Pin<&mut Struct1> = Pin::new(&mut x); let _: &mut (dyn core::fmt::Debug) = x.project().f; pin_project! { pub struct Struct2 { #[pin] f: T, } } let mut x = Struct2 { f: 0_u8 }; let x: Pin<&mut Struct2> = Pin::new(&mut x); let _: Pin<&mut (dyn core::fmt::Debug + Unpin)> = x.project().f; pin_project! { struct Struct3 where T: ?Sized, { f: T, } } pin_project! { struct Struct4 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 { type Y; } struct Struct1(A); impl Trait for Struct1 { type Y = Option; } pin_project! { struct Struct2 { _f: as Trait>::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 { type Error; } pin_project! { struct Struct3<'a, T, Request> where T: Service, T::Error: std::error::Error, { was_dropped: &'a mut bool, #[pin] field: T, req: Request, } /// dox1 impl PinnedDrop for Struct3<'_, T, Request> where T: Service, T::Error: std::error::Error, { /// dox2 fn drop(mut this: Pin<&mut Self>) { **this.as_mut().project().was_dropped = true; } } } } pin-project-lite-0.2.16/tests/ui/not_unpin/conflict-unpin.rs000064400000000000000000000010771046102023000221720ustar 00000000000000// SPDX-License-Identifier: Apache-2.0 OR MIT use pin_project_lite::pin_project; pin_project! { #[project(!Unpin)] struct Foo { #[pin] f1: T, f2: U, } } impl Unpin for Foo where T: Unpin {} pin_project! { #[project(!Unpin)] struct Bar { #[pin] f1: T, f2: U, } } impl Unpin for Bar {} pin_project! { #[project(!Unpin)] struct Baz { #[pin] f1: T, f2: U, } } impl Unpin for Baz {} fn main() {} pin-project-lite-0.2.16/tests/ui/not_unpin/conflict-unpin.stderr000064400000000000000000000046061046102023000230520ustar 00000000000000error[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 { 8 | | #[pin] ... | 12 | | } | |_^ conflicting implementation for `Foo<_, _>` 13 | 14 | impl Unpin for Foo 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 { 19 | | #[pin] ... | 23 | | } | |_^ conflicting implementation for `Bar<_, _>` 24 | 25 | impl Unpin for Bar {} | ------------------------------ 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 { 30 | | #[pin] ... | 34 | | } | |_^ conflicting implementation for `Baz<_, _>` 35 | 36 | impl Unpin for Baz {} | -------------------------------------------- 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) pin-project-lite-0.2.16/tests/ui/not_unpin/negative_impls_stable.rs000064400000000000000000000010341046102023000235730ustar 00000000000000// 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 { #[pin] pinned: Pinned, unpinned: Unpinned, } } struct MyPhantomPinned(::core::marker::PhantomPinned); impl Unpin for MyPhantomPinned where for<'cursed> str: Sized {} impl Unpin for Foo {} fn is_unpin() {} fn main() { is_unpin::>() } pin-project-lite-0.2.16/tests/ui/not_unpin/negative_impls_stable.stderr000064400000000000000000000015761046102023000244650ustar 00000000000000error[E0119]: conflicting implementations of trait `Unpin` for type `Foo` --> tests/ui/not_unpin/negative_impls_stable.rs:5:1 | 5 | / pin_project_lite::pin_project! { 6 | | #[project(!Unpin)] 7 | | struct Foo { 8 | | #[pin] ... | 12 | | } | |_^ conflicting implementation for `Foo` ... 16 | impl Unpin for Foo {} | --------------------------------------- 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) pin-project-lite-0.2.16/tests/ui/pin_project/conflict-drop.rs000064400000000000000000000004201046102023000222770ustar 00000000000000// SPDX-License-Identifier: Apache-2.0 OR MIT use pin_project_lite::pin_project; pin_project! { //~ ERROR E0119 struct Foo { #[pin] future: T, field: U, } } impl Drop for Foo { fn drop(&mut self) {} } fn main() {} pin-project-lite-0.2.16/tests/ui/pin_project/conflict-drop.stderr000064400000000000000000000011131046102023000231560ustar 00000000000000error[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 { 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) pin-project-lite-0.2.16/tests/ui/pin_project/conflict-unpin.rs000064400000000000000000000024431046102023000224730ustar 00000000000000// SPDX-License-Identifier: Apache-2.0 OR MIT use pin_project_lite::pin_project; // The same implementation. pin_project! { //~ ERROR E0119 struct Foo { #[pin] future: T, field: U, } } // conflicting implementations impl Unpin for Foo where T: Unpin {} // Conditional Unpin impl // The implementation that under different conditions. pin_project! { //~ ERROR E0119 struct Bar { #[pin] future: T, field: U, } } // conflicting implementations impl Unpin for Bar {} // Non-conditional Unpin impl pin_project! { //~ ERROR E0119 struct Baz { #[pin] future: T, field: U, } } // conflicting implementations impl Unpin for Baz {} // Conditional Unpin impl pin_project! { //~ ERROR E0119 #[project(!Unpin)] struct Qux { #[pin] future: T, field: U, } } // conflicting implementations impl Unpin for Qux {} // Non-conditional Unpin impl pin_project! { //~ ERROR E0119 #[project(!Unpin)] struct Fred { #[pin] future: T, field: U, } } // conflicting implementations impl Unpin for Fred {} // Conditional Unpin impl fn main() {} pin-project-lite-0.2.16/tests/ui/pin_project/conflict-unpin.stderr000064400000000000000000000072741046102023000233610ustar 00000000000000error[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 { 9 | | #[pin] 10 | | future: T, ... | 13 | | } | |_^ conflicting implementation for `Foo<_, _>` ... 16 | impl Unpin for Foo 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 { 22 | | #[pin] 23 | | future: T, ... | 26 | | } | |_^ conflicting implementation for `Bar<_, _>` ... 29 | impl Unpin for Bar {} // 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 { 33 | | #[pin] 34 | | future: T, ... | 37 | | } | |_^ conflicting implementation for `Baz<_, _>` ... 40 | impl Unpin for Baz {} // 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 { 45 | | #[pin] ... | 49 | | } | |_^ conflicting implementation for `Qux<_, _>` ... 52 | impl Unpin for Qux {} // 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 { 57 | | #[pin] ... | 61 | | } | |_^ conflicting implementation for `Fred<_, _>` ... 64 | impl Unpin for Fred {} // 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) pin-project-lite-0.2.16/tests/ui/pin_project/invalid-bounds.rs000064400000000000000000000035631046102023000224650ustar 00000000000000// SPDX-License-Identifier: Apache-2.0 OR MIT use pin_project_lite::pin_project; pin_project! { struct Generics1 { //~ ERROR no rules expected the token `:` field: T, } } pin_project! { struct Generics2 { //~ ERROR no rules expected the token `:` field: T, } } pin_project! { struct Generics3 { //~ ERROR expected one of `+`, `,`, `=`, or `>`, found `:` field: T, } } pin_project! { struct Generics4 { //~ ERROR expected one of `+`, `,`, `=`, or `>`, found `:` field: T, } } pin_project! { struct Generics5 { //~ ERROR expected one of `+`, `,`, `=`, or `>`, found `:` field: T, } } pin_project! { struct Generics6 { //~ ERROR no rules expected the token `Sized` field: T, } } pin_project! { struct WhereClause1 where T: 'static : Sized //~ ERROR no rules expected the token `:` { field: T, } } pin_project! { struct WhereClause2 where T: 'static : ?Sized //~ ERROR no rules expected the token `:` { field: T, } } pin_project! { struct WhereClause3 where T: Sized : 'static //~ ERROR expected `where`, or `{` after struct name, found `:` { field: T, } } pin_project! { struct WhereClause4 where T: ?Sized : 'static //~ ERROR expected `where`, or `{` after struct name, found `:` { field: T, } } pin_project! { struct WhereClause5 where T: Sized : ?Sized //~ ERROR expected `where`, or `{` after struct name, found `:` { field: T, } } pin_project! { struct WhereClause6 where T: ?Sized : Sized //~ ERROR no rules expected the token `Sized` { field: T, } } fn main() {} pin-project-lite-0.2.16/tests/ui/pin_project/invalid-bounds.stderr000064400000000000000000000462361046102023000233500ustar 00000000000000error: no rules expected `:` --> tests/ui/pin_project/invalid-bounds.rs:6:33 | 6 | struct Generics1 { //~ 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 { //~ 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 { //~ 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 { //~ 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 = 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 { //~ 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 { //~ 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 { //~ 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 { //~ 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 = 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 { //~ 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 { //~ 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 { //~ 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 { //~ 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 = 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 { //~ 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 { //~ 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 { //~ 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 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 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 = 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 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 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 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 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 = 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 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 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 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 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 = 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 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 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)? | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ pin-project-lite-0.2.16/tests/ui/pin_project/invalid.rs000064400000000000000000000007311046102023000211670ustar 00000000000000// SPDX-License-Identifier: Apache-2.0 OR MIT use pin_project_lite::pin_project; pin_project! { struct A { #[pin()] //~ ERROR no rules expected the token `(` pinned: T, } } pin_project! { #[pin] //~ ERROR cannot find attribute `pin` in this scope struct B { pinned: T, } } pin_project! { struct C { #[pin] #[pin] //~ ERROR no rules expected the token `#` pinned: T, } } fn main() {} pin-project-lite-0.2.16/tests/ui/pin_project/invalid.stderr000064400000000000000000000031101046102023000220400ustar 00000000000000error: 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 | ^^^ pin-project-lite-0.2.16/tests/ui/pin_project/negative_impls_stable.rs000064400000000000000000000010051046102023000240740ustar 00000000000000// 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 { #[pin] pinned: Pinned, unpinned: Unpinned, } } struct MyPhantomPinned(::core::marker::PhantomPinned); impl Unpin for MyPhantomPinned where for<'cursed> str: Sized {} impl Unpin for Foo {} fn is_unpin() {} fn main() { is_unpin::>() } pin-project-lite-0.2.16/tests/ui/pin_project/negative_impls_stable.stderr000064400000000000000000000013331046102023000247570ustar 00000000000000error[E0119]: conflicting implementations of trait `Unpin` for type `Foo` --> tests/ui/pin_project/negative_impls_stable.rs:5:1 | 5 | / pin_project_lite::pin_project! { 6 | | struct Foo { 7 | | #[pin] 8 | | pinned: Pinned, ... | 11 | | } | |_^ conflicting implementation for `Foo` ... 15 | impl Unpin for Foo {} | --------------------------------------- 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) pin-project-lite-0.2.16/tests/ui/pin_project/overlapping_lifetime_names.rs000064400000000000000000000003331046102023000251260ustar 00000000000000// 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() {} pin-project-lite-0.2.16/tests/ui/pin_project/overlapping_lifetime_names.stderr000064400000000000000000000055571046102023000260220ustar 00000000000000error[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` pin-project-lite-0.2.16/tests/ui/pin_project/overlapping_unpin_struct.rs000064400000000000000000000005211046102023000247010ustar 00000000000000// SPDX-License-Identifier: Apache-2.0 OR MIT use std::marker::PhantomPinned; use pin_project_lite::pin_project; pin_project! { struct Foo { #[pin] inner: T, } } struct __Origin {} impl Unpin for __Origin {} fn is_unpin() {} fn main() { is_unpin::>(); //~ ERROR E0277 } pin-project-lite-0.2.16/tests/ui/pin_project/overlapping_unpin_struct.stderr000064400000000000000000000026361046102023000255710ustar 00000000000000error[E0277]: `PhantomPinned` cannot be unpinned --> tests/ui/pin_project/overlapping_unpin_struct.rs:21:16 | 21 | is_unpin::>(); //~ 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 { 9 | | #[pin] 10 | | inner: T, 11 | | } 12 | | } | |_^ note: required for `Foo` to implement `Unpin` --> tests/ui/pin_project/overlapping_unpin_struct.rs:7:1 | 7 | / pin_project! { 8 | | struct Foo { 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() {} | ^^^^^ 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) pin-project-lite-0.2.16/tests/ui/pin_project/packed.rs000064400000000000000000000006171046102023000207730ustar 00000000000000// 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() {} pin-project-lite-0.2.16/tests/ui/pin_project/packed.stderr000064400000000000000000000130671046102023000216550ustar 00000000000000error[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) pin-project-lite-0.2.16/tests/ui/pin_project/unpin_sneaky.rs000064400000000000000000000003351046102023000222440ustar 00000000000000// 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() {} pin-project-lite-0.2.16/tests/ui/pin_project/unpin_sneaky.stderr000064400000000000000000000003311046102023000231170ustar 00000000000000error[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 pin-project-lite-0.2.16/tests/ui/pin_project/unsupported.rs000064400000000000000000000010361046102023000221300ustar 00000000000000// 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() {} pin-project-lite-0.2.16/tests/ui/pin_project/unsupported.stderr000064400000000000000000000071171046102023000230150ustar 00000000000000error: 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) pin-project-lite-0.2.16/tests/ui/pinned_drop/call-drop-inner.rs000064400000000000000000000004771046102023000225230ustar 00000000000000// 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 }; } pin-project-lite-0.2.16/tests/ui/pinned_drop/call-drop-inner.stderr000064400000000000000000000014041046102023000233710ustar 00000000000000error[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(); | pin-project-lite-0.2.16/tests/ui/pinned_drop/conditional-drop-impl.rs000064400000000000000000000010041046102023000237240ustar 00000000000000// 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 { f: T, } impl Drop for DropImpl { //~^ ERROR E0367 fn drop(&mut self) {} } pin_project! { //~^ ERROR E0367 struct PinnedDropImpl { #[pin] f: T, } impl PinnedDrop for PinnedDropImpl { fn drop(_this: Pin<&mut Self>) {} } } fn main() {} pin-project-lite-0.2.16/tests/ui/pinned_drop/conditional-drop-impl.stderr000064400000000000000000000021661046102023000246150ustar 00000000000000error[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 Drop for DropImpl { | ^^^^^ | note: the implementor must specify the same requirement --> tests/ui/pinned_drop/conditional-drop-impl.rs:7:1 | 7 | struct DropImpl { | ^^^^^^^^^^^^^^^^^^ 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 { 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 { 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)