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_clean(cfg="cfail3")]
  42 pub enum EnumVisibility { A }
  43
  44
  45
  46 // Change name of a c-style variant -------------------------------------------
  47 #[cfg(cfail1)]
  48 enum EnumChangeNameCStyleVariant {
  49     Variant1,
  50     Variant2,
  51 }
  52
  53 #[cfg(not(cfail1))]
  54 #[rustc_dirty(label="Hir", cfg="cfail2")]
  55 #[rustc_clean(label="Hir", cfg="cfail3")]
  56 #[rustc_metadata_dirty(cfg="cfail2")]
  57 #[rustc_metadata_clean(cfg="cfail3")]
  58 enum EnumChangeNameCStyleVariant {
  59     Variant1,
  60     Variant2Changed,
  61 }
  62
  63
  64
  65 // Change name of a tuple-style variant ---------------------------------------
  66 #[cfg(cfail1)]
  67 enum EnumChangeNameTupleStyleVariant {
  68     Variant1,
  69     Variant2(u32, f32),
  70 }
  71
  72 #[cfg(not(cfail1))]
  73 #[rustc_dirty(label="Hir", cfg="cfail2")]
  74 #[rustc_clean(label="Hir", cfg="cfail3")]
  75 #[rustc_metadata_dirty(cfg="cfail2")]
  76 #[rustc_metadata_clean(cfg="cfail3")]
  77 enum EnumChangeNameTupleStyleVariant {
  78     Variant1,
  79     Variant2Changed(u32, f32),
  80 }
  81
  82
  83
  84 // Change name of a struct-style variant --------------------------------------
  85 #[cfg(cfail1)]
  86 enum EnumChangeNameStructStyleVariant {
  87     Variant1,
  88     Variant2 { a: u32, b: f32 },
  89 }
  90
  91 #[cfg(not(cfail1))]
  92 #[rustc_dirty(label="Hir", cfg="cfail2")]
  93 #[rustc_clean(label="Hir", cfg="cfail3")]
  94 #[rustc_metadata_dirty(cfg="cfail2")]
  95 #[rustc_metadata_clean(cfg="cfail3")]
  96 enum EnumChangeNameStructStyleVariant {
  97     Variant1,
  98     Variant2Changed { a: u32, b: f32 },
  99 }
 100
 101
 102
 103 // Change the value of a c-style variant --------------------------------------
 104 #[cfg(cfail1)]
 105 enum EnumChangeValueCStyleVariant0 {
 106     Variant1,
 107     Variant2 = 11,
 108 }
 109
 110 #[cfg(not(cfail1))]
 111 #[rustc_clean(label="Hir", cfg="cfail2")]
 112 #[rustc_clean(label="Hir", cfg="cfail3")]
 113 #[rustc_dirty(label="HirBody", cfg="cfail2")]
 114 #[rustc_clean(label="HirBody", cfg="cfail3")]
 115 #[rustc_metadata_clean(cfg="cfail2")]
 116 #[rustc_metadata_clean(cfg="cfail3")]
 117 enum EnumChangeValueCStyleVariant0 {
 118     Variant1,
 119
 120     #[rustc_metadata_dirty(cfg="cfail2")]
 121     #[rustc_metadata_clean(cfg="cfail3")]
 122     Variant2 = 22,
 123 }
 124
 125 #[cfg(cfail1)]
 126 enum EnumChangeValueCStyleVariant1 {
 127     Variant1,
 128     Variant2,
 129 }
 130
 131 #[cfg(not(cfail1))]
 132 #[rustc_dirty(label="Hir", cfg="cfail2")]
 133 #[rustc_clean(label="Hir", cfg="cfail3")]
 134 #[rustc_clean(label="HirBody", cfg="cfail2")]
 135 #[rustc_clean(label="HirBody", cfg="cfail3")]
 136 #[rustc_metadata_dirty(cfg="cfail2")]
 137 #[rustc_metadata_clean(cfg="cfail3")]
 138 enum EnumChangeValueCStyleVariant1 {
 139     Variant1,
 140     Variant2 = 11,
 141 }
 142
 143
 144
 145 // Add a c-style variant ------------------------------------------------------
 146 #[cfg(cfail1)]
 147 enum EnumAddCStyleVariant {
 148     Variant1,
 149 }
 150
 151 #[cfg(not(cfail1))]
 152 #[rustc_dirty(label="Hir", cfg="cfail2")]
 153 #[rustc_clean(label="Hir", cfg="cfail3")]
 154 #[rustc_metadata_dirty(cfg="cfail2")]
 155 #[rustc_metadata_clean(cfg="cfail3")]
 156 enum EnumAddCStyleVariant {
 157     Variant1,
 158     Variant2,
 159 }
 160
 161
 162
 163 // Remove a c-style variant ---------------------------------------------------
 164 #[cfg(cfail1)]
 165 enum EnumRemoveCStyleVariant {
 166     Variant1,
 167     Variant2,
 168 }
 169
 170 #[cfg(not(cfail1))]
 171 #[rustc_dirty(label="Hir", cfg="cfail2")]
 172 #[rustc_clean(label="Hir", cfg="cfail3")]
 173 #[rustc_metadata_dirty(cfg="cfail2")]
 174 #[rustc_metadata_clean(cfg="cfail3")]
 175 enum EnumRemoveCStyleVariant {
 176     Variant1,
 177 }
 178
 179
 180
 181 // Add a tuple-style variant --------------------------------------------------
 182 #[cfg(cfail1)]
 183 enum EnumAddTupleStyleVariant {
 184     Variant1,
 185 }
 186
 187 #[cfg(not(cfail1))]
 188 #[rustc_dirty(label="Hir", cfg="cfail2")]
 189 #[rustc_clean(label="Hir", cfg="cfail3")]
 190 #[rustc_metadata_dirty(cfg="cfail2")]
 191 #[rustc_metadata_clean(cfg="cfail3")]
 192 enum EnumAddTupleStyleVariant {
 193     Variant1,
 194     Variant2(u32, f32),
 195 }
 196
 197
 198
 199 // Remove a tuple-style variant -----------------------------------------------
 200 #[cfg(cfail1)]
 201 enum EnumRemoveTupleStyleVariant {
 202     Variant1,
 203     Variant2(u32, f32),
 204 }
 205
 206 #[cfg(not(cfail1))]
 207 #[rustc_dirty(label="Hir", cfg="cfail2")]
 208 #[rustc_clean(label="Hir", cfg="cfail3")]
 209 #[rustc_metadata_dirty(cfg="cfail2")]
 210 #[rustc_metadata_clean(cfg="cfail3")]
 211 enum EnumRemoveTupleStyleVariant {
 212     Variant1,
 213 }
 214
 215
 216
 217 // Add a struct-style variant -------------------------------------------------
 218 #[cfg(cfail1)]
 219 enum EnumAddStructStyleVariant {
 220     Variant1,
 221 }
 222
 223 #[cfg(not(cfail1))]
 224 #[rustc_dirty(label="Hir", cfg="cfail2")]
 225 #[rustc_clean(label="Hir", cfg="cfail3")]
 226 #[rustc_metadata_dirty(cfg="cfail2")]
 227 #[rustc_metadata_clean(cfg="cfail3")]
 228 enum EnumAddStructStyleVariant {
 229     Variant1,
 230     Variant2 { a: u32, b: f32 },
 231 }
 232
 233
 234
 235 // Remove a struct-style variant ----------------------------------------------
 236 #[cfg(cfail1)]
 237 enum EnumRemoveStructStyleVariant {
 238     Variant1,
 239     Variant2 { a: u32, b: f32 },
 240 }
 241
 242 #[cfg(not(cfail1))]
 243 #[rustc_dirty(label="Hir", cfg="cfail2")]
 244 #[rustc_clean(label="Hir", cfg="cfail3")]
 245 #[rustc_metadata_dirty(cfg="cfail2")]
 246 #[rustc_metadata_clean(cfg="cfail3")]
 247 enum EnumRemoveStructStyleVariant {
 248     Variant1,
 249 }
 250
 251
 252
 253 // Change the type of a field in a tuple-style variant ------------------------
 254 #[cfg(cfail1)]
 255 enum EnumChangeFieldTypeTupleStyleVariant {
 256     Variant1(u32, u32),
 257 }
 258
 259 #[cfg(not(cfail1))]
 260 #[rustc_dirty(label="Hir", cfg="cfail2")]
 261 #[rustc_clean(label="Hir", cfg="cfail3")]
 262 #[rustc_metadata_dirty(cfg="cfail2")]
 263 #[rustc_metadata_clean(cfg="cfail3")]
 264 enum EnumChangeFieldTypeTupleStyleVariant {
 265     Variant1(u32, u64),
 266 }
 267
 268
 269
 270 // Change the type of a field in a struct-style variant -----------------------
 271 #[cfg(cfail1)]
 272 enum EnumChangeFieldTypeStructStyleVariant {
 273     Variant1,
 274     Variant2 { a: u32, b: u32 },
 275 }
 276
 277 #[cfg(not(cfail1))]
 278 #[rustc_dirty(label="Hir", cfg="cfail2")]
 279 #[rustc_clean(label="Hir", cfg="cfail3")]
 280 #[rustc_metadata_dirty(cfg="cfail2")]
 281 #[rustc_metadata_clean(cfg="cfail3")]
 282 enum EnumChangeFieldTypeStructStyleVariant {
 283     Variant1,
 284     Variant2 { a: u32, b: u64 },
 285 }
 286
 287
 288
 289 // Change the name of a field in a struct-style variant -----------------------
 290 #[cfg(cfail1)]
 291 enum EnumChangeFieldNameStructStyleVariant {
 292     Variant1 { a: u32, b: u32 },
 293 }
 294
 295 #[cfg(not(cfail1))]
 296 #[rustc_dirty(label="Hir", cfg="cfail2")]
 297 #[rustc_clean(label="Hir", cfg="cfail3")]
 298 #[rustc_metadata_dirty(cfg="cfail2")]
 299 #[rustc_metadata_clean(cfg="cfail3")]
 300 enum EnumChangeFieldNameStructStyleVariant {
 301     Variant1 { a: u32, c: u32 },
 302 }
 303
 304
 305
 306 // Change order of fields in a tuple-style variant ----------------------------
 307 #[cfg(cfail1)]
 308 enum EnumChangeOrderTupleStyleVariant {
 309     Variant1(u32, u64),
 310 }
 311
 312 #[cfg(not(cfail1))]
 313 #[rustc_dirty(label="Hir", cfg="cfail2")]
 314 #[rustc_clean(label="Hir", cfg="cfail3")]
 315 #[rustc_metadata_dirty(cfg="cfail2")]
 316 #[rustc_metadata_clean(cfg="cfail3")]
 317 enum EnumChangeOrderTupleStyleVariant {
 318     Variant1(u64, u32),
 319 }
 320
 321
 322
 323 // Change order of fields in a struct-style variant ---------------------------
 324 #[cfg(cfail1)]
 325 enum EnumChangeFieldOrderStructStyleVariant {
 326     Variant1 { a: u32, b: f32 },
 327 }
 328
 329 #[cfg(not(cfail1))]
 330 #[rustc_dirty(label="Hir", cfg="cfail2")]
 331 #[rustc_clean(label="Hir", cfg="cfail3")]
 332 #[rustc_metadata_dirty(cfg="cfail2")]
 333 #[rustc_metadata_clean(cfg="cfail3")]
 334 enum EnumChangeFieldOrderStructStyleVariant {
 335     Variant1 { b: f32, a: u32 },
 336 }
 337
 338
 339
 340 // Add a field to a tuple-style variant ---------------------------------------
 341 #[cfg(cfail1)]
 342 enum EnumAddFieldTupleStyleVariant {
 343     Variant1(u32, u32),
 344 }
 345
 346 #[cfg(not(cfail1))]
 347 #[rustc_dirty(label="Hir", cfg="cfail2")]
 348 #[rustc_clean(label="Hir", cfg="cfail3")]
 349 #[rustc_metadata_dirty(cfg="cfail2")]
 350 #[rustc_metadata_clean(cfg="cfail3")]
 351 enum EnumAddFieldTupleStyleVariant {
 352     Variant1(u32, u32, u32),
 353 }
 354
 355
 356
 357 // Add a field to a struct-style variant --------------------------------------
 358 #[cfg(cfail1)]
 359 enum EnumAddFieldStructStyleVariant {
 360     Variant1 { a: u32, b: u32 },
 361 }
 362
 363 #[cfg(not(cfail1))]
 364 #[rustc_dirty(label="Hir", cfg="cfail2")]
 365 #[rustc_clean(label="Hir", cfg="cfail3")]
 366 #[rustc_metadata_dirty(cfg="cfail2")]
 367 #[rustc_metadata_clean(cfg="cfail3")]
 368 enum EnumAddFieldStructStyleVariant {
 369     Variant1 { a: u32, b: u32, c: u32 },
 370 }
 371
 372
 373
 374 // Add #[must_use] to the enum ------------------------------------------------
 375 #[cfg(cfail1)]
 376 enum EnumAddMustUse {
 377     Variant1,
 378     Variant2,
 379 }
 380
 381 #[cfg(not(cfail1))]
 382 #[rustc_dirty(label="Hir", cfg="cfail2")]
 383 #[rustc_clean(label="Hir", cfg="cfail3")]
 384 #[rustc_metadata_dirty(cfg="cfail2")]
 385 #[rustc_metadata_clean(cfg="cfail3")]
 386 #[must_use]
 387 enum EnumAddMustUse {
 388     Variant1,
 389     Variant2,
 390 }
 391
 392
 393
 394 // Add #[repr(C)] to the enum -------------------------------------------------
 395 #[cfg(cfail1)]
 396 enum EnumAddReprC {
 397     Variant1,
 398     Variant2,
 399 }
 400
 401 #[cfg(not(cfail1))]
 402 #[rustc_dirty(label="Hir", cfg="cfail2")]
 403 #[rustc_clean(label="Hir", cfg="cfail3")]
 404 #[rustc_metadata_dirty(cfg="cfail2")]
 405 #[rustc_metadata_clean(cfg="cfail3")]
 406 #[repr(C)]
 407 enum EnumAddReprC {
 408     Variant1,
 409     Variant2,
 410 }
 411
 412
 413
 414 // Change the name of a type parameter ----------------------------------------
 415 #[cfg(cfail1)]
 416 enum EnumChangeNameOfTypeParameter<S> {
 417     Variant1(S),
 418 }
 419
 420 #[cfg(not(cfail1))]
 421 #[rustc_dirty(label="Hir", cfg="cfail2")]
 422 #[rustc_clean(label="Hir", cfg="cfail3")]
 423 #[rustc_metadata_dirty(cfg="cfail2")]
 424 #[rustc_metadata_clean(cfg="cfail3")]
 425 #[repr(C)]
 426 enum EnumChangeNameOfTypeParameter<T> {
 427     Variant1(T),
 428 }
 429
 430
 431
 432 // Add a type parameter ------------------------------------------------------
 433 #[cfg(cfail1)]
 434 enum EnumAddTypeParameter<S> {
 435     Variant1(S),
 436     Variant2(S),
 437 }
 438
 439 #[cfg(not(cfail1))]
 440 #[rustc_dirty(label="Hir", cfg="cfail2")]
 441 #[rustc_clean(label="Hir", cfg="cfail3")]
 442 #[rustc_metadata_dirty(cfg="cfail2")]
 443 #[rustc_metadata_clean(cfg="cfail3")]
 444 #[repr(C)]
 445 enum EnumAddTypeParameter<S, T> {
 446     Variant1(S),
 447     Variant2(T),
 448 }
 449
 450
 451
 452 // Change the name of a lifetime parameter ------------------------------------
 453 #[cfg(cfail1)]
 454 enum EnumChangeNameOfLifetimeParameter<'a> {
 455     Variant1(&'a u32),
 456 }
 457
 458 #[cfg(not(cfail1))]
 459 #[rustc_dirty(label="Hir", cfg="cfail2")]
 460 #[rustc_clean(label="Hir", cfg="cfail3")]
 461 #[rustc_metadata_dirty(cfg="cfail2")]
 462 #[rustc_metadata_clean(cfg="cfail3")]
 463 #[repr(C)]
 464 enum EnumChangeNameOfLifetimeParameter<'b> {
 465     Variant1(&'b u32),
 466 }
 467
 468
 469
 470 // Add a lifetime parameter ---------------------------------------------------
 471 #[cfg(cfail1)]
 472 enum EnumAddLifetimeParameter<'a> {
 473     Variant1(&'a u32),
 474     Variant2(&'a u32),
 475 }
 476
 477 #[cfg(not(cfail1))]
 478 #[rustc_dirty(label="Hir", cfg="cfail2")]
 479 #[rustc_clean(label="Hir", cfg="cfail3")]
 480 #[rustc_metadata_dirty(cfg="cfail2")]
 481 #[rustc_metadata_clean(cfg="cfail3")]
 482 #[repr(C)]
 483 enum EnumAddLifetimeParameter<'a, 'b> {
 484     Variant1(&'a u32),
 485     Variant2(&'b u32),
 486 }
 487
 488
 489
 490 // Add a lifetime bound to a lifetime parameter -------------------------------
 491 #[cfg(cfail1)]
 492 enum EnumAddLifetimeParameterBound<'a, 'b> {
 493     Variant1(&'a u32),
 494     Variant2(&'b u32),
 495 }
 496
 497 #[cfg(not(cfail1))]
 498 #[rustc_dirty(label="Hir", cfg="cfail2")]
 499 #[rustc_clean(label="Hir", cfg="cfail3")]
 500 #[rustc_metadata_dirty(cfg="cfail2")]
 501 #[rustc_metadata_clean(cfg="cfail3")]
 502 #[repr(C)]
 503 enum EnumAddLifetimeParameterBound<'a, 'b: 'a> {
 504     Variant1(&'a u32),
 505     Variant2(&'b u32),
 506 }
 507
 508 // Add a lifetime bound to a type parameter -----------------------------------
 509 #[cfg(cfail1)]
 510 enum EnumAddLifetimeBoundToParameter<'a, T> {
 511     Variant1(T),
 512     Variant2(&'a u32),
 513 }
 514
 515 #[cfg(not(cfail1))]
 516 #[rustc_dirty(label="Hir", cfg="cfail2")]
 517 #[rustc_clean(label="Hir", cfg="cfail3")]
 518 #[rustc_metadata_dirty(cfg="cfail2")]
 519 #[rustc_metadata_clean(cfg="cfail3")]
 520 #[repr(C)]
 521 enum EnumAddLifetimeBoundToParameter<'a, T: 'a> {
 522     Variant1(T),
 523     Variant2(&'a u32),
 524 }
 525
 526
 527
 528 // Add a trait bound to a type parameter --------------------------------------
 529 #[cfg(cfail1)]
 530 enum EnumAddTraitBound<S> {
 531     Variant1(S),
 532 }
 533
 534 #[cfg(not(cfail1))]
 535 #[rustc_dirty(label="Hir", cfg="cfail2")]
 536 #[rustc_clean(label="Hir", cfg="cfail3")]
 537 #[rustc_metadata_dirty(cfg="cfail2")]
 538 #[rustc_metadata_clean(cfg="cfail3")]
 539 #[repr(C)]
 540 enum EnumAddTraitBound<T: Sync> {
 541     Variant1(T),
 542 }
 543
 544
 545
 546 // Add a lifetime bound to a lifetime parameter in where clause ---------------
 547 #[cfg(cfail1)]
 548 enum EnumAddLifetimeParameterBoundWhere<'a, 'b> {
 549     Variant1(&'a u32),
 550     Variant2(&'b u32),
 551 }
 552
 553 #[cfg(not(cfail1))]
 554 #[rustc_dirty(label="Hir", cfg="cfail2")]
 555 #[rustc_clean(label="Hir", cfg="cfail3")]
 556 #[rustc_metadata_dirty(cfg="cfail2")]
 557 #[rustc_metadata_clean(cfg="cfail3")]
 558 #[repr(C)]
 559 enum EnumAddLifetimeParameterBoundWhere<'a, 'b> where 'b: 'a {
 560     Variant1(&'a u32),
 561     Variant2(&'b u32),
 562 }
 563
 564
 565
 566 // Add a lifetime bound to a type parameter in where clause -------------------
 567 #[cfg(cfail1)]
 568 enum EnumAddLifetimeBoundToParameterWhere<'a, T> {
 569     Variant1(T),
 570     Variant2(&'a u32),
 571 }
 572
 573 #[cfg(not(cfail1))]
 574 #[rustc_dirty(label="Hir", cfg="cfail2")]
 575 #[rustc_clean(label="Hir", cfg="cfail3")]
 576 #[rustc_metadata_dirty(cfg="cfail2")]
 577 #[rustc_metadata_clean(cfg="cfail3")]
 578 #[repr(C)]
 579 enum EnumAddLifetimeBoundToParameterWhere<'a, T> where T: 'a {
 580     Variant1(T),
 581     Variant2(&'a u32),
 582 }
 583
 584
 585
 586 // Add a trait bound to a type parameter in where clause ----------------------
 587 #[cfg(cfail1)]
 588 enum EnumAddTraitBoundWhere<S> {
 589     Variant1(S),
 590 }
 591
 592 #[cfg(not(cfail1))]
 593 #[rustc_dirty(label="Hir", cfg="cfail2")]
 594 #[rustc_clean(label="Hir", cfg="cfail3")]
 595 #[rustc_metadata_dirty(cfg="cfail2")]
 596 #[rustc_metadata_clean(cfg="cfail3")]
 597 #[repr(C)]
 598 enum EnumAddTraitBoundWhere<T> where T: Sync {
 599     Variant1(T),
 600 }
 601
 602
 603
 604 // In an enum with two variants, swap usage of type parameters ----------------
 605 #[cfg(cfail1)]
 606 enum EnumSwapUsageTypeParameters<A, B> {
 607     Variant1 { a: A },
 608     Variant2 { a: B },
 609 }
 610
 611 #[cfg(not(cfail1))]
 612 #[rustc_dirty(label="Hir", cfg="cfail2")]
 613 #[rustc_clean(label="Hir", cfg="cfail3")]
 614 #[rustc_metadata_dirty(cfg="cfail2")]
 615 #[rustc_metadata_clean(cfg="cfail3")]
 616 enum EnumSwapUsageTypeParameters<A, B> {
 617     Variant1 { a: B },
 618     Variant2 { a: A },
 619 }
 620
 621
 622
 623 // In an enum with two variants, swap usage of lifetime parameters ------------
 624 #[cfg(cfail1)]
 625 enum EnumSwapUsageLifetimeParameters<'a, 'b> {
 626     Variant1 { a: &'a u32 },
 627     Variant2 { b: &'b u32 },
 628 }
 629
 630 #[cfg(not(cfail1))]
 631 #[rustc_dirty(label="Hir", cfg="cfail2")]
 632 #[rustc_clean(label="Hir", cfg="cfail3")]
 633 #[rustc_metadata_dirty(cfg="cfail2")]
 634 #[rustc_metadata_clean(cfg="cfail3")]
 635 enum EnumSwapUsageLifetimeParameters<'a, 'b> {
 636     Variant1 { a: &'b u32 },
 637     Variant2 { b: &'a u32 },
 638 }
 639
 640
 641
 642 struct ReferencedType1;
 643 struct ReferencedType2;
 644
 645
 646
 647 // Change field type in tuple-style variant indirectly by modifying a use statement
 648 mod change_field_type_indirectly_tuple_style {
 649     #[cfg(cfail1)]
 650     use super::ReferencedType1 as FieldType;
 651     #[cfg(not(cfail1))]
 652     use super::ReferencedType2 as FieldType;
 653
 654     #[rustc_dirty(label="Hir", cfg="cfail2")]
 655     #[rustc_clean(label="Hir", cfg="cfail3")]
 656     #[rustc_metadata_dirty(cfg="cfail2")]
 657     #[rustc_metadata_clean(cfg="cfail3")]
 658     enum TupleStyle {
 659         Variant1(FieldType)
 660     }
 661 }
 662
 663
 664
 665 // Change field type in record-style variant indirectly by modifying a use statement
 666 mod change_field_type_indirectly_struct_style {
 667     #[cfg(cfail1)]
 668     use super::ReferencedType1 as FieldType;
 669     #[cfg(not(cfail1))]
 670     use super::ReferencedType2 as FieldType;
 671
 672     #[rustc_dirty(label="Hir", cfg="cfail2")]
 673     #[rustc_clean(label="Hir", cfg="cfail3")]
 674     #[rustc_metadata_dirty(cfg="cfail2")]
 675     #[rustc_metadata_clean(cfg="cfail3")]
 676     enum StructStyle {
 677         Variant1 { a: FieldType }
 678     }
 679 }
 680
 681
 682
 683 trait ReferencedTrait1 {}
 684 trait ReferencedTrait2 {}
 685
 686
 687
 688 // Change trait bound of type parameter indirectly by modifying a use statement
 689 mod change_trait_bound_indirectly {
 690     #[cfg(cfail1)]
 691     use super::ReferencedTrait1 as Trait;
 692     #[cfg(not(cfail1))]
 693     use super::ReferencedTrait2 as Trait;
 694
 695     #[rustc_dirty(label="Hir", cfg="cfail2")]
 696     #[rustc_clean(label="Hir", cfg="cfail3")]
 697     #[rustc_metadata_dirty(cfg="cfail2")]
 698     #[rustc_metadata_clean(cfg="cfail3")]
 699     enum Enum<T: Trait> {
 700         Variant1(T)
 701     }
 702 }
 703
 704
 705
 706 // Change trait bound of type parameter in where clause indirectly by modifying a use statement
 707 mod change_trait_bound_indirectly_where {
 708     #[cfg(cfail1)]
 709     use super::ReferencedTrait1 as Trait;
 710     #[cfg(not(cfail1))]
 711     use super::ReferencedTrait2 as Trait;
 712
 713     #[rustc_dirty(label="Hir", cfg="cfail2")]
 714     #[rustc_clean(label="Hir", cfg="cfail3")]
 715     #[rustc_metadata_dirty(cfg="cfail2")]
 716     #[rustc_metadata_clean(cfg="cfail3")]
 717     enum Enum<T> where T: Trait {
 718         Variant1(T)
 719     }
 720 }
 721
 722