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