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