src/test/incremental/hashes/trait_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 trait 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 trait 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 trait'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 #![feature(associated_type_defaults)]
  32 #![feature(intrinsics)]
  33 #![feature(associated_consts)]
  34
  35
  36 // Change trait visibility --------------------------------------------------------
  37 #[cfg(cfail1)]
  38 trait TraitVisibility { }
  39
  40 #[cfg(not(cfail1))]
  41 #[rustc_dirty(label="Hir", cfg="cfail2")]
  42 #[rustc_clean(label="Hir", cfg="cfail3")]
  43 #[rustc_metadata_clean(cfg="cfail3")]
  44 pub trait TraitVisibility { }
  45
  46
  47
  48 // Change trait unsafety ----------------------------------------------------------
  49 #[cfg(cfail1)]
  50 trait TraitUnsafety { }
  51
  52 #[cfg(not(cfail1))]
  53 #[rustc_dirty(label="Hir", cfg="cfail2")]
  54 #[rustc_clean(label="Hir", cfg="cfail3")]
  55 #[rustc_metadata_dirty(cfg="cfail2")]
  56 #[rustc_metadata_clean(cfg="cfail3")]
  57 unsafe trait TraitUnsafety { }
  58
  59
  60
  61 // Add method ---------------------------------------------------------------------
  62 #[cfg(cfail1)]
  63 trait TraitAddMethod {
  64 }
  65
  66 #[cfg(not(cfail1))]
  67 #[rustc_dirty(label="Hir", cfg="cfail2")]
  68 #[rustc_clean(label="Hir", cfg="cfail3")]
  69 #[rustc_metadata_dirty(cfg="cfail2")]
  70 #[rustc_metadata_clean(cfg="cfail3")]
  71 pub trait TraitAddMethod {
  72     fn method();
  73 }
  74
  75
  76
  77 // Change name of method ----------------------------------------------------------
  78 #[cfg(cfail1)]
  79 trait TraitChangeMethodName {
  80     fn method();
  81 }
  82
  83 #[cfg(not(cfail1))]
  84 #[rustc_dirty(label="Hir", cfg="cfail2")]
  85 #[rustc_clean(label="Hir", cfg="cfail3")]
  86 #[rustc_metadata_dirty(cfg="cfail2")]
  87 #[rustc_metadata_clean(cfg="cfail3")]
  88 trait TraitChangeMethodName {
  89     fn methodChanged();
  90 }
  91
  92
  93
  94 // Add return type to method ------------------------------------------------------
  95 #[cfg(cfail1)]
  96 trait TraitAddReturnType {
  97     fn method();
  98 }
  99
 100 #[cfg(not(cfail1))]
 101 #[rustc_clean(label="Hir", cfg="cfail2")]
 102 #[rustc_clean(label="Hir", cfg="cfail3")]
 103 #[rustc_metadata_clean(cfg="cfail2")]
 104 #[rustc_metadata_clean(cfg="cfail3")]
 105 trait TraitAddReturnType {
 106     #[rustc_dirty(label="Hir", cfg="cfail2")]
 107     #[rustc_clean(label="Hir", cfg="cfail3")]
 108     #[rustc_metadata_dirty(cfg="cfail2")]
 109     #[rustc_metadata_clean(cfg="cfail3")]
 110     fn method() -> u32;
 111 }
 112
 113
 114
 115 // Change return type of method ---------------------------------------------------
 116 #[cfg(cfail1)]
 117 trait TraitChangeReturnType {
 118     fn method() -> u32;
 119 }
 120
 121 #[cfg(not(cfail1))]
 122 #[rustc_clean(label="Hir", cfg="cfail2")]
 123 #[rustc_clean(label="Hir", cfg="cfail3")]
 124 #[rustc_metadata_clean(cfg="cfail2")]
 125 #[rustc_metadata_clean(cfg="cfail3")]
 126 trait TraitChangeReturnType {
 127     #[rustc_dirty(label="Hir", cfg="cfail2")]
 128     #[rustc_clean(label="Hir", cfg="cfail3")]
 129     #[rustc_metadata_dirty(cfg="cfail2")]
 130     #[rustc_metadata_clean(cfg="cfail3")]
 131     fn method() -> u64;
 132 }
 133
 134
 135
 136 // Add parameter to method --------------------------------------------------------
 137 #[cfg(cfail1)]
 138 trait TraitAddParameterToMethod {
 139     fn method();
 140 }
 141
 142 #[cfg(not(cfail1))]
 143 #[rustc_clean(label="Hir", cfg="cfail2")]
 144 #[rustc_clean(label="Hir", cfg="cfail3")]
 145 #[rustc_metadata_clean(cfg="cfail2")]
 146 #[rustc_metadata_clean(cfg="cfail3")]
 147 trait TraitAddParameterToMethod {
 148     #[rustc_dirty(label="Hir", cfg="cfail2")]
 149     #[rustc_clean(label="Hir", cfg="cfail3")]
 150     #[rustc_metadata_dirty(cfg="cfail2")]
 151     #[rustc_metadata_clean(cfg="cfail3")]
 152     fn method(a: u32);
 153 }
 154
 155
 156
 157 // Change name of method parameter ------------------------------------------------
 158 #[cfg(cfail1)]
 159 trait TraitChangeMethodParameterName {
 160     fn method(a: u32);
 161     fn with_default(x: i32) {}
 162 }
 163
 164 #[cfg(not(cfail1))]
 165 #[rustc_clean(label="Hir", cfg="cfail2")]
 166 #[rustc_clean(label="Hir", cfg="cfail3")]
 167 #[rustc_metadata_clean(cfg="cfail2")]
 168 #[rustc_metadata_clean(cfg="cfail3")]
 169 trait TraitChangeMethodParameterName {
 170     // FIXME(#38501) This should preferably always be clean.
 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     fn method(b: u32);
 176
 177     #[rustc_clean(label="Hir", cfg="cfail2")]
 178     #[rustc_clean(label="Hir", cfg="cfail3")]
 179     #[rustc_dirty(label="HirBody", cfg="cfail2")]
 180     #[rustc_clean(label="HirBody", cfg="cfail3")]
 181     #[rustc_metadata_dirty(cfg="cfail2")]
 182     #[rustc_metadata_clean(cfg="cfail3")]
 183     fn with_default(y: i32) {}
 184 }
 185
 186
 187
 188 // Change type of method parameter (i32 => i64) -----------------------------------
 189 #[cfg(cfail1)]
 190 trait TraitChangeMethodParameterType {
 191     fn method(a: i32);
 192 }
 193
 194 #[cfg(not(cfail1))]
 195 #[rustc_clean(label="Hir", cfg="cfail2")]
 196 #[rustc_clean(label="Hir", cfg="cfail3")]
 197 #[rustc_metadata_clean(cfg="cfail2")]
 198 #[rustc_metadata_clean(cfg="cfail3")]
 199 trait TraitChangeMethodParameterType {
 200     #[rustc_dirty(label="Hir", cfg="cfail2")]
 201     #[rustc_clean(label="Hir", cfg="cfail3")]
 202     #[rustc_metadata_dirty(cfg="cfail2")]
 203     #[rustc_metadata_clean(cfg="cfail3")]
 204     fn method(a: i64);
 205 }
 206
 207
 208
 209 // Change type of method parameter (&i32 => &mut i32) -----------------------------
 210 #[cfg(cfail1)]
 211 trait TraitChangeMethodParameterTypeRef {
 212     fn method(a: &i32);
 213 }
 214
 215 #[cfg(not(cfail1))]
 216 #[rustc_clean(label="Hir", cfg="cfail2")]
 217 #[rustc_clean(label="Hir", cfg="cfail3")]
 218 #[rustc_metadata_clean(cfg="cfail2")]
 219 #[rustc_metadata_clean(cfg="cfail3")]
 220 trait TraitChangeMethodParameterTypeRef {
 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     fn method(a: &mut i32);
 226 }
 227
 228
 229
 230 // Change order of method parameters ----------------------------------------------
 231 #[cfg(cfail1)]
 232 trait TraitChangeMethodParametersOrder {
 233     fn method(a: i32, b: i64);
 234 }
 235
 236 #[cfg(not(cfail1))]
 237 #[rustc_clean(label="Hir", cfg="cfail2")]
 238 #[rustc_clean(label="Hir", cfg="cfail3")]
 239 #[rustc_metadata_clean(cfg="cfail2")]
 240 #[rustc_metadata_clean(cfg="cfail3")]
 241 trait TraitChangeMethodParametersOrder {
 242     #[rustc_dirty(label="Hir", cfg="cfail2")]
 243     #[rustc_clean(label="Hir", cfg="cfail3")]
 244     #[rustc_metadata_dirty(cfg="cfail2")]
 245     #[rustc_metadata_clean(cfg="cfail3")]
 246     fn method(b: i64, a: i32);
 247 }
 248
 249
 250
 251 // Add default implementation to method -------------------------------------------
 252 #[cfg(cfail1)]
 253 trait TraitAddMethodDefaultImplementation {
 254     fn method();
 255 }
 256
 257 #[cfg(not(cfail1))]
 258 #[rustc_dirty(label="Hir", cfg="cfail2")]
 259 #[rustc_clean(label="Hir", cfg="cfail3")]
 260 #[rustc_metadata_clean(cfg="cfail2")]
 261 #[rustc_metadata_clean(cfg="cfail3")]
 262 trait TraitAddMethodDefaultImplementation {
 263     #[rustc_dirty(label="Hir", cfg="cfail2")]
 264     #[rustc_clean(label="Hir", cfg="cfail3")]
 265     #[rustc_metadata_dirty(cfg="cfail2")]
 266     #[rustc_metadata_clean(cfg="cfail3")]
 267     fn method() { }
 268 }
 269
 270
 271
 272 // Change order of methods --------------------------------------------------------
 273 #[cfg(cfail1)]
 274 trait TraitChangeOrderOfMethods {
 275     fn method0();
 276     fn method1();
 277 }
 278
 279 #[cfg(not(cfail1))]
 280 #[rustc_dirty(label="Hir", cfg="cfail2")]
 281 #[rustc_clean(label="Hir", cfg="cfail3")]
 282 #[rustc_metadata_dirty(cfg="cfail2")]
 283 #[rustc_metadata_clean(cfg="cfail3")]
 284 trait TraitChangeOrderOfMethods {
 285     fn method1();
 286     fn method0();
 287 }
 288
 289
 290
 291 // Change mode of self parameter --------------------------------------------------
 292 #[cfg(cfail1)]
 293 trait TraitChangeModeSelfRefToMut {
 294     fn method(&self);
 295 }
 296
 297 #[cfg(not(cfail1))]
 298 #[rustc_clean(label="Hir", cfg="cfail2")]
 299 #[rustc_clean(label="Hir", cfg="cfail3")]
 300 #[rustc_metadata_clean(cfg="cfail2")]
 301 #[rustc_metadata_clean(cfg="cfail3")]
 302 trait TraitChangeModeSelfRefToMut {
 303     #[rustc_dirty(label="Hir", cfg="cfail2")]
 304     #[rustc_clean(label="Hir", cfg="cfail3")]
 305     #[rustc_metadata_dirty(cfg="cfail2")]
 306     #[rustc_metadata_clean(cfg="cfail3")]
 307     fn method(&mut self);
 308 }
 309
 310
 311
 312 #[cfg(cfail1)]
 313 trait TraitChangeModeSelfOwnToMut: Sized {
 314     fn method(self) {}
 315 }
 316
 317 #[cfg(not(cfail1))]
 318 #[rustc_clean(label="Hir", cfg="cfail2")]
 319 #[rustc_clean(label="Hir", cfg="cfail3")]
 320 #[rustc_metadata_clean(cfg="cfail2")]
 321 #[rustc_metadata_clean(cfg="cfail3")]
 322 trait TraitChangeModeSelfOwnToMut: Sized {
 323     #[rustc_clean(label="Hir", cfg="cfail2")]
 324     #[rustc_clean(label="Hir", cfg="cfail3")]
 325     #[rustc_dirty(label="HirBody", cfg="cfail2")]
 326     #[rustc_clean(label="HirBody", cfg="cfail3")]
 327     #[rustc_metadata_dirty(cfg="cfail2")]
 328     #[rustc_metadata_clean(cfg="cfail3")]
 329     fn method(mut self) {}
 330 }
 331
 332
 333
 334 #[cfg(cfail1)]
 335 trait TraitChangeModeSelfOwnToRef {
 336     fn method(self);
 337 }
 338
 339 #[cfg(not(cfail1))]
 340 #[rustc_clean(label="Hir", cfg="cfail2")]
 341 #[rustc_clean(label="Hir", cfg="cfail3")]
 342 #[rustc_metadata_clean(cfg="cfail2")]
 343 #[rustc_metadata_clean(cfg="cfail3")]
 344 trait TraitChangeModeSelfOwnToRef {
 345     #[rustc_dirty(label="Hir", cfg="cfail2")]
 346     #[rustc_clean(label="Hir", cfg="cfail3")]
 347     #[rustc_metadata_dirty(cfg="cfail2")]
 348     #[rustc_metadata_clean(cfg="cfail3")]
 349     fn method(&self);
 350 }
 351
 352
 353
 354 // Add unsafe modifier to method --------------------------------------------------
 355 #[cfg(cfail1)]
 356 trait TraitAddUnsafeModifier {
 357     fn method();
 358 }
 359
 360 #[cfg(not(cfail1))]
 361 #[rustc_clean(label="Hir", cfg="cfail2")]
 362 #[rustc_clean(label="Hir", cfg="cfail3")]
 363 #[rustc_metadata_clean(cfg="cfail2")]
 364 #[rustc_metadata_clean(cfg="cfail3")]
 365 trait TraitAddUnsafeModifier {
 366     #[rustc_dirty(label="Hir", cfg="cfail2")]
 367     #[rustc_clean(label="Hir", cfg="cfail3")]
 368     #[rustc_metadata_dirty(cfg="cfail2")]
 369     #[rustc_metadata_clean(cfg="cfail3")]
 370     unsafe fn method();
 371 }
 372
 373
 374
 375 // Add extern modifier to method --------------------------------------------------
 376 #[cfg(cfail1)]
 377 trait TraitAddExternModifier {
 378     fn method();
 379 }
 380
 381 #[cfg(not(cfail1))]
 382 #[rustc_clean(label="Hir", cfg="cfail2")]
 383 #[rustc_clean(label="Hir", cfg="cfail3")]
 384 #[rustc_metadata_clean(cfg="cfail2")]
 385 #[rustc_metadata_clean(cfg="cfail3")]
 386 trait TraitAddExternModifier {
 387     #[rustc_dirty(label="Hir", cfg="cfail2")]
 388     #[rustc_clean(label="Hir", cfg="cfail3")]
 389     #[rustc_metadata_dirty(cfg="cfail2")]
 390     #[rustc_metadata_clean(cfg="cfail3")]
 391     extern fn method();
 392 }
 393
 394
 395
 396 // Change extern "C" to extern "rust-intrinsic" -----------------------------------
 397 #[cfg(cfail1)]
 398 trait TraitChangeExternCToRustIntrinsic {
 399     extern "C" fn method();
 400 }
 401
 402 #[cfg(not(cfail1))]
 403 #[rustc_clean(label="Hir", cfg="cfail2")]
 404 #[rustc_clean(label="Hir", cfg="cfail3")]
 405 #[rustc_metadata_clean(cfg="cfail2")]
 406 #[rustc_metadata_clean(cfg="cfail3")]
 407 trait TraitChangeExternCToRustIntrinsic {
 408     #[rustc_dirty(label="Hir", cfg="cfail2")]
 409     #[rustc_clean(label="Hir", cfg="cfail3")]
 410     #[rustc_metadata_dirty(cfg="cfail2")]
 411     #[rustc_metadata_clean(cfg="cfail3")]
 412     extern "rust-intrinsic" fn method();
 413 }
 414
 415
 416
 417 // Add type parameter to method ---------------------------------------------------
 418 #[cfg(cfail1)]
 419 trait TraitAddTypeParameterToMethod {
 420     fn method();
 421 }
 422
 423 #[cfg(not(cfail1))]
 424 #[rustc_clean(label="Hir", cfg="cfail2")]
 425 #[rustc_clean(label="Hir", cfg="cfail3")]
 426 #[rustc_metadata_clean(cfg="cfail2")]
 427 #[rustc_metadata_clean(cfg="cfail3")]
 428 trait TraitAddTypeParameterToMethod {
 429     #[rustc_dirty(label="Hir", cfg="cfail2")]
 430     #[rustc_clean(label="Hir", cfg="cfail3")]
 431     #[rustc_metadata_dirty(cfg="cfail2")]
 432     #[rustc_metadata_clean(cfg="cfail3")]
 433     fn method<T>();
 434 }
 435
 436
 437
 438 // Add lifetime parameter to method -----------------------------------------------
 439 #[cfg(cfail1)]
 440 trait TraitAddLifetimeParameterToMethod {
 441     fn method();
 442 }
 443
 444 #[cfg(not(cfail1))]
 445 #[rustc_clean(label="Hir", cfg="cfail2")]
 446 #[rustc_clean(label="Hir", cfg="cfail3")]
 447 #[rustc_metadata_clean(cfg="cfail2")]
 448 #[rustc_metadata_clean(cfg="cfail3")]
 449 trait TraitAddLifetimeParameterToMethod {
 450     #[rustc_dirty(label="Hir", cfg="cfail2")]
 451     #[rustc_clean(label="Hir", cfg="cfail3")]
 452     #[rustc_metadata_clean(cfg="cfail2")] // Unused lifetimes don't seem to show up in type?
 453     #[rustc_metadata_clean(cfg="cfail3")]
 454     fn method<'a>();
 455 }
 456
 457
 458
 459 // dummy trait for bound
 460 trait ReferencedTrait0 { }
 461 trait ReferencedTrait1 { }
 462
 463 // Add trait bound to method type parameter ---------------------------------------
 464 #[cfg(cfail1)]
 465 trait TraitAddTraitBoundToMethodTypeParameter {
 466     fn method<T>();
 467 }
 468
 469 #[cfg(not(cfail1))]
 470 #[rustc_clean(label="Hir", cfg="cfail2")]
 471 #[rustc_clean(label="Hir", cfg="cfail3")]
 472 #[rustc_metadata_clean(cfg="cfail2")]
 473 #[rustc_metadata_clean(cfg="cfail3")]
 474 trait TraitAddTraitBoundToMethodTypeParameter {
 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     fn method<T: ReferencedTrait0>();
 480 }
 481
 482
 483
 484 // Add builtin bound to method type parameter -------------------------------------
 485 #[cfg(cfail1)]
 486 trait TraitAddBuiltinBoundToMethodTypeParameter {
 487     fn method<T>();
 488 }
 489
 490 #[cfg(not(cfail1))]
 491 #[rustc_clean(label="Hir", cfg="cfail2")]
 492 #[rustc_clean(label="Hir", cfg="cfail3")]
 493 #[rustc_metadata_clean(cfg="cfail2")]
 494 #[rustc_metadata_clean(cfg="cfail3")]
 495 trait TraitAddBuiltinBoundToMethodTypeParameter {
 496     #[rustc_dirty(label="Hir", cfg="cfail2")]
 497     #[rustc_clean(label="Hir", cfg="cfail3")]
 498     #[rustc_metadata_dirty(cfg="cfail2")]
 499     #[rustc_metadata_clean(cfg="cfail3")]
 500     fn method<T: Sized>();
 501 }
 502
 503
 504
 505 // Add lifetime bound to method lifetime parameter ------------------------------------
 506 #[cfg(cfail1)]
 507 trait TraitAddLifetimeBoundToMethodLifetimeParameter {
 508     fn method<'a, 'b>(a: &'a u32, b: &'b u32);
 509 }
 510
 511 #[cfg(not(cfail1))]
 512 #[rustc_clean(label="Hir", cfg="cfail2")]
 513 #[rustc_clean(label="Hir", cfg="cfail3")]
 514 #[rustc_metadata_clean(cfg="cfail2")]
 515 #[rustc_metadata_clean(cfg="cfail3")]
 516 trait TraitAddLifetimeBoundToMethodLifetimeParameter {
 517     #[rustc_dirty(label="Hir", cfg="cfail2")]
 518     #[rustc_clean(label="Hir", cfg="cfail3")]
 519     #[rustc_metadata_dirty(cfg="cfail2")]
 520     #[rustc_metadata_clean(cfg="cfail3")]
 521     fn method<'a, 'b: 'a>(a: &'a u32, b: &'b u32);
 522 }
 523
 524
 525
 526 // Add second trait bound to method type parameter --------------------------------
 527 #[cfg(cfail1)]
 528 trait TraitAddSecondTraitBoundToMethodTypeParameter {
 529     fn method<T: ReferencedTrait0>();
 530 }
 531
 532 #[cfg(not(cfail1))]
 533 #[rustc_clean(label="Hir", cfg="cfail2")]
 534 #[rustc_clean(label="Hir", cfg="cfail3")]
 535 #[rustc_metadata_clean(cfg="cfail2")]
 536 #[rustc_metadata_clean(cfg="cfail3")]
 537 trait TraitAddSecondTraitBoundToMethodTypeParameter {
 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     fn method<T: ReferencedTrait0 + ReferencedTrait1>();
 543 }
 544
 545
 546
 547 // Add second builtin bound to method type parameter ------------------------------
 548 #[cfg(cfail1)]
 549 trait TraitAddSecondBuiltinBoundToMethodTypeParameter {
 550     fn method<T: Sized>();
 551 }
 552
 553 #[cfg(not(cfail1))]
 554 #[rustc_clean(label="Hir", cfg="cfail2")]
 555 #[rustc_clean(label="Hir", cfg="cfail3")]
 556 #[rustc_metadata_clean(cfg="cfail2")]
 557 #[rustc_metadata_clean(cfg="cfail3")]
 558 trait TraitAddSecondBuiltinBoundToMethodTypeParameter {
 559     #[rustc_dirty(label="Hir", cfg="cfail2")]
 560     #[rustc_clean(label="Hir", cfg="cfail3")]
 561     #[rustc_metadata_dirty(cfg="cfail2")]
 562     #[rustc_metadata_clean(cfg="cfail3")]
 563     fn method<T: Sized + Sync>();
 564 }
 565
 566
 567
 568 // Add second lifetime bound to method lifetime parameter -----------------------------
 569 #[cfg(cfail1)]
 570 trait TraitAddSecondLifetimeBoundToMethodLifetimeParameter {
 571     fn method<'a, 'b, 'c: 'a>(a: &'a u32, b: &'b u32, c: &'c u32);
 572 }
 573
 574 #[cfg(not(cfail1))]
 575 #[rustc_clean(label="Hir", cfg="cfail2")]
 576 #[rustc_clean(label="Hir", cfg="cfail3")]
 577 #[rustc_metadata_clean(cfg="cfail2")]
 578 #[rustc_metadata_clean(cfg="cfail3")]
 579 trait TraitAddSecondLifetimeBoundToMethodLifetimeParameter {
 580     #[rustc_dirty(label="Hir", cfg="cfail2")]
 581     #[rustc_clean(label="Hir", cfg="cfail3")]
 582     #[rustc_metadata_dirty(cfg="cfail2")]
 583     #[rustc_metadata_clean(cfg="cfail3")]
 584     fn method<'a, 'b, 'c: 'a + 'b>(a: &'a u32, b: &'b u32, c: &'c u32);
 585 }
 586
 587
 588
 589 // Add associated type ------------------------------------------------------------
 590 #[cfg(cfail1)]
 591 trait TraitAddAssociatedType {
 592
 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     fn method();
 598 }
 599
 600 #[cfg(not(cfail1))]
 601 #[rustc_dirty(label="Hir", cfg="cfail2")]
 602 #[rustc_clean(label="Hir", cfg="cfail3")]
 603 #[rustc_metadata_dirty(cfg="cfail2")]
 604 #[rustc_metadata_clean(cfg="cfail3")]
 605 trait TraitAddAssociatedType {
 606     type Associated;
 607
 608     fn method();
 609 }
 610
 611
 612
 613 // Add trait bound to associated type ---------------------------------------------
 614 #[cfg(cfail1)]
 615 trait TraitAddTraitBoundToAssociatedType {
 616     type Associated;
 617
 618     fn method();
 619 }
 620
 621
 622 // Apparently the type bound contributes to the predicates of the trait, but
 623 // does not change the associated item itself.
 624 #[cfg(not(cfail1))]
 625 #[rustc_clean(label="Hir", cfg="cfail2")]
 626 #[rustc_clean(label="Hir", cfg="cfail3")]
 627 #[rustc_metadata_dirty(cfg="cfail2")]
 628 #[rustc_metadata_clean(cfg="cfail3")]
 629 trait TraitAddTraitBoundToAssociatedType {
 630     #[rustc_dirty(label="Hir", cfg="cfail2")]
 631     #[rustc_clean(label="Hir", cfg="cfail3")]
 632     #[rustc_metadata_clean(cfg="cfail2")]
 633     #[rustc_metadata_clean(cfg="cfail3")]
 634     type Associated: ReferencedTrait0;
 635
 636     fn method();
 637 }
 638
 639
 640
 641 // Add lifetime bound to associated type ------------------------------------------
 642 #[cfg(cfail1)]
 643 trait TraitAddLifetimeBoundToAssociatedType<'a> {
 644     type Associated;
 645
 646     fn method();
 647 }
 648
 649 #[cfg(not(cfail1))]
 650 #[rustc_clean(label="Hir", cfg="cfail2")]
 651 #[rustc_clean(label="Hir", cfg="cfail3")]
 652 #[rustc_metadata_dirty(cfg="cfail2")]
 653 #[rustc_metadata_clean(cfg="cfail3")]
 654 trait TraitAddLifetimeBoundToAssociatedType<'a> {
 655     #[rustc_dirty(label="Hir", cfg="cfail2")]
 656     #[rustc_clean(label="Hir", cfg="cfail3")]
 657     #[rustc_metadata_clean(cfg="cfail2")]
 658     #[rustc_metadata_clean(cfg="cfail3")]
 659     type Associated: 'a;
 660
 661     fn method();
 662 }
 663
 664
 665
 666 // Add default to associated type -------------------------------------------------
 667 #[cfg(cfail1)]
 668 trait TraitAddDefaultToAssociatedType {
 669     type Associated;
 670
 671     fn method();
 672 }
 673
 674 #[cfg(not(cfail1))]
 675 #[rustc_dirty(label="Hir", cfg="cfail2")]
 676 #[rustc_clean(label="Hir", cfg="cfail3")]
 677 #[rustc_metadata_clean(cfg="cfail2")]
 678 #[rustc_metadata_clean(cfg="cfail3")]
 679 trait TraitAddDefaultToAssociatedType {
 680     #[rustc_dirty(label="Hir", cfg="cfail2")]
 681     #[rustc_clean(label="Hir", cfg="cfail3")]
 682     #[rustc_metadata_dirty(cfg="cfail2")]
 683     #[rustc_metadata_clean(cfg="cfail3")]
 684     type Associated = ReferenceType0;
 685
 686     fn method();
 687 }
 688
 689
 690
 691 // Add associated constant --------------------------------------------------------
 692 #[cfg(cfail1)]
 693 trait TraitAddAssociatedConstant {
 694     fn method();
 695 }
 696
 697 #[cfg(not(cfail1))]
 698 #[rustc_dirty(label="Hir", cfg="cfail2")]
 699 #[rustc_clean(label="Hir", cfg="cfail3")]
 700 #[rustc_metadata_dirty(cfg="cfail2")]
 701 #[rustc_metadata_clean(cfg="cfail3")]
 702 trait TraitAddAssociatedConstant {
 703     const Value: u32;
 704
 705     fn method();
 706 }
 707
 708
 709
 710 // Add initializer to associated constant -----------------------------------------
 711 #[cfg(cfail1)]
 712 trait TraitAddInitializerToAssociatedConstant {
 713     const Value: u32;
 714
 715     fn method();
 716 }
 717
 718 #[cfg(not(cfail1))]
 719 #[rustc_dirty(label="Hir", cfg="cfail2")]
 720 #[rustc_clean(label="Hir", cfg="cfail3")]
 721 #[rustc_metadata_clean(cfg="cfail2")]
 722 #[rustc_metadata_clean(cfg="cfail3")]
 723 trait TraitAddInitializerToAssociatedConstant {
 724     #[rustc_dirty(label="Hir", cfg="cfail2")]
 725     #[rustc_clean(label="Hir", cfg="cfail3")]
 726     #[rustc_metadata_dirty(cfg="cfail2")]
 727     #[rustc_metadata_clean(cfg="cfail3")]
 728     const Value: u32 = 1;
 729
 730     #[rustc_clean(label="Hir", cfg="cfail2")]
 731     #[rustc_clean(label="Hir", cfg="cfail3")]
 732     #[rustc_metadata_clean(cfg="cfail2")]
 733     #[rustc_metadata_clean(cfg="cfail3")]
 734     fn method();
 735 }
 736
 737
 738
 739 // Change type of associated constant ---------------------------------------------
 740 #[cfg(cfail1)]
 741 trait TraitChangeTypeOfAssociatedConstant {
 742     const Value: u32;
 743
 744     fn method();
 745 }
 746
 747 #[cfg(not(cfail1))]
 748 #[rustc_clean(label="Hir", cfg="cfail2")]
 749 #[rustc_clean(label="Hir", cfg="cfail3")]
 750 #[rustc_metadata_clean(cfg="cfail2")]
 751 #[rustc_metadata_clean(cfg="cfail3")]
 752 trait TraitChangeTypeOfAssociatedConstant {
 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     const Value: f64;
 758
 759     #[rustc_clean(label="Hir", cfg="cfail2")]
 760     #[rustc_clean(label="Hir", cfg="cfail3")]
 761     #[rustc_metadata_clean(cfg="cfail2")]
 762     #[rustc_metadata_clean(cfg="cfail3")]
 763     fn method();
 764 }
 765
 766
 767
 768 // Add super trait ----------------------------------------------------------------
 769 #[cfg(cfail1)]
 770 trait TraitAddSuperTrait { }
 771
 772 #[cfg(not(cfail1))]
 773 #[rustc_dirty(label="Hir", cfg="cfail2")]
 774 #[rustc_clean(label="Hir", cfg="cfail3")]
 775 #[rustc_metadata_dirty(cfg="cfail2")]
 776 #[rustc_metadata_clean(cfg="cfail3")]
 777 trait TraitAddSuperTrait : ReferencedTrait0 { }
 778
 779
 780
 781 // Add builtin bound (Send or Copy) -----------------------------------------------
 782 #[cfg(cfail1)]
 783 trait TraitAddBuiltiBound { }
 784
 785 #[cfg(not(cfail1))]
 786 #[rustc_dirty(label="Hir", cfg="cfail2")]
 787 #[rustc_clean(label="Hir", cfg="cfail3")]
 788 #[rustc_metadata_dirty(cfg="cfail2")]
 789 #[rustc_metadata_clean(cfg="cfail3")]
 790 trait TraitAddBuiltiBound : Send { }
 791
 792
 793
 794 // Add 'static lifetime bound to trait --------------------------------------------
 795 #[cfg(cfail1)]
 796 trait TraitAddStaticLifetimeBound { }
 797
 798 #[cfg(not(cfail1))]
 799 #[rustc_dirty(label="Hir", cfg="cfail2")]
 800 #[rustc_clean(label="Hir", cfg="cfail3")]
 801 #[rustc_metadata_dirty(cfg="cfail2")]
 802 #[rustc_metadata_clean(cfg="cfail3")]
 803 trait TraitAddStaticLifetimeBound : 'static { }
 804
 805
 806
 807 // Add super trait as second bound ------------------------------------------------
 808 #[cfg(cfail1)]
 809 trait TraitAddTraitAsSecondBound : ReferencedTrait0 { }
 810
 811 #[cfg(not(cfail1))]
 812 #[rustc_dirty(label="Hir", cfg="cfail2")]
 813 #[rustc_clean(label="Hir", cfg="cfail3")]
 814 #[rustc_metadata_dirty(cfg="cfail2")]
 815 #[rustc_metadata_clean(cfg="cfail3")]
 816 trait TraitAddTraitAsSecondBound : ReferencedTrait0 + ReferencedTrait1 { }
 817
 818 #[cfg(cfail1)]
 819 trait TraitAddTraitAsSecondBoundFromBuiltin : Send { }
 820
 821 #[cfg(not(cfail1))]
 822 #[rustc_dirty(label="Hir", cfg="cfail2")]
 823 #[rustc_clean(label="Hir", cfg="cfail3")]
 824 #[rustc_metadata_dirty(cfg="cfail2")]
 825 #[rustc_metadata_clean(cfg="cfail3")]
 826 trait TraitAddTraitAsSecondBoundFromBuiltin : Send + ReferencedTrait0 { }
 827
 828
 829
 830 // Add builtin bound as second bound ----------------------------------------------
 831 #[cfg(cfail1)]
 832 trait TraitAddBuiltinBoundAsSecondBound : ReferencedTrait0 { }
 833
 834 #[cfg(not(cfail1))]
 835 #[rustc_dirty(label="Hir", cfg="cfail2")]
 836 #[rustc_clean(label="Hir", cfg="cfail3")]
 837 #[rustc_metadata_dirty(cfg="cfail2")]
 838 #[rustc_metadata_clean(cfg="cfail3")]
 839 trait TraitAddBuiltinBoundAsSecondBound : ReferencedTrait0 + Send { }
 840
 841 #[cfg(cfail1)]
 842 trait TraitAddBuiltinBoundAsSecondBoundFromBuiltin : Send { }
 843
 844 #[cfg(not(cfail1))]
 845 #[rustc_dirty(label="Hir", cfg="cfail2")]
 846 #[rustc_clean(label="Hir", cfg="cfail3")]
 847 #[rustc_metadata_dirty(cfg="cfail2")]
 848 #[rustc_metadata_clean(cfg="cfail3")]
 849 trait TraitAddBuiltinBoundAsSecondBoundFromBuiltin: Send + Copy { }
 850
 851
 852
 853 // Add 'static bounds as second bound ---------------------------------------------
 854 #[cfg(cfail1)]
 855 trait TraitAddStaticBoundAsSecondBound : ReferencedTrait0 { }
 856
 857 #[cfg(not(cfail1))]
 858 #[rustc_dirty(label="Hir", cfg="cfail2")]
 859 #[rustc_clean(label="Hir", cfg="cfail3")]
 860 #[rustc_metadata_dirty(cfg="cfail2")]
 861 #[rustc_metadata_clean(cfg="cfail3")]
 862 trait TraitAddStaticBoundAsSecondBound : ReferencedTrait0 + 'static { }
 863
 864 #[cfg(cfail1)]
 865 trait TraitAddStaticBoundAsSecondBoundFromBuiltin : Send { }
 866
 867 #[cfg(not(cfail1))]
 868 #[rustc_dirty(label="Hir", cfg="cfail2")]
 869 #[rustc_clean(label="Hir", cfg="cfail3")]
 870 #[rustc_metadata_dirty(cfg="cfail2")]
 871 #[rustc_metadata_clean(cfg="cfail3")]
 872 trait TraitAddStaticBoundAsSecondBoundFromBuiltin : Send + 'static { }
 873
 874
 875
 876 // Add type parameter to trait ----------------------------------------------------
 877 #[cfg(cfail1)]
 878 trait TraitAddTypeParameterToTrait { }
 879
 880 #[cfg(not(cfail1))]
 881 #[rustc_dirty(label="Hir", cfg="cfail2")]
 882 #[rustc_clean(label="Hir", cfg="cfail3")]
 883 #[rustc_metadata_dirty(cfg="cfail2")]
 884 #[rustc_metadata_clean(cfg="cfail3")]
 885 trait TraitAddTypeParameterToTrait<T> { }
 886
 887
 888
 889 // Add lifetime parameter to trait ------------------------------------------------
 890 #[cfg(cfail1)]
 891 trait TraitAddLifetimeParameterToTrait { }
 892
 893 #[cfg(not(cfail1))]
 894 #[rustc_dirty(label="Hir", cfg="cfail2")]
 895 #[rustc_clean(label="Hir", cfg="cfail3")]
 896 #[rustc_metadata_dirty(cfg="cfail2")]
 897 #[rustc_metadata_clean(cfg="cfail3")]
 898 trait TraitAddLifetimeParameterToTrait<'a> { }
 899
 900
 901
 902 // Add trait bound to type parameter of trait -------------------------------------
 903 #[cfg(cfail1)]
 904 trait TraitAddTraitBoundToTypeParameterOfTrait<T> { }
 905
 906 #[cfg(not(cfail1))]
 907 #[rustc_dirty(label="Hir", cfg="cfail2")]
 908 #[rustc_clean(label="Hir", cfg="cfail3")]
 909 #[rustc_metadata_dirty(cfg="cfail2")]
 910 #[rustc_metadata_clean(cfg="cfail3")]
 911 trait TraitAddTraitBoundToTypeParameterOfTrait<T: ReferencedTrait0> { }
 912
 913
 914
 915 // Add lifetime bound to type parameter of trait ----------------------------------
 916 #[cfg(cfail1)]
 917 trait TraitAddLifetimeBoundToTypeParameterOfTrait<'a, T> { }
 918
 919 #[cfg(not(cfail1))]
 920 #[rustc_dirty(label="Hir", cfg="cfail2")]
 921 #[rustc_clean(label="Hir", cfg="cfail3")]
 922 #[rustc_metadata_dirty(cfg="cfail2")]
 923 #[rustc_metadata_clean(cfg="cfail3")]
 924 trait TraitAddLifetimeBoundToTypeParameterOfTrait<'a, T: 'a> { }
 925
 926
 927
 928 // Add lifetime bound to lifetime parameter of trait ------------------------------
 929 #[cfg(cfail1)]
 930 trait TraitAddLifetimeBoundToLifetimeParameterOfTrait<'a, 'b> { }
 931
 932 #[cfg(not(cfail1))]
 933 #[rustc_dirty(label="Hir", cfg="cfail2")]
 934 #[rustc_clean(label="Hir", cfg="cfail3")]
 935 #[rustc_metadata_dirty(cfg="cfail2")]
 936 #[rustc_metadata_clean(cfg="cfail3")]
 937 trait TraitAddLifetimeBoundToLifetimeParameterOfTrait<'a: 'b, 'b> { }
 938
 939
 940
 941 // Add builtin bound to type parameter of trait -----------------------------------
 942 #[cfg(cfail1)]
 943 trait TraitAddBuiltinBoundToTypeParameterOfTrait<T> { }
 944
 945 #[cfg(not(cfail1))]
 946 #[rustc_dirty(label="Hir", cfg="cfail2")]
 947 #[rustc_clean(label="Hir", cfg="cfail3")]
 948 #[rustc_metadata_dirty(cfg="cfail2")]
 949 #[rustc_metadata_clean(cfg="cfail3")]
 950 trait TraitAddBuiltinBoundToTypeParameterOfTrait<T: Send> { }
 951
 952
 953
 954 // Add second type parameter to trait ---------------------------------------------
 955 #[cfg(cfail1)]
 956 trait TraitAddSecondTypeParameterToTrait<T> { }
 957
 958 #[cfg(not(cfail1))]
 959 #[rustc_dirty(label="Hir", cfg="cfail2")]
 960 #[rustc_clean(label="Hir", cfg="cfail3")]
 961 #[rustc_metadata_dirty(cfg="cfail2")]
 962 #[rustc_metadata_clean(cfg="cfail3")]
 963 trait TraitAddSecondTypeParameterToTrait<T, S> { }
 964
 965
 966
 967 // Add second lifetime parameter to trait -----------------------------------------
 968 #[cfg(cfail1)]
 969 trait TraitAddSecondLifetimeParameterToTrait<'a> { }
 970
 971 #[cfg(not(cfail1))]
 972 #[rustc_dirty(label="Hir", cfg="cfail2")]
 973 #[rustc_clean(label="Hir", cfg="cfail3")]
 974 #[rustc_metadata_dirty(cfg="cfail2")]
 975 #[rustc_metadata_clean(cfg="cfail3")]
 976 trait TraitAddSecondLifetimeParameterToTrait<'a, 'b> { }
 977
 978
 979
 980 // Add second trait bound to type parameter of trait ------------------------------
 981 #[cfg(cfail1)]
 982 trait TraitAddSecondTraitBoundToTypeParameterOfTrait<T: ReferencedTrait0> { }
 983
 984 #[cfg(not(cfail1))]
 985 #[rustc_dirty(label="Hir", cfg="cfail2")]
 986 #[rustc_clean(label="Hir", cfg="cfail3")]
 987 #[rustc_metadata_dirty(cfg="cfail2")]
 988 #[rustc_metadata_clean(cfg="cfail3")]
 989 trait TraitAddSecondTraitBoundToTypeParameterOfTrait<T: ReferencedTrait0 + ReferencedTrait1> { }
 990
 991
 992
 993 // Add second lifetime bound to type parameter of trait ---------------------------
 994 #[cfg(cfail1)]
 995 trait TraitAddSecondLifetimeBoundToTypeParameterOfTrait<'a, 'b, T: 'a> { }
 996
 997 #[cfg(not(cfail1))]
 998 #[rustc_dirty(label="Hir", cfg="cfail2")]
 999 #[rustc_clean(label="Hir", cfg="cfail3")]
1000 #[rustc_metadata_dirty(cfg="cfail2")]
1001 #[rustc_metadata_clean(cfg="cfail3")]
1002 trait TraitAddSecondLifetimeBoundToTypeParameterOfTrait<'a, 'b, T: 'a + 'b> { }
1003
1004
1005
1006 // Add second lifetime bound to lifetime parameter of trait------------------------
1007 #[cfg(cfail1)]
1008 trait TraitAddSecondLifetimeBoundToLifetimeParameterOfTrait<'a: 'b, 'b, 'c> { }
1009
1010 #[cfg(not(cfail1))]
1011 #[rustc_dirty(label="Hir", cfg="cfail2")]
1012 #[rustc_clean(label="Hir", cfg="cfail3")]
1013 #[rustc_metadata_dirty(cfg="cfail2")]
1014 #[rustc_metadata_clean(cfg="cfail3")]
1015 trait TraitAddSecondLifetimeBoundToLifetimeParameterOfTrait<'a: 'b + 'c, 'b, 'c> { }
1016
1017
1018
1019 // Add second builtin bound to type parameter of trait ----------------------------
1020 #[cfg(cfail1)]
1021 trait TraitAddSecondBuiltinBoundToTypeParameterOfTrait<T: Send> { }
1022
1023 #[cfg(not(cfail1))]
1024 #[rustc_dirty(label="Hir", cfg="cfail2")]
1025 #[rustc_clean(label="Hir", cfg="cfail3")]
1026 #[rustc_metadata_dirty(cfg="cfail2")]
1027 #[rustc_metadata_clean(cfg="cfail3")]
1028 trait TraitAddSecondBuiltinBoundToTypeParameterOfTrait<T: Send + Sync> { }
1029
1030
1031
1032 // --------------------------------------------------------------------------------
1033 struct ReferenceType0 {}
1034 struct ReferenceType1 {}
1035
1036
1037
1038 // Add trait bound to type parameter of trait in where clause----------------------
1039 #[cfg(cfail1)]
1040 trait TraitAddTraitBoundToTypeParameterOfTraitWhere<T> { }
1041
1042 #[cfg(not(cfail1))]
1043 #[rustc_dirty(label="Hir", cfg="cfail2")]
1044 #[rustc_clean(label="Hir", cfg="cfail3")]
1045 #[rustc_metadata_dirty(cfg="cfail2")]
1046 #[rustc_metadata_clean(cfg="cfail3")]
1047 trait TraitAddTraitBoundToTypeParameterOfTraitWhere<T> where T: ReferencedTrait0 { }
1048
1049
1050
1051 // Add lifetime bound to type parameter of trait in where clause-------------------
1052 #[cfg(cfail1)]
1053 trait TraitAddLifetimeBoundToTypeParameterOfTraitWhere<'a, T> { }
1054
1055 #[cfg(not(cfail1))]
1056 #[rustc_dirty(label="Hir", cfg="cfail2")]
1057 #[rustc_clean(label="Hir", cfg="cfail3")]
1058 #[rustc_metadata_dirty(cfg="cfail2")]
1059 #[rustc_metadata_clean(cfg="cfail3")]
1060 trait TraitAddLifetimeBoundToTypeParameterOfTraitWhere<'a, T> where T: 'a { }
1061
1062
1063
1064 // Add lifetime bound to lifetime parameter of trait in where clause---------------
1065 #[cfg(cfail1)]
1066 trait TraitAddLifetimeBoundToLifetimeParameterOfTraitWhere<'a, 'b> { }
1067
1068 #[cfg(not(cfail1))]
1069 #[rustc_dirty(label="Hir", cfg="cfail2")]
1070 #[rustc_clean(label="Hir", cfg="cfail3")]
1071 #[rustc_metadata_dirty(cfg="cfail2")]
1072 #[rustc_metadata_clean(cfg="cfail3")]
1073 trait TraitAddLifetimeBoundToLifetimeParameterOfTraitWhere<'a, 'b> where 'a: 'b { }
1074
1075
1076
1077 // Add builtin bound to type parameter of trait in where clause--------------------
1078 #[cfg(cfail1)]
1079 trait TraitAddBuiltinBoundToTypeParameterOfTraitWhere<T> { }
1080
1081 #[cfg(not(cfail1))]
1082 #[rustc_dirty(label="Hir", cfg="cfail2")]
1083 #[rustc_clean(label="Hir", cfg="cfail3")]
1084 #[rustc_metadata_dirty(cfg="cfail2")]
1085 #[rustc_metadata_clean(cfg="cfail3")]
1086 trait TraitAddBuiltinBoundToTypeParameterOfTraitWhere<T> where T: Send { }
1087
1088
1089
1090 // Add second trait bound to type parameter of trait in where clause---------------
1091 #[cfg(cfail1)]
1092 trait TraitAddSecondTraitBoundToTypeParameterOfTraitWhere<T> where T: ReferencedTrait0 { }
1093
1094 #[cfg(not(cfail1))]
1095 #[rustc_dirty(label="Hir", cfg="cfail2")]
1096 #[rustc_clean(label="Hir", cfg="cfail3")]
1097 #[rustc_metadata_dirty(cfg="cfail2")]
1098 #[rustc_metadata_clean(cfg="cfail3")]
1099 trait TraitAddSecondTraitBoundToTypeParameterOfTraitWhere<T>
1100     where T: ReferencedTrait0 + ReferencedTrait1 { }
1101
1102
1103
1104 // Add second lifetime bound to type parameter of trait in where clause------------
1105 #[cfg(cfail1)]
1106 trait TraitAddSecondLifetimeBoundToTypeParameterOfTraitWhere<'a, 'b, T> where T: 'a { }
1107
1108 #[cfg(not(cfail1))]
1109 #[rustc_dirty(label="Hir", cfg="cfail2")]
1110 #[rustc_clean(label="Hir", cfg="cfail3")]
1111 #[rustc_metadata_dirty(cfg="cfail2")]
1112 #[rustc_metadata_clean(cfg="cfail3")]
1113 trait TraitAddSecondLifetimeBoundToTypeParameterOfTraitWhere<'a, 'b, T> where T: 'a + 'b { }
1114
1115
1116
1117 // Add second lifetime bound to lifetime parameter of trait in where clause--------
1118 #[cfg(cfail1)]
1119 trait TraitAddSecondLifetimeBoundToLifetimeParameterOfTraitWhere<'a, 'b, 'c> where 'a: 'b { }
1120
1121 #[cfg(not(cfail1))]
1122 #[rustc_dirty(label="Hir", cfg="cfail2")]
1123 #[rustc_clean(label="Hir", cfg="cfail3")]
1124 #[rustc_metadata_dirty(cfg="cfail2")]
1125 #[rustc_metadata_clean(cfg="cfail3")]
1126 trait TraitAddSecondLifetimeBoundToLifetimeParameterOfTraitWhere<'a, 'b, 'c> where 'a: 'b + 'c { }
1127
1128
1129
1130 // Add second builtin bound to type parameter of trait in where clause-------------
1131 #[cfg(cfail1)]
1132 trait TraitAddSecondBuiltinBoundToTypeParameterOfTraitWhere<T> where T: Send { }
1133
1134 #[cfg(not(cfail1))]
1135 #[rustc_dirty(label="Hir", cfg="cfail2")]
1136 #[rustc_clean(label="Hir", cfg="cfail3")]
1137 #[rustc_metadata_dirty(cfg="cfail2")]
1138 #[rustc_metadata_clean(cfg="cfail3")]
1139 trait TraitAddSecondBuiltinBoundToTypeParameterOfTraitWhere<T> where T: Send + Sync { }
1140
1141
1142 // Change return type of method indirectly by modifying a use statement------------
1143 mod change_return_type_of_method_indirectly_use {
1144     #[cfg(cfail1)]
1145     use super::ReferenceType0 as ReturnType;
1146     #[cfg(not(cfail1))]
1147     use super::ReferenceType1 as ReturnType;
1148
1149     #[rustc_clean(label="Hir", cfg="cfail2")]
1150     #[rustc_clean(label="Hir", cfg="cfail3")]
1151     #[rustc_metadata_clean(cfg="cfail2")]
1152     #[rustc_metadata_clean(cfg="cfail3")]
1153     trait TraitChangeReturnType {
1154         #[rustc_dirty(label="Hir", cfg="cfail2")]
1155         #[rustc_clean(label="Hir", cfg="cfail3")]
1156         #[rustc_metadata_dirty(cfg="cfail2")]
1157         #[rustc_metadata_clean(cfg="cfail3")]
1158         fn method() -> ReturnType;
1159     }
1160 }
1161
1162
1163
1164 // Change type of method parameter indirectly by modifying a use statement---------
1165 mod change_method_parameter_type_indirectly_by_use {
1166     #[cfg(cfail1)]
1167     use super::ReferenceType0 as ArgType;
1168     #[cfg(not(cfail1))]
1169     use super::ReferenceType1 as ArgType;
1170
1171     #[rustc_clean(label="Hir", cfg="cfail2")]
1172     #[rustc_clean(label="Hir", cfg="cfail3")]
1173     #[rustc_metadata_clean(cfg="cfail2")]
1174     #[rustc_metadata_clean(cfg="cfail3")]
1175     trait TraitChangeArgType {
1176         #[rustc_dirty(label="Hir", cfg="cfail2")]
1177         #[rustc_clean(label="Hir", cfg="cfail3")]
1178         #[rustc_metadata_dirty(cfg="cfail2")]
1179         #[rustc_metadata_clean(cfg="cfail3")]
1180         fn method(a: ArgType);
1181     }
1182 }
1183
1184
1185
1186 // Change trait bound of method type parameter indirectly by modifying a use statement
1187 mod change_method_parameter_type_bound_indirectly_by_use {
1188     #[cfg(cfail1)]
1189     use super::ReferencedTrait0 as Bound;
1190     #[cfg(not(cfail1))]
1191     use super::ReferencedTrait1 as Bound;
1192
1193     #[rustc_clean(label="Hir", cfg="cfail2")]
1194     #[rustc_clean(label="Hir", cfg="cfail3")]
1195     #[rustc_metadata_clean(cfg="cfail2")]
1196     #[rustc_metadata_clean(cfg="cfail3")]
1197     trait TraitChangeBoundOfMethodTypeParameter {
1198         #[rustc_dirty(label="Hir", cfg="cfail2")]
1199         #[rustc_clean(label="Hir", cfg="cfail3")]
1200         #[rustc_metadata_dirty(cfg="cfail2")]
1201         #[rustc_metadata_clean(cfg="cfail3")]
1202         fn method<T: Bound>(a: T);
1203     }
1204 }
1205
1206
1207
1208 // Change trait bound of method type parameter in where clause indirectly
1209 // by modifying a use statement
1210 mod change_method_parameter_type_bound_indirectly_by_use_where {
1211     #[cfg(cfail1)]
1212     use super::ReferencedTrait0 as Bound;
1213     #[cfg(not(cfail1))]
1214     use super::ReferencedTrait1 as Bound;
1215
1216     #[rustc_clean(label="Hir", cfg="cfail2")]
1217     #[rustc_clean(label="Hir", cfg="cfail3")]
1218     #[rustc_metadata_clean(cfg="cfail2")]
1219     #[rustc_metadata_clean(cfg="cfail3")]
1220     trait TraitChangeBoundOfMethodTypeParameterWhere {
1221         #[rustc_dirty(label="Hir", cfg="cfail2")]
1222         #[rustc_clean(label="Hir", cfg="cfail3")]
1223         #[rustc_metadata_dirty(cfg="cfail2")]
1224         #[rustc_metadata_clean(cfg="cfail3")]
1225         fn method<T>(a: T) where T: Bound;
1226     }
1227 }
1228
1229
1230
1231 // Change trait bound of trait type parameter indirectly by modifying a use statement
1232 mod change_method_type_parameter_bound_indirectly {
1233     #[cfg(cfail1)]
1234     use super::ReferencedTrait0 as Bound;
1235     #[cfg(not(cfail1))]
1236     use super::ReferencedTrait1 as Bound;
1237
1238     #[rustc_dirty(label="Hir", cfg="cfail2")]
1239     #[rustc_clean(label="Hir", cfg="cfail3")]
1240     #[rustc_metadata_dirty(cfg="cfail2")]
1241     #[rustc_metadata_clean(cfg="cfail3")]
1242     trait TraitChangeTraitBound<T: Bound> {
1243         fn method(a: T);
1244     }
1245 }
1246
1247
1248
1249 // Change trait bound of trait type parameter in where clause indirectly
1250 // by modifying a use statement
1251 mod change_method_type_parameter_bound_indirectly_where {
1252     #[cfg(cfail1)]
1253     use super::ReferencedTrait0 as Bound;
1254     #[cfg(not(cfail1))]
1255     use super::ReferencedTrait1 as Bound;
1256
1257     #[rustc_dirty(label="Hir", cfg="cfail2")]
1258     #[rustc_clean(label="Hir", cfg="cfail3")]
1259     #[rustc_metadata_dirty(cfg="cfail2")]
1260     #[rustc_metadata_clean(cfg="cfail3")]
1261     trait TraitChangeTraitBoundWhere<T> where T: Bound {
1262         fn method(a: T);
1263     }
1264 }