constant-expression-cxx11.cpp revision 5705f211472f19fc38e58d81365f9261024b3ba3 
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
342}
343
344constexpr int strcmp_ce(const char *p, const char *q) {
345  return (!*p || *p != *q) ? *p - *q : strcmp_ce(p+1, q+1);
346}
347
348namespace StringLiteral {
349
350template<typename Char>
351constexpr int MangleChars(const Char *p) {
352  return *p + 3 * (*p ? MangleChars(p+1) : 0);
353}
354
355static_assert(MangleChars("constexpr!") == 1768383, "");
356static_assert(MangleChars(u8"constexpr!") == 1768383, "");
357static_assert(MangleChars(L"constexpr!") == 1768383, "");
358static_assert(MangleChars(u"constexpr!") == 1768383, "");
359static_assert(MangleChars(U"constexpr!") == 1768383, "");
360
361constexpr char c0 = "nought index"[0];
362constexpr char c1 = "nice index"[10];
363constexpr 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}}
364constexpr 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}}
365constexpr 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}}
366
367constexpr const char *p = "test" + 2;
368static_assert(*p == 's', "");
369
370constexpr const char *max_iter(const char *a, const char *b) {
371  return *a < *b ? b : a;
372}
373constexpr const char *max_element(const char *a, const char *b) {
374  return (a+1 >= b) ? a : max_iter(a, max_element(a+1, b));
375}
376
377constexpr char str[] = "the quick brown fox jumped over the lazy dog";
378constexpr const char *max = max_element(begin(str), end(str));
379static_assert(*max == 'z', "");
380static_assert(max == str + 38, "");
381
382static_assert(strcmp_ce("hello world", "hello world") == 0, "");
383static_assert(strcmp_ce("hello world", "hello clang") > 0, "");
384static_assert(strcmp_ce("constexpr", "test") < 0, "");
385static_assert(strcmp_ce("", " ") < 0, "");
386
387struct S {
388  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}}
389};
390
391struct T {
392  char c[6];
393  constexpr T() : c{"foo"} {}
394};
395constexpr T t;
396
397static_assert(t.c[0] == 'f', "");
398static_assert(t.c[1] == 'o', "");
399static_assert(t.c[2] == 'o', "");
400static_assert(t.c[3] == 0, "");
401static_assert(t.c[4] == 0, "");
402static_assert(t.c[5] == 0, "");
403static_assert(t.c[6] == 0, ""); // expected-error {{constant expression}} expected-note {{one-past-the-end}}
404
405struct U {
406  wchar_t chars[6];
407  int n;
408} constexpr u = { { L"test" }, 0 };
409static_assert(u.chars[2] == L's', "");
410
411struct V {
412  char c[4];
413  constexpr V() : c("hi!") {}
414};
415static_assert(V().c[1] == "i"[0], "");
416
417namespace Parens {
418  constexpr unsigned char a[] = ("foo"), b[] = {"foo"}, c[] = {("foo")},
419                          d[4] = ("foo"), e[5] = {"foo"}, f[6] = {("foo")};
420  static_assert(a[0] == 'f', "");
421  static_assert(b[1] == 'o', "");
422  static_assert(c[2] == 'o', "");
423  static_assert(d[0] == 'f', "");
424  static_assert(e[1] == 'o', "");
425  static_assert(f[2] == 'o', "");
426  static_assert(f[5] == 0, "");
427  static_assert(f[6] == 0, ""); // expected-error {{constant expression}} expected-note {{one-past-the-end}}
428}
429
430}
431
432namespace Array {
433
434template<typename Iter>
435constexpr auto Sum(Iter begin, Iter end) -> decltype(+*begin) {
436  return begin == end ? 0 : *begin + Sum(begin+1, end);
437}
438
439constexpr int xs[] = { 1, 2, 3, 4, 5 };
440constexpr int ys[] = { 5, 4, 3, 2, 1 };
441constexpr int sum_xs = Sum(begin(xs), end(xs));
442static_assert(sum_xs == 15, "");
443
444constexpr int ZipFoldR(int (*F)(int x, int y, int c), int n,
445                       const int *xs, const int *ys, int c) {
446  return n ? F(
447               *xs, // expected-note {{read of dereferenced one-past-the-end pointer}}
448               *ys,
449               ZipFoldR(F, n-1, xs+1, ys+1, c)) // \
450      expected-note {{in call to 'ZipFoldR(&SubMul, 2, &xs[4], &ys[4], 1)'}} \
451      expected-note {{in call to 'ZipFoldR(&SubMul, 1, &xs[5], &ys[5], 1)'}}
452           : c;
453}
454constexpr int MulAdd(int x, int y, int c) { return x * y + c; }
455constexpr int InnerProduct = ZipFoldR(MulAdd, 5, xs, ys, 0);
456static_assert(InnerProduct == 35, "");
457
458constexpr int SubMul(int x, int y, int c) { return (x - y) * c; }
459constexpr int DiffProd = ZipFoldR(SubMul, 2, xs+3, ys+3, 1);
460static_assert(DiffProd == 8, "");
461static_assert(ZipFoldR(SubMul, 3, xs+3, ys+3, 1), ""); // \
462      expected-error {{constant expression}} \
463      expected-note {{in call to 'ZipFoldR(&SubMul, 3, &xs[3], &ys[3], 1)'}}
464
465constexpr const int *p = xs + 3;
466constexpr int xs4 = p[1]; // ok
467constexpr int xs5 = p[2]; // expected-error {{constant expression}} expected-note {{read of dereferenced one-past-the-end pointer}}
468constexpr int xs6 = p[3]; // expected-error {{constant expression}} expected-note {{cannot refer to element 6}}
469constexpr int xs0 = p[-3]; // ok
470constexpr int xs_1 = p[-4]; // expected-error {{constant expression}} expected-note {{cannot refer to element -1}}
471
472constexpr int zs[2][2][2][2] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
473static_assert(zs[0][0][0][0] == 1, "");
474static_assert(zs[1][1][1][1] == 16, "");
475static_assert(zs[0][0][0][2] == 3, ""); // expected-error {{constant expression}} expected-note {{read of dereferenced one-past-the-end pointer}}
476static_assert((&zs[0][0][0][2])[-1] == 2, "");
477static_assert(**(**(zs + 1) + 1) == 11, "");
478static_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}}
479static_assert(*(&(&(*(*&(&zs[2] - 1)[0] + 2 - 2))[2])[-1][2] - 2) == 11, "");
480constexpr 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}}
481
482constexpr int fail(const int &p) {
483  return (&p)[64]; // expected-note {{cannot refer to element 64 of array of 2 elements}}
484}
485static_assert(fail(*(&(&(*(*&(&zs[2] - 1)[0] + 2 - 2))[2])[-1][2] - 2)) == 11, ""); // \
486expected-error {{static_assert expression is not an integral constant expression}} \
487expected-note {{in call to 'fail(zs[1][0][1][0])'}}
488
489constexpr int arr[40] = { 1, 2, 3, [8] = 4 }; // expected-warning {{C99 feature}}
490constexpr int SumNonzero(const int *p) {
491  return *p + (*p ? SumNonzero(p+1) : 0);
492}
493constexpr int CountZero(const int *p, const int *q) {
494  return p == q ? 0 : (*p == 0) + CountZero(p+1, q);
495}
496static_assert(SumNonzero(arr) == 6, "");
497static_assert(CountZero(arr, arr + 40) == 36, "");
498
499struct ArrayElem {
500  constexpr ArrayElem() : n(0) {}
501  int n;
502  constexpr int f() const { return n; }
503};
504struct ArrayRVal {
505  constexpr ArrayRVal() {}
506  ArrayElem elems[10];
507};
508static_assert(ArrayRVal().elems[3].f() == 0, "");
509
510constexpr int selfref[2][2][2] = {
511  selfref[1][1][1] + 1, selfref[0][0][0] + 1,
512  selfref[1][0][1] + 1, selfref[0][1][0] + 1,
513  selfref[1][0][0] + 1, selfref[0][1][1] + 1 };
514static_assert(selfref[0][0][0] == 1, "");
515static_assert(selfref[0][0][1] == 2, "");
516static_assert(selfref[0][1][0] == 1, "");
517static_assert(selfref[0][1][1] == 2, "");
518static_assert(selfref[1][0][0] == 1, "");
519static_assert(selfref[1][0][1] == 3, "");
520static_assert(selfref[1][1][0] == 0, "");
521static_assert(selfref[1][1][1] == 0, "");
522
523struct TrivialDefCtor { int n; };
524typedef TrivialDefCtor TDCArray[2][2];
525static_assert(TDCArray{}[1][1].n == 0, "");
526
527struct NonAggregateTDC : TrivialDefCtor {};
528typedef NonAggregateTDC NATDCArray[2][2];
529static_assert(NATDCArray{}[1][1].n == 0, "");
530
531}
532
533namespace DependentValues {
534
535struct I { int n; typedef I V[10]; };
536I::V x, y;
537int g();
538template<bool B, typename T> struct S : T {
539  int k;
540  void f() {
541    I::V &cells = B ? x : y;
542    I &i = cells[k];
543    switch (i.n) {}
544
545    // FIXME: We should be able to diagnose this.
546    constexpr int n = g();
547
548    constexpr int m = this->g(); // ok, could be constexpr
549  }
550};
551
552}
553
554namespace Class {
555
556struct A { constexpr A(int a, int b) : k(a + b) {} int k; };
557constexpr int fn(const A &a) { return a.k; }
558static_assert(fn(A(4,5)) == 9, "");
559
560struct B { int n; int m; } constexpr b = { 0, b.n }; // expected-warning {{uninitialized}}
561struct C {
562  constexpr C(C *this_) : m(42), n(this_->m) {} // ok
563  int m, n;
564};
565struct D {
566  C c;
567  constexpr D() : c(&c) {}
568};
569static_assert(D().c.n == 42, "");
570
571struct E {
572  constexpr E() : p(&p) {}
573  void *p;
574};
575constexpr const E &e1 = E(); // expected-error {{constant expression}} expected-note {{reference to temporary is not a constant expression}} expected-note {{temporary created here}}
576// This is a constant expression if we elide the copy constructor call, and
577// is not a constant expression if we don't! But we do, so it is.
578constexpr E e2 = E();
579static_assert(e2.p == &e2.p, "");
580constexpr E e3;
581static_assert(e3.p == &e3.p, "");
582
583extern const class F f;
584struct F {
585  constexpr F() : p(&f.p) {}
586  const void *p;
587};
588constexpr F f;
589
590struct G {
591  struct T {
592    constexpr T(T *p) : u1(), u2(p) {}
593    union U1 {
594      constexpr U1() {}
595      int a, b = 42;
596    } u1;
597    union U2 {
598      constexpr U2(T *p) : c(p->u1.b) {}
599      int c, d;
600    } u2;
601  } t;
602  constexpr G() : t(&t) {}
603} constexpr g;
604
605static_assert(g.t.u1.a == 42, ""); // expected-error {{constant expression}} expected-note {{read of member 'a' of union with active member 'b'}}
606static_assert(g.t.u1.b == 42, "");
607static_assert(g.t.u2.c == 42, "");
608static_assert(g.t.u2.d == 42, ""); // expected-error {{constant expression}} expected-note {{read of member 'd' of union with active member 'c'}}
609
610struct S {
611  int a, b;
612  const S *p;
613  double d;
614  const char *q;
615
616  constexpr S(int n, const S *p) : a(5), b(n), p(p), d(n), q("hello") {}
617};
618
619S global(43, &global);
620
621static_assert(S(15, &global).b == 15, "");
622
623constexpr bool CheckS(const S &s) {
624  return s.a == 5 && s.b == 27 && s.p == &global && s.d == 27. && s.q[3] == 'l';
625}
626static_assert(CheckS(S(27, &global)), "");
627
628struct Arr {
629  char arr[3];
630  constexpr Arr() : arr{'x', 'y', 'z'} {}
631};
632constexpr int hash(Arr &&a) {
633  return a.arr[0] + a.arr[1] * 0x100 + a.arr[2] * 0x10000;
634}
635constexpr int k = hash(Arr());
636static_assert(k == 0x007a7978, "");
637
638
639struct AggregateInit {
640  const char &c;
641  int n;
642  double d;
643  int arr[5];
644  void *p;
645};
646
647constexpr AggregateInit agg1 = { "hello"[0] };
648
649static_assert(strcmp_ce(&agg1.c, "hello") == 0, "");
650static_assert(agg1.n == 0, "");
651static_assert(agg1.d == 0.0, "");
652static_assert(agg1.arr[-1] == 0, ""); // expected-error {{constant expression}} expected-note {{cannot refer to element -1}}
653static_assert(agg1.arr[0] == 0, "");
654static_assert(agg1.arr[4] == 0, "");
655static_assert(agg1.arr[5] == 0, ""); // expected-error {{constant expression}} expected-note {{read of dereferenced one-past-the-end}}
656static_assert(agg1.p == nullptr, "");
657
658static constexpr const unsigned char uc[] = { "foo" };
659static_assert(uc[0] == 'f', "");
660static_assert(uc[3] == 0, "");
661
662namespace SimpleDerivedClass {
663
664struct B {
665  constexpr B(int n) : a(n) {}
666  int a;
667};
668struct D : B {
669  constexpr D(int n) : B(n) {}
670};
671constexpr D d(3);
672static_assert(d.a == 3, "");
673
674}
675
676struct Bottom { constexpr Bottom() {} };
677struct Base : Bottom {
678  constexpr Base(int a = 42, const char *b = "test") : a(a), b(b) {}
679  int a;
680  const char *b;
681};
682struct Base2 : Bottom {
683  constexpr Base2(const int &r) : r(r) {}
684  int q = 123;
685  const int &r;
686};
687struct Derived : Base, Base2 {
688  constexpr Derived() : Base(76), Base2(a) {}
689  int c = r + b[1];
690};
691
692constexpr bool operator==(const Base &a, const Base &b) {
693  return a.a == b.a && strcmp_ce(a.b, b.b) == 0;
694}
695
696constexpr Base base;
697constexpr Base base2(76);
698constexpr Derived derived;
699static_assert(derived.a == 76, "");
700static_assert(derived.b[2] == 's', "");
701static_assert(derived.c == 76 + 'e', "");
702static_assert(derived.q == 123, "");
703static_assert(derived.r == 76, "");
704static_assert(&derived.r == &derived.a, "");
705
706static_assert(!(derived == base), "");
707static_assert(derived == base2, "");
708
709constexpr Bottom &bot1 = (Base&)derived;
710constexpr Bottom &bot2 = (Base2&)derived;
711static_assert(&bot1 != &bot2, "");
712
713constexpr Bottom *pb1 = (Base*)&derived;
714constexpr Bottom *pb2 = (Base2*)&derived;
715static_assert(&pb1 != &pb2, "");
716static_assert(pb1 == &bot1, "");
717static_assert(pb2 == &bot2, "");
718
719constexpr Base2 &fail = (Base2&)bot1; // expected-error {{constant expression}} expected-note {{cannot cast object of dynamic type 'const Class::Derived' to type 'Class::Base2'}}
720constexpr Base &fail2 = (Base&)*pb2; // expected-error {{constant expression}} expected-note {{cannot cast object of dynamic type 'const Class::Derived' to type 'Class::Base'}}
721constexpr Base2 &ok2 = (Base2&)bot2;
722static_assert(&ok2 == &derived, "");
723
724constexpr Base2 *pfail = (Base2*)pb1; // expected-error {{constant expression}} expected-note {{cannot cast object of dynamic type 'const Class::Derived' to type 'Class::Base2'}}
725constexpr Base *pfail2 = (Base*)&bot2; // expected-error {{constant expression}} expected-note {{cannot cast object of dynamic type 'const Class::Derived' to type 'Class::Base'}}
726constexpr Base2 *pok2 = (Base2*)pb2;
727static_assert(pok2 == &derived, "");
728static_assert(&ok2 == pok2, "");
729static_assert((Base2*)(Derived*)(Base*)pb1 == pok2, "");
730static_assert((Derived*)(Base*)pb1 == (Derived*)pok2, "");
731
732constexpr Base *nullB = 42 - 6 * 7; // expected-warning {{expression which evaluates to zero treated as a null pointer constant of type 'Class::Base *const'}}
733static_assert((Bottom*)nullB == 0, "");
734static_assert((Derived*)nullB == 0, "");
735static_assert((void*)(Bottom*)nullB == (void*)(Derived*)nullB, "");
736Base * nullB2 = '\0'; // expected-warning {{expression which evaluates to zero treated as a null pointer constant of type 'Class::Base *'}}
737Base * nullB3 = (0);
738// We suppress the warning in unevaluated contexts to workaround some gtest
739// behavior. Once this becomes an error this isn't a problem anymore.
740static_assert(nullB == (1 - 1), "");
741
742
743namespace ConversionOperators {
744
745struct T {
746  constexpr T(int n) : k(5*n - 3) {}
747  constexpr operator int() const { return k; }
748  int k;
749};
750
751struct S {
752  constexpr S(int n) : k(2*n + 1) {}
753  constexpr operator int() const { return k; }
754  constexpr operator T() const { return T(k); }
755  int k;
756};
757
758constexpr bool check(T a, T b) { return a == b.k; }
759
760static_assert(S(5) == 11, "");
761static_assert(check(S(5), 11), "");
762
763namespace PR14171 {
764
765struct X {
766  constexpr (operator int)() const { return 0; }
767};
768static_assert(X() == 0, "");
769
770}
771
772}
773
774}
775
776namespace Temporaries {
777
778struct S {
779  constexpr S() {}
780  constexpr int f() const;
781};
782struct T : S {
783  constexpr T(int n) : S(), n(n) {}
784  int n;
785};
786constexpr int S::f() const {
787  // 'this' must be the postfix-expression in a class member access expression,
788  // so we can't just use
789  //   return static_cast<T*>(this)->n;
790  return this->*(int(S::*))&T::n;
791}
792// The T temporary is implicitly cast to an S subobject, but we can recover the
793// T full-object via a base-to-derived cast, or a derived-to-base-casted member
794// pointer.
795static_assert(T(3).f() == 3, "");
796
797constexpr int f(const S &s) {
798  return static_cast<const T&>(s).n;
799}
800constexpr int n = f(T(5));
801static_assert(f(T(5)) == 5, "");
802
803constexpr bool b(int n) { return &n; }
804static_assert(b(0), "");
805
806}
807
808namespace Union {
809
810union U {
811  int a;
812  int b;
813};
814
815constexpr U u[4] = { { .a = 0 }, { .b = 1 }, { .a = 2 }, { .b = 3 } }; // expected-warning 4{{C99 feature}}
816static_assert(u[0].a == 0, "");
817static_assert(u[0].b, ""); // expected-error {{constant expression}} expected-note {{read of member 'b' of union with active member 'a'}}
818static_assert(u[1].b == 1, "");
819static_assert((&u[1].b)[1] == 2, ""); // expected-error {{constant expression}} expected-note {{read of dereferenced one-past-the-end pointer}}
820static_assert(*(&(u[1].b) + 1 + 1) == 3, ""); // expected-error {{constant expression}} expected-note {{cannot refer to element 2 of non-array object}}
821static_assert((&(u[1]) + 1 + 1)->b == 3, "");
822
823constexpr U v = {};
824static_assert(v.a == 0, "");
825
826union Empty {};
827constexpr Empty e = {};
828
829// Make sure we handle trivial copy constructors for unions.
830constexpr U x = {42};
831constexpr U y = x;
832static_assert(y.a == 42, "");
833static_assert(y.b == 42, ""); // expected-error {{constant expression}} expected-note {{'b' of union with active member 'a'}}
834
835}
836
837namespace MemberPointer {
838  struct A {
839    constexpr A(int n) : n(n) {}
840    int n;
841    constexpr int f() const { return n + 3; }
842  };
843  constexpr A a(7);
844  static_assert(A(5).*&A::n == 5, "");
845  static_assert((&a)->*&A::n == 7, "");
846  static_assert((A(8).*&A::f)() == 11, "");
847  static_assert(((&a)->*&A::f)() == 10, "");
848
849  struct B : A {
850    constexpr B(int n, int m) : A(n), m(m) {}
851    int m;
852    constexpr int g() const { return n + m + 1; }
853  };
854  constexpr B b(9, 13);
855  static_assert(B(4, 11).*&A::n == 4, "");
856  static_assert(B(4, 11).*&B::m == 11, "");
857  static_assert(B(4, 11).*(int(A::*))&B::m == 11, "");
858  static_assert((&b)->*&A::n == 9, "");
859  static_assert((&b)->*&B::m == 13, "");
860  static_assert((&b)->*(int(A::*))&B::m == 13, "");
861  static_assert((B(4, 11).*&A::f)() == 7, "");
862  static_assert((B(4, 11).*&B::g)() == 16, "");
863  static_assert((B(4, 11).*(int(A::*)()const)&B::g)() == 16, "");
864  static_assert(((&b)->*&A::f)() == 12, "");
865  static_assert(((&b)->*&B::g)() == 23, "");
866  static_assert(((&b)->*(int(A::*)()const)&B::g)() == 23, "");
867
868  struct S {
869    constexpr S(int m, int n, int (S::*pf)() const, int S::*pn) :
870      m(m), n(n), pf(pf), pn(pn) {}
871    constexpr S() : m(), n(), pf(&S::f), pn(&S::n) {}
872
873    constexpr int f() const { return this->*pn; }
874    virtual int g() const;
875
876    int m, n;
877    int (S::*pf)() const;
878    int S::*pn;
879  };
880
881  constexpr int S::*pm = &S::m;
882  constexpr int S::*pn = &S::n;
883  constexpr int (S::*pf)() const = &S::f;
884  constexpr int (S::*pg)() const = &S::g;
885
886  constexpr S s(2, 5, &S::f, &S::m);
887
888  static_assert((s.*&S::f)() == 2, "");
889  static_assert((s.*s.pf)() == 2, "");
890
891  static_assert(pf == &S::f, "");
892  static_assert(pf == s.*&S::pf, "");
893  static_assert(pm == &S::m, "");
894  static_assert(pm != pn, "");
895  static_assert(s.pn != pn, "");
896  static_assert(s.pn == pm, "");
897  static_assert(pg != nullptr, "");
898  static_assert(pf != nullptr, "");
899  static_assert((int S::*)nullptr == nullptr, "");
900  static_assert(pg == pg, ""); // expected-error {{constant expression}} expected-note {{comparison of pointer to virtual member function 'g' has unspecified value}}
901  static_assert(pf != pg, ""); // expected-error {{constant expression}} expected-note {{comparison of pointer to virtual member function 'g' has unspecified value}}
902
903  template<int n> struct T : T<n-1> {};
904  template<> struct T<0> { int n; };
905  template<> struct T<30> : T<29> { int m; };
906
907  T<17> t17;
908  T<30> t30;
909
910  constexpr int (T<10>::*deepn) = &T<0>::n;
911  static_assert(&(t17.*deepn) == &t17.n, "");
912  static_assert(deepn == &T<2>::n, "");
913
914  constexpr int (T<15>::*deepm) = (int(T<10>::*))&T<30>::m;
915  constexpr int *pbad = &(t17.*deepm); // expected-error {{constant expression}}
916  static_assert(&(t30.*deepm) == &t30.m, "");
917  static_assert(deepm == &T<50>::m, "");
918  static_assert(deepm != deepn, "");
919
920  constexpr T<5> *p17_5 = &t17;
921  constexpr T<13> *p17_13 = (T<13>*)p17_5;
922  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>'}}
923  static_assert(&(p17_5->*(int(T<3>::*))deepn) == &t17.n, "");
924  static_assert(&(p17_13->*deepn) == &t17.n, "");
925  constexpr int *pbad2 = &(p17_13->*(int(T<9>::*))deepm); // expected-error {{constant expression}}
926
927  constexpr T<5> *p30_5 = &t30;
928  constexpr T<23> *p30_23 = (T<23>*)p30_5;
929  constexpr T<13> *p30_13 = p30_23;
930  static_assert(&(p30_5->*(int(T<3>::*))deepn) == &t30.n, "");
931  static_assert(&(p30_13->*deepn) == &t30.n, "");
932  static_assert(&(p30_23->*deepn) == &t30.n, "");
933  static_assert(&(p30_5->*(int(T<2>::*))deepm) == &t30.m, "");
934  static_assert(&(((T<17>*)p30_13)->*deepm) == &t30.m, "");
935  static_assert(&(p30_23->*deepm) == &t30.m, "");
936
937  struct Base { int n; };
938  template<int N> struct Mid : Base {};
939  struct Derived : Mid<0>, Mid<1> {};
940  static_assert(&Mid<0>::n == &Mid<1>::n, "");
941  static_assert((int Derived::*)(int Mid<0>::*)&Mid<0>::n !=
942                (int Derived::*)(int Mid<1>::*)&Mid<1>::n, "");
943  static_assert(&Mid<0>::n == (int Mid<0>::*)&Base::n, "");
944}
945
946namespace ArrayBaseDerived {
947
948  struct Base {
949    constexpr Base() {}
950    int n = 0;
951  };
952  struct Derived : Base {
953    constexpr Derived() {}
954    constexpr const int *f() const { return &n; }
955  };
956
957  constexpr Derived a[10];
958  constexpr Derived *pd3 = const_cast<Derived*>(&a[3]);
959  constexpr Base *pb3 = const_cast<Derived*>(&a[3]);
960  static_assert(pb3 == pd3, "");
961
962  // pb3 does not point to an array element.
963  constexpr Base *pb4 = pb3 + 1; // ok, one-past-the-end pointer.
964  constexpr int pb4n = pb4->n; // expected-error {{constant expression}} expected-note {{cannot access field of pointer past the end}}
965  constexpr Base *err_pb5 = pb3 + 2; // expected-error {{constant expression}} expected-note {{cannot refer to element 2}} expected-note {{here}}
966  constexpr int err_pb5n = err_pb5->n; // expected-error {{constant expression}} expected-note {{initializer of 'err_pb5' is not a constant expression}}
967  constexpr Base *err_pb2 = pb3 - 1; // expected-error {{constant expression}} expected-note {{cannot refer to element -1}} expected-note {{here}}
968  constexpr int err_pb2n = err_pb2->n; // expected-error {{constant expression}} expected-note {{initializer of 'err_pb2'}}
969  constexpr Base *pb3a = pb4 - 1;
970
971  // pb4 does not point to a Derived.
972  constexpr Derived *err_pd4 = (Derived*)pb4; // expected-error {{constant expression}} expected-note {{cannot access derived class of pointer past the end}}
973  constexpr Derived *pd3a = (Derived*)pb3a;
974  constexpr int pd3n = pd3a->n;
975
976  // pd3a still points to the Derived array.
977  constexpr Derived *pd6 = pd3a + 3;
978  static_assert(pd6 == &a[6], "");
979  constexpr Derived *pd9 = pd6 + 3;
980  constexpr Derived *pd10 = pd6 + 4;
981  constexpr int pd9n = pd9->n; // ok
982  constexpr int err_pd10n = pd10->n; // expected-error {{constant expression}} expected-note {{cannot access base class of pointer past the end}}
983  constexpr int pd0n = pd10[-10].n;
984  constexpr int err_pdminus1n = pd10[-11].n; // expected-error {{constant expression}} expected-note {{cannot refer to element -1 of}}
985
986  constexpr Base *pb9 = pd9;
987  constexpr const int *(Base::*pfb)() const =
988      static_cast<const int *(Base::*)() const>(&Derived::f);
989  static_assert((pb9->*pfb)() == &a[9].n, "");
990}
991
992namespace Complex {
993
994class complex {
995  int re, im;
996public:
997  constexpr complex(int re = 0, int im = 0) : re(re), im(im) {}
998  constexpr complex(const complex &o) : re(o.re), im(o.im) {}
999  constexpr complex operator-() const { return complex(-re, -im); }
1000  friend constexpr complex operator+(const complex &l, const complex &r) {
1001    return complex(l.re + r.re, l.im + r.im);
1002  }
1003  friend constexpr complex operator-(const complex &l, const complex &r) {
1004    return l + -r;
1005  }
1006  friend constexpr complex operator*(const complex &l, const complex &r) {
1007    return complex(l.re * r.re - l.im * r.im, l.re * r.im + l.im * r.re);
1008  }
1009  friend constexpr bool operator==(const complex &l, const complex &r) {
1010    return l.re == r.re && l.im == r.im;
1011  }
1012  constexpr bool operator!=(const complex &r) const {
1013    return re != r.re || im != r.im;
1014  }
1015  constexpr int real() const { return re; }
1016  constexpr int imag() const { return im; }
1017};
1018
1019constexpr complex i = complex(0, 1);
1020constexpr complex k = (3 + 4*i) * (6 - 4*i);
1021static_assert(complex(1,0).real() == 1, "");
1022static_assert(complex(1,0).imag() == 0, "");
1023static_assert(((complex)1).imag() == 0, "");
1024static_assert(k.real() == 34, "");
1025static_assert(k.imag() == 12, "");
1026static_assert(k - 34 == 12*i, "");
1027static_assert((complex)1 == complex(1), "");
1028static_assert((complex)1 != complex(0, 1), "");
1029static_assert(complex(1) == complex(1), "");
1030static_assert(complex(1) != complex(0, 1), "");
1031constexpr complex makeComplex(int re, int im) { return complex(re, im); }
1032static_assert(makeComplex(1,0) == complex(1), "");
1033static_assert(makeComplex(1,0) != complex(0, 1), "");
1034
1035class complex_wrap : public complex {
1036public:
1037  constexpr complex_wrap(int re, int im = 0) : complex(re, im) {}
1038  constexpr complex_wrap(const complex_wrap &o) : complex(o) {}
1039};
1040
1041static_assert((complex_wrap)1 == complex(1), "");
1042static_assert((complex)1 != complex_wrap(0, 1), "");
1043static_assert(complex(1) == complex_wrap(1), "");
1044static_assert(complex_wrap(1) != complex(0, 1), "");
1045constexpr complex_wrap makeComplexWrap(int re, int im) {
1046  return complex_wrap(re, im);
1047}
1048static_assert(makeComplexWrap(1,0) == complex(1), "");
1049static_assert(makeComplexWrap(1,0) != complex(0, 1), "");
1050
1051}
1052
1053namespace PR11595 {
1054  struct A { constexpr bool operator==(int x) const { return true; } };
1055  struct B { B(); A& x; };
1056  static_assert(B().x == 3, "");  // expected-error {{constant expression}} expected-note {{non-literal type 'PR11595::B' cannot be used in a constant expression}}
1057
1058  constexpr bool f(int k) { // expected-error {{constexpr function never produces a constant expression}}
1059    return B().x == k; // expected-note {{non-literal type 'PR11595::B' cannot be used in a constant expression}}
1060  }
1061}
1062
1063namespace ExprWithCleanups {
1064  struct A { A(); ~A(); int get(); };
1065  constexpr int get(bool FromA) { return FromA ? A().get() : 1; }
1066  constexpr int n = get(false);
1067}
1068
1069namespace Volatile {
1070
1071volatile constexpr int n1 = 0; // expected-note {{here}}
1072volatile const int n2 = 0; // expected-note {{here}}
1073int n3 = 37; // expected-note {{declared here}}
1074
1075constexpr int m1 = n1; // expected-error {{constant expression}} expected-note {{read of volatile-qualified type 'const volatile int'}}
1076constexpr int m2 = n2; // expected-error {{constant expression}} expected-note {{read of volatile-qualified type 'const volatile int'}}
1077constexpr int m1b = const_cast<const int&>(n1); // expected-error {{constant expression}} expected-note {{read of volatile object 'n1'}}
1078constexpr int m2b = const_cast<const int&>(n2); // expected-error {{constant expression}} expected-note {{read of volatile object 'n2'}}
1079
1080struct T { int n; };
1081const T t = { 42 }; // expected-note {{declared here}}
1082
1083constexpr int f(volatile int &&r) {
1084  return r; // expected-note {{read of volatile-qualified type 'volatile int'}}
1085}
1086constexpr int g(volatile int &&r) {
1087  return const_cast<int&>(r); // expected-note {{read of volatile temporary is not allowed in a constant expression}}
1088}
1089struct S {
1090  int j : f(0); // expected-error {{constant expression}} expected-note {{in call to 'f(0)'}}
1091  int k : g(0); // expected-error {{constant expression}} expected-note {{temporary created here}} expected-note {{in call to 'g(0)'}}
1092  int l : n3; // expected-error {{constant expression}} expected-note {{read of non-const variable}}
1093  int m : t.n; // expected-error {{constant expression}} expected-note {{read of non-constexpr variable}}
1094};
1095
1096}
1097
1098namespace ExternConstexpr {
1099  extern constexpr int n = 0;
1100  extern constexpr int m; // expected-error {{constexpr variable declaration must be a definition}}
1101  void f() {
1102    extern constexpr int i; // expected-error {{constexpr variable declaration must be a definition}}
1103    constexpr int j = 0;
1104    constexpr int k; // expected-error {{default initialization of an object of const type}}
1105  }
1106}
1107
1108namespace ComplexConstexpr {
1109  constexpr _Complex float test1 = {};
1110  constexpr _Complex float test2 = {1};
1111  constexpr _Complex double test3 = {1,2};
1112  constexpr _Complex int test4 = {4};
1113  constexpr _Complex int test5 = 4;
1114  constexpr _Complex int test6 = {5,6};
1115  typedef _Complex float fcomplex;
1116  constexpr fcomplex test7 = fcomplex();
1117
1118  constexpr const double &t2r = __real test3;
1119  constexpr const double &t2i = __imag test3;
1120  static_assert(&t2r + 1 == &t2i, "");
1121  static_assert(t2r == 1.0, "");
1122  static_assert(t2i == 2.0, "");
1123  constexpr const double *t2p = &t2r;
1124  static_assert(t2p[-1] == 0.0, ""); // expected-error {{constant expr}} expected-note {{cannot refer to element -1 of array of 2 elements}}
1125  static_assert(t2p[0] == 1.0, "");
1126  static_assert(t2p[1] == 2.0, "");
1127  static_assert(t2p[2] == 0.0, ""); // expected-error {{constant expr}} expected-note {{one-past-the-end pointer}}
1128  static_assert(t2p[3] == 0.0, ""); // expected-error {{constant expr}} expected-note {{cannot refer to element 3 of array of 2 elements}}
1129  constexpr _Complex float *p = 0;
1130  constexpr float pr = __real *p; // expected-error {{constant expr}} expected-note {{cannot access real component of null}}
1131  constexpr float pi = __imag *p; // expected-error {{constant expr}} expected-note {{cannot access imaginary component of null}}
1132  constexpr const _Complex double *q = &test3 + 1;
1133  constexpr double qr = __real *q; // expected-error {{constant expr}} expected-note {{cannot access real component of pointer past the end}}
1134  constexpr double qi = __imag *q; // expected-error {{constant expr}} expected-note {{cannot access imaginary component of pointer past the end}}
1135
1136  static_assert(__real test6 == 5, "");
1137  static_assert(__imag test6 == 6, "");
1138  static_assert(&__imag test6 == &__real test6 + 1, "");
1139}
1140
1141// _Atomic(T) is exactly like T for the purposes of constant expression
1142// evaluation..
1143namespace Atomic {
1144  constexpr _Atomic int n = 3;
1145
1146  struct S { _Atomic(double) d; };
1147  constexpr S s = { 0.5 };
1148  constexpr double d1 = s.d;
1149  constexpr double d2 = n;
1150  constexpr _Atomic double d3 = n;
1151
1152  constexpr _Atomic(int) n2 = d3;
1153  static_assert(d1 == 0.5, "");
1154  static_assert(d3 == 3.0, "");
1155
1156  namespace PR16056 {
1157    struct TestVar {
1158      _Atomic(int) value;
1159      constexpr TestVar(int value) : value(value) {}
1160    };
1161    constexpr TestVar testVar{-1};
1162    static_assert(testVar.value == -1, "");
1163  }
1164}
1165
1166namespace InstantiateCaseStmt {
1167  template<int x> constexpr int f() { return x; }
1168  template<int x> int g(int c) { switch(c) { case f<x>(): return 1; } return 0; }
1169  int gg(int c) { return g<4>(c); }
1170}
1171
1172namespace ConvertedConstantExpr {
1173  extern int &m;
1174  extern int &n;
1175
1176  constexpr int k = 4;
1177  int &m = const_cast<int&>(k);
1178
1179  // If we have nothing more interesting to say, ensure we don't produce a
1180  // useless note and instead just point to the non-constant subexpression.
1181  enum class E {
1182    em = m,
1183    en = n, // expected-error {{not a constant expression}}
1184    eo = (m +
1185          n // expected-error {{not a constant expression}}
1186          ),
1187    eq = reinterpret_cast<int>((int*)0) // expected-error {{not a constant expression}} expected-note {{reinterpret_cast}}
1188  };
1189}
1190
1191namespace IndirectField {
1192  struct S {
1193    struct { // expected-warning {{GNU extension}}
1194      union { // expected-warning {{declared in an anonymous struct}}
1195        struct { // expected-warning {{GNU extension}} expected-warning {{declared in an anonymous union}}
1196          int a;
1197          int b;
1198        };
1199        int c;
1200      };
1201      int d;
1202    };
1203    union {
1204      int e;
1205      int f;
1206    };
1207    constexpr S(int a, int b, int d, int e) : a(a), b(b), d(d), e(e) {}
1208    constexpr S(int c, int d, int f) : c(c), d(d), f(f) {}
1209  };
1210
1211  constexpr S s1(1, 2, 3, 4);
1212  constexpr S s2(5, 6, 7);
1213
1214  // FIXME: The diagnostics here do a very poor job of explaining which unnamed
1215  // member is active and which is requested.
1216  static_assert(s1.a == 1, "");
1217  static_assert(s1.b == 2, "");
1218  static_assert(s1.c == 0, ""); // expected-error {{constant expression}} expected-note {{union with active member}}
1219  static_assert(s1.d == 3, "");
1220  static_assert(s1.e == 4, "");
1221  static_assert(s1.f == 0, ""); // expected-error {{constant expression}} expected-note {{union with active member}}
1222
1223  static_assert(s2.a == 0, ""); // expected-error {{constant expression}} expected-note {{union with active member}}
1224  static_assert(s2.b == 0, ""); // expected-error {{constant expression}} expected-note {{union with active member}}
1225  static_assert(s2.c == 5, "");
1226  static_assert(s2.d == 6, "");
1227  static_assert(s2.e == 0, ""); // expected-error {{constant expression}} expected-note {{union with active member}}
1228  static_assert(s2.f == 7, "");
1229}
1230
1231// DR1405: don't allow reading mutable members in constant expressions.
1232namespace MutableMembers {
1233  struct MM {
1234    mutable int n; // expected-note 3{{declared here}}
1235  } constexpr mm = { 4 };
1236  constexpr int mmn = mm.n; // expected-error {{constant expression}} expected-note {{read of mutable member 'n' is not allowed in a constant expression}}
1237  int x = (mm.n = 1, 3);
1238  constexpr int mmn2 = mm.n; // expected-error {{constant expression}} expected-note {{read of mutable member 'n' is not allowed in a constant expression}}
1239
1240  // Here's one reason why allowing this would be a disaster...
1241  template<int n> struct Id { int k = n; };
1242  int f() {
1243    constexpr MM m = { 0 };
1244    ++m.n;
1245    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}}
1246  }
1247
1248  struct A { int n; };
1249  struct B { mutable A a; }; // expected-note {{here}}
1250  struct C { B b; };
1251  constexpr C c[3] = {};
1252  constexpr int k = c[1].b.a.n; // expected-error {{constant expression}} expected-note {{mutable}}
1253}
1254
1255namespace Fold {
1256
1257  // This macro forces its argument to be constant-folded, even if it's not
1258  // otherwise a constant expression.
1259  #define fold(x) (__builtin_constant_p(x) ? (x) : (x))
1260
1261  constexpr int n = (int)(char*)123; // expected-error {{constant expression}} expected-note {{reinterpret_cast}}
1262  constexpr int m = fold((int)(char*)123); // ok
1263  static_assert(m == 123, "");
1264
1265  #undef fold
1266
1267}
1268
1269namespace DR1454 {
1270
1271constexpr const int &f(const int &n) { return n; }
1272constexpr int k1 = f(0); // ok
1273
1274struct Wrap {
1275  const int &value;
1276};
1277constexpr const Wrap &g(const Wrap &w) { return w; }
1278constexpr int k2 = g({0}).value; // ok
1279
1280constexpr const int &i = 0; // expected-error {{constant expression}} expected-note {{temporary}} expected-note 2{{here}}
1281constexpr const int j = i; // expected-error {{constant expression}} expected-note {{initializer of 'i' is not a constant expression}}
1282
1283}
1284
1285namespace RecursiveOpaqueExpr {
1286  template<typename Iter>
1287  constexpr auto LastNonzero(Iter p, Iter q) -> decltype(+*p) {
1288    return p != q ? (LastNonzero(p+1, q) ?: *p) : 0; // expected-warning {{GNU}}
1289  }
1290
1291  constexpr int arr1[] = { 1, 0, 0, 3, 0, 2, 0, 4, 0, 0 };
1292  static_assert(LastNonzero(begin(arr1), end(arr1)) == 4, "");
1293
1294  constexpr int arr2[] = { 1, 0, 0, 3, 0, 2, 0, 4, 0, 5 };
1295  static_assert(LastNonzero(begin(arr2), end(arr2)) == 5, "");
1296
1297  constexpr int arr3[] = {
1298    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,
1299    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,
1300    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,
1301    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,
1302    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,
1303    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,
1304    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,
1305    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 };
1306  static_assert(LastNonzero(begin(arr3), end(arr3)) == 2, "");
1307}
1308
1309namespace VLASizeof {
1310
1311  void f(int k) {
1312    int arr[k]; // expected-warning {{C99}}
1313    constexpr int n = 1 +
1314        sizeof(arr) // expected-error {{constant expression}}
1315        * 3;
1316  }
1317}
1318
1319namespace CompoundLiteral {
1320  // FIXME:
1321  // We don't model the semantics of this correctly: the compound literal is
1322  // represented as a prvalue in the AST, but actually behaves like an lvalue.
1323  // We treat the compound literal as a temporary and refuse to produce a
1324  // pointer to it. This is OK: we're not required to treat this as a constant
1325  // in C++, and in C we model compound literals as lvalues.
1326  constexpr int *p = (int*)(int[1]){0}; // expected-warning {{C99}} expected-error {{constant expression}} expected-note 2{{temporary}}
1327}
1328
1329namespace Vector {
1330  typedef int __attribute__((vector_size(16))) VI4;
1331  constexpr VI4 f(int n) {
1332    return VI4 { n * 3, n + 4, n - 5, n / 6 };
1333  }
1334  constexpr auto v1 = f(10);
1335
1336  typedef double __attribute__((vector_size(32))) VD4;
1337  constexpr VD4 g(int n) {
1338    return (VD4) { n / 2.0, n + 1.5, n - 5.4, n * 0.9 }; // expected-warning {{C99}}
1339  }
1340  constexpr auto v2 = g(4);
1341}
1342
1343// PR12626, redux
1344namespace InvalidClasses {
1345  void test0() {
1346    struct X; // expected-note {{forward declaration}}
1347    struct Y { bool b; X x; }; // expected-error {{field has incomplete type}}
1348    Y y;
1349    auto& b = y.b;
1350  }
1351}
1352
1353namespace NamespaceAlias {
1354  constexpr int f() {
1355    namespace NS = NamespaceAlias; // expected-warning {{use of this statement in a constexpr function is a C++1y extension}}
1356    return &NS::f != nullptr;
1357  }
1358}
1359
1360// Constructors can be implicitly constexpr, even for a non-literal type.
1361namespace ImplicitConstexpr {
1362  struct Q { Q() = default; Q(const Q&) = default; Q(Q&&) = default; ~Q(); }; // expected-note 3{{here}}
1363  struct R { constexpr R() noexcept; constexpr R(const R&) noexcept; constexpr R(R&&) noexcept; ~R() noexcept; };
1364  struct S { R r; }; // expected-note 3{{here}}
1365  struct T { T(const T&) noexcept; T(T &&) noexcept; ~T() noexcept; };
1366  struct U { T t; }; // expected-note 3{{here}}
1367  static_assert(!__is_literal_type(Q), "");
1368  static_assert(!__is_literal_type(R), "");
1369  static_assert(!__is_literal_type(S), "");
1370  static_assert(!__is_literal_type(T), "");
1371  static_assert(!__is_literal_type(U), "");
1372  struct Test {
1373    friend Q::Q() noexcept; // expected-error {{follows constexpr}}
1374    friend Q::Q(Q&&) noexcept; // expected-error {{follows constexpr}}
1375    friend Q::Q(const Q&) noexcept; // expected-error {{follows constexpr}}
1376    friend S::S() noexcept; // expected-error {{follows constexpr}}
1377    friend S::S(S&&) noexcept; // expected-error {{follows constexpr}}
1378    friend S::S(const S&) noexcept; // expected-error {{follows constexpr}}
1379    friend constexpr U::U() noexcept; // expected-error {{follows non-constexpr}}
1380    friend constexpr U::U(U&&) noexcept; // expected-error {{follows non-constexpr}}
1381    friend constexpr U::U(const U&) noexcept; // expected-error {{follows non-constexpr}}
1382  };
1383}
1384
1385// Indirectly test that an implicit lvalue to xvalue conversion performed for
1386// an NRVO move operation isn't implemented as CK_LValueToRValue.
1387namespace PR12826 {
1388  struct Foo {};
1389  constexpr Foo id(Foo x) { return x; }
1390  constexpr Foo res(id(Foo()));
1391}
1392
1393namespace PR13273 {
1394  struct U {
1395    int t;
1396    U() = default;
1397  };
1398
1399  struct S : U {
1400    S() = default;
1401  };
1402
1403  // S's default constructor isn't constexpr, because U's default constructor
1404  // doesn't initialize 't', but it's trivial, so value-initialization doesn't
1405  // actually call it.
1406  static_assert(S{}.t == 0, "");
1407}
1408
1409namespace PR12670 {
1410  struct S {
1411    constexpr S(int a0) : m(a0) {}
1412    constexpr S() : m(6) {}
1413    int m;
1414  };
1415  constexpr S x[3] = { {4}, 5 };
1416  static_assert(x[0].m == 4, "");
1417  static_assert(x[1].m == 5, "");
1418  static_assert(x[2].m == 6, "");
1419}
1420
1421// Indirectly test that an implicit lvalue-to-rvalue conversion is performed
1422// when a conditional operator has one argument of type void and where the other
1423// is a glvalue of class type.
1424namespace ConditionalLValToRVal {
1425  struct A {
1426    constexpr A(int a) : v(a) {}
1427    int v;
1428  };
1429
1430  constexpr A f(const A &a) {
1431    return a.v == 0 ? throw a : a;
1432  }
1433
1434  constexpr A a(4);
1435  static_assert(f(a).v == 4, "");
1436}
1437
1438namespace TLS {
1439  __thread int n;
1440  int m;
1441
1442  constexpr bool b = &n == &n;
1443
1444  constexpr int *p = &n; // expected-error{{constexpr variable 'p' must be initialized by a constant expression}}
1445
1446  constexpr int *f() { return &n; }
1447  constexpr int *q = f(); // expected-error{{constexpr variable 'q' must be initialized by a constant expression}}
1448  constexpr bool c = f() == f();
1449
1450  constexpr int *g() { return &m; }
1451  constexpr int *r = g();
1452}
1453
1454namespace Void {
1455  constexpr void f() { return; } // expected-error{{constexpr function's return type 'void' is not a literal type}}
1456
1457  void assert_failed(const char *msg, const char *file, int line); // expected-note {{declared here}}
1458#define ASSERT(expr) ((expr) ? static_cast<void>(0) : assert_failed(#expr, __FILE__, __LINE__))
1459  template<typename T, size_t S>
1460  constexpr T get(T (&a)[S], size_t k) {
1461    return ASSERT(k > 0 && k < S), a[k]; // expected-note{{non-constexpr function 'assert_failed'}}
1462  }
1463#undef ASSERT
1464  template int get(int (&a)[4], size_t);
1465  constexpr int arr[] = { 4, 1, 2, 3, 4 };
1466  static_assert(get(arr, 1) == 1, "");
1467  static_assert(get(arr, 4) == 4, "");
1468  static_assert(get(arr, 0) == 4, ""); // expected-error{{not an integral constant expression}} \
1469  // expected-note{{in call to 'get(arr, 0)'}}
1470}
1471
1472namespace std { struct type_info; }
1473
1474namespace TypeId {
1475  struct A { virtual ~A(); };
1476  A f();
1477  A &g();
1478  constexpr auto &x = typeid(f());
1479  constexpr auto &y = typeid(g()); // expected-error{{constant expression}} \
1480  // expected-note{{typeid applied to expression of polymorphic type 'TypeId::A' is not allowed in a constant expression}}
1481}
1482
1483namespace PR14203 {
1484  struct duration {
1485    constexpr duration() {}
1486    constexpr operator int() const { return 0; }
1487  };
1488  template<typename T> void f() {
1489    // If we want to evaluate this at the point of the template definition, we
1490    // need to trigger the implicit definition of the move constructor at that
1491    // point.
1492    // FIXME: C++ does not permit us to implicitly define it at the appropriate
1493    // times, since it is only allowed to be implicitly defined when it is
1494    // odr-used.
1495    constexpr duration d = duration();
1496  }
1497  // FIXME: It's unclear whether this is valid. On the one hand, we're not
1498  // allowed to generate a move constructor. On the other hand, if we did,
1499  // this would be a constant expression. For now, we generate a move
1500  // constructor here.
1501  int n = sizeof(short{duration(duration())});
1502}
1503
1504namespace ArrayEltInit {
1505  struct A {
1506    constexpr A() : p(&p) {}
1507    void *p;
1508  };
1509  constexpr A a[10];
1510  static_assert(a[0].p == &a[0].p, "");
1511  static_assert(a[9].p == &a[9].p, "");
1512  static_assert(a[0].p != &a[9].p, "");
1513  static_assert(a[9].p != &a[0].p, "");
1514
1515  constexpr A b[10] = {};
1516  static_assert(b[0].p == &b[0].p, "");
1517  static_assert(b[9].p == &b[9].p, "");
1518  static_assert(b[0].p != &b[9].p, "");
1519  static_assert(b[9].p != &b[0].p, "");
1520}
1521
1522namespace PR15884 {
1523  struct S {};
1524  constexpr S f() { return {}; }
1525  constexpr S *p = &f();
1526  // expected-error@-1 {{taking the address of a temporary}}
1527  // expected-error@-2 {{constexpr variable 'p' must be initialized by a constant expression}}
1528  // expected-note@-3 {{pointer to temporary is not a constant expression}}
1529  // expected-note@-4 {{temporary created here}}
1530}
1531
1532namespace AfterError {
1533  // FIXME: Suppress the 'no return statements' diagnostic if the body is invalid.
1534  constexpr int error() { // expected-error {{no return statement}}
1535    return foobar; // expected-error {{undeclared identifier}}
1536  }
1537  constexpr int k = error(); // expected-error {{must be initialized by a constant expression}}
1538}
1539