constant-expression-cxx11.cpp revision e92b1f4917bfb669a09d220dc979fc3676df4da8
1// RUN: %clang_cc1 -triple i686-linux -Wno-string-plus-int -fsyntax-only -verify -std=c++11 -pedantic %s -Wno-comment 2 3namespace StaticAssertFoldTest { 4 5int x; 6static_assert(++x, "test"); // expected-error {{not an integral constant expression}} 7static_assert(false, "test"); // expected-error {{test}} 8 9} 10 11typedef decltype(sizeof(char)) size_t; 12 13template<typename T> constexpr T id(const T &t) { return t; } 14template<typename T> constexpr T min(const T &a, const T &b) { 15 return a < b ? a : b; 16} 17template<typename T> constexpr T max(const T &a, const T &b) { 18 return a < b ? b : a; 19} 20template<typename T, size_t N> constexpr T *begin(T (&xs)[N]) { return xs; } 21template<typename T, size_t N> constexpr T *end(T (&xs)[N]) { return xs + N; } 22 23struct MemberZero { 24 constexpr int zero() { return 0; } 25}; 26 27namespace DerivedToVBaseCast { 28 29 struct U { int n; }; 30 struct V : U { int n; }; 31 struct A : virtual V { int n; }; 32 struct Aa { int n; }; 33 struct B : virtual A, Aa {}; 34 struct C : virtual A, Aa {}; 35 struct D : B, C {}; 36 37 D d; 38 constexpr B *p = &d; 39 constexpr C *q = &d; 40 41 static_assert((void*)p != (void*)q, ""); 42 static_assert((A*)p == (A*)q, ""); 43 static_assert((Aa*)p != (Aa*)q, ""); 44 45 constexpr B &pp = d; 46 constexpr C &qq = d; 47 static_assert((void*)&pp != (void*)&qq, ""); 48 static_assert(&(A&)pp == &(A&)qq, ""); 49 static_assert(&(Aa&)pp != &(Aa&)qq, ""); 50 51 constexpr V *v = p; 52 constexpr V *w = q; 53 constexpr V *x = (A*)p; 54 static_assert(v == w, ""); 55 static_assert(v == x, ""); 56 57 static_assert((U*)&d == p, ""); 58 static_assert((U*)&d == q, ""); 59 static_assert((U*)&d == v, ""); 60 static_assert((U*)&d == w, ""); 61 static_assert((U*)&d == x, ""); 62 63 struct X {}; 64 struct Y1 : virtual X {}; 65 struct Y2 : X {}; 66 struct Z : Y1, Y2 {}; 67 Z z; 68 static_assert((X*)(Y1*)&z != (X*)(Y2*)&z, ""); 69} 70 71namespace ConstCast { 72 73constexpr int n1 = 0; 74constexpr int n2 = const_cast<int&>(n1); 75constexpr int *n3 = const_cast<int*>(&n1); 76constexpr int n4 = *const_cast<int*>(&n1); 77constexpr const int * const *n5 = const_cast<const int* const*>(&n3); 78constexpr int **n6 = const_cast<int**>(&n3); 79constexpr int n7 = **n5; 80constexpr int n8 = **n6; 81 82} 83 84namespace TemplateArgumentConversion { 85 template<int n> struct IntParam {}; 86 87 using IntParam0 = IntParam<0>; 88 using IntParam0 = IntParam<id(0)>; 89 using IntParam0 = IntParam<MemberZero().zero>; // expected-error {{did you mean to call it with no arguments?}} 90} 91 92namespace CaseStatements { 93 void f(int n) { 94 switch (n) { 95 case MemberZero().zero: // expected-error {{did you mean to call it with no arguments?}} expected-note {{previous}} 96 case id(0): // expected-error {{duplicate case value '0'}} 97 return; 98 } 99 } 100} 101 102extern int &Recurse1; 103int &Recurse2 = Recurse1; // expected-note {{declared here}} 104int &Recurse1 = Recurse2; 105constexpr int &Recurse3 = Recurse2; // expected-error {{must be initialized by a constant expression}} expected-note {{initializer of 'Recurse2' is not a constant expression}} 106 107extern const int RecurseA; 108const int RecurseB = RecurseA; // expected-note {{declared here}} 109const int RecurseA = 10; 110constexpr int RecurseC = RecurseB; // expected-error {{must be initialized by a constant expression}} expected-note {{initializer of 'RecurseB' is not a constant expression}} 111 112namespace MemberEnum { 113 struct WithMemberEnum { 114 enum E { A = 42 }; 115 } wme; 116 117 static_assert(wme.A == 42, ""); 118} 119 120namespace DefaultArguments { 121 122const int z = int(); 123constexpr int Sum(int a = 0, const int &b = 0, const int *c = &z, char d = 0) { 124 return a + b + *c + d; 125} 126const int four = 4; 127constexpr int eight = 8; 128constexpr const int twentyseven = 27; 129static_assert(Sum() == 0, ""); 130static_assert(Sum(1) == 1, ""); 131static_assert(Sum(1, four) == 5, ""); 132static_assert(Sum(1, eight, &twentyseven) == 36, ""); 133static_assert(Sum(1, 2, &four, eight) == 15, ""); 134 135} 136 137namespace Ellipsis { 138 139// Note, values passed through an ellipsis can't actually be used. 140constexpr int F(int a, ...) { return a; } 141static_assert(F(0) == 0, ""); 142static_assert(F(1, 0) == 1, ""); 143static_assert(F(2, "test") == 2, ""); 144static_assert(F(3, &F) == 3, ""); 145int k = 0; // expected-note {{here}} 146static_assert(F(4, k) == 3, ""); // expected-error {{constant expression}} expected-note {{read of non-const variable 'k'}} 147 148} 149 150namespace Recursion { 151 constexpr int fib(int n) { return n > 1 ? fib(n-1) + fib(n-2) : n; } 152 static_assert(fib(11) == 89, ""); 153 154 constexpr int gcd_inner(int a, int b) { 155 return b == 0 ? a : gcd_inner(b, a % b); 156 } 157 constexpr int gcd(int a, int b) { 158 return gcd_inner(max(a, b), min(a, b)); 159 } 160 161 static_assert(gcd(1749237, 5628959) == 7, ""); 162} 163 164namespace FunctionCast { 165 // When folding, we allow functions to be cast to different types. Such 166 // cast functions cannot be called, even if they're constexpr. 167 constexpr int f() { return 1; } 168 typedef double (*DoubleFn)(); 169 typedef int (*IntFn)(); 170 int a[(int)DoubleFn(f)()]; // expected-error {{variable length array}} expected-warning{{C99 feature}} 171 int b[(int)IntFn(f)()]; // ok 172} 173 174namespace StaticMemberFunction { 175 struct S { 176 static constexpr int k = 42; 177 static constexpr int f(int n) { return n * k + 2; } 178 } s; 179 180 constexpr int n = s.f(19); 181 static_assert(S::f(19) == 800, ""); 182 static_assert(s.f(19) == 800, ""); 183 static_assert(n == 800, ""); 184 185 constexpr int (*sf1)(int) = &S::f; 186 constexpr int (*sf2)(int) = &s.f; 187 constexpr const int *sk = &s.k; 188} 189 190namespace ParameterScopes { 191 192 const int k = 42; 193 constexpr const int &ObscureTheTruth(const int &a) { return a; } 194 constexpr const int &MaybeReturnJunk(bool b, const int a) { // expected-note 2{{declared here}} 195 return ObscureTheTruth(b ? a : k); 196 } 197 static_assert(MaybeReturnJunk(false, 0) == 42, ""); // ok 198 constexpr int a = MaybeReturnJunk(true, 0); // expected-error {{constant expression}} expected-note {{read of variable whose lifetime has ended}} 199 200 constexpr const int MaybeReturnNonstaticRef(bool b, const int a) { 201 return ObscureTheTruth(b ? a : k); 202 } 203 static_assert(MaybeReturnNonstaticRef(false, 0) == 42, ""); // ok 204 constexpr int b = MaybeReturnNonstaticRef(true, 0); // ok 205 206 constexpr int InternalReturnJunk(int n) { 207 return MaybeReturnJunk(true, n); // expected-note {{read of variable whose lifetime has ended}} 208 } 209 constexpr int n3 = InternalReturnJunk(0); // expected-error {{must be initialized by a constant expression}} expected-note {{in call to 'InternalReturnJunk(0)'}} 210 211 constexpr int LToR(int &n) { return n; } 212 constexpr int GrabCallersArgument(bool which, int a, int b) { 213 return LToR(which ? b : a); 214 } 215 static_assert(GrabCallersArgument(false, 1, 2) == 1, ""); 216 static_assert(GrabCallersArgument(true, 4, 8) == 8, ""); 217 218} 219 220namespace Pointers { 221 222 constexpr int f(int n, const int *a, const int *b, const int *c) { 223 return n == 0 ? 0 : *a + f(n-1, b, c, a); 224 } 225 226 const int x = 1, y = 10, z = 100; 227 static_assert(f(23, &x, &y, &z) == 788, ""); 228 229 constexpr int g(int n, int a, int b, int c) { 230 return f(n, &a, &b, &c); 231 } 232 static_assert(g(23, x, y, z) == 788, ""); 233 234} 235 236namespace FunctionPointers { 237 238 constexpr int Double(int n) { return 2 * n; } 239 constexpr int Triple(int n) { return 3 * n; } 240 constexpr int Twice(int (*F)(int), int n) { return F(F(n)); } 241 constexpr int Quadruple(int n) { return Twice(Double, n); } 242 constexpr auto Select(int n) -> int (*)(int) { 243 return n == 2 ? &Double : n == 3 ? &Triple : n == 4 ? &Quadruple : 0; 244 } 245 constexpr int Apply(int (*F)(int), int n) { return F(n); } // expected-note {{subexpression}} 246 247 static_assert(1 + Apply(Select(4), 5) + Apply(Select(3), 7) == 42, ""); 248 249 constexpr int Invalid = Apply(Select(0), 0); // expected-error {{must be initialized by a constant expression}} expected-note {{in call to 'Apply(0, 0)'}} 250 251} 252 253namespace PointerComparison { 254 255int x, y; 256static_assert(&x == &y, "false"); // expected-error {{false}} 257static_assert(&x != &y, ""); 258constexpr bool g1 = &x == &y; 259constexpr bool g2 = &x != &y; 260constexpr bool g3 = &x <= &y; // expected-error {{must be initialized by a constant expression}} 261constexpr bool g4 = &x >= &y; // expected-error {{must be initialized by a constant expression}} 262constexpr bool g5 = &x < &y; // expected-error {{must be initialized by a constant expression}} 263constexpr bool g6 = &x > &y; // expected-error {{must be initialized by a constant expression}} 264 265struct S { int x, y; } s; 266static_assert(&s.x == &s.y, "false"); // expected-error {{false}} 267static_assert(&s.x != &s.y, ""); 268static_assert(&s.x <= &s.y, ""); 269static_assert(&s.x >= &s.y, "false"); // expected-error {{false}} 270static_assert(&s.x < &s.y, ""); 271static_assert(&s.x > &s.y, "false"); // expected-error {{false}} 272 273static_assert(0 == &y, "false"); // expected-error {{false}} 274static_assert(0 != &y, ""); 275constexpr bool n3 = 0 <= &y; // expected-error {{must be initialized by a constant expression}} 276constexpr bool n4 = 0 >= &y; // expected-error {{must be initialized by a constant expression}} 277constexpr bool n5 = 0 < &y; // expected-error {{must be initialized by a constant expression}} 278constexpr bool n6 = 0 > &y; // expected-error {{must be initialized by a constant expression}} 279 280static_assert(&x == 0, "false"); // expected-error {{false}} 281static_assert(&x != 0, ""); 282constexpr bool n9 = &x <= 0; // expected-error {{must be initialized by a constant expression}} 283constexpr bool n10 = &x >= 0; // expected-error {{must be initialized by a constant expression}} 284constexpr bool n11 = &x < 0; // expected-error {{must be initialized by a constant expression}} 285constexpr bool n12 = &x > 0; // expected-error {{must be initialized by a constant expression}} 286 287static_assert(&x == &x, ""); 288static_assert(&x != &x, "false"); // expected-error {{false}} 289static_assert(&x <= &x, ""); 290static_assert(&x >= &x, ""); 291static_assert(&x < &x, "false"); // expected-error {{false}} 292static_assert(&x > &x, "false"); // expected-error {{false}} 293 294constexpr S* sptr = &s; 295constexpr bool dyncast = sptr == dynamic_cast<S*>(sptr); // expected-error {{constant expression}} expected-note {{dynamic_cast}} 296 297struct U {}; 298struct Str { 299 int a : dynamic_cast<S*>(sptr) == dynamic_cast<S*>(sptr); // \ 300 expected-warning {{not an integral constant expression}} \ 301 expected-note {{dynamic_cast is not allowed in a constant expression}} 302 int b : reinterpret_cast<S*>(sptr) == reinterpret_cast<S*>(sptr); // \ 303 expected-warning {{not an integral constant expression}} \ 304 expected-note {{reinterpret_cast is not allowed in a constant expression}} 305 int c : (S*)(long)(sptr) == (S*)(long)(sptr); // \ 306 expected-warning {{not an integral constant expression}} \ 307 expected-note {{cast which performs the conversions of a reinterpret_cast is not allowed in a constant expression}} 308 int d : (S*)(42) == (S*)(42); // \ 309 expected-warning {{not an integral constant expression}} \ 310 expected-note {{cast which performs the conversions of a reinterpret_cast is not allowed in a constant expression}} 311 int e : (Str*)(sptr) == (Str*)(sptr); // \ 312 expected-warning {{not an integral constant expression}} \ 313 expected-note {{cast which performs the conversions of a reinterpret_cast is not allowed in a constant expression}} 314 int f : &(U&)(*sptr) == &(U&)(*sptr); // \ 315 expected-warning {{not an integral constant expression}} \ 316 expected-note {{cast which performs the conversions of a reinterpret_cast is not allowed in a constant expression}} 317 int g : (S*)(void*)(sptr) == sptr; // \ 318 expected-warning {{not an integral constant expression}} \ 319 expected-note {{cast from 'void *' is not allowed in a constant expression}} 320}; 321 322extern char externalvar[]; 323constexpr bool constaddress = (void *)externalvar == (void *)0x4000UL; // expected-error {{must be initialized by a constant expression}} 324constexpr bool litaddress = "foo" == "foo"; // expected-error {{must be initialized by a constant expression}} expected-warning {{unspecified}} 325static_assert(0 != "foo", ""); 326 327} 328 329namespace MaterializeTemporary { 330 331constexpr int f(const int &r) { return r; } 332constexpr int n = f(1); 333 334constexpr bool same(const int &a, const int &b) { return &a == &b; } 335constexpr bool sameTemporary(const int &n) { return same(n, n); } 336 337static_assert(n, ""); 338static_assert(!same(4, 4), ""); 339static_assert(same(n, n), ""); 340static_assert(sameTemporary(9), ""); 341 342} 343 344constexpr int strcmp_ce(const char *p, const char *q) { 345 return (!*p || *p != *q) ? *p - *q : strcmp_ce(p+1, q+1); 346} 347 348namespace StringLiteral { 349 350template<typename Char> 351constexpr int MangleChars(const Char *p) { 352 return *p + 3 * (*p ? MangleChars(p+1) : 0); 353} 354 355static_assert(MangleChars("constexpr!") == 1768383, ""); 356static_assert(MangleChars(u8"constexpr!") == 1768383, ""); 357static_assert(MangleChars(L"constexpr!") == 1768383, ""); 358static_assert(MangleChars(u"constexpr!") == 1768383, ""); 359static_assert(MangleChars(U"constexpr!") == 1768383, ""); 360 361constexpr char c0 = "nought index"[0]; 362constexpr char c1 = "nice index"[10]; 363constexpr char c2 = "nasty index"[12]; // expected-error {{must be initialized by a constant expression}} expected-warning {{is past the end}} expected-note {{read of dereferenced one-past-the-end pointer}} 364constexpr char c3 = "negative index"[-1]; // expected-error {{must be initialized by a constant expression}} expected-warning {{is before the beginning}} expected-note {{cannot refer to element -1 of array of 15 elements}} 365constexpr char c4 = ((char*)(int*)"no reinterpret_casts allowed")[14]; // expected-error {{must be initialized by a constant expression}} expected-note {{cast which performs the conversions of a reinterpret_cast}} 366 367constexpr const char *p = "test" + 2; 368static_assert(*p == 's', ""); 369 370constexpr const char *max_iter(const char *a, const char *b) { 371 return *a < *b ? b : a; 372} 373constexpr const char *max_element(const char *a, const char *b) { 374 return (a+1 >= b) ? a : max_iter(a, max_element(a+1, b)); 375} 376 377constexpr char str[] = "the quick brown fox jumped over the lazy dog"; 378constexpr const char *max = max_element(begin(str), end(str)); 379static_assert(*max == 'z', ""); 380static_assert(max == str + 38, ""); 381 382static_assert(strcmp_ce("hello world", "hello world") == 0, ""); 383static_assert(strcmp_ce("hello world", "hello clang") > 0, ""); 384static_assert(strcmp_ce("constexpr", "test") < 0, ""); 385static_assert(strcmp_ce("", " ") < 0, ""); 386 387struct S { 388 int n : "foo"[4]; // expected-error {{constant expression}} expected-note {{read of dereferenced one-past-the-end pointer is not allowed in a constant expression}} 389}; 390 391struct T { 392 char c[6]; 393 constexpr T() : c{"foo"} {} 394}; 395constexpr T t; 396 397static_assert(t.c[0] == 'f', ""); 398static_assert(t.c[1] == 'o', ""); 399static_assert(t.c[2] == 'o', ""); 400static_assert(t.c[3] == 0, ""); 401static_assert(t.c[4] == 0, ""); 402static_assert(t.c[5] == 0, ""); 403static_assert(t.c[6] == 0, ""); // expected-error {{constant expression}} expected-note {{one-past-the-end}} 404 405struct U { 406 wchar_t chars[6]; 407 int n; 408} constexpr u = { { L"test" }, 0 }; 409static_assert(u.chars[2] == L's', ""); 410 411struct V { 412 char c[4]; 413 constexpr V() : c("hi!") {} 414}; 415static_assert(V().c[1] == "i"[0], ""); 416 417} 418 419namespace Array { 420 421template<typename Iter> 422constexpr auto Sum(Iter begin, Iter end) -> decltype(+*begin) { 423 return begin == end ? 0 : *begin + Sum(begin+1, end); 424} 425 426constexpr int xs[] = { 1, 2, 3, 4, 5 }; 427constexpr int ys[] = { 5, 4, 3, 2, 1 }; 428constexpr int sum_xs = Sum(begin(xs), end(xs)); 429static_assert(sum_xs == 15, ""); 430 431constexpr int ZipFoldR(int (*F)(int x, int y, int c), int n, 432 const int *xs, const int *ys, int c) { 433 return n ? F( 434 *xs, // expected-note {{read of dereferenced one-past-the-end pointer}} 435 *ys, 436 ZipFoldR(F, n-1, xs+1, ys+1, c)) // \ 437 expected-note {{in call to 'ZipFoldR(&SubMul, 2, &xs[4], &ys[4], 1)'}} \ 438 expected-note {{in call to 'ZipFoldR(&SubMul, 1, &xs[5], &ys[5], 1)'}} 439 : c; 440} 441constexpr int MulAdd(int x, int y, int c) { return x * y + c; } 442constexpr int InnerProduct = ZipFoldR(MulAdd, 5, xs, ys, 0); 443static_assert(InnerProduct == 35, ""); 444 445constexpr int SubMul(int x, int y, int c) { return (x - y) * c; } 446constexpr int DiffProd = ZipFoldR(SubMul, 2, xs+3, ys+3, 1); 447static_assert(DiffProd == 8, ""); 448static_assert(ZipFoldR(SubMul, 3, xs+3, ys+3, 1), ""); // \ 449 expected-error {{constant expression}} \ 450 expected-note {{in call to 'ZipFoldR(&SubMul, 3, &xs[3], &ys[3], 1)'}} 451 452constexpr const int *p = xs + 3; 453constexpr int xs4 = p[1]; // ok 454constexpr int xs5 = p[2]; // expected-error {{constant expression}} expected-note {{read of dereferenced one-past-the-end pointer}} 455constexpr int xs6 = p[3]; // expected-error {{constant expression}} expected-note {{cannot refer to element 6}} 456constexpr int xs0 = p[-3]; // ok 457constexpr int xs_1 = p[-4]; // expected-error {{constant expression}} expected-note {{cannot refer to element -1}} 458 459constexpr int zs[2][2][2][2] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 }; 460static_assert(zs[0][0][0][0] == 1, ""); 461static_assert(zs[1][1][1][1] == 16, ""); 462static_assert(zs[0][0][0][2] == 3, ""); // expected-error {{constant expression}} expected-note {{read of dereferenced one-past-the-end pointer}} 463static_assert((&zs[0][0][0][2])[-1] == 2, ""); 464static_assert(**(**(zs + 1) + 1) == 11, ""); 465static_assert(*(&(&(*(*&(&zs[2] - 1)[0] + 2 - 2))[2])[-1][-1] + 1) == 11, ""); // expected-error {{constant expression}} expected-note {{cannot refer to element -1 of array of 2 elements in a constant expression}} 466static_assert(*(&(&(*(*&(&zs[2] - 1)[0] + 2 - 2))[2])[-1][2] - 2) == 11, ""); 467constexpr int err_zs_1_2_0_0 = zs[1][2][0][0]; // expected-error {{constant expression}} expected-note {{cannot access array element of pointer past the end}} 468 469constexpr int fail(const int &p) { 470 return (&p)[64]; // expected-note {{cannot refer to element 64 of array of 2 elements}} 471} 472static_assert(fail(*(&(&(*(*&(&zs[2] - 1)[0] + 2 - 2))[2])[-1][2] - 2)) == 11, ""); // \ 473expected-error {{static_assert expression is not an integral constant expression}} \ 474expected-note {{in call to 'fail(zs[1][0][1][0])'}} 475 476constexpr int arr[40] = { 1, 2, 3, [8] = 4 }; // expected-warning {{C99 feature}} 477constexpr int SumNonzero(const int *p) { 478 return *p + (*p ? SumNonzero(p+1) : 0); 479} 480constexpr int CountZero(const int *p, const int *q) { 481 return p == q ? 0 : (*p == 0) + CountZero(p+1, q); 482} 483static_assert(SumNonzero(arr) == 6, ""); 484static_assert(CountZero(arr, arr + 40) == 36, ""); 485 486struct ArrayElem { 487 constexpr ArrayElem() : n(0) {} 488 int n; 489 constexpr int f() { return n; } 490}; 491struct ArrayRVal { 492 constexpr ArrayRVal() {} 493 ArrayElem elems[10]; 494}; 495static_assert(ArrayRVal().elems[3].f() == 0, ""); 496 497} 498 499namespace DependentValues { 500 501struct I { int n; typedef I V[10]; }; 502I::V x, y; 503template<bool B> struct S { 504 int k; 505 void f() { 506 I::V &cells = B ? x : y; 507 I &i = cells[k]; 508 switch (i.n) {} 509 } 510}; 511 512} 513 514namespace Class { 515 516struct A { constexpr A(int a, int b) : k(a + b) {} int k; }; 517constexpr int fn(const A &a) { return a.k; } 518static_assert(fn(A(4,5)) == 9, ""); 519 520struct B { int n; int m; } constexpr b = { 0, b.n }; // expected-warning {{uninitialized}} 521struct C { 522 constexpr C(C *this_) : m(42), n(this_->m) {} // ok 523 int m, n; 524}; 525struct D { 526 C c; 527 constexpr D() : c(&c) {} 528}; 529static_assert(D().c.n == 42, ""); 530 531struct E { 532 constexpr E() : p(&p) {} 533 void *p; 534}; 535constexpr const E &e1 = E(); // expected-error {{constant expression}} expected-note {{reference to temporary is not a constant expression}} expected-note {{temporary created here}} 536// This is a constant expression if we elide the copy constructor call, and 537// is not a constant expression if we don't! But we do, so it is. 538constexpr E e2 = E(); 539static_assert(e2.p == &e2.p, ""); 540constexpr E e3; 541static_assert(e3.p == &e3.p, ""); 542 543extern const class F f; 544struct F { 545 constexpr F() : p(&f.p) {} 546 const void *p; 547}; 548constexpr F f; 549 550struct G { 551 struct T { 552 constexpr T(T *p) : u1(), u2(p) {} 553 union U1 { 554 constexpr U1() {} 555 int a, b = 42; 556 } u1; 557 union U2 { 558 constexpr U2(T *p) : c(p->u1.b) {} 559 int c, d; 560 } u2; 561 } t; 562 constexpr G() : t(&t) {} 563} constexpr g; 564 565static_assert(g.t.u1.a == 42, ""); // expected-error {{constant expression}} expected-note {{read of member 'a' of union with active member 'b'}} 566static_assert(g.t.u1.b == 42, ""); 567static_assert(g.t.u2.c == 42, ""); 568static_assert(g.t.u2.d == 42, ""); // expected-error {{constant expression}} expected-note {{read of member 'd' of union with active member 'c'}} 569 570struct S { 571 int a, b; 572 const S *p; 573 double d; 574 const char *q; 575 576 constexpr S(int n, const S *p) : a(5), b(n), p(p), d(n), q("hello") {} 577}; 578 579S global(43, &global); 580 581static_assert(S(15, &global).b == 15, ""); 582 583constexpr bool CheckS(const S &s) { 584 return s.a == 5 && s.b == 27 && s.p == &global && s.d == 27. && s.q[3] == 'l'; 585} 586static_assert(CheckS(S(27, &global)), ""); 587 588struct Arr { 589 char arr[3]; 590 constexpr Arr() : arr{'x', 'y', 'z'} {} 591}; 592constexpr int hash(Arr &&a) { 593 return a.arr[0] + a.arr[1] * 0x100 + a.arr[2] * 0x10000; 594} 595constexpr int k = hash(Arr()); 596static_assert(k == 0x007a7978, ""); 597 598 599struct AggregateInit { 600 const char &c; 601 int n; 602 double d; 603 int arr[5]; 604 void *p; 605}; 606 607constexpr AggregateInit agg1 = { "hello"[0] }; 608 609static_assert(strcmp_ce(&agg1.c, "hello") == 0, ""); 610static_assert(agg1.n == 0, ""); 611static_assert(agg1.d == 0.0, ""); 612static_assert(agg1.arr[-1] == 0, ""); // expected-error {{constant expression}} expected-note {{cannot refer to element -1}} 613static_assert(agg1.arr[0] == 0, ""); 614static_assert(agg1.arr[4] == 0, ""); 615static_assert(agg1.arr[5] == 0, ""); // expected-error {{constant expression}} expected-note {{read of dereferenced one-past-the-end}} 616static_assert(agg1.p == nullptr, ""); 617 618static constexpr const unsigned char uc[] = { "foo" }; 619static_assert(uc[0] == 'f', ""); 620static_assert(uc[3] == 0, ""); 621 622namespace SimpleDerivedClass { 623 624struct B { 625 constexpr B(int n) : a(n) {} 626 int a; 627}; 628struct D : B { 629 constexpr D(int n) : B(n) {} 630}; 631constexpr D d(3); 632static_assert(d.a == 3, ""); 633 634} 635 636struct Bottom { constexpr Bottom() {} }; 637struct Base : Bottom { 638 constexpr Base(int a = 42, const char *b = "test") : a(a), b(b) {} 639 int a; 640 const char *b; 641}; 642struct Base2 : Bottom { 643 constexpr Base2(const int &r) : r(r) {} 644 int q = 123; 645 const int &r; 646}; 647struct Derived : Base, Base2 { 648 constexpr Derived() : Base(76), Base2(a) {} 649 int c = r + b[1]; 650}; 651 652constexpr bool operator==(const Base &a, const Base &b) { 653 return a.a == b.a && strcmp_ce(a.b, b.b) == 0; 654} 655 656constexpr Base base; 657constexpr Base base2(76); 658constexpr Derived derived; 659static_assert(derived.a == 76, ""); 660static_assert(derived.b[2] == 's', ""); 661static_assert(derived.c == 76 + 'e', ""); 662static_assert(derived.q == 123, ""); 663static_assert(derived.r == 76, ""); 664static_assert(&derived.r == &derived.a, ""); 665 666static_assert(!(derived == base), ""); 667static_assert(derived == base2, ""); 668 669constexpr Bottom &bot1 = (Base&)derived; 670constexpr Bottom &bot2 = (Base2&)derived; 671static_assert(&bot1 != &bot2, ""); 672 673constexpr Bottom *pb1 = (Base*)&derived; 674constexpr Bottom *pb2 = (Base2*)&derived; 675static_assert(&pb1 != &pb2, ""); 676static_assert(pb1 == &bot1, ""); 677static_assert(pb2 == &bot2, ""); 678 679constexpr Base2 &fail = (Base2&)bot1; // expected-error {{constant expression}} expected-note {{cannot cast object of dynamic type 'const Class::Derived' to type 'Class::Base2'}} 680constexpr Base &fail2 = (Base&)*pb2; // expected-error {{constant expression}} expected-note {{cannot cast object of dynamic type 'const Class::Derived' to type 'Class::Base'}} 681constexpr Base2 &ok2 = (Base2&)bot2; 682static_assert(&ok2 == &derived, ""); 683 684constexpr Base2 *pfail = (Base2*)pb1; // expected-error {{constant expression}} expected-note {{cannot cast object of dynamic type 'const Class::Derived' to type 'Class::Base2'}} 685constexpr Base *pfail2 = (Base*)&bot2; // expected-error {{constant expression}} expected-note {{cannot cast object of dynamic type 'const Class::Derived' to type 'Class::Base'}} 686constexpr Base2 *pok2 = (Base2*)pb2; 687static_assert(pok2 == &derived, ""); 688static_assert(&ok2 == pok2, ""); 689static_assert((Base2*)(Derived*)(Base*)pb1 == pok2, ""); 690static_assert((Derived*)(Base*)pb1 == (Derived*)pok2, ""); 691 692constexpr Base *nullB = 42 - 6 * 7; 693static_assert((Bottom*)nullB == 0, ""); 694static_assert((Derived*)nullB == 0, ""); 695static_assert((void*)(Bottom*)nullB == (void*)(Derived*)nullB, ""); 696 697namespace ConversionOperators { 698 699struct T { 700 constexpr T(int n) : k(5*n - 3) {} 701 constexpr operator int() { return k; } 702 int k; 703}; 704 705struct S { 706 constexpr S(int n) : k(2*n + 1) {} 707 constexpr operator int() { return k; } 708 constexpr operator T() { return T(k); } 709 int k; 710}; 711 712constexpr bool check(T a, T b) { return a == b.k; } 713 714static_assert(S(5) == 11, ""); 715static_assert(check(S(5), 11), ""); 716 717} 718 719} 720 721namespace Temporaries { 722 723struct S { 724 constexpr S() {} 725 constexpr int f(); 726}; 727struct T : S { 728 constexpr T(int n) : S(), n(n) {} 729 int n; 730}; 731constexpr int S::f() { 732 // 'this' must be the postfix-expression in a class member access expression, 733 // so we can't just use 734 // return static_cast<T*>(this)->n; 735 return this->*(int(S::*))&T::n; 736} 737// The T temporary is implicitly cast to an S subobject, but we can recover the 738// T full-object via a base-to-derived cast, or a derived-to-base-casted member 739// pointer. 740static_assert(T(3).f() == 3, ""); 741 742constexpr int f(const S &s) { 743 return static_cast<const T&>(s).n; 744} 745constexpr int n = f(T(5)); 746static_assert(f(T(5)) == 5, ""); 747 748constexpr bool b(int n) { return &n; } 749static_assert(b(0), ""); 750 751} 752 753namespace Union { 754 755union U { 756 int a; 757 int b; 758}; 759 760constexpr U u[4] = { { .a = 0 }, { .b = 1 }, { .a = 2 }, { .b = 3 } }; // expected-warning 4{{C99 feature}} 761static_assert(u[0].a == 0, ""); 762static_assert(u[0].b, ""); // expected-error {{constant expression}} expected-note {{read of member 'b' of union with active member 'a'}} 763static_assert(u[1].b == 1, ""); 764static_assert((&u[1].b)[1] == 2, ""); // expected-error {{constant expression}} expected-note {{read of dereferenced one-past-the-end pointer}} 765static_assert(*(&(u[1].b) + 1 + 1) == 3, ""); // expected-error {{constant expression}} expected-note {{cannot refer to element 2 of non-array object}} 766static_assert((&(u[1]) + 1 + 1)->b == 3, ""); 767 768constexpr U v = {}; 769static_assert(v.a == 0, ""); 770 771union Empty {}; 772constexpr Empty e = {}; 773 774// Make sure we handle trivial copy constructors for unions. 775constexpr U x = {42}; 776constexpr U y = x; 777static_assert(y.a == 42, ""); 778static_assert(y.b == 42, ""); // expected-error {{constant expression}} expected-note {{'b' of union with active member 'a'}} 779 780} 781 782namespace MemberPointer { 783 struct A { 784 constexpr A(int n) : n(n) {} 785 int n; 786 constexpr int f() { return n + 3; } 787 }; 788 constexpr A a(7); 789 static_assert(A(5).*&A::n == 5, ""); 790 static_assert((&a)->*&A::n == 7, ""); 791 static_assert((A(8).*&A::f)() == 11, ""); 792 static_assert(((&a)->*&A::f)() == 10, ""); 793 794 struct B : A { 795 constexpr B(int n, int m) : A(n), m(m) {} 796 int m; 797 constexpr int g() { return n + m + 1; } 798 }; 799 constexpr B b(9, 13); 800 static_assert(B(4, 11).*&A::n == 4, ""); 801 static_assert(B(4, 11).*&B::m == 11, ""); 802 static_assert(B(4, 11).*(int(A::*))&B::m == 11, ""); 803 static_assert((&b)->*&A::n == 9, ""); 804 static_assert((&b)->*&B::m == 13, ""); 805 static_assert((&b)->*(int(A::*))&B::m == 13, ""); 806 static_assert((B(4, 11).*&A::f)() == 7, ""); 807 static_assert((B(4, 11).*&B::g)() == 16, ""); 808 static_assert((B(4, 11).*(int(A::*)()const)&B::g)() == 16, ""); 809 static_assert(((&b)->*&A::f)() == 12, ""); 810 static_assert(((&b)->*&B::g)() == 23, ""); 811 static_assert(((&b)->*(int(A::*)()const)&B::g)() == 23, ""); 812 813 struct S { 814 constexpr S(int m, int n, int (S::*pf)() const, int S::*pn) : 815 m(m), n(n), pf(pf), pn(pn) {} 816 constexpr S() : m(), n(), pf(&S::f), pn(&S::n) {} 817 818 constexpr int f() { return this->*pn; } 819 virtual int g() const; 820 821 int m, n; 822 int (S::*pf)() const; 823 int S::*pn; 824 }; 825 826 constexpr int S::*pm = &S::m; 827 constexpr int S::*pn = &S::n; 828 constexpr int (S::*pf)() const = &S::f; 829 constexpr int (S::*pg)() const = &S::g; 830 831 constexpr S s(2, 5, &S::f, &S::m); 832 833 static_assert((s.*&S::f)() == 2, ""); 834 static_assert((s.*s.pf)() == 2, ""); 835 836 static_assert(pf == &S::f, ""); 837 static_assert(pf == s.*&S::pf, ""); 838 static_assert(pm == &S::m, ""); 839 static_assert(pm != pn, ""); 840 static_assert(s.pn != pn, ""); 841 static_assert(s.pn == pm, ""); 842 static_assert(pg != nullptr, ""); 843 static_assert(pf != nullptr, ""); 844 static_assert((int S::*)nullptr == nullptr, ""); 845 static_assert(pg == pg, ""); // expected-error {{constant expression}} expected-note {{comparison of pointer to virtual member function 'g' has unspecified value}} 846 static_assert(pf != pg, ""); // expected-error {{constant expression}} expected-note {{comparison of pointer to virtual member function 'g' has unspecified value}} 847 848 template<int n> struct T : T<n-1> {}; 849 template<> struct T<0> { int n; }; 850 template<> struct T<30> : T<29> { int m; }; 851 852 T<17> t17; 853 T<30> t30; 854 855 constexpr int (T<10>::*deepn) = &T<0>::n; 856 static_assert(&(t17.*deepn) == &t17.n, ""); 857 static_assert(deepn == &T<2>::n, ""); 858 859 constexpr int (T<15>::*deepm) = (int(T<10>::*))&T<30>::m; 860 constexpr int *pbad = &(t17.*deepm); // expected-error {{constant expression}} 861 static_assert(&(t30.*deepm) == &t30.m, ""); 862 static_assert(deepm == &T<50>::m, ""); 863 static_assert(deepm != deepn, ""); 864 865 constexpr T<5> *p17_5 = &t17; 866 constexpr T<13> *p17_13 = (T<13>*)p17_5; 867 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>'}} 868 static_assert(&(p17_5->*(int(T<3>::*))deepn) == &t17.n, ""); 869 static_assert(&(p17_13->*deepn) == &t17.n, ""); 870 constexpr int *pbad2 = &(p17_13->*(int(T<9>::*))deepm); // expected-error {{constant expression}} 871 872 constexpr T<5> *p30_5 = &t30; 873 constexpr T<23> *p30_23 = (T<23>*)p30_5; 874 constexpr T<13> *p30_13 = p30_23; 875 static_assert(&(p30_5->*(int(T<3>::*))deepn) == &t30.n, ""); 876 static_assert(&(p30_13->*deepn) == &t30.n, ""); 877 static_assert(&(p30_23->*deepn) == &t30.n, ""); 878 static_assert(&(p30_5->*(int(T<2>::*))deepm) == &t30.m, ""); 879 static_assert(&(((T<17>*)p30_13)->*deepm) == &t30.m, ""); 880 static_assert(&(p30_23->*deepm) == &t30.m, ""); 881 882 struct Base { int n; }; 883 template<int N> struct Mid : Base {}; 884 struct Derived : Mid<0>, Mid<1> {}; 885 static_assert(&Mid<0>::n == &Mid<1>::n, ""); 886 static_assert((int Derived::*)(int Mid<0>::*)&Mid<0>::n != 887 (int Derived::*)(int Mid<1>::*)&Mid<1>::n, ""); 888 static_assert(&Mid<0>::n == (int Mid<0>::*)&Base::n, ""); 889} 890 891namespace ArrayBaseDerived { 892 893 struct Base { 894 constexpr Base() {} 895 int n = 0; 896 }; 897 struct Derived : Base { 898 constexpr Derived() {} 899 constexpr const int *f() { return &n; } 900 }; 901 902 constexpr Derived a[10]; 903 constexpr Derived *pd3 = const_cast<Derived*>(&a[3]); 904 constexpr Base *pb3 = const_cast<Derived*>(&a[3]); 905 static_assert(pb3 == pd3, ""); 906 907 // pb3 does not point to an array element. 908 constexpr Base *pb4 = pb3 + 1; // ok, one-past-the-end pointer. 909 constexpr int pb4n = pb4->n; // expected-error {{constant expression}} expected-note {{cannot access field of pointer past the end}} 910 constexpr Base *err_pb5 = pb3 + 2; // expected-error {{constant expression}} expected-note {{cannot refer to element 2}} expected-note {{here}} 911 constexpr int err_pb5n = err_pb5->n; // expected-error {{constant expression}} expected-note {{initializer of 'err_pb5' is not a constant expression}} 912 constexpr Base *err_pb2 = pb3 - 1; // expected-error {{constant expression}} expected-note {{cannot refer to element -1}} expected-note {{here}} 913 constexpr int err_pb2n = err_pb2->n; // expected-error {{constant expression}} expected-note {{initializer of 'err_pb2'}} 914 constexpr Base *pb3a = pb4 - 1; 915 916 // pb4 does not point to a Derived. 917 constexpr Derived *err_pd4 = (Derived*)pb4; // expected-error {{constant expression}} expected-note {{cannot access derived class of pointer past the end}} 918 constexpr Derived *pd3a = (Derived*)pb3a; 919 constexpr int pd3n = pd3a->n; 920 921 // pd3a still points to the Derived array. 922 constexpr Derived *pd6 = pd3a + 3; 923 static_assert(pd6 == &a[6], ""); 924 constexpr Derived *pd9 = pd6 + 3; 925 constexpr Derived *pd10 = pd6 + 4; 926 constexpr int pd9n = pd9->n; // ok 927 constexpr int err_pd10n = pd10->n; // expected-error {{constant expression}} expected-note {{cannot access base class of pointer past the end}} 928 constexpr int pd0n = pd10[-10].n; 929 constexpr int err_pdminus1n = pd10[-11].n; // expected-error {{constant expression}} expected-note {{cannot refer to element -1 of}} 930 931 constexpr Base *pb9 = pd9; 932 constexpr const int *(Base::*pfb)() const = 933 static_cast<const int *(Base::*)() const>(&Derived::f); 934 static_assert((pb9->*pfb)() == &a[9].n, ""); 935} 936 937namespace Complex { 938 939class complex { 940 int re, im; 941public: 942 constexpr complex(int re = 0, int im = 0) : re(re), im(im) {} 943 constexpr complex(const complex &o) : re(o.re), im(o.im) {} 944 constexpr complex operator-() const { return complex(-re, -im); } 945 friend constexpr complex operator+(const complex &l, const complex &r) { 946 return complex(l.re + r.re, l.im + r.im); 947 } 948 friend constexpr complex operator-(const complex &l, const complex &r) { 949 return l + -r; 950 } 951 friend constexpr complex operator*(const complex &l, const complex &r) { 952 return complex(l.re * r.re - l.im * r.im, l.re * r.im + l.im * r.re); 953 } 954 friend constexpr bool operator==(const complex &l, const complex &r) { 955 return l.re == r.re && l.im == r.im; 956 } 957 constexpr bool operator!=(const complex &r) const { 958 return re != r.re || im != r.im; 959 } 960 constexpr int real() const { return re; } 961 constexpr int imag() const { return im; } 962}; 963 964constexpr complex i = complex(0, 1); 965constexpr complex k = (3 + 4*i) * (6 - 4*i); 966static_assert(complex(1,0).real() == 1, ""); 967static_assert(complex(1,0).imag() == 0, ""); 968static_assert(((complex)1).imag() == 0, ""); 969static_assert(k.real() == 34, ""); 970static_assert(k.imag() == 12, ""); 971static_assert(k - 34 == 12*i, ""); 972static_assert((complex)1 == complex(1), ""); 973static_assert((complex)1 != complex(0, 1), ""); 974static_assert(complex(1) == complex(1), ""); 975static_assert(complex(1) != complex(0, 1), ""); 976constexpr complex makeComplex(int re, int im) { return complex(re, im); } 977static_assert(makeComplex(1,0) == complex(1), ""); 978static_assert(makeComplex(1,0) != complex(0, 1), ""); 979 980class complex_wrap : public complex { 981public: 982 constexpr complex_wrap(int re, int im = 0) : complex(re, im) {} 983 constexpr complex_wrap(const complex_wrap &o) : complex(o) {} 984}; 985 986static_assert((complex_wrap)1 == complex(1), ""); 987static_assert((complex)1 != complex_wrap(0, 1), ""); 988static_assert(complex(1) == complex_wrap(1), ""); 989static_assert(complex_wrap(1) != complex(0, 1), ""); 990constexpr complex_wrap makeComplexWrap(int re, int im) { 991 return complex_wrap(re, im); 992} 993static_assert(makeComplexWrap(1,0) == complex(1), ""); 994static_assert(makeComplexWrap(1,0) != complex(0, 1), ""); 995 996} 997 998namespace PR11595 { 999 struct A { constexpr bool operator==(int x) { return true; } }; 1000 struct B { B(); A& x; }; 1001 static_assert(B().x == 3, ""); // expected-error {{constant expression}} expected-note {{non-literal type 'PR11595::B' cannot be used in a constant expression}} 1002 1003 constexpr bool f(int k) { // expected-error {{constexpr function never produces a constant expression}} 1004 return B().x == k; // expected-note {{non-literal type 'PR11595::B' cannot be used in a constant expression}} 1005 } 1006} 1007 1008namespace ExprWithCleanups { 1009 struct A { A(); ~A(); int get(); }; 1010 constexpr int get(bool FromA) { return FromA ? A().get() : 1; } 1011 constexpr int n = get(false); 1012} 1013 1014namespace Volatile { 1015 1016volatile constexpr int n1 = 0; // expected-note {{here}} 1017volatile const int n2 = 0; // expected-note {{here}} 1018int n3 = 37; // expected-note {{declared here}} 1019 1020constexpr int m1 = n1; // expected-error {{constant expression}} expected-note {{read of volatile-qualified type 'const volatile int'}} 1021constexpr int m2 = n2; // expected-error {{constant expression}} expected-note {{read of volatile-qualified type 'const volatile int'}} 1022constexpr int m1b = const_cast<const int&>(n1); // expected-error {{constant expression}} expected-note {{read of volatile object 'n1'}} 1023constexpr int m2b = const_cast<const int&>(n2); // expected-error {{constant expression}} expected-note {{read of volatile object 'n2'}} 1024 1025struct T { int n; }; 1026const T t = { 42 }; // expected-note {{declared here}} 1027 1028constexpr int f(volatile int &&r) { 1029 return r; // expected-note {{read of volatile-qualified type 'volatile int'}} 1030} 1031constexpr int g(volatile int &&r) { 1032 return const_cast<int&>(r); // expected-note {{read of volatile temporary is not allowed in a constant expression}} 1033} 1034struct S { 1035 int j : f(0); // expected-error {{constant expression}} expected-note {{in call to 'f(0)'}} 1036 int k : g(0); // expected-error {{constant expression}} expected-note {{temporary created here}} expected-note {{in call to 'g(0)'}} 1037 int l : n3; // expected-error {{constant expression}} expected-note {{read of non-const variable}} 1038 int m : t.n; // expected-error {{constant expression}} expected-note {{read of non-constexpr variable}} 1039}; 1040 1041} 1042 1043namespace ExternConstexpr { 1044 extern constexpr int n = 0; 1045 extern constexpr int m; // expected-error {{constexpr variable declaration must be a definition}} 1046 void f() { 1047 extern constexpr int i; // expected-error {{constexpr variable declaration must be a definition}} 1048 constexpr int j = 0; 1049 constexpr int k; // expected-error {{default initialization of an object of const type}} 1050 } 1051} 1052 1053namespace ComplexConstexpr { 1054 constexpr _Complex float test1 = {}; 1055 constexpr _Complex float test2 = {1}; 1056 constexpr _Complex double test3 = {1,2}; 1057 constexpr _Complex int test4 = {4}; 1058 constexpr _Complex int test5 = 4; 1059 constexpr _Complex int test6 = {5,6}; 1060 typedef _Complex float fcomplex; 1061 constexpr fcomplex test7 = fcomplex(); 1062 1063 constexpr const double &t2r = __real test3; 1064 constexpr const double &t2i = __imag test3; 1065 static_assert(&t2r + 1 == &t2i, ""); 1066 static_assert(t2r == 1.0, ""); 1067 static_assert(t2i == 2.0, ""); 1068 constexpr const double *t2p = &t2r; 1069 static_assert(t2p[-1] == 0.0, ""); // expected-error {{constant expr}} expected-note {{cannot refer to element -1 of array of 2 elements}} 1070 static_assert(t2p[0] == 1.0, ""); 1071 static_assert(t2p[1] == 2.0, ""); 1072 static_assert(t2p[2] == 0.0, ""); // expected-error {{constant expr}} expected-note {{one-past-the-end pointer}} 1073 static_assert(t2p[3] == 0.0, ""); // expected-error {{constant expr}} expected-note {{cannot refer to element 3 of array of 2 elements}} 1074 constexpr _Complex float *p = 0; 1075 constexpr float pr = __real *p; // expected-error {{constant expr}} expected-note {{cannot access real component of null}} 1076 constexpr float pi = __imag *p; // expected-error {{constant expr}} expected-note {{cannot access imaginary component of null}} 1077 constexpr const _Complex double *q = &test3 + 1; 1078 constexpr double qr = __real *q; // expected-error {{constant expr}} expected-note {{cannot access real component of pointer past the end}} 1079 constexpr double qi = __imag *q; // expected-error {{constant expr}} expected-note {{cannot access imaginary component of pointer past the end}} 1080 1081 static_assert(__real test6 == 5, ""); 1082 static_assert(__imag test6 == 6, ""); 1083 static_assert(&__imag test6 == &__real test6 + 1, ""); 1084} 1085 1086namespace InstantiateCaseStmt { 1087 template<int x> constexpr int f() { return x; } 1088 template<int x> int g(int c) { switch(c) { case f<x>(): return 1; } return 0; } 1089 int gg(int c) { return g<4>(c); } 1090} 1091 1092namespace ConvertedConstantExpr { 1093 extern int &m; 1094 extern int &n; 1095 1096 constexpr int k = 4; 1097 int &m = const_cast<int&>(k); 1098 1099 // If we have nothing more interesting to say, ensure we don't produce a 1100 // useless note and instead just point to the non-constant subexpression. 1101 enum class E { 1102 em = m, 1103 en = n, // expected-error {{not a constant expression}} 1104 eo = (m + 1105 n // expected-error {{not a constant expression}} 1106 ), 1107 eq = reinterpret_cast<int>((int*)0) // expected-error {{not a constant expression}} expected-note {{reinterpret_cast}} 1108 }; 1109} 1110 1111namespace IndirectField { 1112 struct S { 1113 struct { // expected-warning {{GNU extension}} 1114 union { 1115 struct { // expected-warning {{GNU extension}} 1116 int a; 1117 int b; 1118 }; 1119 int c; 1120 }; 1121 int d; 1122 }; 1123 union { 1124 int e; 1125 int f; 1126 }; 1127 constexpr S(int a, int b, int d, int e) : a(a), b(b), d(d), e(e) {} 1128 constexpr S(int c, int d, int f) : c(c), d(d), f(f) {} 1129 }; 1130 1131 constexpr S s1(1, 2, 3, 4); 1132 constexpr S s2(5, 6, 7); 1133 1134 // FIXME: The diagnostics here do a very poor job of explaining which unnamed 1135 // member is active and which is requested. 1136 static_assert(s1.a == 1, ""); 1137 static_assert(s1.b == 2, ""); 1138 static_assert(s1.c == 0, ""); // expected-error {{constant expression}} expected-note {{union with active member}} 1139 static_assert(s1.d == 3, ""); 1140 static_assert(s1.e == 4, ""); 1141 static_assert(s1.f == 0, ""); // expected-error {{constant expression}} expected-note {{union with active member}} 1142 1143 static_assert(s2.a == 0, ""); // expected-error {{constant expression}} expected-note {{union with active member}} 1144 static_assert(s2.b == 0, ""); // expected-error {{constant expression}} expected-note {{union with active member}} 1145 static_assert(s2.c == 5, ""); 1146 static_assert(s2.d == 6, ""); 1147 static_assert(s2.e == 0, ""); // expected-error {{constant expression}} expected-note {{union with active member}} 1148 static_assert(s2.f == 7, ""); 1149} 1150 1151// DR1405: don't allow reading mutable members in constant expressions. 1152namespace MutableMembers { 1153 struct MM { 1154 mutable int n; // expected-note 3{{declared here}} 1155 } constexpr mm = { 4 }; 1156 constexpr int mmn = mm.n; // expected-error {{constant expression}} expected-note {{read of mutable member 'n' is not allowed in a constant expression}} 1157 int x = (mm.n = 1, 3); 1158 constexpr int mmn2 = mm.n; // expected-error {{constant expression}} expected-note {{read of mutable member 'n' is not allowed in a constant expression}} 1159 1160 // Here's one reason why allowing this would be a disaster... 1161 template<int n> struct Id { int k = n; }; 1162 int f() { 1163 constexpr MM m = { 0 }; 1164 ++m.n; 1165 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}} 1166 } 1167 1168 struct A { int n; }; 1169 struct B { mutable A a; }; // expected-note {{here}} 1170 struct C { B b; }; 1171 constexpr C c[3] = {}; 1172 constexpr int k = c[1].b.a.n; // expected-error {{constant expression}} expected-note {{mutable}} 1173} 1174 1175namespace Fold { 1176 1177 // This macro forces its argument to be constant-folded, even if it's not 1178 // otherwise a constant expression. 1179 #define fold(x) (__builtin_constant_p(x) ? (x) : (x)) 1180 1181 constexpr int n = (int)(char*)123; // expected-error {{constant expression}} expected-note {{reinterpret_cast}} 1182 constexpr int m = fold((int)(char*)123); // ok 1183 static_assert(m == 123, ""); 1184 1185 #undef fold 1186 1187} 1188 1189namespace DR1454 { 1190 1191constexpr const int &f(const int &n) { return n; } 1192constexpr int k1 = f(0); // ok 1193 1194struct Wrap { 1195 const int &value; 1196}; 1197constexpr const Wrap &g(const Wrap &w) { return w; } 1198constexpr int k2 = g({0}).value; // ok 1199 1200constexpr const int &i = 0; // expected-error {{constant expression}} expected-note {{temporary}} expected-note 2{{here}} 1201constexpr const int j = i; // expected-error {{constant expression}} expected-note {{initializer of 'i' is not a constant expression}} 1202 1203} 1204 1205namespace RecursiveOpaqueExpr { 1206 template<typename Iter> 1207 constexpr auto LastNonzero(Iter p, Iter q) -> decltype(+*p) { 1208 return p != q ? (LastNonzero(p+1, q) ?: *p) : 0; // expected-warning {{GNU}} 1209 } 1210 1211 constexpr int arr1[] = { 1, 0, 0, 3, 0, 2, 0, 4, 0, 0 }; 1212 static_assert(LastNonzero(begin(arr1), end(arr1)) == 4, ""); 1213 1214 constexpr int arr2[] = { 1, 0, 0, 3, 0, 2, 0, 4, 0, 5 }; 1215 static_assert(LastNonzero(begin(arr2), end(arr2)) == 5, ""); 1216 1217 constexpr int arr3[] = { 1218 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, 1219 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, 1220 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, 1221 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, 1222 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, 1223 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, 1224 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, 1225 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 }; 1226 static_assert(LastNonzero(begin(arr3), end(arr3)) == 2, ""); 1227} 1228 1229namespace VLASizeof { 1230 1231 void f(int k) { 1232 int arr[k]; // expected-warning {{C99}} 1233 constexpr int n = 1 + 1234 sizeof(arr) // expected-error {{constant expression}} 1235 * 3; 1236 } 1237} 1238 1239namespace CompoundLiteral { 1240 // FIXME: 1241 // We don't model the semantics of this correctly: the compound literal is 1242 // represented as a prvalue in the AST, but actually behaves like an lvalue. 1243 // We treat the compound literal as a temporary and refuse to produce a 1244 // pointer to it. This is OK: we're not required to treat this as a constant 1245 // in C++, and in C we model compound literals as lvalues. 1246 constexpr int *p = (int*)(int[1]){0}; // expected-warning {{C99}} expected-error {{constant expression}} expected-note 2{{temporary}} 1247} 1248 1249namespace Vector { 1250 typedef int __attribute__((vector_size(16))) VI4; 1251 constexpr VI4 f(int n) { 1252 return VI4 { n * 3, n + 4, n - 5, n / 6 }; 1253 } 1254 constexpr auto v1 = f(10); 1255 1256 typedef double __attribute__((vector_size(32))) VD4; 1257 constexpr VD4 g(int n) { 1258 return (VD4) { n / 2.0, n + 1.5, n - 5.4, n * 0.9 }; // expected-warning {{C99}} 1259 } 1260 constexpr auto v2 = g(4); 1261} 1262 1263// PR12626, redux 1264namespace InvalidClasses { 1265 void test0() { 1266 struct X; // expected-note {{forward declaration}} 1267 struct Y { bool b; X x; }; // expected-error {{field has incomplete type}} 1268 Y y; 1269 auto& b = y.b; 1270 } 1271} 1272 1273// Indirectly test that an implicit lvalue to xvalue conversion performed for 1274// an NRVO move operation isn't implemented as CK_LValueToRValue. 1275namespace PR12826 { 1276 struct Foo {}; 1277 constexpr Foo id(Foo x) { return x; } 1278 constexpr Foo res(id(Foo())); 1279} 1280