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`
 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 //~^ ERROR suggestion without `applicability`
 405 struct AL {
 406     #[primary_span]
 407     span: Span,
 408     #[applicability]
 409 //~^ ERROR the `#[applicability]` attribute can only be applied to fields of type `Applicability`
 410     applicability: Span,
 411 }
 412
 413 #[derive(SessionSubdiagnostic)]
 414 #[suggestion(parser::add_paren, code = "...")]
 415 //~^ ERROR suggestion without `applicability`
 416 struct AM {
 417     #[primary_span]
 418     span: Span,
 419 }
 420
 421 #[derive(SessionSubdiagnostic)]
 422 #[suggestion(parser::add_paren)]
 423 //~^ ERROR suggestion without `code = "..."`
 424 struct AN {
 425     #[primary_span]
 426     span: Span,
 427     #[applicability]
 428     applicability: Applicability,
 429 }
 430
 431 #[derive(SessionSubdiagnostic)]
 432 #[suggestion(parser::add_paren, code ="...", applicability = "foo")]
 433 //~^ ERROR invalid applicability
 434 struct AO {
 435     #[primary_span]
 436     span: Span,
 437 }
 438
 439 #[derive(SessionSubdiagnostic)]
 440 #[help(parser::add_paren)]
 441 struct AP {
 442     var: String
 443 }
 444
 445 #[derive(SessionSubdiagnostic)]
 446 #[note(parser::add_paren)]
 447 struct AQ;
 448
 449 #[derive(SessionSubdiagnostic)]
 450 #[suggestion(parser::add_paren, code = "...")]
 451 //~^ ERROR suggestion without `applicability`
 452 //~^^ ERROR suggestion without `#[primary_span]` field
 453 struct AR {
 454     var: String,
 455 }
 456
 457 #[derive(SessionSubdiagnostic)]
 458 #[suggestion(parser::add_paren, code ="...", applicability = "machine-applicable")]
 459 struct AS {
 460     #[primary_span]
 461     span: Span,
 462 }
 463
 464 #[derive(SessionSubdiagnostic)]
 465 #[label]
 466 //~^ ERROR unsupported type attribute for subdiagnostic enum
 467 enum AT {
 468     #[label(parser::add_paren)]
 469     A {
 470         #[primary_span]
 471         span: Span,
 472         var: String,
 473     }
 474 }
 475
 476 #[derive(SessionSubdiagnostic)]
 477 #[suggestion(parser::add_paren, code ="{var}", applicability = "machine-applicable")]
 478 struct AU {
 479     #[primary_span]
 480     span: Span,
 481     var: String,
 482 }
 483
 484 #[derive(SessionSubdiagnostic)]
 485 #[suggestion(parser::add_paren, code ="{var}", applicability = "machine-applicable")]
 486 //~^ ERROR `var` doesn't refer to a field on this type
 487 struct AV {
 488     #[primary_span]
 489     span: Span,
 490 }
 491
 492 #[derive(SessionSubdiagnostic)]
 493 enum AW {
 494     #[suggestion(parser::add_paren, code ="{var}", applicability = "machine-applicable")]
 495     A {
 496         #[primary_span]
 497         span: Span,
 498         var: String,
 499     }
 500 }
 501
 502 #[derive(SessionSubdiagnostic)]
 503 enum AX {
 504     #[suggestion(parser::add_paren, code ="{var}", applicability = "machine-applicable")]
 505 //~^ ERROR `var` doesn't refer to a field on this type
 506     A {
 507         #[primary_span]
 508         span: Span,
 509     }
 510 }