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