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