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