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