1// RUN: %clang_cc1 -triple i686-linux -Wno-string-plus-int -Wno-pointer-arith -Wno-zero-length-array -fsyntax-only -fcxx-exceptions -verify -std=c++11 -pedantic %s -Wno-comment -Wno-tautological-pointer-compare -Wno-bool-conversion
2
3namespace StaticAssertFoldTest {
4
5int x;
6static_assert(++x, "test"); // expected-error {{not an integral constant expression}}
7static_assert(false, "test"); // expected-error {{test}}
8
9}
10
11typedef decltype(sizeof(char)) size_t;
12
13template<typename T> constexpr T id(const T &t) { return t; }
14template<typename T> constexpr T min(const T &a, const T &b) {
15  return a < b ? a : b;
16}
17template<typename T> constexpr T max(const T &a, const T &b) {
18  return a < b ? b : a;
19}
20template<typename T, size_t N> constexpr T *begin(T (&xs)[N]) { return xs; }
21template<typename T, size_t N> constexpr T *end(T (&xs)[N]) { return xs + N; }
22
23struct MemberZero {
24  constexpr int zero() const { return 0; }
25};
26
27namespace DerivedToVBaseCast {
28
29  struct U { int n; };
30  struct V : U { int n; };
31  struct A : virtual V { int n; };
32  struct Aa { int n; };
33  struct B : virtual A, Aa {};
34  struct C : virtual A, Aa {};
35  struct D : B, C {};
36
37  D d;
38  constexpr B *p = &d;
39  constexpr C *q = &d;
40
41  static_assert((void*)p != (void*)q, "");
42  static_assert((A*)p == (A*)q, "");
43  static_assert((Aa*)p != (Aa*)q, "");
44
45  constexpr B &pp = d;
46  constexpr C &qq = d;
47  static_assert((void*)&pp != (void*)&qq, "");
48  static_assert(&(A&)pp == &(A&)qq, "");
49  static_assert(&(Aa&)pp != &(Aa&)qq, "");
50
51  constexpr V *v = p;
52  constexpr V *w = q;
53  constexpr V *x = (A*)p;
54  static_assert(v == w, "");
55  static_assert(v == x, "");
56
57  static_assert((U*)&d == p, "");
58  static_assert((U*)&d == q, "");
59  static_assert((U*)&d == v, "");
60  static_assert((U*)&d == w, "");
61  static_assert((U*)&d == x, "");
62
63  struct X {};
64  struct Y1 : virtual X {};
65  struct Y2 : X {};
66  struct Z : Y1, Y2 {};
67  Z z;
68  static_assert((X*)(Y1*)&z != (X*)(Y2*)&z, "");
69}
70
71namespace ConstCast {
72
73constexpr int n1 = 0;
74constexpr int n2 = const_cast<int&>(n1);
75constexpr int *n3 = const_cast<int*>(&n1);
76constexpr int n4 = *const_cast<int*>(&n1);
77constexpr const int * const *n5 = const_cast<const int* const*>(&n3);
78constexpr int **n6 = const_cast<int**>(&n3);
79constexpr int n7 = **n5;
80constexpr int n8 = **n6;
81
82// const_cast from prvalue to xvalue.
83struct A { int n; };
84constexpr int n9 = (const_cast<A&&>(A{123})).n;
85static_assert(n9 == 123, "");
86
87}
88
89namespace TemplateArgumentConversion {
90  template<int n> struct IntParam {};
91
92  using IntParam0 = IntParam<0>;
93  using IntParam0 = IntParam<id(0)>;
94  using IntParam0 = IntParam<MemberZero().zero>; // expected-error {{did you mean to call it with no arguments?}}
95}
96
97namespace CaseStatements {
98  int x;
99  void f(int n) {
100    switch (n) {
101    case MemberZero().zero: // expected-error {{did you mean to call it with no arguments?}} expected-note {{previous}}
102    case id(0): // expected-error {{duplicate case value '0'}}
103      return;
104    case __builtin_constant_p(true) ? (__SIZE_TYPE__)&x : 0:; // expected-error {{constant}}
105    }
106  }
107}
108
109extern int &Recurse1;
110int &Recurse2 = Recurse1; // expected-note {{declared here}}
111int &Recurse1 = Recurse2;
112constexpr int &Recurse3 = Recurse2; // expected-error {{must be initialized by a constant expression}} expected-note {{initializer of 'Recurse2' is not a constant expression}}
113
114extern const int RecurseA;
115const int RecurseB = RecurseA; // expected-note {{declared here}}
116const int RecurseA = 10;
117constexpr int RecurseC = RecurseB; // expected-error {{must be initialized by a constant expression}} expected-note {{initializer of 'RecurseB' is not a constant expression}}
118
119namespace MemberEnum {
120  struct WithMemberEnum {
121    enum E { A = 42 };
122  } wme;
123
124  static_assert(wme.A == 42, "");
125}
126
127namespace DefaultArguments {
128
129const int z = int();
130constexpr int Sum(int a = 0, const int &b = 0, const int *c = &z, char d = 0) {
131  return a + b + *c + d;
132}
133const int four = 4;
134constexpr int eight = 8;
135constexpr const int twentyseven = 27;
136static_assert(Sum() == 0, "");
137static_assert(Sum(1) == 1, "");
138static_assert(Sum(1, four) == 5, "");
139static_assert(Sum(1, eight, &twentyseven) == 36, "");
140static_assert(Sum(1, 2, &four, eight) == 15, "");
141
142}
143
144namespace Ellipsis {
145
146// Note, values passed through an ellipsis can't actually be used.
147constexpr int F(int a, ...) { return a; }
148static_assert(F(0) == 0, "");
149static_assert(F(1, 0) == 1, "");
150static_assert(F(2, "test") == 2, "");
151static_assert(F(3, &F) == 3, "");
152int k = 0; // expected-note {{here}}
153static_assert(F(4, k) == 3, ""); // expected-error {{constant expression}} expected-note {{read of non-const variable 'k'}}
154
155}
156
157namespace Recursion {
158  constexpr int fib(int n) { return n > 1 ? fib(n-1) + fib(n-2) : n; }
159  static_assert(fib(11) == 89, "");
160
161  constexpr int gcd_inner(int a, int b) {
162    return b == 0 ? a : gcd_inner(b, a % b);
163  }
164  constexpr int gcd(int a, int b) {
165    return gcd_inner(max(a, b), min(a, b));
166  }
167
168  static_assert(gcd(1749237, 5628959) == 7, "");
169}
170
171namespace FunctionCast {
172  // When folding, we allow functions to be cast to different types. Such
173  // cast functions cannot be called, even if they're constexpr.
174  constexpr int f() { return 1; }
175  typedef double (*DoubleFn)();
176  typedef int (*IntFn)();
177  int a[(int)DoubleFn(f)()]; // expected-error {{variable length array}} expected-warning{{C99 feature}}
178  int b[(int)IntFn(f)()];    // ok
179}
180
181namespace StaticMemberFunction {
182  struct S {
183    static constexpr int k = 42;
184    static constexpr int f(int n) { return n * k + 2; }
185  } s;
186
187  constexpr int n = s.f(19);
188  static_assert(S::f(19) == 800, "");
189  static_assert(s.f(19) == 800, "");
190  static_assert(n == 800, "");
191
192  constexpr int (*sf1)(int) = &S::f;
193  constexpr int (*sf2)(int) = &s.f;
194  constexpr const int *sk = &s.k;
195}
196
197namespace ParameterScopes {
198
199  const int k = 42;
200  constexpr const int &ObscureTheTruth(const int &a) { return a; }
201  constexpr const int &MaybeReturnJunk(bool b, const int a) { // expected-note 2{{declared here}}
202    return ObscureTheTruth(b ? a : k);
203  }
204  static_assert(MaybeReturnJunk(false, 0) == 42, ""); // ok
205  constexpr int a = MaybeReturnJunk(true, 0); // expected-error {{constant expression}} expected-note {{read of variable whose lifetime has ended}}
206
207  constexpr const int MaybeReturnNonstaticRef(bool b, const int a) {
208    return ObscureTheTruth(b ? a : k);
209  }
210  static_assert(MaybeReturnNonstaticRef(false, 0) == 42, ""); // ok
211  constexpr int b = MaybeReturnNonstaticRef(true, 0); // ok
212
213  constexpr int InternalReturnJunk(int n) {
214    return MaybeReturnJunk(true, n); // expected-note {{read of variable whose lifetime has ended}}
215  }
216  constexpr int n3 = InternalReturnJunk(0); // expected-error {{must be initialized by a constant expression}} expected-note {{in call to 'InternalReturnJunk(0)'}}
217
218  constexpr int LToR(int &n) { return n; }
219  constexpr int GrabCallersArgument(bool which, int a, int b) {
220    return LToR(which ? b : a);
221  }
222  static_assert(GrabCallersArgument(false, 1, 2) == 1, "");
223  static_assert(GrabCallersArgument(true, 4, 8) == 8, "");
224
225}
226
227namespace Pointers {
228
229  constexpr int f(int n, const int *a, const int *b, const int *c) {
230    return n == 0 ? 0 : *a + f(n-1, b, c, a);
231  }
232
233  const int x = 1, y = 10, z = 100;
234  static_assert(f(23, &x, &y, &z) == 788, "");
235
236  constexpr int g(int n, int a, int b, int c) {
237    return f(n, &a, &b, &c);
238  }
239  static_assert(g(23, x, y, z) == 788, "");
240
241}
242
243namespace FunctionPointers {
244
245  constexpr int Double(int n) { return 2 * n; }
246  constexpr int Triple(int n) { return 3 * n; }
247  constexpr int Twice(int (*F)(int), int n) { return F(F(n)); }
248  constexpr int Quadruple(int n) { return Twice(Double, n); }
249  constexpr auto Select(int n) -> int (*)(int) {
250    return n == 2 ? &Double : n == 3 ? &Triple : n == 4 ? &Quadruple : 0;
251  }
252  constexpr int Apply(int (*F)(int), int n) { return F(n); } // expected-note {{subexpression}}
253
254  static_assert(1 + Apply(Select(4), 5) + Apply(Select(3), 7) == 42, "");
255
256  constexpr int Invalid = Apply(Select(0), 0); // expected-error {{must be initialized by a constant expression}} expected-note {{in call to 'Apply(0, 0)'}}
257
258}
259
260namespace PointerComparison {
261
262int x, y;
263static_assert(&x == &y, "false"); // expected-error {{false}}
264static_assert(&x != &y, "");
265constexpr bool g1 = &x == &y;
266constexpr bool g2 = &x != &y;
267constexpr bool g3 = &x <= &y; // expected-error {{must be initialized by a constant expression}}
268constexpr bool g4 = &x >= &y; // expected-error {{must be initialized by a constant expression}}
269constexpr bool g5 = &x < &y; // expected-error {{must be initialized by a constant expression}}
270constexpr bool g6 = &x > &y; // expected-error {{must be initialized by a constant expression}}
271
272struct S { int x, y; } s;
273static_assert(&s.x == &s.y, "false"); // expected-error {{false}}
274static_assert(&s.x != &s.y, "");
275static_assert(&s.x <= &s.y, "");
276static_assert(&s.x >= &s.y, "false"); // expected-error {{false}}
277static_assert(&s.x < &s.y, "");
278static_assert(&s.x > &s.y, "false"); // expected-error {{false}}
279
280static_assert(0 == &y, "false"); // expected-error {{false}}
281static_assert(0 != &y, "");
282constexpr bool n3 = 0 <= &y; // expected-error {{must be initialized by a constant expression}}
283constexpr bool n4 = 0 >= &y; // expected-error {{must be initialized by a constant expression}}
284constexpr bool n5 = 0 < &y; // expected-error {{must be initialized by a constant expression}}
285constexpr bool n6 = 0 > &y; // expected-error {{must be initialized by a constant expression}}
286
287static_assert(&x == 0, "false"); // expected-error {{false}}
288static_assert(&x != 0, "");
289constexpr bool n9 = &x <= 0; // expected-error {{must be initialized by a constant expression}}
290constexpr bool n10 = &x >= 0; // expected-error {{must be initialized by a constant expression}}
291constexpr bool n11 = &x < 0; // expected-error {{must be initialized by a constant expression}}
292constexpr bool n12 = &x > 0; // expected-error {{must be initialized by a constant expression}}
293
294static_assert(&x == &x, "");
295static_assert(&x != &x, "false"); // expected-error {{false}}
296static_assert(&x <= &x, "");
297static_assert(&x >= &x, "");
298static_assert(&x < &x, "false"); // expected-error {{false}}
299static_assert(&x > &x, "false"); // expected-error {{false}}
300
301constexpr S* sptr = &s;
302constexpr bool dyncast = sptr == dynamic_cast<S*>(sptr); // expected-error {{constant expression}} expected-note {{dynamic_cast}}
303
304struct U {};
305struct Str {
306  int a : dynamic_cast<S*>(sptr) == dynamic_cast<S*>(sptr); // \
307    expected-warning {{not an integral constant expression}} \
308    expected-note {{dynamic_cast is not allowed in a constant expression}}
309  int b : reinterpret_cast<S*>(sptr) == reinterpret_cast<S*>(sptr); // \
310    expected-warning {{not an integral constant expression}} \
311    expected-note {{reinterpret_cast is not allowed in a constant expression}}
312  int c : (S*)(long)(sptr) == (S*)(long)(sptr); // \
313    expected-warning {{not an integral constant expression}} \
314    expected-note {{cast that performs the conversions of a reinterpret_cast is not allowed in a constant expression}}
315  int d : (S*)(42) == (S*)(42); // \
316    expected-warning {{not an integral constant expression}} \
317    expected-note {{cast that performs the conversions of a reinterpret_cast is not allowed in a constant expression}}
318  int e : (Str*)(sptr) == (Str*)(sptr); // \
319    expected-warning {{not an integral constant expression}} \
320    expected-note {{cast that performs the conversions of a reinterpret_cast is not allowed in a constant expression}}
321  int f : &(U&)(*sptr) == &(U&)(*sptr); // \
322    expected-warning {{not an integral constant expression}} \
323    expected-note {{cast that performs the conversions of a reinterpret_cast is not allowed in a constant expression}}
324  int g : (S*)(void*)(sptr) == sptr; // \
325    expected-warning {{not an integral constant expression}} \
326    expected-note {{cast from 'void *' is not allowed in a constant expression}}
327};
328
329extern char externalvar[];
330constexpr bool constaddress = (void *)externalvar == (void *)0x4000UL; // expected-error {{must be initialized by a constant expression}} expected-note {{reinterpret_cast}}
331constexpr bool litaddress = "foo" == "foo"; // expected-error {{must be initialized by a constant expression}} expected-warning {{unspecified}}
332static_assert(0 != "foo", "");
333
334}
335
336namespace MaterializeTemporary {
337
338constexpr int f(const int &r) { return r; }
339constexpr int n = f(1);
340
341constexpr bool same(const int &a, const int &b) { return &a == &b; }
342constexpr bool sameTemporary(const int &n) { return same(n, n); }
343
344static_assert(n, "");
345static_assert(!same(4, 4), "");
346static_assert(same(n, n), "");
347static_assert(sameTemporary(9), "");
348
349struct A { int &&r; };
350struct B { A &&a1; A &&a2; };
351
352constexpr B b1 { { 1 }, { 2 } }; // expected-note {{temporary created here}}
353static_assert(&b1.a1 != &b1.a2, "");
354static_assert(&b1.a1.r != &b1.a2.r, ""); // expected-error {{constant expression}} expected-note {{outside the expression that created the temporary}}
355
356constexpr B &&b2 { { 3 }, { 4 } }; // expected-note {{temporary created here}}
357static_assert(&b1 != &b2, "");
358static_assert(&b1.a1 != &b2.a1, ""); // expected-error {{constant expression}} expected-note {{outside the expression that created the temporary}}
359
360constexpr thread_local B b3 { { 1 }, { 2 } }; // expected-error {{constant expression}} expected-note {{reference to temporary}} expected-note {{here}}
361void foo() {
362  constexpr static B b1 { { 1 }, { 2 } }; // ok
363  constexpr thread_local B b2 { { 1 }, { 2 } }; // expected-error {{constant expression}} expected-note {{reference to temporary}} expected-note {{here}}
364  constexpr B b3 { { 1 }, { 2 } }; // expected-error {{constant expression}} expected-note {{reference to temporary}} expected-note {{here}}
365}
366
367constexpr B &&b4 = ((1, 2), 3, 4, B { {10}, {{20}} }); // expected-warning 4{{unused}}
368static_assert(&b4 != &b2, "");
369
370// Proposed DR: copy-elision doesn't trigger lifetime extension.
371constexpr B b5 = B{ {0}, {0} }; // expected-error {{constant expression}} expected-note {{reference to temporary}} expected-note {{here}}
372
373namespace NestedNonStatic {
374  // Proposed DR: for a reference constant expression to refer to a static
375  // storage duration temporary, that temporary must itself be initialized
376  // by a constant expression (a core constant expression is not enough).
377  struct A { int &&r; };
378  struct B { A &&a; };
379  constexpr B a = { A{0} }; // ok
380  constexpr B b = { A(A{0}) }; // expected-error {{constant expression}} expected-note {{reference to temporary}} expected-note {{here}}
381}
382
383namespace FakeInitList {
384  struct init_list_3_ints { const int (&x)[3]; };
385  struct init_list_2_init_list_3_ints { const init_list_3_ints (&x)[2]; };
386  constexpr init_list_2_init_list_3_ints ils = { { { { 1, 2, 3 } }, { { 4, 5, 6 } } } };
387}
388
389}
390
391constexpr int strcmp_ce(const char *p, const char *q) {
392  return (!*p || *p != *q) ? *p - *q : strcmp_ce(p+1, q+1);
393}
394
395namespace StringLiteral {
396
397template<typename Char>
398constexpr int MangleChars(const Char *p) {
399  return *p + 3 * (*p ? MangleChars(p+1) : 0);
400}
401
402static_assert(MangleChars("constexpr!") == 1768383, "");
403static_assert(MangleChars(u8"constexpr!") == 1768383, "");
404static_assert(MangleChars(L"constexpr!") == 1768383, "");
405static_assert(MangleChars(u"constexpr!") == 1768383, "");
406static_assert(MangleChars(U"constexpr!") == 1768383, "");
407
408constexpr char c0 = "nought index"[0];
409constexpr char c1 = "nice index"[10];
410constexpr 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}}
411constexpr 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}}
412constexpr char c4 = ((char*)(int*)"no reinterpret_casts allowed")[14]; // expected-error {{must be initialized by a constant expression}} expected-note {{cast that performs the conversions of a reinterpret_cast}}
413
414constexpr const char *p = "test" + 2;
415static_assert(*p == 's', "");
416
417constexpr const char *max_iter(const char *a, const char *b) {
418  return *a < *b ? b : a;
419}
420constexpr const char *max_element(const char *a, const char *b) {
421  return (a+1 >= b) ? a : max_iter(a, max_element(a+1, b));
422}
423
424constexpr char str[] = "the quick brown fox jumped over the lazy dog";
425constexpr const char *max = max_element(begin(str), end(str));
426static_assert(*max == 'z', "");
427static_assert(max == str + 38, "");
428
429static_assert(strcmp_ce("hello world", "hello world") == 0, "");
430static_assert(strcmp_ce("hello world", "hello clang") > 0, "");
431static_assert(strcmp_ce("constexpr", "test") < 0, "");
432static_assert(strcmp_ce("", " ") < 0, "");
433
434struct S {
435  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}}
436};
437
438struct T {
439  char c[6];
440  constexpr T() : c{"foo"} {}
441};
442constexpr T t;
443
444static_assert(t.c[0] == 'f', "");
445static_assert(t.c[1] == 'o', "");
446static_assert(t.c[2] == 'o', "");
447static_assert(t.c[3] == 0, "");
448static_assert(t.c[4] == 0, "");
449static_assert(t.c[5] == 0, "");
450static_assert(t.c[6] == 0, ""); // expected-error {{constant expression}} expected-note {{one-past-the-end}}
451
452struct U {
453  wchar_t chars[6];
454  int n;
455} constexpr u = { { L"test" }, 0 };
456static_assert(u.chars[2] == L's', "");
457
458struct V {
459  char c[4];
460  constexpr V() : c("hi!") {}
461};
462static_assert(V().c[1] == "i"[0], "");
463
464namespace Parens {
465  constexpr unsigned char a[] = ("foo"), b[] = {"foo"}, c[] = {("foo")},
466                          d[4] = ("foo"), e[5] = {"foo"}, f[6] = {("foo")};
467  static_assert(a[0] == 'f', "");
468  static_assert(b[1] == 'o', "");
469  static_assert(c[2] == 'o', "");
470  static_assert(d[0] == 'f', "");
471  static_assert(e[1] == 'o', "");
472  static_assert(f[2] == 'o', "");
473  static_assert(f[5] == 0, "");
474  static_assert(f[6] == 0, ""); // expected-error {{constant expression}} expected-note {{one-past-the-end}}
475}
476
477}
478
479namespace Array {
480
481template<typename Iter>
482constexpr auto Sum(Iter begin, Iter end) -> decltype(+*begin) {
483  return begin == end ? 0 : *begin + Sum(begin+1, end);
484}
485
486constexpr int xs[] = { 1, 2, 3, 4, 5 };
487constexpr int ys[] = { 5, 4, 3, 2, 1 };
488constexpr int sum_xs = Sum(begin(xs), end(xs));
489static_assert(sum_xs == 15, "");
490
491constexpr int ZipFoldR(int (*F)(int x, int y, int c), int n,
492                       const int *xs, const int *ys, int c) {
493  return n ? F(
494               *xs, // expected-note {{read of dereferenced one-past-the-end pointer}}
495               *ys,
496               ZipFoldR(F, n-1, xs+1, ys+1, c)) // \
497      expected-note {{in call to 'ZipFoldR(&SubMul, 2, &xs[4], &ys[4], 1)'}} \
498      expected-note {{in call to 'ZipFoldR(&SubMul, 1, &xs[5], &ys[5], 1)'}}
499           : c;
500}
501constexpr int MulAdd(int x, int y, int c) { return x * y + c; }
502constexpr int InnerProduct = ZipFoldR(MulAdd, 5, xs, ys, 0);
503static_assert(InnerProduct == 35, "");
504
505constexpr int SubMul(int x, int y, int c) { return (x - y) * c; }
506constexpr int DiffProd = ZipFoldR(SubMul, 2, xs+3, ys+3, 1);
507static_assert(DiffProd == 8, "");
508static_assert(ZipFoldR(SubMul, 3, xs+3, ys+3, 1), ""); // \
509      expected-error {{constant expression}} \
510      expected-note {{in call to 'ZipFoldR(&SubMul, 3, &xs[3], &ys[3], 1)'}}
511
512constexpr const int *p = xs + 3;
513constexpr int xs4 = p[1]; // ok
514constexpr int xs5 = p[2]; // expected-error {{constant expression}} expected-note {{read of dereferenced one-past-the-end pointer}}
515constexpr int xs6 = p[3]; // expected-error {{constant expression}} expected-note {{cannot refer to element 6}}
516constexpr int xs0 = p[-3]; // ok
517constexpr int xs_1 = p[-4]; // expected-error {{constant expression}} expected-note {{cannot refer to element -1}}
518
519constexpr int zs[2][2][2][2] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
520static_assert(zs[0][0][0][0] == 1, "");
521static_assert(zs[1][1][1][1] == 16, "");
522static_assert(zs[0][0][0][2] == 3, ""); // expected-error {{constant expression}} expected-note {{read of dereferenced one-past-the-end pointer}}
523static_assert((&zs[0][0][0][2])[-1] == 2, "");
524static_assert(**(**(zs + 1) + 1) == 11, "");
525static_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}}
526static_assert(*(&(&(*(*&(&zs[2] - 1)[0] + 2 - 2))[2])[-1][2] - 2) == 11, "");
527constexpr 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}}
528
529constexpr int fail(const int &p) {
530  return (&p)[64]; // expected-note {{cannot refer to element 64 of array of 2 elements}}
531}
532static_assert(fail(*(&(&(*(*&(&zs[2] - 1)[0] + 2 - 2))[2])[-1][2] - 2)) == 11, ""); // \
533expected-error {{static_assert expression is not an integral constant expression}} \
534expected-note {{in call to 'fail(zs[1][0][1][0])'}}
535
536constexpr int arr[40] = { 1, 2, 3, [8] = 4 }; // expected-warning {{C99 feature}}
537constexpr int SumNonzero(const int *p) {
538  return *p + (*p ? SumNonzero(p+1) : 0);
539}
540constexpr int CountZero(const int *p, const int *q) {
541  return p == q ? 0 : (*p == 0) + CountZero(p+1, q);
542}
543static_assert(SumNonzero(arr) == 6, "");
544static_assert(CountZero(arr, arr + 40) == 36, "");
545
546struct ArrayElem {
547  constexpr ArrayElem() : n(0) {}
548  int n;
549  constexpr int f() const { return n; }
550};
551struct ArrayRVal {
552  constexpr ArrayRVal() {}
553  ArrayElem elems[10];
554};
555static_assert(ArrayRVal().elems[3].f() == 0, "");
556
557constexpr int selfref[2][2][2] = {
558  selfref[1][1][1] + 1, selfref[0][0][0] + 1,
559  selfref[1][0][1] + 1, selfref[0][1][0] + 1,
560  selfref[1][0][0] + 1, selfref[0][1][1] + 1 };
561static_assert(selfref[0][0][0] == 1, "");
562static_assert(selfref[0][0][1] == 2, "");
563static_assert(selfref[0][1][0] == 1, "");
564static_assert(selfref[0][1][1] == 2, "");
565static_assert(selfref[1][0][0] == 1, "");
566static_assert(selfref[1][0][1] == 3, "");
567static_assert(selfref[1][1][0] == 0, "");
568static_assert(selfref[1][1][1] == 0, "");
569
570struct TrivialDefCtor { int n; };
571typedef TrivialDefCtor TDCArray[2][2];
572static_assert(TDCArray{}[1][1].n == 0, "");
573
574struct NonAggregateTDC : TrivialDefCtor {};
575typedef NonAggregateTDC NATDCArray[2][2];
576static_assert(NATDCArray{}[1][1].n == 0, "");
577
578}
579
580namespace DependentValues {
581
582struct I { int n; typedef I V[10]; };
583I::V x, y;
584int g();
585template<bool B, typename T> struct S : T {
586  int k;
587  void f() {
588    I::V &cells = B ? x : y;
589    I &i = cells[k];
590    switch (i.n) {}
591
592    // FIXME: We should be able to diagnose this.
593    constexpr int n = g();
594
595    constexpr int m = this->g(); // ok, could be constexpr
596  }
597};
598
599}
600
601namespace Class {
602
603struct A { constexpr A(int a, int b) : k(a + b) {} int k; };
604constexpr int fn(const A &a) { return a.k; }
605static_assert(fn(A(4,5)) == 9, "");
606
607struct B { int n; int m; } constexpr b = { 0, b.n };
608struct C {
609  constexpr C(C *this_) : m(42), n(this_->m) {} // ok
610  int m, n;
611};
612struct D {
613  C c;
614  constexpr D() : c(&c) {}
615};
616static_assert(D().c.n == 42, "");
617
618struct E {
619  constexpr E() : p(&p) {}
620  void *p;
621};
622constexpr const E &e1 = E();
623// This is a constant expression if we elide the copy constructor call, and
624// is not a constant expression if we don't! But we do, so it is.
625constexpr E e2 = E();
626static_assert(e2.p == &e2.p, "");
627constexpr E e3;
628static_assert(e3.p == &e3.p, "");
629
630extern const class F f;
631struct F {
632  constexpr F() : p(&f.p) {}
633  const void *p;
634};
635constexpr F f;
636
637struct G {
638  struct T {
639    constexpr T(T *p) : u1(), u2(p) {}
640    union U1 {
641      constexpr U1() {}
642      int a, b = 42;
643    } u1;
644    union U2 {
645      constexpr U2(T *p) : c(p->u1.b) {}
646      int c, d;
647    } u2;
648  } t;
649  constexpr G() : t(&t) {}
650} constexpr g;
651
652static_assert(g.t.u1.a == 42, ""); // expected-error {{constant expression}} expected-note {{read of member 'a' of union with active member 'b'}}
653static_assert(g.t.u1.b == 42, "");
654static_assert(g.t.u2.c == 42, "");
655static_assert(g.t.u2.d == 42, ""); // expected-error {{constant expression}} expected-note {{read of member 'd' of union with active member 'c'}}
656
657struct S {
658  int a, b;
659  const S *p;
660  double d;
661  const char *q;
662
663  constexpr S(int n, const S *p) : a(5), b(n), p(p), d(n), q("hello") {}
664};
665
666S global(43, &global);
667
668static_assert(S(15, &global).b == 15, "");
669
670constexpr bool CheckS(const S &s) {
671  return s.a == 5 && s.b == 27 && s.p == &global && s.d == 27. && s.q[3] == 'l';
672}
673static_assert(CheckS(S(27, &global)), "");
674
675struct Arr {
676  char arr[3];
677  constexpr Arr() : arr{'x', 'y', 'z'} {}
678};
679constexpr int hash(Arr &&a) {
680  return a.arr[0] + a.arr[1] * 0x100 + a.arr[2] * 0x10000;
681}
682constexpr int k = hash(Arr());
683static_assert(k == 0x007a7978, "");
684
685
686struct AggregateInit {
687  const char &c;
688  int n;
689  double d;
690  int arr[5];
691  void *p;
692};
693
694constexpr AggregateInit agg1 = { "hello"[0] };
695
696static_assert(strcmp_ce(&agg1.c, "hello") == 0, "");
697static_assert(agg1.n == 0, "");
698static_assert(agg1.d == 0.0, "");
699static_assert(agg1.arr[-1] == 0, ""); // expected-error {{constant expression}} expected-note {{cannot refer to element -1}}
700static_assert(agg1.arr[0] == 0, "");
701static_assert(agg1.arr[4] == 0, "");
702static_assert(agg1.arr[5] == 0, ""); // expected-error {{constant expression}} expected-note {{read of dereferenced one-past-the-end}}
703static_assert(agg1.p == nullptr, "");
704
705static constexpr const unsigned char uc[] = { "foo" };
706static_assert(uc[0] == 'f', "");
707static_assert(uc[3] == 0, "");
708
709namespace SimpleDerivedClass {
710
711struct B {
712  constexpr B(int n) : a(n) {}
713  int a;
714};
715struct D : B {
716  constexpr D(int n) : B(n) {}
717};
718constexpr D d(3);
719static_assert(d.a == 3, "");
720
721}
722
723struct Bottom { constexpr Bottom() {} };
724struct Base : Bottom {
725  constexpr Base(int a = 42, const char *b = "test") : a(a), b(b) {}
726  int a;
727  const char *b;
728};
729struct Base2 : Bottom {
730  constexpr Base2(const int &r) : r(r) {}
731  int q = 123;
732  const int &r;
733};
734struct Derived : Base, Base2 {
735  constexpr Derived() : Base(76), Base2(a) {}
736  int c = r + b[1];
737};
738
739constexpr bool operator==(const Base &a, const Base &b) {
740  return a.a == b.a && strcmp_ce(a.b, b.b) == 0;
741}
742
743constexpr Base base;
744constexpr Base base2(76);
745constexpr Derived derived;
746static_assert(derived.a == 76, "");
747static_assert(derived.b[2] == 's', "");
748static_assert(derived.c == 76 + 'e', "");
749static_assert(derived.q == 123, "");
750static_assert(derived.r == 76, "");
751static_assert(&derived.r == &derived.a, "");
752
753static_assert(!(derived == base), "");
754static_assert(derived == base2, "");
755
756constexpr Bottom &bot1 = (Base&)derived;
757constexpr Bottom &bot2 = (Base2&)derived;
758static_assert(&bot1 != &bot2, "");
759
760constexpr Bottom *pb1 = (Base*)&derived;
761constexpr Bottom *pb2 = (Base2*)&derived;
762static_assert(&pb1 != &pb2, "");
763static_assert(pb1 == &bot1, "");
764static_assert(pb2 == &bot2, "");
765
766constexpr Base2 &fail = (Base2&)bot1; // expected-error {{constant expression}} expected-note {{cannot cast object of dynamic type 'const Class::Derived' to type 'Class::Base2'}}
767constexpr Base &fail2 = (Base&)*pb2; // expected-error {{constant expression}} expected-note {{cannot cast object of dynamic type 'const Class::Derived' to type 'Class::Base'}}
768constexpr Base2 &ok2 = (Base2&)bot2;
769static_assert(&ok2 == &derived, "");
770
771constexpr Base2 *pfail = (Base2*)pb1; // expected-error {{constant expression}} expected-note {{cannot cast object of dynamic type 'const Class::Derived' to type 'Class::Base2'}}
772constexpr Base *pfail2 = (Base*)&bot2; // expected-error {{constant expression}} expected-note {{cannot cast object of dynamic type 'const Class::Derived' to type 'Class::Base'}}
773constexpr Base2 *pok2 = (Base2*)pb2;
774static_assert(pok2 == &derived, "");
775static_assert(&ok2 == pok2, "");
776static_assert((Base2*)(Derived*)(Base*)pb1 == pok2, "");
777static_assert((Derived*)(Base*)pb1 == (Derived*)pok2, "");
778
779// Core issue 903: we do not perform constant evaluation when checking for a
780// null pointer in C++11. Just check for an integer literal with value 0.
781constexpr Base *nullB = 42 - 6 * 7; // expected-error {{cannot initialize a variable of type 'Class::Base *const' with an rvalue of type 'int'}}
782constexpr Base *nullB1 = 0;
783static_assert((Bottom*)nullB == 0, "");
784static_assert((Derived*)nullB == 0, "");
785static_assert((void*)(Bottom*)nullB == (void*)(Derived*)nullB, "");
786Base *nullB2 = '\0'; // expected-error {{cannot initialize a variable of type 'Class::Base *' with an rvalue of type 'char'}}
787Base *nullB3 = (0);
788Base *nullB4 = false; // expected-error {{cannot initialize a variable of type 'Class::Base *' with an rvalue of type 'bool'}}
789Base *nullB5 = ((0ULL));
790Base *nullB6 = 0.; // expected-error {{cannot initialize a variable of type 'Class::Base *' with an rvalue of type 'double'}}
791enum Null { kNull };
792Base *nullB7 = kNull; // expected-error {{cannot initialize a variable of type 'Class::Base *' with an rvalue of type 'Class::Null'}}
793static_assert(nullB1 == (1 - 1), ""); // expected-error {{comparison between pointer and integer}}
794
795
796
797namespace ConversionOperators {
798
799struct T {
800  constexpr T(int n) : k(5*n - 3) {}
801  constexpr operator int() const { return k; }
802  int k;
803};
804
805struct S {
806  constexpr S(int n) : k(2*n + 1) {}
807  constexpr operator int() const { return k; }
808  constexpr operator T() const { return T(k); }
809  int k;
810};
811
812constexpr bool check(T a, T b) { return a == b.k; }
813
814static_assert(S(5) == 11, "");
815static_assert(check(S(5), 11), "");
816
817namespace PR14171 {
818
819struct X {
820  constexpr (operator int)() const { return 0; }
821};
822static_assert(X() == 0, "");
823
824}
825
826}
827
828struct This {
829  constexpr int f() const { return 0; }
830  static constexpr int g() { return 0; }
831  void h() {
832    constexpr int x = f(); // expected-error {{must be initialized by a constant}}
833    // expected-note@-1 {{implicit use of 'this' pointer is only allowed within the evaluation of a call to a 'constexpr' member function}}
834    constexpr int y = this->f(); // expected-error {{must be initialized by a constant}}
835    // expected-note-re@-1 {{{{^}}use of 'this' pointer}}
836    constexpr int z = g();
837    static_assert(z == 0, "");
838  }
839};
840
841}
842
843namespace Temporaries {
844
845struct S {
846  constexpr S() {}
847  constexpr int f() const;
848  constexpr int g() const;
849};
850struct T : S {
851  constexpr T(int n) : S(), n(n) {}
852  int n;
853};
854constexpr int S::f() const {
855  return static_cast<const T*>(this)->n; // expected-note {{cannot cast}}
856}
857constexpr int S::g() const {
858  // FIXME: Better diagnostic for this.
859  return this->*(int(S::*))&T::n; // expected-note {{subexpression}}
860}
861// The T temporary is implicitly cast to an S subobject, but we can recover the
862// T full-object via a base-to-derived cast, or a derived-to-base-casted member
863// pointer.
864static_assert(S().f(), ""); // expected-error {{constant expression}} expected-note {{in call to '&Temporaries::S()->f()'}}
865static_assert(S().g(), ""); // expected-error {{constant expression}} expected-note {{in call to '&Temporaries::S()->g()'}}
866static_assert(T(3).f() == 3, "");
867static_assert(T(4).g() == 4, "");
868
869constexpr int f(const S &s) {
870  return static_cast<const T&>(s).n;
871}
872constexpr int n = f(T(5));
873static_assert(f(T(5)) == 5, "");
874
875constexpr bool b(int n) { return &n; }
876static_assert(b(0), "");
877
878struct NonLiteral {
879  NonLiteral();
880  int f();
881};
882constexpr int k = NonLiteral().f(); // expected-error {{constant expression}} expected-note {{non-literal type 'Temporaries::NonLiteral'}}
883
884}
885
886namespace Union {
887
888union U {
889  int a;
890  int b;
891};
892
893constexpr U u[4] = { { .a = 0 }, { .b = 1 }, { .a = 2 }, { .b = 3 } }; // expected-warning 4{{C99 feature}}
894static_assert(u[0].a == 0, "");
895static_assert(u[0].b, ""); // expected-error {{constant expression}} expected-note {{read of member 'b' of union with active member 'a'}}
896static_assert(u[1].b == 1, "");
897static_assert((&u[1].b)[1] == 2, ""); // expected-error {{constant expression}} expected-note {{read of dereferenced one-past-the-end pointer}}
898static_assert(*(&(u[1].b) + 1 + 1) == 3, ""); // expected-error {{constant expression}} expected-note {{cannot refer to element 2 of non-array object}}
899static_assert((&(u[1]) + 1 + 1)->b == 3, "");
900
901constexpr U v = {};
902static_assert(v.a == 0, "");
903
904union Empty {};
905constexpr Empty e = {};
906
907// Make sure we handle trivial copy constructors for unions.
908constexpr U x = {42};
909constexpr U y = x;
910static_assert(y.a == 42, "");
911static_assert(y.b == 42, ""); // expected-error {{constant expression}} expected-note {{'b' of union with active member 'a'}}
912
913}
914
915namespace MemberPointer {
916  struct A {
917    constexpr A(int n) : n(n) {}
918    int n;
919    constexpr int f() const { return n + 3; }
920  };
921  constexpr A a(7);
922  static_assert(A(5).*&A::n == 5, "");
923  static_assert((&a)->*&A::n == 7, "");
924  static_assert((A(8).*&A::f)() == 11, "");
925  static_assert(((&a)->*&A::f)() == 10, "");
926
927  struct B : A {
928    constexpr B(int n, int m) : A(n), m(m) {}
929    int m;
930    constexpr int g() const { return n + m + 1; }
931  };
932  constexpr B b(9, 13);
933  static_assert(B(4, 11).*&A::n == 4, "");
934  static_assert(B(4, 11).*&B::m == 11, "");
935  static_assert(B(4, 11).*(int(A::*))&B::m == 11, "");
936  static_assert((&b)->*&A::n == 9, "");
937  static_assert((&b)->*&B::m == 13, "");
938  static_assert((&b)->*(int(A::*))&B::m == 13, "");
939  static_assert((B(4, 11).*&A::f)() == 7, "");
940  static_assert((B(4, 11).*&B::g)() == 16, "");
941  static_assert((B(4, 11).*(int(A::*)()const)&B::g)() == 16, "");
942  static_assert(((&b)->*&A::f)() == 12, "");
943  static_assert(((&b)->*&B::g)() == 23, "");
944  static_assert(((&b)->*(int(A::*)()const)&B::g)() == 23, "");
945
946  struct S {
947    constexpr S(int m, int n, int (S::*pf)() const, int S::*pn) :
948      m(m), n(n), pf(pf), pn(pn) {}
949    constexpr S() : m(), n(), pf(&S::f), pn(&S::n) {}
950
951    constexpr int f() const { return this->*pn; }
952    virtual int g() const;
953
954    int m, n;
955    int (S::*pf)() const;
956    int S::*pn;
957  };
958
959  constexpr int S::*pm = &S::m;
960  constexpr int S::*pn = &S::n;
961  constexpr int (S::*pf)() const = &S::f;
962  constexpr int (S::*pg)() const = &S::g;
963
964  constexpr S s(2, 5, &S::f, &S::m);
965
966  static_assert((s.*&S::f)() == 2, "");
967  static_assert((s.*s.pf)() == 2, "");
968
969  static_assert(pf == &S::f, "");
970  static_assert(pf == s.*&S::pf, "");
971  static_assert(pm == &S::m, "");
972  static_assert(pm != pn, "");
973  static_assert(s.pn != pn, "");
974  static_assert(s.pn == pm, "");
975  static_assert(pg != nullptr, "");
976  static_assert(pf != nullptr, "");
977  static_assert((int S::*)nullptr == nullptr, "");
978  static_assert(pg == pg, ""); // expected-error {{constant expression}} expected-note {{comparison of pointer to virtual member function 'g' has unspecified value}}
979  static_assert(pf != pg, ""); // expected-error {{constant expression}} expected-note {{comparison of pointer to virtual member function 'g' has unspecified value}}
980
981  template<int n> struct T : T<n-1> {};
982  template<> struct T<0> { int n; };
983  template<> struct T<30> : T<29> { int m; };
984
985  T<17> t17;
986  T<30> t30;
987
988  constexpr int (T<10>::*deepn) = &T<0>::n;
989  static_assert(&(t17.*deepn) == &t17.n, "");
990  static_assert(deepn == &T<2>::n, "");
991
992  constexpr int (T<15>::*deepm) = (int(T<10>::*))&T<30>::m;
993  constexpr int *pbad = &(t17.*deepm); // expected-error {{constant expression}}
994  static_assert(&(t30.*deepm) == &t30.m, "");
995  static_assert(deepm == &T<50>::m, "");
996  static_assert(deepm != deepn, "");
997
998  constexpr T<5> *p17_5 = &t17;
999  constexpr T<13> *p17_13 = (T<13>*)p17_5;
1000  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>'}}
1001  static_assert(&(p17_5->*(int(T<3>::*))deepn) == &t17.n, "");
1002  static_assert(&(p17_13->*deepn) == &t17.n, "");
1003  constexpr int *pbad2 = &(p17_13->*(int(T<9>::*))deepm); // expected-error {{constant expression}}
1004
1005  constexpr T<5> *p30_5 = &t30;
1006  constexpr T<23> *p30_23 = (T<23>*)p30_5;
1007  constexpr T<13> *p30_13 = p30_23;
1008  static_assert(&(p30_5->*(int(T<3>::*))deepn) == &t30.n, "");
1009  static_assert(&(p30_13->*deepn) == &t30.n, "");
1010  static_assert(&(p30_23->*deepn) == &t30.n, "");
1011  static_assert(&(p30_5->*(int(T<2>::*))deepm) == &t30.m, "");
1012  static_assert(&(((T<17>*)p30_13)->*deepm) == &t30.m, "");
1013  static_assert(&(p30_23->*deepm) == &t30.m, "");
1014
1015  struct Base { int n; };
1016  template<int N> struct Mid : Base {};
1017  struct Derived : Mid<0>, Mid<1> {};
1018  static_assert(&Mid<0>::n == &Mid<1>::n, "");
1019  static_assert((int Derived::*)(int Mid<0>::*)&Mid<0>::n !=
1020                (int Derived::*)(int Mid<1>::*)&Mid<1>::n, "");
1021  static_assert(&Mid<0>::n == (int Mid<0>::*)&Base::n, "");
1022}
1023
1024namespace ArrayBaseDerived {
1025
1026  struct Base {
1027    constexpr Base() {}
1028    int n = 0;
1029  };
1030  struct Derived : Base {
1031    constexpr Derived() {}
1032    constexpr const int *f() const { return &n; }
1033  };
1034
1035  constexpr Derived a[10];
1036  constexpr Derived *pd3 = const_cast<Derived*>(&a[3]);
1037  constexpr Base *pb3 = const_cast<Derived*>(&a[3]);
1038  static_assert(pb3 == pd3, "");
1039
1040  // pb3 does not point to an array element.
1041  constexpr Base *pb4 = pb3 + 1; // ok, one-past-the-end pointer.
1042  constexpr int pb4n = pb4->n; // expected-error {{constant expression}} expected-note {{cannot access field of pointer past the end}}
1043  constexpr Base *err_pb5 = pb3 + 2; // expected-error {{constant expression}} expected-note {{cannot refer to element 2}} expected-note {{here}}
1044  constexpr int err_pb5n = err_pb5->n; // expected-error {{constant expression}} expected-note {{initializer of 'err_pb5' is not a constant expression}}
1045  constexpr Base *err_pb2 = pb3 - 1; // expected-error {{constant expression}} expected-note {{cannot refer to element -1}} expected-note {{here}}
1046  constexpr int err_pb2n = err_pb2->n; // expected-error {{constant expression}} expected-note {{initializer of 'err_pb2'}}
1047  constexpr Base *pb3a = pb4 - 1;
1048
1049  // pb4 does not point to a Derived.
1050  constexpr Derived *err_pd4 = (Derived*)pb4; // expected-error {{constant expression}} expected-note {{cannot access derived class of pointer past the end}}
1051  constexpr Derived *pd3a = (Derived*)pb3a;
1052  constexpr int pd3n = pd3a->n;
1053
1054  // pd3a still points to the Derived array.
1055  constexpr Derived *pd6 = pd3a + 3;
1056  static_assert(pd6 == &a[6], "");
1057  constexpr Derived *pd9 = pd6 + 3;
1058  constexpr Derived *pd10 = pd6 + 4;
1059  constexpr int pd9n = pd9->n; // ok
1060  constexpr int err_pd10n = pd10->n; // expected-error {{constant expression}} expected-note {{cannot access base class of pointer past the end}}
1061  constexpr int pd0n = pd10[-10].n;
1062  constexpr int err_pdminus1n = pd10[-11].n; // expected-error {{constant expression}} expected-note {{cannot refer to element -1 of}}
1063
1064  constexpr Base *pb9 = pd9;
1065  constexpr const int *(Base::*pfb)() const =
1066      static_cast<const int *(Base::*)() const>(&Derived::f);
1067  static_assert((pb9->*pfb)() == &a[9].n, "");
1068}
1069
1070namespace Complex {
1071
1072class complex {
1073  int re, im;
1074public:
1075  constexpr complex(int re = 0, int im = 0) : re(re), im(im) {}
1076  constexpr complex(const complex &o) : re(o.re), im(o.im) {}
1077  constexpr complex operator-() const { return complex(-re, -im); }
1078  friend constexpr complex operator+(const complex &l, const complex &r) {
1079    return complex(l.re + r.re, l.im + r.im);
1080  }
1081  friend constexpr complex operator-(const complex &l, const complex &r) {
1082    return l + -r;
1083  }
1084  friend constexpr complex operator*(const complex &l, const complex &r) {
1085    return complex(l.re * r.re - l.im * r.im, l.re * r.im + l.im * r.re);
1086  }
1087  friend constexpr bool operator==(const complex &l, const complex &r) {
1088    return l.re == r.re && l.im == r.im;
1089  }
1090  constexpr bool operator!=(const complex &r) const {
1091    return re != r.re || im != r.im;
1092  }
1093  constexpr int real() const { return re; }
1094  constexpr int imag() const { return im; }
1095};
1096
1097constexpr complex i = complex(0, 1);
1098constexpr complex k = (3 + 4*i) * (6 - 4*i);
1099static_assert(complex(1,0).real() == 1, "");
1100static_assert(complex(1,0).imag() == 0, "");
1101static_assert(((complex)1).imag() == 0, "");
1102static_assert(k.real() == 34, "");
1103static_assert(k.imag() == 12, "");
1104static_assert(k - 34 == 12*i, "");
1105static_assert((complex)1 == complex(1), "");
1106static_assert((complex)1 != complex(0, 1), "");
1107static_assert(complex(1) == complex(1), "");
1108static_assert(complex(1) != complex(0, 1), "");
1109constexpr complex makeComplex(int re, int im) { return complex(re, im); }
1110static_assert(makeComplex(1,0) == complex(1), "");
1111static_assert(makeComplex(1,0) != complex(0, 1), "");
1112
1113class complex_wrap : public complex {
1114public:
1115  constexpr complex_wrap(int re, int im = 0) : complex(re, im) {}
1116  constexpr complex_wrap(const complex_wrap &o) : complex(o) {}
1117};
1118
1119static_assert((complex_wrap)1 == complex(1), "");
1120static_assert((complex)1 != complex_wrap(0, 1), "");
1121static_assert(complex(1) == complex_wrap(1), "");
1122static_assert(complex_wrap(1) != complex(0, 1), "");
1123constexpr complex_wrap makeComplexWrap(int re, int im) {
1124  return complex_wrap(re, im);
1125}
1126static_assert(makeComplexWrap(1,0) == complex(1), "");
1127static_assert(makeComplexWrap(1,0) != complex(0, 1), "");
1128
1129}
1130
1131namespace PR11595 {
1132  struct A { constexpr bool operator==(int x) const { return true; } };
1133  struct B { B(); A& x; };
1134  static_assert(B().x == 3, "");  // expected-error {{constant expression}} expected-note {{non-literal type 'PR11595::B' cannot be used in a constant expression}}
1135
1136  constexpr bool f(int k) { // expected-error {{constexpr function never produces a constant expression}}
1137    return B().x == k; // expected-note {{non-literal type 'PR11595::B' cannot be used in a constant expression}}
1138  }
1139}
1140
1141namespace ExprWithCleanups {
1142  struct A { A(); ~A(); int get(); };
1143  constexpr int get(bool FromA) { return FromA ? A().get() : 1; }
1144  constexpr int n = get(false);
1145}
1146
1147namespace Volatile {
1148
1149volatile constexpr int n1 = 0; // expected-note {{here}}
1150volatile const int n2 = 0; // expected-note {{here}}
1151int n3 = 37; // expected-note {{declared here}}
1152
1153constexpr int m1 = n1; // expected-error {{constant expression}} expected-note {{read of volatile-qualified type 'const volatile int'}}
1154constexpr int m2 = n2; // expected-error {{constant expression}} expected-note {{read of volatile-qualified type 'const volatile int'}}
1155constexpr int m1b = const_cast<const int&>(n1); // expected-error {{constant expression}} expected-note {{read of volatile object 'n1'}}
1156constexpr int m2b = const_cast<const int&>(n2); // expected-error {{constant expression}} expected-note {{read of volatile object 'n2'}}
1157
1158struct T { int n; };
1159const T t = { 42 }; // expected-note {{declared here}}
1160
1161constexpr int f(volatile int &&r) {
1162  return r; // expected-note {{read of volatile-qualified type 'volatile int'}}
1163}
1164constexpr int g(volatile int &&r) {
1165  return const_cast<int&>(r); // expected-note {{read of volatile temporary is not allowed in a constant expression}}
1166}
1167struct S {
1168  int j : f(0); // expected-error {{constant expression}} expected-note {{in call to 'f(0)'}}
1169  int k : g(0); // expected-error {{constant expression}} expected-note {{temporary created here}} expected-note {{in call to 'g(0)'}}
1170  int l : n3; // expected-error {{constant expression}} expected-note {{read of non-const variable}}
1171  int m : t.n; // expected-error {{constant expression}} expected-note {{read of non-constexpr variable}}
1172};
1173
1174}
1175
1176namespace ExternConstexpr {
1177  extern constexpr int n = 0;
1178  extern constexpr int m; // expected-error {{constexpr variable declaration must be a definition}}
1179  void f() {
1180    extern constexpr int i; // expected-error {{constexpr variable declaration must be a definition}}
1181    constexpr int j = 0;
1182    constexpr int k; // expected-error {{default initialization of an object of const type}}
1183  }
1184
1185  extern const int q;
1186  constexpr int g() { return q; }
1187  constexpr int q = g();
1188  static_assert(q == 0, "zero-initialization should precede static initialization");
1189
1190  extern int r; // expected-note {{here}}
1191  constexpr int h() { return r; } // expected-error {{never produces a constant}} expected-note {{read of non-const}}
1192
1193  struct S { int n; };
1194  extern const S s;
1195  constexpr int x() { return s.n; }
1196  constexpr S s = {x()};
1197  static_assert(s.n == 0, "zero-initialization should precede static initialization");
1198}
1199
1200namespace ComplexConstexpr {
1201  constexpr _Complex float test1 = {};
1202  constexpr _Complex float test2 = {1};
1203  constexpr _Complex double test3 = {1,2};
1204  constexpr _Complex int test4 = {4};
1205  constexpr _Complex int test5 = 4;
1206  constexpr _Complex int test6 = {5,6};
1207  typedef _Complex float fcomplex;
1208  constexpr fcomplex test7 = fcomplex();
1209
1210  constexpr const double &t2r = __real test3;
1211  constexpr const double &t2i = __imag test3;
1212  static_assert(&t2r + 1 == &t2i, "");
1213  static_assert(t2r == 1.0, "");
1214  static_assert(t2i == 2.0, "");
1215  constexpr const double *t2p = &t2r;
1216  static_assert(t2p[-1] == 0.0, ""); // expected-error {{constant expr}} expected-note {{cannot refer to element -1 of array of 2 elements}}
1217  static_assert(t2p[0] == 1.0, "");
1218  static_assert(t2p[1] == 2.0, "");
1219  static_assert(t2p[2] == 0.0, ""); // expected-error {{constant expr}} expected-note {{one-past-the-end pointer}}
1220  static_assert(t2p[3] == 0.0, ""); // expected-error {{constant expr}} expected-note {{cannot refer to element 3 of array of 2 elements}}
1221  constexpr _Complex float *p = 0;
1222  constexpr float pr = __real *p; // expected-error {{constant expr}} expected-note {{cannot access real component of null}}
1223  constexpr float pi = __imag *p; // expected-error {{constant expr}} expected-note {{cannot access imaginary component of null}}
1224  constexpr const _Complex double *q = &test3 + 1;
1225  constexpr double qr = __real *q; // expected-error {{constant expr}} expected-note {{cannot access real component of pointer past the end}}
1226  constexpr double qi = __imag *q; // expected-error {{constant expr}} expected-note {{cannot access imaginary component of pointer past the end}}
1227
1228  static_assert(__real test6 == 5, "");
1229  static_assert(__imag test6 == 6, "");
1230  static_assert(&__imag test6 == &__real test6 + 1, "");
1231}
1232
1233// _Atomic(T) is exactly like T for the purposes of constant expression
1234// evaluation..
1235namespace Atomic {
1236  constexpr _Atomic int n = 3;
1237
1238  struct S { _Atomic(double) d; };
1239  constexpr S s = { 0.5 };
1240  constexpr double d1 = s.d;
1241  constexpr double d2 = n;
1242  constexpr _Atomic double d3 = n;
1243
1244  constexpr _Atomic(int) n2 = d3;
1245  static_assert(d1 == 0.5, "");
1246  static_assert(d3 == 3.0, "");
1247
1248  namespace PR16056 {
1249    struct TestVar {
1250      _Atomic(int) value;
1251      constexpr TestVar(int value) : value(value) {}
1252    };
1253    constexpr TestVar testVar{-1};
1254    static_assert(testVar.value == -1, "");
1255  }
1256}
1257
1258namespace InstantiateCaseStmt {
1259  template<int x> constexpr int f() { return x; }
1260  template<int x> int g(int c) { switch(c) { case f<x>(): return 1; } return 0; }
1261  int gg(int c) { return g<4>(c); }
1262}
1263
1264namespace ConvertedConstantExpr {
1265  extern int &m;
1266  extern int &n;
1267
1268  constexpr int k = 4;
1269  int &m = const_cast<int&>(k);
1270
1271  // If we have nothing more interesting to say, ensure we don't produce a
1272  // useless note and instead just point to the non-constant subexpression.
1273  enum class E {
1274    em = m,
1275    en = n, // expected-error {{not a constant expression}}
1276    eo = (m +
1277          n // expected-error {{not a constant expression}}
1278          ),
1279    eq = reinterpret_cast<int>((int*)0) // expected-error {{not a constant expression}} expected-note {{reinterpret_cast}}
1280  };
1281}
1282
1283namespace IndirectField {
1284  struct S {
1285    struct { // expected-warning {{GNU extension}}
1286      union { // expected-warning {{declared in an anonymous struct}}
1287        struct { // expected-warning {{GNU extension}} expected-warning {{declared in an anonymous union}}
1288          int a;
1289          int b;
1290        };
1291        int c;
1292      };
1293      int d;
1294    };
1295    union {
1296      int e;
1297      int f;
1298    };
1299    constexpr S(int a, int b, int d, int e) : a(a), b(b), d(d), e(e) {}
1300    constexpr S(int c, int d, int f) : c(c), d(d), f(f) {}
1301  };
1302
1303  constexpr S s1(1, 2, 3, 4);
1304  constexpr S s2(5, 6, 7);
1305
1306  // FIXME: The diagnostics here do a very poor job of explaining which unnamed
1307  // member is active and which is requested.
1308  static_assert(s1.a == 1, "");
1309  static_assert(s1.b == 2, "");
1310  static_assert(s1.c == 0, ""); // expected-error {{constant expression}} expected-note {{union with active member}}
1311  static_assert(s1.d == 3, "");
1312  static_assert(s1.e == 4, "");
1313  static_assert(s1.f == 0, ""); // expected-error {{constant expression}} expected-note {{union with active member}}
1314
1315  static_assert(s2.a == 0, ""); // expected-error {{constant expression}} expected-note {{union with active member}}
1316  static_assert(s2.b == 0, ""); // expected-error {{constant expression}} expected-note {{union with active member}}
1317  static_assert(s2.c == 5, "");
1318  static_assert(s2.d == 6, "");
1319  static_assert(s2.e == 0, ""); // expected-error {{constant expression}} expected-note {{union with active member}}
1320  static_assert(s2.f == 7, "");
1321}
1322
1323// DR1405: don't allow reading mutable members in constant expressions.
1324namespace MutableMembers {
1325  struct MM {
1326    mutable int n; // expected-note 3{{declared here}}
1327  } constexpr mm = { 4 };
1328  constexpr int mmn = mm.n; // expected-error {{constant expression}} expected-note {{read of mutable member 'n' is not allowed in a constant expression}}
1329  int x = (mm.n = 1, 3);
1330  constexpr int mmn2 = mm.n; // expected-error {{constant expression}} expected-note {{read of mutable member 'n' is not allowed in a constant expression}}
1331
1332  // Here's one reason why allowing this would be a disaster...
1333  template<int n> struct Id { int k = n; };
1334  int f() {
1335    constexpr MM m = { 0 };
1336    ++m.n;
1337    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}}
1338  }
1339
1340  struct A { int n; };
1341  struct B { mutable A a; }; // expected-note {{here}}
1342  struct C { B b; };
1343  constexpr C c[3] = {};
1344  constexpr int k = c[1].b.a.n; // expected-error {{constant expression}} expected-note {{mutable}}
1345
1346  struct D { int x; mutable int y; }; // expected-note {{here}}
1347  constexpr D d1 = { 1, 2 };
1348  int l = ++d1.y;
1349  constexpr D d2 = d1; // expected-error {{constant}} expected-note {{mutable}} expected-note {{in call}}
1350
1351  struct E {
1352    union {
1353      int a;
1354      mutable int b; // expected-note {{here}}
1355    };
1356  };
1357  constexpr E e1 = {{1}};
1358  constexpr E e2 = e1; // expected-error {{constant}} expected-note {{mutable}} expected-note {{in call}}
1359
1360  struct F {
1361    union U { };
1362    mutable U u;
1363    struct X { };
1364    mutable X x;
1365    struct Y : X { X x; U u; };
1366    mutable Y y;
1367    int n;
1368  };
1369  // This is OK; we don't actually read any mutable state here.
1370  constexpr F f1 = {};
1371  constexpr F f2 = f1;
1372
1373  struct G {
1374    struct X {};
1375    union U { X a; };
1376    mutable U u; // expected-note {{here}}
1377  };
1378  constexpr G g1 = {};
1379  constexpr G g2 = g1; // expected-error {{constant}} expected-note {{mutable}} expected-note {{in call}}
1380  constexpr G::U gu1 = {};
1381  constexpr G::U gu2 = gu1;
1382
1383  union H {
1384    mutable G::X gx; // expected-note {{here}}
1385  };
1386  constexpr H h1 = {};
1387  constexpr H h2 = h1; // expected-error {{constant}} expected-note {{mutable}} expected-note {{in call}}
1388}
1389
1390namespace Fold {
1391
1392  // This macro forces its argument to be constant-folded, even if it's not
1393  // otherwise a constant expression.
1394  #define fold(x) (__builtin_constant_p(x) ? (x) : (x))
1395
1396  constexpr int n = (int)(char*)123; // expected-error {{constant expression}} expected-note {{reinterpret_cast}}
1397  constexpr int m = fold((int)(char*)123); // ok
1398  static_assert(m == 123, "");
1399
1400  #undef fold
1401
1402}
1403
1404namespace DR1454 {
1405
1406constexpr const int &f(const int &n) { return n; }
1407constexpr int k1 = f(0); // ok
1408
1409struct Wrap {
1410  const int &value;
1411};
1412constexpr const Wrap &g(const Wrap &w) { return w; }
1413constexpr int k2 = g({0}).value; // ok
1414
1415// The temporary here has static storage duration, so we can bind a constexpr
1416// reference to it.
1417constexpr const int &i = 1;
1418constexpr const int j = i;
1419static_assert(j == 1, "");
1420
1421// The temporary here is not const, so it can't be read outside the expression
1422// in which it was created (per the C++14 rules, which we use to avoid a C++11
1423// defect).
1424constexpr int &&k = 1; // expected-note {{temporary created here}}
1425constexpr const int l = k; // expected-error {{constant expression}} expected-note {{read of temporary}}
1426
1427void f() {
1428  // The temporary here has automatic storage duration, so we can't bind a
1429  // constexpr reference to it.
1430  constexpr const int &i = 1; // expected-error {{constant expression}} expected-note 2{{temporary}}
1431}
1432
1433}
1434
1435namespace RecursiveOpaqueExpr {
1436  template<typename Iter>
1437  constexpr auto LastNonzero(Iter p, Iter q) -> decltype(+*p) {
1438    return p != q ? (LastNonzero(p+1, q) ?: *p) : 0; // expected-warning {{GNU}}
1439  }
1440
1441  constexpr int arr1[] = { 1, 0, 0, 3, 0, 2, 0, 4, 0, 0 };
1442  static_assert(LastNonzero(begin(arr1), end(arr1)) == 4, "");
1443
1444  constexpr int arr2[] = { 1, 0, 0, 3, 0, 2, 0, 4, 0, 5 };
1445  static_assert(LastNonzero(begin(arr2), end(arr2)) == 5, "");
1446
1447  constexpr int arr3[] = {
1448    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,
1449    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,
1450    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,
1451    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,
1452    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,
1453    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,
1454    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,
1455    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 };
1456  static_assert(LastNonzero(begin(arr3), end(arr3)) == 2, "");
1457}
1458
1459namespace VLASizeof {
1460
1461  void f(int k) {
1462    int arr[k]; // expected-warning {{C99}}
1463    constexpr int n = 1 +
1464        sizeof(arr) // expected-error {{constant expression}}
1465        * 3;
1466  }
1467}
1468
1469namespace CompoundLiteral {
1470  // FIXME:
1471  // We don't model the semantics of this correctly: the compound literal is
1472  // represented as a prvalue in the AST, but actually behaves like an lvalue.
1473  // We treat the compound literal as a temporary and refuse to produce a
1474  // pointer to it. This is OK: we're not required to treat this as a constant
1475  // in C++, and in C we model compound literals as lvalues.
1476  constexpr int *p = (int*)(int[1]){0}; // expected-warning {{C99}} expected-error {{constant expression}} expected-note 2{{temporary}}
1477}
1478
1479namespace Vector {
1480  typedef int __attribute__((vector_size(16))) VI4;
1481  constexpr VI4 f(int n) {
1482    return VI4 { n * 3, n + 4, n - 5, n / 6 };
1483  }
1484  constexpr auto v1 = f(10);
1485
1486  typedef double __attribute__((vector_size(32))) VD4;
1487  constexpr VD4 g(int n) {
1488    return (VD4) { n / 2.0, n + 1.5, n - 5.4, n * 0.9 }; // expected-warning {{C99}}
1489  }
1490  constexpr auto v2 = g(4);
1491}
1492
1493// PR12626, redux
1494namespace InvalidClasses {
1495  void test0() {
1496    struct X; // expected-note {{forward declaration}}
1497    struct Y { bool b; X x; }; // expected-error {{field has incomplete type}}
1498    Y y;
1499    auto& b = y.b;
1500  }
1501}
1502
1503namespace NamespaceAlias {
1504  constexpr int f() {
1505    namespace NS = NamespaceAlias; // expected-warning {{use of this statement in a constexpr function is a C++14 extension}}
1506    return &NS::f != nullptr;
1507  }
1508}
1509
1510// Constructors can be implicitly constexpr, even for a non-literal type.
1511namespace ImplicitConstexpr {
1512  struct Q { Q() = default; Q(const Q&) = default; Q(Q&&) = default; ~Q(); }; // expected-note 3{{here}}
1513  struct R { constexpr R() noexcept; constexpr R(const R&) noexcept; constexpr R(R&&) noexcept; ~R() noexcept; };
1514  struct S { R r; }; // expected-note 3{{here}}
1515  struct T { T(const T&) noexcept; T(T &&) noexcept; ~T() noexcept; };
1516  struct U { T t; }; // expected-note 3{{here}}
1517  static_assert(!__is_literal_type(Q), "");
1518  static_assert(!__is_literal_type(R), "");
1519  static_assert(!__is_literal_type(S), "");
1520  static_assert(!__is_literal_type(T), "");
1521  static_assert(!__is_literal_type(U), "");
1522  struct Test {
1523    friend Q::Q() noexcept; // expected-error {{follows constexpr}}
1524    friend Q::Q(Q&&) noexcept; // expected-error {{follows constexpr}}
1525    friend Q::Q(const Q&) noexcept; // expected-error {{follows constexpr}}
1526    friend S::S() noexcept; // expected-error {{follows constexpr}}
1527    friend S::S(S&&) noexcept; // expected-error {{follows constexpr}}
1528    friend S::S(const S&) noexcept; // expected-error {{follows constexpr}}
1529    friend constexpr U::U() noexcept; // expected-error {{follows non-constexpr}}
1530    friend constexpr U::U(U&&) noexcept; // expected-error {{follows non-constexpr}}
1531    friend constexpr U::U(const U&) noexcept; // expected-error {{follows non-constexpr}}
1532  };
1533}
1534
1535// Indirectly test that an implicit lvalue to xvalue conversion performed for
1536// an NRVO move operation isn't implemented as CK_LValueToRValue.
1537namespace PR12826 {
1538  struct Foo {};
1539  constexpr Foo id(Foo x) { return x; }
1540  constexpr Foo res(id(Foo()));
1541}
1542
1543namespace PR13273 {
1544  struct U {
1545    int t;
1546    U() = default;
1547  };
1548
1549  struct S : U {
1550    S() = default;
1551  };
1552
1553  // S's default constructor isn't constexpr, because U's default constructor
1554  // doesn't initialize 't', but it's trivial, so value-initialization doesn't
1555  // actually call it.
1556  static_assert(S{}.t == 0, "");
1557}
1558
1559namespace PR12670 {
1560  struct S {
1561    constexpr S(int a0) : m(a0) {}
1562    constexpr S() : m(6) {}
1563    int m;
1564  };
1565  constexpr S x[3] = { {4}, 5 };
1566  static_assert(x[0].m == 4, "");
1567  static_assert(x[1].m == 5, "");
1568  static_assert(x[2].m == 6, "");
1569}
1570
1571// Indirectly test that an implicit lvalue-to-rvalue conversion is performed
1572// when a conditional operator has one argument of type void and where the other
1573// is a glvalue of class type.
1574namespace ConditionalLValToRVal {
1575  struct A {
1576    constexpr A(int a) : v(a) {}
1577    int v;
1578  };
1579
1580  constexpr A f(const A &a) {
1581    return a.v == 0 ? throw a : a;
1582  }
1583
1584  constexpr A a(4);
1585  static_assert(f(a).v == 4, "");
1586}
1587
1588namespace TLS {
1589  __thread int n;
1590  int m;
1591
1592  constexpr bool b = &n == &n;
1593
1594  constexpr int *p = &n; // expected-error{{constexpr variable 'p' must be initialized by a constant expression}}
1595
1596  constexpr int *f() { return &n; }
1597  constexpr int *q = f(); // expected-error{{constexpr variable 'q' must be initialized by a constant expression}}
1598  constexpr bool c = f() == f();
1599
1600  constexpr int *g() { return &m; }
1601  constexpr int *r = g();
1602}
1603
1604namespace Void {
1605  constexpr void f() { return; } // expected-error{{constexpr function's return type 'void' is not a literal type}}
1606
1607  void assert_failed(const char *msg, const char *file, int line); // expected-note {{declared here}}
1608#define ASSERT(expr) ((expr) ? static_cast<void>(0) : assert_failed(#expr, __FILE__, __LINE__))
1609  template<typename T, size_t S>
1610  constexpr T get(T (&a)[S], size_t k) {
1611    return ASSERT(k > 0 && k < S), a[k]; // expected-note{{non-constexpr function 'assert_failed'}}
1612  }
1613#undef ASSERT
1614  template int get(int (&a)[4], size_t);
1615  constexpr int arr[] = { 4, 1, 2, 3, 4 };
1616  static_assert(get(arr, 1) == 1, "");
1617  static_assert(get(arr, 4) == 4, "");
1618  static_assert(get(arr, 0) == 4, ""); // expected-error{{not an integral constant expression}} \
1619  // expected-note{{in call to 'get(arr, 0)'}}
1620}
1621
1622namespace std { struct type_info; }
1623
1624namespace TypeId {
1625  struct A { virtual ~A(); };
1626  A f();
1627  A &g();
1628  constexpr auto &x = typeid(f());
1629  constexpr auto &y = typeid(g()); // expected-error{{constant expression}} \
1630  // expected-note{{typeid applied to expression of polymorphic type 'TypeId::A' is not allowed in a constant expression}} \
1631  // expected-warning {{expression with side effects will be evaluated despite being used as an operand to 'typeid'}}
1632}
1633
1634namespace PR14203 {
1635  struct duration {
1636    constexpr duration() {}
1637    constexpr operator int() const { return 0; }
1638  };
1639  template<typename T> void f() {
1640    // If we want to evaluate this at the point of the template definition, we
1641    // need to trigger the implicit definition of the move constructor at that
1642    // point.
1643    // FIXME: C++ does not permit us to implicitly define it at the appropriate
1644    // times, since it is only allowed to be implicitly defined when it is
1645    // odr-used.
1646    constexpr duration d = duration();
1647  }
1648  // FIXME: It's unclear whether this is valid. On the one hand, we're not
1649  // allowed to generate a move constructor. On the other hand, if we did,
1650  // this would be a constant expression. For now, we generate a move
1651  // constructor here.
1652  int n = sizeof(short{duration(duration())});
1653}
1654
1655namespace ArrayEltInit {
1656  struct A {
1657    constexpr A() : p(&p) {}
1658    void *p;
1659  };
1660  constexpr A a[10];
1661  static_assert(a[0].p == &a[0].p, "");
1662  static_assert(a[9].p == &a[9].p, "");
1663  static_assert(a[0].p != &a[9].p, "");
1664  static_assert(a[9].p != &a[0].p, "");
1665
1666  constexpr A b[10] = {};
1667  static_assert(b[0].p == &b[0].p, "");
1668  static_assert(b[9].p == &b[9].p, "");
1669  static_assert(b[0].p != &b[9].p, "");
1670  static_assert(b[9].p != &b[0].p, "");
1671}
1672
1673namespace PR15884 {
1674  struct S {};
1675  constexpr S f() { return {}; }
1676  constexpr S *p = &f();
1677  // expected-error@-1 {{taking the address of a temporary}}
1678  // expected-error@-2 {{constexpr variable 'p' must be initialized by a constant expression}}
1679  // expected-note@-3 {{pointer to temporary is not a constant expression}}
1680  // expected-note@-4 {{temporary created here}}
1681}
1682
1683namespace AfterError {
1684  // FIXME: Suppress the 'no return statements' diagnostic if the body is invalid.
1685  constexpr int error() { // expected-error {{no return statement}}
1686    return foobar; // expected-error {{undeclared identifier}}
1687  }
1688  constexpr int k = error(); // expected-error {{must be initialized by a constant expression}}
1689}
1690
1691namespace std {
1692  typedef decltype(sizeof(int)) size_t;
1693
1694  template <class _E>
1695  class initializer_list
1696  {
1697    const _E* __begin_;
1698    size_t    __size_;
1699
1700    constexpr initializer_list(const _E* __b, size_t __s)
1701      : __begin_(__b),
1702        __size_(__s)
1703    {}
1704
1705  public:
1706    typedef _E        value_type;
1707    typedef const _E& reference;
1708    typedef const _E& const_reference;
1709    typedef size_t    size_type;
1710
1711    typedef const _E* iterator;
1712    typedef const _E* const_iterator;
1713
1714    constexpr initializer_list() : __begin_(nullptr), __size_(0) {}
1715
1716    constexpr size_t    size()  const {return __size_;}
1717    constexpr const _E* begin() const {return __begin_;}
1718    constexpr const _E* end()   const {return __begin_ + __size_;}
1719  };
1720}
1721
1722namespace InitializerList {
1723  constexpr int sum(const int *b, const int *e) {
1724    return b != e ? *b + sum(b+1, e) : 0;
1725  }
1726  constexpr int sum(std::initializer_list<int> ints) {
1727    return sum(ints.begin(), ints.end());
1728  }
1729  static_assert(sum({1, 2, 3, 4, 5}) == 15, "");
1730
1731  static_assert(*std::initializer_list<int>{1, 2, 3}.begin() == 1, "");
1732  static_assert(std::initializer_list<int>{1, 2, 3}.begin()[2] == 3, "");
1733}
1734
1735namespace StmtExpr {
1736  struct A { int k; };
1737  void f() {
1738    static_assert(({ const int x = 5; x * 3; }) == 15, ""); // expected-warning {{extension}}
1739    constexpr auto a = ({ A(); }); // expected-warning {{extension}}
1740  }
1741  constexpr int g(int k) {
1742    return ({ // expected-warning {{extension}}
1743      const int x = k;
1744      x * x;
1745    });
1746  }
1747  static_assert(g(123) == 15129, "");
1748  constexpr int h() { // expected-error {{never produces a constant}}
1749    return ({ // expected-warning {{extension}}
1750      return 0; // expected-note {{not supported}}
1751      1;
1752    });
1753  }
1754}
1755
1756namespace VirtualFromBase {
1757  struct S1 {
1758    virtual int f() const;
1759  };
1760  struct S2 {
1761    virtual int f();
1762  };
1763  template <typename T> struct X : T {
1764    constexpr X() {}
1765    double d = 0.0;
1766    constexpr int f() { return sizeof(T); } // expected-warning {{will not be implicitly 'const' in C++14}}
1767  };
1768
1769  // Virtual f(), not OK.
1770  constexpr X<X<S1>> xxs1;
1771  constexpr X<S1> *p = const_cast<X<X<S1>>*>(&xxs1);
1772  static_assert(p->f() == sizeof(X<S1>), ""); // expected-error {{constant expression}} expected-note {{virtual function call}}
1773
1774  // Non-virtual f(), OK.
1775  constexpr X<X<S2>> xxs2;
1776  constexpr X<S2> *q = const_cast<X<X<S2>>*>(&xxs2);
1777  static_assert(q->f() == sizeof(S2), "");
1778}
1779
1780namespace ConstexprConstructorRecovery {
1781  class X {
1782  public:
1783      enum E : short {
1784          headers = 0x1,
1785          middlefile = 0x2,
1786          choices = 0x4
1787      };
1788      constexpr X() noexcept {};
1789  protected:
1790      E val{0}; // expected-error {{cannot initialize a member subobject of type 'ConstexprConstructorRecovery::X::E' with an rvalue of type 'int'}}
1791  };
1792  constexpr X x{};
1793}
1794
1795namespace Lifetime {
1796  void f() {
1797    constexpr int &n = n; // expected-error {{constant expression}} expected-note {{use of reference outside its lifetime}} expected-warning {{not yet bound to a value}}
1798    constexpr int m = m; // expected-error {{constant expression}} expected-note {{read of object outside its lifetime}}
1799  }
1800
1801  constexpr int &get(int &&n) { return n; }
1802  struct S {
1803    int &&r; // expected-note 2{{declared here}}
1804    int &s;
1805    int t;
1806    constexpr S() : r(0), s(get(0)), t(r) {} // expected-warning {{temporary}}
1807    constexpr S(int) : r(0), s(get(0)), t(s) {} // expected-warning {{temporary}} expected-note {{read of object outside its lifetime}}
1808  };
1809  constexpr int k1 = S().t; // ok, int is lifetime-extended to end of constructor
1810  constexpr int k2 = S(0).t; // expected-error {{constant expression}} expected-note {{in call}}
1811}
1812
1813namespace Bitfields {
1814  struct A {
1815    bool b : 1;
1816    unsigned u : 5;
1817    int n : 5;
1818    bool b2 : 3;
1819    unsigned u2 : 74; // expected-warning {{exceeds the width of its type}}
1820    int n2 : 81; // expected-warning {{exceeds the width of its type}}
1821  };
1822
1823  constexpr A a = { false, 33, 31, false, 0xffffffff, 0x7fffffff }; // expected-warning 2{{truncation}}
1824  static_assert(a.b == 0 && a.u == 1 && a.n == -1 && a.b2 == 0 &&
1825                a.u2 + 1 == 0 && a.n2 == 0x7fffffff,
1826                "bad truncation of bitfield values");
1827
1828  struct B {
1829    int n : 3;
1830    constexpr B(int k) : n(k) {}
1831  };
1832  static_assert(B(3).n == 3, "");
1833  static_assert(B(4).n == -4, "");
1834  static_assert(B(7).n == -1, "");
1835  static_assert(B(8).n == 0, "");
1836  static_assert(B(-1).n == -1, "");
1837  static_assert(B(-8889).n == -1, "");
1838
1839  namespace PR16755 {
1840    struct X {
1841      int x : 1;
1842      constexpr static int f(int x) {
1843        return X{x}.x;
1844      }
1845    };
1846    static_assert(X::f(3) == -1, "3 should truncate to -1");
1847  }
1848}
1849
1850namespace ZeroSizeTypes {
1851  constexpr int (*p1)[0] = 0, (*p2)[0] = 0;
1852  constexpr int k = p2 - p1;
1853  // expected-error@-1 {{constexpr variable 'k' must be initialized by a constant expression}}
1854  // expected-note@-2 {{subtraction of pointers to type 'int [0]' of zero size}}
1855
1856  int arr[5][0];
1857  constexpr int f() { // expected-error {{never produces a constant expression}}
1858    return &arr[3] - &arr[0]; // expected-note {{subtraction of pointers to type 'int [0]' of zero size}}
1859  }
1860}
1861
1862namespace BadDefaultInit {
1863  template<int N> struct X { static const int n = N; };
1864
1865  struct A {
1866    int k = // expected-error {{cannot use defaulted default constructor of 'A' within the class outside of member functions because 'k' has an initializer}}
1867        X<A().k>::n; // expected-error {{not a constant expression}} expected-note {{implicit default constructor for 'BadDefaultInit::A' first required here}}
1868  };
1869
1870  // FIXME: The "constexpr constructor must initialize all members" diagnostic
1871  // here is bogus (we discard the k(k) initializer because the parameter 'k'
1872  // has been marked invalid).
1873  struct B { // expected-note 2{{candidate}}
1874    constexpr B( // expected-error {{must initialize all members}} expected-note {{candidate}}
1875        int k = X<B().k>::n) : // expected-error {{no matching constructor}}
1876      k(k) {}
1877    int k; // expected-note {{not initialized}}
1878  };
1879}
1880
1881namespace NeverConstantTwoWays {
1882  // If we see something non-constant but foldable followed by something
1883  // non-constant and not foldable, we want the first diagnostic, not the
1884  // second.
1885  constexpr int f(int n) { // expected-error {{never produces a constant expression}}
1886    return (int *)(long)&n == &n ? // expected-note {{reinterpret_cast}}
1887        1 / 0 : // expected-warning {{division by zero}}
1888        0;
1889  }
1890
1891  constexpr int n = // expected-error {{must be initialized by a constant expression}}
1892      (int *)(long)&n == &n ? // expected-note {{reinterpret_cast}}
1893        1 / 0 : // expected-warning {{division by zero}}
1894        0;
1895}
1896
1897namespace PR17800 {
1898  struct A {
1899    constexpr int operator()() const { return 0; }
1900  };
1901  template <typename ...T> constexpr int sink(T ...) {
1902    return 0;
1903  }
1904  template <int ...N> constexpr int run() {
1905    return sink(A()() + N ...);
1906  }
1907  constexpr int k = run<1, 2, 3>();
1908}
1909
1910namespace BuiltinStrlen {
1911  constexpr const char *a = "foo\0quux";
1912  constexpr char b[] = "foo\0quux";
1913  constexpr int f() { return 'u'; }
1914  constexpr char c[] = { 'f', 'o', 'o', 0, 'q', f(), 'u', 'x', 0 };
1915
1916  static_assert(__builtin_strlen("foo") == 3, "");
1917  static_assert(__builtin_strlen("foo\0quux") == 3, "");
1918  static_assert(__builtin_strlen("foo\0quux" + 4) == 4, "");
1919
1920  constexpr bool check(const char *p) {
1921    return __builtin_strlen(p) == 3 &&
1922           __builtin_strlen(p + 1) == 2 &&
1923           __builtin_strlen(p + 2) == 1 &&
1924           __builtin_strlen(p + 3) == 0 &&
1925           __builtin_strlen(p + 4) == 4 &&
1926           __builtin_strlen(p + 5) == 3 &&
1927           __builtin_strlen(p + 6) == 2 &&
1928           __builtin_strlen(p + 7) == 1 &&
1929           __builtin_strlen(p + 8) == 0;
1930  }
1931
1932  static_assert(check(a), "");
1933  static_assert(check(b), "");
1934  static_assert(check(c), "");
1935
1936  constexpr int over1 = __builtin_strlen(a + 9); // expected-error {{constant expression}} expected-note {{one-past-the-end}}
1937  constexpr int over2 = __builtin_strlen(b + 9); // expected-error {{constant expression}} expected-note {{one-past-the-end}}
1938  constexpr int over3 = __builtin_strlen(c + 9); // expected-error {{constant expression}} expected-note {{one-past-the-end}}
1939
1940  constexpr int under1 = __builtin_strlen(a - 1); // expected-error {{constant expression}} expected-note {{cannot refer to element -1}}
1941  constexpr int under2 = __builtin_strlen(b - 1); // expected-error {{constant expression}} expected-note {{cannot refer to element -1}}
1942  constexpr int under3 = __builtin_strlen(c - 1); // expected-error {{constant expression}} expected-note {{cannot refer to element -1}}
1943
1944  // FIXME: The diagnostic here could be better.
1945  constexpr char d[] = { 'f', 'o', 'o' }; // no nul terminator.
1946  constexpr int bad = __builtin_strlen(d); // expected-error {{constant expression}} expected-note {{one-past-the-end}}
1947}
1948
1949namespace PR19010 {
1950  struct Empty {};
1951  struct Empty2 : Empty {};
1952  struct Test : Empty2 {
1953    constexpr Test() {}
1954    Empty2 array[2];
1955  };
1956  void test() { constexpr Test t; }
1957}
1958
1959void PR21327(int a, int b) {
1960  static_assert(&a + 1 != &b, ""); // expected-error {{constant expression}}
1961}
1962
1963namespace EmptyClass {
1964  struct E1 {} e1;
1965  union E2 {} e2; // expected-note {{here}}
1966  struct E3 : E1 {} e3;
1967
1968  // The defaulted copy constructor for an empty class does not read any
1969  // members. The defaulted copy constructor for an empty union reads the
1970  // object representation.
1971  constexpr E1 e1b(e1);
1972  constexpr E2 e2b(e2); // expected-error {{constant expression}} expected-note{{read of non-const}} expected-note {{in call}}
1973  constexpr E3 e3b(e3);
1974}
1975
1976namespace PR21786 {
1977  extern void (*start[])();
1978  extern void (*end[])();
1979  static_assert(&start != &end, ""); // expected-error {{constant expression}}
1980  static_assert(&start != nullptr, "");
1981
1982  struct Foo;
1983  struct Bar {
1984    static const Foo x;
1985    static const Foo y;
1986  };
1987  static_assert(&Bar::x != nullptr, "");
1988  static_assert(&Bar::x != &Bar::y, "");
1989}
1990
1991namespace PR21859 {
1992  constexpr int Fun() { return; } // expected-error {{non-void constexpr function 'Fun' should return a value}}
1993  constexpr int Var = Fun(); // expected-error {{constexpr variable 'Var' must be initialized by a constant expression}}
1994}
1995
1996struct InvalidRedef {
1997  int f; // expected-note{{previous definition is here}}
1998  constexpr int f(void); // expected-error{{redefinition of 'f'}} expected-warning{{will not be implicitly 'const'}}
1999};
2000
2001namespace PR17938 {
2002  template <typename T> constexpr T const &f(T const &x) { return x; }
2003
2004  struct X {};
2005  struct Y : X {};
2006  struct Z : Y { constexpr Z() {} };
2007
2008  static constexpr auto z = f(Z());
2009}
2010
2011namespace PR24597 {
2012  struct A {
2013    int x, *p;
2014    constexpr A() : x(0), p(&x) {}
2015    constexpr A(const A &a) : x(a.x), p(&x) {}
2016  };
2017  constexpr A f() { return A(); }
2018  constexpr A g() { return f(); }
2019  constexpr int a = *f().p;
2020  constexpr int b = *g().p;
2021}
2022
2023namespace IncompleteClass {
2024  struct XX {
2025    static constexpr int f(XX*) { return 1; } // expected-note {{here}}
2026    friend constexpr int g(XX*) { return 2; } // expected-note {{here}}
2027
2028    static constexpr int i = f(static_cast<XX*>(nullptr)); // expected-error {{constexpr variable 'i' must be initialized by a constant expression}}  expected-note {{undefined function 'f' cannot be used in a constant expression}}
2029    static constexpr int j = g(static_cast<XX*>(nullptr)); // expected-error {{constexpr variable 'j' must be initialized by a constant expression}}  expected-note {{undefined function 'g' cannot be used in a constant expression}}
2030  };
2031}
2032
2033namespace InheritedCtor {
2034  struct A { constexpr A(int) {} };
2035
2036  struct B : A { int n; using A::A; }; // expected-note {{here}}
2037  constexpr B b(0); // expected-error {{constant expression}} expected-note {{derived class}}
2038
2039  struct C : A { using A::A; struct { union { int n, m = 0; }; union { int a = 0; }; int k = 0; }; struct {}; union {}; }; // expected-warning 4{{extension}}
2040  constexpr C c(0);
2041
2042  struct D : A {
2043    using A::A; // expected-note {{here}}
2044    struct { // expected-warning {{extension}}
2045      union { // expected-warning {{extension}}
2046        int n;
2047      };
2048    };
2049  };
2050  constexpr D d(0); // expected-error {{constant expression}} expected-note {{derived class}}
2051
2052  struct E : virtual A { using A::A; }; // expected-note {{here}}
2053  // We wrap a function around this to avoid implicit zero-initialization
2054  // happening first; the zero-initialization step would produce the same
2055  // error and defeat the point of this test.
2056  void f() {
2057    constexpr E e(0); // expected-error {{constant expression}} expected-note {{derived class}}
2058  }
2059  // FIXME: This produces a note with no source location.
2060  //constexpr E e(0);
2061
2062  struct W { constexpr W(int n) : w(n) {} int w; };
2063  struct X : W { using W::W; int x = 2; };
2064  struct Y : X { using X::X; int y = 3; };
2065  struct Z : Y { using Y::Y; int z = 4; };
2066  constexpr Z z(1);
2067  static_assert(z.w == 1 && z.x == 2 && z.y == 3 && z.z == 4, "");
2068}
2069