src/test/ui-fulldeps/session-diagnostic/subdiagnostic-derive.rs

   1 // check-fail
   2 // Tests error conditions for specifying subdiagnostics using #[derive(Subdiagnostic)]
   3
   4 // The proc_macro2 crate handles spans differently when on beta/stable release rather than nightly,
   5 // changing the output of this test. Since Subdiagnostic is strictly internal to the compiler
   6 // the test is just ignored on stable and beta:
   7 // ignore-beta
   8 // ignore-stable
   9
  10 #![feature(rustc_private)]
  11 #![crate_type = "lib"]
  12
  13 extern crate rustc_errors;
  14 extern crate rustc_macros;
  15 extern crate rustc_session;
  16 extern crate rustc_span;
  17
  18 use rustc_errors::Applicability;
  19 use rustc_macros::Subdiagnostic;
  20 use rustc_span::Span;
  21
  22 #[derive(Subdiagnostic)]
  23 #[label(parser_add_paren)]
  24 struct A {
  25     #[primary_span]
  26     span: Span,
  27     var: String,
  28 }
  29
  30 #[derive(Subdiagnostic)]
  31 enum B {
  32     #[label(parser_add_paren)]
  33     A {
  34         #[primary_span]
  35         span: Span,
  36         var: String,
  37     },
  38     #[label(parser_add_paren)]
  39     B {
  40         #[primary_span]
  41         span: Span,
  42         var: String,
  43     },
  44 }
  45
  46 #[derive(Subdiagnostic)]
  47 #[label(parser_add_paren)]
  48 //~^ ERROR label without `#[primary_span]` field
  49 struct C {
  50     var: String,
  51 }
  52
  53 #[derive(Subdiagnostic)]
  54 #[label]
  55 //~^ ERROR diagnostic slug must be first argument
  56 struct D {
  57     #[primary_span]
  58     span: Span,
  59     var: String,
  60 }
  61
  62 #[derive(Subdiagnostic)]
  63 #[foo]
  64 //~^ ERROR `#[foo]` is not a valid attribute
  65 //~^^ ERROR cannot find attribute `foo` in this scope
  66 struct E {
  67     #[primary_span]
  68     span: Span,
  69     var: String,
  70 }
  71
  72 #[derive(Subdiagnostic)]
  73 #[label = "..."]
  74 //~^ ERROR `#[label = ...]` is not a valid attribute
  75 struct F {
  76     #[primary_span]
  77     span: Span,
  78     var: String,
  79 }
  80
  81 #[derive(Subdiagnostic)]
  82 #[label(bug = "...")]
  83 //~^ ERROR `#[label(bug = ...)]` is not a valid attribute
  84 //~| ERROR diagnostic slug must be first argument
  85 struct G {
  86     #[primary_span]
  87     span: Span,
  88     var: String,
  89 }
  90
  91 #[derive(Subdiagnostic)]
  92 #[label("...")]
  93 //~^ ERROR `#[label("...")]` is not a valid attribute
  94 //~| ERROR diagnostic slug must be first argument
  95 struct H {
  96     #[primary_span]
  97     span: Span,
  98     var: String,
  99 }
 100
 101 #[derive(Subdiagnostic)]
 102 #[label(slug = 4)]
 103 //~^ ERROR `#[label(slug = ...)]` is not a valid attribute
 104 //~| ERROR diagnostic slug must be first argument
 105 struct J {
 106     #[primary_span]
 107     span: Span,
 108     var: String,
 109 }
 110
 111 #[derive(Subdiagnostic)]
 112 #[label(slug("..."))]
 113 //~^ ERROR `#[label(slug(...))]` is not a valid attribute
 114 //~| ERROR diagnostic slug must be first argument
 115 struct K {
 116     #[primary_span]
 117     span: Span,
 118     var: String,
 119 }
 120
 121 #[derive(Subdiagnostic)]
 122 #[label(slug)]
 123 //~^ ERROR cannot find value `slug` in module `rustc_errors::fluent`
 124 //~^^ NOTE not found in `rustc_errors::fluent`
 125 struct L {
 126     #[primary_span]
 127     span: Span,
 128     var: String,
 129 }
 130
 131 #[derive(Subdiagnostic)]
 132 #[label()]
 133 //~^ ERROR diagnostic slug must be first argument of a `#[label(...)]` attribute
 134 struct M {
 135     #[primary_span]
 136     span: Span,
 137     var: String,
 138 }
 139
 140 #[derive(Subdiagnostic)]
 141 #[label(parser_add_paren, code = "...")]
 142 //~^ ERROR `#[label(code = ...)]` is not a valid attribute
 143 struct N {
 144     #[primary_span]
 145     span: Span,
 146     var: String,
 147 }
 148
 149 #[derive(Subdiagnostic)]
 150 #[label(parser_add_paren, applicability = "machine-applicable")]
 151 //~^ ERROR `#[label(applicability = ...)]` is not a valid attribute
 152 struct O {
 153     #[primary_span]
 154     span: Span,
 155     var: String,
 156 }
 157
 158 #[derive(Subdiagnostic)]
 159 #[foo]
 160 //~^ ERROR cannot find attribute `foo` in this scope
 161 //~^^ ERROR unsupported type attribute for subdiagnostic enum
 162 enum P {
 163     #[label(parser_add_paren)]
 164     A {
 165         #[primary_span]
 166         span: Span,
 167         var: String,
 168     },
 169 }
 170
 171 #[derive(Subdiagnostic)]
 172 enum Q {
 173     #[bar]
 174     //~^ ERROR `#[bar]` is not a valid attribute
 175     //~^^ ERROR cannot find attribute `bar` in this scope
 176     A {
 177         #[primary_span]
 178         span: Span,
 179         var: String,
 180     },
 181 }
 182
 183 #[derive(Subdiagnostic)]
 184 enum R {
 185     #[bar = "..."]
 186     //~^ ERROR `#[bar = ...]` is not a valid attribute
 187     //~^^ ERROR cannot find attribute `bar` in this scope
 188     A {
 189         #[primary_span]
 190         span: Span,
 191         var: String,
 192     },
 193 }
 194
 195 #[derive(Subdiagnostic)]
 196 enum S {
 197     #[bar = 4]
 198     //~^ ERROR `#[bar = ...]` is not a valid attribute
 199     //~^^ ERROR cannot find attribute `bar` in this scope
 200     A {
 201         #[primary_span]
 202         span: Span,
 203         var: String,
 204     },
 205 }
 206
 207 #[derive(Subdiagnostic)]
 208 enum T {
 209     #[bar("...")]
 210     //~^ ERROR `#[bar(...)]` is not a valid attribute
 211     //~^^ ERROR cannot find attribute `bar` in this scope
 212     A {
 213         #[primary_span]
 214         span: Span,
 215         var: String,
 216     },
 217 }
 218
 219 #[derive(Subdiagnostic)]
 220 enum U {
 221     #[label(code = "...")]
 222     //~^ ERROR diagnostic slug must be first argument of a `#[label(...)]` attribute
 223     //~| ERROR `#[label(code = ...)]` is not a valid attribute
 224     A {
 225         #[primary_span]
 226         span: Span,
 227         var: String,
 228     },
 229 }
 230
 231 #[derive(Subdiagnostic)]
 232 enum V {
 233     #[label(parser_add_paren)]
 234     A {
 235         #[primary_span]
 236         span: Span,
 237         var: String,
 238     },
 239     B {
 240         #[primary_span]
 241         span: Span,
 242         var: String,
 243     },
 244 }
 245
 246 #[derive(Subdiagnostic)]
 247 #[label(parser_add_paren)]
 248 //~^ ERROR label without `#[primary_span]` field
 249 struct W {
 250     #[primary_span]
 251     //~^ ERROR the `#[primary_span]` attribute can only be applied to fields of type `Span` or `MultiSpan`
 252     span: String,
 253 }
 254
 255 #[derive(Subdiagnostic)]
 256 #[label(parser_add_paren)]
 257 struct X {
 258     #[primary_span]
 259     span: Span,
 260     #[applicability]
 261     //~^ ERROR `#[applicability]` is only valid on suggestions
 262     applicability: Applicability,
 263 }
 264
 265 #[derive(Subdiagnostic)]
 266 #[label(parser_add_paren)]
 267 struct Y {
 268     #[primary_span]
 269     span: Span,
 270     #[bar]
 271     //~^ ERROR `#[bar]` is not a valid attribute
 272     //~^^ ERROR cannot find attribute `bar` in this scope
 273     bar: String,
 274 }
 275
 276 #[derive(Subdiagnostic)]
 277 #[label(parser_add_paren)]
 278 struct Z {
 279     #[primary_span]
 280     span: Span,
 281     #[bar = "..."]
 282     //~^ ERROR `#[bar = ...]` is not a valid attribute
 283     //~^^ ERROR cannot find attribute `bar` in this scope
 284     bar: String,
 285 }
 286
 287 #[derive(Subdiagnostic)]
 288 #[label(parser_add_paren)]
 289 struct AA {
 290     #[primary_span]
 291     span: Span,
 292     #[bar("...")]
 293     //~^ ERROR `#[bar(...)]` is not a valid attribute
 294     //~^^ ERROR cannot find attribute `bar` in this scope
 295     bar: String,
 296 }
 297
 298 #[derive(Subdiagnostic)]
 299 #[label(parser_add_paren)]
 300 struct AB {
 301     #[primary_span]
 302     span: Span,
 303     #[skip_arg]
 304     z: Z,
 305 }
 306
 307 #[derive(Subdiagnostic)]
 308 union AC {
 309     //~^ ERROR unexpected unsupported untagged union
 310     span: u32,
 311     b: u64,
 312 }
 313
 314 #[derive(Subdiagnostic)]
 315 #[label(parser_add_paren)]
 316 #[label(parser_add_paren)]
 317 struct AD {
 318     #[primary_span]
 319     span: Span,
 320 }
 321
 322 #[derive(Subdiagnostic)]
 323 #[label(parser_add_paren, parser_add_paren)]
 324 //~^ ERROR `#[label(parser_add_paren)]` is not a valid attribute
 325 struct AE {
 326     #[primary_span]
 327     span: Span,
 328 }
 329
 330 #[derive(Subdiagnostic)]
 331 #[label(parser_add_paren)]
 332 struct AF {
 333     #[primary_span]
 334     //~^ NOTE previously specified here
 335     span_a: Span,
 336     #[primary_span]
 337     //~^ ERROR specified multiple times
 338     span_b: Span,
 339 }
 340
 341 #[derive(Subdiagnostic)]
 342 struct AG {
 343     //~^ ERROR subdiagnostic kind not specified
 344     #[primary_span]
 345     span: Span,
 346 }
 347
 348 #[derive(Subdiagnostic)]
 349 #[suggestion(parser_add_paren, code = "...")]
 350 struct AH {
 351     #[primary_span]
 352     span: Span,
 353     #[applicability]
 354     applicability: Applicability,
 355     var: String,
 356 }
 357
 358 #[derive(Subdiagnostic)]
 359 enum AI {
 360     #[suggestion(parser_add_paren, code = "...")]
 361     A {
 362         #[primary_span]
 363         span: Span,
 364         #[applicability]
 365         applicability: Applicability,
 366         var: String,
 367     },
 368     #[suggestion(parser_add_paren, code = "...")]
 369     B {
 370         #[primary_span]
 371         span: Span,
 372         #[applicability]
 373         applicability: Applicability,
 374         var: String,
 375     },
 376 }
 377
 378 #[derive(Subdiagnostic)]
 379 #[suggestion(parser_add_paren, code = "...", code = "...")]
 380 //~^ ERROR specified multiple times
 381 //~^^ NOTE previously specified here
 382 struct AJ {
 383     #[primary_span]
 384     span: Span,
 385     #[applicability]
 386     applicability: Applicability,
 387 }
 388
 389 #[derive(Subdiagnostic)]
 390 #[suggestion(parser_add_paren, code = "...")]
 391 struct AK {
 392     #[primary_span]
 393     span: Span,
 394     #[applicability]
 395     //~^ NOTE previously specified here
 396     applicability_a: Applicability,
 397     #[applicability]
 398     //~^ ERROR specified multiple times
 399     applicability_b: Applicability,
 400 }
 401
 402 #[derive(Subdiagnostic)]
 403 #[suggestion(parser_add_paren, code = "...")]
 404 struct AL {
 405     #[primary_span]
 406     span: Span,
 407     #[applicability]
 408     //~^ ERROR the `#[applicability]` attribute can only be applied to fields of type `Applicability`
 409     applicability: Span,
 410 }
 411
 412 #[derive(Subdiagnostic)]
 413 #[suggestion(parser_add_paren, code = "...")]
 414 struct AM {
 415     #[primary_span]
 416     span: Span,
 417 }
 418
 419 #[derive(Subdiagnostic)]
 420 #[suggestion(parser_add_paren)]
 421 //~^ ERROR suggestion without `code = "..."`
 422 struct AN {
 423     #[primary_span]
 424     span: Span,
 425     #[applicability]
 426     applicability: Applicability,
 427 }
 428
 429 #[derive(Subdiagnostic)]
 430 #[suggestion(parser_add_paren, code = "...", applicability = "foo")]
 431 //~^ ERROR invalid applicability
 432 struct AO {
 433     #[primary_span]
 434     span: Span,
 435 }
 436
 437 #[derive(Subdiagnostic)]
 438 #[help(parser_add_paren)]
 439 struct AP {
 440     var: String,
 441 }
 442
 443 #[derive(Subdiagnostic)]
 444 #[note(parser_add_paren)]
 445 struct AQ;
 446
 447 #[derive(Subdiagnostic)]
 448 #[suggestion(parser_add_paren, code = "...")]
 449 //~^ ERROR suggestion without `#[primary_span]` field
 450 struct AR {
 451     var: String,
 452 }
 453
 454 #[derive(Subdiagnostic)]
 455 #[suggestion(parser_add_paren, code = "...", applicability = "machine-applicable")]
 456 struct AS {
 457     #[primary_span]
 458     span: Span,
 459 }
 460
 461 #[derive(Subdiagnostic)]
 462 #[label]
 463 //~^ ERROR unsupported type attribute for subdiagnostic enum
 464 enum AT {
 465     #[label(parser_add_paren)]
 466     A {
 467         #[primary_span]
 468         span: Span,
 469         var: String,
 470     },
 471 }
 472
 473 #[derive(Subdiagnostic)]
 474 #[suggestion(parser_add_paren, code = "{var}", applicability = "machine-applicable")]
 475 struct AU {
 476     #[primary_span]
 477     span: Span,
 478     var: String,
 479 }
 480
 481 #[derive(Subdiagnostic)]
 482 #[suggestion(parser_add_paren, code = "{var}", applicability = "machine-applicable")]
 483 //~^ ERROR `var` doesn't refer to a field on this type
 484 struct AV {
 485     #[primary_span]
 486     span: Span,
 487 }
 488
 489 #[derive(Subdiagnostic)]
 490 enum AW {
 491     #[suggestion(parser_add_paren, code = "{var}", applicability = "machine-applicable")]
 492     A {
 493         #[primary_span]
 494         span: Span,
 495         var: String,
 496     },
 497 }
 498
 499 #[derive(Subdiagnostic)]
 500 enum AX {
 501     #[suggestion(parser_add_paren, code = "{var}", applicability = "machine-applicable")]
 502     //~^ ERROR `var` doesn't refer to a field on this type
 503     A {
 504         #[primary_span]
 505         span: Span,
 506     },
 507 }
 508
 509 #[derive(Subdiagnostic)]
 510 #[warning(parser_add_paren)]
 511 struct AY {}
 512
 513 #[derive(Subdiagnostic)]
 514 #[warning(parser_add_paren)]
 515 struct AZ {
 516     #[primary_span]
 517     span: Span,
 518 }
 519
 520 #[derive(Subdiagnostic)]
 521 #[suggestion(parser_add_paren, code = "...")]
 522 //~^ ERROR suggestion without `#[primary_span]` field
 523 struct BA {
 524     #[suggestion_part]
 525     //~^ ERROR `#[suggestion_part]` is not a valid attribute
 526     span: Span,
 527     #[suggestion_part(code = "...")]
 528     //~^ ERROR `#[suggestion_part(...)]` is not a valid attribute
 529     span2: Span,
 530     #[applicability]
 531     applicability: Applicability,
 532     var: String,
 533 }
 534
 535 #[derive(Subdiagnostic)]
 536 #[multipart_suggestion(parser_add_paren, code = "...", applicability = "machine-applicable")]
 537 //~^ ERROR multipart suggestion without any `#[suggestion_part(...)]` fields
 538 //~| ERROR `#[multipart_suggestion(code = ...)]` is not a valid attribute
 539 struct BBa {
 540     var: String,
 541 }
 542
 543 #[derive(Subdiagnostic)]
 544 #[multipart_suggestion(parser_add_paren, applicability = "machine-applicable")]
 545 struct BBb {
 546     #[suggestion_part]
 547     //~^ ERROR `#[suggestion_part(...)]` attribute without `code = "..."`
 548     span1: Span,
 549 }
 550
 551 #[derive(Subdiagnostic)]
 552 #[multipart_suggestion(parser_add_paren, applicability = "machine-applicable")]
 553 struct BBc {
 554     #[suggestion_part()]
 555     //~^ ERROR `#[suggestion_part(...)]` attribute without `code = "..."`
 556     span1: Span,
 557 }
 558
 559 #[derive(Subdiagnostic)]
 560 #[multipart_suggestion(parser_add_paren)]
 561 //~^ ERROR multipart suggestion without any `#[suggestion_part(...)]` fields
 562 struct BC {
 563     #[primary_span]
 564     //~^ ERROR `#[primary_span]` is not a valid attribute
 565     span: Span,
 566 }
 567
 568 #[derive(Subdiagnostic)]
 569 #[multipart_suggestion(parser_add_paren)]
 570 struct BD {
 571     #[suggestion_part]
 572     //~^ ERROR `#[suggestion_part(...)]` attribute without `code = "..."`
 573     span1: Span,
 574     #[suggestion_part()]
 575     //~^ ERROR `#[suggestion_part(...)]` attribute without `code = "..."`
 576     span2: Span,
 577     #[suggestion_part(foo = "bar")]
 578     //~^ ERROR `#[suggestion_part(foo = ...)]` is not a valid attribute
 579     span4: Span,
 580     #[suggestion_part(code = "...")]
 581     //~^ ERROR the `#[suggestion_part(...)]` attribute can only be applied to fields of type `Span` or `MultiSpan`
 582     s1: String,
 583     #[suggestion_part()]
 584     //~^ ERROR the `#[suggestion_part(...)]` attribute can only be applied to fields of type `Span` or `MultiSpan`
 585     s2: String,
 586 }
 587
 588 #[derive(Subdiagnostic)]
 589 #[multipart_suggestion(parser_add_paren, applicability = "machine-applicable")]
 590 struct BE {
 591     #[suggestion_part(code = "...", code = ",,,")]
 592     //~^ ERROR specified multiple times
 593     //~| NOTE previously specified here
 594     span: Span,
 595 }
 596
 597 #[derive(Subdiagnostic)]
 598 #[multipart_suggestion(parser_add_paren, applicability = "machine-applicable")]
 599 struct BF {
 600     #[suggestion_part(code = "(")]
 601     first: Span,
 602     #[suggestion_part(code = ")")]
 603     second: Span,
 604 }
 605
 606 #[derive(Subdiagnostic)]
 607 #[multipart_suggestion(parser_add_paren)]
 608 struct BG {
 609     #[applicability]
 610     appl: Applicability,
 611     #[suggestion_part(code = "(")]
 612     first: Span,
 613     #[suggestion_part(code = ")")]
 614     second: Span,
 615 }
 616
 617 #[derive(Subdiagnostic)]
 618 #[multipart_suggestion(parser_add_paren, applicability = "machine-applicable")]
 619 struct BH {
 620     #[applicability]
 621     //~^ ERROR `#[applicability]` has no effect
 622     appl: Applicability,
 623     #[suggestion_part(code = "(")]
 624     first: Span,
 625     #[suggestion_part(code = ")")]
 626     second: Span,
 627 }
 628
 629 #[derive(Subdiagnostic)]
 630 #[multipart_suggestion(parser_add_paren, applicability = "machine-applicable")]
 631 struct BI {
 632     #[suggestion_part(code = "")]
 633     spans: Vec<Span>,
 634 }
 635
 636 #[derive(Subdiagnostic)]
 637 #[label(parser_add_paren)]
 638 struct BJ {
 639     #[primary_span]
 640     span: Span,
 641     r#type: String,
 642 }
 643
 644 /// with a doc comment on the type..
 645 #[derive(Subdiagnostic)]
 646 #[label(parser_add_paren)]
 647 struct BK {
 648     /// ..and the field
 649     #[primary_span]
 650     span: Span,
 651 }
 652
 653 /// with a doc comment on the type..
 654 #[derive(Subdiagnostic)]
 655 enum BL {
 656     /// ..and the variant..
 657     #[label(parser_add_paren)]
 658     Foo {
 659         /// ..and the field
 660         #[primary_span]
 661         span: Span,
 662     },
 663 }
 664
 665 #[derive(Subdiagnostic)]
 666 #[multipart_suggestion(parser_add_paren)]
 667 struct BM {
 668     #[suggestion_part(code("foo"))]
 669     //~^ ERROR expected exactly one string literal for `code = ...`
 670     span: Span,
 671     r#type: String,
 672 }
 673
 674 #[derive(Subdiagnostic)]
 675 #[multipart_suggestion(parser_add_paren)]
 676 struct BN {
 677     #[suggestion_part(code("foo", "bar"))]
 678     //~^ ERROR expected exactly one string literal for `code = ...`
 679     span: Span,
 680     r#type: String,
 681 }
 682
 683 #[derive(Subdiagnostic)]
 684 #[multipart_suggestion(parser_add_paren)]
 685 struct BO {
 686     #[suggestion_part(code(3))]
 687     //~^ ERROR expected exactly one string literal for `code = ...`
 688     span: Span,
 689     r#type: String,
 690 }
 691
 692 #[derive(Subdiagnostic)]
 693 #[multipart_suggestion(parser_add_paren)]
 694 struct BP {
 695     #[suggestion_part(code())]
 696     //~^ ERROR expected exactly one string literal for `code = ...`
 697     span: Span,
 698     r#type: String,
 699 }
 700
 701 #[derive(Subdiagnostic)]
 702 #[multipart_suggestion(parser_add_paren)]
 703 struct BQ {
 704     #[suggestion_part(code = 3)]
 705     //~^ ERROR `code = "..."`/`code(...)` must contain only string literals
 706     span: Span,
 707     r#type: String,
 708 }
 709
 710 #[derive(Subdiagnostic)]
 711 #[suggestion(parser_add_paren, code = "")]
 712 struct SuggestionStyleDefault {
 713     #[primary_span]
 714     sub: Span,
 715 }
 716
 717 #[derive(Subdiagnostic)]
 718 #[suggestion(parser_add_paren, code = "", style = "short")]
 719 struct SuggestionStyleShort {
 720     #[primary_span]
 721     sub: Span,
 722 }
 723
 724 #[derive(Subdiagnostic)]
 725 #[suggestion(parser_add_paren, code = "", style = "hidden")]
 726 struct SuggestionStyleHidden {
 727     #[primary_span]
 728     sub: Span,
 729 }
 730
 731 #[derive(Subdiagnostic)]
 732 #[suggestion(parser_add_paren, code = "", style = "verbose")]
 733 struct SuggestionStyleVerbose {
 734     #[primary_span]
 735     sub: Span,
 736 }
 737
 738 #[derive(Subdiagnostic)]
 739 #[suggestion(parser_add_paren, code = "", style = "tool-only")]
 740 struct SuggestionStyleToolOnly {
 741     #[primary_span]
 742     sub: Span,
 743 }
 744
 745 #[derive(Subdiagnostic)]
 746 #[suggestion(parser_add_paren, code = "", style = "hidden", style = "normal")]
 747 //~^ ERROR specified multiple times
 748 //~| NOTE previously specified here
 749 struct SuggestionStyleTwice {
 750     #[primary_span]
 751     sub: Span,
 752 }
 753
 754 #[derive(Subdiagnostic)]
 755 #[suggestion_hidden(parser_add_paren, code = "")]
 756 //~^ ERROR #[suggestion_hidden(...)]` is not a valid attribute
 757 struct SuggestionStyleOldSyntax {
 758     #[primary_span]
 759     sub: Span,
 760 }
 761
 762 #[derive(Subdiagnostic)]
 763 #[suggestion_hidden(parser_add_paren, code = "", style = "normal")]
 764 //~^ ERROR #[suggestion_hidden(...)]` is not a valid attribute
 765 struct SuggestionStyleOldAndNewSyntax {
 766     #[primary_span]
 767     sub: Span,
 768 }
 769
 770 #[derive(Subdiagnostic)]
 771 #[suggestion(parser_add_paren, code = "", style = "foo")]
 772 //~^ ERROR invalid suggestion style
 773 struct SuggestionStyleInvalid1 {
 774     #[primary_span]
 775     sub: Span,
 776 }
 777
 778 #[derive(Subdiagnostic)]
 779 #[suggestion(parser_add_paren, code = "", style = 42)]
 780 //~^ ERROR `#[suggestion(style = ...)]` is not a valid attribute
 781 struct SuggestionStyleInvalid2 {
 782     #[primary_span]
 783     sub: Span,
 784 }
 785
 786 #[derive(Subdiagnostic)]
 787 #[suggestion(parser_add_paren, code = "", style)]
 788 //~^ ERROR `#[suggestion(style)]` is not a valid attribute
 789 struct SuggestionStyleInvalid3 {
 790     #[primary_span]
 791     sub: Span,
 792 }
 793
 794 #[derive(Subdiagnostic)]
 795 #[suggestion(parser_add_paren, code = "", style("foo"))]
 796 //~^ ERROR `#[suggestion(style(...))]` is not a valid attribute
 797 struct SuggestionStyleInvalid4 {
 798     #[primary_span]
 799     sub: Span,
 800 }