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

   1 // check-fail
   2 // Tests error conditions for specifying subdiagnostics using #[derive(SessionSubdiagnostic)]
   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 SessionSubdiagnostic 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_session;
  15 extern crate rustc_span;
  16 extern crate rustc_macros;
  17
  18 use rustc_errors::Applicability;
  19 use rustc_span::Span;
  20 use rustc_macros::SessionSubdiagnostic;
  21
  22 #[derive(SessionSubdiagnostic)]
  23 #[label(parser::add_paren)]
  24 struct A {
  25     #[primary_span]
  26     span: Span,
  27     var: String,
  28 }
  29
  30 #[derive(SessionSubdiagnostic)]
  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(SessionSubdiagnostic)]
  47 #[label(parser::add_paren)]
  48 //~^ ERROR label without `#[primary_span]` field
  49 struct C {
  50     var: String,
  51 }
  52
  53 #[derive(SessionSubdiagnostic)]
  54 #[label]
  55 //~^ ERROR `#[label]` is not a valid attribute
  56 struct D {
  57     #[primary_span]
  58     span: Span,
  59     var: String,
  60 }
  61
  62 #[derive(SessionSubdiagnostic)]
  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(SessionSubdiagnostic)]
  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(SessionSubdiagnostic)]
  82 #[label(bug = "...")]
  83 //~^ ERROR `#[label(bug = ...)]` is not a valid attribute
  84 struct G {
  85     #[primary_span]
  86     span: Span,
  87     var: String,
  88 }
  89
  90 #[derive(SessionSubdiagnostic)]
  91 #[label("...")]
  92 //~^ ERROR `#[label("...")]` is not a valid attribute
  93 struct H {
  94     #[primary_span]
  95     span: Span,
  96     var: String,
  97 }
  98
  99 #[derive(SessionSubdiagnostic)]
 100 #[label(slug = 4)]
 101 //~^ ERROR `#[label(slug = ...)]` is not a valid attribute
 102 struct J {
 103     #[primary_span]
 104     span: Span,
 105     var: String,
 106 }
 107
 108 #[derive(SessionSubdiagnostic)]
 109 #[label(slug("..."))]
 110 //~^ ERROR `#[label(slug(...))]` is not a valid attribute
 111 struct K {
 112     #[primary_span]
 113     span: Span,
 114     var: String,
 115 }
 116
 117 #[derive(SessionSubdiagnostic)]
 118 #[label(slug)]
 119 //~^ ERROR cannot find value `slug` in module `rustc_errors::fluent`
 120 //~^^ NOTE not found in `rustc_errors::fluent`
 121 struct L {
 122     #[primary_span]
 123     span: Span,
 124     var: String,
 125 }
 126
 127 #[derive(SessionSubdiagnostic)]
 128 #[label()]
 129 //~^ ERROR diagnostic slug must be first argument of a `#[label(...)]` attribute
 130 struct M {
 131     #[primary_span]
 132     span: Span,
 133     var: String,
 134 }
 135
 136 #[derive(SessionSubdiagnostic)]
 137 #[label(parser::add_paren, code = "...")]
 138 //~^ ERROR `code` is not a valid nested attribute of a `label` attribute
 139 struct N {
 140     #[primary_span]
 141     span: Span,
 142     var: String,
 143 }
 144
 145 #[derive(SessionSubdiagnostic)]
 146 #[label(parser::add_paren, applicability = "machine-applicable")]
 147 //~^ ERROR `applicability` is not a valid nested attribute of a `label` attribute
 148 struct O {
 149     #[primary_span]
 150     span: Span,
 151     var: String,
 152 }
 153
 154 #[derive(SessionSubdiagnostic)]
 155 #[foo]
 156 //~^ ERROR cannot find attribute `foo` in this scope
 157 //~^^ ERROR unsupported type attribute for subdiagnostic enum
 158 enum P {
 159     #[label(parser::add_paren)]
 160     A {
 161         #[primary_span]
 162         span: Span,
 163         var: String,
 164     }
 165 }
 166
 167 #[derive(SessionSubdiagnostic)]
 168 enum Q {
 169     #[bar]
 170     //~^ ERROR `#[bar]` is not a valid attribute
 171     //~^^ ERROR cannot find attribute `bar` in this scope
 172     A {
 173         #[primary_span]
 174         span: Span,
 175         var: String,
 176     }
 177 }
 178
 179 #[derive(SessionSubdiagnostic)]
 180 enum R {
 181     #[bar = "..."]
 182     //~^ ERROR `#[bar = ...]` is not a valid attribute
 183     //~^^ ERROR cannot find attribute `bar` in this scope
 184     A {
 185         #[primary_span]
 186         span: Span,
 187         var: String,
 188     }
 189 }
 190
 191 #[derive(SessionSubdiagnostic)]
 192 enum S {
 193     #[bar = 4]
 194     //~^ ERROR `#[bar = ...]` is not a valid attribute
 195     //~^^ ERROR cannot find attribute `bar` in this scope
 196     A {
 197         #[primary_span]
 198         span: Span,
 199         var: String,
 200     }
 201 }
 202
 203 #[derive(SessionSubdiagnostic)]
 204 enum T {
 205     #[bar("...")]
 206     //~^ ERROR `#[bar(...)]` is not a valid attribute
 207     //~^^ ERROR cannot find attribute `bar` in this scope
 208     A {
 209         #[primary_span]
 210         span: Span,
 211         var: String,
 212     }
 213 }
 214
 215 #[derive(SessionSubdiagnostic)]
 216 enum U {
 217     #[label(code = "...")]
 218     //~^ ERROR diagnostic slug must be first argument of a `#[label(...)]` attribute
 219     A {
 220         #[primary_span]
 221         span: Span,
 222         var: String,
 223     }
 224 }
 225
 226 #[derive(SessionSubdiagnostic)]
 227 enum V {
 228     #[label(parser::add_paren)]
 229     A {
 230         #[primary_span]
 231         span: Span,
 232         var: String,
 233     },
 234     B {
 235     //~^ ERROR subdiagnostic kind not specified
 236         #[primary_span]
 237         span: Span,
 238         var: String,
 239     }
 240 }
 241
 242 #[derive(SessionSubdiagnostic)]
 243 #[label(parser::add_paren)]
 244 //~^ ERROR label without `#[primary_span]` field
 245 struct W {
 246     #[primary_span]
 247     //~^ ERROR the `#[primary_span]` attribute can only be applied to fields of type `Span` or `MultiSpan`
 248     span: String,
 249 }
 250
 251 #[derive(SessionSubdiagnostic)]
 252 #[label(parser::add_paren)]
 253 struct X {
 254     #[primary_span]
 255     span: Span,
 256     #[applicability]
 257     //~^ ERROR `#[applicability]` is only valid on suggestions
 258     applicability: Applicability,
 259 }
 260
 261 #[derive(SessionSubdiagnostic)]
 262 #[label(parser::add_paren)]
 263 struct Y {
 264     #[primary_span]
 265     span: Span,
 266     #[bar]
 267     //~^ ERROR `#[bar]` is not a valid attribute
 268     //~^^ ERROR cannot find attribute `bar` in this scope
 269     bar: String,
 270 }
 271
 272 #[derive(SessionSubdiagnostic)]
 273 #[label(parser::add_paren)]
 274 struct Z {
 275     #[primary_span]
 276     span: Span,
 277     #[bar = "..."]
 278     //~^ ERROR `#[bar = ...]` is not a valid attribute
 279     //~^^ ERROR cannot find attribute `bar` in this scope
 280     bar: String,
 281 }
 282
 283 #[derive(SessionSubdiagnostic)]
 284 #[label(parser::add_paren)]
 285 struct AA {
 286     #[primary_span]
 287     span: Span,
 288     #[bar("...")]
 289     //~^ ERROR `#[bar(...)]` is not a valid attribute
 290     //~^^ ERROR cannot find attribute `bar` in this scope
 291     bar: String,
 292 }
 293
 294 #[derive(SessionSubdiagnostic)]
 295 #[label(parser::add_paren)]
 296 struct AB {
 297     #[primary_span]
 298     span: Span,
 299     #[skip_arg]
 300     z: Z
 301 }
 302
 303 #[derive(SessionSubdiagnostic)]
 304 union AC {
 305 //~^ ERROR unexpected unsupported untagged union
 306     span: u32,
 307     b: u64
 308 }
 309
 310 #[derive(SessionSubdiagnostic)]
 311 #[label(parser::add_paren)]
 312 //~^ NOTE previously specified here
 313 //~^^ NOTE previously specified here
 314 #[label(parser::add_paren)]
 315 //~^ ERROR specified multiple times
 316 //~^^ ERROR specified multiple times
 317 struct AD {
 318     #[primary_span]
 319     span: Span,
 320 }
 321
 322 #[derive(SessionSubdiagnostic)]
 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(SessionSubdiagnostic)]
 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(SessionSubdiagnostic)]
 342 struct AG {
 343     //~^ ERROR subdiagnostic kind not specified
 344     #[primary_span]
 345     span: Span,
 346 }
 347
 348 #[derive(SessionSubdiagnostic)]
 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(SessionSubdiagnostic)]
 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(SessionSubdiagnostic)]
 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(SessionSubdiagnostic)]
 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(SessionSubdiagnostic)]
 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(SessionSubdiagnostic)]
 413 #[suggestion(parser::add_paren, code = "...")]
 414 struct AM {
 415     #[primary_span]
 416     span: Span,
 417 }
 418
 419 #[derive(SessionSubdiagnostic)]
 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(SessionSubdiagnostic)]
 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(SessionSubdiagnostic)]
 438 #[help(parser::add_paren)]
 439 struct AP {
 440     var: String
 441 }
 442
 443 #[derive(SessionSubdiagnostic)]
 444 #[note(parser::add_paren)]
 445 struct AQ;
 446
 447 #[derive(SessionSubdiagnostic)]
 448 #[suggestion(parser::add_paren, code = "...")]
 449 //~^ ERROR suggestion without `#[primary_span]` field
 450 struct AR {
 451     var: String,
 452 }
 453
 454 #[derive(SessionSubdiagnostic)]
 455 #[suggestion(parser::add_paren, code ="...", applicability = "machine-applicable")]
 456 struct AS {
 457     #[primary_span]
 458     span: Span,
 459 }
 460
 461 #[derive(SessionSubdiagnostic)]
 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(SessionSubdiagnostic)]
 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(SessionSubdiagnostic)]
 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(SessionSubdiagnostic)]
 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(SessionSubdiagnostic)]
 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(SessionSubdiagnostic)]
 510 #[warning(parser::add_paren)]
 511 struct AY {}
 512
 513 #[derive(SessionSubdiagnostic)]
 514 #[warning(parser::add_paren)]
 515 struct AZ {
 516     #[primary_span]
 517     span: Span,
 518 }