• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 
3 namespace StaticAssertFoldTest {
4 
5 int x;
6 static_assert(++x, "test"); // expected-error {{not an integral constant expression}}
7 static_assert(false, "test"); // expected-error {{test}}
8 
9 }
10 
11 typedef decltype(sizeof(char)) size_t;
12 
id(const T & t)13 template<typename T> constexpr T id(const T &t) { return t; }
min(const T & a,const T & b)14 template<typename T> constexpr T min(const T &a, const T &b) {
15   return a < b ? a : b;
16 }
max(const T & a,const T & b)17 template<typename T> constexpr T max(const T &a, const T &b) {
18   return a < b ? b : a;
19 }
begin(T (& xs)[N])20 template<typename T, size_t N> constexpr T *begin(T (&xs)[N]) { return xs; }
end(T (& xs)[N])21 template<typename T, size_t N> constexpr T *end(T (&xs)[N]) { return xs + N; }
22 
23 struct MemberZero {
zeroMemberZero24   constexpr int zero() const { return 0; }
25 };
26 
27 namespace 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 
71 namespace ConstCast {
72 
73 constexpr int n1 = 0;
74 constexpr int n2 = const_cast<int&>(n1);
75 constexpr int *n3 = const_cast<int*>(&n1);
76 constexpr int n4 = *const_cast<int*>(&n1);
77 constexpr const int * const *n5 = const_cast<const int* const*>(&n3);
78 constexpr int **n6 = const_cast<int**>(&n3);
79 constexpr int n7 = **n5;
80 constexpr int n8 = **n6;
81 
82 // const_cast from prvalue to xvalue.
83 struct A { int n; };
84 constexpr int n9 = (const_cast<A&&>(A{123})).n;
85 static_assert(n9 == 123, "");
86 
87 }
88 
89 namespace 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 
97 namespace CaseStatements {
98   int x;
f(int n)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 
109 extern int &Recurse1;
110 int &Recurse2 = Recurse1; // expected-note {{declared here}}
111 int &Recurse1 = Recurse2;
112 constexpr int &Recurse3 = Recurse2; // expected-error {{must be initialized by a constant expression}} expected-note {{initializer of 'Recurse2' is not a constant expression}}
113 
114 extern const int RecurseA;
115 const int RecurseB = RecurseA; // expected-note {{declared here}}
116 const int RecurseA = 10;
117 constexpr int RecurseC = RecurseB; // expected-error {{must be initialized by a constant expression}} expected-note {{initializer of 'RecurseB' is not a constant expression}}
118 
119 namespace MemberEnum {
120   struct WithMemberEnum {
121     enum E { A = 42 };
122   } wme;
123 
124   static_assert(wme.A == 42, "");
125 }
126 
127 namespace DefaultArguments {
128 
129 const int z = int();
Sum(int a=0,const int & b=0,const int * c=& z,char d=0)130 constexpr int Sum(int a = 0, const int &b = 0, const int *c = &z, char d = 0) {
131   return a + b + *c + d;
132 }
133 const int four = 4;
134 constexpr int eight = 8;
135 constexpr const int twentyseven = 27;
136 static_assert(Sum() == 0, "");
137 static_assert(Sum(1) == 1, "");
138 static_assert(Sum(1, four) == 5, "");
139 static_assert(Sum(1, eight, &twentyseven) == 36, "");
140 static_assert(Sum(1, 2, &four, eight) == 15, "");
141 
142 }
143 
144 namespace Ellipsis {
145 
146 // Note, values passed through an ellipsis can't actually be used.
F(int a,...)147 constexpr int F(int a, ...) { return a; }
148 static_assert(F(0) == 0, "");
149 static_assert(F(1, 0) == 1, "");
150 static_assert(F(2, "test") == 2, "");
151 static_assert(F(3, &F) == 3, "");
152 int k = 0; // expected-note {{here}}
153 static_assert(F(4, k) == 3, ""); // expected-error {{constant expression}} expected-note {{read of non-const variable 'k'}}
154 
155 }
156 
157 namespace Recursion {
fib(int n)158   constexpr int fib(int n) { return n > 1 ? fib(n-1) + fib(n-2) : n; }
159   static_assert(fib(11) == 89, "");
160 
gcd_inner(int a,int b)161   constexpr int gcd_inner(int a, int b) {
162     return b == 0 ? a : gcd_inner(b, a % b);
163   }
gcd(int a,int b)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 
171 namespace 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.
f()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 
181 namespace StaticMemberFunction {
182   struct S {
183     static constexpr int k = 42;
fStaticMemberFunction::S184     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 
197 namespace ParameterScopes {
198 
199   const int k = 42;
ObscureTheTruth(const int & a)200   constexpr const int &ObscureTheTruth(const int &a) { return a; }
MaybeReturnJunk(bool b,const int 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 
MaybeReturnNonstaticRef(bool b,const int a)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 
InternalReturnJunk(int n)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 
LToR(int & n)218   constexpr int LToR(int &n) { return n; }
GrabCallersArgument(bool which,int a,int b)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 
227 namespace Pointers {
228 
f(int n,const int * a,const int * b,const int * c)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 
g(int n,int a,int b,int c)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 
243 namespace FunctionPointers {
244 
Double(int n)245   constexpr int Double(int n) { return 2 * n; }
Triple(int n)246   constexpr int Triple(int n) { return 3 * n; }
Twice(int (* F)(int),int n)247   constexpr int Twice(int (*F)(int), int n) { return F(F(n)); }
Quadruple(int n)248   constexpr int Quadruple(int n) { return Twice(Double, n); }
Select(int n)249   constexpr auto Select(int n) -> int (*)(int) {
250     return n == 2 ? &Double : n == 3 ? &Triple : n == 4 ? &Quadruple : 0;
251   }
Apply(int (* F)(int),int n)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 
260 namespace PointerComparison {
261 
262 int x, y;
263 static_assert(&x == &y, "false"); // expected-error {{false}}
264 static_assert(&x != &y, "");
265 constexpr bool g1 = &x == &y;
266 constexpr bool g2 = &x != &y;
267 constexpr bool g3 = &x <= &y; // expected-error {{must be initialized by a constant expression}}
268 constexpr bool g4 = &x >= &y; // expected-error {{must be initialized by a constant expression}}
269 constexpr bool g5 = &x < &y; // expected-error {{must be initialized by a constant expression}}
270 constexpr bool g6 = &x > &y; // expected-error {{must be initialized by a constant expression}}
271 
272 struct S { int x, y; } s;
273 static_assert(&s.x == &s.y, "false"); // expected-error {{false}}
274 static_assert(&s.x != &s.y, "");
275 static_assert(&s.x <= &s.y, "");
276 static_assert(&s.x >= &s.y, "false"); // expected-error {{false}}
277 static_assert(&s.x < &s.y, "");
278 static_assert(&s.x > &s.y, "false"); // expected-error {{false}}
279 
280 static_assert(0 == &y, "false"); // expected-error {{false}}
281 static_assert(0 != &y, "");
282 constexpr bool n3 = 0 <= &y; // expected-error {{must be initialized by a constant expression}}
283 constexpr bool n4 = 0 >= &y; // expected-error {{must be initialized by a constant expression}}
284 constexpr bool n5 = 0 < &y; // expected-error {{must be initialized by a constant expression}}
285 constexpr bool n6 = 0 > &y; // expected-error {{must be initialized by a constant expression}}
286 
287 static_assert(&x == 0, "false"); // expected-error {{false}}
288 static_assert(&x != 0, "");
289 constexpr bool n9 = &x <= 0; // expected-error {{must be initialized by a constant expression}}
290 constexpr bool n10 = &x >= 0; // expected-error {{must be initialized by a constant expression}}
291 constexpr bool n11 = &x < 0; // expected-error {{must be initialized by a constant expression}}
292 constexpr bool n12 = &x > 0; // expected-error {{must be initialized by a constant expression}}
293 
294 static_assert(&x == &x, "");
295 static_assert(&x != &x, "false"); // expected-error {{false}}
296 static_assert(&x <= &x, "");
297 static_assert(&x >= &x, "");
298 static_assert(&x < &x, "false"); // expected-error {{false}}
299 static_assert(&x > &x, "false"); // expected-error {{false}}
300 
301 constexpr S* sptr = &s;
302 constexpr bool dyncast = sptr == dynamic_cast<S*>(sptr); // expected-error {{constant expression}} expected-note {{dynamic_cast}}
303 
304 struct U {};
305 struct 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 
329 extern char externalvar[];
330 constexpr bool constaddress = (void *)externalvar == (void *)0x4000UL; // expected-error {{must be initialized by a constant expression}} expected-note {{reinterpret_cast}}
331 constexpr bool litaddress = "foo" == "foo"; // expected-error {{must be initialized by a constant expression}} expected-warning {{unspecified}}
332 static_assert(0 != "foo", "");
333 
334 }
335 
336 namespace MaterializeTemporary {
337 
f(const int & r)338 constexpr int f(const int &r) { return r; }
339 constexpr int n = f(1);
340 
same(const int & a,const int & b)341 constexpr bool same(const int &a, const int &b) { return &a == &b; }
sameTemporary(const int & n)342 constexpr bool sameTemporary(const int &n) { return same(n, n); }
343 
344 static_assert(n, "");
345 static_assert(!same(4, 4), "");
346 static_assert(same(n, n), "");
347 static_assert(sameTemporary(9), "");
348 
349 struct A { int &&r; };
350 struct B { A &&a1; A &&a2; };
351 
352 constexpr B b1 { { 1 }, { 2 } }; // expected-note {{temporary created here}}
353 static_assert(&b1.a1 != &b1.a2, "");
354 static_assert(&b1.a1.r != &b1.a2.r, ""); // expected-error {{constant expression}} expected-note {{outside the expression that created the temporary}}
355 
356 constexpr B &&b2 { { 3 }, { 4 } }; // expected-note {{temporary created here}}
357 static_assert(&b1 != &b2, "");
358 static_assert(&b1.a1 != &b2.a1, ""); // expected-error {{constant expression}} expected-note {{outside the expression that created the temporary}}
359 
360 constexpr thread_local B b3 { { 1 }, { 2 } }; // expected-error {{constant expression}} expected-note {{reference to temporary}} expected-note {{here}}
foo()361 void 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 
367 constexpr B &&b4 = ((1, 2), 3, 4, B { {10}, {{20}} }); // expected-warning 4{{unused}}
368 static_assert(&b4 != &b2, "");
369 
370 // Proposed DR: copy-elision doesn't trigger lifetime extension.
371 constexpr B b5 = B{ {0}, {0} }; // expected-error {{constant expression}} expected-note {{reference to temporary}} expected-note {{here}}
372 
373 namespace 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 
383 namespace 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 
strcmp_ce(const char * p,const char * q)391 constexpr int strcmp_ce(const char *p, const char *q) {
392   return (!*p || *p != *q) ? *p - *q : strcmp_ce(p+1, q+1);
393 }
394 
395 namespace StringLiteral {
396 
397 template<typename Char>
MangleChars(const Char * p)398 constexpr int MangleChars(const Char *p) {
399   return *p + 3 * (*p ? MangleChars(p+1) : 0);
400 }
401 
402 static_assert(MangleChars("constexpr!") == 1768383, "");
403 static_assert(MangleChars(u8"constexpr!") == 1768383, "");
404 static_assert(MangleChars(L"constexpr!") == 1768383, "");
405 static_assert(MangleChars(u"constexpr!") == 1768383, "");
406 static_assert(MangleChars(U"constexpr!") == 1768383, "");
407 
408 constexpr char c0 = "nought index"[0];
409 constexpr char c1 = "nice index"[10];
410 constexpr 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}}
411 constexpr 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}}
412 constexpr 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 
414 constexpr const char *p = "test" + 2;
415 static_assert(*p == 's', "");
416 
max_iter(const char * a,const char * b)417 constexpr const char *max_iter(const char *a, const char *b) {
418   return *a < *b ? b : a;
419 }
max_element(const char * a,const char * b)420 constexpr 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 
424 constexpr char str[] = "the quick brown fox jumped over the lazy dog";
425 constexpr const char *max = max_element(begin(str), end(str));
426 static_assert(*max == 'z', "");
427 static_assert(max == str + 38, "");
428 
429 static_assert(strcmp_ce("hello world", "hello world") == 0, "");
430 static_assert(strcmp_ce("hello world", "hello clang") > 0, "");
431 static_assert(strcmp_ce("constexpr", "test") < 0, "");
432 static_assert(strcmp_ce("", " ") < 0, "");
433 
434 struct 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 
438 struct T {
439   char c[6];
TStringLiteral::T440   constexpr T() : c{"foo"} {}
441 };
442 constexpr T t;
443 
444 static_assert(t.c[0] == 'f', "");
445 static_assert(t.c[1] == 'o', "");
446 static_assert(t.c[2] == 'o', "");
447 static_assert(t.c[3] == 0, "");
448 static_assert(t.c[4] == 0, "");
449 static_assert(t.c[5] == 0, "");
450 static_assert(t.c[6] == 0, ""); // expected-error {{constant expression}} expected-note {{one-past-the-end}}
451 
452 struct U {
453   wchar_t chars[6];
454   int n;
455 } constexpr u = { { L"test" }, 0 };
456 static_assert(u.chars[2] == L's', "");
457 
458 struct V {
459   char c[4];
VStringLiteral::V460   constexpr V() : c("hi!") {}
461 };
462 static_assert(V().c[1] == "i"[0], "");
463 
464 namespace 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 
479 namespace Array {
480 
481 template<typename Iter>
Sum(Iter begin,Iter end)482 constexpr auto Sum(Iter begin, Iter end) -> decltype(+*begin) {
483   return begin == end ? 0 : *begin + Sum(begin+1, end);
484 }
485 
486 constexpr int xs[] = { 1, 2, 3, 4, 5 };
487 constexpr int ys[] = { 5, 4, 3, 2, 1 };
488 constexpr int sum_xs = Sum(begin(xs), end(xs));
489 static_assert(sum_xs == 15, "");
490 
ZipFoldR(int (* F)(int x,int y,int c),int n,const int * xs,const int * ys,int c)491 constexpr 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 }
MulAdd(int x,int y,int c)501 constexpr int MulAdd(int x, int y, int c) { return x * y + c; }
502 constexpr int InnerProduct = ZipFoldR(MulAdd, 5, xs, ys, 0);
503 static_assert(InnerProduct == 35, "");
504 
SubMul(int x,int y,int c)505 constexpr int SubMul(int x, int y, int c) { return (x - y) * c; }
506 constexpr int DiffProd = ZipFoldR(SubMul, 2, xs+3, ys+3, 1);
507 static_assert(DiffProd == 8, "");
508 static_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 
512 constexpr const int *p = xs + 3;
513 constexpr int xs4 = p[1]; // ok
514 constexpr int xs5 = p[2]; // expected-error {{constant expression}} expected-note {{read of dereferenced one-past-the-end pointer}}
515 constexpr int xs6 = p[3]; // expected-error {{constant expression}} expected-note {{cannot refer to element 6}}
516 constexpr int xs0 = p[-3]; // ok
517 constexpr int xs_1 = p[-4]; // expected-error {{constant expression}} expected-note {{cannot refer to element -1}}
518 
519 constexpr int zs[2][2][2][2] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
520 static_assert(zs[0][0][0][0] == 1, "");
521 static_assert(zs[1][1][1][1] == 16, "");
522 static_assert(zs[0][0][0][2] == 3, ""); // expected-error {{constant expression}} expected-note {{read of dereferenced one-past-the-end pointer}}
523 static_assert((&zs[0][0][0][2])[-1] == 2, "");
524 static_assert(**(**(zs + 1) + 1) == 11, "");
525 static_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}}
526 static_assert(*(&(&(*(*&(&zs[2] - 1)[0] + 2 - 2))[2])[-1][2] - 2) == 11, "");
527 constexpr 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 
fail(const int & p)529 constexpr int fail(const int &p) {
530   return (&p)[64]; // expected-note {{cannot refer to element 64 of array of 2 elements}}
531 }
532 static_assert(fail(*(&(&(*(*&(&zs[2] - 1)[0] + 2 - 2))[2])[-1][2] - 2)) == 11, ""); // \
533 expected-error {{static_assert expression is not an integral constant expression}} \
534 expected-note {{in call to 'fail(zs[1][0][1][0])'}}
535 
536 constexpr int arr[40] = { 1, 2, 3, [8] = 4 }; // expected-warning {{C99 feature}}
SumNonzero(const int * p)537 constexpr int SumNonzero(const int *p) {
538   return *p + (*p ? SumNonzero(p+1) : 0);
539 }
CountZero(const int * p,const int * q)540 constexpr int CountZero(const int *p, const int *q) {
541   return p == q ? 0 : (*p == 0) + CountZero(p+1, q);
542 }
543 static_assert(SumNonzero(arr) == 6, "");
544 static_assert(CountZero(arr, arr + 40) == 36, "");
545 
546 struct ArrayElem {
ArrayElemArray::ArrayElem547   constexpr ArrayElem() : n(0) {}
548   int n;
fArray::ArrayElem549   constexpr int f() const { return n; }
550 };
551 struct ArrayRVal {
ArrayRValArray::ArrayRVal552   constexpr ArrayRVal() {}
553   ArrayElem elems[10];
554 };
555 static_assert(ArrayRVal().elems[3].f() == 0, "");
556 
557 constexpr 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 };
561 static_assert(selfref[0][0][0] == 1, "");
562 static_assert(selfref[0][0][1] == 2, "");
563 static_assert(selfref[0][1][0] == 1, "");
564 static_assert(selfref[0][1][1] == 2, "");
565 static_assert(selfref[1][0][0] == 1, "");
566 static_assert(selfref[1][0][1] == 3, "");
567 static_assert(selfref[1][1][0] == 0, "");
568 static_assert(selfref[1][1][1] == 0, "");
569 
570 struct TrivialDefCtor { int n; };
571 typedef TrivialDefCtor TDCArray[2][2];
572 static_assert(TDCArray{}[1][1].n == 0, "");
573 
574 struct NonAggregateTDC : TrivialDefCtor {};
575 typedef NonAggregateTDC NATDCArray[2][2];
576 static_assert(NATDCArray{}[1][1].n == 0, "");
577 
578 }
579 
580 namespace DependentValues {
581 
582 struct I { int n; typedef I V[10]; };
583 I::V x, y;
584 int g();
585 template<bool B, typename T> struct S : T {
586   int k;
fDependentValues::S587   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 
601 namespace Class {
602 
AClass::A603 struct A { constexpr A(int a, int b) : k(a + b) {} int k; };
fn(const A & a)604 constexpr int fn(const A &a) { return a.k; }
605 static_assert(fn(A(4,5)) == 9, "");
606 
607 struct B { int n; int m; } constexpr b = { 0, b.n };
608 struct C {
CClass::C609   constexpr C(C *this_) : m(42), n(this_->m) {} // ok
610   int m, n;
611 };
612 struct D {
613   C c;
DClass::D614   constexpr D() : c(&c) {}
615 };
616 static_assert(D().c.n == 42, "");
617 
618 struct E {
EClass::E619   constexpr E() : p(&p) {}
620   void *p;
621 };
622 constexpr 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.
625 constexpr E e2 = E();
626 static_assert(e2.p == &e2.p, "");
627 constexpr E e3;
628 static_assert(e3.p == &e3.p, "");
629 
630 extern const class F f;
631 struct F {
FClass::F632   constexpr F() : p(&f.p) {}
633   const void *p;
634 };
635 constexpr F f;
636 
637 struct G {
638   struct T {
TClass::G::T639     constexpr T(T *p) : u1(), u2(p) {}
640     union U1 {
U1()641       constexpr U1() {}
642       int a, b = 42;
643     } u1;
644     union U2 {
U2(T * p)645       constexpr U2(T *p) : c(p->u1.b) {}
646       int c, d;
647     } u2;
648   } t;
GClass::G649   constexpr G() : t(&t) {}
650 } constexpr g;
651 
652 static_assert(g.t.u1.a == 42, ""); // expected-error {{constant expression}} expected-note {{read of member 'a' of union with active member 'b'}}
653 static_assert(g.t.u1.b == 42, "");
654 static_assert(g.t.u2.c == 42, "");
655 static_assert(g.t.u2.d == 42, ""); // expected-error {{constant expression}} expected-note {{read of member 'd' of union with active member 'c'}}
656 
657 struct S {
658   int a, b;
659   const S *p;
660   double d;
661   const char *q;
662 
SClass::S663   constexpr S(int n, const S *p) : a(5), b(n), p(p), d(n), q("hello") {}
664 };
665 
666 S global(43, &global);
667 
668 static_assert(S(15, &global).b == 15, "");
669 
CheckS(const S & s)670 constexpr bool CheckS(const S &s) {
671   return s.a == 5 && s.b == 27 && s.p == &global && s.d == 27. && s.q[3] == 'l';
672 }
673 static_assert(CheckS(S(27, &global)), "");
674 
675 struct Arr {
676   char arr[3];
ArrClass::Arr677   constexpr Arr() : arr{'x', 'y', 'z'} {}
678 };
hash(Arr && a)679 constexpr int hash(Arr &&a) {
680   return a.arr[0] + a.arr[1] * 0x100 + a.arr[2] * 0x10000;
681 }
682 constexpr int k = hash(Arr());
683 static_assert(k == 0x007a7978, "");
684 
685 
686 struct AggregateInit {
687   const char &c;
688   int n;
689   double d;
690   int arr[5];
691   void *p;
692 };
693 
694 constexpr AggregateInit agg1 = { "hello"[0] };
695 
696 static_assert(strcmp_ce(&agg1.c, "hello") == 0, "");
697 static_assert(agg1.n == 0, "");
698 static_assert(agg1.d == 0.0, "");
699 static_assert(agg1.arr[-1] == 0, ""); // expected-error {{constant expression}} expected-note {{cannot refer to element -1}}
700 static_assert(agg1.arr[0] == 0, "");
701 static_assert(agg1.arr[4] == 0, "");
702 static_assert(agg1.arr[5] == 0, ""); // expected-error {{constant expression}} expected-note {{read of dereferenced one-past-the-end}}
703 static_assert(agg1.p == nullptr, "");
704 
705 static constexpr const unsigned char uc[] = { "foo" };
706 static_assert(uc[0] == 'f', "");
707 static_assert(uc[3] == 0, "");
708 
709 namespace SimpleDerivedClass {
710 
711 struct B {
BClass::SimpleDerivedClass::B712   constexpr B(int n) : a(n) {}
713   int a;
714 };
715 struct D : B {
DClass::SimpleDerivedClass::D716   constexpr D(int n) : B(n) {}
717 };
718 constexpr D d(3);
719 static_assert(d.a == 3, "");
720 
721 }
722 
BottomClass::Bottom723 struct Bottom { constexpr Bottom() {} };
724 struct Base : Bottom {
BaseClass::Base725   constexpr Base(int a = 42, const char *b = "test") : a(a), b(b) {}
726   int a;
727   const char *b;
728 };
729 struct Base2 : Bottom {
Base2Class::Base2730   constexpr Base2(const int &r) : r(r) {}
731   int q = 123;
732   const int &r;
733 };
734 struct Derived : Base, Base2 {
DerivedClass::Derived735   constexpr Derived() : Base(76), Base2(a) {}
736   int c = r + b[1];
737 };
738 
operator ==(const Base & a,const Base & b)739 constexpr bool operator==(const Base &a, const Base &b) {
740   return a.a == b.a && strcmp_ce(a.b, b.b) == 0;
741 }
742 
743 constexpr Base base;
744 constexpr Base base2(76);
745 constexpr Derived derived;
746 static_assert(derived.a == 76, "");
747 static_assert(derived.b[2] == 's', "");
748 static_assert(derived.c == 76 + 'e', "");
749 static_assert(derived.q == 123, "");
750 static_assert(derived.r == 76, "");
751 static_assert(&derived.r == &derived.a, "");
752 
753 static_assert(!(derived == base), "");
754 static_assert(derived == base2, "");
755 
756 constexpr Bottom &bot1 = (Base&)derived;
757 constexpr Bottom &bot2 = (Base2&)derived;
758 static_assert(&bot1 != &bot2, "");
759 
760 constexpr Bottom *pb1 = (Base*)&derived;
761 constexpr Bottom *pb2 = (Base2*)&derived;
762 static_assert(&pb1 != &pb2, "");
763 static_assert(pb1 == &bot1, "");
764 static_assert(pb2 == &bot2, "");
765 
766 constexpr Base2 &fail = (Base2&)bot1; // expected-error {{constant expression}} expected-note {{cannot cast object of dynamic type 'const Class::Derived' to type 'Class::Base2'}}
767 constexpr Base &fail2 = (Base&)*pb2; // expected-error {{constant expression}} expected-note {{cannot cast object of dynamic type 'const Class::Derived' to type 'Class::Base'}}
768 constexpr Base2 &ok2 = (Base2&)bot2;
769 static_assert(&ok2 == &derived, "");
770 
771 constexpr Base2 *pfail = (Base2*)pb1; // expected-error {{constant expression}} expected-note {{cannot cast object of dynamic type 'const Class::Derived' to type 'Class::Base2'}}
772 constexpr Base *pfail2 = (Base*)&bot2; // expected-error {{constant expression}} expected-note {{cannot cast object of dynamic type 'const Class::Derived' to type 'Class::Base'}}
773 constexpr Base2 *pok2 = (Base2*)pb2;
774 static_assert(pok2 == &derived, "");
775 static_assert(&ok2 == pok2, "");
776 static_assert((Base2*)(Derived*)(Base*)pb1 == pok2, "");
777 static_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.
781 constexpr Base *nullB = 42 - 6 * 7; // expected-error {{cannot initialize a variable of type 'Class::Base *const' with an rvalue of type 'int'}}
782 constexpr Base *nullB1 = 0;
783 static_assert((Bottom*)nullB == 0, "");
784 static_assert((Derived*)nullB == 0, "");
785 static_assert((void*)(Bottom*)nullB == (void*)(Derived*)nullB, "");
786 Base *nullB2 = '\0'; // expected-error {{cannot initialize a variable of type 'Class::Base *' with an rvalue of type 'char'}}
787 Base *nullB3 = (0);
788 Base *nullB4 = false; // expected-error {{cannot initialize a variable of type 'Class::Base *' with an rvalue of type 'bool'}}
789 Base *nullB5 = ((0ULL));
790 Base *nullB6 = 0.; // expected-error {{cannot initialize a variable of type 'Class::Base *' with an rvalue of type 'double'}}
791 enum Null { kNull };
792 Base *nullB7 = kNull; // expected-error {{cannot initialize a variable of type 'Class::Base *' with an rvalue of type 'Class::Null'}}
793 static_assert(nullB1 == (1 - 1), ""); // expected-error {{comparison between pointer and integer}}
794 
795 
796 
797 namespace ConversionOperators {
798 
799 struct T {
TClass::ConversionOperators::T800   constexpr T(int n) : k(5*n - 3) {}
operator intClass::ConversionOperators::T801   constexpr operator int() const { return k; }
802   int k;
803 };
804 
805 struct S {
SClass::ConversionOperators::S806   constexpr S(int n) : k(2*n + 1) {}
operator intClass::ConversionOperators::S807   constexpr operator int() const { return k; }
operator TClass::ConversionOperators::S808   constexpr operator T() const { return T(k); }
809   int k;
810 };
811 
check(T a,T b)812 constexpr bool check(T a, T b) { return a == b.k; }
813 
814 static_assert(S(5) == 11, "");
815 static_assert(check(S(5), 11), "");
816 
817 namespace PR14171 {
818 
819 struct X {
820   constexpr (operator int)() const { return 0; }
821 };
822 static_assert(X() == 0, "");
823 
824 }
825 
826 }
827 
828 struct This {
fClass::This829   constexpr int f() const { return 0; }
gClass::This830   static constexpr int g() { return 0; }
hClass::This831   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 
843 namespace Temporaries {
844 
845 struct S {
STemporaries::S846   constexpr S() {}
847   constexpr int f() const;
848   constexpr int g() const;
849 };
850 struct T : S {
TTemporaries::T851   constexpr T(int n) : S(), n(n) {}
852   int n;
853 };
f() const854 constexpr int S::f() const {
855   return static_cast<const T*>(this)->n; // expected-note {{cannot cast}}
856 }
g() const857 constexpr 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.
864 static_assert(S().f(), ""); // expected-error {{constant expression}} expected-note {{in call to '&Temporaries::S()->f()'}}
865 static_assert(S().g(), ""); // expected-error {{constant expression}} expected-note {{in call to '&Temporaries::S()->g()'}}
866 static_assert(T(3).f() == 3, "");
867 static_assert(T(4).g() == 4, "");
868 
f(const S & s)869 constexpr int f(const S &s) {
870   return static_cast<const T&>(s).n;
871 }
872 constexpr int n = f(T(5));
873 static_assert(f(T(5)) == 5, "");
874 
b(int n)875 constexpr bool b(int n) { return &n; }
876 static_assert(b(0), "");
877 
878 struct NonLiteral {
879   NonLiteral();
880   int f();
881 };
882 constexpr int k = NonLiteral().f(); // expected-error {{constant expression}} expected-note {{non-literal type 'Temporaries::NonLiteral'}}
883 
884 }
885 
886 namespace Union {
887 
888 union U {
889   int a;
890   int b;
891 };
892 
893 constexpr U u[4] = { { .a = 0 }, { .b = 1 }, { .a = 2 }, { .b = 3 } }; // expected-warning 4{{C99 feature}}
894 static_assert(u[0].a == 0, "");
895 static_assert(u[0].b, ""); // expected-error {{constant expression}} expected-note {{read of member 'b' of union with active member 'a'}}
896 static_assert(u[1].b == 1, "");
897 static_assert((&u[1].b)[1] == 2, ""); // expected-error {{constant expression}} expected-note {{read of dereferenced one-past-the-end pointer}}
898 static_assert(*(&(u[1].b) + 1 + 1) == 3, ""); // expected-error {{constant expression}} expected-note {{cannot refer to element 2 of non-array object}}
899 static_assert((&(u[1]) + 1 + 1)->b == 3, "");
900 
901 constexpr U v = {};
902 static_assert(v.a == 0, "");
903 
904 union Empty {};
905 constexpr Empty e = {};
906 
907 // Make sure we handle trivial copy constructors for unions.
908 constexpr U x = {42};
909 constexpr U y = x;
910 static_assert(y.a == 42, "");
911 static_assert(y.b == 42, ""); // expected-error {{constant expression}} expected-note {{'b' of union with active member 'a'}}
912 
913 }
914 
915 namespace MemberPointer {
916   struct A {
AMemberPointer::A917     constexpr A(int n) : n(n) {}
918     int n;
fMemberPointer::A919     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 {
BMemberPointer::B928     constexpr B(int n, int m) : A(n), m(m) {}
929     int m;
gMemberPointer::B930     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 {
SMemberPointer::S947     constexpr S(int m, int n, int (S::*pf)() const, int S::*pn) :
948       m(m), n(n), pf(pf), pn(pn) {}
SMemberPointer::S949     constexpr S() : m(), n(), pf(&S::f), pn(&S::n) {}
950 
fMemberPointer::S951     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 
1024 namespace ArrayBaseDerived {
1025 
1026   struct Base {
BaseArrayBaseDerived::Base1027     constexpr Base() {}
1028     int n = 0;
1029   };
1030   struct Derived : Base {
DerivedArrayBaseDerived::Derived1031     constexpr Derived() {}
fArrayBaseDerived::Derived1032     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 
1070 namespace Complex {
1071 
1072 class complex {
1073   int re, im;
1074 public:
complex(int re=0,int im=0)1075   constexpr complex(int re = 0, int im = 0) : re(re), im(im) {}
complex(const complex & o)1076   constexpr complex(const complex &o) : re(o.re), im(o.im) {}
operator -() const1077   constexpr complex operator-() const { return complex(-re, -im); }
operator +(const complex & l,const complex & r)1078   friend constexpr complex operator+(const complex &l, const complex &r) {
1079     return complex(l.re + r.re, l.im + r.im);
1080   }
operator -(const complex & l,const complex & r)1081   friend constexpr complex operator-(const complex &l, const complex &r) {
1082     return l + -r;
1083   }
operator *(const complex & l,const complex & r)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   }
operator ==(const complex & l,const complex & r)1087   friend constexpr bool operator==(const complex &l, const complex &r) {
1088     return l.re == r.re && l.im == r.im;
1089   }
operator !=(const complex & r) const1090   constexpr bool operator!=(const complex &r) const {
1091     return re != r.re || im != r.im;
1092   }
real() const1093   constexpr int real() const { return re; }
imag() const1094   constexpr int imag() const { return im; }
1095 };
1096 
1097 constexpr complex i = complex(0, 1);
1098 constexpr complex k = (3 + 4*i) * (6 - 4*i);
1099 static_assert(complex(1,0).real() == 1, "");
1100 static_assert(complex(1,0).imag() == 0, "");
1101 static_assert(((complex)1).imag() == 0, "");
1102 static_assert(k.real() == 34, "");
1103 static_assert(k.imag() == 12, "");
1104 static_assert(k - 34 == 12*i, "");
1105 static_assert((complex)1 == complex(1), "");
1106 static_assert((complex)1 != complex(0, 1), "");
1107 static_assert(complex(1) == complex(1), "");
1108 static_assert(complex(1) != complex(0, 1), "");
makeComplex(int re,int im)1109 constexpr complex makeComplex(int re, int im) { return complex(re, im); }
1110 static_assert(makeComplex(1,0) == complex(1), "");
1111 static_assert(makeComplex(1,0) != complex(0, 1), "");
1112 
1113 class complex_wrap : public complex {
1114 public:
complex_wrap(int re,int im=0)1115   constexpr complex_wrap(int re, int im = 0) : complex(re, im) {}
complex_wrap(const complex_wrap & o)1116   constexpr complex_wrap(const complex_wrap &o) : complex(o) {}
1117 };
1118 
1119 static_assert((complex_wrap)1 == complex(1), "");
1120 static_assert((complex)1 != complex_wrap(0, 1), "");
1121 static_assert(complex(1) == complex_wrap(1), "");
1122 static_assert(complex_wrap(1) != complex(0, 1), "");
makeComplexWrap(int re,int im)1123 constexpr complex_wrap makeComplexWrap(int re, int im) {
1124   return complex_wrap(re, im);
1125 }
1126 static_assert(makeComplexWrap(1,0) == complex(1), "");
1127 static_assert(makeComplexWrap(1,0) != complex(0, 1), "");
1128 
1129 }
1130 
1131 namespace PR11595 {
operator ==PR11595::A1132   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 
f(int k)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 
1141 namespace ExprWithCleanups {
1142   struct A { A(); ~A(); int get(); };
get(bool FromA)1143   constexpr int get(bool FromA) { return FromA ? A().get() : 1; }
1144   constexpr int n = get(false);
1145 }
1146 
1147 namespace Volatile {
1148 
1149 volatile constexpr int n1 = 0; // expected-note {{here}}
1150 volatile const int n2 = 0; // expected-note {{here}}
1151 int n3 = 37; // expected-note {{declared here}}
1152 
1153 constexpr int m1 = n1; // expected-error {{constant expression}} expected-note {{read of volatile-qualified type 'const volatile int'}}
1154 constexpr int m2 = n2; // expected-error {{constant expression}} expected-note {{read of volatile-qualified type 'const volatile int'}}
1155 constexpr int m1b = const_cast<const int&>(n1); // expected-error {{constant expression}} expected-note {{read of volatile object 'n1'}}
1156 constexpr int m2b = const_cast<const int&>(n2); // expected-error {{constant expression}} expected-note {{read of volatile object 'n2'}}
1157 
1158 struct T { int n; };
1159 const T t = { 42 }; // expected-note {{declared here}}
1160 
f(volatile int && r)1161 constexpr int f(volatile int &&r) {
1162   return r; // expected-note {{read of volatile-qualified type 'volatile int'}}
1163 }
g(volatile int && r)1164 constexpr 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 }
1167 struct 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 
1176 namespace ExternConstexpr {
1177   extern constexpr int n = 0;
1178   extern constexpr int m; // expected-error {{constexpr variable declaration must be a definition}}
f()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;
g()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}}
h()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;
x()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 
1200 namespace 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..
1235 namespace 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;
TestVarAtomic::PR16056::TestVar1251       constexpr TestVar(int value) : value(value) {}
1252     };
1253     constexpr TestVar testVar{-1};
1254     static_assert(testVar.value == -1, "");
1255   }
1256 }
1257 
1258 namespace InstantiateCaseStmt {
f()1259   template<int x> constexpr int f() { return x; }
g(int c)1260   template<int x> int g(int c) { switch(c) { case f<x>(): return 1; } return 0; }
gg(int c)1261   int gg(int c) { return g<4>(c); }
1262 }
1263 
1264 namespace 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 
1283 namespace 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     };
SIndirectField::S1299     constexpr S(int a, int b, int d, int e) : a(a), b(b), d(d), e(e) {}
SIndirectField::S1300     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.
1324 namespace 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; };
f()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 
1390 namespace 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 
1404 namespace DR1454 {
1405 
f(const int & n)1406 constexpr const int &f(const int &n) { return n; }
1407 constexpr int k1 = f(0); // ok
1408 
1409 struct Wrap {
1410   const int &value;
1411 };
g(const Wrap & w)1412 constexpr const Wrap &g(const Wrap &w) { return w; }
1413 constexpr 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.
1417 constexpr const int &i = 1;
1418 constexpr const int j = i;
1419 static_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).
1424 constexpr int &&k = 1; // expected-note {{temporary created here}}
1425 constexpr const int l = k; // expected-error {{constant expression}} expected-note {{read of temporary}}
1426 
f()1427 void 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 
1435 namespace RecursiveOpaqueExpr {
1436   template<typename Iter>
LastNonzero(Iter p,Iter q)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 
1459 namespace VLASizeof {
1460 
f(int k)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 
1469 namespace 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 
1479 namespace Vector {
1480   typedef int __attribute__((vector_size(16))) VI4;
f(int n)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;
g(int n)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
1494 namespace InvalidClasses {
test0()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 
1503 namespace NamespaceAlias {
f()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.
1511 namespace 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.
1537 namespace PR12826 {
1538   struct Foo {};
id(Foo x)1539   constexpr Foo id(Foo x) { return x; }
1540   constexpr Foo res(id(Foo()));
1541 }
1542 
1543 namespace 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 
1559 namespace PR12670 {
1560   struct S {
SPR12670::S1561     constexpr S(int a0) : m(a0) {}
SPR12670::S1562     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.
1574 namespace ConditionalLValToRVal {
1575   struct A {
AConditionalLValToRVal::A1576     constexpr A(int a) : v(a) {}
1577     int v;
1578   };
1579 
f(const A & a)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 
1588 namespace 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 
f()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 
g()1600   constexpr int *g() { return &m; }
1601   constexpr int *r = g();
1602 }
1603 
1604 namespace Void {
f()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>
get(T (& a)[S],size_t k)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 
1622 namespace std { struct type_info; }
1623 
1624 namespace 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 
1634 namespace PR14203 {
1635   struct duration {
durationPR14203::duration1636     constexpr duration() {}
operator intPR14203::duration1637     constexpr operator int() const { return 0; }
1638   };
f()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 
1655 namespace ArrayEltInit {
1656   struct A {
AArrayEltInit::A1657     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 
1673 namespace PR15884 {
1674   struct S {};
f()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 
1683 namespace AfterError {
1684   // FIXME: Suppress the 'no return statements' diagnostic if the body is invalid.
error()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 
1691 namespace 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 
initializer_list(const _E * __b,size_t __s)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 
initializer_list()1714     constexpr initializer_list() : __begin_(nullptr), __size_(0) {}
1715 
size() const1716     constexpr size_t    size()  const {return __size_;}
begin() const1717     constexpr const _E* begin() const {return __begin_;}
end() const1718     constexpr const _E* end()   const {return __begin_ + __size_;}
1719   };
1720 }
1721 
1722 namespace InitializerList {
sum(const int * b,const int * e)1723   constexpr int sum(const int *b, const int *e) {
1724     return b != e ? *b + sum(b+1, e) : 0;
1725   }
sum(std::initializer_list<int> ints)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 
1735 namespace StmtExpr {
1736   struct A { int k; };
f()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   }
g(int k)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, "");
h()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 
1756 namespace 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 {
XVirtualFromBase::X1764     constexpr X() {}
1765     double d = 0.0;
fVirtualFromBase::X1766     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 
1780 namespace ConstexprConstructorRecovery {
1781   class X {
1782   public:
1783       enum E : short {
1784           headers = 0x1,
1785           middlefile = 0x2,
1786           choices = 0x4
1787       };
X()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 
1795 namespace Lifetime {
f()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 
get(int && n)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;
SLifetime::S1806     constexpr S() : r(0), s(get(0)), t(r) {} // expected-warning {{temporary}}
SLifetime::S1807     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 
1813 namespace 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;
BBitfields::B1830     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;
fBitfields::PR16755::X1842       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 
1850 namespace 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];
f()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 
1862 namespace 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}}
BBadDefaultInit::B1874     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 
1881 namespace 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.
f(int n)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 
1897 namespace PR17800 {
1898   struct A {
operator ()PR17800::A1899     constexpr int operator()() const { return 0; }
1900   };
sink(T...)1901   template <typename ...T> constexpr int sink(T ...) {
1902     return 0;
1903   }
run()1904   template <int ...N> constexpr int run() {
1905     return sink(A()() + N ...);
1906   }
1907   constexpr int k = run<1, 2, 3>();
1908 }
1909 
1910 namespace BuiltinStrlen {
1911   constexpr const char *a = "foo\0quux";
1912   constexpr char b[] = "foo\0quux";
f()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 
check(const char * p)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 
1949 namespace PR19010 {
1950   struct Empty {};
1951   struct Empty2 : Empty {};
1952   struct Test : Empty2 {
TestPR19010::Test1953     constexpr Test() {}
1954     Empty2 array[2];
1955   };
test()1956   void test() { constexpr Test t; }
1957 }
1958 
PR21327(int a,int b)1959 void PR21327(int a, int b) {
1960   static_assert(&a + 1 != &b, ""); // expected-error {{constant expression}}
1961 }
1962 
1963 namespace 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 
1976 namespace 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 
1991 namespace PR21859 {
Fun()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 
1996 struct 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 
2001 namespace PR17938 {
f(T const & x)2002   template <typename T> constexpr T const &f(T const &x) { return x; }
2003 
2004   struct X {};
2005   struct Y : X {};
ZPR17938::Z2006   struct Z : Y { constexpr Z() {} };
2007 
2008   static constexpr auto z = f(Z());
2009 }
2010 
2011 namespace PR24597 {
2012   struct A {
2013     int x, *p;
APR24597::A2014     constexpr A() : x(0), p(&x) {}
APR24597::A2015     constexpr A(const A &a) : x(a.x), p(&x) {}
2016   };
f()2017   constexpr A f() { return A(); }
g()2018   constexpr A g() { return f(); }
2019   constexpr int a = *f().p;
2020   constexpr int b = *g().p;
2021 }
2022 
2023 namespace IncompleteClass {
2024   struct XX {
fIncompleteClass::XX2025     static constexpr int f(XX*) { return 1; } // expected-note {{here}}
g(XX *)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 
2033 namespace InheritedCtor {
AInheritedCtor::A2034   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.
f()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 
WInheritedCtor::W2062   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