constant-expression-cxx11.cpp revision 8a66bf78becf05a24e8251379f3843d1fceb627f 
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  constexpr int g() const;
782};
783struct T : S {
784  constexpr T(int n) : S(), n(n) {}
785  int n;
786};
787constexpr int S::f() const {
788  return static_cast<const T*>(this)->n; // expected-note {{cannot cast}}
789}
790constexpr int S::g() const {
791  // FIXME: Better diagnostic for this.
792  return this->*(int(S::*))&T::n; // expected-note {{subexpression}}
793}
794// The T temporary is implicitly cast to an S subobject, but we can recover the
795// T full-object via a base-to-derived cast, or a derived-to-base-casted member
796// pointer.
797static_assert(S().f(), ""); // expected-error {{constant expression}} expected-note {{in call to '&Temporaries::S()->f()'}}
798static_assert(S().g(), ""); // expected-error {{constant expression}} expected-note {{in call to '&Temporaries::S()->g()'}}
799static_assert(T(3).f() == 3, "");
800static_assert(T(4).g() == 4, "");
801
802constexpr int f(const S &s) {
803  return static_cast<const T&>(s).n;
804}
805constexpr int n = f(T(5));
806static_assert(f(T(5)) == 5, "");
807
808constexpr bool b(int n) { return &n; }
809static_assert(b(0), "");
810
811}
812
813namespace Union {
814
815union U {
816  int a;
817  int b;
818};
819
820constexpr U u[4] = { { .a = 0 }, { .b = 1 }, { .a = 2 }, { .b = 3 } }; // expected-warning 4{{C99 feature}}
821static_assert(u[0].a == 0, "");
822static_assert(u[0].b, ""); // expected-error {{constant expression}} expected-note {{read of member 'b' of union with active member 'a'}}
823static_assert(u[1].b == 1, "");
824static_assert((&u[1].b)[1] == 2, ""); // expected-error {{constant expression}} expected-note {{read of dereferenced one-past-the-end pointer}}
825static_assert(*(&(u[1].b) + 1 + 1) == 3, ""); // expected-error {{constant expression}} expected-note {{cannot refer to element 2 of non-array object}}
826static_assert((&(u[1]) + 1 + 1)->b == 3, "");
827
828constexpr U v = {};
829static_assert(v.a == 0, "");
830
831union Empty {};
832constexpr Empty e = {};
833
834// Make sure we handle trivial copy constructors for unions.
835constexpr U x = {42};
836constexpr U y = x;
837static_assert(y.a == 42, "");
838static_assert(y.b == 42, ""); // expected-error {{constant expression}} expected-note {{'b' of union with active member 'a'}}
839
840}
841
842namespace MemberPointer {
843  struct A {
844    constexpr A(int n) : n(n) {}
845    int n;
846    constexpr int f() const { return n + 3; }
847  };
848  constexpr A a(7);
849  static_assert(A(5).*&A::n == 5, "");
850  static_assert((&a)->*&A::n == 7, "");
851  static_assert((A(8).*&A::f)() == 11, "");
852  static_assert(((&a)->*&A::f)() == 10, "");
853
854  struct B : A {
855    constexpr B(int n, int m) : A(n), m(m) {}
856    int m;
857    constexpr int g() const { return n + m + 1; }
858  };
859  constexpr B b(9, 13);
860  static_assert(B(4, 11).*&A::n == 4, "");
861  static_assert(B(4, 11).*&B::m == 11, "");
862  static_assert(B(4, 11).*(int(A::*))&B::m == 11, "");
863  static_assert((&b)->*&A::n == 9, "");
864  static_assert((&b)->*&B::m == 13, "");
865  static_assert((&b)->*(int(A::*))&B::m == 13, "");
866  static_assert((B(4, 11).*&A::f)() == 7, "");
867  static_assert((B(4, 11).*&B::g)() == 16, "");
868  static_assert((B(4, 11).*(int(A::*)()const)&B::g)() == 16, "");
869  static_assert(((&b)->*&A::f)() == 12, "");
870  static_assert(((&b)->*&B::g)() == 23, "");
871  static_assert(((&b)->*(int(A::*)()const)&B::g)() == 23, "");
872
873  struct S {
874    constexpr S(int m, int n, int (S::*pf)() const, int S::*pn) :
875      m(m), n(n), pf(pf), pn(pn) {}
876    constexpr S() : m(), n(), pf(&S::f), pn(&S::n) {}
877
878    constexpr int f() const { return this->*pn; }
879    virtual int g() const;
880
881    int m, n;
882    int (S::*pf)() const;
883    int S::*pn;
884  };
885
886  constexpr int S::*pm = &S::m;
887  constexpr int S::*pn = &S::n;
888  constexpr int (S::*pf)() const = &S::f;
889  constexpr int (S::*pg)() const = &S::g;
890
891  constexpr S s(2, 5, &S::f, &S::m);
892
893  static_assert((s.*&S::f)() == 2, "");
894  static_assert((s.*s.pf)() == 2, "");
895
896  static_assert(pf == &S::f, "");
897  static_assert(pf == s.*&S::pf, "");
898  static_assert(pm == &S::m, "");
899  static_assert(pm != pn, "");
900  static_assert(s.pn != pn, "");
901  static_assert(s.pn == pm, "");
902  static_assert(pg != nullptr, "");
903  static_assert(pf != nullptr, "");
904  static_assert((int S::*)nullptr == nullptr, "");
905  static_assert(pg == pg, ""); // expected-error {{constant expression}} expected-note {{comparison of pointer to virtual member function 'g' has unspecified value}}
906  static_assert(pf != pg, ""); // expected-error {{constant expression}} expected-note {{comparison of pointer to virtual member function 'g' has unspecified value}}
907
908  template<int n> struct T : T<n-1> {};
909  template<> struct T<0> { int n; };
910  template<> struct T<30> : T<29> { int m; };
911
912  T<17> t17;
913  T<30> t30;
914
915  constexpr int (T<10>::*deepn) = &T<0>::n;
916  static_assert(&(t17.*deepn) == &t17.n, "");
917  static_assert(deepn == &T<2>::n, "");
918
919  constexpr int (T<15>::*deepm) = (int(T<10>::*))&T<30>::m;
920  constexpr int *pbad = &(t17.*deepm); // expected-error {{constant expression}}
921  static_assert(&(t30.*deepm) == &t30.m, "");
922  static_assert(deepm == &T<50>::m, "");
923  static_assert(deepm != deepn, "");
924
925  constexpr T<5> *p17_5 = &t17;
926  constexpr T<13> *p17_13 = (T<13>*)p17_5;
927  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>'}}
928  static_assert(&(p17_5->*(int(T<3>::*))deepn) == &t17.n, "");
929  static_assert(&(p17_13->*deepn) == &t17.n, "");
930  constexpr int *pbad2 = &(p17_13->*(int(T<9>::*))deepm); // expected-error {{constant expression}}
931
932  constexpr T<5> *p30_5 = &t30;
933  constexpr T<23> *p30_23 = (T<23>*)p30_5;
934  constexpr T<13> *p30_13 = p30_23;
935  static_assert(&(p30_5->*(int(T<3>::*))deepn) == &t30.n, "");
936  static_assert(&(p30_13->*deepn) == &t30.n, "");
937  static_assert(&(p30_23->*deepn) == &t30.n, "");
938  static_assert(&(p30_5->*(int(T<2>::*))deepm) == &t30.m, "");
939  static_assert(&(((T<17>*)p30_13)->*deepm) == &t30.m, "");
940  static_assert(&(p30_23->*deepm) == &t30.m, "");
941
942  struct Base { int n; };
943  template<int N> struct Mid : Base {};
944  struct Derived : Mid<0>, Mid<1> {};
945  static_assert(&Mid<0>::n == &Mid<1>::n, "");
946  static_assert((int Derived::*)(int Mid<0>::*)&Mid<0>::n !=
947                (int Derived::*)(int Mid<1>::*)&Mid<1>::n, "");
948  static_assert(&Mid<0>::n == (int Mid<0>::*)&Base::n, "");
949}
950
951namespace ArrayBaseDerived {
952
953  struct Base {
954    constexpr Base() {}
955    int n = 0;
956  };
957  struct Derived : Base {
958    constexpr Derived() {}
959    constexpr const int *f() const { return &n; }
960  };
961
962  constexpr Derived a[10];
963  constexpr Derived *pd3 = const_cast<Derived*>(&a[3]);
964  constexpr Base *pb3 = const_cast<Derived*>(&a[3]);
965  static_assert(pb3 == pd3, "");
966
967  // pb3 does not point to an array element.
968  constexpr Base *pb4 = pb3 + 1; // ok, one-past-the-end pointer.
969  constexpr int pb4n = pb4->n; // expected-error {{constant expression}} expected-note {{cannot access field of pointer past the end}}
970  constexpr Base *err_pb5 = pb3 + 2; // expected-error {{constant expression}} expected-note {{cannot refer to element 2}} expected-note {{here}}
971  constexpr int err_pb5n = err_pb5->n; // expected-error {{constant expression}} expected-note {{initializer of 'err_pb5' is not a constant expression}}
972  constexpr Base *err_pb2 = pb3 - 1; // expected-error {{constant expression}} expected-note {{cannot refer to element -1}} expected-note {{here}}
973  constexpr int err_pb2n = err_pb2->n; // expected-error {{constant expression}} expected-note {{initializer of 'err_pb2'}}
974  constexpr Base *pb3a = pb4 - 1;
975
976  // pb4 does not point to a Derived.
977  constexpr Derived *err_pd4 = (Derived*)pb4; // expected-error {{constant expression}} expected-note {{cannot access derived class of pointer past the end}}
978  constexpr Derived *pd3a = (Derived*)pb3a;
979  constexpr int pd3n = pd3a->n;
980
981  // pd3a still points to the Derived array.
982  constexpr Derived *pd6 = pd3a + 3;
983  static_assert(pd6 == &a[6], "");
984  constexpr Derived *pd9 = pd6 + 3;
985  constexpr Derived *pd10 = pd6 + 4;
986  constexpr int pd9n = pd9->n; // ok
987  constexpr int err_pd10n = pd10->n; // expected-error {{constant expression}} expected-note {{cannot access base class of pointer past the end}}
988  constexpr int pd0n = pd10[-10].n;
989  constexpr int err_pdminus1n = pd10[-11].n; // expected-error {{constant expression}} expected-note {{cannot refer to element -1 of}}
990
991  constexpr Base *pb9 = pd9;
992  constexpr const int *(Base::*pfb)() const =
993      static_cast<const int *(Base::*)() const>(&Derived::f);
994  static_assert((pb9->*pfb)() == &a[9].n, "");
995}
996
997namespace Complex {
998
999class complex {
1000  int re, im;
1001public:
1002  constexpr complex(int re = 0, int im = 0) : re(re), im(im) {}
1003  constexpr complex(const complex &o) : re(o.re), im(o.im) {}
1004  constexpr complex operator-() const { return complex(-re, -im); }
1005  friend constexpr complex operator+(const complex &l, const complex &r) {
1006    return complex(l.re + r.re, l.im + r.im);
1007  }
1008  friend constexpr complex operator-(const complex &l, const complex &r) {
1009    return l + -r;
1010  }
1011  friend constexpr complex operator*(const complex &l, const complex &r) {
1012    return complex(l.re * r.re - l.im * r.im, l.re * r.im + l.im * r.re);
1013  }
1014  friend constexpr bool operator==(const complex &l, const complex &r) {
1015    return l.re == r.re && l.im == r.im;
1016  }
1017  constexpr bool operator!=(const complex &r) const {
1018    return re != r.re || im != r.im;
1019  }
1020  constexpr int real() const { return re; }
1021  constexpr int imag() const { return im; }
1022};
1023
1024constexpr complex i = complex(0, 1);
1025constexpr complex k = (3 + 4*i) * (6 - 4*i);
1026static_assert(complex(1,0).real() == 1, "");
1027static_assert(complex(1,0).imag() == 0, "");
1028static_assert(((complex)1).imag() == 0, "");
1029static_assert(k.real() == 34, "");
1030static_assert(k.imag() == 12, "");
1031static_assert(k - 34 == 12*i, "");
1032static_assert((complex)1 == complex(1), "");
1033static_assert((complex)1 != complex(0, 1), "");
1034static_assert(complex(1) == complex(1), "");
1035static_assert(complex(1) != complex(0, 1), "");
1036constexpr complex makeComplex(int re, int im) { return complex(re, im); }
1037static_assert(makeComplex(1,0) == complex(1), "");
1038static_assert(makeComplex(1,0) != complex(0, 1), "");
1039
1040class complex_wrap : public complex {
1041public:
1042  constexpr complex_wrap(int re, int im = 0) : complex(re, im) {}
1043  constexpr complex_wrap(const complex_wrap &o) : complex(o) {}
1044};
1045
1046static_assert((complex_wrap)1 == complex(1), "");
1047static_assert((complex)1 != complex_wrap(0, 1), "");
1048static_assert(complex(1) == complex_wrap(1), "");
1049static_assert(complex_wrap(1) != complex(0, 1), "");
1050constexpr complex_wrap makeComplexWrap(int re, int im) {
1051  return complex_wrap(re, im);
1052}
1053static_assert(makeComplexWrap(1,0) == complex(1), "");
1054static_assert(makeComplexWrap(1,0) != complex(0, 1), "");
1055
1056}
1057
1058namespace PR11595 {
1059  struct A { constexpr bool operator==(int x) const { return true; } };
1060  struct B { B(); A& x; };
1061  static_assert(B().x == 3, "");  // expected-error {{constant expression}} expected-note {{non-literal type 'PR11595::B' cannot be used in a constant expression}}
1062
1063  constexpr bool f(int k) { // expected-error {{constexpr function never produces a constant expression}}
1064    return B().x == k; // expected-note {{non-literal type 'PR11595::B' cannot be used in a constant expression}}
1065  }
1066}
1067
1068namespace ExprWithCleanups {
1069  struct A { A(); ~A(); int get(); };
1070  constexpr int get(bool FromA) { return FromA ? A().get() : 1; }
1071  constexpr int n = get(false);
1072}
1073
1074namespace Volatile {
1075
1076volatile constexpr int n1 = 0; // expected-note {{here}}
1077volatile const int n2 = 0; // expected-note {{here}}
1078int n3 = 37; // expected-note {{declared here}}
1079
1080constexpr int m1 = n1; // expected-error {{constant expression}} expected-note {{read of volatile-qualified type 'const volatile int'}}
1081constexpr int m2 = n2; // expected-error {{constant expression}} expected-note {{read of volatile-qualified type 'const volatile int'}}
1082constexpr int m1b = const_cast<const int&>(n1); // expected-error {{constant expression}} expected-note {{read of volatile object 'n1'}}
1083constexpr int m2b = const_cast<const int&>(n2); // expected-error {{constant expression}} expected-note {{read of volatile object 'n2'}}
1084
1085struct T { int n; };
1086const T t = { 42 }; // expected-note {{declared here}}
1087
1088constexpr int f(volatile int &&r) {
1089  return r; // expected-note {{read of volatile-qualified type 'volatile int'}}
1090}
1091constexpr int g(volatile int &&r) {
1092  return const_cast<int&>(r); // expected-note {{read of volatile temporary is not allowed in a constant expression}}
1093}
1094struct S {
1095  int j : f(0); // expected-error {{constant expression}} expected-note {{in call to 'f(0)'}}
1096  int k : g(0); // expected-error {{constant expression}} expected-note {{temporary created here}} expected-note {{in call to 'g(0)'}}
1097  int l : n3; // expected-error {{constant expression}} expected-note {{read of non-const variable}}
1098  int m : t.n; // expected-error {{constant expression}} expected-note {{read of non-constexpr variable}}
1099};
1100
1101}
1102
1103namespace ExternConstexpr {
1104  extern constexpr int n = 0;
1105  extern constexpr int m; // expected-error {{constexpr variable declaration must be a definition}}
1106  void f() {
1107    extern constexpr int i; // expected-error {{constexpr variable declaration must be a definition}}
1108    constexpr int j = 0;
1109    constexpr int k; // expected-error {{default initialization of an object of const type}}
1110  }
1111}
1112
1113namespace ComplexConstexpr {
1114  constexpr _Complex float test1 = {};
1115  constexpr _Complex float test2 = {1};
1116  constexpr _Complex double test3 = {1,2};
1117  constexpr _Complex int test4 = {4};
1118  constexpr _Complex int test5 = 4;
1119  constexpr _Complex int test6 = {5,6};
1120  typedef _Complex float fcomplex;
1121  constexpr fcomplex test7 = fcomplex();
1122
1123  constexpr const double &t2r = __real test3;
1124  constexpr const double &t2i = __imag test3;
1125  static_assert(&t2r + 1 == &t2i, "");
1126  static_assert(t2r == 1.0, "");
1127  static_assert(t2i == 2.0, "");
1128  constexpr const double *t2p = &t2r;
1129  static_assert(t2p[-1] == 0.0, ""); // expected-error {{constant expr}} expected-note {{cannot refer to element -1 of array of 2 elements}}
1130  static_assert(t2p[0] == 1.0, "");
1131  static_assert(t2p[1] == 2.0, "");
1132  static_assert(t2p[2] == 0.0, ""); // expected-error {{constant expr}} expected-note {{one-past-the-end pointer}}
1133  static_assert(t2p[3] == 0.0, ""); // expected-error {{constant expr}} expected-note {{cannot refer to element 3 of array of 2 elements}}
1134  constexpr _Complex float *p = 0;
1135  constexpr float pr = __real *p; // expected-error {{constant expr}} expected-note {{cannot access real component of null}}
1136  constexpr float pi = __imag *p; // expected-error {{constant expr}} expected-note {{cannot access imaginary component of null}}
1137  constexpr const _Complex double *q = &test3 + 1;
1138  constexpr double qr = __real *q; // expected-error {{constant expr}} expected-note {{cannot access real component of pointer past the end}}
1139  constexpr double qi = __imag *q; // expected-error {{constant expr}} expected-note {{cannot access imaginary component of pointer past the end}}
1140
1141  static_assert(__real test6 == 5, "");
1142  static_assert(__imag test6 == 6, "");
1143  static_assert(&__imag test6 == &__real test6 + 1, "");
1144}
1145
1146// _Atomic(T) is exactly like T for the purposes of constant expression
1147// evaluation..
1148namespace Atomic {
1149  constexpr _Atomic int n = 3;
1150
1151  struct S { _Atomic(double) d; };
1152  constexpr S s = { 0.5 };
1153  constexpr double d1 = s.d;
1154  constexpr double d2 = n;
1155  constexpr _Atomic double d3 = n;
1156
1157  constexpr _Atomic(int) n2 = d3;
1158  static_assert(d1 == 0.5, "");
1159  static_assert(d3 == 3.0, "");
1160
1161  namespace PR16056 {
1162    struct TestVar {
1163      _Atomic(int) value;
1164      constexpr TestVar(int value) : value(value) {}
1165    };
1166    constexpr TestVar testVar{-1};
1167    static_assert(testVar.value == -1, "");
1168  }
1169}
1170
1171namespace InstantiateCaseStmt {
1172  template<int x> constexpr int f() { return x; }
1173  template<int x> int g(int c) { switch(c) { case f<x>(): return 1; } return 0; }
1174  int gg(int c) { return g<4>(c); }
1175}
1176
1177namespace ConvertedConstantExpr {
1178  extern int &m;
1179  extern int &n;
1180
1181  constexpr int k = 4;
1182  int &m = const_cast<int&>(k);
1183
1184  // If we have nothing more interesting to say, ensure we don't produce a
1185  // useless note and instead just point to the non-constant subexpression.
1186  enum class E {
1187    em = m,
1188    en = n, // expected-error {{not a constant expression}}
1189    eo = (m +
1190          n // expected-error {{not a constant expression}}
1191          ),
1192    eq = reinterpret_cast<int>((int*)0) // expected-error {{not a constant expression}} expected-note {{reinterpret_cast}}
1193  };
1194}
1195
1196namespace IndirectField {
1197  struct S {
1198    struct { // expected-warning {{GNU extension}}
1199      union { // expected-warning {{declared in an anonymous struct}}
1200        struct { // expected-warning {{GNU extension}} expected-warning {{declared in an anonymous union}}
1201          int a;
1202          int b;
1203        };
1204        int c;
1205      };
1206      int d;
1207    };
1208    union {
1209      int e;
1210      int f;
1211    };
1212    constexpr S(int a, int b, int d, int e) : a(a), b(b), d(d), e(e) {}
1213    constexpr S(int c, int d, int f) : c(c), d(d), f(f) {}
1214  };
1215
1216  constexpr S s1(1, 2, 3, 4);
1217  constexpr S s2(5, 6, 7);
1218
1219  // FIXME: The diagnostics here do a very poor job of explaining which unnamed
1220  // member is active and which is requested.
1221  static_assert(s1.a == 1, "");
1222  static_assert(s1.b == 2, "");
1223  static_assert(s1.c == 0, ""); // expected-error {{constant expression}} expected-note {{union with active member}}
1224  static_assert(s1.d == 3, "");
1225  static_assert(s1.e == 4, "");
1226  static_assert(s1.f == 0, ""); // expected-error {{constant expression}} expected-note {{union with active member}}
1227
1228  static_assert(s2.a == 0, ""); // expected-error {{constant expression}} expected-note {{union with active member}}
1229  static_assert(s2.b == 0, ""); // expected-error {{constant expression}} expected-note {{union with active member}}
1230  static_assert(s2.c == 5, "");
1231  static_assert(s2.d == 6, "");
1232  static_assert(s2.e == 0, ""); // expected-error {{constant expression}} expected-note {{union with active member}}
1233  static_assert(s2.f == 7, "");
1234}
1235
1236// DR1405: don't allow reading mutable members in constant expressions.
1237namespace MutableMembers {
1238  struct MM {
1239    mutable int n; // expected-note 3{{declared here}}
1240  } constexpr mm = { 4 };
1241  constexpr int mmn = mm.n; // expected-error {{constant expression}} expected-note {{read of mutable member 'n' is not allowed in a constant expression}}
1242  int x = (mm.n = 1, 3);
1243  constexpr int mmn2 = mm.n; // expected-error {{constant expression}} expected-note {{read of mutable member 'n' is not allowed in a constant expression}}
1244
1245  // Here's one reason why allowing this would be a disaster...
1246  template<int n> struct Id { int k = n; };
1247  int f() {
1248    constexpr MM m = { 0 };
1249    ++m.n;
1250    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}}
1251  }
1252
1253  struct A { int n; };
1254  struct B { mutable A a; }; // expected-note {{here}}
1255  struct C { B b; };
1256  constexpr C c[3] = {};
1257  constexpr int k = c[1].b.a.n; // expected-error {{constant expression}} expected-note {{mutable}}
1258}
1259
1260namespace Fold {
1261
1262  // This macro forces its argument to be constant-folded, even if it's not
1263  // otherwise a constant expression.
1264  #define fold(x) (__builtin_constant_p(x) ? (x) : (x))
1265
1266  constexpr int n = (int)(char*)123; // expected-error {{constant expression}} expected-note {{reinterpret_cast}}
1267  constexpr int m = fold((int)(char*)123); // ok
1268  static_assert(m == 123, "");
1269
1270  #undef fold
1271
1272}
1273
1274namespace DR1454 {
1275
1276constexpr const int &f(const int &n) { return n; }
1277constexpr int k1 = f(0); // ok
1278
1279struct Wrap {
1280  const int &value;
1281};
1282constexpr const Wrap &g(const Wrap &w) { return w; }
1283constexpr int k2 = g({0}).value; // ok
1284
1285constexpr const int &i = 0; // expected-error {{constant expression}} expected-note {{temporary}} expected-note 2{{here}}
1286constexpr const int j = i; // expected-error {{constant expression}} expected-note {{initializer of 'i' is not a constant expression}}
1287
1288}
1289
1290namespace RecursiveOpaqueExpr {
1291  template<typename Iter>
1292  constexpr auto LastNonzero(Iter p, Iter q) -> decltype(+*p) {
1293    return p != q ? (LastNonzero(p+1, q) ?: *p) : 0; // expected-warning {{GNU}}
1294  }
1295
1296  constexpr int arr1[] = { 1, 0, 0, 3, 0, 2, 0, 4, 0, 0 };
1297  static_assert(LastNonzero(begin(arr1), end(arr1)) == 4, "");
1298
1299  constexpr int arr2[] = { 1, 0, 0, 3, 0, 2, 0, 4, 0, 5 };
1300  static_assert(LastNonzero(begin(arr2), end(arr2)) == 5, "");
1301
1302  constexpr int arr3[] = {
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    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,
1306    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,
1307    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,
1308    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,
1309    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,
1310    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 };
1311  static_assert(LastNonzero(begin(arr3), end(arr3)) == 2, "");
1312}
1313
1314namespace VLASizeof {
1315
1316  void f(int k) {
1317    int arr[k]; // expected-warning {{C99}}
1318    constexpr int n = 1 +
1319        sizeof(arr) // expected-error {{constant expression}}
1320        * 3;
1321  }
1322}
1323
1324namespace CompoundLiteral {
1325  // FIXME:
1326  // We don't model the semantics of this correctly: the compound literal is
1327  // represented as a prvalue in the AST, but actually behaves like an lvalue.
1328  // We treat the compound literal as a temporary and refuse to produce a
1329  // pointer to it. This is OK: we're not required to treat this as a constant
1330  // in C++, and in C we model compound literals as lvalues.
1331  constexpr int *p = (int*)(int[1]){0}; // expected-warning {{C99}} expected-error {{constant expression}} expected-note 2{{temporary}}
1332}
1333
1334namespace Vector {
1335  typedef int __attribute__((vector_size(16))) VI4;
1336  constexpr VI4 f(int n) {
1337    return VI4 { n * 3, n + 4, n - 5, n / 6 };
1338  }
1339  constexpr auto v1 = f(10);
1340
1341  typedef double __attribute__((vector_size(32))) VD4;
1342  constexpr VD4 g(int n) {
1343    return (VD4) { n / 2.0, n + 1.5, n - 5.4, n * 0.9 }; // expected-warning {{C99}}
1344  }
1345  constexpr auto v2 = g(4);
1346}
1347
1348// PR12626, redux
1349namespace InvalidClasses {
1350  void test0() {
1351    struct X; // expected-note {{forward declaration}}
1352    struct Y { bool b; X x; }; // expected-error {{field has incomplete type}}
1353    Y y;
1354    auto& b = y.b;
1355  }
1356}
1357
1358namespace NamespaceAlias {
1359  constexpr int f() {
1360    namespace NS = NamespaceAlias; // expected-warning {{use of this statement in a constexpr function is a C++1y extension}}
1361    return &NS::f != nullptr;
1362  }
1363}
1364
1365// Constructors can be implicitly constexpr, even for a non-literal type.
1366namespace ImplicitConstexpr {
1367  struct Q { Q() = default; Q(const Q&) = default; Q(Q&&) = default; ~Q(); }; // expected-note 3{{here}}
1368  struct R { constexpr R() noexcept; constexpr R(const R&) noexcept; constexpr R(R&&) noexcept; ~R() noexcept; };
1369  struct S { R r; }; // expected-note 3{{here}}
1370  struct T { T(const T&) noexcept; T(T &&) noexcept; ~T() noexcept; };
1371  struct U { T t; }; // expected-note 3{{here}}
1372  static_assert(!__is_literal_type(Q), "");
1373  static_assert(!__is_literal_type(R), "");
1374  static_assert(!__is_literal_type(S), "");
1375  static_assert(!__is_literal_type(T), "");
1376  static_assert(!__is_literal_type(U), "");
1377  struct Test {
1378    friend Q::Q() noexcept; // expected-error {{follows constexpr}}
1379    friend Q::Q(Q&&) noexcept; // expected-error {{follows constexpr}}
1380    friend Q::Q(const Q&) noexcept; // expected-error {{follows constexpr}}
1381    friend S::S() noexcept; // expected-error {{follows constexpr}}
1382    friend S::S(S&&) noexcept; // expected-error {{follows constexpr}}
1383    friend S::S(const S&) noexcept; // expected-error {{follows constexpr}}
1384    friend constexpr U::U() noexcept; // expected-error {{follows non-constexpr}}
1385    friend constexpr U::U(U&&) noexcept; // expected-error {{follows non-constexpr}}
1386    friend constexpr U::U(const U&) noexcept; // expected-error {{follows non-constexpr}}
1387  };
1388}
1389
1390// Indirectly test that an implicit lvalue to xvalue conversion performed for
1391// an NRVO move operation isn't implemented as CK_LValueToRValue.
1392namespace PR12826 {
1393  struct Foo {};
1394  constexpr Foo id(Foo x) { return x; }
1395  constexpr Foo res(id(Foo()));
1396}
1397
1398namespace PR13273 {
1399  struct U {
1400    int t;
1401    U() = default;
1402  };
1403
1404  struct S : U {
1405    S() = default;
1406  };
1407
1408  // S's default constructor isn't constexpr, because U's default constructor
1409  // doesn't initialize 't', but it's trivial, so value-initialization doesn't
1410  // actually call it.
1411  static_assert(S{}.t == 0, "");
1412}
1413
1414namespace PR12670 {
1415  struct S {
1416    constexpr S(int a0) : m(a0) {}
1417    constexpr S() : m(6) {}
1418    int m;
1419  };
1420  constexpr S x[3] = { {4}, 5 };
1421  static_assert(x[0].m == 4, "");
1422  static_assert(x[1].m == 5, "");
1423  static_assert(x[2].m == 6, "");
1424}
1425
1426// Indirectly test that an implicit lvalue-to-rvalue conversion is performed
1427// when a conditional operator has one argument of type void and where the other
1428// is a glvalue of class type.
1429namespace ConditionalLValToRVal {
1430  struct A {
1431    constexpr A(int a) : v(a) {}
1432    int v;
1433  };
1434
1435  constexpr A f(const A &a) {
1436    return a.v == 0 ? throw a : a;
1437  }
1438
1439  constexpr A a(4);
1440  static_assert(f(a).v == 4, "");
1441}
1442
1443namespace TLS {
1444  __thread int n;
1445  int m;
1446
1447  constexpr bool b = &n == &n;
1448
1449  constexpr int *p = &n; // expected-error{{constexpr variable 'p' must be initialized by a constant expression}}
1450
1451  constexpr int *f() { return &n; }
1452  constexpr int *q = f(); // expected-error{{constexpr variable 'q' must be initialized by a constant expression}}
1453  constexpr bool c = f() == f();
1454
1455  constexpr int *g() { return &m; }
1456  constexpr int *r = g();
1457}
1458
1459namespace Void {
1460  constexpr void f() { return; } // expected-error{{constexpr function's return type 'void' is not a literal type}}
1461
1462  void assert_failed(const char *msg, const char *file, int line); // expected-note {{declared here}}
1463#define ASSERT(expr) ((expr) ? static_cast<void>(0) : assert_failed(#expr, __FILE__, __LINE__))
1464  template<typename T, size_t S>
1465  constexpr T get(T (&a)[S], size_t k) {
1466    return ASSERT(k > 0 && k < S), a[k]; // expected-note{{non-constexpr function 'assert_failed'}}
1467  }
1468#undef ASSERT
1469  template int get(int (&a)[4], size_t);
1470  constexpr int arr[] = { 4, 1, 2, 3, 4 };
1471  static_assert(get(arr, 1) == 1, "");
1472  static_assert(get(arr, 4) == 4, "");
1473  static_assert(get(arr, 0) == 4, ""); // expected-error{{not an integral constant expression}} \
1474  // expected-note{{in call to 'get(arr, 0)'}}
1475}
1476
1477namespace std { struct type_info; }
1478
1479namespace TypeId {
1480  struct A { virtual ~A(); };
1481  A f();
1482  A &g();
1483  constexpr auto &x = typeid(f());
1484  constexpr auto &y = typeid(g()); // expected-error{{constant expression}} \
1485  // expected-note{{typeid applied to expression of polymorphic type 'TypeId::A' is not allowed in a constant expression}}
1486}
1487
1488namespace PR14203 {
1489  struct duration {
1490    constexpr duration() {}
1491    constexpr operator int() const { return 0; }
1492  };
1493  template<typename T> void f() {
1494    // If we want to evaluate this at the point of the template definition, we
1495    // need to trigger the implicit definition of the move constructor at that
1496    // point.
1497    // FIXME: C++ does not permit us to implicitly define it at the appropriate
1498    // times, since it is only allowed to be implicitly defined when it is
1499    // odr-used.
1500    constexpr duration d = duration();
1501  }
1502  // FIXME: It's unclear whether this is valid. On the one hand, we're not
1503  // allowed to generate a move constructor. On the other hand, if we did,
1504  // this would be a constant expression. For now, we generate a move
1505  // constructor here.
1506  int n = sizeof(short{duration(duration())});
1507}
1508
1509namespace ArrayEltInit {
1510  struct A {
1511    constexpr A() : p(&p) {}
1512    void *p;
1513  };
1514  constexpr A a[10];
1515  static_assert(a[0].p == &a[0].p, "");
1516  static_assert(a[9].p == &a[9].p, "");
1517  static_assert(a[0].p != &a[9].p, "");
1518  static_assert(a[9].p != &a[0].p, "");
1519
1520  constexpr A b[10] = {};
1521  static_assert(b[0].p == &b[0].p, "");
1522  static_assert(b[9].p == &b[9].p, "");
1523  static_assert(b[0].p != &b[9].p, "");
1524  static_assert(b[9].p != &b[0].p, "");
1525}
1526
1527namespace PR15884 {
1528  struct S {};
1529  constexpr S f() { return {}; }
1530  constexpr S *p = &f();
1531  // expected-error@-1 {{taking the address of a temporary}}
1532  // expected-error@-2 {{constexpr variable 'p' must be initialized by a constant expression}}
1533  // expected-note@-3 {{pointer to temporary is not a constant expression}}
1534  // expected-note@-4 {{temporary created here}}
1535}
1536
1537namespace AfterError {
1538  // FIXME: Suppress the 'no return statements' diagnostic if the body is invalid.
1539  constexpr int error() { // expected-error {{no return statement}}
1540    return foobar; // expected-error {{undeclared identifier}}
1541  }
1542  constexpr int k = error(); // expected-error {{must be initialized by a constant expression}}
1543}
1544