ca2dce9b48
Instead of collecting all potential inputs to some metadata entry and hashing those, we directly hash the values we are storing in metadata. This is more accurate and doesn't suffer from quadratic blow-up when many entries have the same dependencies.
781 lines
19 KiB
Rust
781 lines
19 KiB
Rust
// Copyright 2016 The Rust Project Developers. See the COPYRIGHT
|
|
// file at the top-level directory of this distribution and at
|
|
// http://rust-lang.org/COPYRIGHT.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
|
// option. This file may not be copied, modified, or distributed
|
|
// except according to those terms.
|
|
|
|
|
|
// This test case tests the incremental compilation hash (ICH) implementation
|
|
// for enum definitions.
|
|
|
|
// The general pattern followed here is: Change one thing between rev1 and rev2
|
|
// and make sure that the hash has changed, then change nothing between rev2 and
|
|
// rev3 and make sure that the hash has not changed.
|
|
|
|
// We also test the ICH for enum definitions exported in metadata. Same as
|
|
// above, we want to make sure that the change between rev1 and rev2 also
|
|
// results in a change of the ICH for the enum's metadata, and that it stays
|
|
// the same between rev2 and rev3.
|
|
|
|
// must-compile-successfully
|
|
// revisions: cfail1 cfail2 cfail3
|
|
// compile-flags: -Z query-dep-graph
|
|
|
|
#![allow(warnings)]
|
|
#![feature(rustc_attrs)]
|
|
#![crate_type="rlib"]
|
|
|
|
|
|
|
|
// Change enum visibility -----------------------------------------------------
|
|
#[cfg(cfail1)]
|
|
enum EnumVisibility { A }
|
|
|
|
#[cfg(not(cfail1))]
|
|
#[rustc_dirty(label="Hir", cfg="cfail2")]
|
|
#[rustc_clean(label="Hir", cfg="cfail3")]
|
|
#[rustc_metadata_dirty(cfg="cfail2")]
|
|
#[rustc_metadata_clean(cfg="cfail3")]
|
|
pub enum EnumVisibility {
|
|
#[rustc_metadata_dirty(cfg="cfail2")]
|
|
#[rustc_metadata_clean(cfg="cfail3")]
|
|
A
|
|
}
|
|
|
|
|
|
|
|
// Change name of a c-style variant -------------------------------------------
|
|
#[cfg(cfail1)]
|
|
enum EnumChangeNameCStyleVariant {
|
|
Variant1,
|
|
Variant2,
|
|
}
|
|
|
|
#[cfg(not(cfail1))]
|
|
#[rustc_dirty(label="Hir", cfg="cfail2")]
|
|
#[rustc_clean(label="Hir", cfg="cfail3")]
|
|
#[rustc_metadata_dirty(cfg="cfail2")]
|
|
#[rustc_metadata_clean(cfg="cfail3")]
|
|
enum EnumChangeNameCStyleVariant {
|
|
#[rustc_metadata_dirty(cfg="cfail2")]
|
|
#[rustc_metadata_clean(cfg="cfail3")]
|
|
Variant1,
|
|
#[rustc_metadata_clean(cfg="cfail3")]
|
|
Variant2Changed,
|
|
}
|
|
|
|
|
|
|
|
// Change name of a tuple-style variant ---------------------------------------
|
|
#[cfg(cfail1)]
|
|
enum EnumChangeNameTupleStyleVariant {
|
|
Variant1,
|
|
Variant2(u32, f32),
|
|
}
|
|
|
|
#[cfg(not(cfail1))]
|
|
#[rustc_dirty(label="Hir", cfg="cfail2")]
|
|
#[rustc_clean(label="Hir", cfg="cfail3")]
|
|
#[rustc_metadata_dirty(cfg="cfail2")]
|
|
#[rustc_metadata_clean(cfg="cfail3")]
|
|
enum EnumChangeNameTupleStyleVariant {
|
|
Variant1,
|
|
Variant2Changed(u32, f32),
|
|
}
|
|
|
|
|
|
|
|
// Change name of a struct-style variant --------------------------------------
|
|
#[cfg(cfail1)]
|
|
enum EnumChangeNameStructStyleVariant {
|
|
Variant1,
|
|
Variant2 { a: u32, b: f32 },
|
|
}
|
|
|
|
#[cfg(not(cfail1))]
|
|
#[rustc_dirty(label="Hir", cfg="cfail2")]
|
|
#[rustc_clean(label="Hir", cfg="cfail3")]
|
|
#[rustc_metadata_dirty(cfg="cfail2")]
|
|
#[rustc_metadata_clean(cfg="cfail3")]
|
|
enum EnumChangeNameStructStyleVariant {
|
|
Variant1,
|
|
Variant2Changed { a: u32, b: f32 },
|
|
}
|
|
|
|
|
|
|
|
// Change the value of a c-style variant --------------------------------------
|
|
#[cfg(cfail1)]
|
|
enum EnumChangeValueCStyleVariant0 {
|
|
Variant1,
|
|
Variant2 = 11,
|
|
}
|
|
|
|
#[cfg(not(cfail1))]
|
|
#[rustc_clean(label="Hir", cfg="cfail2")]
|
|
#[rustc_clean(label="Hir", cfg="cfail3")]
|
|
#[rustc_dirty(label="HirBody", cfg="cfail2")]
|
|
#[rustc_clean(label="HirBody", cfg="cfail3")]
|
|
#[rustc_metadata_clean(cfg="cfail2")]
|
|
#[rustc_metadata_clean(cfg="cfail3")]
|
|
enum EnumChangeValueCStyleVariant0 {
|
|
Variant1,
|
|
|
|
#[rustc_metadata_dirty(cfg="cfail2")]
|
|
#[rustc_metadata_clean(cfg="cfail3")]
|
|
Variant2 = 22,
|
|
}
|
|
|
|
#[cfg(cfail1)]
|
|
enum EnumChangeValueCStyleVariant1 {
|
|
Variant1,
|
|
Variant2,
|
|
}
|
|
|
|
#[cfg(not(cfail1))]
|
|
#[rustc_dirty(label="Hir", cfg="cfail2")]
|
|
#[rustc_clean(label="Hir", cfg="cfail3")]
|
|
#[rustc_clean(label="HirBody", cfg="cfail2")]
|
|
#[rustc_clean(label="HirBody", cfg="cfail3")]
|
|
#[rustc_metadata_dirty(cfg="cfail2")]
|
|
#[rustc_metadata_clean(cfg="cfail3")]
|
|
enum EnumChangeValueCStyleVariant1 {
|
|
Variant1,
|
|
Variant2 = 11,
|
|
}
|
|
|
|
|
|
|
|
// Add a c-style variant ------------------------------------------------------
|
|
#[cfg(cfail1)]
|
|
enum EnumAddCStyleVariant {
|
|
Variant1,
|
|
}
|
|
|
|
#[cfg(not(cfail1))]
|
|
#[rustc_dirty(label="Hir", cfg="cfail2")]
|
|
#[rustc_clean(label="Hir", cfg="cfail3")]
|
|
#[rustc_metadata_dirty(cfg="cfail2")]
|
|
#[rustc_metadata_clean(cfg="cfail3")]
|
|
enum EnumAddCStyleVariant {
|
|
Variant1,
|
|
Variant2,
|
|
}
|
|
|
|
|
|
|
|
// Remove a c-style variant ---------------------------------------------------
|
|
#[cfg(cfail1)]
|
|
enum EnumRemoveCStyleVariant {
|
|
Variant1,
|
|
Variant2,
|
|
}
|
|
|
|
#[cfg(not(cfail1))]
|
|
#[rustc_dirty(label="Hir", cfg="cfail2")]
|
|
#[rustc_clean(label="Hir", cfg="cfail3")]
|
|
#[rustc_metadata_dirty(cfg="cfail2")]
|
|
#[rustc_metadata_clean(cfg="cfail3")]
|
|
enum EnumRemoveCStyleVariant {
|
|
Variant1,
|
|
}
|
|
|
|
|
|
|
|
// Add a tuple-style variant --------------------------------------------------
|
|
#[cfg(cfail1)]
|
|
enum EnumAddTupleStyleVariant {
|
|
Variant1,
|
|
}
|
|
|
|
#[cfg(not(cfail1))]
|
|
#[rustc_dirty(label="Hir", cfg="cfail2")]
|
|
#[rustc_clean(label="Hir", cfg="cfail3")]
|
|
#[rustc_metadata_dirty(cfg="cfail2")]
|
|
#[rustc_metadata_clean(cfg="cfail3")]
|
|
enum EnumAddTupleStyleVariant {
|
|
Variant1,
|
|
Variant2(u32, f32),
|
|
}
|
|
|
|
|
|
|
|
// Remove a tuple-style variant -----------------------------------------------
|
|
#[cfg(cfail1)]
|
|
enum EnumRemoveTupleStyleVariant {
|
|
Variant1,
|
|
Variant2(u32, f32),
|
|
}
|
|
|
|
#[cfg(not(cfail1))]
|
|
#[rustc_dirty(label="Hir", cfg="cfail2")]
|
|
#[rustc_clean(label="Hir", cfg="cfail3")]
|
|
#[rustc_metadata_dirty(cfg="cfail2")]
|
|
#[rustc_metadata_clean(cfg="cfail3")]
|
|
enum EnumRemoveTupleStyleVariant {
|
|
Variant1,
|
|
}
|
|
|
|
|
|
|
|
// Add a struct-style variant -------------------------------------------------
|
|
#[cfg(cfail1)]
|
|
enum EnumAddStructStyleVariant {
|
|
Variant1,
|
|
}
|
|
|
|
#[cfg(not(cfail1))]
|
|
#[rustc_dirty(label="Hir", cfg="cfail2")]
|
|
#[rustc_clean(label="Hir", cfg="cfail3")]
|
|
#[rustc_metadata_dirty(cfg="cfail2")]
|
|
#[rustc_metadata_clean(cfg="cfail3")]
|
|
enum EnumAddStructStyleVariant {
|
|
Variant1,
|
|
Variant2 { a: u32, b: f32 },
|
|
}
|
|
|
|
|
|
|
|
// Remove a struct-style variant ----------------------------------------------
|
|
#[cfg(cfail1)]
|
|
enum EnumRemoveStructStyleVariant {
|
|
Variant1,
|
|
Variant2 { a: u32, b: f32 },
|
|
}
|
|
|
|
#[cfg(not(cfail1))]
|
|
#[rustc_dirty(label="Hir", cfg="cfail2")]
|
|
#[rustc_clean(label="Hir", cfg="cfail3")]
|
|
#[rustc_metadata_dirty(cfg="cfail2")]
|
|
#[rustc_metadata_clean(cfg="cfail3")]
|
|
enum EnumRemoveStructStyleVariant {
|
|
Variant1,
|
|
}
|
|
|
|
|
|
|
|
// Change the type of a field in a tuple-style variant ------------------------
|
|
#[cfg(cfail1)]
|
|
enum EnumChangeFieldTypeTupleStyleVariant {
|
|
Variant1(u32, u32),
|
|
}
|
|
|
|
#[cfg(not(cfail1))]
|
|
#[rustc_dirty(label="Hir", cfg="cfail2")]
|
|
#[rustc_clean(label="Hir", cfg="cfail3")]
|
|
#[rustc_metadata_clean(cfg="cfail2")]
|
|
#[rustc_metadata_clean(cfg="cfail3")]
|
|
enum EnumChangeFieldTypeTupleStyleVariant {
|
|
Variant1(u32,
|
|
#[rustc_metadata_dirty(cfg="cfail2")]
|
|
#[rustc_metadata_clean(cfg="cfail3")]
|
|
u64),
|
|
}
|
|
|
|
|
|
|
|
// Change the type of a field in a struct-style variant -----------------------
|
|
#[cfg(cfail1)]
|
|
enum EnumChangeFieldTypeStructStyleVariant {
|
|
Variant1,
|
|
Variant2 { a: u32, b: u32 },
|
|
}
|
|
|
|
#[cfg(not(cfail1))]
|
|
#[rustc_dirty(label="Hir", cfg="cfail2")]
|
|
#[rustc_clean(label="Hir", cfg="cfail3")]
|
|
#[rustc_metadata_clean(cfg="cfail2")]
|
|
#[rustc_metadata_clean(cfg="cfail3")]
|
|
enum EnumChangeFieldTypeStructStyleVariant {
|
|
Variant1,
|
|
Variant2 {
|
|
a: u32,
|
|
#[rustc_metadata_dirty(cfg="cfail2")]
|
|
#[rustc_metadata_clean(cfg="cfail3")]
|
|
b: u64
|
|
},
|
|
}
|
|
|
|
|
|
|
|
// Change the name of a field in a struct-style variant -----------------------
|
|
#[cfg(cfail1)]
|
|
enum EnumChangeFieldNameStructStyleVariant {
|
|
Variant1 { a: u32, b: u32 },
|
|
}
|
|
|
|
#[cfg(not(cfail1))]
|
|
#[rustc_dirty(label="Hir", cfg="cfail2")]
|
|
#[rustc_clean(label="Hir", cfg="cfail3")]
|
|
#[rustc_metadata_dirty(cfg="cfail2")]
|
|
#[rustc_metadata_clean(cfg="cfail3")]
|
|
enum EnumChangeFieldNameStructStyleVariant {
|
|
Variant1 { a: u32, c: u32 },
|
|
}
|
|
|
|
|
|
|
|
// Change order of fields in a tuple-style variant ----------------------------
|
|
#[cfg(cfail1)]
|
|
enum EnumChangeOrderTupleStyleVariant {
|
|
Variant1(u32, u64),
|
|
}
|
|
|
|
#[cfg(not(cfail1))]
|
|
#[rustc_dirty(label="Hir", cfg="cfail2")]
|
|
#[rustc_clean(label="Hir", cfg="cfail3")]
|
|
#[rustc_metadata_clean(cfg="cfail2")]
|
|
#[rustc_metadata_clean(cfg="cfail3")]
|
|
enum EnumChangeOrderTupleStyleVariant {
|
|
Variant1(
|
|
#[rustc_metadata_dirty(cfg="cfail2")]
|
|
#[rustc_metadata_clean(cfg="cfail3")]
|
|
u64,
|
|
#[rustc_metadata_dirty(cfg="cfail2")]
|
|
#[rustc_metadata_clean(cfg="cfail3")]
|
|
u32),
|
|
}
|
|
|
|
|
|
|
|
// Change order of fields in a struct-style variant ---------------------------
|
|
#[cfg(cfail1)]
|
|
enum EnumChangeFieldOrderStructStyleVariant {
|
|
Variant1 { a: u32, b: f32 },
|
|
}
|
|
|
|
#[cfg(not(cfail1))]
|
|
#[rustc_dirty(label="Hir", cfg="cfail2")]
|
|
#[rustc_clean(label="Hir", cfg="cfail3")]
|
|
#[rustc_metadata_dirty(cfg="cfail2")]
|
|
#[rustc_metadata_clean(cfg="cfail3")]
|
|
enum EnumChangeFieldOrderStructStyleVariant {
|
|
Variant1 { b: f32, a: u32 },
|
|
}
|
|
|
|
|
|
|
|
// Add a field to a tuple-style variant ---------------------------------------
|
|
#[cfg(cfail1)]
|
|
enum EnumAddFieldTupleStyleVariant {
|
|
Variant1(u32, u32),
|
|
}
|
|
|
|
#[cfg(not(cfail1))]
|
|
#[rustc_dirty(label="Hir", cfg="cfail2")]
|
|
#[rustc_clean(label="Hir", cfg="cfail3")]
|
|
#[rustc_metadata_dirty(cfg="cfail2")]
|
|
#[rustc_metadata_clean(cfg="cfail3")]
|
|
enum EnumAddFieldTupleStyleVariant {
|
|
Variant1(u32, u32, u32),
|
|
}
|
|
|
|
|
|
|
|
// Add a field to a struct-style variant --------------------------------------
|
|
#[cfg(cfail1)]
|
|
enum EnumAddFieldStructStyleVariant {
|
|
Variant1 { a: u32, b: u32 },
|
|
}
|
|
|
|
#[cfg(not(cfail1))]
|
|
#[rustc_dirty(label="Hir", cfg="cfail2")]
|
|
#[rustc_clean(label="Hir", cfg="cfail3")]
|
|
#[rustc_metadata_dirty(cfg="cfail2")]
|
|
#[rustc_metadata_clean(cfg="cfail3")]
|
|
enum EnumAddFieldStructStyleVariant {
|
|
Variant1 { a: u32, b: u32, c: u32 },
|
|
}
|
|
|
|
|
|
|
|
// Add #[must_use] to the enum ------------------------------------------------
|
|
#[cfg(cfail1)]
|
|
enum EnumAddMustUse {
|
|
Variant1,
|
|
Variant2,
|
|
}
|
|
|
|
#[cfg(not(cfail1))]
|
|
#[rustc_dirty(label="Hir", cfg="cfail2")]
|
|
#[rustc_clean(label="Hir", cfg="cfail3")]
|
|
#[rustc_metadata_dirty(cfg="cfail2")]
|
|
#[rustc_metadata_clean(cfg="cfail3")]
|
|
#[must_use]
|
|
enum EnumAddMustUse {
|
|
Variant1,
|
|
Variant2,
|
|
}
|
|
|
|
|
|
|
|
// Add #[repr(C)] to the enum -------------------------------------------------
|
|
#[cfg(cfail1)]
|
|
enum EnumAddReprC {
|
|
Variant1,
|
|
Variant2,
|
|
}
|
|
|
|
#[cfg(not(cfail1))]
|
|
#[rustc_dirty(label="Hir", cfg="cfail2")]
|
|
#[rustc_clean(label="Hir", cfg="cfail3")]
|
|
#[rustc_metadata_dirty(cfg="cfail2")]
|
|
#[rustc_metadata_clean(cfg="cfail3")]
|
|
#[repr(C)]
|
|
enum EnumAddReprC {
|
|
Variant1,
|
|
Variant2,
|
|
}
|
|
|
|
|
|
|
|
// Change the name of a type parameter ----------------------------------------
|
|
#[cfg(cfail1)]
|
|
enum EnumChangeNameOfTypeParameter<S> {
|
|
Variant1(S),
|
|
}
|
|
|
|
#[cfg(not(cfail1))]
|
|
#[rustc_dirty(label="Hir", cfg="cfail2")]
|
|
#[rustc_clean(label="Hir", cfg="cfail3")]
|
|
#[rustc_metadata_dirty(cfg="cfail2")]
|
|
#[rustc_metadata_clean(cfg="cfail3")]
|
|
#[repr(C)]
|
|
enum EnumChangeNameOfTypeParameter<T> {
|
|
Variant1(T),
|
|
}
|
|
|
|
|
|
|
|
// Add a type parameter ------------------------------------------------------
|
|
#[cfg(cfail1)]
|
|
enum EnumAddTypeParameter<S> {
|
|
Variant1(S),
|
|
Variant2(S),
|
|
}
|
|
|
|
#[cfg(not(cfail1))]
|
|
#[rustc_dirty(label="Hir", cfg="cfail2")]
|
|
#[rustc_clean(label="Hir", cfg="cfail3")]
|
|
#[rustc_metadata_dirty(cfg="cfail2")]
|
|
#[rustc_metadata_clean(cfg="cfail3")]
|
|
#[repr(C)]
|
|
enum EnumAddTypeParameter<S, T> {
|
|
Variant1(S),
|
|
Variant2(T),
|
|
}
|
|
|
|
|
|
|
|
// Change the name of a lifetime parameter ------------------------------------
|
|
#[cfg(cfail1)]
|
|
enum EnumChangeNameOfLifetimeParameter<'a> {
|
|
Variant1(&'a u32),
|
|
}
|
|
|
|
#[cfg(not(cfail1))]
|
|
#[rustc_dirty(label="Hir", cfg="cfail2")]
|
|
#[rustc_clean(label="Hir", cfg="cfail3")]
|
|
#[rustc_metadata_dirty(cfg="cfail2")]
|
|
#[rustc_metadata_clean(cfg="cfail3")]
|
|
#[repr(C)]
|
|
enum EnumChangeNameOfLifetimeParameter<'b> {
|
|
Variant1(&'b u32),
|
|
}
|
|
|
|
|
|
|
|
// Add a lifetime parameter ---------------------------------------------------
|
|
#[cfg(cfail1)]
|
|
enum EnumAddLifetimeParameter<'a> {
|
|
Variant1(&'a u32),
|
|
Variant2(&'a u32),
|
|
}
|
|
|
|
#[cfg(not(cfail1))]
|
|
#[rustc_dirty(label="Hir", cfg="cfail2")]
|
|
#[rustc_clean(label="Hir", cfg="cfail3")]
|
|
#[rustc_metadata_dirty(cfg="cfail2")]
|
|
#[rustc_metadata_clean(cfg="cfail3")]
|
|
#[repr(C)]
|
|
enum EnumAddLifetimeParameter<'a, 'b> {
|
|
Variant1(&'a u32),
|
|
Variant2(&'b u32),
|
|
}
|
|
|
|
|
|
|
|
// Add a lifetime bound to a lifetime parameter -------------------------------
|
|
#[cfg(cfail1)]
|
|
enum EnumAddLifetimeParameterBound<'a, 'b> {
|
|
Variant1(&'a u32),
|
|
Variant2(&'b u32),
|
|
}
|
|
|
|
#[cfg(not(cfail1))]
|
|
#[rustc_dirty(label="Hir", cfg="cfail2")]
|
|
#[rustc_clean(label="Hir", cfg="cfail3")]
|
|
#[rustc_metadata_dirty(cfg="cfail2")]
|
|
#[rustc_metadata_clean(cfg="cfail3")]
|
|
#[repr(C)]
|
|
enum EnumAddLifetimeParameterBound<'a, 'b: 'a> {
|
|
Variant1(&'a u32),
|
|
Variant2(&'b u32),
|
|
}
|
|
|
|
// Add a lifetime bound to a type parameter -----------------------------------
|
|
#[cfg(cfail1)]
|
|
enum EnumAddLifetimeBoundToParameter<'a, T> {
|
|
Variant1(T),
|
|
Variant2(&'a u32),
|
|
}
|
|
|
|
#[cfg(not(cfail1))]
|
|
#[rustc_dirty(label="Hir", cfg="cfail2")]
|
|
#[rustc_clean(label="Hir", cfg="cfail3")]
|
|
#[rustc_metadata_dirty(cfg="cfail2")]
|
|
#[rustc_metadata_clean(cfg="cfail3")]
|
|
#[repr(C)]
|
|
enum EnumAddLifetimeBoundToParameter<'a, T: 'a> {
|
|
Variant1(T),
|
|
Variant2(&'a u32),
|
|
}
|
|
|
|
|
|
|
|
// Add a trait bound to a type parameter --------------------------------------
|
|
#[cfg(cfail1)]
|
|
enum EnumAddTraitBound<S> {
|
|
Variant1(S),
|
|
}
|
|
|
|
#[cfg(not(cfail1))]
|
|
#[rustc_dirty(label="Hir", cfg="cfail2")]
|
|
#[rustc_clean(label="Hir", cfg="cfail3")]
|
|
#[rustc_metadata_dirty(cfg="cfail2")]
|
|
#[rustc_metadata_clean(cfg="cfail3")]
|
|
#[repr(C)]
|
|
enum EnumAddTraitBound<T: Sync> {
|
|
Variant1(T),
|
|
}
|
|
|
|
|
|
|
|
// Add a lifetime bound to a lifetime parameter in where clause ---------------
|
|
#[cfg(cfail1)]
|
|
enum EnumAddLifetimeParameterBoundWhere<'a, 'b> {
|
|
Variant1(&'a u32),
|
|
Variant2(&'b u32),
|
|
}
|
|
|
|
#[cfg(not(cfail1))]
|
|
#[rustc_dirty(label="Hir", cfg="cfail2")]
|
|
#[rustc_clean(label="Hir", cfg="cfail3")]
|
|
#[rustc_metadata_dirty(cfg="cfail2")]
|
|
#[rustc_metadata_clean(cfg="cfail3")]
|
|
#[repr(C)]
|
|
enum EnumAddLifetimeParameterBoundWhere<'a, 'b> where 'b: 'a {
|
|
Variant1(&'a u32),
|
|
Variant2(&'b u32),
|
|
}
|
|
|
|
|
|
|
|
// Add a lifetime bound to a type parameter in where clause -------------------
|
|
#[cfg(cfail1)]
|
|
enum EnumAddLifetimeBoundToParameterWhere<'a, T> {
|
|
Variant1(T),
|
|
Variant2(&'a u32),
|
|
}
|
|
|
|
#[cfg(not(cfail1))]
|
|
#[rustc_dirty(label="Hir", cfg="cfail2")]
|
|
#[rustc_clean(label="Hir", cfg="cfail3")]
|
|
#[rustc_metadata_dirty(cfg="cfail2")]
|
|
#[rustc_metadata_clean(cfg="cfail3")]
|
|
#[repr(C)]
|
|
enum EnumAddLifetimeBoundToParameterWhere<'a, T> where T: 'a {
|
|
Variant1(T),
|
|
Variant2(&'a u32),
|
|
}
|
|
|
|
|
|
|
|
// Add a trait bound to a type parameter in where clause ----------------------
|
|
#[cfg(cfail1)]
|
|
enum EnumAddTraitBoundWhere<S> {
|
|
Variant1(S),
|
|
}
|
|
|
|
#[cfg(not(cfail1))]
|
|
#[rustc_dirty(label="Hir", cfg="cfail2")]
|
|
#[rustc_clean(label="Hir", cfg="cfail3")]
|
|
#[rustc_metadata_dirty(cfg="cfail2")]
|
|
#[rustc_metadata_clean(cfg="cfail3")]
|
|
#[repr(C)]
|
|
enum EnumAddTraitBoundWhere<T> where T: Sync {
|
|
Variant1(T),
|
|
}
|
|
|
|
|
|
|
|
// In an enum with two variants, swap usage of type parameters ----------------
|
|
#[cfg(cfail1)]
|
|
enum EnumSwapUsageTypeParameters<A, B> {
|
|
Variant1 { a: A },
|
|
Variant2 { a: B },
|
|
}
|
|
|
|
#[cfg(not(cfail1))]
|
|
#[rustc_dirty(label="Hir", cfg="cfail2")]
|
|
#[rustc_clean(label="Hir", cfg="cfail3")]
|
|
#[rustc_metadata_clean(cfg="cfail2")]
|
|
#[rustc_metadata_clean(cfg="cfail3")]
|
|
enum EnumSwapUsageTypeParameters<A, B> {
|
|
#[rustc_metadata_clean(cfg="cfail2")]
|
|
#[rustc_metadata_clean(cfg="cfail3")]
|
|
Variant1 {
|
|
#[rustc_metadata_dirty(cfg="cfail2")]
|
|
#[rustc_metadata_clean(cfg="cfail3")]
|
|
a: B
|
|
},
|
|
#[rustc_metadata_clean(cfg="cfail2")]
|
|
#[rustc_metadata_clean(cfg="cfail3")]
|
|
Variant2 {
|
|
#[rustc_metadata_dirty(cfg="cfail2")]
|
|
#[rustc_metadata_clean(cfg="cfail3")]
|
|
a: A
|
|
},
|
|
}
|
|
|
|
|
|
|
|
// In an enum with two variants, swap usage of lifetime parameters ------------
|
|
#[cfg(cfail1)]
|
|
enum EnumSwapUsageLifetimeParameters<'a, 'b> {
|
|
Variant1 { a: &'a u32 },
|
|
Variant2 { b: &'b u32 },
|
|
}
|
|
|
|
#[cfg(not(cfail1))]
|
|
#[rustc_dirty(label="Hir", cfg="cfail2")]
|
|
#[rustc_clean(label="Hir", cfg="cfail3")]
|
|
#[rustc_metadata_clean(cfg="cfail2")]
|
|
#[rustc_metadata_clean(cfg="cfail3")]
|
|
enum EnumSwapUsageLifetimeParameters<'a, 'b> {
|
|
#[rustc_metadata_clean(cfg="cfail2")]
|
|
#[rustc_metadata_clean(cfg="cfail3")]
|
|
Variant1 {
|
|
#[rustc_metadata_dirty(cfg="cfail2")]
|
|
#[rustc_metadata_clean(cfg="cfail3")]
|
|
a: &'b u32
|
|
},
|
|
#[rustc_metadata_clean(cfg="cfail2")]
|
|
#[rustc_metadata_clean(cfg="cfail3")]
|
|
Variant2 {
|
|
#[rustc_metadata_dirty(cfg="cfail2")]
|
|
#[rustc_metadata_clean(cfg="cfail3")]
|
|
b: &'a u32
|
|
},
|
|
}
|
|
|
|
|
|
|
|
struct ReferencedType1;
|
|
struct ReferencedType2;
|
|
|
|
|
|
|
|
// Change field type in tuple-style variant indirectly by modifying a use statement
|
|
mod change_field_type_indirectly_tuple_style {
|
|
#[cfg(cfail1)]
|
|
use super::ReferencedType1 as FieldType;
|
|
#[cfg(not(cfail1))]
|
|
use super::ReferencedType2 as FieldType;
|
|
|
|
#[rustc_dirty(label="Hir", cfg="cfail2")]
|
|
#[rustc_clean(label="Hir", cfg="cfail3")]
|
|
#[rustc_metadata_clean(cfg="cfail2")]
|
|
#[rustc_metadata_clean(cfg="cfail3")]
|
|
enum TupleStyle {
|
|
#[rustc_metadata_dirty(cfg="cfail2")]
|
|
#[rustc_metadata_clean(cfg="cfail3")]
|
|
Variant1(
|
|
#[rustc_metadata_dirty(cfg="cfail2")]
|
|
#[rustc_metadata_clean(cfg="cfail3")]
|
|
FieldType
|
|
)
|
|
}
|
|
}
|
|
|
|
|
|
|
|
// Change field type in record-style variant indirectly by modifying a use statement
|
|
mod change_field_type_indirectly_struct_style {
|
|
#[cfg(cfail1)]
|
|
use super::ReferencedType1 as FieldType;
|
|
#[cfg(not(cfail1))]
|
|
use super::ReferencedType2 as FieldType;
|
|
|
|
#[rustc_dirty(label="Hir", cfg="cfail2")]
|
|
#[rustc_clean(label="Hir", cfg="cfail3")]
|
|
#[rustc_metadata_clean(cfg="cfail2")]
|
|
#[rustc_metadata_clean(cfg="cfail3")]
|
|
enum StructStyle {
|
|
#[rustc_metadata_clean(cfg="cfail2")]
|
|
#[rustc_metadata_clean(cfg="cfail3")]
|
|
Variant1 {
|
|
#[rustc_metadata_dirty(cfg="cfail2")]
|
|
#[rustc_metadata_clean(cfg="cfail3")]
|
|
a: FieldType
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
trait ReferencedTrait1 {}
|
|
trait ReferencedTrait2 {}
|
|
|
|
|
|
|
|
// Change trait bound of type parameter indirectly by modifying a use statement
|
|
mod change_trait_bound_indirectly {
|
|
#[cfg(cfail1)]
|
|
use super::ReferencedTrait1 as Trait;
|
|
#[cfg(not(cfail1))]
|
|
use super::ReferencedTrait2 as Trait;
|
|
|
|
#[rustc_dirty(label="Hir", cfg="cfail2")]
|
|
#[rustc_clean(label="Hir", cfg="cfail3")]
|
|
#[rustc_metadata_dirty(cfg="cfail2")]
|
|
#[rustc_metadata_clean(cfg="cfail3")]
|
|
enum Enum<T: Trait> {
|
|
Variant1(T)
|
|
}
|
|
}
|
|
|
|
|
|
|
|
// Change trait bound of type parameter in where clause indirectly by modifying a use statement
|
|
mod change_trait_bound_indirectly_where {
|
|
#[cfg(cfail1)]
|
|
use super::ReferencedTrait1 as Trait;
|
|
#[cfg(not(cfail1))]
|
|
use super::ReferencedTrait2 as Trait;
|
|
|
|
#[rustc_dirty(label="Hir", cfg="cfail2")]
|
|
#[rustc_clean(label="Hir", cfg="cfail3")]
|
|
#[rustc_metadata_dirty(cfg="cfail2")]
|
|
#[rustc_metadata_clean(cfg="cfail3")]
|
|
enum Enum<T> where T: Trait {
|
|
Variant1(T)
|
|
}
|
|
}
|
|
|
|
|