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
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
|
// RUN: %clang_cc1 -fexperimental-new-constant-interpreter -std=c++17 -verify=expected,both %s
// RUN: %clang_cc1 -std=c++17 -verify=ref,both %s
struct F { int a; int b;};
constexpr F getF() {
return {12, 3};
}
constexpr int f() {
auto [a1, b1] = getF();
auto [a2, b2] = getF();
return a1 + a2 + b1 + b2;
}
static_assert(f() == 30);
constexpr int structRefs() {
const auto &[a, b] = getF();
return a + b;
}
static_assert(structRefs() == 15);
constexpr int structRefs2() {
F f = getF();
const auto &[a, b] = f;
return a + b;
}
static_assert(structRefs2() == 15);
template<typename T>
struct Tuple {
T first;
T second;
constexpr Tuple(T a, T b) : first(a), second(b) {}
};
template<typename T>
constexpr T addTuple(const Tuple<T> &Tu) {
auto [a, b] = Tu;
return a + b;
}
template<typename T>
constexpr T addTuple2(const Tuple<T> &Tu) {
auto [a, b] = Tu;
return Tu.first + Tu.second;
}
constexpr Tuple<int> T1 = Tuple(1,2);
static_assert(addTuple(T1) == 3);
static_assert(addTuple2(T1) == 3);
constexpr Tuple<short> T2 = Tuple<short>(11,2);
static_assert(addTuple(T2) == 13);
static_assert(addTuple2(T2) == 13);
constexpr int Modify() {
auto T = Tuple<int>(10, 20);
auto &[x, y] = T;
x += 1;
y += 1;
return T.first + T.second;
}
static_assert(Modify() == 32, "");
constexpr int a() {
int a[2] = {5, 3};
auto [x, y] = a;
return x + y;
}
static_assert(a() == 8);
constexpr int b() {
int a[2] = {5, 3};
auto &[x, y] = a;
x += 1;
y += 2;
return a[0] + a[1];
}
static_assert(b() == 11);
/// The diagnostics between the two interpreters used to be different here.
struct S { int a; };
constexpr S getS() { // both-error {{constexpr function never produces a constant expression}}
(void)(1/0); // both-note 2{{division by zero}} \
// both-warning {{division by zero}}
return S{12};
}
constexpr S s = getS(); // both-error {{must be initialized by a constant expression}} \
// both-note {{in call to 'getS()'}} \
// both-note {{declared here}}
static_assert(s.a == 12, ""); // both-error {{not an integral constant expression}} \
// both-note {{initializer of 's' is not a constant expression}}
|
