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