constant-expression-cxx11.cpp revision 211c8ddb5b500ed84833751363d0cfe1115f4dd3 
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() 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}
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 that 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 that 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 that 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 that 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
342struct A { int &&r; };
343struct B { A &&a1; A &&a2; };
344
345constexpr B b1 { { 1 }, { 2 } }; // expected-note {{temporary created here}}
346static_assert(&b1.a1 != &b1.a2, "");
347static_assert(&b1.a1.r != &b1.a2.r, ""); // expected-error {{constant expression}} expected-note {{outside the expression that created the temporary}}
348
349constexpr B &&b2 { { 3 }, { 4 } }; // expected-note {{temporary created here}}
350static_assert(&b1 != &b2, "");
351static_assert(&b1.a1 != &b2.a1, ""); // expected-error {{constant expression}} expected-note {{outside the expression that created the temporary}}
352
353constexpr thread_local B b3 { { 1 }, { 2 } }; // expected-error {{constant expression}} expected-note {{reference to temporary}} expected-note {{here}}
354void foo() {
355  constexpr static B b1 { { 1 }, { 2 } }; // ok
356  constexpr thread_local B b2 { { 1 }, { 2 } }; // expected-error {{constant expression}} expected-note {{reference to temporary}} expected-note {{here}}
357  constexpr B b3 { { 1 }, { 2 } }; // expected-error {{constant expression}} expected-note {{reference to temporary}} expected-note {{here}}
358}
359
360constexpr B &&b4 = ((1, 2), 3, 4, B { {10}, {{20}} }); // expected-warning 4{{unused}}
361static_assert(&b4 != &b2, "");
362
363// Proposed DR: copy-elision doesn't trigger lifetime extension.
364constexpr B b5 = B{ {0}, {0} }; // expected-error {{constant expression}} expected-note {{reference to temporary}} expected-note {{here}}
365
366}
367
368constexpr int strcmp_ce(const char *p, const char *q) {
369  return (!*p || *p != *q) ? *p - *q : strcmp_ce(p+1, q+1);
370}
371
372namespace StringLiteral {
373
374template<typename Char>
375constexpr int MangleChars(const Char *p) {
376  return *p + 3 * (*p ? MangleChars(p+1) : 0);
377}
378
379static_assert(MangleChars("constexpr!") == 1768383, "");
380static_assert(MangleChars(u8"constexpr!") == 1768383, "");
381static_assert(MangleChars(L"constexpr!") == 1768383, "");
382static_assert(MangleChars(u"constexpr!") == 1768383, "");
383static_assert(MangleChars(U"constexpr!") == 1768383, "");
384
385constexpr char c0 = "nought index"[0];
386constexpr char c1 = "nice index"[10];
387constexpr 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}}
388constexpr 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}}
389constexpr 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}}
390
391constexpr const char *p = "test" + 2;
392static_assert(*p == 's', "");
393
394constexpr const char *max_iter(const char *a, const char *b) {
395  return *a < *b ? b : a;
396}
397constexpr const char *max_element(const char *a, const char *b) {
398  return (a+1 >= b) ? a : max_iter(a, max_element(a+1, b));
399}
400
401constexpr char str[] = "the quick brown fox jumped over the lazy dog";
402constexpr const char *max = max_element(begin(str), end(str));
403static_assert(*max == 'z', "");
404static_assert(max == str + 38, "");
405
406static_assert(strcmp_ce("hello world", "hello world") == 0, "");
407static_assert(strcmp_ce("hello world", "hello clang") > 0, "");
408static_assert(strcmp_ce("constexpr", "test") < 0, "");
409static_assert(strcmp_ce("", " ") < 0, "");
410
411struct S {
412  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}}
413};
414
415struct T {
416  char c[6];
417  constexpr T() : c{"foo"} {}
418};
419constexpr T t;
420
421static_assert(t.c[0] == 'f', "");
422static_assert(t.c[1] == 'o', "");
423static_assert(t.c[2] == 'o', "");
424static_assert(t.c[3] == 0, "");
425static_assert(t.c[4] == 0, "");
426static_assert(t.c[5] == 0, "");
427static_assert(t.c[6] == 0, ""); // expected-error {{constant expression}} expected-note {{one-past-the-end}}
428
429struct U {
430  wchar_t chars[6];
431  int n;
432} constexpr u = { { L"test" }, 0 };
433static_assert(u.chars[2] == L's', "");
434
435struct V {
436  char c[4];
437  constexpr V() : c("hi!") {}
438};
439static_assert(V().c[1] == "i"[0], "");
440
441namespace Parens {
442  constexpr unsigned char a[] = ("foo"), b[] = {"foo"}, c[] = {("foo")},
443                          d[4] = ("foo"), e[5] = {"foo"}, f[6] = {("foo")};
444  static_assert(a[0] == 'f', "");
445  static_assert(b[1] == 'o', "");
446  static_assert(c[2] == 'o', "");
447  static_assert(d[0] == 'f', "");
448  static_assert(e[1] == 'o', "");
449  static_assert(f[2] == 'o', "");
450  static_assert(f[5] == 0, "");
451  static_assert(f[6] == 0, ""); // expected-error {{constant expression}} expected-note {{one-past-the-end}}
452}
453
454}
455
456namespace Array {
457
458template<typename Iter>
459constexpr auto Sum(Iter begin, Iter end) -> decltype(+*begin) {
460  return begin == end ? 0 : *begin + Sum(begin+1, end);
461}
462
463constexpr int xs[] = { 1, 2, 3, 4, 5 };
464constexpr int ys[] = { 5, 4, 3, 2, 1 };
465constexpr int sum_xs = Sum(begin(xs), end(xs));
466static_assert(sum_xs == 15, "");
467
468constexpr int ZipFoldR(int (*F)(int x, int y, int c), int n,
469                       const int *xs, const int *ys, int c) {
470  return n ? F(
471               *xs, // expected-note {{read of dereferenced one-past-the-end pointer}}
472               *ys,
473               ZipFoldR(F, n-1, xs+1, ys+1, c)) // \
474      expected-note {{in call to 'ZipFoldR(&SubMul, 2, &xs[4], &ys[4], 1)'}} \
475      expected-note {{in call to 'ZipFoldR(&SubMul, 1, &xs[5], &ys[5], 1)'}}
476           : c;
477}
478constexpr int MulAdd(int x, int y, int c) { return x * y + c; }
479constexpr int InnerProduct = ZipFoldR(MulAdd, 5, xs, ys, 0);
480static_assert(InnerProduct == 35, "");
481
482constexpr int SubMul(int x, int y, int c) { return (x - y) * c; }
483constexpr int DiffProd = ZipFoldR(SubMul, 2, xs+3, ys+3, 1);
484static_assert(DiffProd == 8, "");
485static_assert(ZipFoldR(SubMul, 3, xs+3, ys+3, 1), ""); // \
486      expected-error {{constant expression}} \
487      expected-note {{in call to 'ZipFoldR(&SubMul, 3, &xs[3], &ys[3], 1)'}}
488
489constexpr const int *p = xs + 3;
490constexpr int xs4 = p[1]; // ok
491constexpr int xs5 = p[2]; // expected-error {{constant expression}} expected-note {{read of dereferenced one-past-the-end pointer}}
492constexpr int xs6 = p[3]; // expected-error {{constant expression}} expected-note {{cannot refer to element 6}}
493constexpr int xs0 = p[-3]; // ok
494constexpr int xs_1 = p[-4]; // expected-error {{constant expression}} expected-note {{cannot refer to element -1}}
495
496constexpr int zs[2][2][2][2] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
497static_assert(zs[0][0][0][0] == 1, "");
498static_assert(zs[1][1][1][1] == 16, "");
499static_assert(zs[0][0][0][2] == 3, ""); // expected-error {{constant expression}} expected-note {{read of dereferenced one-past-the-end pointer}}
500static_assert((&zs[0][0][0][2])[-1] == 2, "");
501static_assert(**(**(zs + 1) + 1) == 11, "");
502static_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}}
503static_assert(*(&(&(*(*&(&zs[2] - 1)[0] + 2 - 2))[2])[-1][2] - 2) == 11, "");
504constexpr 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}}
505
506constexpr int fail(const int &p) {
507  return (&p)[64]; // expected-note {{cannot refer to element 64 of array of 2 elements}}
508}
509static_assert(fail(*(&(&(*(*&(&zs[2] - 1)[0] + 2 - 2))[2])[-1][2] - 2)) == 11, ""); // \
510expected-error {{static_assert expression is not an integral constant expression}} \
511expected-note {{in call to 'fail(zs[1][0][1][0])'}}
512
513constexpr int arr[40] = { 1, 2, 3, [8] = 4 }; // expected-warning {{C99 feature}}
514constexpr int SumNonzero(const int *p) {
515  return *p + (*p ? SumNonzero(p+1) : 0);
516}
517constexpr int CountZero(const int *p, const int *q) {
518  return p == q ? 0 : (*p == 0) + CountZero(p+1, q);
519}
520static_assert(SumNonzero(arr) == 6, "");
521static_assert(CountZero(arr, arr + 40) == 36, "");
522
523struct ArrayElem {
524  constexpr ArrayElem() : n(0) {}
525  int n;
526  constexpr int f() const { return n; }
527};
528struct ArrayRVal {
529  constexpr ArrayRVal() {}
530  ArrayElem elems[10];
531};
532static_assert(ArrayRVal().elems[3].f() == 0, "");
533
534constexpr int selfref[2][2][2] = {
535  selfref[1][1][1] + 1, selfref[0][0][0] + 1,
536  selfref[1][0][1] + 1, selfref[0][1][0] + 1,
537  selfref[1][0][0] + 1, selfref[0][1][1] + 1 };
538static_assert(selfref[0][0][0] == 1, "");
539static_assert(selfref[0][0][1] == 2, "");
540static_assert(selfref[0][1][0] == 1, "");
541static_assert(selfref[0][1][1] == 2, "");
542static_assert(selfref[1][0][0] == 1, "");
543static_assert(selfref[1][0][1] == 3, "");
544static_assert(selfref[1][1][0] == 0, "");
545static_assert(selfref[1][1][1] == 0, "");
546
547struct TrivialDefCtor { int n; };
548typedef TrivialDefCtor TDCArray[2][2];
549static_assert(TDCArray{}[1][1].n == 0, "");
550
551struct NonAggregateTDC : TrivialDefCtor {};
552typedef NonAggregateTDC NATDCArray[2][2];
553static_assert(NATDCArray{}[1][1].n == 0, "");
554
555}
556
557namespace DependentValues {
558
559struct I { int n; typedef I V[10]; };
560I::V x, y;
561int g();
562template<bool B, typename T> struct S : T {
563  int k;
564  void f() {
565    I::V &cells = B ? x : y;
566    I &i = cells[k];
567    switch (i.n) {}
568
569    // FIXME: We should be able to diagnose this.
570    constexpr int n = g();
571
572    constexpr int m = this->g(); // ok, could be constexpr
573  }
574};
575
576}
577
578namespace Class {
579
580struct A { constexpr A(int a, int b) : k(a + b) {} int k; };
581constexpr int fn(const A &a) { return a.k; }
582static_assert(fn(A(4,5)) == 9, "");
583
584struct B { int n; int m; } constexpr b = { 0, b.n }; // expected-warning {{uninitialized}}
585struct C {
586  constexpr C(C *this_) : m(42), n(this_->m) {} // ok
587  int m, n;
588};
589struct D {
590  C c;
591  constexpr D() : c(&c) {}
592};
593static_assert(D().c.n == 42, "");
594
595struct E {
596  constexpr E() : p(&p) {}
597  void *p;
598};
599constexpr const E &e1 = E();
600// This is a constant expression if we elide the copy constructor call, and
601// is not a constant expression if we don't! But we do, so it is.
602constexpr E e2 = E();
603static_assert(e2.p == &e2.p, "");
604constexpr E e3;
605static_assert(e3.p == &e3.p, "");
606
607extern const class F f;
608struct F {
609  constexpr F() : p(&f.p) {}
610  const void *p;
611};
612constexpr F f;
613
614struct G {
615  struct T {
616    constexpr T(T *p) : u1(), u2(p) {}
617    union U1 {
618      constexpr U1() {}
619      int a, b = 42;
620    } u1;
621    union U2 {
622      constexpr U2(T *p) : c(p->u1.b) {}
623      int c, d;
624    } u2;
625  } t;
626  constexpr G() : t(&t) {}
627} constexpr g;
628
629static_assert(g.t.u1.a == 42, ""); // expected-error {{constant expression}} expected-note {{read of member 'a' of union with active member 'b'}}
630static_assert(g.t.u1.b == 42, "");
631static_assert(g.t.u2.c == 42, "");
632static_assert(g.t.u2.d == 42, ""); // expected-error {{constant expression}} expected-note {{read of member 'd' of union with active member 'c'}}
633
634struct S {
635  int a, b;
636  const S *p;
637  double d;
638  const char *q;
639
640  constexpr S(int n, const S *p) : a(5), b(n), p(p), d(n), q("hello") {}
641};
642
643S global(43, &global);
644
645static_assert(S(15, &global).b == 15, "");
646
647constexpr bool CheckS(const S &s) {
648  return s.a == 5 && s.b == 27 && s.p == &global && s.d == 27. && s.q[3] == 'l';
649}
650static_assert(CheckS(S(27, &global)), "");
651
652struct Arr {
653  char arr[3];
654  constexpr Arr() : arr{'x', 'y', 'z'} {}
655};
656constexpr int hash(Arr &&a) {
657  return a.arr[0] + a.arr[1] * 0x100 + a.arr[2] * 0x10000;
658}
659constexpr int k = hash(Arr());
660static_assert(k == 0x007a7978, "");
661
662
663struct AggregateInit {
664  const char &c;
665  int n;
666  double d;
667  int arr[5];
668  void *p;
669};
670
671constexpr AggregateInit agg1 = { "hello"[0] };
672
673static_assert(strcmp_ce(&agg1.c, "hello") == 0, "");
674static_assert(agg1.n == 0, "");
675static_assert(agg1.d == 0.0, "");
676static_assert(agg1.arr[-1] == 0, ""); // expected-error {{constant expression}} expected-note {{cannot refer to element -1}}
677static_assert(agg1.arr[0] == 0, "");
678static_assert(agg1.arr[4] == 0, "");
679static_assert(agg1.arr[5] == 0, ""); // expected-error {{constant expression}} expected-note {{read of dereferenced one-past-the-end}}
680static_assert(agg1.p == nullptr, "");
681
682static constexpr const unsigned char uc[] = { "foo" };
683static_assert(uc[0] == 'f', "");
684static_assert(uc[3] == 0, "");
685
686namespace SimpleDerivedClass {
687
688struct B {
689  constexpr B(int n) : a(n) {}
690  int a;
691};
692struct D : B {
693  constexpr D(int n) : B(n) {}
694};
695constexpr D d(3);
696static_assert(d.a == 3, "");
697
698}
699
700struct Bottom { constexpr Bottom() {} };
701struct Base : Bottom {
702  constexpr Base(int a = 42, const char *b = "test") : a(a), b(b) {}
703  int a;
704  const char *b;
705};
706struct Base2 : Bottom {
707  constexpr Base2(const int &r) : r(r) {}
708  int q = 123;
709  const int &r;
710};
711struct Derived : Base, Base2 {
712  constexpr Derived() : Base(76), Base2(a) {}
713  int c = r + b[1];
714};
715
716constexpr bool operator==(const Base &a, const Base &b) {
717  return a.a == b.a && strcmp_ce(a.b, b.b) == 0;
718}
719
720constexpr Base base;
721constexpr Base base2(76);
722constexpr Derived derived;
723static_assert(derived.a == 76, "");
724static_assert(derived.b[2] == 's', "");
725static_assert(derived.c == 76 + 'e', "");
726static_assert(derived.q == 123, "");
727static_assert(derived.r == 76, "");
728static_assert(&derived.r == &derived.a, "");
729
730static_assert(!(derived == base), "");
731static_assert(derived == base2, "");
732
733constexpr Bottom &bot1 = (Base&)derived;
734constexpr Bottom &bot2 = (Base2&)derived;
735static_assert(&bot1 != &bot2, "");
736
737constexpr Bottom *pb1 = (Base*)&derived;
738constexpr Bottom *pb2 = (Base2*)&derived;
739static_assert(&pb1 != &pb2, "");
740static_assert(pb1 == &bot1, "");
741static_assert(pb2 == &bot2, "");
742
743constexpr Base2 &fail = (Base2&)bot1; // expected-error {{constant expression}} expected-note {{cannot cast object of dynamic type 'const Class::Derived' to type 'Class::Base2'}}
744constexpr Base &fail2 = (Base&)*pb2; // expected-error {{constant expression}} expected-note {{cannot cast object of dynamic type 'const Class::Derived' to type 'Class::Base'}}
745constexpr Base2 &ok2 = (Base2&)bot2;
746static_assert(&ok2 == &derived, "");
747
748constexpr Base2 *pfail = (Base2*)pb1; // expected-error {{constant expression}} expected-note {{cannot cast object of dynamic type 'const Class::Derived' to type 'Class::Base2'}}
749constexpr Base *pfail2 = (Base*)&bot2; // expected-error {{constant expression}} expected-note {{cannot cast object of dynamic type 'const Class::Derived' to type 'Class::Base'}}
750constexpr Base2 *pok2 = (Base2*)pb2;
751static_assert(pok2 == &derived, "");
752static_assert(&ok2 == pok2, "");
753static_assert((Base2*)(Derived*)(Base*)pb1 == pok2, "");
754static_assert((Derived*)(Base*)pb1 == (Derived*)pok2, "");
755
756constexpr Base *nullB = 42 - 6 * 7; // expected-warning {{expression which evaluates to zero treated as a null pointer constant of type 'Class::Base *const'}}
757static_assert((Bottom*)nullB == 0, "");
758static_assert((Derived*)nullB == 0, "");
759static_assert((void*)(Bottom*)nullB == (void*)(Derived*)nullB, "");
760Base * nullB2 = '\0'; // expected-warning {{expression which evaluates to zero treated as a null pointer constant of type 'Class::Base *'}}
761Base * nullB3 = (0);
762// We suppress the warning in unevaluated contexts to workaround some gtest
763// behavior. Once this becomes an error this isn't a problem anymore.
764static_assert(nullB == (1 - 1), "");
765
766
767namespace ConversionOperators {
768
769struct T {
770  constexpr T(int n) : k(5*n - 3) {}
771  constexpr operator int() const { return k; }
772  int k;
773};
774
775struct S {
776  constexpr S(int n) : k(2*n + 1) {}
777  constexpr operator int() const { return k; }
778  constexpr operator T() const { return T(k); }
779  int k;
780};
781
782constexpr bool check(T a, T b) { return a == b.k; }
783
784static_assert(S(5) == 11, "");
785static_assert(check(S(5), 11), "");
786
787namespace PR14171 {
788
789struct X {
790  constexpr (operator int)() const { return 0; }
791};
792static_assert(X() == 0, "");
793
794}
795
796}
797
798}
799
800namespace Temporaries {
801
802struct S {
803  constexpr S() {}
804  constexpr int f() const;
805  constexpr int g() const;
806};
807struct T : S {
808  constexpr T(int n) : S(), n(n) {}
809  int n;
810};
811constexpr int S::f() const {
812  return static_cast<const T*>(this)->n; // expected-note {{cannot cast}}
813}
814constexpr int S::g() const {
815  // FIXME: Better diagnostic for this.
816  return this->*(int(S::*))&T::n; // expected-note {{subexpression}}
817}
818// The T temporary is implicitly cast to an S subobject, but we can recover the
819// T full-object via a base-to-derived cast, or a derived-to-base-casted member
820// pointer.
821static_assert(S().f(), ""); // expected-error {{constant expression}} expected-note {{in call to '&Temporaries::S()->f()'}}
822static_assert(S().g(), ""); // expected-error {{constant expression}} expected-note {{in call to '&Temporaries::S()->g()'}}
823static_assert(T(3).f() == 3, "");
824static_assert(T(4).g() == 4, "");
825
826constexpr int f(const S &s) {
827  return static_cast<const T&>(s).n;
828}
829constexpr int n = f(T(5));
830static_assert(f(T(5)) == 5, "");
831
832constexpr bool b(int n) { return &n; }
833static_assert(b(0), "");
834
835}
836
837namespace Union {
838
839union U {
840  int a;
841  int b;
842};
843
844constexpr U u[4] = { { .a = 0 }, { .b = 1 }, { .a = 2 }, { .b = 3 } }; // expected-warning 4{{C99 feature}}
845static_assert(u[0].a == 0, "");
846static_assert(u[0].b, ""); // expected-error {{constant expression}} expected-note {{read of member 'b' of union with active member 'a'}}
847static_assert(u[1].b == 1, "");
848static_assert((&u[1].b)[1] == 2, ""); // expected-error {{constant expression}} expected-note {{read of dereferenced one-past-the-end pointer}}
849static_assert(*(&(u[1].b) + 1 + 1) == 3, ""); // expected-error {{constant expression}} expected-note {{cannot refer to element 2 of non-array object}}
850static_assert((&(u[1]) + 1 + 1)->b == 3, "");
851
852constexpr U v = {};
853static_assert(v.a == 0, "");
854
855union Empty {};
856constexpr Empty e = {};
857
858// Make sure we handle trivial copy constructors for unions.
859constexpr U x = {42};
860constexpr U y = x;
861static_assert(y.a == 42, "");
862static_assert(y.b == 42, ""); // expected-error {{constant expression}} expected-note {{'b' of union with active member 'a'}}
863
864}
865
866namespace MemberPointer {
867  struct A {
868    constexpr A(int n) : n(n) {}
869    int n;
870    constexpr int f() const { return n + 3; }
871  };
872  constexpr A a(7);
873  static_assert(A(5).*&A::n == 5, "");
874  static_assert((&a)->*&A::n == 7, "");
875  static_assert((A(8).*&A::f)() == 11, "");
876  static_assert(((&a)->*&A::f)() == 10, "");
877
878  struct B : A {
879    constexpr B(int n, int m) : A(n), m(m) {}
880    int m;
881    constexpr int g() const { return n + m + 1; }
882  };
883  constexpr B b(9, 13);
884  static_assert(B(4, 11).*&A::n == 4, "");
885  static_assert(B(4, 11).*&B::m == 11, "");
886  static_assert(B(4, 11).*(int(A::*))&B::m == 11, "");
887  static_assert((&b)->*&A::n == 9, "");
888  static_assert((&b)->*&B::m == 13, "");
889  static_assert((&b)->*(int(A::*))&B::m == 13, "");
890  static_assert((B(4, 11).*&A::f)() == 7, "");
891  static_assert((B(4, 11).*&B::g)() == 16, "");
892  static_assert((B(4, 11).*(int(A::*)()const)&B::g)() == 16, "");
893  static_assert(((&b)->*&A::f)() == 12, "");
894  static_assert(((&b)->*&B::g)() == 23, "");
895  static_assert(((&b)->*(int(A::*)()const)&B::g)() == 23, "");
896
897  struct S {
898    constexpr S(int m, int n, int (S::*pf)() const, int S::*pn) :
899      m(m), n(n), pf(pf), pn(pn) {}
900    constexpr S() : m(), n(), pf(&S::f), pn(&S::n) {}
901
902    constexpr int f() const { return this->*pn; }
903    virtual int g() const;
904
905    int m, n;
906    int (S::*pf)() const;
907    int S::*pn;
908  };
909
910  constexpr int S::*pm = &S::m;
911  constexpr int S::*pn = &S::n;
912  constexpr int (S::*pf)() const = &S::f;
913  constexpr int (S::*pg)() const = &S::g;
914
915  constexpr S s(2, 5, &S::f, &S::m);
916
917  static_assert((s.*&S::f)() == 2, "");
918  static_assert((s.*s.pf)() == 2, "");
919
920  static_assert(pf == &S::f, "");
921  static_assert(pf == s.*&S::pf, "");
922  static_assert(pm == &S::m, "");
923  static_assert(pm != pn, "");
924  static_assert(s.pn != pn, "");
925  static_assert(s.pn == pm, "");
926  static_assert(pg != nullptr, "");
927  static_assert(pf != nullptr, "");
928  static_assert((int S::*)nullptr == nullptr, "");
929  static_assert(pg == pg, ""); // expected-error {{constant expression}} expected-note {{comparison of pointer to virtual member function 'g' has unspecified value}}
930  static_assert(pf != pg, ""); // expected-error {{constant expression}} expected-note {{comparison of pointer to virtual member function 'g' has unspecified value}}
931
932  template<int n> struct T : T<n-1> {};
933  template<> struct T<0> { int n; };
934  template<> struct T<30> : T<29> { int m; };
935
936  T<17> t17;
937  T<30> t30;
938
939  constexpr int (T<10>::*deepn) = &T<0>::n;
940  static_assert(&(t17.*deepn) == &t17.n, "");
941  static_assert(deepn == &T<2>::n, "");
942
943  constexpr int (T<15>::*deepm) = (int(T<10>::*))&T<30>::m;
944  constexpr int *pbad = &(t17.*deepm); // expected-error {{constant expression}}
945  static_assert(&(t30.*deepm) == &t30.m, "");
946  static_assert(deepm == &T<50>::m, "");
947  static_assert(deepm != deepn, "");
948
949  constexpr T<5> *p17_5 = &t17;
950  constexpr T<13> *p17_13 = (T<13>*)p17_5;
951  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>'}}
952  static_assert(&(p17_5->*(int(T<3>::*))deepn) == &t17.n, "");
953  static_assert(&(p17_13->*deepn) == &t17.n, "");
954  constexpr int *pbad2 = &(p17_13->*(int(T<9>::*))deepm); // expected-error {{constant expression}}
955
956  constexpr T<5> *p30_5 = &t30;
957  constexpr T<23> *p30_23 = (T<23>*)p30_5;
958  constexpr T<13> *p30_13 = p30_23;
959  static_assert(&(p30_5->*(int(T<3>::*))deepn) == &t30.n, "");
960  static_assert(&(p30_13->*deepn) == &t30.n, "");
961  static_assert(&(p30_23->*deepn) == &t30.n, "");
962  static_assert(&(p30_5->*(int(T<2>::*))deepm) == &t30.m, "");
963  static_assert(&(((T<17>*)p30_13)->*deepm) == &t30.m, "");
964  static_assert(&(p30_23->*deepm) == &t30.m, "");
965
966  struct Base { int n; };
967  template<int N> struct Mid : Base {};
968  struct Derived : Mid<0>, Mid<1> {};
969  static_assert(&Mid<0>::n == &Mid<1>::n, "");
970  static_assert((int Derived::*)(int Mid<0>::*)&Mid<0>::n !=
971                (int Derived::*)(int Mid<1>::*)&Mid<1>::n, "");
972  static_assert(&Mid<0>::n == (int Mid<0>::*)&Base::n, "");
973}
974
975namespace ArrayBaseDerived {
976
977  struct Base {
978    constexpr Base() {}
979    int n = 0;
980  };
981  struct Derived : Base {
982    constexpr Derived() {}
983    constexpr const int *f() const { return &n; }
984  };
985
986  constexpr Derived a[10];
987  constexpr Derived *pd3 = const_cast<Derived*>(&a[3]);
988  constexpr Base *pb3 = const_cast<Derived*>(&a[3]);
989  static_assert(pb3 == pd3, "");
990
991  // pb3 does not point to an array element.
992  constexpr Base *pb4 = pb3 + 1; // ok, one-past-the-end pointer.
993  constexpr int pb4n = pb4->n; // expected-error {{constant expression}} expected-note {{cannot access field of pointer past the end}}
994  constexpr Base *err_pb5 = pb3 + 2; // expected-error {{constant expression}} expected-note {{cannot refer to element 2}} expected-note {{here}}
995  constexpr int err_pb5n = err_pb5->n; // expected-error {{constant expression}} expected-note {{initializer of 'err_pb5' is not a constant expression}}
996  constexpr Base *err_pb2 = pb3 - 1; // expected-error {{constant expression}} expected-note {{cannot refer to element -1}} expected-note {{here}}
997  constexpr int err_pb2n = err_pb2->n; // expected-error {{constant expression}} expected-note {{initializer of 'err_pb2'}}
998  constexpr Base *pb3a = pb4 - 1;
999
1000  // pb4 does not point to a Derived.
1001  constexpr Derived *err_pd4 = (Derived*)pb4; // expected-error {{constant expression}} expected-note {{cannot access derived class of pointer past the end}}
1002  constexpr Derived *pd3a = (Derived*)pb3a;
1003  constexpr int pd3n = pd3a->n;
1004
1005  // pd3a still points to the Derived array.
1006  constexpr Derived *pd6 = pd3a + 3;
1007  static_assert(pd6 == &a[6], "");
1008  constexpr Derived *pd9 = pd6 + 3;
1009  constexpr Derived *pd10 = pd6 + 4;
1010  constexpr int pd9n = pd9->n; // ok
1011  constexpr int err_pd10n = pd10->n; // expected-error {{constant expression}} expected-note {{cannot access base class of pointer past the end}}
1012  constexpr int pd0n = pd10[-10].n;
1013  constexpr int err_pdminus1n = pd10[-11].n; // expected-error {{constant expression}} expected-note {{cannot refer to element -1 of}}
1014
1015  constexpr Base *pb9 = pd9;
1016  constexpr const int *(Base::*pfb)() const =
1017      static_cast<const int *(Base::*)() const>(&Derived::f);
1018  static_assert((pb9->*pfb)() == &a[9].n, "");
1019}
1020
1021namespace Complex {
1022
1023class complex {
1024  int re, im;
1025public:
1026  constexpr complex(int re = 0, int im = 0) : re(re), im(im) {}
1027  constexpr complex(const complex &o) : re(o.re), im(o.im) {}
1028  constexpr complex operator-() const { return complex(-re, -im); }
1029  friend constexpr complex operator+(const complex &l, const complex &r) {
1030    return complex(l.re + r.re, l.im + r.im);
1031  }
1032  friend constexpr complex operator-(const complex &l, const complex &r) {
1033    return l + -r;
1034  }
1035  friend constexpr complex operator*(const complex &l, const complex &r) {
1036    return complex(l.re * r.re - l.im * r.im, l.re * r.im + l.im * r.re);
1037  }
1038  friend constexpr bool operator==(const complex &l, const complex &r) {
1039    return l.re == r.re && l.im == r.im;
1040  }
1041  constexpr bool operator!=(const complex &r) const {
1042    return re != r.re || im != r.im;
1043  }
1044  constexpr int real() const { return re; }
1045  constexpr int imag() const { return im; }
1046};
1047
1048constexpr complex i = complex(0, 1);
1049constexpr complex k = (3 + 4*i) * (6 - 4*i);
1050static_assert(complex(1,0).real() == 1, "");
1051static_assert(complex(1,0).imag() == 0, "");
1052static_assert(((complex)1).imag() == 0, "");
1053static_assert(k.real() == 34, "");
1054static_assert(k.imag() == 12, "");
1055static_assert(k - 34 == 12*i, "");
1056static_assert((complex)1 == complex(1), "");
1057static_assert((complex)1 != complex(0, 1), "");
1058static_assert(complex(1) == complex(1), "");
1059static_assert(complex(1) != complex(0, 1), "");
1060constexpr complex makeComplex(int re, int im) { return complex(re, im); }
1061static_assert(makeComplex(1,0) == complex(1), "");
1062static_assert(makeComplex(1,0) != complex(0, 1), "");
1063
1064class complex_wrap : public complex {
1065public:
1066  constexpr complex_wrap(int re, int im = 0) : complex(re, im) {}
1067  constexpr complex_wrap(const complex_wrap &o) : complex(o) {}
1068};
1069
1070static_assert((complex_wrap)1 == complex(1), "");
1071static_assert((complex)1 != complex_wrap(0, 1), "");
1072static_assert(complex(1) == complex_wrap(1), "");
1073static_assert(complex_wrap(1) != complex(0, 1), "");
1074constexpr complex_wrap makeComplexWrap(int re, int im) {
1075  return complex_wrap(re, im);
1076}
1077static_assert(makeComplexWrap(1,0) == complex(1), "");
1078static_assert(makeComplexWrap(1,0) != complex(0, 1), "");
1079
1080}
1081
1082namespace PR11595 {
1083  struct A { constexpr bool operator==(int x) const { return true; } };
1084  struct B { B(); A& x; };
1085  static_assert(B().x == 3, "");  // expected-error {{constant expression}} expected-note {{non-literal type 'PR11595::B' cannot be used in a constant expression}}
1086
1087  constexpr bool f(int k) { // expected-error {{constexpr function never produces a constant expression}}
1088    return B().x == k; // expected-note {{non-literal type 'PR11595::B' cannot be used in a constant expression}}
1089  }
1090}
1091
1092namespace ExprWithCleanups {
1093  struct A { A(); ~A(); int get(); };
1094  constexpr int get(bool FromA) { return FromA ? A().get() : 1; }
1095  constexpr int n = get(false);
1096}
1097
1098namespace Volatile {
1099
1100volatile constexpr int n1 = 0; // expected-note {{here}}
1101volatile const int n2 = 0; // expected-note {{here}}
1102int n3 = 37; // expected-note {{declared here}}
1103
1104constexpr int m1 = n1; // expected-error {{constant expression}} expected-note {{read of volatile-qualified type 'const volatile int'}}
1105constexpr int m2 = n2; // expected-error {{constant expression}} expected-note {{read of volatile-qualified type 'const volatile int'}}
1106constexpr int m1b = const_cast<const int&>(n1); // expected-error {{constant expression}} expected-note {{read of volatile object 'n1'}}
1107constexpr int m2b = const_cast<const int&>(n2); // expected-error {{constant expression}} expected-note {{read of volatile object 'n2'}}
1108
1109struct T { int n; };
1110const T t = { 42 }; // expected-note {{declared here}}
1111
1112constexpr int f(volatile int &&r) {
1113  return r; // expected-note {{read of volatile-qualified type 'volatile int'}}
1114}
1115constexpr int g(volatile int &&r) {
1116  return const_cast<int&>(r); // expected-note {{read of volatile temporary is not allowed in a constant expression}}
1117}
1118struct S {
1119  int j : f(0); // expected-error {{constant expression}} expected-note {{in call to 'f(0)'}}
1120  int k : g(0); // expected-error {{constant expression}} expected-note {{temporary created here}} expected-note {{in call to 'g(0)'}}
1121  int l : n3; // expected-error {{constant expression}} expected-note {{read of non-const variable}}
1122  int m : t.n; // expected-error {{constant expression}} expected-note {{read of non-constexpr variable}}
1123};
1124
1125}
1126
1127namespace ExternConstexpr {
1128  extern constexpr int n = 0;
1129  extern constexpr int m; // expected-error {{constexpr variable declaration must be a definition}}
1130  void f() {
1131    extern constexpr int i; // expected-error {{constexpr variable declaration must be a definition}}
1132    constexpr int j = 0;
1133    constexpr int k; // expected-error {{default initialization of an object of const type}}
1134  }
1135}
1136
1137namespace ComplexConstexpr {
1138  constexpr _Complex float test1 = {};
1139  constexpr _Complex float test2 = {1};
1140  constexpr _Complex double test3 = {1,2};
1141  constexpr _Complex int test4 = {4};
1142  constexpr _Complex int test5 = 4;
1143  constexpr _Complex int test6 = {5,6};
1144  typedef _Complex float fcomplex;
1145  constexpr fcomplex test7 = fcomplex();
1146
1147  constexpr const double &t2r = __real test3;
1148  constexpr const double &t2i = __imag test3;
1149  static_assert(&t2r + 1 == &t2i, "");
1150  static_assert(t2r == 1.0, "");
1151  static_assert(t2i == 2.0, "");
1152  constexpr const double *t2p = &t2r;
1153  static_assert(t2p[-1] == 0.0, ""); // expected-error {{constant expr}} expected-note {{cannot refer to element -1 of array of 2 elements}}
1154  static_assert(t2p[0] == 1.0, "");
1155  static_assert(t2p[1] == 2.0, "");
1156  static_assert(t2p[2] == 0.0, ""); // expected-error {{constant expr}} expected-note {{one-past-the-end pointer}}
1157  static_assert(t2p[3] == 0.0, ""); // expected-error {{constant expr}} expected-note {{cannot refer to element 3 of array of 2 elements}}
1158  constexpr _Complex float *p = 0;
1159  constexpr float pr = __real *p; // expected-error {{constant expr}} expected-note {{cannot access real component of null}}
1160  constexpr float pi = __imag *p; // expected-error {{constant expr}} expected-note {{cannot access imaginary component of null}}
1161  constexpr const _Complex double *q = &test3 + 1;
1162  constexpr double qr = __real *q; // expected-error {{constant expr}} expected-note {{cannot access real component of pointer past the end}}
1163  constexpr double qi = __imag *q; // expected-error {{constant expr}} expected-note {{cannot access imaginary component of pointer past the end}}
1164
1165  static_assert(__real test6 == 5, "");
1166  static_assert(__imag test6 == 6, "");
1167  static_assert(&__imag test6 == &__real test6 + 1, "");
1168}
1169
1170// _Atomic(T) is exactly like T for the purposes of constant expression
1171// evaluation..
1172namespace Atomic {
1173  constexpr _Atomic int n = 3;
1174
1175  struct S { _Atomic(double) d; };
1176  constexpr S s = { 0.5 };
1177  constexpr double d1 = s.d;
1178  constexpr double d2 = n;
1179  constexpr _Atomic double d3 = n;
1180
1181  constexpr _Atomic(int) n2 = d3;
1182  static_assert(d1 == 0.5, "");
1183  static_assert(d3 == 3.0, "");
1184
1185  namespace PR16056 {
1186    struct TestVar {
1187      _Atomic(int) value;
1188      constexpr TestVar(int value) : value(value) {}
1189    };
1190    constexpr TestVar testVar{-1};
1191    static_assert(testVar.value == -1, "");
1192  }
1193}
1194
1195namespace InstantiateCaseStmt {
1196  template<int x> constexpr int f() { return x; }
1197  template<int x> int g(int c) { switch(c) { case f<x>(): return 1; } return 0; }
1198  int gg(int c) { return g<4>(c); }
1199}
1200
1201namespace ConvertedConstantExpr {
1202  extern int &m;
1203  extern int &n;
1204
1205  constexpr int k = 4;
1206  int &m = const_cast<int&>(k);
1207
1208  // If we have nothing more interesting to say, ensure we don't produce a
1209  // useless note and instead just point to the non-constant subexpression.
1210  enum class E {
1211    em = m,
1212    en = n, // expected-error {{not a constant expression}}
1213    eo = (m +
1214          n // expected-error {{not a constant expression}}
1215          ),
1216    eq = reinterpret_cast<int>((int*)0) // expected-error {{not a constant expression}} expected-note {{reinterpret_cast}}
1217  };
1218}
1219
1220namespace IndirectField {
1221  struct S {
1222    struct { // expected-warning {{GNU extension}}
1223      union { // expected-warning {{declared in an anonymous struct}}
1224        struct { // expected-warning {{GNU extension}} expected-warning {{declared in an anonymous union}}
1225          int a;
1226          int b;
1227        };
1228        int c;
1229      };
1230      int d;
1231    };
1232    union {
1233      int e;
1234      int f;
1235    };
1236    constexpr S(int a, int b, int d, int e) : a(a), b(b), d(d), e(e) {}
1237    constexpr S(int c, int d, int f) : c(c), d(d), f(f) {}
1238  };
1239
1240  constexpr S s1(1, 2, 3, 4);
1241  constexpr S s2(5, 6, 7);
1242
1243  // FIXME: The diagnostics here do a very poor job of explaining which unnamed
1244  // member is active and which is requested.
1245  static_assert(s1.a == 1, "");
1246  static_assert(s1.b == 2, "");
1247  static_assert(s1.c == 0, ""); // expected-error {{constant expression}} expected-note {{union with active member}}
1248  static_assert(s1.d == 3, "");
1249  static_assert(s1.e == 4, "");
1250  static_assert(s1.f == 0, ""); // expected-error {{constant expression}} expected-note {{union with active member}}
1251
1252  static_assert(s2.a == 0, ""); // expected-error {{constant expression}} expected-note {{union with active member}}
1253  static_assert(s2.b == 0, ""); // expected-error {{constant expression}} expected-note {{union with active member}}
1254  static_assert(s2.c == 5, "");
1255  static_assert(s2.d == 6, "");
1256  static_assert(s2.e == 0, ""); // expected-error {{constant expression}} expected-note {{union with active member}}
1257  static_assert(s2.f == 7, "");
1258}
1259
1260// DR1405: don't allow reading mutable members in constant expressions.
1261namespace MutableMembers {
1262  struct MM {
1263    mutable int n; // expected-note 3{{declared here}}
1264  } constexpr mm = { 4 };
1265  constexpr int mmn = mm.n; // expected-error {{constant expression}} expected-note {{read of mutable member 'n' is not allowed in a constant expression}}
1266  int x = (mm.n = 1, 3);
1267  constexpr int mmn2 = mm.n; // expected-error {{constant expression}} expected-note {{read of mutable member 'n' is not allowed in a constant expression}}
1268
1269  // Here's one reason why allowing this would be a disaster...
1270  template<int n> struct Id { int k = n; };
1271  int f() {
1272    constexpr MM m = { 0 };
1273    ++m.n;
1274    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}}
1275  }
1276
1277  struct A { int n; };
1278  struct B { mutable A a; }; // expected-note {{here}}
1279  struct C { B b; };
1280  constexpr C c[3] = {};
1281  constexpr int k = c[1].b.a.n; // expected-error {{constant expression}} expected-note {{mutable}}
1282}
1283
1284namespace Fold {
1285
1286  // This macro forces its argument to be constant-folded, even if it's not
1287  // otherwise a constant expression.
1288  #define fold(x) (__builtin_constant_p(x) ? (x) : (x))
1289
1290  constexpr int n = (int)(char*)123; // expected-error {{constant expression}} expected-note {{reinterpret_cast}}
1291  constexpr int m = fold((int)(char*)123); // ok
1292  static_assert(m == 123, "");
1293
1294  #undef fold
1295
1296}
1297
1298namespace DR1454 {
1299
1300constexpr const int &f(const int &n) { return n; }
1301constexpr int k1 = f(0); // ok
1302
1303struct Wrap {
1304  const int &value;
1305};
1306constexpr const Wrap &g(const Wrap &w) { return w; }
1307constexpr int k2 = g({0}).value; // ok
1308
1309// The temporary here has static storage duration, so we can bind a constexpr
1310// reference to it.
1311constexpr const int &i = 1;
1312constexpr const int j = i;
1313static_assert(j == 1, "");
1314
1315// The temporary here is not const, so it can't be read outside the expression
1316// in which it was created (per the C++14 rules, which we use to avoid a C++11
1317// defect).
1318constexpr int &&k = 1; // expected-note {{temporary created here}}
1319constexpr const int l = k; // expected-error {{constant expression}} expected-note {{read of temporary}}
1320
1321void f() {
1322  // The temporary here has automatic storage duration, so we can't bind a
1323  // constexpr reference to it.
1324  constexpr const int &i = 1; // expected-error {{constant expression}} expected-note 2{{temporary}}
1325}
1326
1327}
1328
1329namespace RecursiveOpaqueExpr {
1330  template<typename Iter>
1331  constexpr auto LastNonzero(Iter p, Iter q) -> decltype(+*p) {
1332    return p != q ? (LastNonzero(p+1, q) ?: *p) : 0; // expected-warning {{GNU}}
1333  }
1334
1335  constexpr int arr1[] = { 1, 0, 0, 3, 0, 2, 0, 4, 0, 0 };
1336  static_assert(LastNonzero(begin(arr1), end(arr1)) == 4, "");
1337
1338  constexpr int arr2[] = { 1, 0, 0, 3, 0, 2, 0, 4, 0, 5 };
1339  static_assert(LastNonzero(begin(arr2), end(arr2)) == 5, "");
1340
1341  constexpr int arr3[] = {
1342    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,
1343    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,
1344    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,
1345    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,
1346    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,
1347    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,
1348    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,
1349    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 };
1350  static_assert(LastNonzero(begin(arr3), end(arr3)) == 2, "");
1351}
1352
1353namespace VLASizeof {
1354
1355  void f(int k) {
1356    int arr[k]; // expected-warning {{C99}}
1357    constexpr int n = 1 +
1358        sizeof(arr) // expected-error {{constant expression}}
1359        * 3;
1360  }
1361}
1362
1363namespace CompoundLiteral {
1364  // FIXME:
1365  // We don't model the semantics of this correctly: the compound literal is
1366  // represented as a prvalue in the AST, but actually behaves like an lvalue.
1367  // We treat the compound literal as a temporary and refuse to produce a
1368  // pointer to it. This is OK: we're not required to treat this as a constant
1369  // in C++, and in C we model compound literals as lvalues.
1370  constexpr int *p = (int*)(int[1]){0}; // expected-warning {{C99}} expected-error {{constant expression}} expected-note 2{{temporary}}
1371}
1372
1373namespace Vector {
1374  typedef int __attribute__((vector_size(16))) VI4;
1375  constexpr VI4 f(int n) {
1376    return VI4 { n * 3, n + 4, n - 5, n / 6 };
1377  }
1378  constexpr auto v1 = f(10);
1379
1380  typedef double __attribute__((vector_size(32))) VD4;
1381  constexpr VD4 g(int n) {
1382    return (VD4) { n / 2.0, n + 1.5, n - 5.4, n * 0.9 }; // expected-warning {{C99}}
1383  }
1384  constexpr auto v2 = g(4);
1385}
1386
1387// PR12626, redux
1388namespace InvalidClasses {
1389  void test0() {
1390    struct X; // expected-note {{forward declaration}}
1391    struct Y { bool b; X x; }; // expected-error {{field has incomplete type}}
1392    Y y;
1393    auto& b = y.b;
1394  }
1395}
1396
1397namespace NamespaceAlias {
1398  constexpr int f() {
1399    namespace NS = NamespaceAlias; // expected-warning {{use of this statement in a constexpr function is a C++1y extension}}
1400    return &NS::f != nullptr;
1401  }
1402}
1403
1404// Constructors can be implicitly constexpr, even for a non-literal type.
1405namespace ImplicitConstexpr {
1406  struct Q { Q() = default; Q(const Q&) = default; Q(Q&&) = default; ~Q(); }; // expected-note 3{{here}}
1407  struct R { constexpr R() noexcept; constexpr R(const R&) noexcept; constexpr R(R&&) noexcept; ~R() noexcept; };
1408  struct S { R r; }; // expected-note 3{{here}}
1409  struct T { T(const T&) noexcept; T(T &&) noexcept; ~T() noexcept; };
1410  struct U { T t; }; // expected-note 3{{here}}
1411  static_assert(!__is_literal_type(Q), "");
1412  static_assert(!__is_literal_type(R), "");
1413  static_assert(!__is_literal_type(S), "");
1414  static_assert(!__is_literal_type(T), "");
1415  static_assert(!__is_literal_type(U), "");
1416  struct Test {
1417    friend Q::Q() noexcept; // expected-error {{follows constexpr}}
1418    friend Q::Q(Q&&) noexcept; // expected-error {{follows constexpr}}
1419    friend Q::Q(const Q&) noexcept; // expected-error {{follows constexpr}}
1420    friend S::S() noexcept; // expected-error {{follows constexpr}}
1421    friend S::S(S&&) noexcept; // expected-error {{follows constexpr}}
1422    friend S::S(const S&) noexcept; // expected-error {{follows constexpr}}
1423    friend constexpr U::U() noexcept; // expected-error {{follows non-constexpr}}
1424    friend constexpr U::U(U&&) noexcept; // expected-error {{follows non-constexpr}}
1425    friend constexpr U::U(const U&) noexcept; // expected-error {{follows non-constexpr}}
1426  };
1427}
1428
1429// Indirectly test that an implicit lvalue to xvalue conversion performed for
1430// an NRVO move operation isn't implemented as CK_LValueToRValue.
1431namespace PR12826 {
1432  struct Foo {};
1433  constexpr Foo id(Foo x) { return x; }
1434  constexpr Foo res(id(Foo()));
1435}
1436
1437namespace PR13273 {
1438  struct U {
1439    int t;
1440    U() = default;
1441  };
1442
1443  struct S : U {
1444    S() = default;
1445  };
1446
1447  // S's default constructor isn't constexpr, because U's default constructor
1448  // doesn't initialize 't', but it's trivial, so value-initialization doesn't
1449  // actually call it.
1450  static_assert(S{}.t == 0, "");
1451}
1452
1453namespace PR12670 {
1454  struct S {
1455    constexpr S(int a0) : m(a0) {}
1456    constexpr S() : m(6) {}
1457    int m;
1458  };
1459  constexpr S x[3] = { {4}, 5 };
1460  static_assert(x[0].m == 4, "");
1461  static_assert(x[1].m == 5, "");
1462  static_assert(x[2].m == 6, "");
1463}
1464
1465// Indirectly test that an implicit lvalue-to-rvalue conversion is performed
1466// when a conditional operator has one argument of type void and where the other
1467// is a glvalue of class type.
1468namespace ConditionalLValToRVal {
1469  struct A {
1470    constexpr A(int a) : v(a) {}
1471    int v;
1472  };
1473
1474  constexpr A f(const A &a) {
1475    return a.v == 0 ? throw a : a;
1476  }
1477
1478  constexpr A a(4);
1479  static_assert(f(a).v == 4, "");
1480}
1481
1482namespace TLS {
1483  __thread int n;
1484  int m;
1485
1486  constexpr bool b = &n == &n;
1487
1488  constexpr int *p = &n; // expected-error{{constexpr variable 'p' must be initialized by a constant expression}}
1489
1490  constexpr int *f() { return &n; }
1491  constexpr int *q = f(); // expected-error{{constexpr variable 'q' must be initialized by a constant expression}}
1492  constexpr bool c = f() == f();
1493
1494  constexpr int *g() { return &m; }
1495  constexpr int *r = g();
1496}
1497
1498namespace Void {
1499  constexpr void f() { return; } // expected-error{{constexpr function's return type 'void' is not a literal type}}
1500
1501  void assert_failed(const char *msg, const char *file, int line); // expected-note {{declared here}}
1502#define ASSERT(expr) ((expr) ? static_cast<void>(0) : assert_failed(#expr, __FILE__, __LINE__))
1503  template<typename T, size_t S>
1504  constexpr T get(T (&a)[S], size_t k) {
1505    return ASSERT(k > 0 && k < S), a[k]; // expected-note{{non-constexpr function 'assert_failed'}}
1506  }
1507#undef ASSERT
1508  template int get(int (&a)[4], size_t);
1509  constexpr int arr[] = { 4, 1, 2, 3, 4 };
1510  static_assert(get(arr, 1) == 1, "");
1511  static_assert(get(arr, 4) == 4, "");
1512  static_assert(get(arr, 0) == 4, ""); // expected-error{{not an integral constant expression}} \
1513  // expected-note{{in call to 'get(arr, 0)'}}
1514}
1515
1516namespace std { struct type_info; }
1517
1518namespace TypeId {
1519  struct A { virtual ~A(); };
1520  A f();
1521  A &g();
1522  constexpr auto &x = typeid(f());
1523  constexpr auto &y = typeid(g()); // expected-error{{constant expression}} \
1524  // expected-note{{typeid applied to expression of polymorphic type 'TypeId::A' is not allowed in a constant expression}}
1525}
1526
1527namespace PR14203 {
1528  struct duration {
1529    constexpr duration() {}
1530    constexpr operator int() const { return 0; }
1531  };
1532  template<typename T> void f() {
1533    // If we want to evaluate this at the point of the template definition, we
1534    // need to trigger the implicit definition of the move constructor at that
1535    // point.
1536    // FIXME: C++ does not permit us to implicitly define it at the appropriate
1537    // times, since it is only allowed to be implicitly defined when it is
1538    // odr-used.
1539    constexpr duration d = duration();
1540  }
1541  // FIXME: It's unclear whether this is valid. On the one hand, we're not
1542  // allowed to generate a move constructor. On the other hand, if we did,
1543  // this would be a constant expression. For now, we generate a move
1544  // constructor here.
1545  int n = sizeof(short{duration(duration())});
1546}
1547
1548namespace ArrayEltInit {
1549  struct A {
1550    constexpr A() : p(&p) {}
1551    void *p;
1552  };
1553  constexpr A a[10];
1554  static_assert(a[0].p == &a[0].p, "");
1555  static_assert(a[9].p == &a[9].p, "");
1556  static_assert(a[0].p != &a[9].p, "");
1557  static_assert(a[9].p != &a[0].p, "");
1558
1559  constexpr A b[10] = {};
1560  static_assert(b[0].p == &b[0].p, "");
1561  static_assert(b[9].p == &b[9].p, "");
1562  static_assert(b[0].p != &b[9].p, "");
1563  static_assert(b[9].p != &b[0].p, "");
1564}
1565
1566namespace PR15884 {
1567  struct S {};
1568  constexpr S f() { return {}; }
1569  constexpr S *p = &f();
1570  // expected-error@-1 {{taking the address of a temporary}}
1571  // expected-error@-2 {{constexpr variable 'p' must be initialized by a constant expression}}
1572  // expected-note@-3 {{pointer to temporary is not a constant expression}}
1573  // expected-note@-4 {{temporary created here}}
1574}
1575
1576namespace AfterError {
1577  // FIXME: Suppress the 'no return statements' diagnostic if the body is invalid.
1578  constexpr int error() { // expected-error {{no return statement}}
1579    return foobar; // expected-error {{undeclared identifier}}
1580  }
1581  constexpr int k = error(); // expected-error {{must be initialized by a constant expression}}
1582}
1583