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