blob: 1aac1bc7d722caab214511938ef35a0e93f8b48b (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
|
// 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 }>();
}
|
