tests/ui/span/lint-unused-unsafe.rs

   1 // Exercise the unused_unsafe attribute in some positive and negative cases
   2
   3
   4 // edition:2018
   5
   6 // revisions: mir
   7
   8 // FIXME: Adapt -Zthir-unsafeck to behave the same as the mir version after #93678,
   9 // then delete lint-unused-unsafe-thir.rs, and go back to using the settings below
  10 // // revisions: mir thir
  11 // // [thir]compile-flags: -Zthir-unsafeck
  12
  13 #![allow(dead_code)]
  14 #![deny(unused_unsafe)]
  15
  16
  17 mod foo {
  18     extern "C" {
  19         pub fn bar();
  20     }
  21 }
  22
  23 fn callback<T, F>(_f: F) -> T where F: FnOnce() -> T { panic!() }
  24 unsafe fn unsf() {}
  25
  26 fn bad1() { unsafe {} }                  //~ ERROR: unnecessary `unsafe` block
  27 fn bad2() { unsafe { bad1() } }          //~ ERROR: unnecessary `unsafe` block
  28 unsafe fn bad3() { unsafe {} }           //~ ERROR: unnecessary `unsafe` block
  29 fn bad4() { unsafe { callback(||{}) } }  //~ ERROR: unnecessary `unsafe` block
  30 unsafe fn bad5() { unsafe { unsf() } }
  31 fn bad6() {
  32     unsafe {                             //~ ERROR: unnecessary `unsafe` block
  33         unsafe {                         // don't put the warning here
  34             unsf()
  35         }
  36     }
  37 }
  38 unsafe fn bad7() {
  39     unsafe {                             //~ ERROR: unnecessary `unsafe` block
  40         unsafe {
  41             unsf()
  42         }
  43     }
  44 }
  45
  46 unsafe fn good0() { unsf() }
  47 fn good1() { unsafe { unsf() } }
  48 fn good2() {
  49     /* bug uncovered when implementing warning about unused unsafe blocks. Be
  50        sure that when purity is inherited that the source of the unsafe-ness
  51        is tracked correctly */
  52     unsafe {
  53         unsafe fn what() -> Vec<String> { panic!() }
  54
  55         callback(|| {
  56             what();
  57         });
  58     }
  59 }
  60
  61 unsafe fn good3() { foo::bar() }
  62 fn good4() { unsafe { foo::bar() } }
  63
  64 #[allow(unused_unsafe)] fn allowed() { unsafe {} }
  65
  66 fn main() {}
  67
  68 mod additional_tests {
  69     unsafe fn unsf() {}
  70
  71     // some tests
  72
  73     fn inner_ignored() {
  74         unsafe { //~ ERROR: unnecessary `unsafe` block
  75             #[allow(unused_unsafe)]
  76             unsafe {
  77                 unsf()
  78             }
  79         }
  80     }
  81
  82     fn multi_level_unused() {
  83         unsafe { //~ ERROR: unnecessary `unsafe` block
  84             unsafe {} //~ ERROR: unnecessary `unsafe` block
  85             unsafe {} //~ ERROR: unnecessary `unsafe` block
  86         }
  87     }
  88
  89     fn granularity() {
  90         unsafe { //~ ERROR: unnecessary `unsafe` block
  91             unsafe { unsf() }
  92             unsafe { unsf() }
  93             unsafe { unsf() }
  94         }
  95     }
  96
  97     fn top_level_used() {
  98         unsafe {
  99             unsf();
 100             unsafe { unsf() } //~ ERROR: unnecessary `unsafe` block
 101             unsafe { unsf() } //~ ERROR: unnecessary `unsafe` block
 102             unsafe { unsf() } //~ ERROR: unnecessary `unsafe` block
 103         }
 104
 105     }
 106
 107     fn top_level_ignored() {
 108         #[allow(unused_unsafe)]
 109         unsafe {
 110             #[deny(unused_unsafe)]
 111             {
 112                 unsafe { unsf() } //~ ERROR: unnecessary `unsafe` block
 113                 unsafe { unsf() } //~ ERROR: unnecessary `unsafe` block
 114                 unsafe { unsf() } //~ ERROR: unnecessary `unsafe` block
 115             }
 116         }
 117
 118     }
 119
 120     // same tests in unsafe fn without unsafe_op_in_unsafe_fn allowed
 121
 122     #[deny(unsafe_op_in_unsafe_fn)]
 123     unsafe fn inner_ignored_1() {
 124         unsafe { //~ ERROR: unnecessary `unsafe` block
 125             #[allow(unused_unsafe)]
 126             unsafe {
 127                 unsf()
 128             }
 129         }
 130     }
 131
 132     #[deny(unsafe_op_in_unsafe_fn)]
 133     unsafe fn multi_level_unused_1() {
 134         unsafe { //~ ERROR: unnecessary `unsafe` block
 135             unsafe {} //~ ERROR: unnecessary `unsafe` block
 136             unsafe {} //~ ERROR: unnecessary `unsafe` block
 137         }
 138     }
 139
 140     #[deny(unsafe_op_in_unsafe_fn)]
 141     unsafe fn granularity_1() {
 142         unsafe { //~ ERROR: unnecessary `unsafe` block
 143             unsafe { unsf() }
 144             unsafe { unsf() }
 145             unsafe { unsf() }
 146         }
 147     }
 148
 149     #[deny(unsafe_op_in_unsafe_fn)]
 150     unsafe fn top_level_used_1() {
 151         unsafe {
 152             unsf();
 153             unsafe { unsf() } //~ ERROR: unnecessary `unsafe` block
 154             unsafe { unsf() } //~ ERROR: unnecessary `unsafe` block
 155             unsafe { unsf() } //~ ERROR: unnecessary `unsafe` block
 156         }
 157
 158     }
 159
 160     #[deny(unsafe_op_in_unsafe_fn)]
 161     unsafe fn top_level_ignored_1() {
 162         #[allow(unused_unsafe)]
 163         unsafe {
 164             #[deny(unused_unsafe)]
 165             {
 166                 unsafe { unsf() } //~ ERROR: unnecessary `unsafe` block
 167                 unsafe { unsf() } //~ ERROR: unnecessary `unsafe` block
 168                 unsafe { unsf() } //~ ERROR: unnecessary `unsafe` block
 169             }
 170         }
 171     }
 172
 173     // same tests, but unsafe_op_in_unsafe_fn allowed,
 174     // so that *all* unsafe blocks are unused
 175
 176     #[allow(unsafe_op_in_unsafe_fn)]
 177     unsafe fn inner_ignored_2() {
 178         unsafe { //~ ERROR: unnecessary `unsafe` block
 179             #[allow(unused_unsafe)]
 180             unsafe {
 181                 unsf()
 182             }
 183         }
 184     }
 185
 186     #[allow(unsafe_op_in_unsafe_fn)]
 187     unsafe fn multi_level_unused_2() {
 188         unsafe { //~ ERROR: unnecessary `unsafe` block
 189             unsafe {} //~ ERROR: unnecessary `unsafe` block
 190             unsafe {} //~ ERROR: unnecessary `unsafe` block
 191         }
 192     }
 193
 194     #[allow(unsafe_op_in_unsafe_fn)]
 195     unsafe fn granularity_2() {
 196         unsafe { //~ ERROR: unnecessary `unsafe` block
 197             unsafe { unsf() }
 198             unsafe { unsf() }
 199             unsafe { unsf() }
 200         }
 201     }
 202
 203     #[allow(unsafe_op_in_unsafe_fn)]
 204     unsafe fn top_level_used_2() {
 205         unsafe {
 206             unsf();
 207             unsafe { unsf() } //~ ERROR: unnecessary `unsafe` block
 208             unsafe { unsf() } //~ ERROR: unnecessary `unsafe` block
 209             unsafe { unsf() } //~ ERROR: unnecessary `unsafe` block
 210         }
 211
 212     }
 213
 214     #[allow(unsafe_op_in_unsafe_fn)]
 215     unsafe fn top_level_ignored_2() {
 216         #[allow(unused_unsafe)]
 217         unsafe {
 218             #[deny(unused_unsafe)]
 219             {
 220                 unsafe { unsf() } //~ ERROR: unnecessary `unsafe` block
 221                 unsafe { unsf() } //~ ERROR: unnecessary `unsafe` block
 222                 unsafe { unsf() } //~ ERROR: unnecessary `unsafe` block
 223             }
 224         }
 225     }
 226
 227     // additional tests when using unsafe_op_in_unsafe_fn
 228     // in more complex ways
 229
 230     #[allow(unsafe_op_in_unsafe_fn)]
 231     unsafe fn granular_disallow_op_in_unsafe_fn() {
 232         unsafe {
 233             #[deny(unsafe_op_in_unsafe_fn)]
 234             {
 235                 unsf();
 236             }
 237         }
 238     }
 239
 240     #[allow(unsafe_op_in_unsafe_fn)]
 241     unsafe fn granular_disallow_op_in_unsafe_fn_2() {
 242         unsafe { //~ ERROR: unnecessary `unsafe` block
 243             unsafe {
 244                 #[deny(unsafe_op_in_unsafe_fn)]
 245                 {
 246                     unsf();
 247                 }
 248             }
 249         }
 250     }
 251
 252     #[allow(unsafe_op_in_unsafe_fn)]
 253     unsafe fn granular_disallow_op_in_unsafe_fn_3() {
 254         unsafe {
 255             unsafe { //~ ERROR: unnecessary `unsafe` block
 256                 #[deny(unsafe_op_in_unsafe_fn)]
 257                 {
 258                     unsf();
 259                 }
 260             }
 261             unsf();
 262         }
 263     }
 264
 265     #[allow(unsafe_op_in_unsafe_fn)]
 266     unsafe fn granular_disallow_op_in_unsafe_fn_4() {
 267         unsafe {
 268             unsafe { //~ ERROR: unnecessary `unsafe` block
 269                 unsf();
 270             }
 271             #[deny(unsafe_op_in_unsafe_fn)]
 272             {
 273                 unsf();
 274             }
 275         }
 276     }
 277 }
 278
 279 // the same set of tests, with closures everywhere
 280 mod additional_tests_closures {
 281     unsafe fn unsf() {}
 282
 283     // some tests
 284
 285     fn inner_ignored() {
 286         let _ = || unsafe { //~ ERROR: unnecessary `unsafe` block
 287             #[allow(unused_unsafe)]
 288             let _ = || unsafe {
 289                 unsf()
 290             };
 291         };
 292     }
 293
 294     fn multi_level_unused() {
 295         let _ = || unsafe { //~ ERROR: unnecessary `unsafe` block
 296             let _ = || unsafe {}; //~ ERROR: unnecessary `unsafe` block
 297             let _ = || unsafe {}; //~ ERROR: unnecessary `unsafe` block
 298         };
 299     }
 300
 301     fn granularity() {
 302         let _ = || unsafe { //~ ERROR: unnecessary `unsafe` block
 303             let _ = || unsafe { unsf() };
 304             let _ = || unsafe { unsf() };
 305             let _ = || unsafe { unsf() };
 306         };
 307     }
 308
 309     fn top_level_used() {
 310         let _ = || unsafe {
 311             unsf();
 312             let _ = || unsafe { unsf() }; //~ ERROR: unnecessary `unsafe` block
 313             let _ = || unsafe { unsf() }; //~ ERROR: unnecessary `unsafe` block
 314             let _ = || unsafe { unsf() }; //~ ERROR: unnecessary `unsafe` block
 315         };
 316
 317     }
 318
 319     fn top_level_ignored() {
 320         #[allow(unused_unsafe)]
 321         let _ = || unsafe {
 322             #[deny(unused_unsafe)]
 323             {
 324                 let _ = || unsafe { unsf() }; //~ ERROR: unnecessary `unsafe` block
 325                 let _ = || unsafe { unsf() }; //~ ERROR: unnecessary `unsafe` block
 326                 let _ = || unsafe { unsf() }; //~ ERROR: unnecessary `unsafe` block
 327             }
 328         };
 329
 330     }
 331
 332     // same tests in unsafe fn without unsafe_op_in_unsafe_fn allowed
 333
 334     #[deny(unsafe_op_in_unsafe_fn)]
 335     unsafe fn inner_ignored_1() {
 336         let _ = || unsafe { //~ ERROR: unnecessary `unsafe` block
 337             #[allow(unused_unsafe)]
 338             let _ = || unsafe {
 339                 unsf()
 340             };
 341         };
 342     }
 343
 344     #[deny(unsafe_op_in_unsafe_fn)]
 345     unsafe fn multi_level_unused_1() {
 346         let _ = || unsafe { //~ ERROR: unnecessary `unsafe` block
 347             let _ = || unsafe {}; //~ ERROR: unnecessary `unsafe` block
 348             let _ = || unsafe {}; //~ ERROR: unnecessary `unsafe` block
 349         };
 350     }
 351
 352     #[deny(unsafe_op_in_unsafe_fn)]
 353     unsafe fn granularity_1() {
 354         let _ = || unsafe { //~ ERROR: unnecessary `unsafe` block
 355             let _ = || unsafe { unsf() };
 356             let _ = || unsafe { unsf() };
 357             let _ = || unsafe { unsf() };
 358         };
 359     }
 360
 361     #[deny(unsafe_op_in_unsafe_fn)]
 362     unsafe fn top_level_used_1() {
 363         let _ = || unsafe {
 364             unsf();
 365             let _ = || unsafe { unsf() }; //~ ERROR: unnecessary `unsafe` block
 366             let _ = || unsafe { unsf() }; //~ ERROR: unnecessary `unsafe` block
 367             let _ = || unsafe { unsf() }; //~ ERROR: unnecessary `unsafe` block
 368         };
 369
 370     }
 371
 372     #[deny(unsafe_op_in_unsafe_fn)]
 373     unsafe fn top_level_ignored_1() {
 374         #[allow(unused_unsafe)]
 375         let _ = || unsafe {
 376             #[deny(unused_unsafe)]
 377             {
 378                 let _ = || unsafe { unsf() }; //~ ERROR: unnecessary `unsafe` block
 379                 let _ = || unsafe { unsf() }; //~ ERROR: unnecessary `unsafe` block
 380                 let _ = || unsafe { unsf() }; //~ ERROR: unnecessary `unsafe` block
 381             }
 382         };
 383     }
 384
 385     // same tests, but unsafe_op_in_unsafe_fn allowed,
 386     // so that *all* unsafe blocks are unused
 387
 388     #[allow(unsafe_op_in_unsafe_fn)]
 389     unsafe fn inner_ignored_2() {
 390         let _ = || unsafe { //~ ERROR: unnecessary `unsafe` block
 391             #[allow(unused_unsafe)]
 392             let _ = || unsafe {
 393                 unsf()
 394             };
 395         };
 396     }
 397
 398     #[allow(unsafe_op_in_unsafe_fn)]
 399     unsafe fn multi_level_unused_2() {
 400         let _ = || unsafe { //~ ERROR: unnecessary `unsafe` block
 401             let _ = || unsafe {}; //~ ERROR: unnecessary `unsafe` block
 402             let _ = || unsafe {}; //~ ERROR: unnecessary `unsafe` block
 403         };
 404     }
 405
 406     #[allow(unsafe_op_in_unsafe_fn)]
 407     unsafe fn granularity_2() {
 408         let _ = || unsafe { //~ ERROR: unnecessary `unsafe` block
 409             let _ = || unsafe { unsf() };
 410             let _ = || unsafe { unsf() };
 411             let _ = || unsafe { unsf() };
 412         };
 413     }
 414
 415     #[allow(unsafe_op_in_unsafe_fn)]
 416     unsafe fn top_level_used_2() {
 417         let _ = || unsafe {
 418             unsf();
 419             let _ = || unsafe { unsf() }; //~ ERROR: unnecessary `unsafe` block
 420             let _ = || unsafe { unsf() }; //~ ERROR: unnecessary `unsafe` block
 421             let _ = || unsafe { unsf() }; //~ ERROR: unnecessary `unsafe` block
 422         };
 423
 424     }
 425
 426     #[allow(unsafe_op_in_unsafe_fn)]
 427     unsafe fn top_level_ignored_2() {
 428         #[allow(unused_unsafe)]
 429         let _ = || unsafe {
 430             #[deny(unused_unsafe)]
 431             {
 432                 let _ = || unsafe { unsf() }; //~ ERROR: unnecessary `unsafe` block
 433                 let _ = || unsafe { unsf() }; //~ ERROR: unnecessary `unsafe` block
 434                 let _ = || unsafe { unsf() }; //~ ERROR: unnecessary `unsafe` block
 435             }
 436         };
 437     }
 438
 439     // additional tests when using unsafe_op_in_unsafe_fn
 440     // in more complex ways
 441
 442     #[allow(unsafe_op_in_unsafe_fn)]
 443     unsafe fn granular_disallow_op_in_unsafe_fn() {
 444         let _ = || unsafe {
 445             #[deny(unsafe_op_in_unsafe_fn)]
 446             {
 447                 unsf();
 448             }
 449         };
 450     }
 451
 452     #[allow(unsafe_op_in_unsafe_fn)]
 453     unsafe fn granular_disallow_op_in_unsafe_fn_2() {
 454         let _ = || unsafe { //~ ERROR: unnecessary `unsafe` block
 455             let _ = || unsafe {
 456                 #[deny(unsafe_op_in_unsafe_fn)]
 457                 {
 458                     unsf();
 459                 }
 460             };
 461         };
 462     }
 463
 464     #[allow(unsafe_op_in_unsafe_fn)]
 465     unsafe fn granular_disallow_op_in_unsafe_fn_3() {
 466         let _ = || unsafe {
 467             let _ = || unsafe { //~ ERROR: unnecessary `unsafe` block
 468                 #[deny(unsafe_op_in_unsafe_fn)]
 469                 {
 470                     unsf();
 471                 }
 472             };
 473             unsf();
 474         };
 475     }
 476
 477     #[allow(unsafe_op_in_unsafe_fn)]
 478     unsafe fn granular_disallow_op_in_unsafe_fn_4() {
 479         let _ = || unsafe {
 480             let _ = || unsafe { //~ ERROR: unnecessary `unsafe` block
 481                 unsf();
 482             };
 483             #[deny(unsafe_op_in_unsafe_fn)]
 484             {
 485                 unsf();
 486             }
 487         };
 488     }
 489 }
 490
 491 // the same set of tests, with closures everywhere
 492 // and closures on the unsafe fn calls
 493 mod additional_tests_even_more_closures {
 494     unsafe fn unsf() {}
 495
 496     // some tests
 497
 498     fn inner_ignored() {
 499         let _ = || unsafe { //~ ERROR: unnecessary `unsafe` block
 500             #[allow(unused_unsafe)]
 501             let _ = || unsafe {
 502                 let _ = || unsf();
 503             };
 504         };
 505     }
 506
 507     fn multi_level_unused() {
 508         let _ = || unsafe { //~ ERROR: unnecessary `unsafe` block
 509             let _ = || unsafe {}; //~ ERROR: unnecessary `unsafe` block
 510             let _ = || unsafe {}; //~ ERROR: unnecessary `unsafe` block
 511         };
 512     }
 513
 514     fn granularity() {
 515         let _ = || unsafe { //~ ERROR: unnecessary `unsafe` block
 516             let _ = || unsafe { let _ = || unsf(); };
 517             let _ = || unsafe { let _ = || unsf(); };
 518             let _ = || unsafe { let _ = || unsf(); };
 519         };
 520     }
 521
 522     fn top_level_used() {
 523         let _ = || unsafe {
 524             let _ = || unsf();
 525             let _ = || unsafe { let _ = || unsf(); }; //~ ERROR: unnecessary `unsafe` block
 526             let _ = || unsafe { let _ = || unsf(); }; //~ ERROR: unnecessary `unsafe` block
 527             let _ = || unsafe { let _ = || unsf(); }; //~ ERROR: unnecessary `unsafe` block
 528         };
 529
 530     }
 531
 532     fn top_level_ignored() {
 533         #[allow(unused_unsafe)]
 534         let _ = || unsafe {
 535             #[deny(unused_unsafe)]
 536             {
 537                 let _ = || unsafe { let _ = || unsf(); }; //~ ERROR: unnecessary `unsafe` block
 538                 let _ = || unsafe { let _ = || unsf(); }; //~ ERROR: unnecessary `unsafe` block
 539                 let _ = || unsafe { let _ = || unsf(); }; //~ ERROR: unnecessary `unsafe` block
 540             }
 541         };
 542
 543     }
 544
 545     // same tests in unsafe fn without unsafe_op_in_unsafe_fn allowed
 546
 547     #[deny(unsafe_op_in_unsafe_fn)]
 548     unsafe fn inner_ignored_1() {
 549         let _ = || unsafe { //~ ERROR: unnecessary `unsafe` block
 550             #[allow(unused_unsafe)]
 551             let _ = || unsafe {
 552                 let _ = || unsf();
 553             };
 554         };
 555     }
 556
 557     #[deny(unsafe_op_in_unsafe_fn)]
 558     unsafe fn multi_level_unused_1() {
 559         let _ = || unsafe { //~ ERROR: unnecessary `unsafe` block
 560             let _ = || unsafe {}; //~ ERROR: unnecessary `unsafe` block
 561             let _ = || unsafe {}; //~ ERROR: unnecessary `unsafe` block
 562         };
 563     }
 564
 565     #[deny(unsafe_op_in_unsafe_fn)]
 566     unsafe fn granularity_1() {
 567         let _ = || unsafe { //~ ERROR: unnecessary `unsafe` block
 568             let _ = || unsafe { let _ = || unsf(); };
 569             let _ = || unsafe { let _ = || unsf(); };
 570             let _ = || unsafe { let _ = || unsf(); };
 571         };
 572     }
 573
 574     #[deny(unsafe_op_in_unsafe_fn)]
 575     unsafe fn top_level_used_1() {
 576         let _ = || unsafe {
 577             let _ = || unsf();
 578             let _ = || unsafe { let _ = || unsf(); }; //~ ERROR: unnecessary `unsafe` block
 579             let _ = || unsafe { let _ = || unsf(); }; //~ ERROR: unnecessary `unsafe` block
 580             let _ = || unsafe { let _ = || unsf(); }; //~ ERROR: unnecessary `unsafe` block
 581         };
 582
 583     }
 584
 585     #[deny(unsafe_op_in_unsafe_fn)]
 586     unsafe fn top_level_ignored_1() {
 587         #[allow(unused_unsafe)]
 588         let _ = || unsafe {
 589             #[deny(unused_unsafe)]
 590             {
 591                 let _ = || unsafe { let _ = || unsf(); }; //~ ERROR: unnecessary `unsafe` block
 592                 let _ = || unsafe { let _ = || unsf(); }; //~ ERROR: unnecessary `unsafe` block
 593                 let _ = || unsafe { let _ = || unsf(); }; //~ ERROR: unnecessary `unsafe` block
 594             }
 595         };
 596     }
 597
 598     // same tests, but unsafe_op_in_unsafe_fn allowed,
 599     // so that *all* unsafe blocks are unused
 600
 601     #[allow(unsafe_op_in_unsafe_fn)]
 602     unsafe fn inner_ignored_2() {
 603         let _ = || unsafe { //~ ERROR: unnecessary `unsafe` block
 604             #[allow(unused_unsafe)]
 605             let _ = || unsafe {
 606                 let _ = || unsf();
 607             };
 608         };
 609     }
 610
 611     #[allow(unsafe_op_in_unsafe_fn)]
 612     unsafe fn multi_level_unused_2() {
 613         let _ = || unsafe { //~ ERROR: unnecessary `unsafe` block
 614             let _ = || unsafe {}; //~ ERROR: unnecessary `unsafe` block
 615             let _ = || unsafe {}; //~ ERROR: unnecessary `unsafe` block
 616         };
 617     }
 618
 619     #[allow(unsafe_op_in_unsafe_fn)]
 620     unsafe fn granularity_2() {
 621         let _ = || unsafe { //~ ERROR: unnecessary `unsafe` block
 622             let _ = || unsafe { let _ = || unsf(); };
 623             let _ = || unsafe { let _ = || unsf(); };
 624             let _ = || unsafe { let _ = || unsf(); };
 625         };
 626     }
 627
 628     #[allow(unsafe_op_in_unsafe_fn)]
 629     unsafe fn top_level_used_2() {
 630         let _ = || unsafe {
 631             let _ = || unsf();
 632             let _ = || unsafe { let _ = || unsf(); }; //~ ERROR: unnecessary `unsafe` block
 633             let _ = || unsafe { let _ = || unsf(); }; //~ ERROR: unnecessary `unsafe` block
 634             let _ = || unsafe { let _ = || unsf(); }; //~ ERROR: unnecessary `unsafe` block
 635         };
 636
 637     }
 638
 639     #[allow(unsafe_op_in_unsafe_fn)]
 640     unsafe fn top_level_ignored_2() {
 641         #[allow(unused_unsafe)]
 642         let _ = || unsafe {
 643             #[deny(unused_unsafe)]
 644             {
 645                 let _ = || unsafe { let _ = || unsf(); }; //~ ERROR: unnecessary `unsafe` block
 646                 let _ = || unsafe { let _ = || unsf(); }; //~ ERROR: unnecessary `unsafe` block
 647                 let _ = || unsafe { let _ = || unsf(); }; //~ ERROR: unnecessary `unsafe` block
 648             }
 649         };
 650     }
 651
 652     // additional tests when using unsafe_op_in_unsafe_fn
 653     // in more complex ways
 654
 655     #[allow(unsafe_op_in_unsafe_fn)]
 656     unsafe fn granular_disallow_op_in_unsafe_fn() {
 657         let _ = || unsafe {
 658             #[deny(unsafe_op_in_unsafe_fn)]
 659             {
 660                 let _ = || unsf();
 661             }
 662         };
 663     }
 664
 665     #[allow(unsafe_op_in_unsafe_fn)]
 666     unsafe fn granular_disallow_op_in_unsafe_fn_2() {
 667         let _ = || unsafe { //~ ERROR: unnecessary `unsafe` block
 668             let _ = || unsafe {
 669                 #[deny(unsafe_op_in_unsafe_fn)]
 670                 {
 671                     let _ = || unsf();
 672                 }
 673             };
 674         };
 675     }
 676
 677     #[allow(unsafe_op_in_unsafe_fn)]
 678     unsafe fn granular_disallow_op_in_unsafe_fn_3() {
 679         let _ = || unsafe {
 680             let _ = || unsafe { //~ ERROR: unnecessary `unsafe` block
 681                 #[deny(unsafe_op_in_unsafe_fn)]
 682                 {
 683                     let _ = || unsf();
 684                 }
 685             };
 686             let _ = || unsf();
 687         };
 688     }
 689
 690     #[allow(unsafe_op_in_unsafe_fn)]
 691     unsafe fn granular_disallow_op_in_unsafe_fn_4() {
 692         let _ = || unsafe {
 693             let _ = || unsafe { //~ ERROR: unnecessary `unsafe` block
 694                 let _ = || unsf();
 695             };
 696             #[deny(unsafe_op_in_unsafe_fn)]
 697             {
 698                 let _ = || unsf();
 699             }
 700         };
 701     }
 702 }
 703
 704 mod item_likes {
 705     unsafe fn unsf() {}
 706
 707     struct S;
 708     impl S {
 709         #[deny(unsafe_op_in_unsafe_fn)]
 710         unsafe fn inner_ignored_1() {
 711             let _ = || unsafe { //~ ERROR: unnecessary `unsafe` block
 712                 #[allow(unused_unsafe)]
 713                 let _ = || unsafe {
 714                     unsf()
 715                 };
 716             };
 717         }
 718
 719         #[deny(unsafe_op_in_unsafe_fn)]
 720         unsafe fn multi_level_unused_1() {
 721             let _ = || unsafe { //~ ERROR: unnecessary `unsafe` block
 722                 let _ = || unsafe {}; //~ ERROR: unnecessary `unsafe` block
 723                 let _ = || unsafe {}; //~ ERROR: unnecessary `unsafe` block
 724             };
 725         }
 726
 727         #[deny(unsafe_op_in_unsafe_fn)]
 728         unsafe fn granularity_1() {
 729             let _ = || unsafe { //~ ERROR: unnecessary `unsafe` block
 730                 let _ = || unsafe { unsf() };
 731                 let _ = || unsafe { unsf() };
 732                 let _ = || unsafe { unsf() };
 733             };
 734         }
 735
 736         #[deny(unsafe_op_in_unsafe_fn)]
 737         unsafe fn top_level_used_1() {
 738             let _ = || unsafe {
 739                 unsf();
 740                 let _ = || unsafe { unsf() }; //~ ERROR: unnecessary `unsafe` block
 741                 let _ = || unsafe { unsf() }; //~ ERROR: unnecessary `unsafe` block
 742                 let _ = || unsafe { unsf() }; //~ ERROR: unnecessary `unsafe` block
 743             };
 744
 745         }
 746
 747         #[deny(unsafe_op_in_unsafe_fn)]
 748         unsafe fn top_level_ignored_1() {
 749             #[allow(unused_unsafe)]
 750             let _ = || unsafe {
 751                 #[deny(unused_unsafe)]
 752                 {
 753                     let _ = || unsafe { unsf() }; //~ ERROR: unnecessary `unsafe` block
 754                     let _ = || unsafe { unsf() }; //~ ERROR: unnecessary `unsafe` block
 755                     let _ = || unsafe { unsf() }; //~ ERROR: unnecessary `unsafe` block
 756                 }
 757             };
 758         }
 759
 760         // same tests, but unsafe_op_in_unsafe_fn allowed,
 761         // so that *all* unsafe blocks are unused
 762
 763         #[allow(unsafe_op_in_unsafe_fn)]
 764         unsafe fn inner_ignored_2() {
 765             let _ = || unsafe { //~ ERROR: unnecessary `unsafe` block
 766                 #[allow(unused_unsafe)]
 767                 let _ = || unsafe {
 768                     unsf()
 769                 };
 770             };
 771         }
 772
 773         #[allow(unsafe_op_in_unsafe_fn)]
 774         unsafe fn multi_level_unused_2() {
 775             let _ = || unsafe { //~ ERROR: unnecessary `unsafe` block
 776                 let _ = || unsafe {}; //~ ERROR: unnecessary `unsafe` block
 777                 let _ = || unsafe {}; //~ ERROR: unnecessary `unsafe` block
 778             };
 779         }
 780
 781         #[allow(unsafe_op_in_unsafe_fn)]
 782         unsafe fn granularity_2() {
 783             let _ = || unsafe { //~ ERROR: unnecessary `unsafe` block
 784                 let _ = || unsafe { unsf() };
 785                 let _ = || unsafe { unsf() };
 786                 let _ = || unsafe { unsf() };
 787             };
 788         }
 789
 790         #[allow(unsafe_op_in_unsafe_fn)]
 791         unsafe fn top_level_used_2() {
 792             let _ = || unsafe {
 793                 unsf();
 794                 let _ = || unsafe { unsf() }; //~ ERROR: unnecessary `unsafe` block
 795                 let _ = || unsafe { unsf() }; //~ ERROR: unnecessary `unsafe` block
 796                 let _ = || unsafe { unsf() }; //~ ERROR: unnecessary `unsafe` block
 797             };
 798
 799         }
 800
 801         #[allow(unsafe_op_in_unsafe_fn)]
 802         unsafe fn top_level_ignored_2() {
 803             #[allow(unused_unsafe)]
 804             let _ = || unsafe {
 805                 #[deny(unused_unsafe)]
 806                 {
 807                     let _ = || unsafe { unsf() }; //~ ERROR: unnecessary `unsafe` block
 808                     let _ = || unsafe { unsf() }; //~ ERROR: unnecessary `unsafe` block
 809                     let _ = || unsafe { unsf() }; //~ ERROR: unnecessary `unsafe` block
 810                 }
 811             };
 812         }
 813
 814         // additional tests when using unsafe_op_in_unsafe_fn
 815         // in more complex ways
 816
 817         #[allow(unsafe_op_in_unsafe_fn)]
 818         unsafe fn granular_disallow_op_in_unsafe_fn() {
 819             let _ = || unsafe {
 820                 #[deny(unsafe_op_in_unsafe_fn)]
 821                 {
 822                     unsf();
 823                 }
 824             };
 825         }
 826
 827         #[allow(unsafe_op_in_unsafe_fn)]
 828         unsafe fn granular_disallow_op_in_unsafe_fn_2() {
 829             let _ = || unsafe { //~ ERROR: unnecessary `unsafe` block
 830                 let _ = || unsafe {
 831                     #[deny(unsafe_op_in_unsafe_fn)]
 832                     {
 833                         unsf();
 834                     }
 835                 };
 836             };
 837         }
 838
 839         #[allow(unsafe_op_in_unsafe_fn)]
 840         unsafe fn granular_disallow_op_in_unsafe_fn_3() {
 841             let _ = || unsafe {
 842                 let _ = || unsafe { //~ ERROR: unnecessary `unsafe` block
 843                     #[deny(unsafe_op_in_unsafe_fn)]
 844                     {
 845                         unsf();
 846                     }
 847                 };
 848                 unsf();
 849             };
 850         }
 851
 852         #[allow(unsafe_op_in_unsafe_fn)]
 853         unsafe fn granular_disallow_op_in_unsafe_fn_4() {
 854             let _ = || unsafe {
 855                 let _ = || unsafe { //~ ERROR: unnecessary `unsafe` block
 856                     unsf();
 857                 };
 858                 #[deny(unsafe_op_in_unsafe_fn)]
 859                 {
 860                     unsf();
 861                 }
 862             };
 863         }
 864     }
 865
 866     trait T {
 867         #[deny(unsafe_op_in_unsafe_fn)]
 868         unsafe fn inner_ignored_1() {
 869             let _ = || unsafe { //~ ERROR: unnecessary `unsafe` block
 870                 #[allow(unused_unsafe)]
 871                 let _ = || unsafe {
 872                     unsf()
 873                 };
 874             };
 875         }
 876
 877         #[deny(unsafe_op_in_unsafe_fn)]
 878         unsafe fn multi_level_unused_1() {
 879             let _ = || unsafe { //~ ERROR: unnecessary `unsafe` block
 880                 let _ = || unsafe {}; //~ ERROR: unnecessary `unsafe` block
 881                 let _ = || unsafe {}; //~ ERROR: unnecessary `unsafe` block
 882             };
 883         }
 884
 885         #[deny(unsafe_op_in_unsafe_fn)]
 886         unsafe fn granularity_1() {
 887             let _ = || unsafe { //~ ERROR: unnecessary `unsafe` block
 888                 let _ = || unsafe { unsf() };
 889                 let _ = || unsafe { unsf() };
 890                 let _ = || unsafe { unsf() };
 891             };
 892         }
 893
 894         #[deny(unsafe_op_in_unsafe_fn)]
 895         unsafe fn top_level_used_1() {
 896             let _ = || unsafe {
 897                 unsf();
 898                 let _ = || unsafe { unsf() }; //~ ERROR: unnecessary `unsafe` block
 899                 let _ = || unsafe { unsf() }; //~ ERROR: unnecessary `unsafe` block
 900                 let _ = || unsafe { unsf() }; //~ ERROR: unnecessary `unsafe` block
 901             };
 902
 903         }
 904
 905         #[deny(unsafe_op_in_unsafe_fn)]
 906         unsafe fn top_level_ignored_1() {
 907             #[allow(unused_unsafe)]
 908             let _ = || unsafe {
 909                 #[deny(unused_unsafe)]
 910                 {
 911                     let _ = || unsafe { unsf() }; //~ ERROR: unnecessary `unsafe` block
 912                     let _ = || unsafe { unsf() }; //~ ERROR: unnecessary `unsafe` block
 913                     let _ = || unsafe { unsf() }; //~ ERROR: unnecessary `unsafe` block
 914                 }
 915             };
 916         }
 917
 918         // same tests, but unsafe_op_in_unsafe_fn allowed,
 919         // so that *all* unsafe blocks are unused
 920
 921         #[allow(unsafe_op_in_unsafe_fn)]
 922         unsafe fn inner_ignored_2() {
 923             let _ = || unsafe { //~ ERROR: unnecessary `unsafe` block
 924                 #[allow(unused_unsafe)]
 925                 let _ = || unsafe {
 926                     unsf()
 927                 };
 928             };
 929         }
 930
 931         #[allow(unsafe_op_in_unsafe_fn)]
 932         unsafe fn multi_level_unused_2() {
 933             let _ = || unsafe { //~ ERROR: unnecessary `unsafe` block
 934                 let _ = || unsafe {}; //~ ERROR: unnecessary `unsafe` block
 935                 let _ = || unsafe {}; //~ ERROR: unnecessary `unsafe` block
 936             };
 937         }
 938
 939         #[allow(unsafe_op_in_unsafe_fn)]
 940         unsafe fn granularity_2() {
 941             let _ = || unsafe { //~ ERROR: unnecessary `unsafe` block
 942                 let _ = || unsafe { unsf() };
 943                 let _ = || unsafe { unsf() };
 944                 let _ = || unsafe { unsf() };
 945             };
 946         }
 947
 948         #[allow(unsafe_op_in_unsafe_fn)]
 949         unsafe fn top_level_used_2() {
 950             let _ = || unsafe {
 951                 unsf();
 952                 let _ = || unsafe { unsf() }; //~ ERROR: unnecessary `unsafe` block
 953                 let _ = || unsafe { unsf() }; //~ ERROR: unnecessary `unsafe` block
 954                 let _ = || unsafe { unsf() }; //~ ERROR: unnecessary `unsafe` block
 955             };
 956
 957         }
 958
 959         #[allow(unsafe_op_in_unsafe_fn)]
 960         unsafe fn top_level_ignored_2() {
 961             #[allow(unused_unsafe)]
 962             let _ = || unsafe {
 963                 #[deny(unused_unsafe)]
 964                 {
 965                     let _ = || unsafe { unsf() }; //~ ERROR: unnecessary `unsafe` block
 966                     let _ = || unsafe { unsf() }; //~ ERROR: unnecessary `unsafe` block
 967                     let _ = || unsafe { unsf() }; //~ ERROR: unnecessary `unsafe` block
 968                 }
 969             };
 970         }
 971
 972         // additional tests when using unsafe_op_in_unsafe_fn
 973         // in more complex ways
 974
 975         #[allow(unsafe_op_in_unsafe_fn)]
 976         unsafe fn granular_disallow_op_in_unsafe_fn() {
 977             let _ = || unsafe {
 978                 #[deny(unsafe_op_in_unsafe_fn)]
 979                 {
 980                     unsf();
 981                 }
 982             };
 983         }
 984
 985         #[allow(unsafe_op_in_unsafe_fn)]
 986         unsafe fn granular_disallow_op_in_unsafe_fn_2() {
 987             let _ = || unsafe { //~ ERROR: unnecessary `unsafe` block
 988                 let _ = || unsafe {
 989                     #[deny(unsafe_op_in_unsafe_fn)]
 990                     {
 991                         unsf();
 992                     }
 993                 };
 994             };
 995         }
 996
 997         #[allow(unsafe_op_in_unsafe_fn)]
 998         unsafe fn granular_disallow_op_in_unsafe_fn_3() {
 999             let _ = || unsafe {
1000                 let _ = || unsafe { //~ ERROR: unnecessary `unsafe` block
1001                     #[deny(unsafe_op_in_unsafe_fn)]
1002                     {
1003                         unsf();
1004                     }
1005                 };
1006                 unsf();
1007             };
1008         }
1009
1010         #[allow(unsafe_op_in_unsafe_fn)]
1011         unsafe fn granular_disallow_op_in_unsafe_fn_4() {
1012             let _ = || unsafe {
1013                 let _ = || unsafe { //~ ERROR: unnecessary `unsafe` block
1014                     unsf();
1015                 };
1016                 #[deny(unsafe_op_in_unsafe_fn)]
1017                 {
1018                     unsf();
1019                 }
1020             };
1021         }
1022     }
1023 }
1024
1025 mod additional_tests_extra {
1026     unsafe fn unsf() {}
1027
1028     // multiple uses with different `unsafe_op_in_unsafe_fn` in the same closure
1029     #[allow(unsafe_op_in_unsafe_fn)]
1030     unsafe fn granular_disallow_op_in_unsafe_fn() {
1031         let _ = || unsafe {
1032             let _ = || {
1033                 unsf();
1034                 #[deny(unsafe_op_in_unsafe_fn)]
1035                 {
1036                     unsf();
1037                 }
1038             };
1039         };
1040     }
1041
1042     #[warn(unsafe_op_in_unsafe_fn)]
1043     unsafe fn multiple_unsafe_op_in_unsafe_fn_allows() {
1044         unsafe {
1045             #[allow(unsafe_op_in_unsafe_fn)]
1046             {
1047                 unsf();
1048             }
1049             #[allow(unsafe_op_in_unsafe_fn)]
1050             {
1051                 unsf();
1052             }
1053         }
1054     }
1055
1056     async unsafe fn async_blocks() {
1057         #[deny(unsafe_op_in_unsafe_fn)]
1058         {
1059             let _ = async { unsafe { //~ ERROR: unnecessary `unsafe` block
1060                 let _ = async { unsafe { let _ = async { unsf() }; }};
1061                 let _ = async { unsafe { let _ = async { unsf() }; }};
1062                 let _ = async { unsafe { let _ = async { unsf() }; }};
1063             }};
1064             let _ = async { unsafe {
1065                 let _ = async { unsf() };
1066                 let _ = async { unsafe { let _ = async { unsf() }; }}; //~ ERROR: unnecessary `unsafe` block
1067                 let _ = async { unsafe { let _ = async { unsf() }; }}; //~ ERROR: unnecessary `unsafe` block
1068                 let _ = async { unsafe { let _ = async { unsf() }; }}; //~ ERROR: unnecessary `unsafe` block
1069             }};
1070         }
1071         #[allow(unsafe_op_in_unsafe_fn)]
1072         {
1073             let _ = async { unsafe { //~ ERROR: unnecessary `unsafe` block
1074                 let _ = async { unsafe { let _ = async { unsf() }; }};
1075                 let _ = async { unsafe { let _ = async { unsf() }; }};
1076                 let _ = async { unsafe { let _ = async { unsf() }; }};
1077             }};
1078             let _ = async { unsafe {
1079                 let _ = async { unsf() };
1080                 let _ = async { unsafe { let _ = async { unsf() }; }}; //~ ERROR: unnecessary `unsafe` block
1081                 let _ = async { unsafe { let _ = async { unsf() }; }}; //~ ERROR: unnecessary `unsafe` block
1082                 let _ = async { unsafe { let _ = async { unsf() }; }}; //~ ERROR: unnecessary `unsafe` block
1083             }};
1084         }
1085     }
1086
1087     fn used_unsafe_in_const() {
1088         let _x: [(); unsafe { size() }] = [];
1089     }
1090
1091     fn unused_unsafe_in_const_1() {
1092         let _x: [(); unsafe { 0 }] = []; //~ ERROR: unnecessary `unsafe` block
1093     }
1094
1095     fn unused_unsafe_in_const_2() {
1096         let _x: [(); unsafe { unsafe { size() } }] = []; //~ ERROR: unnecessary `unsafe` block
1097     }
1098
1099     const unsafe fn size() -> usize { 0 }
1100 }