Change:
This issue is part of a broader effort to implement comprehensive regression testing for incremental compilation. For the tracking issue go to . For incremental compilation we need to determine if a given HIR node has changed in between two versions of a program. This is implemented in the module. We compute a hash value for each HIR node that corresponds to a node in the dependency graph and then compare those hash values. We call this hash value the Incremental Compilation Hash (ICH) of the HIR node. It is supposed to be sensitive to any change that might make a semantic difference to the thing being hashed. The auto-tests in the directory all follow the same pattern: Each source file defines one test case The source file is compiled multiple times with incremental compilation turned on, each time with a different flag, allowing each version to differ via conditional compilation. Each of these versions we call a revision. During each revision, the test runner will make sure that some assertions about the dependency graph of the program hold. These assertions are specified in the source code of the test file as attributes attached to the items being tested (e.g. /). The ICH-specific tests use this framework by adhering to the following pattern: There are two versions of the definition under test, one marked with and the second marked with . As a consequence, the first revision will be compiled with the first version of the definition, and all other revisions will be compiled with the second version. The two versions are supposed to differ in exactly one aspect (e.g. the visibility of a field is different, or the return of a function has changed). The second definition has a attribute attached. This attribute makes the test runner check that a change of the dependency node of the definition has been detected between revisions and . This will effectively test that a different ICH value has been computed for the two versions of the definition. The second definition also has a attribute. This makes sure that the dependency node (and thus the ICH) of the definition has not changed between revisions and . That's what we expect, because both revisions use the same version of the definition. For definitions that are exported from the crate, we also want to check the ICH of the corresponding metadata. This is tested using the / attributes and works analogous to the case: We add to the second definition to make sure that the ICH of the exported metadata is not the same for the different versions of the definition, and we add to make sure that the ICH is the same for the two identical versions of the definition. Why are the revisions called "cfail"? That's because of reasons internal to how the test-runner works. Prefixing a revision with "cfail" tells the test runner to treat the test like a "compile-file" test, that is: compile the test case but don't actually run it (which would be the case for an "rpass" revision). For the ICH tests we need to compile "rlibs", so that we can test metadata ICHs. As a consequence we cannot declare them "rpass". In an additional directive (), we tell the test runner that we actually expect the file to not produce any errors. Each test case must contain the following test-runner directives and crate attributes at the top: See for a full example of such a ICH regression test. Each of the following things should be tested with its own definition pair: Change enum visibility Change name of a c-style variant Change name of a tuple-style variant Change name of a struct-style variant Change the value of a c-style variant Add a c-style variant Remove a c-style variant Add a tuple-style variant Remove a tuple-style variant Add a struct-style variant Remove a struct-style variant Change the type of a field in a tuple-style variant Change the type of a field in a struct-style variant Change the name of a field in a struct-style variant N/A for enums N/A for enums Change order of fields in a tuple-style variant Change order of fields in a struct-style variant Add a field to a tuple-style variant Add a field to a struct-style variant Add #[mustuse] to the enum Add #[repr(C)] to the enum Change the name of a type parameter Add a type parameter Change the name of a lifetime parameter Add a lifetime parameter Add a lifetime bound to a lifetime parameter Add a lifetime bound to a type parameter Add a trait bound to a type parameter Add a lifetime bound to a lifetime parameter in where clause Add a lifetime bound to a type parameter in where clause Add a trait bound to a type parameter in where clause In an enum with two variants, swap usage of type parameters In an enum with two variants, swap usage of lifetime parameters EDIT: Some more cases Change field type in tuple-style variant by modifying a statement Change field type in record-style variant by modifying a statement Change trait bound of type parameter by modifying a statement Change trait bound of type parameter in where clause by modifying a statement
cc
I can work on this (and maybe even on , .) For "Change the visibility of a field in a [tuple|struct]-style variant", do you mean using the "pub(restricted)" RFC ?
Cool! I'd start out with taking as a template. Feel free to ask here if there are any questions. No, that's actually an oversight on my part. Good catch! I'll remove it from the list.
FYI: A good way to run the incremental tests is:

Discussion:
<ins> // 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_clean(cfg="cfail3")] pub enum EnumVisibility { 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 { Variant1, 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_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] #[rustc_metadata_dirty(cfg="cfail2")] #[rustc_metadata_clean(cfg="cfail3")] enum EnumChangeValueCStyleVariant0 { Variant1, Variant2 = 22, } #[cfg(cfail1)] enum EnumChangeValueCStyleVariant1 { 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 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_dirty(cfg="cfail2")] #[rustc_metadata_clean(cfg="cfail3")] enum EnumChangeFieldTypeTupleStyleVariant { Variant1(u32, 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_dirty(cfg="cfail2")] #[rustc_metadata_clean(cfg="cfail3")] enum EnumChangeFieldTypeStructStyleVariant { Variant1, Variant2 { a: u32, 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_dirty(cfg="cfail2")] #[rustc_metadata_clean(cfg="cfail3")] enum EnumChangeOrderTupleStyleVariant { Variant1(u64, 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_dirty(cfg="cfail2")] #[rustc_metadata_clean(cfg="cfail3")] enum EnumSwapUsageTypeParameters<A, B> { Variant1 { a: B }, Variant2 { 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_dirty(cfg="cfail2")] #[rustc_metadata_clean(cfg="cfail3")] enum EnumSwapUsageLifetimeParameters<'a, 'b> { Variant1 { a: &'b u32 }, Variant2 { 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_dirty(cfg="cfail2")] #[rustc_metadata_clean(cfg="cfail3")] enum TupleStyle { Variant1(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_dirty(cfg="cfail2")] #[rustc_metadata_clean(cfg="cfail3")] enum StructStyle { Variant1 { 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) } } </ins>