src/test/incremental/hashes/enum_defs.rs

   1 // Copyright 2016 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11
  12 // This test case tests the incremental compilation hash (ICH) implementation
  13 // for enum definitions.
  14
  15 // The general pattern followed here is: Change one thing between rev1 and rev2
  16 // and make sure that the hash has changed, then change nothing between rev2 and
  17 // rev3 and make sure that the hash has not changed.
  18
  19 // We also test the ICH for enum definitions exported in metadata. Same as
  20 // above, we want to make sure that the change between rev1 and rev2 also
  21 // results in a change of the ICH for the enum's metadata, and that it stays
  22 // the same between rev2 and rev3.
  23
  24 // must-compile-successfully
  25 // revisions: cfail1 cfail2 cfail3
  26 // compile-flags: -Z query-dep-graph
  27
  28 #![allow(warnings)]
  29 #![feature(rustc_attrs)]
  30 #![crate_type="rlib"]
  31
  32
  33
  34 // Change enum visibility -----------------------------------------------------
  35 #[cfg(cfail1)]
  36 enum EnumVisibility { A }
  37
  38 #[cfg(not(cfail1))]
  39 #[rustc_dirty(label="Hir", cfg="cfail2")]
  40 #[rustc_clean(label="Hir", cfg="cfail3")]
  41 #[rustc_metadata_dirty(cfg="cfail2")]
  42 #[rustc_metadata_clean(cfg="cfail3")]
  43 pub enum EnumVisibility {
  44     #[rustc_metadata_dirty(cfg="cfail2")]
  45     #[rustc_metadata_clean(cfg="cfail3")]
  46     A
  47 }
  48
  49
  50
  51 // Change name of a c-style variant -------------------------------------------
  52 #[cfg(cfail1)]
  53 enum EnumChangeNameCStyleVariant {
  54     Variant1,
  55     Variant2,
  56 }
  57
  58 #[cfg(not(cfail1))]
  59 #[rustc_dirty(label="Hir", cfg="cfail2")]
  60 #[rustc_clean(label="Hir", cfg="cfail3")]
  61 #[rustc_metadata_dirty(cfg="cfail2")]
  62 #[rustc_metadata_clean(cfg="cfail3")]
  63 enum EnumChangeNameCStyleVariant {
  64     #[rustc_metadata_dirty(cfg="cfail2")]
  65     #[rustc_metadata_clean(cfg="cfail3")]
  66     Variant1,
  67     #[rustc_metadata_clean(cfg="cfail3")]
  68     Variant2Changed,
  69 }
  70
  71
  72
  73 // Change name of a tuple-style variant ---------------------------------------
  74 #[cfg(cfail1)]
  75 enum EnumChangeNameTupleStyleVariant {
  76     Variant1,
  77     Variant2(u32, f32),
  78 }
  79
  80 #[cfg(not(cfail1))]
  81 #[rustc_dirty(label="Hir", cfg="cfail2")]
  82 #[rustc_clean(label="Hir", cfg="cfail3")]
  83 #[rustc_metadata_dirty(cfg="cfail2")]
  84 #[rustc_metadata_clean(cfg="cfail3")]
  85 enum EnumChangeNameTupleStyleVariant {
  86     Variant1,
  87     Variant2Changed(u32, f32),
  88 }
  89
  90
  91
  92 // Change name of a struct-style variant --------------------------------------
  93 #[cfg(cfail1)]
  94 enum EnumChangeNameStructStyleVariant {
  95     Variant1,
  96     Variant2 { a: u32, b: f32 },
  97 }
  98
  99 #[cfg(not(cfail1))]
 100 #[rustc_dirty(label="Hir", cfg="cfail2")]
 101 #[rustc_clean(label="Hir", cfg="cfail3")]
 102 #[rustc_metadata_dirty(cfg="cfail2")]
 103 #[rustc_metadata_clean(cfg="cfail3")]
 104 enum EnumChangeNameStructStyleVariant {
 105     Variant1,
 106     Variant2Changed { a: u32, b: f32 },
 107 }
 108
 109
 110
 111 // Change the value of a c-style variant --------------------------------------
 112 #[cfg(cfail1)]
 113 enum EnumChangeValueCStyleVariant0 {
 114     Variant1,
 115     Variant2 = 11,
 116 }
 117
 118 #[cfg(not(cfail1))]
 119 #[rustc_clean(label="Hir", cfg="cfail2")]
 120 #[rustc_clean(label="Hir", cfg="cfail3")]
 121 #[rustc_dirty(label="HirBody", cfg="cfail2")]
 122 #[rustc_clean(label="HirBody", cfg="cfail3")]
 123 #[rustc_metadata_clean(cfg="cfail2")]
 124 #[rustc_metadata_clean(cfg="cfail3")]
 125 enum EnumChangeValueCStyleVariant0 {
 126     Variant1,
 127
 128     #[rustc_metadata_dirty(cfg="cfail2")]
 129     #[rustc_metadata_clean(cfg="cfail3")]
 130     Variant2 = 22,
 131 }
 132
 133 #[cfg(cfail1)]
 134 enum EnumChangeValueCStyleVariant1 {
 135     Variant1,
 136     Variant2,
 137 }
 138
 139 #[cfg(not(cfail1))]
 140 #[rustc_dirty(label="Hir", cfg="cfail2")]
 141 #[rustc_clean(label="Hir", cfg="cfail3")]
 142 #[rustc_clean(label="HirBody", cfg="cfail2")]
 143 #[rustc_clean(label="HirBody", cfg="cfail3")]
 144 #[rustc_metadata_dirty(cfg="cfail2")]
 145 #[rustc_metadata_clean(cfg="cfail3")]
 146 enum EnumChangeValueCStyleVariant1 {
 147     Variant1,
 148     Variant2 = 11,
 149 }
 150
 151
 152
 153 // Add a c-style variant ------------------------------------------------------
 154 #[cfg(cfail1)]
 155 enum EnumAddCStyleVariant {
 156     Variant1,
 157 }
 158
 159 #[cfg(not(cfail1))]
 160 #[rustc_dirty(label="Hir", cfg="cfail2")]
 161 #[rustc_clean(label="Hir", cfg="cfail3")]
 162 #[rustc_metadata_dirty(cfg="cfail2")]
 163 #[rustc_metadata_clean(cfg="cfail3")]
 164 enum EnumAddCStyleVariant {
 165     Variant1,
 166     Variant2,
 167 }
 168
 169
 170
 171 // Remove a c-style variant ---------------------------------------------------
 172 #[cfg(cfail1)]
 173 enum EnumRemoveCStyleVariant {
 174     Variant1,
 175     Variant2,
 176 }
 177
 178 #[cfg(not(cfail1))]
 179 #[rustc_dirty(label="Hir", cfg="cfail2")]
 180 #[rustc_clean(label="Hir", cfg="cfail3")]
 181 #[rustc_metadata_dirty(cfg="cfail2")]
 182 #[rustc_metadata_clean(cfg="cfail3")]
 183 enum EnumRemoveCStyleVariant {
 184     Variant1,
 185 }
 186
 187
 188
 189 // Add a tuple-style variant --------------------------------------------------
 190 #[cfg(cfail1)]
 191 enum EnumAddTupleStyleVariant {
 192     Variant1,
 193 }
 194
 195 #[cfg(not(cfail1))]
 196 #[rustc_dirty(label="Hir", cfg="cfail2")]
 197 #[rustc_clean(label="Hir", cfg="cfail3")]
 198 #[rustc_metadata_dirty(cfg="cfail2")]
 199 #[rustc_metadata_clean(cfg="cfail3")]
 200 enum EnumAddTupleStyleVariant {
 201     Variant1,
 202     Variant2(u32, f32),
 203 }
 204
 205
 206
 207 // Remove a tuple-style variant -----------------------------------------------
 208 #[cfg(cfail1)]
 209 enum EnumRemoveTupleStyleVariant {
 210     Variant1,
 211     Variant2(u32, f32),
 212 }
 213
 214 #[cfg(not(cfail1))]
 215 #[rustc_dirty(label="Hir", cfg="cfail2")]
 216 #[rustc_clean(label="Hir", cfg="cfail3")]
 217 #[rustc_metadata_dirty(cfg="cfail2")]
 218 #[rustc_metadata_clean(cfg="cfail3")]
 219 enum EnumRemoveTupleStyleVariant {
 220     Variant1,
 221 }
 222
 223
 224
 225 // Add a struct-style variant -------------------------------------------------
 226 #[cfg(cfail1)]
 227 enum EnumAddStructStyleVariant {
 228     Variant1,
 229 }
 230
 231 #[cfg(not(cfail1))]
 232 #[rustc_dirty(label="Hir", cfg="cfail2")]
 233 #[rustc_clean(label="Hir", cfg="cfail3")]
 234 #[rustc_metadata_dirty(cfg="cfail2")]
 235 #[rustc_metadata_clean(cfg="cfail3")]
 236 enum EnumAddStructStyleVariant {
 237     Variant1,
 238     Variant2 { a: u32, b: f32 },
 239 }
 240
 241
 242
 243 // Remove a struct-style variant ----------------------------------------------
 244 #[cfg(cfail1)]
 245 enum EnumRemoveStructStyleVariant {
 246     Variant1,
 247     Variant2 { a: u32, b: f32 },
 248 }
 249
 250 #[cfg(not(cfail1))]
 251 #[rustc_dirty(label="Hir", cfg="cfail2")]
 252 #[rustc_clean(label="Hir", cfg="cfail3")]
 253 #[rustc_metadata_dirty(cfg="cfail2")]
 254 #[rustc_metadata_clean(cfg="cfail3")]
 255 enum EnumRemoveStructStyleVariant {
 256     Variant1,
 257 }
 258
 259
 260
 261 // Change the type of a field in a tuple-style variant ------------------------
 262 #[cfg(cfail1)]
 263 enum EnumChangeFieldTypeTupleStyleVariant {
 264     Variant1(u32, u32),
 265 }
 266
 267 #[cfg(not(cfail1))]
 268 #[rustc_dirty(label="Hir", cfg="cfail2")]
 269 #[rustc_clean(label="Hir", cfg="cfail3")]
 270 #[rustc_metadata_clean(cfg="cfail2")]
 271 #[rustc_metadata_clean(cfg="cfail3")]
 272 enum EnumChangeFieldTypeTupleStyleVariant {
 273     Variant1(u32,
 274         #[rustc_metadata_dirty(cfg="cfail2")]
 275         #[rustc_metadata_clean(cfg="cfail3")]
 276         u64),
 277 }
 278
 279
 280
 281 // Change the type of a field in a struct-style variant -----------------------
 282 #[cfg(cfail1)]
 283 enum EnumChangeFieldTypeStructStyleVariant {
 284     Variant1,
 285     Variant2 { a: u32, b: u32 },
 286 }
 287
 288 #[cfg(not(cfail1))]
 289 #[rustc_dirty(label="Hir", cfg="cfail2")]
 290 #[rustc_clean(label="Hir", cfg="cfail3")]
 291 #[rustc_metadata_clean(cfg="cfail2")]
 292 #[rustc_metadata_clean(cfg="cfail3")]
 293 enum EnumChangeFieldTypeStructStyleVariant {
 294     Variant1,
 295     Variant2 {
 296         a: u32,
 297         #[rustc_metadata_dirty(cfg="cfail2")]
 298         #[rustc_metadata_clean(cfg="cfail3")]
 299         b: u64
 300     },
 301 }
 302
 303
 304
 305 // Change the name of a field in a struct-style variant -----------------------
 306 #[cfg(cfail1)]
 307 enum EnumChangeFieldNameStructStyleVariant {
 308     Variant1 { a: u32, b: u32 },
 309 }
 310
 311 #[cfg(not(cfail1))]
 312 #[rustc_dirty(label="Hir", cfg="cfail2")]
 313 #[rustc_clean(label="Hir", cfg="cfail3")]
 314 #[rustc_metadata_dirty(cfg="cfail2")]
 315 #[rustc_metadata_clean(cfg="cfail3")]
 316 enum EnumChangeFieldNameStructStyleVariant {
 317     Variant1 { a: u32, c: u32 },
 318 }
 319
 320
 321
 322 // Change order of fields in a tuple-style variant ----------------------------
 323 #[cfg(cfail1)]
 324 enum EnumChangeOrderTupleStyleVariant {
 325     Variant1(u32, u64),
 326 }
 327
 328 #[cfg(not(cfail1))]
 329 #[rustc_dirty(label="Hir", cfg="cfail2")]
 330 #[rustc_clean(label="Hir", cfg="cfail3")]
 331 #[rustc_metadata_clean(cfg="cfail2")]
 332 #[rustc_metadata_clean(cfg="cfail3")]
 333 enum EnumChangeOrderTupleStyleVariant {
 334     Variant1(
 335         #[rustc_metadata_dirty(cfg="cfail2")]
 336         #[rustc_metadata_clean(cfg="cfail3")]
 337         u64,
 338         #[rustc_metadata_dirty(cfg="cfail2")]
 339         #[rustc_metadata_clean(cfg="cfail3")]
 340         u32),
 341 }
 342
 343
 344
 345 // Change order of fields in a struct-style variant ---------------------------
 346 #[cfg(cfail1)]
 347 enum EnumChangeFieldOrderStructStyleVariant {
 348     Variant1 { a: u32, b: f32 },
 349 }
 350
 351 #[cfg(not(cfail1))]
 352 #[rustc_dirty(label="Hir", cfg="cfail2")]
 353 #[rustc_clean(label="Hir", cfg="cfail3")]
 354 #[rustc_metadata_dirty(cfg="cfail2")]
 355 #[rustc_metadata_clean(cfg="cfail3")]
 356 enum EnumChangeFieldOrderStructStyleVariant {
 357     Variant1 { b: f32, a: u32 },
 358 }
 359
 360
 361
 362 // Add a field to a tuple-style variant ---------------------------------------
 363 #[cfg(cfail1)]
 364 enum EnumAddFieldTupleStyleVariant {
 365     Variant1(u32, u32),
 366 }
 367
 368 #[cfg(not(cfail1))]
 369 #[rustc_dirty(label="Hir", cfg="cfail2")]
 370 #[rustc_clean(label="Hir", cfg="cfail3")]
 371 #[rustc_metadata_dirty(cfg="cfail2")]
 372 #[rustc_metadata_clean(cfg="cfail3")]
 373 enum EnumAddFieldTupleStyleVariant {
 374     Variant1(u32, u32, u32),
 375 }
 376
 377
 378
 379 // Add a field to a struct-style variant --------------------------------------
 380 #[cfg(cfail1)]
 381 enum EnumAddFieldStructStyleVariant {
 382     Variant1 { a: u32, b: u32 },
 383 }
 384
 385 #[cfg(not(cfail1))]
 386 #[rustc_dirty(label="Hir", cfg="cfail2")]
 387 #[rustc_clean(label="Hir", cfg="cfail3")]
 388 #[rustc_metadata_dirty(cfg="cfail2")]
 389 #[rustc_metadata_clean(cfg="cfail3")]
 390 enum EnumAddFieldStructStyleVariant {
 391     Variant1 { a: u32, b: u32, c: u32 },
 392 }
 393
 394
 395
 396 // Add #[must_use] to the enum ------------------------------------------------
 397 #[cfg(cfail1)]
 398 enum EnumAddMustUse {
 399     Variant1,
 400     Variant2,
 401 }
 402
 403 #[cfg(not(cfail1))]
 404 #[rustc_dirty(label="Hir", cfg="cfail2")]
 405 #[rustc_clean(label="Hir", cfg="cfail3")]
 406 #[rustc_metadata_dirty(cfg="cfail2")]
 407 #[rustc_metadata_clean(cfg="cfail3")]
 408 #[must_use]
 409 enum EnumAddMustUse {
 410     Variant1,
 411     Variant2,
 412 }
 413
 414
 415
 416 // Add #[repr(C)] to the enum -------------------------------------------------
 417 #[cfg(cfail1)]
 418 enum EnumAddReprC {
 419     Variant1,
 420     Variant2,
 421 }
 422
 423 #[cfg(not(cfail1))]
 424 #[rustc_dirty(label="Hir", cfg="cfail2")]
 425 #[rustc_clean(label="Hir", cfg="cfail3")]
 426 #[rustc_metadata_dirty(cfg="cfail2")]
 427 #[rustc_metadata_clean(cfg="cfail3")]
 428 #[repr(C)]
 429 enum EnumAddReprC {
 430     Variant1,
 431     Variant2,
 432 }
 433
 434
 435
 436 // Change the name of a type parameter ----------------------------------------
 437 #[cfg(cfail1)]
 438 enum EnumChangeNameOfTypeParameter<S> {
 439     Variant1(S),
 440 }
 441
 442 #[cfg(not(cfail1))]
 443 #[rustc_dirty(label="Hir", cfg="cfail2")]
 444 #[rustc_clean(label="Hir", cfg="cfail3")]
 445 #[rustc_metadata_dirty(cfg="cfail2")]
 446 #[rustc_metadata_clean(cfg="cfail3")]
 447 #[repr(C)]
 448 enum EnumChangeNameOfTypeParameter<T> {
 449     Variant1(T),
 450 }
 451
 452
 453
 454 // Add a type parameter ------------------------------------------------------
 455 #[cfg(cfail1)]
 456 enum EnumAddTypeParameter<S> {
 457     Variant1(S),
 458     Variant2(S),
 459 }
 460
 461 #[cfg(not(cfail1))]
 462 #[rustc_dirty(label="Hir", cfg="cfail2")]
 463 #[rustc_clean(label="Hir", cfg="cfail3")]
 464 #[rustc_metadata_dirty(cfg="cfail2")]
 465 #[rustc_metadata_clean(cfg="cfail3")]
 466 #[repr(C)]
 467 enum EnumAddTypeParameter<S, T> {
 468     Variant1(S),
 469     Variant2(T),
 470 }
 471
 472
 473
 474 // Change the name of a lifetime parameter ------------------------------------
 475 #[cfg(cfail1)]
 476 enum EnumChangeNameOfLifetimeParameter<'a> {
 477     Variant1(&'a u32),
 478 }
 479
 480 #[cfg(not(cfail1))]
 481 #[rustc_dirty(label="Hir", cfg="cfail2")]
 482 #[rustc_clean(label="Hir", cfg="cfail3")]
 483 #[rustc_metadata_dirty(cfg="cfail2")]
 484 #[rustc_metadata_clean(cfg="cfail3")]
 485 #[repr(C)]
 486 enum EnumChangeNameOfLifetimeParameter<'b> {
 487     Variant1(&'b u32),
 488 }
 489
 490
 491
 492 // Add a lifetime parameter ---------------------------------------------------
 493 #[cfg(cfail1)]
 494 enum EnumAddLifetimeParameter<'a> {
 495     Variant1(&'a u32),
 496     Variant2(&'a u32),
 497 }
 498
 499 #[cfg(not(cfail1))]
 500 #[rustc_dirty(label="Hir", cfg="cfail2")]
 501 #[rustc_clean(label="Hir", cfg="cfail3")]
 502 #[rustc_metadata_dirty(cfg="cfail2")]
 503 #[rustc_metadata_clean(cfg="cfail3")]
 504 #[repr(C)]
 505 enum EnumAddLifetimeParameter<'a, 'b> {
 506     Variant1(&'a u32),
 507     Variant2(&'b u32),
 508 }
 509
 510
 511
 512 // Add a lifetime bound to a lifetime parameter -------------------------------
 513 #[cfg(cfail1)]
 514 enum EnumAddLifetimeParameterBound<'a, 'b> {
 515     Variant1(&'a u32),
 516     Variant2(&'b u32),
 517 }
 518
 519 #[cfg(not(cfail1))]
 520 #[rustc_dirty(label="Hir", cfg="cfail2")]
 521 #[rustc_clean(label="Hir", cfg="cfail3")]
 522 #[rustc_metadata_dirty(cfg="cfail2")]
 523 #[rustc_metadata_clean(cfg="cfail3")]
 524 #[repr(C)]
 525 enum EnumAddLifetimeParameterBound<'a, 'b: 'a> {
 526     Variant1(&'a u32),
 527     Variant2(&'b u32),
 528 }
 529
 530 // Add a lifetime bound to a type parameter -----------------------------------
 531 #[cfg(cfail1)]
 532 enum EnumAddLifetimeBoundToParameter<'a, T> {
 533     Variant1(T),
 534     Variant2(&'a u32),
 535 }
 536
 537 #[cfg(not(cfail1))]
 538 #[rustc_dirty(label="Hir", cfg="cfail2")]
 539 #[rustc_clean(label="Hir", cfg="cfail3")]
 540 #[rustc_metadata_dirty(cfg="cfail2")]
 541 #[rustc_metadata_clean(cfg="cfail3")]
 542 #[repr(C)]
 543 enum EnumAddLifetimeBoundToParameter<'a, T: 'a> {
 544     Variant1(T),
 545     Variant2(&'a u32),
 546 }
 547
 548
 549
 550 // Add a trait bound to a type parameter --------------------------------------
 551 #[cfg(cfail1)]
 552 enum EnumAddTraitBound<S> {
 553     Variant1(S),
 554 }
 555
 556 #[cfg(not(cfail1))]
 557 #[rustc_dirty(label="Hir", cfg="cfail2")]
 558 #[rustc_clean(label="Hir", cfg="cfail3")]
 559 #[rustc_metadata_dirty(cfg="cfail2")]
 560 #[rustc_metadata_clean(cfg="cfail3")]
 561 #[repr(C)]
 562 enum EnumAddTraitBound<T: Sync> {
 563     Variant1(T),
 564 }
 565
 566
 567
 568 // Add a lifetime bound to a lifetime parameter in where clause ---------------
 569 #[cfg(cfail1)]
 570 enum EnumAddLifetimeParameterBoundWhere<'a, 'b> {
 571     Variant1(&'a u32),
 572     Variant2(&'b u32),
 573 }
 574
 575 #[cfg(not(cfail1))]
 576 #[rustc_dirty(label="Hir", cfg="cfail2")]
 577 #[rustc_clean(label="Hir", cfg="cfail3")]
 578 #[rustc_metadata_dirty(cfg="cfail2")]
 579 #[rustc_metadata_clean(cfg="cfail3")]
 580 #[repr(C)]
 581 enum EnumAddLifetimeParameterBoundWhere<'a, 'b> where 'b: 'a {
 582     Variant1(&'a u32),
 583     Variant2(&'b u32),
 584 }
 585
 586
 587
 588 // Add a lifetime bound to a type parameter in where clause -------------------
 589 #[cfg(cfail1)]
 590 enum EnumAddLifetimeBoundToParameterWhere<'a, T> {
 591     Variant1(T),
 592     Variant2(&'a u32),
 593 }
 594
 595 #[cfg(not(cfail1))]
 596 #[rustc_dirty(label="Hir", cfg="cfail2")]
 597 #[rustc_clean(label="Hir", cfg="cfail3")]
 598 #[rustc_metadata_dirty(cfg="cfail2")]
 599 #[rustc_metadata_clean(cfg="cfail3")]
 600 #[repr(C)]
 601 enum EnumAddLifetimeBoundToParameterWhere<'a, T> where T: 'a {
 602     Variant1(T),
 603     Variant2(&'a u32),
 604 }
 605
 606
 607
 608 // Add a trait bound to a type parameter in where clause ----------------------
 609 #[cfg(cfail1)]
 610 enum EnumAddTraitBoundWhere<S> {
 611     Variant1(S),
 612 }
 613
 614 #[cfg(not(cfail1))]
 615 #[rustc_dirty(label="Hir", cfg="cfail2")]
 616 #[rustc_clean(label="Hir", cfg="cfail3")]
 617 #[rustc_metadata_dirty(cfg="cfail2")]
 618 #[rustc_metadata_clean(cfg="cfail3")]
 619 #[repr(C)]
 620 enum EnumAddTraitBoundWhere<T> where T: Sync {
 621     Variant1(T),
 622 }
 623
 624
 625
 626 // In an enum with two variants, swap usage of type parameters ----------------
 627 #[cfg(cfail1)]
 628 enum EnumSwapUsageTypeParameters<A, B> {
 629     Variant1 { a: A },
 630     Variant2 { a: B },
 631 }
 632
 633 #[cfg(not(cfail1))]
 634 #[rustc_dirty(label="Hir", cfg="cfail2")]
 635 #[rustc_clean(label="Hir", cfg="cfail3")]
 636 #[rustc_metadata_clean(cfg="cfail2")]
 637 #[rustc_metadata_clean(cfg="cfail3")]
 638 enum EnumSwapUsageTypeParameters<A, B> {
 639     #[rustc_metadata_clean(cfg="cfail2")]
 640     #[rustc_metadata_clean(cfg="cfail3")]
 641     Variant1 {
 642         #[rustc_metadata_dirty(cfg="cfail2")]
 643         #[rustc_metadata_clean(cfg="cfail3")]
 644         a: B
 645     },
 646     #[rustc_metadata_clean(cfg="cfail2")]
 647     #[rustc_metadata_clean(cfg="cfail3")]
 648     Variant2 {
 649         #[rustc_metadata_dirty(cfg="cfail2")]
 650         #[rustc_metadata_clean(cfg="cfail3")]
 651         a: A
 652     },
 653 }
 654
 655
 656
 657 // In an enum with two variants, swap usage of lifetime parameters ------------
 658 #[cfg(cfail1)]
 659 enum EnumSwapUsageLifetimeParameters<'a, 'b> {
 660     Variant1 { a: &'a u32 },
 661     Variant2 { b: &'b u32 },
 662 }
 663
 664 #[cfg(not(cfail1))]
 665 #[rustc_dirty(label="Hir", cfg="cfail2")]
 666 #[rustc_clean(label="Hir", cfg="cfail3")]
 667 #[rustc_metadata_clean(cfg="cfail2")]
 668 #[rustc_metadata_clean(cfg="cfail3")]
 669 enum EnumSwapUsageLifetimeParameters<'a, 'b> {
 670     #[rustc_metadata_clean(cfg="cfail2")]
 671     #[rustc_metadata_clean(cfg="cfail3")]
 672     Variant1 {
 673         #[rustc_metadata_dirty(cfg="cfail2")]
 674         #[rustc_metadata_clean(cfg="cfail3")]
 675         a: &'b u32
 676     },
 677     #[rustc_metadata_clean(cfg="cfail2")]
 678     #[rustc_metadata_clean(cfg="cfail3")]
 679     Variant2 {
 680         #[rustc_metadata_dirty(cfg="cfail2")]
 681         #[rustc_metadata_clean(cfg="cfail3")]
 682         b: &'a u32
 683     },
 684 }
 685
 686
 687
 688 struct ReferencedType1;
 689 struct ReferencedType2;
 690
 691
 692
 693 // Change field type in tuple-style variant indirectly by modifying a use statement
 694 mod change_field_type_indirectly_tuple_style {
 695     #[cfg(cfail1)]
 696     use super::ReferencedType1 as FieldType;
 697     #[cfg(not(cfail1))]
 698     use super::ReferencedType2 as FieldType;
 699
 700     #[rustc_dirty(label="Hir", cfg="cfail2")]
 701     #[rustc_clean(label="Hir", cfg="cfail3")]
 702     #[rustc_metadata_clean(cfg="cfail2")]
 703     #[rustc_metadata_clean(cfg="cfail3")]
 704     enum TupleStyle {
 705         #[rustc_metadata_dirty(cfg="cfail2")]
 706         #[rustc_metadata_clean(cfg="cfail3")]
 707         Variant1(
 708             #[rustc_metadata_dirty(cfg="cfail2")]
 709             #[rustc_metadata_clean(cfg="cfail3")]
 710             FieldType
 711         )
 712     }
 713 }
 714
 715
 716
 717 // Change field type in record-style variant indirectly by modifying a use statement
 718 mod change_field_type_indirectly_struct_style {
 719     #[cfg(cfail1)]
 720     use super::ReferencedType1 as FieldType;
 721     #[cfg(not(cfail1))]
 722     use super::ReferencedType2 as FieldType;
 723
 724     #[rustc_dirty(label="Hir", cfg="cfail2")]
 725     #[rustc_clean(label="Hir", cfg="cfail3")]
 726     #[rustc_metadata_clean(cfg="cfail2")]
 727     #[rustc_metadata_clean(cfg="cfail3")]
 728     enum StructStyle {
 729         #[rustc_metadata_clean(cfg="cfail2")]
 730         #[rustc_metadata_clean(cfg="cfail3")]
 731         Variant1 {
 732             #[rustc_metadata_dirty(cfg="cfail2")]
 733             #[rustc_metadata_clean(cfg="cfail3")]
 734             a: FieldType
 735         }
 736     }
 737 }
 738
 739
 740
 741 trait ReferencedTrait1 {}
 742 trait ReferencedTrait2 {}
 743
 744
 745
 746 // Change trait bound of type parameter indirectly by modifying a use statement
 747 mod change_trait_bound_indirectly {
 748     #[cfg(cfail1)]
 749     use super::ReferencedTrait1 as Trait;
 750     #[cfg(not(cfail1))]
 751     use super::ReferencedTrait2 as Trait;
 752
 753     #[rustc_dirty(label="Hir", cfg="cfail2")]
 754     #[rustc_clean(label="Hir", cfg="cfail3")]
 755     #[rustc_metadata_dirty(cfg="cfail2")]
 756     #[rustc_metadata_clean(cfg="cfail3")]
 757     enum Enum<T: Trait> {
 758         Variant1(T)
 759     }
 760 }
 761
 762
 763
 764 // Change trait bound of type parameter in where clause indirectly by modifying a use statement
 765 mod change_trait_bound_indirectly_where {
 766     #[cfg(cfail1)]
 767     use super::ReferencedTrait1 as Trait;
 768     #[cfg(not(cfail1))]
 769     use super::ReferencedTrait2 as Trait;
 770
 771     #[rustc_dirty(label="Hir", cfg="cfail2")]
 772     #[rustc_clean(label="Hir", cfg="cfail3")]
 773     #[rustc_metadata_dirty(cfg="cfail2")]
 774     #[rustc_metadata_clean(cfg="cfail3")]
 775     enum Enum<T> where T: Trait {
 776         Variant1(T)
 777     }
 778 }
 779
 780