constant-expression-cxx11.cpp revision 7c3e615f01e8f9f587315800fdaf2305ed824568 
1// RUN: %clang_cc1 -triple i686-linux -Wno-string-plus-int -fsyntax-only -fcxx-exceptions -verify -std=c++11 -pedantic %s -Wno-comment
2
3namespace StaticAssertFoldTest {
4
5int x;
6static_assert(++x, "test"); // expected-error {{not an integral constant expression}}
7static_assert(false, "test"); // expected-error {{test}}
8
9}
10
11typedef decltype(sizeof(char)) size_t;
12
13template<typename T> constexpr T id(const T &t) { return t; }
14template<typename T> constexpr T min(const T &a, const T &b) {
15  return a < b ? a : b;
16}
17template<typename T> constexpr T max(const T &a, const T &b) {
18  return a < b ? b : a;
19}
20template<typename T, size_t N> constexpr T *begin(T (&xs)[N]) { return xs; }
21template<typename T, size_t N> constexpr T *end(T (&xs)[N]) { return xs + N; }
22
23struct MemberZero {
24  constexpr int zero() const { return 0; }
25};
26
27namespace DerivedToVBaseCast {
28
29  struct U { int n; };
30  struct V : U { int n; };
31  struct A : virtual V { int n; };
32  struct Aa { int n; };
33  struct B : virtual A, Aa {};
34  struct C : virtual A, Aa {};
35  struct D : B, C {};
36
37  D d;
38  constexpr B *p = &d;
39  constexpr C *q = &d;
40
41  static_assert((void*)p != (void*)q, "");
42  static_assert((A*)p == (A*)q, "");
43  static_assert((Aa*)p != (Aa*)q, "");
44
45  constexpr B &pp = d;
46  constexpr C &qq = d;
47  static_assert((void*)&pp != (void*)&qq, "");
48  static_assert(&(A&)pp == &(A&)qq, "");
49  static_assert(&(Aa&)pp != &(Aa&)qq, "");
50
51  constexpr V *v = p;
52  constexpr V *w = q;
53  constexpr V *x = (A*)p;
54  static_assert(v == w, "");
55  static_assert(v == x, "");
56
57  static_assert((U*)&d == p, "");
58  static_assert((U*)&d == q, "");
59  static_assert((U*)&d == v, "");
60  static_assert((U*)&d == w, "");
61  static_assert((U*)&d == x, "");
62
63  struct X {};
64  struct Y1 : virtual X {};
65  struct Y2 : X {};
66  struct Z : Y1, Y2 {};
67  Z z;
68  static_assert((X*)(Y1*)&z != (X*)(Y2*)&z, "");
69}
70
71namespace ConstCast {
72
73constexpr int n1 = 0;
74constexpr int n2 = const_cast<int&>(n1);
75constexpr int *n3 = const_cast<int*>(&n1);
76constexpr int n4 = *const_cast<int*>(&n1);
77constexpr const int * const *n5 = const_cast<const int* const*>(&n3);
78constexpr int **n6 = const_cast<int**>(&n3);
79constexpr int n7 = **n5;
80constexpr int n8 = **n6;
81
82}
83
84namespace TemplateArgumentConversion {
85  template<int n> struct IntParam {};
86
87  using IntParam0 = IntParam<0>;
88  using IntParam0 = IntParam<id(0)>;
89  using IntParam0 = IntParam<MemberZero().zero>; // expected-error {{did you mean to call it with no arguments?}}
90}
91
92namespace CaseStatements {
93  void f(int n) {
94    switch (n) {
95    case MemberZero().zero: // expected-error {{did you mean to call it with no arguments?}} expected-note {{previous}}
96    case id(0): // expected-error {{duplicate case value '0'}}
97      return;
98    }
99  }
100}
101
102extern int &Recurse1;
103int &Recurse2 = Recurse1; // expected-note {{declared here}}
104int &Recurse1 = Recurse2;
105constexpr int &Recurse3 = Recurse2; // expected-error {{must be initialized by a constant expression}} expected-note {{initializer of 'Recurse2' is not a constant expression}}
106
107extern const int RecurseA;
108const int RecurseB = RecurseA; // expected-note {{declared here}}
109const int RecurseA = 10;
110constexpr int RecurseC = RecurseB; // expected-error {{must be initialized by a constant expression}} expected-note {{initializer of 'RecurseB' is not a constant expression}}
111
112namespace MemberEnum {
113  struct WithMemberEnum {
114    enum E { A = 42 };
115  } wme;
116
117  static_assert(wme.A == 42, "");
118}
119
120namespace DefaultArguments {
121
122const int z = int();
123constexpr int Sum(int a = 0, const int &b = 0, const int *c = &z, char d = 0) {
124  return a + b + *c + d;
125}
126const int four = 4;
127constexpr int eight = 8;
128constexpr const int twentyseven = 27;
129static_assert(Sum() == 0, "");
130static_assert(Sum(1) == 1, "");
131static_assert(Sum(1, four) == 5, "");
132static_assert(Sum(1, eight, &twentyseven) == 36, "");
133static_assert(Sum(1, 2, &four, eight) == 15, "");
134
135}
136
137namespace Ellipsis {
138
139// Note, values passed through an ellipsis can't actually be used.
140constexpr int F(int a, ...) { return a; }
141static_assert(F(0) == 0, "");
142static_assert(F(1, 0) == 1, "");
143static_assert(F(2, "test") == 2, "");
144static_assert(F(3, &F) == 3, "");
145int k = 0; // expected-note {{here}}
146static_assert(F(4, k) == 3, ""); // expected-error {{constant expression}} expected-note {{read of non-const variable 'k'}}
147
148}
149
150namespace Recursion {
151  constexpr int fib(int n) { return n > 1 ? fib(n-1) + fib(n-2) : n; }
152  static_assert(fib(11) == 89, "");
153
154  constexpr int gcd_inner(int a, int b) {
155    return b == 0 ? a : gcd_inner(b, a % b);
156  }
157  constexpr int gcd(int a, int b) {
158    return gcd_inner(max(a, b), min(a, b));
159  }
160
161  static_assert(gcd(1749237, 5628959) == 7, "");
162}
163
164namespace FunctionCast {
165  // When folding, we allow functions to be cast to different types. Such
166  // cast functions cannot be called, even if they're constexpr.
167  constexpr int f() { return 1; }
168  typedef double (*DoubleFn)();
169  typedef int (*IntFn)();
170  int a[(int)DoubleFn(f)()]; // expected-error {{variable length array}} expected-warning{{C99 feature}}
171  int b[(int)IntFn(f)()];    // ok
172}
173
174namespace StaticMemberFunction {
175  struct S {
176    static constexpr int k = 42;
177    static constexpr int f(int n) { return n * k + 2; }
178  } s;
179
180  constexpr int n = s.f(19);
181  static_assert(S::f(19) == 800, "");
182  static_assert(s.f(19) == 800, "");
183  static_assert(n == 800, "");
184
185  constexpr int (*sf1)(int) = &S::f;
186  constexpr int (*sf2)(int) = &s.f;
187  constexpr const int *sk = &s.k;
188}
189
190namespace ParameterScopes {
191
192  const int k = 42;
193  constexpr const int &ObscureTheTruth(const int &a) { return a; }
194  constexpr const int &MaybeReturnJunk(bool b, const int a) { // expected-note 2{{declared here}}
195    return ObscureTheTruth(b ? a : k);
196  }
197  static_assert(MaybeReturnJunk(false, 0) == 42, ""); // ok
198  constexpr int a = MaybeReturnJunk(true, 0); // expected-error {{constant expression}} expected-note {{read of variable whose lifetime has ended}}
199
200  constexpr const int MaybeReturnNonstaticRef(bool b, const int a) {
201    return ObscureTheTruth(b ? a : k);
202  }
203  static_assert(MaybeReturnNonstaticRef(false, 0) == 42, ""); // ok
204  constexpr int b = MaybeReturnNonstaticRef(true, 0); // ok
205
206  constexpr int InternalReturnJunk(int n) {
207    return MaybeReturnJunk(true, n); // expected-note {{read of variable whose lifetime has ended}}
208  }
209  constexpr int n3 = InternalReturnJunk(0); // expected-error {{must be initialized by a constant expression}} expected-note {{in call to 'InternalReturnJunk(0)'}}
210
211  constexpr int LToR(int &n) { return n; }
212  constexpr int GrabCallersArgument(bool which, int a, int b) {
213    return LToR(which ? b : a);
214  }
215  static_assert(GrabCallersArgument(false, 1, 2) == 1, "");
216  static_assert(GrabCallersArgument(true, 4, 8) == 8, "");
217
218}
219
220namespace Pointers {
221
222  constexpr int f(int n, const int *a, const int *b, const int *c) {
223    return n == 0 ? 0 : *a + f(n-1, b, c, a);
224  }
225
226  const int x = 1, y = 10, z = 100;
227  static_assert(f(23, &x, &y, &z) == 788, "");
228
229  constexpr int g(int n, int a, int b, int c) {
230    return f(n, &a, &b, &c);
231  }
232  static_assert(g(23, x, y, z) == 788, "");
233
234}
235
236namespace FunctionPointers {
237
238  constexpr int Double(int n) { return 2 * n; }
239  constexpr int Triple(int n) { return 3 * n; }
240  constexpr int Twice(int (*F)(int), int n) { return F(F(n)); }
241  constexpr int Quadruple(int n) { return Twice(Double, n); }
242  constexpr auto Select(int n) -> int (*)(int) {
243    return n == 2 ? &Double : n == 3 ? &Triple : n == 4 ? &Quadruple : 0;
244  }
245  constexpr int Apply(int (*F)(int), int n) { return F(n); } // expected-note {{subexpression}}
246
247  static_assert(1 + Apply(Select(4), 5) + Apply(Select(3), 7) == 42, "");
248
249  constexpr int Invalid = Apply(Select(0), 0); // expected-error {{must be initialized by a constant expression}} expected-note {{in call to 'Apply(0, 0)'}}
250
251}
252
253namespace PointerComparison {
254
255int x, y;
256static_assert(&x == &y, "false"); // expected-error {{false}}
257static_assert(&x != &y, "");
258constexpr bool g1 = &x == &y;
259constexpr bool g2 = &x != &y;
260constexpr bool g3 = &x <= &y; // expected-error {{must be initialized by a constant expression}}
261constexpr bool g4 = &x >= &y; // expected-error {{must be initialized by a constant expression}}
262constexpr bool g5 = &x < &y; // expected-error {{must be initialized by a constant expression}}
263constexpr bool g6 = &x > &y; // expected-error {{must be initialized by a constant expression}}
264
265struct S { int x, y; } s;
266static_assert(&s.x == &s.y, "false"); // expected-error {{false}}
267static_assert(&s.x != &s.y, "");
268static_assert(&s.x <= &s.y, "");
269static_assert(&s.x >= &s.y, "false"); // expected-error {{false}}
270static_assert(&s.x < &s.y, "");
271static_assert(&s.x > &s.y, "false"); // expected-error {{false}}
272
273static_assert(0 == &y, "false"); // expected-error {{false}}
274static_assert(0 != &y, "");
275constexpr bool n3 = 0 <= &y; // expected-error {{must be initialized by a constant expression}}
276constexpr bool n4 = 0 >= &y; // expected-error {{must be initialized by a constant expression}}
277constexpr bool n5 = 0 < &y; // expected-error {{must be initialized by a constant expression}}
278constexpr bool n6 = 0 > &y; // expected-error {{must be initialized by a constant expression}}
279
280static_assert(&x == 0, "false"); // expected-error {{false}}
281static_assert(&x != 0, "");
282constexpr bool n9 = &x <= 0; // expected-error {{must be initialized by a constant expression}}
283constexpr bool n10 = &x >= 0; // expected-error {{must be initialized by a constant expression}}
284constexpr bool n11 = &x < 0; // expected-error {{must be initialized by a constant expression}}
285constexpr bool n12 = &x > 0; // expected-error {{must be initialized by a constant expression}}
286
287static_assert(&x == &x, "");
288static_assert(&x != &x, "false"); // expected-error {{false}}
289static_assert(&x <= &x, "");
290static_assert(&x >= &x, "");
291static_assert(&x < &x, "false"); // expected-error {{false}}
292static_assert(&x > &x, "false"); // expected-error {{false}}
293
294constexpr S* sptr = &s;
295constexpr bool dyncast = sptr == dynamic_cast<S*>(sptr); // expected-error {{constant expression}} expected-note {{dynamic_cast}}
296
297struct U {};
298struct Str {
299  int a : dynamic_cast<S*>(sptr) == dynamic_cast<S*>(sptr); // \
300    expected-warning {{not an integral constant expression}} \
301    expected-note {{dynamic_cast is not allowed in a constant expression}}
302  int b : reinterpret_cast<S*>(sptr) == reinterpret_cast<S*>(sptr); // \
303    expected-warning {{not an integral constant expression}} \
304    expected-note {{reinterpret_cast is not allowed in a constant expression}}
305  int c : (S*)(long)(sptr) == (S*)(long)(sptr); // \
306    expected-warning {{not an integral constant expression}} \
307    expected-note {{cast that performs the conversions of a reinterpret_cast is not allowed in a constant expression}}
308  int d : (S*)(42) == (S*)(42); // \
309    expected-warning {{not an integral constant expression}} \
310    expected-note {{cast that performs the conversions of a reinterpret_cast is not allowed in a constant expression}}
311  int e : (Str*)(sptr) == (Str*)(sptr); // \
312    expected-warning {{not an integral constant expression}} \
313    expected-note {{cast that performs the conversions of a reinterpret_cast is not allowed in a constant expression}}
314  int f : &(U&)(*sptr) == &(U&)(*sptr); // \
315    expected-warning {{not an integral constant expression}} \
316    expected-note {{cast that performs the conversions of a reinterpret_cast is not allowed in a constant expression}}
317  int g : (S*)(void*)(sptr) == sptr; // \
318    expected-warning {{not an integral constant expression}} \
319    expected-note {{cast from 'void *' is not allowed in a constant expression}}
320};
321
322extern char externalvar[];
323constexpr bool constaddress = (void *)externalvar == (void *)0x4000UL; // expected-error {{must be initialized by a constant expression}}
324constexpr bool litaddress = "foo" == "foo"; // expected-error {{must be initialized by a constant expression}} expected-warning {{unspecified}}
325static_assert(0 != "foo", "");
326
327}
328
329namespace MaterializeTemporary {
330
331constexpr int f(const int &r) { return r; }
332constexpr int n = f(1);
333
334constexpr bool same(const int &a, const int &b) { return &a == &b; }
335constexpr bool sameTemporary(const int &n) { return same(n, n); }
336
337static_assert(n, "");
338static_assert(!same(4, 4), "");
339static_assert(same(n, n), "");
340static_assert(sameTemporary(9), "");
341
342struct A { int &&r; };
343struct B { A &&a1; A &&a2; };
344
345constexpr B b1 { { 1 }, { 2 } }; // expected-note {{temporary created here}}
346static_assert(&b1.a1 != &b1.a2, "");
347static_assert(&b1.a1.r != &b1.a2.r, ""); // expected-error {{constant expression}} expected-note {{outside the expression that created the temporary}}
348
349constexpr B &&b2 { { 3 }, { 4 } }; // expected-note {{temporary created here}}
350static_assert(&b1 != &b2, "");
351static_assert(&b1.a1 != &b2.a1, ""); // expected-error {{constant expression}} expected-note {{outside the expression that created the temporary}}
352
353constexpr thread_local B b3 { { 1 }, { 2 } }; // expected-error {{constant expression}} expected-note {{reference to temporary}} expected-note {{here}}
354void foo() {
355  constexpr static B b1 { { 1 }, { 2 } }; // ok
356  constexpr thread_local B b2 { { 1 }, { 2 } }; // expected-error {{constant expression}} expected-note {{reference to temporary}} expected-note {{here}}
357  constexpr B b3 { { 1 }, { 2 } }; // expected-error {{constant expression}} expected-note {{reference to temporary}} expected-note {{here}}
358}
359
360constexpr B &&b4 = ((1, 2), 3, 4, B { {10}, {{20}} }); // expected-warning 4{{unused}}
361static_assert(&b4 != &b2, "");
362
363// Proposed DR: copy-elision doesn't trigger lifetime extension.
364constexpr B b5 = B{ {0}, {0} }; // expected-error {{constant expression}} expected-note {{reference to temporary}} expected-note {{here}}
365
366namespace NestedNonStatic {
367  // Proposed DR: for a reference constant expression to refer to a static
368  // storage duration temporary, that temporary must itself be initialized
369  // by a constant expression (a core constant expression is not enough).
370  struct A { int &&r; };
371  struct B { A &&a; };
372  constexpr B a = { A{0} }; // ok
373  constexpr B b = { A(A{0}) }; // expected-error {{constant expression}} expected-note {{reference to temporary}} expected-note {{here}}
374}
375
376namespace FakeInitList {
377  struct init_list_3_ints { const int (&x)[3]; };
378  struct init_list_2_init_list_3_ints { const init_list_3_ints (&x)[2]; };
379  constexpr init_list_2_init_list_3_ints ils = { { { { 1, 2, 3 } }, { { 4, 5, 6 } } } };
380}
381
382}
383
384constexpr int strcmp_ce(const char *p, const char *q) {
385  return (!*p || *p != *q) ? *p - *q : strcmp_ce(p+1, q+1);
386}
387
388namespace StringLiteral {
389
390template<typename Char>
391constexpr int MangleChars(const Char *p) {
392  return *p + 3 * (*p ? MangleChars(p+1) : 0);
393}
394
395static_assert(MangleChars("constexpr!") == 1768383, "");
396static_assert(MangleChars(u8"constexpr!") == 1768383, "");
397static_assert(MangleChars(L"constexpr!") == 1768383, "");
398static_assert(MangleChars(u"constexpr!") == 1768383, "");
399static_assert(MangleChars(U"constexpr!") == 1768383, "");
400
401constexpr char c0 = "nought index"[0];
402constexpr char c1 = "nice index"[10];
403constexpr char c2 = "nasty index"[12]; // expected-error {{must be initialized by a constant expression}} expected-warning {{is past the end}} expected-note {{read of dereferenced one-past-the-end pointer}}
404constexpr char c3 = "negative index"[-1]; // expected-error {{must be initialized by a constant expression}} expected-warning {{is before the beginning}} expected-note {{cannot refer to element -1 of array of 15 elements}}
405constexpr char c4 = ((char*)(int*)"no reinterpret_casts allowed")[14]; // expected-error {{must be initialized by a constant expression}} expected-note {{cast that performs the conversions of a reinterpret_cast}}
406
407constexpr const char *p = "test" + 2;
408static_assert(*p == 's', "");
409
410constexpr const char *max_iter(const char *a, const char *b) {
411  return *a < *b ? b : a;
412}
413constexpr const char *max_element(const char *a, const char *b) {
414  return (a+1 >= b) ? a : max_iter(a, max_element(a+1, b));
415}
416
417constexpr char str[] = "the quick brown fox jumped over the lazy dog";
418constexpr const char *max = max_element(begin(str), end(str));
419static_assert(*max == 'z', "");
420static_assert(max == str + 38, "");
421
422static_assert(strcmp_ce("hello world", "hello world") == 0, "");
423static_assert(strcmp_ce("hello world", "hello clang") > 0, "");
424static_assert(strcmp_ce("constexpr", "test") < 0, "");
425static_assert(strcmp_ce("", " ") < 0, "");
426
427struct S {
428  int n : "foo"[4]; // expected-error {{constant expression}} expected-note {{read of dereferenced one-past-the-end pointer is not allowed in a constant expression}}
429};
430
431struct T {
432  char c[6];
433  constexpr T() : c{"foo"} {}
434};
435constexpr T t;
436
437static_assert(t.c[0] == 'f', "");
438static_assert(t.c[1] == 'o', "");
439static_assert(t.c[2] == 'o', "");
440static_assert(t.c[3] == 0, "");
441static_assert(t.c[4] == 0, "");
442static_assert(t.c[5] == 0, "");
443static_assert(t.c[6] == 0, ""); // expected-error {{constant expression}} expected-note {{one-past-the-end}}
444
445struct U {
446  wchar_t chars[6];
447  int n;
448} constexpr u = { { L"test" }, 0 };
449static_assert(u.chars[2] == L's', "");
450
451struct V {
452  char c[4];
453  constexpr V() : c("hi!") {}
454};
455static_assert(V().c[1] == "i"[0], "");
456
457namespace Parens {
458  constexpr unsigned char a[] = ("foo"), b[] = {"foo"}, c[] = {("foo")},
459                          d[4] = ("foo"), e[5] = {"foo"}, f[6] = {("foo")};
460  static_assert(a[0] == 'f', "");
461  static_assert(b[1] == 'o', "");
462  static_assert(c[2] == 'o', "");
463  static_assert(d[0] == 'f', "");
464  static_assert(e[1] == 'o', "");
465  static_assert(f[2] == 'o', "");
466  static_assert(f[5] == 0, "");
467  static_assert(f[6] == 0, ""); // expected-error {{constant expression}} expected-note {{one-past-the-end}}
468}
469
470}
471
472namespace Array {
473
474template<typename Iter>
475constexpr auto Sum(Iter begin, Iter end) -> decltype(+*begin) {
476  return begin == end ? 0 : *begin + Sum(begin+1, end);
477}
478
479constexpr int xs[] = { 1, 2, 3, 4, 5 };
480constexpr int ys[] = { 5, 4, 3, 2, 1 };
481constexpr int sum_xs = Sum(begin(xs), end(xs));
482static_assert(sum_xs == 15, "");
483
484constexpr int ZipFoldR(int (*F)(int x, int y, int c), int n,
485                       const int *xs, const int *ys, int c) {
486  return n ? F(
487               *xs, // expected-note {{read of dereferenced one-past-the-end pointer}}
488               *ys,
489               ZipFoldR(F, n-1, xs+1, ys+1, c)) // \
490      expected-note {{in call to 'ZipFoldR(&SubMul, 2, &xs[4], &ys[4], 1)'}} \
491      expected-note {{in call to 'ZipFoldR(&SubMul, 1, &xs[5], &ys[5], 1)'}}
492           : c;
493}
494constexpr int MulAdd(int x, int y, int c) { return x * y + c; }
495constexpr int InnerProduct = ZipFoldR(MulAdd, 5, xs, ys, 0);
496static_assert(InnerProduct == 35, "");
497
498constexpr int SubMul(int x, int y, int c) { return (x - y) * c; }
499constexpr int DiffProd = ZipFoldR(SubMul, 2, xs+3, ys+3, 1);
500static_assert(DiffProd == 8, "");
501static_assert(ZipFoldR(SubMul, 3, xs+3, ys+3, 1), ""); // \
502      expected-error {{constant expression}} \
503      expected-note {{in call to 'ZipFoldR(&SubMul, 3, &xs[3], &ys[3], 1)'}}
504
505constexpr const int *p = xs + 3;
506constexpr int xs4 = p[1]; // ok
507constexpr int xs5 = p[2]; // expected-error {{constant expression}} expected-note {{read of dereferenced one-past-the-end pointer}}
508constexpr int xs6 = p[3]; // expected-error {{constant expression}} expected-note {{cannot refer to element 6}}
509constexpr int xs0 = p[-3]; // ok
510constexpr int xs_1 = p[-4]; // expected-error {{constant expression}} expected-note {{cannot refer to element -1}}
511
512constexpr int zs[2][2][2][2] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
513static_assert(zs[0][0][0][0] == 1, "");
514static_assert(zs[1][1][1][1] == 16, "");
515static_assert(zs[0][0][0][2] == 3, ""); // expected-error {{constant expression}} expected-note {{read of dereferenced one-past-the-end pointer}}
516static_assert((&zs[0][0][0][2])[-1] == 2, "");
517static_assert(**(**(zs + 1) + 1) == 11, "");
518static_assert(*(&(&(*(*&(&zs[2] - 1)[0] + 2 - 2))[2])[-1][-1] + 1) == 11, ""); // expected-error {{constant expression}} expected-note {{cannot refer to element -1 of array of 2 elements in a constant expression}}
519static_assert(*(&(&(*(*&(&zs[2] - 1)[0] + 2 - 2))[2])[-1][2] - 2) == 11, "");
520constexpr int err_zs_1_2_0_0 = zs[1][2][0][0]; // expected-error {{constant expression}} expected-note {{cannot access array element of pointer past the end}}
521
522constexpr int fail(const int &p) {
523  return (&p)[64]; // expected-note {{cannot refer to element 64 of array of 2 elements}}
524}
525static_assert(fail(*(&(&(*(*&(&zs[2] - 1)[0] + 2 - 2))[2])[-1][2] - 2)) == 11, ""); // \
526expected-error {{static_assert expression is not an integral constant expression}} \
527expected-note {{in call to 'fail(zs[1][0][1][0])'}}
528
529constexpr int arr[40] = { 1, 2, 3, [8] = 4 }; // expected-warning {{C99 feature}}
530constexpr int SumNonzero(const int *p) {
531  return *p + (*p ? SumNonzero(p+1) : 0);
532}
533constexpr int CountZero(const int *p, const int *q) {
534  return p == q ? 0 : (*p == 0) + CountZero(p+1, q);
535}
536static_assert(SumNonzero(arr) == 6, "");
537static_assert(CountZero(arr, arr + 40) == 36, "");
538
539struct ArrayElem {
540  constexpr ArrayElem() : n(0) {}
541  int n;
542  constexpr int f() const { return n; }
543};
544struct ArrayRVal {
545  constexpr ArrayRVal() {}
546  ArrayElem elems[10];
547};
548static_assert(ArrayRVal().elems[3].f() == 0, "");
549
550constexpr int selfref[2][2][2] = {
551  selfref[1][1][1] + 1, selfref[0][0][0] + 1,
552  selfref[1][0][1] + 1, selfref[0][1][0] + 1,
553  selfref[1][0][0] + 1, selfref[0][1][1] + 1 };
554static_assert(selfref[0][0][0] == 1, "");
555static_assert(selfref[0][0][1] == 2, "");
556static_assert(selfref[0][1][0] == 1, "");
557static_assert(selfref[0][1][1] == 2, "");
558static_assert(selfref[1][0][0] == 1, "");
559static_assert(selfref[1][0][1] == 3, "");
560static_assert(selfref[1][1][0] == 0, "");
561static_assert(selfref[1][1][1] == 0, "");
562
563struct TrivialDefCtor { int n; };
564typedef TrivialDefCtor TDCArray[2][2];
565static_assert(TDCArray{}[1][1].n == 0, "");
566
567struct NonAggregateTDC : TrivialDefCtor {};
568typedef NonAggregateTDC NATDCArray[2][2];
569static_assert(NATDCArray{}[1][1].n == 0, "");
570
571}
572
573namespace DependentValues {
574
575struct I { int n; typedef I V[10]; };
576I::V x, y;
577int g();
578template<bool B, typename T> struct S : T {
579  int k;
580  void f() {
581    I::V &cells = B ? x : y;
582    I &i = cells[k];
583    switch (i.n) {}
584
585    // FIXME: We should be able to diagnose this.
586    constexpr int n = g();
587
588    constexpr int m = this->g(); // ok, could be constexpr
589  }
590};
591
592}
593
594namespace Class {
595
596struct A { constexpr A(int a, int b) : k(a + b) {} int k; };
597constexpr int fn(const A &a) { return a.k; }
598static_assert(fn(A(4,5)) == 9, "");
599
600struct B { int n; int m; } constexpr b = { 0, b.n }; // expected-warning {{uninitialized}}
601struct C {
602  constexpr C(C *this_) : m(42), n(this_->m) {} // ok
603  int m, n;
604};
605struct D {
606  C c;
607  constexpr D() : c(&c) {}
608};
609static_assert(D().c.n == 42, "");
610
611struct E {
612  constexpr E() : p(&p) {}
613  void *p;
614};
615constexpr const E &e1 = E();
616// This is a constant expression if we elide the copy constructor call, and
617// is not a constant expression if we don't! But we do, so it is.
618constexpr E e2 = E();
619static_assert(e2.p == &e2.p, "");
620constexpr E e3;
621static_assert(e3.p == &e3.p, "");
622
623extern const class F f;
624struct F {
625  constexpr F() : p(&f.p) {}
626  const void *p;
627};
628constexpr F f;
629
630struct G {
631  struct T {
632    constexpr T(T *p) : u1(), u2(p) {}
633    union U1 {
634      constexpr U1() {}
635      int a, b = 42;
636    } u1;
637    union U2 {
638      constexpr U2(T *p) : c(p->u1.b) {}
639      int c, d;
640    } u2;
641  } t;
642  constexpr G() : t(&t) {}
643} constexpr g;
644
645static_assert(g.t.u1.a == 42, ""); // expected-error {{constant expression}} expected-note {{read of member 'a' of union with active member 'b'}}
646static_assert(g.t.u1.b == 42, "");
647static_assert(g.t.u2.c == 42, "");
648static_assert(g.t.u2.d == 42, ""); // expected-error {{constant expression}} expected-note {{read of member 'd' of union with active member 'c'}}
649
650struct S {
651  int a, b;
652  const S *p;
653  double d;
654  const char *q;
655
656  constexpr S(int n, const S *p) : a(5), b(n), p(p), d(n), q("hello") {}
657};
658
659S global(43, &global);
660
661static_assert(S(15, &global).b == 15, "");
662
663constexpr bool CheckS(const S &s) {
664  return s.a == 5 && s.b == 27 && s.p == &global && s.d == 27. && s.q[3] == 'l';
665}
666static_assert(CheckS(S(27, &global)), "");
667
668struct Arr {
669  char arr[3];
670  constexpr Arr() : arr{'x', 'y', 'z'} {}
671};
672constexpr int hash(Arr &&a) {
673  return a.arr[0] + a.arr[1] * 0x100 + a.arr[2] * 0x10000;
674}
675constexpr int k = hash(Arr());
676static_assert(k == 0x007a7978, "");
677
678
679struct AggregateInit {
680  const char &c;
681  int n;
682  double d;
683  int arr[5];
684  void *p;
685};
686
687constexpr AggregateInit agg1 = { "hello"[0] };
688
689static_assert(strcmp_ce(&agg1.c, "hello") == 0, "");
690static_assert(agg1.n == 0, "");
691static_assert(agg1.d == 0.0, "");
692static_assert(agg1.arr[-1] == 0, ""); // expected-error {{constant expression}} expected-note {{cannot refer to element -1}}
693static_assert(agg1.arr[0] == 0, "");
694static_assert(agg1.arr[4] == 0, "");
695static_assert(agg1.arr[5] == 0, ""); // expected-error {{constant expression}} expected-note {{read of dereferenced one-past-the-end}}
696static_assert(agg1.p == nullptr, "");
697
698static constexpr const unsigned char uc[] = { "foo" };
699static_assert(uc[0] == 'f', "");
700static_assert(uc[3] == 0, "");
701
702namespace SimpleDerivedClass {
703
704struct B {
705  constexpr B(int n) : a(n) {}
706  int a;
707};
708struct D : B {
709  constexpr D(int n) : B(n) {}
710};
711constexpr D d(3);
712static_assert(d.a == 3, "");
713
714}
715
716struct Bottom { constexpr Bottom() {} };
717struct Base : Bottom {
718  constexpr Base(int a = 42, const char *b = "test") : a(a), b(b) {}
719  int a;
720  const char *b;
721};
722struct Base2 : Bottom {
723  constexpr Base2(const int &r) : r(r) {}
724  int q = 123;
725  const int &r;
726};
727struct Derived : Base, Base2 {
728  constexpr Derived() : Base(76), Base2(a) {}
729  int c = r + b[1];
730};
731
732constexpr bool operator==(const Base &a, const Base &b) {
733  return a.a == b.a && strcmp_ce(a.b, b.b) == 0;
734}
735
736constexpr Base base;
737constexpr Base base2(76);
738constexpr Derived derived;
739static_assert(derived.a == 76, "");
740static_assert(derived.b[2] == 's', "");
741static_assert(derived.c == 76 + 'e', "");
742static_assert(derived.q == 123, "");
743static_assert(derived.r == 76, "");
744static_assert(&derived.r == &derived.a, "");
745
746static_assert(!(derived == base), "");
747static_assert(derived == base2, "");
748
749constexpr Bottom &bot1 = (Base&)derived;
750constexpr Bottom &bot2 = (Base2&)derived;
751static_assert(&bot1 != &bot2, "");
752
753constexpr Bottom *pb1 = (Base*)&derived;
754constexpr Bottom *pb2 = (Base2*)&derived;
755static_assert(&pb1 != &pb2, "");
756static_assert(pb1 == &bot1, "");
757static_assert(pb2 == &bot2, "");
758
759constexpr Base2 &fail = (Base2&)bot1; // expected-error {{constant expression}} expected-note {{cannot cast object of dynamic type 'const Class::Derived' to type 'Class::Base2'}}
760constexpr Base &fail2 = (Base&)*pb2; // expected-error {{constant expression}} expected-note {{cannot cast object of dynamic type 'const Class::Derived' to type 'Class::Base'}}
761constexpr Base2 &ok2 = (Base2&)bot2;
762static_assert(&ok2 == &derived, "");
763
764constexpr Base2 *pfail = (Base2*)pb1; // expected-error {{constant expression}} expected-note {{cannot cast object of dynamic type 'const Class::Derived' to type 'Class::Base2'}}
765constexpr Base *pfail2 = (Base*)&bot2; // expected-error {{constant expression}} expected-note {{cannot cast object of dynamic type 'const Class::Derived' to type 'Class::Base'}}
766constexpr Base2 *pok2 = (Base2*)pb2;
767static_assert(pok2 == &derived, "");
768static_assert(&ok2 == pok2, "");
769static_assert((Base2*)(Derived*)(Base*)pb1 == pok2, "");
770static_assert((Derived*)(Base*)pb1 == (Derived*)pok2, "");
771
772constexpr Base *nullB = 42 - 6 * 7; // expected-warning {{expression which evaluates to zero treated as a null pointer constant of type 'Class::Base *const'}}
773static_assert((Bottom*)nullB == 0, "");
774static_assert((Derived*)nullB == 0, "");
775static_assert((void*)(Bottom*)nullB == (void*)(Derived*)nullB, "");
776Base * nullB2 = '\0'; // expected-warning {{expression which evaluates to zero treated as a null pointer constant of type 'Class::Base *'}}
777Base * nullB3 = (0);
778// We suppress the warning in unevaluated contexts to workaround some gtest
779// behavior. Once this becomes an error this isn't a problem anymore.
780static_assert(nullB == (1 - 1), "");
781
782
783namespace ConversionOperators {
784
785struct T {
786  constexpr T(int n) : k(5*n - 3) {}
787  constexpr operator int() const { return k; }
788  int k;
789};
790
791struct S {
792  constexpr S(int n) : k(2*n + 1) {}
793  constexpr operator int() const { return k; }
794  constexpr operator T() const { return T(k); }
795  int k;
796};
797
798constexpr bool check(T a, T b) { return a == b.k; }
799
800static_assert(S(5) == 11, "");
801static_assert(check(S(5), 11), "");
802
803namespace PR14171 {
804
805struct X {
806  constexpr (operator int)() const { return 0; }
807};
808static_assert(X() == 0, "");
809
810}
811
812}
813
814}
815
816namespace Temporaries {
817
818struct S {
819  constexpr S() {}
820  constexpr int f() const;
821  constexpr int g() const;
822};
823struct T : S {
824  constexpr T(int n) : S(), n(n) {}
825  int n;
826};
827constexpr int S::f() const {
828  return static_cast<const T*>(this)->n; // expected-note {{cannot cast}}
829}
830constexpr int S::g() const {
831  // FIXME: Better diagnostic for this.
832  return this->*(int(S::*))&T::n; // expected-note {{subexpression}}
833}
834// The T temporary is implicitly cast to an S subobject, but we can recover the
835// T full-object via a base-to-derived cast, or a derived-to-base-casted member
836// pointer.
837static_assert(S().f(), ""); // expected-error {{constant expression}} expected-note {{in call to '&Temporaries::S()->f()'}}
838static_assert(S().g(), ""); // expected-error {{constant expression}} expected-note {{in call to '&Temporaries::S()->g()'}}
839static_assert(T(3).f() == 3, "");
840static_assert(T(4).g() == 4, "");
841
842constexpr int f(const S &s) {
843  return static_cast<const T&>(s).n;
844}
845constexpr int n = f(T(5));
846static_assert(f(T(5)) == 5, "");
847
848constexpr bool b(int n) { return &n; }
849static_assert(b(0), "");
850
851}
852
853namespace Union {
854
855union U {
856  int a;
857  int b;
858};
859
860constexpr U u[4] = { { .a = 0 }, { .b = 1 }, { .a = 2 }, { .b = 3 } }; // expected-warning 4{{C99 feature}}
861static_assert(u[0].a == 0, "");
862static_assert(u[0].b, ""); // expected-error {{constant expression}} expected-note {{read of member 'b' of union with active member 'a'}}
863static_assert(u[1].b == 1, "");
864static_assert((&u[1].b)[1] == 2, ""); // expected-error {{constant expression}} expected-note {{read of dereferenced one-past-the-end pointer}}
865static_assert(*(&(u[1].b) + 1 + 1) == 3, ""); // expected-error {{constant expression}} expected-note {{cannot refer to element 2 of non-array object}}
866static_assert((&(u[1]) + 1 + 1)->b == 3, "");
867
868constexpr U v = {};
869static_assert(v.a == 0, "");
870
871union Empty {};
872constexpr Empty e = {};
873
874// Make sure we handle trivial copy constructors for unions.
875constexpr U x = {42};
876constexpr U y = x;
877static_assert(y.a == 42, "");
878static_assert(y.b == 42, ""); // expected-error {{constant expression}} expected-note {{'b' of union with active member 'a'}}
879
880}
881
882namespace MemberPointer {
883  struct A {
884    constexpr A(int n) : n(n) {}
885    int n;
886    constexpr int f() const { return n + 3; }
887  };
888  constexpr A a(7);
889  static_assert(A(5).*&A::n == 5, "");
890  static_assert((&a)->*&A::n == 7, "");
891  static_assert((A(8).*&A::f)() == 11, "");
892  static_assert(((&a)->*&A::f)() == 10, "");
893
894  struct B : A {
895    constexpr B(int n, int m) : A(n), m(m) {}
896    int m;
897    constexpr int g() const { return n + m + 1; }
898  };
899  constexpr B b(9, 13);
900  static_assert(B(4, 11).*&A::n == 4, "");
901  static_assert(B(4, 11).*&B::m == 11, "");
902  static_assert(B(4, 11).*(int(A::*))&B::m == 11, "");
903  static_assert((&b)->*&A::n == 9, "");
904  static_assert((&b)->*&B::m == 13, "");
905  static_assert((&b)->*(int(A::*))&B::m == 13, "");
906  static_assert((B(4, 11).*&A::f)() == 7, "");
907  static_assert((B(4, 11).*&B::g)() == 16, "");
908  static_assert((B(4, 11).*(int(A::*)()const)&B::g)() == 16, "");
909  static_assert(((&b)->*&A::f)() == 12, "");
910  static_assert(((&b)->*&B::g)() == 23, "");
911  static_assert(((&b)->*(int(A::*)()const)&B::g)() == 23, "");
912
913  struct S {
914    constexpr S(int m, int n, int (S::*pf)() const, int S::*pn) :
915      m(m), n(n), pf(pf), pn(pn) {}
916    constexpr S() : m(), n(), pf(&S::f), pn(&S::n) {}
917
918    constexpr int f() const { return this->*pn; }
919    virtual int g() const;
920
921    int m, n;
922    int (S::*pf)() const;
923    int S::*pn;
924  };
925
926  constexpr int S::*pm = &S::m;
927  constexpr int S::*pn = &S::n;
928  constexpr int (S::*pf)() const = &S::f;
929  constexpr int (S::*pg)() const = &S::g;
930
931  constexpr S s(2, 5, &S::f, &S::m);
932
933  static_assert((s.*&S::f)() == 2, "");
934  static_assert((s.*s.pf)() == 2, "");
935
936  static_assert(pf == &S::f, "");
937  static_assert(pf == s.*&S::pf, "");
938  static_assert(pm == &S::m, "");
939  static_assert(pm != pn, "");
940  static_assert(s.pn != pn, "");
941  static_assert(s.pn == pm, "");
942  static_assert(pg != nullptr, "");
943  static_assert(pf != nullptr, "");
944  static_assert((int S::*)nullptr == nullptr, "");
945  static_assert(pg == pg, ""); // expected-error {{constant expression}} expected-note {{comparison of pointer to virtual member function 'g' has unspecified value}}
946  static_assert(pf != pg, ""); // expected-error {{constant expression}} expected-note {{comparison of pointer to virtual member function 'g' has unspecified value}}
947
948  template<int n> struct T : T<n-1> {};
949  template<> struct T<0> { int n; };
950  template<> struct T<30> : T<29> { int m; };
951
952  T<17> t17;
953  T<30> t30;
954
955  constexpr int (T<10>::*deepn) = &T<0>::n;
956  static_assert(&(t17.*deepn) == &t17.n, "");
957  static_assert(deepn == &T<2>::n, "");
958
959  constexpr int (T<15>::*deepm) = (int(T<10>::*))&T<30>::m;
960  constexpr int *pbad = &(t17.*deepm); // expected-error {{constant expression}}
961  static_assert(&(t30.*deepm) == &t30.m, "");
962  static_assert(deepm == &T<50>::m, "");
963  static_assert(deepm != deepn, "");
964
965  constexpr T<5> *p17_5 = &t17;
966  constexpr T<13> *p17_13 = (T<13>*)p17_5;
967  constexpr T<23> *p17_23 = (T<23>*)p17_13; // expected-error {{constant expression}} expected-note {{cannot cast object of dynamic type 'T<17>' to type 'T<23>'}}
968  static_assert(&(p17_5->*(int(T<3>::*))deepn) == &t17.n, "");
969  static_assert(&(p17_13->*deepn) == &t17.n, "");
970  constexpr int *pbad2 = &(p17_13->*(int(T<9>::*))deepm); // expected-error {{constant expression}}
971
972  constexpr T<5> *p30_5 = &t30;
973  constexpr T<23> *p30_23 = (T<23>*)p30_5;
974  constexpr T<13> *p30_13 = p30_23;
975  static_assert(&(p30_5->*(int(T<3>::*))deepn) == &t30.n, "");
976  static_assert(&(p30_13->*deepn) == &t30.n, "");
977  static_assert(&(p30_23->*deepn) == &t30.n, "");
978  static_assert(&(p30_5->*(int(T<2>::*))deepm) == &t30.m, "");
979  static_assert(&(((T<17>*)p30_13)->*deepm) == &t30.m, "");
980  static_assert(&(p30_23->*deepm) == &t30.m, "");
981
982  struct Base { int n; };
983  template<int N> struct Mid : Base {};
984  struct Derived : Mid<0>, Mid<1> {};
985  static_assert(&Mid<0>::n == &Mid<1>::n, "");
986  static_assert((int Derived::*)(int Mid<0>::*)&Mid<0>::n !=
987                (int Derived::*)(int Mid<1>::*)&Mid<1>::n, "");
988  static_assert(&Mid<0>::n == (int Mid<0>::*)&Base::n, "");
989}
990
991namespace ArrayBaseDerived {
992
993  struct Base {
994    constexpr Base() {}
995    int n = 0;
996  };
997  struct Derived : Base {
998    constexpr Derived() {}
999    constexpr const int *f() const { return &n; }
1000  };
1001
1002  constexpr Derived a[10];
1003  constexpr Derived *pd3 = const_cast<Derived*>(&a[3]);
1004  constexpr Base *pb3 = const_cast<Derived*>(&a[3]);
1005  static_assert(pb3 == pd3, "");
1006
1007  // pb3 does not point to an array element.
1008  constexpr Base *pb4 = pb3 + 1; // ok, one-past-the-end pointer.
1009  constexpr int pb4n = pb4->n; // expected-error {{constant expression}} expected-note {{cannot access field of pointer past the end}}
1010  constexpr Base *err_pb5 = pb3 + 2; // expected-error {{constant expression}} expected-note {{cannot refer to element 2}} expected-note {{here}}
1011  constexpr int err_pb5n = err_pb5->n; // expected-error {{constant expression}} expected-note {{initializer of 'err_pb5' is not a constant expression}}
1012  constexpr Base *err_pb2 = pb3 - 1; // expected-error {{constant expression}} expected-note {{cannot refer to element -1}} expected-note {{here}}
1013  constexpr int err_pb2n = err_pb2->n; // expected-error {{constant expression}} expected-note {{initializer of 'err_pb2'}}
1014  constexpr Base *pb3a = pb4 - 1;
1015
1016  // pb4 does not point to a Derived.
1017  constexpr Derived *err_pd4 = (Derived*)pb4; // expected-error {{constant expression}} expected-note {{cannot access derived class of pointer past the end}}
1018  constexpr Derived *pd3a = (Derived*)pb3a;
1019  constexpr int pd3n = pd3a->n;
1020
1021  // pd3a still points to the Derived array.
1022  constexpr Derived *pd6 = pd3a + 3;
1023  static_assert(pd6 == &a[6], "");
1024  constexpr Derived *pd9 = pd6 + 3;
1025  constexpr Derived *pd10 = pd6 + 4;
1026  constexpr int pd9n = pd9->n; // ok
1027  constexpr int err_pd10n = pd10->n; // expected-error {{constant expression}} expected-note {{cannot access base class of pointer past the end}}
1028  constexpr int pd0n = pd10[-10].n;
1029  constexpr int err_pdminus1n = pd10[-11].n; // expected-error {{constant expression}} expected-note {{cannot refer to element -1 of}}
1030
1031  constexpr Base *pb9 = pd9;
1032  constexpr const int *(Base::*pfb)() const =
1033      static_cast<const int *(Base::*)() const>(&Derived::f);
1034  static_assert((pb9->*pfb)() == &a[9].n, "");
1035}
1036
1037namespace Complex {
1038
1039class complex {
1040  int re, im;
1041public:
1042  constexpr complex(int re = 0, int im = 0) : re(re), im(im) {}
1043  constexpr complex(const complex &o) : re(o.re), im(o.im) {}
1044  constexpr complex operator-() const { return complex(-re, -im); }
1045  friend constexpr complex operator+(const complex &l, const complex &r) {
1046    return complex(l.re + r.re, l.im + r.im);
1047  }
1048  friend constexpr complex operator-(const complex &l, const complex &r) {
1049    return l + -r;
1050  }
1051  friend constexpr complex operator*(const complex &l, const complex &r) {
1052    return complex(l.re * r.re - l.im * r.im, l.re * r.im + l.im * r.re);
1053  }
1054  friend constexpr bool operator==(const complex &l, const complex &r) {
1055    return l.re == r.re && l.im == r.im;
1056  }
1057  constexpr bool operator!=(const complex &r) const {
1058    return re != r.re || im != r.im;
1059  }
1060  constexpr int real() const { return re; }
1061  constexpr int imag() const { return im; }
1062};
1063
1064constexpr complex i = complex(0, 1);
1065constexpr complex k = (3 + 4*i) * (6 - 4*i);
1066static_assert(complex(1,0).real() == 1, "");
1067static_assert(complex(1,0).imag() == 0, "");
1068static_assert(((complex)1).imag() == 0, "");
1069static_assert(k.real() == 34, "");
1070static_assert(k.imag() == 12, "");
1071static_assert(k - 34 == 12*i, "");
1072static_assert((complex)1 == complex(1), "");
1073static_assert((complex)1 != complex(0, 1), "");
1074static_assert(complex(1) == complex(1), "");
1075static_assert(complex(1) != complex(0, 1), "");
1076constexpr complex makeComplex(int re, int im) { return complex(re, im); }
1077static_assert(makeComplex(1,0) == complex(1), "");
1078static_assert(makeComplex(1,0) != complex(0, 1), "");
1079
1080class complex_wrap : public complex {
1081public:
1082  constexpr complex_wrap(int re, int im = 0) : complex(re, im) {}
1083  constexpr complex_wrap(const complex_wrap &o) : complex(o) {}
1084};
1085
1086static_assert((complex_wrap)1 == complex(1), "");
1087static_assert((complex)1 != complex_wrap(0, 1), "");
1088static_assert(complex(1) == complex_wrap(1), "");
1089static_assert(complex_wrap(1) != complex(0, 1), "");
1090constexpr complex_wrap makeComplexWrap(int re, int im) {
1091  return complex_wrap(re, im);
1092}
1093static_assert(makeComplexWrap(1,0) == complex(1), "");
1094static_assert(makeComplexWrap(1,0) != complex(0, 1), "");
1095
1096}
1097
1098namespace PR11595 {
1099  struct A { constexpr bool operator==(int x) const { return true; } };
1100  struct B { B(); A& x; };
1101  static_assert(B().x == 3, "");  // expected-error {{constant expression}} expected-note {{non-literal type 'PR11595::B' cannot be used in a constant expression}}
1102
1103  constexpr bool f(int k) { // expected-error {{constexpr function never produces a constant expression}}
1104    return B().x == k; // expected-note {{non-literal type 'PR11595::B' cannot be used in a constant expression}}
1105  }
1106}
1107
1108namespace ExprWithCleanups {
1109  struct A { A(); ~A(); int get(); };
1110  constexpr int get(bool FromA) { return FromA ? A().get() : 1; }
1111  constexpr int n = get(false);
1112}
1113
1114namespace Volatile {
1115
1116volatile constexpr int n1 = 0; // expected-note {{here}}
1117volatile const int n2 = 0; // expected-note {{here}}
1118int n3 = 37; // expected-note {{declared here}}
1119
1120constexpr int m1 = n1; // expected-error {{constant expression}} expected-note {{read of volatile-qualified type 'const volatile int'}}
1121constexpr int m2 = n2; // expected-error {{constant expression}} expected-note {{read of volatile-qualified type 'const volatile int'}}
1122constexpr int m1b = const_cast<const int&>(n1); // expected-error {{constant expression}} expected-note {{read of volatile object 'n1'}}
1123constexpr int m2b = const_cast<const int&>(n2); // expected-error {{constant expression}} expected-note {{read of volatile object 'n2'}}
1124
1125struct T { int n; };
1126const T t = { 42 }; // expected-note {{declared here}}
1127
1128constexpr int f(volatile int &&r) {
1129  return r; // expected-note {{read of volatile-qualified type 'volatile int'}}
1130}
1131constexpr int g(volatile int &&r) {
1132  return const_cast<int&>(r); // expected-note {{read of volatile temporary is not allowed in a constant expression}}
1133}
1134struct S {
1135  int j : f(0); // expected-error {{constant expression}} expected-note {{in call to 'f(0)'}}
1136  int k : g(0); // expected-error {{constant expression}} expected-note {{temporary created here}} expected-note {{in call to 'g(0)'}}
1137  int l : n3; // expected-error {{constant expression}} expected-note {{read of non-const variable}}
1138  int m : t.n; // expected-error {{constant expression}} expected-note {{read of non-constexpr variable}}
1139};
1140
1141}
1142
1143namespace ExternConstexpr {
1144  extern constexpr int n = 0;
1145  extern constexpr int m; // expected-error {{constexpr variable declaration must be a definition}}
1146  void f() {
1147    extern constexpr int i; // expected-error {{constexpr variable declaration must be a definition}}
1148    constexpr int j = 0;
1149    constexpr int k; // expected-error {{default initialization of an object of const type}}
1150  }
1151}
1152
1153namespace ComplexConstexpr {
1154  constexpr _Complex float test1 = {};
1155  constexpr _Complex float test2 = {1};
1156  constexpr _Complex double test3 = {1,2};
1157  constexpr _Complex int test4 = {4};
1158  constexpr _Complex int test5 = 4;
1159  constexpr _Complex int test6 = {5,6};
1160  typedef _Complex float fcomplex;
1161  constexpr fcomplex test7 = fcomplex();
1162
1163  constexpr const double &t2r = __real test3;
1164  constexpr const double &t2i = __imag test3;
1165  static_assert(&t2r + 1 == &t2i, "");
1166  static_assert(t2r == 1.0, "");
1167  static_assert(t2i == 2.0, "");
1168  constexpr const double *t2p = &t2r;
1169  static_assert(t2p[-1] == 0.0, ""); // expected-error {{constant expr}} expected-note {{cannot refer to element -1 of array of 2 elements}}
1170  static_assert(t2p[0] == 1.0, "");
1171  static_assert(t2p[1] == 2.0, "");
1172  static_assert(t2p[2] == 0.0, ""); // expected-error {{constant expr}} expected-note {{one-past-the-end pointer}}
1173  static_assert(t2p[3] == 0.0, ""); // expected-error {{constant expr}} expected-note {{cannot refer to element 3 of array of 2 elements}}
1174  constexpr _Complex float *p = 0;
1175  constexpr float pr = __real *p; // expected-error {{constant expr}} expected-note {{cannot access real component of null}}
1176  constexpr float pi = __imag *p; // expected-error {{constant expr}} expected-note {{cannot access imaginary component of null}}
1177  constexpr const _Complex double *q = &test3 + 1;
1178  constexpr double qr = __real *q; // expected-error {{constant expr}} expected-note {{cannot access real component of pointer past the end}}
1179  constexpr double qi = __imag *q; // expected-error {{constant expr}} expected-note {{cannot access imaginary component of pointer past the end}}
1180
1181  static_assert(__real test6 == 5, "");
1182  static_assert(__imag test6 == 6, "");
1183  static_assert(&__imag test6 == &__real test6 + 1, "");
1184}
1185
1186// _Atomic(T) is exactly like T for the purposes of constant expression
1187// evaluation..
1188namespace Atomic {
1189  constexpr _Atomic int n = 3;
1190
1191  struct S { _Atomic(double) d; };
1192  constexpr S s = { 0.5 };
1193  constexpr double d1 = s.d;
1194  constexpr double d2 = n;
1195  constexpr _Atomic double d3 = n;
1196
1197  constexpr _Atomic(int) n2 = d3;
1198  static_assert(d1 == 0.5, "");
1199  static_assert(d3 == 3.0, "");
1200
1201  namespace PR16056 {
1202    struct TestVar {
1203      _Atomic(int) value;
1204      constexpr TestVar(int value) : value(value) {}
1205    };
1206    constexpr TestVar testVar{-1};
1207    static_assert(testVar.value == -1, "");
1208  }
1209}
1210
1211namespace InstantiateCaseStmt {
1212  template<int x> constexpr int f() { return x; }
1213  template<int x> int g(int c) { switch(c) { case f<x>(): return 1; } return 0; }
1214  int gg(int c) { return g<4>(c); }
1215}
1216
1217namespace ConvertedConstantExpr {
1218  extern int &m;
1219  extern int &n;
1220
1221  constexpr int k = 4;
1222  int &m = const_cast<int&>(k);
1223
1224  // If we have nothing more interesting to say, ensure we don't produce a
1225  // useless note and instead just point to the non-constant subexpression.
1226  enum class E {
1227    em = m,
1228    en = n, // expected-error {{not a constant expression}}
1229    eo = (m +
1230          n // expected-error {{not a constant expression}}
1231          ),
1232    eq = reinterpret_cast<int>((int*)0) // expected-error {{not a constant expression}} expected-note {{reinterpret_cast}}
1233  };
1234}
1235
1236namespace IndirectField {
1237  struct S {
1238    struct { // expected-warning {{GNU extension}}
1239      union { // expected-warning {{declared in an anonymous struct}}
1240        struct { // expected-warning {{GNU extension}} expected-warning {{declared in an anonymous union}}
1241          int a;
1242          int b;
1243        };
1244        int c;
1245      };
1246      int d;
1247    };
1248    union {
1249      int e;
1250      int f;
1251    };
1252    constexpr S(int a, int b, int d, int e) : a(a), b(b), d(d), e(e) {}
1253    constexpr S(int c, int d, int f) : c(c), d(d), f(f) {}
1254  };
1255
1256  constexpr S s1(1, 2, 3, 4);
1257  constexpr S s2(5, 6, 7);
1258
1259  // FIXME: The diagnostics here do a very poor job of explaining which unnamed
1260  // member is active and which is requested.
1261  static_assert(s1.a == 1, "");
1262  static_assert(s1.b == 2, "");
1263  static_assert(s1.c == 0, ""); // expected-error {{constant expression}} expected-note {{union with active member}}
1264  static_assert(s1.d == 3, "");
1265  static_assert(s1.e == 4, "");
1266  static_assert(s1.f == 0, ""); // expected-error {{constant expression}} expected-note {{union with active member}}
1267
1268  static_assert(s2.a == 0, ""); // expected-error {{constant expression}} expected-note {{union with active member}}
1269  static_assert(s2.b == 0, ""); // expected-error {{constant expression}} expected-note {{union with active member}}
1270  static_assert(s2.c == 5, "");
1271  static_assert(s2.d == 6, "");
1272  static_assert(s2.e == 0, ""); // expected-error {{constant expression}} expected-note {{union with active member}}
1273  static_assert(s2.f == 7, "");
1274}
1275
1276// DR1405: don't allow reading mutable members in constant expressions.
1277namespace MutableMembers {
1278  struct MM {
1279    mutable int n; // expected-note 3{{declared here}}
1280  } constexpr mm = { 4 };
1281  constexpr int mmn = mm.n; // expected-error {{constant expression}} expected-note {{read of mutable member 'n' is not allowed in a constant expression}}
1282  int x = (mm.n = 1, 3);
1283  constexpr int mmn2 = mm.n; // expected-error {{constant expression}} expected-note {{read of mutable member 'n' is not allowed in a constant expression}}
1284
1285  // Here's one reason why allowing this would be a disaster...
1286  template<int n> struct Id { int k = n; };
1287  int f() {
1288    constexpr MM m = { 0 };
1289    ++m.n;
1290    return Id<m.n>().k; // expected-error {{not a constant expression}} expected-note {{read of mutable member 'n' is not allowed in a constant expression}}
1291  }
1292
1293  struct A { int n; };
1294  struct B { mutable A a; }; // expected-note {{here}}
1295  struct C { B b; };
1296  constexpr C c[3] = {};
1297  constexpr int k = c[1].b.a.n; // expected-error {{constant expression}} expected-note {{mutable}}
1298}
1299
1300namespace Fold {
1301
1302  // This macro forces its argument to be constant-folded, even if it's not
1303  // otherwise a constant expression.
1304  #define fold(x) (__builtin_constant_p(x) ? (x) : (x))
1305
1306  constexpr int n = (int)(char*)123; // expected-error {{constant expression}} expected-note {{reinterpret_cast}}
1307  constexpr int m = fold((int)(char*)123); // ok
1308  static_assert(m == 123, "");
1309
1310  #undef fold
1311
1312}
1313
1314namespace DR1454 {
1315
1316constexpr const int &f(const int &n) { return n; }
1317constexpr int k1 = f(0); // ok
1318
1319struct Wrap {
1320  const int &value;
1321};
1322constexpr const Wrap &g(const Wrap &w) { return w; }
1323constexpr int k2 = g({0}).value; // ok
1324
1325// The temporary here has static storage duration, so we can bind a constexpr
1326// reference to it.
1327constexpr const int &i = 1;
1328constexpr const int j = i;
1329static_assert(j == 1, "");
1330
1331// The temporary here is not const, so it can't be read outside the expression
1332// in which it was created (per the C++14 rules, which we use to avoid a C++11
1333// defect).
1334constexpr int &&k = 1; // expected-note {{temporary created here}}
1335constexpr const int l = k; // expected-error {{constant expression}} expected-note {{read of temporary}}
1336
1337void f() {
1338  // The temporary here has automatic storage duration, so we can't bind a
1339  // constexpr reference to it.
1340  constexpr const int &i = 1; // expected-error {{constant expression}} expected-note 2{{temporary}}
1341}
1342
1343}
1344
1345namespace RecursiveOpaqueExpr {
1346  template<typename Iter>
1347  constexpr auto LastNonzero(Iter p, Iter q) -> decltype(+*p) {
1348    return p != q ? (LastNonzero(p+1, q) ?: *p) : 0; // expected-warning {{GNU}}
1349  }
1350
1351  constexpr int arr1[] = { 1, 0, 0, 3, 0, 2, 0, 4, 0, 0 };
1352  static_assert(LastNonzero(begin(arr1), end(arr1)) == 4, "");
1353
1354  constexpr int arr2[] = { 1, 0, 0, 3, 0, 2, 0, 4, 0, 5 };
1355  static_assert(LastNonzero(begin(arr2), end(arr2)) == 5, "");
1356
1357  constexpr int arr3[] = {
1358    1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0,
1359    1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0,
1360    1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0,
1361    1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0,
1362    1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0,
1363    1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0,
1364    1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0,
1365    2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
1366  static_assert(LastNonzero(begin(arr3), end(arr3)) == 2, "");
1367}
1368
1369namespace VLASizeof {
1370
1371  void f(int k) {
1372    int arr[k]; // expected-warning {{C99}}
1373    constexpr int n = 1 +
1374        sizeof(arr) // expected-error {{constant expression}}
1375        * 3;
1376  }
1377}
1378
1379namespace CompoundLiteral {
1380  // FIXME:
1381  // We don't model the semantics of this correctly: the compound literal is
1382  // represented as a prvalue in the AST, but actually behaves like an lvalue.
1383  // We treat the compound literal as a temporary and refuse to produce a
1384  // pointer to it. This is OK: we're not required to treat this as a constant
1385  // in C++, and in C we model compound literals as lvalues.
1386  constexpr int *p = (int*)(int[1]){0}; // expected-warning {{C99}} expected-error {{constant expression}} expected-note 2{{temporary}}
1387}
1388
1389namespace Vector {
1390  typedef int __attribute__((vector_size(16))) VI4;
1391  constexpr VI4 f(int n) {
1392    return VI4 { n * 3, n + 4, n - 5, n / 6 };
1393  }
1394  constexpr auto v1 = f(10);
1395
1396  typedef double __attribute__((vector_size(32))) VD4;
1397  constexpr VD4 g(int n) {
1398    return (VD4) { n / 2.0, n + 1.5, n - 5.4, n * 0.9 }; // expected-warning {{C99}}
1399  }
1400  constexpr auto v2 = g(4);
1401}
1402
1403// PR12626, redux
1404namespace InvalidClasses {
1405  void test0() {
1406    struct X; // expected-note {{forward declaration}}
1407    struct Y { bool b; X x; }; // expected-error {{field has incomplete type}}
1408    Y y;
1409    auto& b = y.b;
1410  }
1411}
1412
1413namespace NamespaceAlias {
1414  constexpr int f() {
1415    namespace NS = NamespaceAlias; // expected-warning {{use of this statement in a constexpr function is a C++1y extension}}
1416    return &NS::f != nullptr;
1417  }
1418}
1419
1420// Constructors can be implicitly constexpr, even for a non-literal type.
1421namespace ImplicitConstexpr {
1422  struct Q { Q() = default; Q(const Q&) = default; Q(Q&&) = default; ~Q(); }; // expected-note 3{{here}}
1423  struct R { constexpr R() noexcept; constexpr R(const R&) noexcept; constexpr R(R&&) noexcept; ~R() noexcept; };
1424  struct S { R r; }; // expected-note 3{{here}}
1425  struct T { T(const T&) noexcept; T(T &&) noexcept; ~T() noexcept; };
1426  struct U { T t; }; // expected-note 3{{here}}
1427  static_assert(!__is_literal_type(Q), "");
1428  static_assert(!__is_literal_type(R), "");
1429  static_assert(!__is_literal_type(S), "");
1430  static_assert(!__is_literal_type(T), "");
1431  static_assert(!__is_literal_type(U), "");
1432  struct Test {
1433    friend Q::Q() noexcept; // expected-error {{follows constexpr}}
1434    friend Q::Q(Q&&) noexcept; // expected-error {{follows constexpr}}
1435    friend Q::Q(const Q&) noexcept; // expected-error {{follows constexpr}}
1436    friend S::S() noexcept; // expected-error {{follows constexpr}}
1437    friend S::S(S&&) noexcept; // expected-error {{follows constexpr}}
1438    friend S::S(const S&) noexcept; // expected-error {{follows constexpr}}
1439    friend constexpr U::U() noexcept; // expected-error {{follows non-constexpr}}
1440    friend constexpr U::U(U&&) noexcept; // expected-error {{follows non-constexpr}}
1441    friend constexpr U::U(const U&) noexcept; // expected-error {{follows non-constexpr}}
1442  };
1443}
1444
1445// Indirectly test that an implicit lvalue to xvalue conversion performed for
1446// an NRVO move operation isn't implemented as CK_LValueToRValue.
1447namespace PR12826 {
1448  struct Foo {};
1449  constexpr Foo id(Foo x) { return x; }
1450  constexpr Foo res(id(Foo()));
1451}
1452
1453namespace PR13273 {
1454  struct U {
1455    int t;
1456    U() = default;
1457  };
1458
1459  struct S : U {
1460    S() = default;
1461  };
1462
1463  // S's default constructor isn't constexpr, because U's default constructor
1464  // doesn't initialize 't', but it's trivial, so value-initialization doesn't
1465  // actually call it.
1466  static_assert(S{}.t == 0, "");
1467}
1468
1469namespace PR12670 {
1470  struct S {
1471    constexpr S(int a0) : m(a0) {}
1472    constexpr S() : m(6) {}
1473    int m;
1474  };
1475  constexpr S x[3] = { {4}, 5 };
1476  static_assert(x[0].m == 4, "");
1477  static_assert(x[1].m == 5, "");
1478  static_assert(x[2].m == 6, "");
1479}
1480
1481// Indirectly test that an implicit lvalue-to-rvalue conversion is performed
1482// when a conditional operator has one argument of type void and where the other
1483// is a glvalue of class type.
1484namespace ConditionalLValToRVal {
1485  struct A {
1486    constexpr A(int a) : v(a) {}
1487    int v;
1488  };
1489
1490  constexpr A f(const A &a) {
1491    return a.v == 0 ? throw a : a;
1492  }
1493
1494  constexpr A a(4);
1495  static_assert(f(a).v == 4, "");
1496}
1497
1498namespace TLS {
1499  __thread int n;
1500  int m;
1501
1502  constexpr bool b = &n == &n;
1503
1504  constexpr int *p = &n; // expected-error{{constexpr variable 'p' must be initialized by a constant expression}}
1505
1506  constexpr int *f() { return &n; }
1507  constexpr int *q = f(); // expected-error{{constexpr variable 'q' must be initialized by a constant expression}}
1508  constexpr bool c = f() == f();
1509
1510  constexpr int *g() { return &m; }
1511  constexpr int *r = g();
1512}
1513
1514namespace Void {
1515  constexpr void f() { return; } // expected-error{{constexpr function's return type 'void' is not a literal type}}
1516
1517  void assert_failed(const char *msg, const char *file, int line); // expected-note {{declared here}}
1518#define ASSERT(expr) ((expr) ? static_cast<void>(0) : assert_failed(#expr, __FILE__, __LINE__))
1519  template<typename T, size_t S>
1520  constexpr T get(T (&a)[S], size_t k) {
1521    return ASSERT(k > 0 && k < S), a[k]; // expected-note{{non-constexpr function 'assert_failed'}}
1522  }
1523#undef ASSERT
1524  template int get(int (&a)[4], size_t);
1525  constexpr int arr[] = { 4, 1, 2, 3, 4 };
1526  static_assert(get(arr, 1) == 1, "");
1527  static_assert(get(arr, 4) == 4, "");
1528  static_assert(get(arr, 0) == 4, ""); // expected-error{{not an integral constant expression}} \
1529  // expected-note{{in call to 'get(arr, 0)'}}
1530}
1531
1532namespace std { struct type_info; }
1533
1534namespace TypeId {
1535  struct A { virtual ~A(); };
1536  A f();
1537  A &g();
1538  constexpr auto &x = typeid(f());
1539  constexpr auto &y = typeid(g()); // expected-error{{constant expression}} \
1540  // expected-note{{typeid applied to expression of polymorphic type 'TypeId::A' is not allowed in a constant expression}}
1541}
1542
1543namespace PR14203 {
1544  struct duration {
1545    constexpr duration() {}
1546    constexpr operator int() const { return 0; }
1547  };
1548  template<typename T> void f() {
1549    // If we want to evaluate this at the point of the template definition, we
1550    // need to trigger the implicit definition of the move constructor at that
1551    // point.
1552    // FIXME: C++ does not permit us to implicitly define it at the appropriate
1553    // times, since it is only allowed to be implicitly defined when it is
1554    // odr-used.
1555    constexpr duration d = duration();
1556  }
1557  // FIXME: It's unclear whether this is valid. On the one hand, we're not
1558  // allowed to generate a move constructor. On the other hand, if we did,
1559  // this would be a constant expression. For now, we generate a move
1560  // constructor here.
1561  int n = sizeof(short{duration(duration())});
1562}
1563
1564namespace ArrayEltInit {
1565  struct A {
1566    constexpr A() : p(&p) {}
1567    void *p;
1568  };
1569  constexpr A a[10];
1570  static_assert(a[0].p == &a[0].p, "");
1571  static_assert(a[9].p == &a[9].p, "");
1572  static_assert(a[0].p != &a[9].p, "");
1573  static_assert(a[9].p != &a[0].p, "");
1574
1575  constexpr A b[10] = {};
1576  static_assert(b[0].p == &b[0].p, "");
1577  static_assert(b[9].p == &b[9].p, "");
1578  static_assert(b[0].p != &b[9].p, "");
1579  static_assert(b[9].p != &b[0].p, "");
1580}
1581
1582namespace PR15884 {
1583  struct S {};
1584  constexpr S f() { return {}; }
1585  constexpr S *p = &f();
1586  // expected-error@-1 {{taking the address of a temporary}}
1587  // expected-error@-2 {{constexpr variable 'p' must be initialized by a constant expression}}
1588  // expected-note@-3 {{pointer to temporary is not a constant expression}}
1589  // expected-note@-4 {{temporary created here}}
1590}
1591
1592namespace AfterError {
1593  // FIXME: Suppress the 'no return statements' diagnostic if the body is invalid.
1594  constexpr int error() { // expected-error {{no return statement}}
1595    return foobar; // expected-error {{undeclared identifier}}
1596  }
1597  constexpr int k = error(); // expected-error {{must be initialized by a constant expression}}
1598}
1599
1600namespace std {
1601  typedef decltype(sizeof(int)) size_t;
1602
1603  template <class _E>
1604  class initializer_list
1605  {
1606    const _E* __begin_;
1607    size_t    __size_;
1608
1609    constexpr initializer_list(const _E* __b, size_t __s)
1610      : __begin_(__b),
1611        __size_(__s)
1612    {}
1613
1614  public:
1615    typedef _E        value_type;
1616    typedef const _E& reference;
1617    typedef const _E& const_reference;
1618    typedef size_t    size_type;
1619
1620    typedef const _E* iterator;
1621    typedef const _E* const_iterator;
1622
1623    constexpr initializer_list() : __begin_(nullptr), __size_(0) {}
1624
1625    constexpr size_t    size()  const {return __size_;}
1626    constexpr const _E* begin() const {return __begin_;}
1627    constexpr const _E* end()   const {return __begin_ + __size_;}
1628  };
1629}
1630
1631namespace InitializerList {
1632  constexpr int sum(const int *b, const int *e) {
1633    return b != e ? *b + sum(b+1, e) : 0;
1634  }
1635  constexpr int sum(std::initializer_list<int> ints) {
1636    return sum(ints.begin(), ints.end());
1637  }
1638  static_assert(sum({1, 2, 3, 4, 5}) == 15, "");
1639}
1640