src/test/incremental/hashes/trait_impls.rs

   1 // This test case tests the incremental compilation hash (ICH) implementation
   2 // for let expressions.
   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 // build-pass (FIXME(62277): could be check-pass?)
   9 // revisions: cfail1 cfail2 cfail3 cfail4 cfail5 cfail6
  10 // compile-flags: -Z query-dep-graph -O
  11 // [cfail1]compile-flags: -Zincremental-ignore-spans
  12 // [cfail2]compile-flags: -Zincremental-ignore-spans
  13 // [cfail3]compile-flags: -Zincremental-ignore-spans
  14 // [cfail4]compile-flags: -Zincremental-relative-spans
  15 // [cfail5]compile-flags: -Zincremental-relative-spans
  16 // [cfail6]compile-flags: -Zincremental-relative-spans
  17
  18 #![allow(warnings)]
  19 #![feature(rustc_attrs)]
  20 #![feature(specialization)]
  21 #![crate_type="rlib"]
  22
  23 struct Foo;
  24
  25 // Change Method Name -----------------------------------------------------------
  26
  27 #[cfg(any(cfail1,cfail4))]
  28 pub trait ChangeMethodNameTrait {
  29     fn method_name();
  30 }
  31
  32 #[cfg(any(cfail1,cfail4))]
  33 impl ChangeMethodNameTrait for Foo {
  34     fn method_name() { }
  35 }
  36
  37 #[cfg(not(any(cfail1,cfail4)))]
  38 #[rustc_clean(except="hir_owner,hir_owner_nodes,associated_item_def_ids", cfg="cfail2")]
  39 #[rustc_clean(cfg="cfail3")]
  40 #[rustc_clean(except="hir_owner,hir_owner_nodes,associated_item_def_ids", cfg="cfail5")]
  41 #[rustc_clean(cfg="cfail6")]
  42 pub trait ChangeMethodNameTrait {
  43     #[rustc_clean(cfg="cfail3")]
  44     #[rustc_clean(cfg="cfail6")]
  45     fn method_name2();
  46 }
  47
  48 #[cfg(not(any(cfail1,cfail4)))]
  49 #[rustc_clean(except="hir_owner,hir_owner_nodes,associated_item_def_ids", cfg="cfail2")]
  50 #[rustc_clean(cfg="cfail3")]
  51 #[rustc_clean(except="hir_owner,hir_owner_nodes,associated_item_def_ids", cfg="cfail5")]
  52 #[rustc_clean(cfg="cfail6")]
  53 impl ChangeMethodNameTrait for Foo {
  54     #[rustc_clean(cfg="cfail3")]
  55     #[rustc_clean(cfg="cfail6")]
  56     fn method_name2() { }
  57 }
  58
  59 // Change Method Body -----------------------------------------------------------
  60 //
  61 // This should affect the method itself, but not the impl.
  62
  63 pub trait ChangeMethodBodyTrait {
  64     fn method_name();
  65 }
  66
  67 #[cfg(any(cfail1,cfail4))]
  68 impl ChangeMethodBodyTrait for Foo {
  69     // ----------------------------------------------------------
  70     // -------------------------
  71     // ----------------------------------------------------------
  72     // -------------------------
  73     fn method_name() {
  74         //
  75     }
  76 }
  77
  78 #[cfg(not(any(cfail1,cfail4)))]
  79 #[rustc_clean(cfg="cfail2")]
  80 #[rustc_clean(cfg="cfail3")]
  81 #[rustc_clean(cfg="cfail5")]
  82 #[rustc_clean(cfg="cfail6")]
  83 impl ChangeMethodBodyTrait for Foo {
  84     #[rustc_clean(except="hir_owner_nodes,typeck", cfg="cfail2")]
  85     #[rustc_clean(cfg="cfail3")]
  86     #[rustc_clean(except="hir_owner_nodes,typeck", cfg="cfail5")]
  87     #[rustc_clean(cfg="cfail6")]
  88     fn method_name() {
  89         ()
  90     }
  91 }
  92
  93 // Change Method Body (inlined fn) ---------------------------------------------
  94 //
  95 // This should affect the method itself, but not the impl.
  96
  97 pub trait ChangeMethodBodyTraitInlined {
  98     fn method_name();
  99 }
 100
 101 #[cfg(any(cfail1,cfail4))]
 102 impl ChangeMethodBodyTraitInlined for Foo {
 103     // ------------------------------------------------------------------------
 104     // -------------------------
 105     // ------------------------------------------------------------------------
 106     // -------------------------
 107     #[inline]
 108     fn method_name() {
 109         // -----
 110     }
 111 }
 112
 113 #[cfg(not(any(cfail1,cfail4)))]
 114 #[rustc_clean(cfg="cfail2")]
 115 #[rustc_clean(cfg="cfail3")]
 116 #[rustc_clean(cfg="cfail5")]
 117 #[rustc_clean(cfg="cfail6")]
 118 impl ChangeMethodBodyTraitInlined for Foo {
 119     #[rustc_clean(except="hir_owner_nodes,typeck,optimized_mir", cfg="cfail2")]
 120     #[rustc_clean(cfg="cfail3")]
 121     #[rustc_clean(except="hir_owner_nodes,typeck,optimized_mir", cfg="cfail5")]
 122     #[rustc_clean(cfg="cfail6")]
 123     #[inline]
 124     fn method_name() {
 125         panic!()
 126     }
 127 }
 128
 129 // Change Method Selfness ------------------------------------------------------
 130
 131 #[cfg(any(cfail1,cfail4))]
 132 pub trait ChangeMethodSelfnessTrait {
 133     fn method_name();
 134 }
 135
 136 #[cfg(any(cfail1,cfail4))]
 137 impl ChangeMethodSelfnessTrait for Foo {
 138     fn method_name() { }
 139 }
 140
 141 #[cfg(not(any(cfail1,cfail4)))]
 142 pub trait ChangeMethodSelfnessTrait {
 143     fn method_name(&self);
 144 }
 145
 146 #[cfg(not(any(cfail1,cfail4)))]
 147 #[rustc_clean(except="hir_owner,hir_owner_nodes", cfg="cfail2")]
 148 #[rustc_clean(cfg="cfail3")]
 149 #[rustc_clean(except="hir_owner,hir_owner_nodes", cfg="cfail5")]
 150 #[rustc_clean(cfg="cfail6")]
 151 impl ChangeMethodSelfnessTrait for Foo {
 152     #[rustc_clean(
 153         except="hir_owner,hir_owner_nodes,associated_item,generics_of,fn_sig,typeck,optimized_mir",
 154         cfg="cfail2",
 155     )]
 156     #[rustc_clean(cfg="cfail3")]
 157     #[rustc_clean(
 158         except="hir_owner,hir_owner_nodes,associated_item,generics_of,fn_sig,typeck,optimized_mir",
 159         cfg="cfail5",
 160     )]
 161     #[rustc_clean(cfg="cfail6")]
 162     fn method_name(&self) {
 163         ()
 164     }
 165 }
 166
 167 // Change Method Selfness -----------------------------------------------------------
 168
 169 #[cfg(any(cfail1,cfail4))]
 170 pub trait RemoveMethodSelfnessTrait {
 171     fn method_name(&self);
 172 }
 173
 174 #[cfg(any(cfail1,cfail4))]
 175 impl RemoveMethodSelfnessTrait for Foo {
 176     fn method_name(&self) { }
 177 }
 178
 179 #[cfg(not(any(cfail1,cfail4)))]
 180 pub trait RemoveMethodSelfnessTrait {
 181     fn method_name();
 182 }
 183
 184 #[cfg(not(any(cfail1,cfail4)))]
 185 #[rustc_clean(except="hir_owner,hir_owner_nodes", cfg="cfail2")]
 186 #[rustc_clean(cfg="cfail3")]
 187 #[rustc_clean(except="hir_owner,hir_owner_nodes", cfg="cfail5")]
 188 #[rustc_clean(cfg="cfail6")]
 189 impl RemoveMethodSelfnessTrait for Foo {
 190     #[rustc_clean(
 191         except="hir_owner,hir_owner_nodes,associated_item,generics_of,fn_sig,typeck,optimized_mir",
 192         cfg="cfail2",
 193     )]
 194     #[rustc_clean(cfg="cfail3")]
 195     #[rustc_clean(
 196         except="hir_owner,hir_owner_nodes,associated_item,generics_of,fn_sig,typeck,optimized_mir",
 197         cfg="cfail5",
 198     )]
 199     #[rustc_clean(cfg="cfail6")]
 200     fn method_name() {}
 201 }
 202
 203 // Change Method Selfmutness -----------------------------------------------------------
 204
 205 #[cfg(any(cfail1,cfail4))]
 206 pub trait ChangeMethodSelfmutnessTrait {
 207     fn method_name(&self);
 208 }
 209
 210 #[cfg(any(cfail1,cfail4))]
 211 impl ChangeMethodSelfmutnessTrait for Foo {
 212     // -----------------------------------------------------------------------------------------
 213     // -------------------------
 214     // -----------------------------------------------------------------------------------------
 215     // -------------------------
 216     fn method_name(&    self) {}
 217 }
 218
 219 #[cfg(not(any(cfail1,cfail4)))]
 220 pub trait ChangeMethodSelfmutnessTrait {
 221     fn method_name(&mut self);
 222 }
 223
 224 #[cfg(not(any(cfail1,cfail4)))]
 225 #[rustc_clean(cfg="cfail2")]
 226 #[rustc_clean(cfg="cfail3")]
 227 #[rustc_clean(cfg="cfail5")]
 228 #[rustc_clean(cfg="cfail6")]
 229 impl ChangeMethodSelfmutnessTrait for Foo {
 230     #[rustc_clean(except="hir_owner,hir_owner_nodes,fn_sig,typeck,optimized_mir", cfg="cfail2")]
 231     #[rustc_clean(cfg="cfail3")]
 232     #[rustc_clean(except="hir_owner,hir_owner_nodes,fn_sig,typeck,optimized_mir", cfg="cfail5")]
 233     #[rustc_clean(cfg="cfail6")]
 234     fn method_name(&mut self) {}
 235 }
 236
 237 // Change item kind -----------------------------------------------------------
 238
 239 #[cfg(any(cfail1,cfail4))]
 240 pub trait ChangeItemKindTrait {
 241     fn name();
 242 }
 243
 244 #[cfg(any(cfail1,cfail4))]
 245 impl ChangeItemKindTrait for Foo {
 246     fn name() { }
 247 }
 248
 249 #[cfg(not(any(cfail1,cfail4)))]
 250 pub trait ChangeItemKindTrait {
 251     type name;
 252 }
 253
 254 #[cfg(not(any(cfail1,cfail4)))]
 255 #[rustc_clean(except="hir_owner,hir_owner_nodes,associated_item_def_ids", cfg="cfail2")]
 256 #[rustc_clean(cfg="cfail3")]
 257 #[rustc_clean(except="hir_owner,hir_owner_nodes,associated_item_def_ids", cfg="cfail5")]
 258 #[rustc_clean(cfg="cfail6")]
 259 impl ChangeItemKindTrait for Foo {
 260     type name = ();
 261 }
 262
 263 // Remove item -----------------------------------------------------------
 264
 265 #[cfg(any(cfail1,cfail4))]
 266 pub trait RemoveItemTrait {
 267     type TypeName;
 268     fn method_name();
 269 }
 270
 271 #[cfg(any(cfail1,cfail4))]
 272 impl RemoveItemTrait for Foo {
 273     type TypeName = ();
 274     fn method_name() { }
 275 }
 276
 277 #[cfg(not(any(cfail1,cfail4)))]
 278 pub trait RemoveItemTrait {
 279     type TypeName;
 280 }
 281
 282 #[cfg(not(any(cfail1,cfail4)))]
 283 #[rustc_clean(except="hir_owner,hir_owner_nodes,associated_item_def_ids", cfg="cfail2")]
 284 #[rustc_clean(cfg="cfail3")]
 285 #[rustc_clean(except="hir_owner,hir_owner_nodes,associated_item_def_ids", cfg="cfail5")]
 286 #[rustc_clean(cfg="cfail6")]
 287 impl RemoveItemTrait for Foo {
 288     type TypeName = ();
 289 }
 290
 291 // Add item -----------------------------------------------------------
 292
 293 #[cfg(any(cfail1,cfail4))]
 294 pub trait AddItemTrait {
 295     type TypeName;
 296 }
 297
 298 #[cfg(any(cfail1,cfail4))]
 299 impl AddItemTrait for Foo {
 300     type TypeName = ();
 301 }
 302
 303 #[cfg(not(any(cfail1,cfail4)))]
 304 pub trait AddItemTrait {
 305     type TypeName;
 306     fn method_name();
 307 }
 308
 309 #[cfg(not(any(cfail1,cfail4)))]
 310 #[rustc_clean(except="hir_owner,hir_owner_nodes,associated_item_def_ids", cfg="cfail2")]
 311 #[rustc_clean(cfg="cfail3")]
 312 #[rustc_clean(except="hir_owner,hir_owner_nodes,associated_item_def_ids", cfg="cfail5")]
 313 #[rustc_clean(cfg="cfail6")]
 314 impl AddItemTrait for Foo {
 315     type TypeName = ();
 316     fn method_name() { }
 317 }
 318
 319 // Change has-value -----------------------------------------------------------
 320
 321 #[cfg(any(cfail1,cfail4))]
 322 pub trait ChangeHasValueTrait {
 323     fn method_name();
 324 }
 325
 326 #[cfg(any(cfail1,cfail4))]
 327 impl ChangeHasValueTrait for Foo {
 328     fn method_name() { }
 329 }
 330
 331 #[cfg(not(any(cfail1,cfail4)))]
 332 #[rustc_clean(except="hir_owner,hir_owner_nodes", cfg="cfail2")]
 333 #[rustc_clean(cfg="cfail3")]
 334 #[rustc_clean(except="hir_owner,hir_owner_nodes", cfg="cfail5")]
 335 #[rustc_clean(cfg="cfail6")]
 336 pub trait ChangeHasValueTrait {
 337     #[rustc_clean(except="hir_owner,hir_owner_nodes,associated_item", cfg="cfail2")]
 338     #[rustc_clean(cfg="cfail3")]
 339     #[rustc_clean(except="hir_owner,hir_owner_nodes,associated_item", cfg="cfail5")]
 340     #[rustc_clean(cfg="cfail6")]
 341     fn method_name() { }
 342 }
 343
 344 #[cfg(not(any(cfail1,cfail4)))]
 345 #[rustc_clean(cfg="cfail2")]
 346 #[rustc_clean(cfg="cfail3")]
 347 #[rustc_clean(cfg="cfail5")]
 348 #[rustc_clean(cfg="cfail6")]
 349 impl ChangeHasValueTrait for Foo {
 350     fn method_name() { }
 351 }
 352
 353 // Add default
 354
 355 pub trait AddDefaultTrait {
 356     fn method_name();
 357 }
 358
 359 #[cfg(any(cfail1,cfail4))]
 360 impl AddDefaultTrait for Foo {
 361     // ----------------------------------------------------
 362     // -------------------------
 363     // ----------------------------------------------------
 364     // -------------------------
 365     fn         method_name() { }
 366 }
 367
 368 #[cfg(not(any(cfail1,cfail4)))]
 369 #[rustc_clean(except="hir_owner,hir_owner_nodes", cfg="cfail2")]
 370 #[rustc_clean(cfg="cfail3")]
 371 #[rustc_clean(except="hir_owner,hir_owner_nodes", cfg="cfail5")]
 372 #[rustc_clean(cfg="cfail6")]
 373 impl AddDefaultTrait for Foo {
 374     #[rustc_clean(except="associated_item", cfg="cfail2")]
 375     #[rustc_clean(cfg="cfail3")]
 376     #[rustc_clean(except="associated_item", cfg="cfail5")]
 377     #[rustc_clean(cfg="cfail6")]
 378     default fn method_name() { }
 379 }
 380
 381 // Add arguments
 382
 383 #[cfg(any(cfail1,cfail4))]
 384 pub trait AddArgumentTrait {
 385     fn method_name(&self);
 386 }
 387
 388 #[cfg(any(cfail1,cfail4))]
 389 impl AddArgumentTrait for Foo {
 390     // -----------------------------------------------------------------------------------------
 391     // -------------------------
 392     // -----------------------------------------------------------------------------------------
 393     // -------------------------
 394     fn method_name(&self         ) { }
 395 }
 396
 397 #[cfg(not(any(cfail1,cfail4)))]
 398 pub trait AddArgumentTrait {
 399     fn method_name(&self, x: u32);
 400 }
 401
 402 #[cfg(not(any(cfail1,cfail4)))]
 403 #[rustc_clean(cfg="cfail2")]
 404 #[rustc_clean(cfg="cfail3")]
 405 #[rustc_clean(cfg="cfail5")]
 406 #[rustc_clean(cfg="cfail6")]
 407 impl AddArgumentTrait for Foo {
 408     #[rustc_clean(except="hir_owner,hir_owner_nodes,fn_sig,typeck,optimized_mir", cfg="cfail2")]
 409     #[rustc_clean(cfg="cfail3")]
 410     #[rustc_clean(except="hir_owner,hir_owner_nodes,fn_sig,typeck,optimized_mir", cfg="cfail5")]
 411     #[rustc_clean(cfg="cfail6")]
 412     fn method_name(&self, _x: u32) { }
 413 }
 414
 415 // Change argument type
 416
 417 #[cfg(any(cfail1,cfail4))]
 418 pub trait ChangeArgumentTypeTrait {
 419     fn method_name(&self, x: u32);
 420 }
 421
 422 #[cfg(any(cfail1,cfail4))]
 423 impl ChangeArgumentTypeTrait for Foo {
 424     // -----------------------------------------------------------------------------------------
 425     // -------------------------
 426     // -----------------------------------------------------------------------------------------
 427     // -------------------------
 428     fn method_name(&self, _x: u32 ) { }
 429 }
 430
 431 #[cfg(not(any(cfail1,cfail4)))]
 432 pub trait ChangeArgumentTypeTrait {
 433     fn method_name(&self, x: char);
 434 }
 435
 436 #[cfg(not(any(cfail1,cfail4)))]
 437 #[rustc_clean(cfg="cfail2")]
 438 #[rustc_clean(cfg="cfail3")]
 439 #[rustc_clean(cfg="cfail5")]
 440 #[rustc_clean(cfg="cfail6")]
 441 impl ChangeArgumentTypeTrait for Foo {
 442     #[rustc_clean(except="hir_owner,hir_owner_nodes,fn_sig,typeck,optimized_mir", cfg="cfail2")]
 443     #[rustc_clean(cfg="cfail3")]
 444     #[rustc_clean(except="hir_owner,hir_owner_nodes,fn_sig,typeck,optimized_mir", cfg="cfail5")]
 445     #[rustc_clean(cfg="cfail6")]
 446     fn method_name(&self, _x: char) { }
 447 }
 448
 449
 450
 451 struct Bar<T>(T);
 452
 453 // Add Type Parameter To Impl --------------------------------------------------
 454 trait AddTypeParameterToImpl<T> {
 455     fn id(t: T) -> T;
 456 }
 457
 458 #[cfg(any(cfail1,cfail4))]
 459 impl AddTypeParameterToImpl<u32> for Bar<u32> {
 460     fn id(t: u32) -> u32 { t }
 461 }
 462
 463 #[cfg(not(any(cfail1,cfail4)))]
 464 #[rustc_clean(except="hir_owner,hir_owner_nodes,generics_of,impl_trait_ref", cfg="cfail2")]
 465 #[rustc_clean(cfg="cfail3")]
 466 #[rustc_clean(except="hir_owner,hir_owner_nodes,generics_of,impl_trait_ref", cfg="cfail5")]
 467 #[rustc_clean(cfg="cfail6")]
 468 impl<TTT> AddTypeParameterToImpl<TTT> for Bar<TTT> {
 469     #[rustc_clean(
 470         except="hir_owner,hir_owner_nodes,generics_of,fn_sig,type_of,typeck,optimized_mir",
 471         cfg="cfail2",
 472     )]
 473     #[rustc_clean(cfg="cfail3")]
 474     #[rustc_clean(
 475         except="hir_owner,hir_owner_nodes,generics_of,fn_sig,type_of,typeck,optimized_mir",
 476         cfg="cfail5",
 477     )]
 478     #[rustc_clean(cfg="cfail6")]
 479     fn id(t: TTT) -> TTT { t }
 480 }
 481
 482
 483
 484 // Change Self Type of Impl ----------------------------------------------------
 485 trait ChangeSelfTypeOfImpl {
 486     fn id(self) -> Self;
 487 }
 488
 489 #[cfg(any(cfail1,cfail4))]
 490 impl ChangeSelfTypeOfImpl for u32 {
 491     fn id(self) -> Self { self }
 492 }
 493
 494 #[cfg(not(any(cfail1,cfail4)))]
 495 #[rustc_clean(except="hir_owner,hir_owner_nodes,impl_trait_ref", cfg="cfail2")]
 496 #[rustc_clean(cfg="cfail3")]
 497 #[rustc_clean(except="hir_owner,hir_owner_nodes,impl_trait_ref", cfg="cfail5")]
 498 #[rustc_clean(cfg="cfail6")]
 499 impl ChangeSelfTypeOfImpl for u64 {
 500     #[rustc_clean(except="fn_sig,typeck,optimized_mir", cfg="cfail2")]
 501     #[rustc_clean(cfg="cfail3")]
 502     #[rustc_clean(except="fn_sig,typeck,optimized_mir", cfg="cfail5")]
 503     #[rustc_clean(cfg="cfail6")]
 504     fn id(self) -> Self { self }
 505 }
 506
 507
 508
 509 // Add Lifetime Bound to Impl --------------------------------------------------
 510 trait AddLifetimeBoundToImplParameter {
 511     fn id(self) -> Self;
 512 }
 513
 514 #[cfg(any(cfail1,cfail4))]
 515 impl<T> AddLifetimeBoundToImplParameter for T {
 516     fn id(self) -> Self { self }
 517 }
 518
 519 #[cfg(not(any(cfail1,cfail4)))]
 520 #[rustc_clean(except="hir_owner,hir_owner_nodes", cfg="cfail2")]
 521 #[rustc_clean(cfg="cfail3")]
 522 #[rustc_clean(except="hir_owner,hir_owner_nodes", cfg="cfail5")]
 523 #[rustc_clean(cfg="cfail6")]
 524 impl<T: 'static> AddLifetimeBoundToImplParameter for T {
 525     #[rustc_clean(cfg="cfail2")]
 526     #[rustc_clean(cfg="cfail3")]
 527     #[rustc_clean(cfg="cfail5")]
 528     #[rustc_clean(cfg="cfail6")]
 529     fn id(self) -> Self { self }
 530 }
 531
 532
 533
 534 // Add Trait Bound to Impl Parameter -------------------------------------------
 535 trait AddTraitBoundToImplParameter {
 536     fn id(self) -> Self;
 537 }
 538
 539 #[cfg(any(cfail1,cfail4))]
 540 impl<T> AddTraitBoundToImplParameter for T {
 541     fn id(self) -> Self { self }
 542 }
 543
 544 #[cfg(not(any(cfail1,cfail4)))]
 545 #[rustc_clean(except="hir_owner,hir_owner_nodes", cfg="cfail2")]
 546 #[rustc_clean(cfg="cfail3")]
 547 #[rustc_clean(except="hir_owner,hir_owner_nodes", cfg="cfail5")]
 548 #[rustc_clean(cfg="cfail6")]
 549 impl<T: Clone> AddTraitBoundToImplParameter for T {
 550     #[rustc_clean(cfg="cfail2")]
 551     #[rustc_clean(cfg="cfail3")]
 552     #[rustc_clean(cfg="cfail5")]
 553     #[rustc_clean(cfg="cfail6")]
 554     fn id(self) -> Self { self }
 555 }
 556
 557
 558
 559 // Add #[no_mangle] to Method --------------------------------------------------
 560 trait AddNoMangleToMethod {
 561     fn add_no_mangle_to_method(&self) { }
 562 }
 563
 564 #[cfg(any(cfail1,cfail4))]
 565 impl AddNoMangleToMethod for Foo {
 566     // -------------------------
 567     // -------------------------
 568     // -------------------------
 569     // -------------------------
 570     // ---------
 571     fn add_no_mangle_to_method(&self) { }
 572 }
 573
 574 #[cfg(not(any(cfail1,cfail4)))]
 575 #[rustc_clean(cfg="cfail2")]
 576 #[rustc_clean(cfg="cfail3")]
 577 #[rustc_clean(cfg="cfail5")]
 578 #[rustc_clean(cfg="cfail6")]
 579 impl AddNoMangleToMethod for Foo {
 580     #[rustc_clean(cfg="cfail2")]
 581     #[rustc_clean(cfg="cfail3")]
 582     #[rustc_clean(cfg="cfail5")]
 583     #[rustc_clean(cfg="cfail6")]
 584     #[no_mangle]
 585     fn add_no_mangle_to_method(&self) { }
 586 }
 587
 588
 589 // Make Method #[inline] -------------------------------------------------------
 590 trait MakeMethodInline {
 591     fn make_method_inline(&self) -> u8 { 0 }
 592 }
 593
 594 #[cfg(any(cfail1,cfail4))]
 595 impl MakeMethodInline for Foo {
 596     // -------------------------
 597     // -------------------------
 598     // -------------------------
 599     // -------------------------
 600     // ------
 601     fn make_method_inline(&self) -> u8 { 0 }
 602 }
 603
 604 #[cfg(not(any(cfail1,cfail4)))]
 605 #[rustc_clean(cfg="cfail2")]
 606 #[rustc_clean(cfg="cfail3")]
 607 #[rustc_clean(cfg="cfail5")]
 608 #[rustc_clean(cfg="cfail6")]
 609 impl MakeMethodInline for Foo {
 610     #[rustc_clean(cfg="cfail2")]
 611     #[rustc_clean(cfg="cfail3")]
 612     #[rustc_clean(cfg="cfail5")]
 613     #[rustc_clean(cfg="cfail6")]
 614     #[inline]
 615     fn make_method_inline(&self) -> u8 { 0 }
 616 }