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