src/test/incremental/hashes/enum_defs.rs

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