1 // Check interoperability with rustc and clippy lints. 2 3 // for old compilers 4 #![allow(unknown_lints)] 5 #![warn(nonstandard_style, rust_2018_idioms, unused)] 6 // Note: This does not guarantee compatibility with forbidding these lints in the future. 7 // If rustc adds a new lint, we may not be able to keep this. 8 #![forbid(future_incompatible, rust_2018_compatibility, rust_2021_compatibility)] 9 // lints forbidden as a part of future_incompatible, rust_2018_compatibility, and rust_2021_compatibility are not included in the list below. 10 // elided_lifetimes_in_paths, explicit_outlives_requirements, unused_extern_crates: as a part of rust_2018_idioms 11 // unsafe_op_in_unsafe_fn: requires Rust 1.52. and, we don't generate unsafe fn. 12 // non_exhaustive_omitted_patterns: unstable 13 // unstable_features: no way to generate #![feature(..)] by macros, expect for unstable inner attribute. and this lint is deprecated: https://doc.rust-lang.org/rustc/lints/listing/allowed-by-default.html#unstable-features 14 // unused_crate_dependencies, must_not_suspend: unrelated 15 // unsafe_code: checked in forbid_unsafe module 16 #![warn( 17 box_pointers, 18 deprecated_in_future, 19 fuzzy_provenance_casts, 20 lossy_provenance_casts, 21 macro_use_extern_crate, 22 meta_variable_misuse, 23 missing_abi, 24 missing_copy_implementations, 25 missing_debug_implementations, 26 missing_docs, 27 non_ascii_idents, 28 noop_method_call, 29 single_use_lifetimes, 30 trivial_casts, 31 trivial_numeric_casts, 32 unreachable_pub, 33 unused_import_braces, 34 unused_lifetimes, 35 unused_qualifications, 36 unused_results, 37 unused_tuple_struct_fields, 38 variant_size_differences 39 )] 40 #![warn(clippy::all, clippy::pedantic, clippy::nursery, clippy::restriction)] 41 #![allow(clippy::blanket_clippy_restriction_lints)] // this is a test, so enable all restriction lints intentionally. 42 #![allow(clippy::exhaustive_structs, clippy::exhaustive_enums, clippy::single_char_lifetime_names)] // TODO 43 44 pub mod basic { 45 include!("include/basic.rs"); 46 47 pub mod inside_macro { 48 #[rustfmt::skip] 49 macro_rules! mac { 50 () => { 51 #[::pin_project::pin_project] 52 #[derive(Debug)] 53 pub struct DefaultStruct<T, U> { 54 #[pin] 55 pub pinned: T, 56 pub unpinned: U, 57 } 58 59 #[::pin_project::pin_project( 60 project = DefaultStructNamedProj, 61 project_ref = DefaultStructNamedProjRef, 62 )] 63 #[derive(Debug)] 64 pub struct DefaultStructNamed<T, U> { 65 #[pin] 66 pub pinned: T, 67 pub unpinned: U, 68 } 69 70 #[::pin_project::pin_project] 71 #[derive(Debug)] 72 pub struct DefaultTupleStruct<T, U>(#[pin] pub T, pub U); 73 74 #[::pin_project::pin_project( 75 project = DefaultTupleStructNamedProj, 76 project_ref = DefaultTupleStructNamedProjRef, 77 )] 78 #[derive(Debug)] 79 pub struct DefaultTupleStructNamed<T, U>(#[pin] pub T, pub U); 80 81 #[::pin_project::pin_project( 82 project = DefaultEnumProj, 83 project_ref = DefaultEnumProjRef, 84 )] 85 #[derive(Debug)] 86 pub enum DefaultEnum<T, U> { 87 Struct { 88 #[pin] 89 pinned: T, 90 unpinned: U, 91 }, 92 Tuple(#[pin] T, U), 93 Unit, 94 } 95 96 #[::pin_project::pin_project(PinnedDrop)] 97 #[derive(Debug)] 98 pub struct PinnedDropStruct<T, U> { 99 #[pin] 100 pub pinned: T, 101 pub unpinned: U, 102 } 103 104 #[::pin_project::pinned_drop] 105 impl<T, U> PinnedDrop for PinnedDropStruct<T, U> { 106 fn drop(self: ::pin_project::__private::Pin<&mut Self>) {} 107 } 108 109 #[::pin_project::pin_project(PinnedDrop)] 110 #[derive(Debug)] 111 pub struct PinnedDropTupleStruct<T, U>(#[pin] pub T, pub U); 112 113 #[::pin_project::pinned_drop] 114 impl<T, U> PinnedDrop for PinnedDropTupleStruct<T, U> { 115 fn drop(self: ::pin_project::__private::Pin<&mut Self>) {} 116 } 117 118 #[::pin_project::pin_project( 119 PinnedDrop, 120 project = PinnedDropEnumProj, 121 project_ref = PinnedDropEnumProjRef, 122 )] 123 #[derive(Debug)] 124 pub enum PinnedDropEnum<T, U> { 125 Struct { 126 #[pin] 127 pinned: T, 128 unpinned: U, 129 }, 130 Tuple(#[pin] T, U), 131 Unit, 132 } 133 134 #[::pin_project::pinned_drop] 135 impl<T, U> PinnedDrop for PinnedDropEnum<T, U> { 136 fn drop(self: ::pin_project::__private::Pin<&mut Self>) {} 137 } 138 139 #[::pin_project::pin_project(project_replace)] 140 #[derive(Debug)] 141 pub struct ReplaceStruct<T, U> { 142 #[pin] 143 pub pinned: T, 144 pub unpinned: U, 145 } 146 147 #[::pin_project::pin_project( 148 project = ReplaceStructNamedProj, 149 project_ref = ReplaceStructNamedProjRef, 150 project_replace = ReplaceStructNamedProjOwn, 151 )] 152 #[derive(Debug)] 153 pub struct ReplaceStructNamed<T, U> { 154 #[pin] 155 pub pinned: T, 156 pub unpinned: U, 157 } 158 159 #[::pin_project::pin_project(project_replace)] 160 #[derive(Debug)] 161 pub struct ReplaceTupleStruct<T, U>(#[pin] pub T, pub U); 162 163 #[::pin_project::pin_project( 164 project = ReplaceTupleStructNamedProj, 165 project_ref = ReplaceTupleStructNamedProjRef, 166 project_replace = ReplaceTupleStructNamedProjOwn, 167 )] 168 #[derive(Debug)] 169 pub struct ReplaceTupleStructNamed<T, U>(#[pin] pub T, pub U); 170 171 #[::pin_project::pin_project( 172 project = ReplaceEnumProj, 173 project_ref = ReplaceEnumProjRef, 174 project_replace = ReplaceEnumProjOwn, 175 )] 176 #[derive(Debug)] 177 pub enum ReplaceEnum<T, U> { 178 Struct { 179 #[pin] 180 pinned: T, 181 unpinned: U, 182 }, 183 Tuple(#[pin] T, U), 184 Unit, 185 } 186 187 #[::pin_project::pin_project(UnsafeUnpin)] 188 #[derive(Debug)] 189 pub struct UnsafeUnpinStruct<T, U> { 190 #[pin] 191 pub pinned: T, 192 pub unpinned: U, 193 } 194 195 #[::pin_project::pin_project(UnsafeUnpin)] 196 #[derive(Debug)] 197 pub struct UnsafeUnpinTupleStruct<T, U>(#[pin] pub T, pub U); 198 199 #[::pin_project::pin_project( 200 UnsafeUnpin, 201 project = UnsafeUnpinEnumProj, 202 project_ref = UnsafeUnpinEnumProjRef, 203 )] 204 #[derive(Debug)] 205 pub enum UnsafeUnpinEnum<T, U> { 206 Struct { 207 #[pin] 208 pinned: T, 209 unpinned: U, 210 }, 211 Tuple(#[pin] T, U), 212 Unit, 213 } 214 215 #[::pin_project::pin_project(!Unpin)] 216 #[derive(Debug)] 217 pub struct NotUnpinStruct<T, U> { 218 #[pin] 219 pub pinned: T, 220 pub unpinned: U, 221 } 222 223 #[::pin_project::pin_project(!Unpin)] 224 #[derive(Debug)] 225 pub struct NotUnpinTupleStruct<T, U>(#[pin] pub T, pub U); 226 227 #[::pin_project::pin_project( 228 !Unpin, 229 project = NotUnpinEnumProj, 230 project_ref = NotUnpinEnumProjRef, 231 )] 232 #[derive(Debug)] 233 pub enum NotUnpinEnum<T, U> { 234 Struct { 235 #[pin] 236 pinned: T, 237 unpinned: U, 238 }, 239 Tuple(#[pin] T, U), 240 Unit, 241 } 242 243 #[allow(clippy::undocumented_unsafe_blocks)] 244 unsafe impl<T: ::pin_project::__private::Unpin, U: ::pin_project::__private::Unpin> 245 ::pin_project::UnsafeUnpin for UnsafeUnpinStruct<T, U> 246 { 247 } 248 #[allow(clippy::undocumented_unsafe_blocks)] 249 unsafe impl<T: ::pin_project::__private::Unpin, U: ::pin_project::__private::Unpin> 250 ::pin_project::UnsafeUnpin for UnsafeUnpinTupleStruct<T, U> 251 { 252 } 253 #[allow(clippy::undocumented_unsafe_blocks)] 254 unsafe impl<T: ::pin_project::__private::Unpin, U: ::pin_project::__private::Unpin> 255 ::pin_project::UnsafeUnpin for UnsafeUnpinEnum<T, U> 256 { 257 } 258 }; 259 } 260 261 mac!(); 262 } 263 } 264 265 pub mod forbid_unsafe { 266 #![forbid(unsafe_code)] 267 268 include!("include/basic-safe-part.rs"); 269 270 pub mod inside_macro { 271 #[rustfmt::skip] 272 macro_rules! mac { 273 () => { 274 #[::pin_project::pin_project] 275 #[derive(Debug)] 276 pub struct DefaultStruct<T, U> { 277 #[pin] 278 pub pinned: T, 279 pub unpinned: U, 280 } 281 282 #[::pin_project::pin_project( 283 project = DefaultStructNamedProj, 284 project_ref = DefaultStructNamedProjRef, 285 )] 286 #[derive(Debug)] 287 pub struct DefaultStructNamed<T, U> { 288 #[pin] 289 pub pinned: T, 290 pub unpinned: U, 291 } 292 293 #[::pin_project::pin_project] 294 #[derive(Debug)] 295 pub struct DefaultTupleStruct<T, U>(#[pin] pub T, pub U); 296 297 #[::pin_project::pin_project( 298 project = DefaultTupleStructNamedProj, 299 project_ref = DefaultTupleStructNamedProjRef, 300 )] 301 #[derive(Debug)] 302 pub struct DefaultTupleStructNamed<T, U>(#[pin] pub T, pub U); 303 304 #[::pin_project::pin_project( 305 project = DefaultEnumProj, 306 project_ref = DefaultEnumProjRef, 307 )] 308 #[derive(Debug)] 309 pub enum DefaultEnum<T, U> { 310 Struct { 311 #[pin] 312 pinned: T, 313 unpinned: U, 314 }, 315 Tuple(#[pin] T, U), 316 Unit, 317 } 318 319 #[::pin_project::pin_project(PinnedDrop)] 320 #[derive(Debug)] 321 pub struct PinnedDropStruct<T, U> { 322 #[pin] 323 pub pinned: T, 324 pub unpinned: U, 325 } 326 327 #[::pin_project::pinned_drop] 328 impl<T, U> PinnedDrop for PinnedDropStruct<T, U> { 329 fn drop(self: ::pin_project::__private::Pin<&mut Self>) {} 330 } 331 332 #[::pin_project::pin_project(PinnedDrop)] 333 #[derive(Debug)] 334 pub struct PinnedDropTupleStruct<T, U>(#[pin] pub T, pub U); 335 336 #[::pin_project::pinned_drop] 337 impl<T, U> PinnedDrop for PinnedDropTupleStruct<T, U> { 338 fn drop(self: ::pin_project::__private::Pin<&mut Self>) {} 339 } 340 341 #[::pin_project::pin_project( 342 PinnedDrop, 343 project = PinnedDropEnumProj, 344 project_ref = PinnedDropEnumProjRef, 345 )] 346 #[derive(Debug)] 347 pub enum PinnedDropEnum<T, U> { 348 Struct { 349 #[pin] 350 pinned: T, 351 unpinned: U, 352 }, 353 Tuple(#[pin] T, U), 354 Unit, 355 } 356 357 #[::pin_project::pinned_drop] 358 impl<T, U> PinnedDrop for PinnedDropEnum<T, U> { 359 fn drop(self: ::pin_project::__private::Pin<&mut Self>) {} 360 } 361 362 #[::pin_project::pin_project(project_replace)] 363 #[derive(Debug)] 364 pub struct ReplaceStruct<T, U> { 365 #[pin] 366 pub pinned: T, 367 pub unpinned: U, 368 } 369 370 #[::pin_project::pin_project( 371 project = ReplaceStructNamedProj, 372 project_ref = ReplaceStructNamedProjRef, 373 project_replace = ReplaceStructNamedProjOwn, 374 )] 375 #[derive(Debug)] 376 pub struct ReplaceStructNamed<T, U> { 377 #[pin] 378 pub pinned: T, 379 pub unpinned: U, 380 } 381 382 #[::pin_project::pin_project(project_replace)] 383 #[derive(Debug)] 384 pub struct ReplaceTupleStruct<T, U>(#[pin] pub T, pub U); 385 386 #[::pin_project::pin_project( 387 project = ReplaceTupleStructNamedProj, 388 project_ref = ReplaceTupleStructNamedProjRef, 389 project_replace = ReplaceTupleStructNamedProjOwn, 390 )] 391 #[derive(Debug)] 392 pub struct ReplaceTupleStructNamed<T, U>(#[pin] pub T, pub U); 393 394 #[::pin_project::pin_project( 395 project = ReplaceEnumProj, 396 project_ref = ReplaceEnumProjRef, 397 project_replace = ReplaceEnumProjOwn, 398 )] 399 #[derive(Debug)] 400 pub enum ReplaceEnum<T, U> { 401 Struct { 402 #[pin] 403 pinned: T, 404 unpinned: U, 405 }, 406 Tuple(#[pin] T, U), 407 Unit, 408 } 409 410 #[::pin_project::pin_project(UnsafeUnpin)] 411 #[derive(Debug)] 412 pub struct UnsafeUnpinStruct<T, U> { 413 #[pin] 414 pub pinned: T, 415 pub unpinned: U, 416 } 417 418 #[::pin_project::pin_project(UnsafeUnpin)] 419 #[derive(Debug)] 420 pub struct UnsafeUnpinTupleStruct<T, U>(#[pin] pub T, pub U); 421 422 #[::pin_project::pin_project( 423 UnsafeUnpin, 424 project = UnsafeUnpinEnumProj, 425 project_ref = UnsafeUnpinEnumProjRef, 426 )] 427 #[derive(Debug)] 428 pub enum UnsafeUnpinEnum<T, U> { 429 Struct { 430 #[pin] 431 pinned: T, 432 unpinned: U, 433 }, 434 Tuple(#[pin] T, U), 435 Unit, 436 } 437 438 #[::pin_project::pin_project(!Unpin)] 439 #[derive(Debug)] 440 pub struct NotUnpinStruct<T, U> { 441 #[pin] 442 pub pinned: T, 443 pub unpinned: U, 444 } 445 446 #[::pin_project::pin_project(!Unpin)] 447 #[derive(Debug)] 448 pub struct NotUnpinTupleStruct<T, U>(#[pin] pub T, pub U); 449 450 #[::pin_project::pin_project( 451 !Unpin, 452 project = NotUnpinEnumProj, 453 project_ref = NotUnpinEnumProjRef, 454 )] 455 #[derive(Debug)] 456 pub enum NotUnpinEnum<T, U> { 457 Struct { 458 #[pin] 459 pinned: T, 460 unpinned: U, 461 }, 462 Tuple(#[pin] T, U), 463 Unit, 464 } 465 }; 466 } 467 468 mac!(); 469 } 470 } 471 472 pub mod box_pointers { 473 use pin_project::pin_project; 474 475 #[allow(box_pointers)] // for the type itself 476 #[pin_project(project_replace)] 477 #[derive(Debug)] 478 pub struct Struct { 479 #[pin] 480 pub p: Box<isize>, 481 pub u: Box<isize>, 482 } 483 484 #[allow(box_pointers)] // for the type itself 485 #[pin_project(project_replace)] 486 #[derive(Debug)] 487 pub struct TupleStruct(#[pin] pub Box<isize>, pub Box<isize>); 488 489 #[allow(box_pointers)] // for the type itself 490 #[pin_project( 491 project = EnumProj, 492 project_ref = EnumProjRef, 493 project_replace = EnumProjOwn, 494 )] 495 #[derive(Debug)] 496 pub enum Enum { 497 Struct { 498 #[pin] 499 p: Box<isize>, 500 u: Box<isize>, 501 }, 502 Tuple(#[pin] Box<isize>, Box<isize>), 503 Unit, 504 } 505 506 pub mod inside_macro { 507 use pin_project::pin_project; 508 509 #[rustfmt::skip] 510 macro_rules! mac { 511 () => { 512 #[allow(box_pointers)] // for the type itself 513 #[pin_project(project_replace)] 514 #[derive(Debug)] 515 pub struct Struct { 516 #[pin] 517 pub p: Box<isize>, 518 pub u: Box<isize>, 519 } 520 521 #[allow(box_pointers)] // for the type itself 522 #[pin_project(project_replace)] 523 #[derive(Debug)] 524 pub struct TupleStruct(#[pin] pub Box<isize>, pub Box<isize>); 525 526 #[allow(box_pointers)] // for the type itself 527 #[pin_project( 528 project = EnumProj, 529 project_ref = EnumProjRef, 530 project_replace = EnumProjOwn, 531 )] 532 #[derive(Debug)] 533 pub enum Enum { 534 Struct { 535 #[pin] 536 p: Box<isize>, 537 u: Box<isize>, 538 }, 539 Tuple(#[pin] Box<isize>, Box<isize>), 540 Unit, 541 } 542 }; 543 } 544 545 mac!(); 546 } 547 } 548 549 pub mod deprecated { 550 use pin_project::pin_project; 551 552 #[allow(deprecated)] // for the type itself 553 #[pin_project(project_replace)] 554 #[derive(Debug, Clone, Copy)] 555 #[deprecated] 556 pub struct Struct { 557 #[deprecated] 558 #[pin] 559 pub p: (), 560 #[deprecated] 561 pub u: (), 562 } 563 564 #[allow(deprecated)] // for the type itself 565 #[pin_project(project_replace)] 566 #[derive(Debug, Clone, Copy)] 567 #[deprecated] 568 pub struct TupleStruct( 569 #[deprecated] 570 #[pin] 571 pub (), 572 #[deprecated] pub (), 573 ); 574 575 #[allow(deprecated)] // for the type itself 576 #[pin_project( 577 project = EnumProj, 578 project_ref = EnumProjRef, 579 project_replace = EnumProjOwn, 580 )] 581 #[derive(Debug, Clone, Copy)] 582 #[deprecated] 583 pub enum Enum { 584 #[deprecated] 585 Struct { 586 #[deprecated] 587 #[pin] 588 p: (), 589 #[deprecated] 590 u: (), 591 }, 592 #[deprecated] 593 Tuple( 594 #[deprecated] 595 #[pin] 596 (), 597 #[deprecated] (), 598 ), 599 #[deprecated] 600 Unit, 601 } 602 603 pub mod inside_macro { 604 use pin_project::pin_project; 605 606 #[rustfmt::skip] 607 macro_rules! mac { 608 () => { 609 #[allow(deprecated)] // for the type itself 610 #[pin_project(project_replace)] 611 #[derive(Debug, Clone, Copy)] 612 #[deprecated] 613 pub struct Struct { 614 #[deprecated] 615 #[pin] 616 pub p: (), 617 #[deprecated] 618 pub u: (), 619 } 620 621 #[allow(deprecated)] // for the type itself 622 #[pin_project(project_replace)] 623 #[derive(Debug, Clone, Copy)] 624 #[deprecated] 625 pub struct TupleStruct( 626 #[deprecated] 627 #[pin] 628 pub (), 629 #[deprecated] pub (), 630 ); 631 632 #[allow(deprecated)] // for the type itself 633 #[pin_project( 634 project = EnumProj, 635 project_ref = EnumProjRef, 636 project_replace = EnumProjOwn, 637 )] 638 #[derive(Debug, Clone, Copy)] 639 #[deprecated] 640 pub enum Enum { 641 #[deprecated] 642 Struct { 643 #[deprecated] 644 #[pin] 645 p: (), 646 #[deprecated] 647 u: (), 648 }, 649 #[deprecated] 650 Tuple( 651 #[deprecated] 652 #[pin] 653 (), 654 #[deprecated] (), 655 ), 656 #[deprecated] 657 Unit, 658 } 659 }; 660 } 661 662 mac!(); 663 } 664 } 665 666 pub mod explicit_outlives_requirements { 667 use pin_project::pin_project; 668 669 #[allow(explicit_outlives_requirements)] // for the type itself: https://github.com/rust-lang/rust/issues/60993 670 #[pin_project(project_replace)] 671 #[derive(Debug)] 672 pub struct Struct<'a, T, U> 673 where 674 T: ?Sized, 675 U: ?Sized, 676 { 677 #[pin] 678 pub pinned: &'a mut T, 679 pub unpinned: &'a mut U, 680 } 681 682 #[allow(explicit_outlives_requirements)] // for the type itself: https://github.com/rust-lang/rust/issues/60993 683 #[pin_project(project_replace)] 684 #[derive(Debug)] 685 pub struct TupleStruct<'a, T, U>(#[pin] pub &'a mut T, pub &'a mut U) 686 where 687 T: ?Sized, 688 U: ?Sized; 689 690 #[allow(explicit_outlives_requirements)] // for the type itself: https://github.com/rust-lang/rust/issues/60993 691 #[pin_project( 692 project = EnumProj, 693 project_ref = EnumProjRef, 694 project_replace = EnumProjOwn, 695 )] 696 #[derive(Debug)] 697 pub enum Enum<'a, T, U> 698 where 699 T: ?Sized, 700 U: ?Sized, 701 { 702 Struct { 703 #[pin] 704 pinned: &'a mut T, 705 unpinned: &'a mut U, 706 }, 707 Tuple(#[pin] &'a mut T, &'a mut U), 708 Unit, 709 } 710 711 pub mod inside_macro { 712 use pin_project::pin_project; 713 714 #[rustfmt::skip] 715 macro_rules! mac { 716 () => { 717 #[allow(explicit_outlives_requirements)] // for the type itself: https://github.com/rust-lang/rust/issues/60993 718 #[pin_project(project_replace)] 719 #[derive(Debug)] 720 pub struct Struct<'a, T, U> 721 where 722 T: ?Sized, 723 U: ?Sized, 724 { 725 #[pin] 726 pub pinned: &'a mut T, 727 pub unpinned: &'a mut U, 728 } 729 730 #[allow(explicit_outlives_requirements)] // for the type itself: https://github.com/rust-lang/rust/issues/60993 731 #[pin_project(project_replace)] 732 #[derive(Debug)] 733 pub struct TupleStruct<'a, T, U>(#[pin] pub &'a mut T, pub &'a mut U) 734 where 735 T: ?Sized, 736 U: ?Sized; 737 738 #[allow(explicit_outlives_requirements)] // for the type itself: https://github.com/rust-lang/rust/issues/60993 739 #[pin_project( 740 project = EnumProj, 741 project_ref = EnumProjRef, 742 project_replace = EnumProjOwn, 743 )] 744 #[derive(Debug)] 745 pub enum Enum<'a, T, U> 746 where 747 T: ?Sized, 748 U: ?Sized, 749 { 750 Struct { 751 #[pin] 752 pinned: &'a mut T, 753 unpinned: &'a mut U, 754 }, 755 Tuple(#[pin] &'a mut T, &'a mut U), 756 Unit, 757 } 758 }; 759 } 760 761 mac!(); 762 } 763 } 764 765 #[allow(missing_debug_implementations)] 766 pub mod single_use_lifetimes { 767 use pin_project::pin_project; 768 769 #[allow(unused_lifetimes)] 770 pub trait Trait<'a> {} 771 772 #[allow(unused_lifetimes)] // for the type itself 773 #[allow(single_use_lifetimes)] // for the type itself: https://github.com/rust-lang/rust/issues/55058 774 #[pin_project(project_replace)] 775 pub struct Hrtb<'pin___, T> 776 where 777 for<'pin> &'pin T: Unpin, 778 T: for<'pin> Trait<'pin>, 779 for<'pin, 'pin_, 'pin__> &'pin &'pin_ &'pin__ T: Unpin, 780 { 781 #[pin] 782 _f: &'pin___ mut T, 783 } 784 785 pub mod inside_macro { 786 use pin_project::pin_project; 787 788 #[rustfmt::skip] 789 macro_rules! mac { 790 () => { 791 #[allow(unused_lifetimes)] 792 pub trait Trait<'a> {} 793 794 #[allow(unused_lifetimes)] // for the type itself 795 #[allow(single_use_lifetimes)] // for the type itself: https://github.com/rust-lang/rust/issues/55058 796 #[pin_project(project_replace)] 797 pub struct Hrtb<'pin___, T> 798 where 799 for<'pin> &'pin T: Unpin, 800 T: for<'pin> Trait<'pin>, 801 for<'pin, 'pin_, 'pin__> &'pin &'pin_ &'pin__ T: Unpin, 802 { 803 #[pin] 804 _f: &'pin___ mut T, 805 } 806 }; 807 } 808 809 mac!(); 810 } 811 } 812 813 pub mod variant_size_differences { 814 use pin_project::pin_project; 815 816 #[allow(missing_debug_implementations, missing_copy_implementations)] // https://github.com/rust-lang/rust/pull/74060 817 #[allow(variant_size_differences)] // for the type itself 818 #[allow(clippy::large_enum_variant)] // for the type itself 819 #[pin_project( 820 project = EnumProj, 821 project_ref = EnumProjRef, 822 project_replace = EnumProjOwn, 823 )] 824 pub enum Enum { 825 V1(u8), 826 V2([u8; 1024]), 827 } 828 829 pub mod inside_macro { 830 use pin_project::pin_project; 831 832 #[rustfmt::skip] 833 macro_rules! mac { 834 () => { 835 #[allow(missing_debug_implementations, missing_copy_implementations)] // https://github.com/rust-lang/rust/pull/74060 836 #[allow(variant_size_differences)] // for the type itself 837 #[allow(clippy::large_enum_variant)] // for the type itself 838 #[pin_project( 839 project = EnumProj, 840 project_ref = EnumProjRef, 841 project_replace = EnumProjOwn, 842 )] 843 pub enum Enum { 844 V1(u8), 845 V2([u8; 1024]), 846 } 847 }; 848 } 849 850 mac!(); 851 } 852 } 853 854 pub mod clippy_mut_mut { 855 use pin_project::pin_project; 856 857 #[pin_project(project_replace)] 858 #[derive(Debug)] 859 pub struct Struct<'a, T, U> { 860 #[pin] 861 pub pinned: &'a mut T, 862 pub unpinned: &'a mut U, 863 } 864 865 #[pin_project(project_replace)] 866 #[derive(Debug)] 867 pub struct TupleStruct<'a, T, U>(#[pin] &'a mut T, &'a mut U); 868 869 #[pin_project( 870 project = EnumProj, 871 project_ref = EnumProjRef, 872 project_replace = EnumProjOwn, 873 )] 874 #[derive(Debug)] 875 pub enum Enum<'a, T, U> { 876 Struct { 877 #[pin] 878 pinned: &'a mut T, 879 unpinned: &'a mut U, 880 }, 881 Tuple(#[pin] &'a mut T, &'a mut U), 882 Unit, 883 } 884 885 pub mod inside_macro { 886 use pin_project::pin_project; 887 888 #[rustfmt::skip] 889 macro_rules! mac { 890 () => { 891 #[pin_project(project_replace)] 892 #[derive(Debug)] 893 pub struct Struct<'a, T, U> { 894 #[pin] 895 pub pinned: &'a mut T, 896 pub unpinned: &'a mut U, 897 } 898 899 #[pin_project(project_replace)] 900 #[derive(Debug)] 901 pub struct TupleStruct<'a, T, U>(#[pin] &'a mut T, &'a mut U); 902 903 #[pin_project( 904 project = EnumProj, 905 project_ref = EnumProjRef, 906 project_replace = EnumProjOwn, 907 )] 908 #[derive(Debug)] 909 pub enum Enum<'a, T, U> { 910 Struct { 911 #[pin] 912 pinned: &'a mut T, 913 unpinned: &'a mut U, 914 }, 915 Tuple(#[pin] &'a mut T, &'a mut U), 916 Unit, 917 } 918 }; 919 } 920 921 mac!(); 922 } 923 } 924 925 #[allow(missing_debug_implementations)] 926 #[allow(unreachable_pub)] 927 mod clippy_redundant_pub_crate { 928 use pin_project::pin_project; 929 930 #[pin_project(project_replace)] 931 pub struct Struct<T, U> { 932 #[pin] 933 pub pinned: T, 934 pub unpinned: U, 935 } 936 937 #[pin_project(project_replace)] 938 pub struct TupleStruct<T, U>(#[pin] pub T, pub U); 939 940 #[allow(dead_code)] 941 #[pin_project( 942 project = EnumProj, 943 project_ref = EnumProjRef, 944 project_replace = EnumProjOwn, 945 )] 946 pub enum Enum<T, U> { 947 Struct { 948 #[pin] 949 pinned: T, 950 unpinned: U, 951 }, 952 Tuple(#[pin] T, U), 953 Unit, 954 } 955 956 pub mod inside_macro { 957 use pin_project::pin_project; 958 959 #[allow(clippy::redundant_pub_crate)] 960 #[rustfmt::skip] 961 macro_rules! mac { 962 () => { 963 #[pin_project(project_replace)] 964 pub struct Struct<T, U> { 965 #[pin] 966 pub pinned: T, 967 pub unpinned: U, 968 } 969 970 #[pin_project(project_replace)] 971 pub struct TupleStruct<T, U>(#[pin] pub T, pub U); 972 973 #[allow(dead_code)] 974 #[pin_project( 975 project = EnumProj, 976 project_ref = EnumProjRef, 977 project_replace = EnumProjOwn, 978 )] 979 pub enum Enum<T, U> { 980 Struct { 981 #[pin] 982 pinned: T, 983 unpinned: U, 984 }, 985 Tuple(#[pin] T, U), 986 Unit, 987 } 988 }; 989 } 990 991 mac!(); 992 } 993 } 994 995 #[allow(missing_debug_implementations)] 996 pub mod clippy_type_repetition_in_bounds { 997 use pin_project::pin_project; 998 999 #[pin_project(project_replace)] 1000 pub struct Struct<T, U> 1001 where 1002 Self: Sized, 1003 { 1004 #[pin] 1005 pub pinned: T, 1006 pub unpinned: U, 1007 } 1008 1009 #[pin_project(project_replace)] 1010 pub struct TupleStruct<T, U>(#[pin] T, U) 1011 where 1012 Self: Sized; 1013 1014 #[pin_project( 1015 project = EnumProj, 1016 project_ref = EnumProjRef, 1017 project_replace = EnumProjOwn, 1018 )] 1019 pub enum Enum<T, U> 1020 where 1021 Self: Sized, 1022 { 1023 Struct { 1024 #[pin] 1025 pinned: T, 1026 unpinned: U, 1027 }, 1028 Tuple(#[pin] T, U), 1029 Unit, 1030 } 1031 1032 pub mod inside_macro { 1033 use pin_project::pin_project; 1034 1035 #[rustfmt::skip] 1036 macro_rules! mac { 1037 () => { 1038 #[pin_project(project_replace)] 1039 pub struct Struct<T, U> 1040 where 1041 Self: Sized, 1042 { 1043 #[pin] 1044 pub pinned: T, 1045 pub unpinned: U, 1046 } 1047 1048 #[pin_project(project_replace)] 1049 pub struct TupleStruct<T, U>(#[pin] T, U) 1050 where 1051 Self: Sized; 1052 1053 #[pin_project( 1054 project = EnumProj, 1055 project_ref = EnumProjRef, 1056 project_replace = EnumProjOwn, 1057 )] 1058 pub enum Enum<T, U> 1059 where 1060 Self: Sized, 1061 { 1062 Struct { 1063 #[pin] 1064 pinned: T, 1065 unpinned: U, 1066 }, 1067 Tuple(#[pin] T, U), 1068 Unit, 1069 } 1070 }; 1071 } 1072 1073 mac!(); 1074 } 1075 } 1076 1077 #[allow(missing_debug_implementations)] 1078 pub mod clippy_use_self { 1079 use pin_project::pin_project; 1080 1081 pub trait Trait { 1082 type Assoc; 1083 } 1084 1085 #[pin_project(project_replace)] 1086 pub struct Generics<T: Trait<Assoc = Self>> 1087 where 1088 Self: Trait<Assoc = Self>, 1089 { 1090 _f: T, 1091 } 1092 1093 pub mod inside_macro { 1094 use pin_project::pin_project; 1095 1096 use super::Trait; 1097 1098 #[rustfmt::skip] 1099 macro_rules! mac { 1100 () => { 1101 #[pin_project(project_replace)] 1102 pub struct Generics<T: Trait<Assoc = Self>> 1103 where 1104 Self: Trait<Assoc = Self>, 1105 { 1106 _f: T, 1107 } 1108 }; 1109 } 1110 1111 mac!(); 1112 } 1113 } 1114 1115 #[allow(missing_debug_implementations)] 1116 pub mod clippy_used_underscore_binding { 1117 use pin_project::pin_project; 1118 1119 #[pin_project(project_replace)] 1120 pub struct Struct<T, U> { 1121 #[pin] 1122 pub _pinned: T, 1123 pub _unpinned: U, 1124 } 1125 1126 #[pin_project( 1127 project = EnumProj, 1128 project_ref = EnumProjRef, 1129 project_replace = EnumProjOwn, 1130 )] 1131 pub enum Enum<T, U> { 1132 Struct { 1133 #[pin] 1134 _pinned: T, 1135 _unpinned: U, 1136 }, 1137 } 1138 1139 pub mod inside_macro { 1140 use pin_project::pin_project; 1141 1142 #[rustfmt::skip] 1143 macro_rules! mac { 1144 () => { 1145 #[pin_project(project_replace)] 1146 pub struct Struct<T, U> { 1147 #[pin] 1148 pub _pinned: T, 1149 pub _unpinned: U, 1150 } 1151 1152 #[pin_project( 1153 project = EnumProj, 1154 project_ref = EnumProjRef, 1155 project_replace = EnumProjOwn, 1156 )] 1157 pub enum Enum<T, U> { 1158 Struct { 1159 #[pin] 1160 _pinned: T, 1161 _unpinned: U, 1162 }, 1163 } 1164 }; 1165 } 1166 1167 mac!(); 1168 } 1169 } 1170 1171 #[allow(missing_debug_implementations)] 1172 pub mod clippy_ref_option_ref { 1173 use pin_project::pin_project; 1174 1175 #[pin_project] 1176 pub struct Struct<'a> { 1177 #[pin] 1178 pub _pinned: Option<&'a ()>, 1179 pub _unpinned: Option<&'a ()>, 1180 } 1181 1182 #[pin_project(project = EnumProj, project_ref = EnumProjRef)] 1183 pub enum Enum<'a> { 1184 Struct { 1185 #[pin] 1186 _pinned: Option<&'a ()>, 1187 _unpinned: Option<&'a ()>, 1188 }, 1189 } 1190 } 1191