// revisions: rpass1 rpass2 rpass3
// compile-flags: -Zincremental-ignore-spans

enum Foo<const N: usize> {
    Variant,
    Variant2(),
    Variant3 {},
}

impl Foo<1> {
    fn foo<const N: usize>(&self) -> [(); N] { [(); N] }
}

impl Foo<2> {
    fn foo<const N: u32>(self) -> usize { N as usize }
}

struct Bar<const N: usize>;
struct Bar2<const N: usize>();
struct Bar3<const N: usize> {}

#[cfg(rpass1)]
struct ChangingStruct<const N: usize>;

#[cfg(any(rpass2, rpass3))]
struct ChangingStruct<const N: u32>;

struct S;

impl S {
    #[cfg(rpass1)]
    fn changing_method<const N: usize>(self) {}

    #[cfg(any(rpass2, rpass3))]
    fn changing_method<const N: u32>(self) {}
}

// We want to verify that all goes well when the value of the const argument change.
// To avoid modifying `main`'s HIR, we use a separate constant, and use `{ FOO_ARG + 1 }`
// inside the body to keep having an `AnonConst` to compute.
const FOO_ARG: usize = if cfg!(rpass2) { 1 } else { 0 };

fn main() {
    let foo = Foo::Variant::<{ FOO_ARG + 1 }>;
    foo.foo::<{ if cfg!(rpass3) { 3 } else { 4 } }>();

    let foo = Foo::Variant2::<{ FOO_ARG + 1 }>();
    foo.foo::<{ if cfg!(rpass3) { 3 } else { 4 } }>();

    let foo = Foo::Variant3::<{ FOO_ARG + 1 }> {};
    foo.foo::<{ if cfg!(rpass3) { 3 } else { 4 } }>();

    let foo = Foo::<{ FOO_ARG + 1 }>::Variant;
    foo.foo::<{ if cfg!(rpass3) { 3 } else { 4 } }>();

    let foo = Foo::<{ FOO_ARG + 1 }>::Variant2();
    foo.foo::<{ if cfg!(rpass3) { 3 } else { 4 } }>();

    let foo = Foo::<{ FOO_ARG + 1 }>::Variant3 {};
    foo.foo::<{ if cfg!(rpass3) { 3 } else { 4 } }>();

    let _ = Bar::<{ FOO_ARG + 1 }>;
    let _ = Bar2::<{ FOO_ARG + 1 }>();
    let _ = Bar3::<{ FOO_ARG + 1 }> {};

    let _ = ChangingStruct::<{ 5 }>;
    let _ = S.changing_method::<{ 5 }>();
}