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