clang/test/AST/ByteCode/literals.cpp

   1 // RUN: %clang_cc1 -fexperimental-new-constant-interpreter -Wno-vla -fms-extensions -std=c++11 -verify=expected,both %s
   2 // RUN: %clang_cc1 -fexperimental-new-constant-interpreter -Wno-vla -fms-extensions -std=c++20 -verify=expected,both %s
   3 // RUN: %clang_cc1 -std=c++11 -fms-extensions -Wno-vla -verify=ref,both %s
   4 // RUN: %clang_cc1 -std=c++20 -fms-extensions -Wno-vla -verify=ref,both %s
   5
   6 #define INT_MIN (~__INT_MAX__)
   7 #define INT_MAX __INT_MAX__
   8
   9 typedef __INTPTR_TYPE__ intptr_t;
  10 typedef __PTRDIFF_TYPE__ ptrdiff_t;
  11
  12
  13 static_assert(true, "");
  14 static_assert(false, ""); // both-error{{failed}}
  15 static_assert(nullptr == nullptr, "");
  16 static_assert(__null == __null, "");
  17 static_assert(1 == 1, "");
  18 static_assert(1 == 3, ""); // both-error{{failed}}
  19
  20 constexpr void* v = nullptr;
  21 static_assert(__null == v, "");
  22
  23 constexpr int number = 10;
  24 static_assert(number == 10, "");
  25 static_assert(number != 10, ""); // both-error{{failed}} \
  26                                  // both-note{{evaluates to}}
  27
  28 static_assert(__objc_yes, "");
  29 static_assert(!__objc_no, "");
  30
  31 constexpr bool b = number;
  32 static_assert(b, "");
  33 constexpr int one = true;
  34 static_assert(one == 1, "");
  35
  36 constexpr bool b2 = bool();
  37 static_assert(!b2, "");
  38
  39 constexpr int Failed1 = 1 / 0; // both-error {{must be initialized by a constant expression}} \
  40                                // both-note {{division by zero}} \
  41                                // both-note {{declared here}}
  42 constexpr int Failed2 = Failed1 + 1; // both-error {{must be initialized by a constant expression}} \
  43                                      // both-note {{declared here}} \
  44                                      // both-note {{initializer of 'Failed1' is not a constant expression}}
  45 static_assert(Failed2 == 0, ""); // both-error {{not an integral constant expression}} \
  46                                  // both-note {{initializer of 'Failed2' is not a constant expression}}
  47
  48 const int x = *(volatile int*)0x1234;
  49 static_assert((void{}, true), "");
  50
  51 namespace ScalarTypes {
  52   constexpr int ScalarInitInt = int();
  53   static_assert(ScalarInitInt == 0, "");
  54   constexpr float ScalarInitFloat = float();
  55   static_assert(ScalarInitFloat == 0.0f, "");
  56
  57   static_assert(decltype(nullptr)() == nullptr, "");
  58
  59   template<typename T>
  60   constexpr T getScalar() { return T(); }
  61
  62   static_assert(getScalar<const int>() == 0, "");
  63   static_assert(getScalar<const double>() == 0.0, "");
  64
  65   static_assert(getScalar<void*>() == nullptr, "");
  66   static_assert(getScalar<void(*)(void)>() == nullptr, "");
  67
  68   enum E {
  69     First = 0,
  70   };
  71   static_assert(getScalar<E>() == First, "");
  72
  73   struct S {
  74     int v;
  75   };
  76   constexpr int S::* MemberPtr = &S::v;
  77   static_assert(getScalar<decltype(MemberPtr)>() == nullptr, "");
  78
  79 #if __cplusplus >= 201402L
  80   constexpr void Void(int n) {
  81     void(n + 1);
  82     void();
  83   }
  84   constexpr int void_test = (Void(0), 1);
  85   static_assert(void_test == 1, "");
  86 #endif
  87 }
  88
  89 namespace IntegralCasts {
  90   constexpr int i = 12;
  91   constexpr unsigned int ui = i;
  92   static_assert(ui == 12, "");
  93   constexpr unsigned int ub = !false;
  94   static_assert(ub == 1, "");
  95
  96   constexpr int si = ui;
  97   static_assert(si == 12, "");
  98   constexpr int sb = true;
  99   static_assert(sb == 1, "");
 100
 101   constexpr int zero = 0;
 102   constexpr unsigned int uzero = 0;
 103   constexpr bool bs = i;
 104   static_assert(bs, "");
 105   constexpr bool bu = ui;
 106   static_assert(bu, "");
 107   constexpr bool ns = zero;
 108   static_assert(!ns, "");
 109   constexpr bool nu = uzero;
 110   static_assert(!nu, "");
 111 };
 112
 113 constexpr int UninitI; // both-error {{must be initialized by a constant expression}}
 114 constexpr int *UninitPtr; // both-error {{must be initialized by a constant expression}}
 115
 116 constexpr bool getTrue() { return true; }
 117 constexpr bool getFalse() { return false; }
 118 constexpr void* getNull() { return nullptr; }
 119
 120 constexpr int neg(int m) { return -m; }
 121 constexpr bool inv(bool b) { return !b; }
 122
 123 static_assert(12, "");
 124 static_assert(12 == -(-(12)), "");
 125 static_assert(!false, "");
 126 static_assert(!!true, "");
 127 static_assert(!!true == !false, "");
 128 static_assert(true == 1, "");
 129 static_assert(false == 0, "");
 130 static_assert(!5 == false, "");
 131 static_assert(!0, "");
 132 static_assert(-true, "");
 133 static_assert(-false, ""); //both-error{{failed}}
 134
 135 static_assert(~0 == -1, "");
 136 static_assert(~1 == -2, "");
 137 static_assert(~-1 == 0, "");
 138 static_assert(~255 == -256, "");
 139 static_assert(~INT_MIN == INT_MAX, "");
 140 static_assert(~INT_MAX == INT_MIN, "");
 141
 142 static_assert(-(1 << 31), ""); // both-error {{not an integral constant expression}} \
 143                                // both-note {{outside the range of representable values}}
 144
 145 namespace PrimitiveEmptyInitList {
 146   constexpr int a = {};
 147   static_assert(a == 0, "");
 148   constexpr bool b = {};
 149   static_assert(!b, "");
 150   constexpr double d = {};
 151   static_assert(d == 0.0, "");
 152 }
 153
 154
 155 enum E {};
 156 constexpr E e = static_cast<E>(0);
 157 static_assert(~e == -1, "");
 158
 159
 160 constexpr int m = 10;
 161 constexpr const int *p = &m;
 162 static_assert(p != nullptr, "");
 163 static_assert(*p == 10, "");
 164
 165 constexpr const int* getIntPointer() {
 166   return &m;
 167 }
 168 static_assert(getIntPointer() == &m, "");
 169 static_assert(*getIntPointer() == 10, "");
 170
 171 constexpr int gimme(int k) {
 172   return k;
 173 }
 174 static_assert(gimme(5) == 5, "");
 175
 176 namespace PointerToBool {
 177
 178   constexpr void *N = nullptr;
 179   constexpr bool B = N;
 180   static_assert(!B, "");
 181   static_assert(!N, "");
 182
 183   constexpr float F = 1.0;
 184   constexpr const float *FP = &F;
 185   static_assert(FP, "");
 186   static_assert(!!FP, "");
 187 }
 188
 189 namespace PointerComparison {
 190
 191   struct S { int a, b; } s;
 192   constexpr void *null = 0;
 193   constexpr void *pv = (void*)&s.a;
 194   constexpr void *qv = (void*)&s.b;
 195   constexpr bool v1 = null < (int*)0;
 196   constexpr bool v2 = null < pv; // both-error {{must be initialized by a constant expression}} \
 197                                  // both-note {{comparison between 'nullptr' and '&s.a' has unspecified value}}
 198
 199   constexpr bool v3 = null == pv; // ok
 200   constexpr bool v4 = qv == pv; // ok
 201
 202   constexpr bool v5 = qv >= pv;
 203   constexpr bool v8 = qv > (void*)&s.a;
 204   constexpr bool v6 = qv > null; // both-error {{must be initialized by a constant expression}} \
 205                                  // both-note {{comparison between '&s.b' and 'nullptr' has unspecified value}}
 206
 207   constexpr bool v7 = qv <= (void*)&s.b; // ok
 208
 209   constexpr ptrdiff_t m = &m - &m;
 210   static_assert(m == 0, "");
 211
 212   constexpr ptrdiff_t m2 = (&m2 + 1) - (&m2 + 1);
 213   static_assert(m2 == 0, "");
 214
 215   constexpr long m3 = (&m3 + 1) - (&m3);
 216   static_assert(m3 == 1, "");
 217
 218   constexpr long m4 = &m4 + 2 - &m4; // both-error {{must be initialized by a constant expression}} \
 219                                      // both-note {{cannot refer to element 2 of non-array object}}
 220 }
 221
 222 namespace SizeOf {
 223   static_assert(alignof(char&) == 1, "");
 224
 225   constexpr int soint = sizeof(int);
 226   constexpr int souint = sizeof(unsigned int);
 227   static_assert(soint == souint, "");
 228
 229   static_assert(sizeof(&soint) == sizeof(void*), "");
 230   static_assert(sizeof(&soint) == sizeof(nullptr), "");
 231
 232   static_assert(sizeof(long) == sizeof(unsigned long), "");
 233   static_assert(sizeof(char) == sizeof(unsigned char), "");
 234
 235   constexpr int N = 4;
 236   constexpr int arr[N] = {1,2,3,4};
 237   static_assert(sizeof(arr) == N * sizeof(int), "");
 238   static_assert(sizeof(arr) == N * sizeof(arr[0]), "");
 239
 240   constexpr bool arrB[N] = {true, true, true, true};
 241   static_assert(sizeof(arrB) == N * sizeof(bool), "");
 242
 243   static_assert(sizeof(bool) == 1, "");
 244   static_assert(sizeof(char) == 1, "");
 245
 246   constexpr int F = sizeof(void); // both-error{{incomplete type 'void'}}
 247
 248   constexpr int F2 = sizeof(gimme); // both-error{{to a function type}}
 249
 250
 251   struct S {
 252     void func();
 253   };
 254   constexpr void (S::*Func)() = &S::func;
 255   static_assert(sizeof(Func) == sizeof(&S::func), "");
 256
 257
 258   void func() {
 259     int n = 12;
 260     constexpr int oofda = sizeof(int[n++]); // both-error {{must be initialized by a constant expression}}
 261   }
 262
 263 #if __cplusplus >= 201402L
 264   constexpr int IgnoredRejected() { // ref-error {{never produces a constant expression}}
 265     int n = 0;
 266     sizeof(int[n++]); // both-warning {{expression result unused}} \
 267                       // ref-note 2{{subexpression not valid in a constant expression}}
 268     return n;
 269   }
 270   /// FIXME: This is rejected because the parameter so sizeof() is not constant.
 271   ///   produce a proper diagnostic.
 272   static_assert(IgnoredRejected() == 0, ""); // both-error {{not an integral constant expression}} \
 273                                              // ref-note {{in call to 'IgnoredRejected()'}}
 274 #endif
 275
 276
 277 #if __cplusplus >= 202002L
 278   /// FIXME: The following code should be accepted.
 279   consteval int foo(int n) { // ref-error {{consteval function never produces a constant expression}}
 280     return sizeof(int[n]); // ref-note 3{{not valid in a constant expression}}
 281   }
 282   constinit int var = foo(5); // ref-error {{not a constant expression}} \
 283                               // ref-note 2{{in call to}} \
 284                               // ref-error {{does not have a constant initializer}} \
 285                               // ref-note {{required by 'constinit' specifier}} \
 286                               // expected-error  {{is not a constant expression}} \
 287                               // expected-error {{does not have a constant initializer}} \
 288                               // expected-note {{required by 'constinit' specifier}} \
 289
 290 #endif
 291 };
 292
 293 namespace rem {
 294   static_assert(2 % 2 == 0, "");
 295   static_assert(2 % 1 == 0, "");
 296   static_assert(-3 % 4 == -3, "");
 297   static_assert(4 % -2 == 0, "");
 298   static_assert(-3 % -4 == -3, "");
 299
 300   constexpr int zero() { return 0; }
 301   static_assert(10 % zero() == 20, ""); // both-error {{not an integral constant expression}} \
 302                                         // both-note {{division by zero}}
 303
 304   static_assert(true % true == 0, "");
 305   static_assert(false % true == 0, "");
 306   static_assert(true % false == 10, ""); // both-error {{not an integral constant expression}} \
 307                                          // both-note {{division by zero}}
 308   constexpr int x = INT_MIN % - 1; // both-error {{must be initialized by a constant expression}} \
 309                                    // both-note {{value 2147483648 is outside the range}}
 310 };
 311
 312 namespace div {
 313   constexpr int zero() { return 0; }
 314   static_assert(12 / 3 == 4, "");
 315   static_assert(12 / zero() == 12, ""); // both-error {{not an integral constant expression}} \
 316                                         // both-note {{division by zero}}
 317   static_assert(12 / -3 == -4, "");
 318   static_assert(-12 / 3 == -4, "");
 319
 320
 321   constexpr int LHS = 12;
 322   constexpr long unsigned RHS = 3;
 323   static_assert(LHS / RHS == 4, "");
 324
 325   constexpr int x = INT_MIN / - 1; // both-error {{must be initialized by a constant expression}} \
 326                                    // both-note {{value 2147483648 is outside the range}}
 327 };
 328
 329 namespace cond {
 330   constexpr bool isEven(int n) {
 331     return n % 2 == 0 ? true : false;
 332   }
 333   static_assert(isEven(2), "");
 334   static_assert(!isEven(3), "");
 335   static_assert(isEven(100), "");
 336
 337   constexpr int M = 5 ? 10 : 20;
 338   static_assert(M == 10, "");
 339
 340   static_assert(5 ? 13 : 16 == 13, "");
 341   static_assert(0 ? 13 : 16 == 16, "");
 342
 343   static_assert(number ?: -15 == number, "");
 344   static_assert(0 ?: 100 == 100 , "");
 345
 346 #if __cplusplus >= 201402L
 347   constexpr int N = 20;
 348   constexpr int foo() {
 349     int m = N > 0 ? 5 : 10;
 350
 351     return m == 5 ? isEven(m) : true;
 352   }
 353   static_assert(foo() == false, "");
 354
 355   constexpr int dontCallMe(unsigned m) {
 356     if (m == 0) return 0;
 357     return dontCallMe(m - 2);
 358   }
 359
 360   // Can't call this because it will run into infinite recursion.
 361   constexpr int assertNotReached() {
 362     return dontCallMe(3);
 363   }
 364
 365   constexpr int testCond() {
 366     return true ? 5 : assertNotReached();
 367   }
 368
 369   constexpr int testCond2() {
 370     return false ? assertNotReached() : 10;
 371   }
 372
 373   static_assert(testCond() == 5, "");
 374   static_assert(testCond2() == 10, "");
 375
 376 #endif
 377
 378 };
 379
 380 namespace band {
 381   static_assert((10 & 1) == 0, "");
 382   static_assert((10 & 10) == 10, "");
 383
 384   static_assert((1337 & -1) == 1337, "");
 385   static_assert((0 & gimme(12)) == 0, "");
 386 };
 387
 388 namespace bitOr {
 389   static_assert((10 | 1) == 11, "");
 390   static_assert((10 | 10) == 10, "");
 391
 392   static_assert((1337 | -1) == -1, "");
 393   static_assert((0 | gimme(12)) == 12, "");
 394   static_assert((12 | true) == 13, "");
 395 };
 396
 397 namespace bitXor {
 398 #pragma clang diagnostic push
 399 #pragma clang diagnostic ignored "-Wxor-used-as-pow"
 400   static_assert((10 ^ 1) == 11, "");
 401   static_assert((10 ^ 10) == 0, "");
 402
 403   enum {
 404     ONE = 1,
 405   };
 406
 407   static_assert((1337 ^ -1) == -1338, "");
 408   static_assert((0 | gimme(12)) == 12, "");
 409   static_assert((12 ^ true) == 13, "");
 410   static_assert((12 ^ ONE) == 13, "");
 411 #pragma clang diagnostic pop
 412 };
 413
 414 #if __cplusplus >= 201402L
 415 constexpr bool IgnoredUnary() {
 416   bool bo = true;
 417   !bo; // both-warning {{expression result unused}}
 418   return bo;
 419 }
 420 static_assert(IgnoredUnary(), "");
 421 #endif
 422
 423 namespace strings {
 424   constexpr const char *S = "abc";
 425   static_assert(S[0] == 97, "");
 426   static_assert(S[1] == 98, "");
 427   static_assert(S[2] == 99, "");
 428   static_assert(S[3] == 0, "");
 429
 430   static_assert("foobar"[2] == 'o', "");
 431   static_assert(2["foobar"] == 'o', "");
 432
 433   constexpr const wchar_t *wide = L"bar";
 434   static_assert(wide[0] == L'b', "");
 435
 436   constexpr const char32_t *u32 = U"abc";
 437   static_assert(u32[1] == U'b', "");
 438
 439   constexpr char32_t c = U'\U0001F60E';
 440   static_assert(c == 0x0001F60EL, "");
 441
 442   constexpr char k = -1;
 443   static_assert(k == -1, "");
 444
 445   static_assert('\N{LATIN CAPITAL LETTER E}' == 'E', "");
 446   static_assert('\t' == 9, "");
 447
 448 #pragma clang diagnostic push
 449 #pragma clang diagnostic ignored "-Wmultichar"
 450   constexpr int mc = 'abc';
 451   static_assert(mc == 'abc', "");
 452   __WCHAR_TYPE__ wm = L'abc'; // both-error{{wide character literals may not contain multiple characters}}
 453   __WCHAR_TYPE__ wu = u'abc'; // both-error{{Unicode character literals may not contain multiple characters}}
 454   __WCHAR_TYPE__ wU = U'abc'; // both-error{{Unicode character literals may not contain multiple characters}}
 455 #if __cplusplus > 201103L
 456   __WCHAR_TYPE__ wu8 = u8'abc'; // both-error{{Unicode character literals may not contain multiple characters}}
 457 #endif
 458
 459 #pragma clang diagnostic pop
 460
 461   constexpr char foo[12] = "abc";
 462   static_assert(foo[0] == 'a', "");
 463   static_assert(foo[1] == 'b', "");
 464   static_assert(foo[2] == 'c', "");
 465   static_assert(foo[3] == 0, "");
 466   static_assert(foo[11] == 0, "");
 467
 468   constexpr char foo2[] = "abc\0def";
 469   static_assert(foo2[0] == 'a', "");
 470   static_assert(foo2[3] == '\0', "");
 471   static_assert(foo2[6] == 'f', "");
 472   static_assert(foo2[7] == '\0', "");
 473   static_assert(foo2[8] == '\0', ""); // both-error {{not an integral constant expression}} \
 474                                       // both-note {{read of dereferenced one-past-the-end pointer}}
 475
 476   constexpr char foo3[4] = "abc";
 477   static_assert(foo3[3] == '\0', "");
 478   static_assert(foo3[4] == '\0', ""); // both-error {{not an integral constant expression}} \
 479                                       // both-note {{read of dereferenced one-past-the-end pointer}}
 480
 481   constexpr char foo4[2] = "abcd"; // both-error {{initializer-string for char array is too long}}
 482   static_assert(foo4[0] == 'a', "");
 483   static_assert(foo4[1] == 'b', "");
 484   static_assert(foo4[2] == '\0', ""); // both-error {{not an integral constant expression}} \
 485                                       // both-note {{read of dereferenced one-past-the-end pointer}}
 486
 487 constexpr char foo5[12] = "abc\xff";
 488 #if defined(__CHAR_UNSIGNED__) || __CHAR_BIT__ > 8
 489 static_assert(foo5[3] == 255, "");
 490 #else
 491 static_assert(foo5[3] == -1, "");
 492 #endif
 493 };
 494
 495 #if __cplusplus > 201402L
 496 namespace IncDec {
 497   constexpr int zero() {
 498     int a = 0;
 499     a++;
 500     ++a;
 501     a--;
 502     --a;
 503     return a;
 504   }
 505   static_assert(zero() == 0, "");
 506
 507   constexpr int preInc() {
 508     int a = 0;
 509     return ++a;
 510   }
 511   static_assert(preInc() == 1, "");
 512
 513   constexpr int postInc() {
 514     int a = 0;
 515     return a++;
 516   }
 517   static_assert(postInc() == 0, "");
 518
 519   constexpr int preDec() {
 520     int a = 0;
 521     return --a;
 522   }
 523   static_assert(preDec() == -1, "");
 524
 525   constexpr int postDec() {
 526     int a = 0;
 527     return a--;
 528   }
 529   static_assert(postDec() == 0, "");
 530
 531   constexpr int three() {
 532     int a = 0;
 533     return ++a + ++a; // both-warning {{multiple unsequenced modifications to 'a'}}
 534   }
 535   static_assert(three() == 3, "");
 536
 537   constexpr bool incBool() {
 538     bool b = false;
 539     return ++b; // both-error {{ISO C++17 does not allow incrementing expression of type bool}}
 540   }
 541   static_assert(incBool(), "");
 542
 543   /// FIXME: The diagnostics for pre-inc/dec of pointers doesn't match the
 544   /// current interpreter. But they are stil OK.
 545   template<typename T, bool Inc, bool Pre>
 546   constexpr int uninit() {
 547     T a;
 548     if constexpr (Inc) {
 549       if (Pre)
 550         ++a; // ref-note 3{{increment of uninitialized}} \
 551              // expected-note 2{{increment of uninitialized}} \
 552              // expected-note {{read of uninitialized}}
 553       else
 554         a++; // ref-note 2{{increment of uninitialized}} \
 555              // expected-note 2{{increment of uninitialized}}
 556     } else {
 557       if (Pre)
 558         --a; // ref-note 3{{decrement of uninitialized}} \
 559              // expected-note 2{{decrement of uninitialized}} \
 560              // expected-note {{read of uninitialized}}
 561       else
 562         a--; // ref-note 2{{decrement of uninitialized}} \
 563              // expected-note 2{{decrement of uninitialized}}
 564     }
 565     return 1;
 566   }
 567   static_assert(uninit<int, true, true>(), ""); // both-error {{not an integral constant expression}} \
 568                                                 // both-note {{in call to 'uninit<int, true, true>()'}}
 569   static_assert(uninit<int, false, true>(), ""); // both-error {{not an integral constant expression}} \
 570                                                  // both-note {{in call to 'uninit<int, false, true>()'}}
 571
 572   static_assert(uninit<float, true, true>(), ""); // both-error {{not an integral constant expression}} \
 573                                                   // both-note {{in call to 'uninit<float, true, true>()'}}
 574   static_assert(uninit<float, false, true>(), ""); // both-error {{not an integral constant expression}} \
 575                                                    // both-note {{in call to 'uninit<float, false, true>()'}}
 576   static_assert(uninit<float, true, false>(), ""); // both-error {{not an integral constant expression}} \
 577                                                    // both-note {{in call to 'uninit<float, true, false>()'}}
 578   static_assert(uninit<float, false, false>(), ""); // both-error {{not an integral constant expression}} \
 579                                                     // both-note {{in call to 'uninit<float, false, false>()'}}
 580
 581   static_assert(uninit<int*, true, true>(), ""); // both-error {{not an integral constant expression}} \
 582                                                  // both-note {{in call to 'uninit<int *, true, true>()'}}
 583   static_assert(uninit<int*, false, true>(), ""); // both-error {{not an integral constant expression}} \
 584                                                   // both-note {{in call to 'uninit<int *, false, true>()'}}
 585   static_assert(uninit<int*, true, false>(), ""); // both-error {{not an integral constant expression}} \
 586                                                   // both-note {{in call to 'uninit<int *, true, false>()'}}
 587   static_assert(uninit<int*, false, false>(), ""); // both-error {{not an integral constant expression}} \
 588                                                    // both-note {{in call to 'uninit<int *, false, false>()'}}
 589
 590   constexpr int OverFlow() { // both-error {{never produces a constant expression}}
 591     int a = INT_MAX;
 592     ++a; // both-note 2{{is outside the range}}
 593     return -1;
 594   }
 595   static_assert(OverFlow() == -1, "");  // both-error {{not an integral constant expression}} \
 596                                         // both-note {{in call to 'OverFlow()'}}
 597
 598   constexpr int UnderFlow() { // both-error {{never produces a constant expression}}
 599     int a = INT_MIN;
 600     --a; // both-note 2{{is outside the range}}
 601     return -1;
 602   }
 603   static_assert(UnderFlow() == -1, "");  // both-error {{not an integral constant expression}} \
 604                                          // both-note {{in call to 'UnderFlow()'}}
 605
 606   constexpr int getTwo() {
 607     int i = 1;
 608     return (i += 1);
 609   }
 610   static_assert(getTwo() == 2, "");
 611
 612   constexpr int sub(int a) {
 613     return (a -= 2);
 614   }
 615   static_assert(sub(7) == 5, "");
 616
 617   constexpr int add(int a, int b) {
 618     a += b; // both-note {{is outside the range of representable values}}
 619     return a;
 620   }
 621   static_assert(add(1, 2) == 3, "");
 622   static_assert(add(INT_MAX, 1) == 0, ""); // both-error {{not an integral constant expression}} \
 623                                            // both-note {{in call to 'add}}
 624
 625   constexpr int sub(int a, int b) {
 626     a -= b; // both-note {{is outside the range of representable values}}
 627     return a;
 628   }
 629   static_assert(sub(10, 20) == -10, "");
 630   static_assert(sub(INT_MIN, 1) == 0, ""); // both-error {{not an integral constant expression}} \
 631                                            // both-note {{in call to 'sub}}
 632
 633   constexpr int subAll(int a) {
 634     return (a -= a);
 635   }
 636   static_assert(subAll(213) == 0, "");
 637
 638   constexpr bool BoolOr(bool b1, bool b2) {
 639     bool a;
 640     a = b1;
 641     a |= b2;
 642     return a;
 643   }
 644   static_assert(BoolOr(true, true), "");
 645   static_assert(BoolOr(true, false), "");
 646   static_assert(BoolOr(false, true), "");
 647   static_assert(!BoolOr(false, false), "");
 648
 649   constexpr int IntOr(unsigned a, unsigned b) {
 650     unsigned r;
 651     r = a;
 652     r |= b;
 653     return r;
 654   }
 655   static_assert(IntOr(10, 1) == 11, "");
 656   static_assert(IntOr(1337, -1) == -1, "");
 657   static_assert(IntOr(0, 12) == 12, "");
 658
 659   constexpr bool BoolAnd(bool b1, bool b2) {
 660     bool a;
 661     a = b1;
 662     a &= b2;
 663     return a;
 664   }
 665   static_assert(BoolAnd(true, true), "");
 666   static_assert(!BoolAnd(true, false), "");
 667   static_assert(!BoolAnd(false, true), "");
 668   static_assert(!BoolAnd(false, false), "");
 669
 670   constexpr int IntAnd(unsigned a, unsigned b) {
 671     unsigned r;
 672     r = a;
 673     r &= b;
 674     return r;
 675   }
 676   static_assert(IntAnd(10, 1) == 0, "");
 677   static_assert(IntAnd(1337, -1) == 1337, "");
 678   static_assert(IntAnd(0, 12) == 0, "");
 679
 680   constexpr bool BoolXor(bool b1, bool b2) {
 681     bool a;
 682     a = b1;
 683     a ^= b2;
 684     return a;
 685   }
 686   static_assert(!BoolXor(true, true), "");
 687   static_assert(BoolXor(true, false), "");
 688   static_assert(BoolXor(false, true), "");
 689   static_assert(!BoolXor(false, false), "");
 690
 691   constexpr int IntXor(unsigned a, unsigned b) {
 692     unsigned r;
 693     r = a;
 694     r ^= b;
 695     return r;
 696   }
 697   static_assert(IntXor(10, 1) == 11, "");
 698   static_assert(IntXor(10, 10) == 0, "");
 699   static_assert(IntXor(12, true) == 13, "");
 700
 701   constexpr bool BoolRem(bool b1, bool b2) {
 702     bool a;
 703     a = b1;
 704     a %= b2;
 705     return a;
 706   }
 707   static_assert(!BoolRem(true, true), "");
 708   static_assert(!BoolRem(false, true), "");
 709
 710   constexpr int IntRem(int a, int b) {
 711     int r;
 712     r = a;
 713     r %= b; // both-note {{division by zero}} \
 714             // both-note {{outside the range of representable values}}
 715     return r;
 716   }
 717   static_assert(IntRem(2, 2) == 0, "");
 718   static_assert(IntRem(2, 1) == 0, "");
 719   static_assert(IntRem(9, 7) == 2, "");
 720   static_assert(IntRem(5, 0) == 0, ""); // both-error {{not an integral constant expression}} \
 721                                         // both-note {{in call to 'IntRem(5, 0)'}}
 722
 723   static_assert(IntRem(INT_MIN, -1) == 0, ""); // both-error {{not an integral constant expression}} \
 724                                                // both-note {{in call to 'IntRem}}
 725
 726   constexpr bool BoolDiv(bool b1, bool b2) {
 727     bool a;
 728     a = b1;
 729     a /= b2;
 730     return a;
 731   }
 732   static_assert(BoolDiv(true, true), "");
 733   static_assert(!BoolDiv(false, true), "");
 734
 735   constexpr int IntDiv(int a, int b) {
 736     int r;
 737     r = a;
 738     r /= b; // both-note {{division by zero}} \
 739             // both-note {{outside the range of representable values}}
 740     return r;
 741   }
 742   static_assert(IntDiv(2, 2) == 1, "");
 743   static_assert(IntDiv(12, 20) == 0, "");
 744   static_assert(IntDiv(2, 1) == 2, "");
 745   static_assert(IntDiv(9, 7) == 1, "");
 746   static_assert(IntDiv(5, 0) == 0, ""); // both-error {{not an integral constant expression}} \
 747                                         // both-note {{in call to 'IntDiv(5, 0)'}}
 748
 749   static_assert(IntDiv(INT_MIN, -1) == 0, ""); // both-error {{not an integral constant expression}} \
 750                                                // both-note {{in call to 'IntDiv}}
 751
 752   constexpr bool BoolMul(bool b1, bool b2) {
 753     bool a;
 754     a = b1;
 755     a *= b2;
 756     return a;
 757   }
 758   static_assert(BoolMul(true, true), "");
 759   static_assert(!BoolMul(true, false), "");
 760   static_assert(!BoolMul(false, true), "");
 761   static_assert(!BoolMul(false, false), "");
 762
 763   constexpr int IntMul(int a, int b) {
 764     int r;
 765     r = a;
 766     r *= b; // both-note {{is outside the range of representable values of type 'int'}}
 767     return r;
 768   }
 769   static_assert(IntMul(2, 2) == 4, "");
 770   static_assert(IntMul(12, 20) == 240, "");
 771   static_assert(IntMul(2, 1) == 2, "");
 772   static_assert(IntMul(9, 7) == 63, "");
 773   static_assert(IntMul(INT_MAX, 2) == 0, ""); // both-error {{not an integral constant expression}} \
 774                                               // both-note {{in call to 'IntMul}}
 775   constexpr int arr[] = {1,2,3};
 776   constexpr int ptrInc1() {
 777     const int *p = arr;
 778     p += 2;
 779     return *p;
 780   }
 781   static_assert(ptrInc1() == 3, "");
 782
 783   constexpr int ptrInc2() {
 784     const int *p = arr;
 785     return *(p += 1);
 786   }
 787   static_assert(ptrInc2() == 2, "");
 788
 789   constexpr int ptrInc3() { // both-error {{never produces a constant expression}}
 790     const int *p = arr;
 791     p += 12; // both-note {{cannot refer to element 12 of array of 3 elements}}
 792     return *p;
 793   }
 794
 795   constexpr int ptrIncDec1() {
 796     const int *p = arr;
 797     p += 2;
 798     p -= 1;
 799     return *p;
 800   }
 801   static_assert(ptrIncDec1() == 2, "");
 802
 803   constexpr int ptrDec1() { // both-error {{never produces a constant expression}}
 804     const int *p = arr;
 805     p -= 1;  // both-note {{cannot refer to element -1 of array of 3 elements}}
 806     return *p;
 807   }
 808
 809   /// This used to leave a 0 on the stack instead of the previous
 810   /// value of a.
 811   constexpr int bug1Inc() {
 812     int a = 3;
 813     int b = a++;
 814     return b;
 815   }
 816   static_assert(bug1Inc() == 3);
 817
 818   constexpr int bug1Dec() {
 819     int a = 3;
 820     int b = a--;
 821     return b;
 822   }
 823   static_assert(bug1Dec() == 3);
 824
 825   constexpr int f() {
 826     int a[] = {1,2};
 827     int i = 0;
 828
 829     // RHS should be evaluated before LHS, so this should
 830     // write to a[1];
 831     a[i++] += ++i;
 832
 833     return a[1];
 834   }
 835   static_assert(f() == 3, "");
 836
 837   int nonconst(int a) { // both-note 4{{declared here}}
 838     static_assert(a++, ""); // both-error {{not an integral constant expression}} \
 839                             // both-note {{function parameter 'a' with unknown value cannot be used in a constant expression}}
 840     static_assert(a--, ""); // both-error {{not an integral constant expression}} \
 841                             // both-note {{function parameter 'a' with unknown value cannot be used in a constant expression}}
 842     static_assert(++a, ""); // both-error {{not an integral constant expression}} \
 843                             // both-note {{function parameter 'a' with unknown value cannot be used in a constant expression}}
 844     static_assert(--a, ""); // both-error {{not an integral constant expression}} \
 845                             // both-note {{function parameter 'a' with unknown value cannot be used in a constant expression}}
 846   }
 847
 848 };
 849 #endif
 850
 851 namespace CompoundLiterals {
 852   constexpr int get5() {
 853     return (int[]){1,2,3,4,5}[4];
 854   }
 855   static_assert(get5() == 5, "");
 856
 857   constexpr int get6(int f = (int[]){1,2,6}[2]) { // ref-note {{subexpression not valid in a constant expression}} \
 858                                                   // ref-note {{declared here}}
 859     return f;
 860   }
 861   static_assert(get6(6) == 6, "");
 862   // FIXME: Who's right here?
 863   static_assert(get6() == 6, ""); // ref-error {{not an integral constant expression}}
 864
 865   constexpr int x = (int){3};
 866   static_assert(x == 3, "");
 867 #if __cplusplus >= 201402L
 868   constexpr int getX() {
 869     int x = (int){3};
 870     x = (int){5};
 871     return x;
 872   }
 873   static_assert(getX() == 5, "");
 874 #endif
 875
 876 #if __cplusplus >= 202002L
 877   constexpr int get3() {
 878     int m;
 879     m = (int){3};
 880     return m;
 881   }
 882   static_assert(get3() == 3, "");
 883 #endif
 884 };
 885
 886 namespace TypeTraits {
 887   static_assert(__is_trivial(int), "");
 888   static_assert(__is_trivial(float), "");
 889   static_assert(__is_trivial(E), "");
 890   struct S{};
 891   static_assert(__is_trivial(S), "");
 892   struct S2 {
 893     S2() {}
 894   };
 895   static_assert(!__is_trivial(S2), "");
 896
 897   template <typename T>
 898   struct S3 {
 899     constexpr bool foo() const { return __is_trivial(T); }
 900   };
 901   struct T {
 902     ~T() {}
 903   };
 904   struct U {};
 905   static_assert(S3<U>{}.foo(), "");
 906   static_assert(!S3<T>{}.foo(), "");
 907
 908   typedef int Int;
 909   typedef Int IntAr[10];
 910   typedef const IntAr ConstIntAr;
 911   typedef ConstIntAr ConstIntArAr[4];
 912
 913   static_assert(__array_rank(IntAr) == 1, "");
 914   static_assert(__array_rank(ConstIntArAr) == 2, "");
 915
 916   static_assert(__array_extent(IntAr, 0) == 10, "");
 917   static_assert(__array_extent(ConstIntArAr, 0) == 4, "");
 918   static_assert(__array_extent(ConstIntArAr, 1) == 10, "");
 919 }
 920
 921 #if __cplusplus >= 201402L
 922 constexpr int ignoredDecls() {
 923   static_assert(true, "");
 924   struct F { int a; };
 925   enum E { b };
 926   using A = int;
 927   typedef int Z;
 928
 929   return F{12}.a;
 930 }
 931 static_assert(ignoredDecls() == 12, "");
 932
 933 namespace DiscardExprs {
 934 #pragma clang diagnostic push
 935 #pragma clang diagnostic ignored "-Wunused-value"
 936   typedef struct _GUID {
 937     __UINT32_TYPE__ Data1;
 938     __UINT16_TYPE__ Data2;
 939     __UINT16_TYPE__ Data3;
 940     __UINT8_TYPE__ Data4[8];
 941   } GUID;
 942   class __declspec(uuid("000000A0-0000-0000-C000-000000000049")) GuidType;
 943
 944   struct A{ int a; };
 945   constexpr int ignoredExprs() {
 946     (void)(1 / 2);
 947     A a{12};
 948     a;
 949     (void)a;
 950     (a);
 951
 952     /// Ignored MaterializeTemporaryExpr.
 953     struct B{ const int &a; };
 954     (void)B{12};
 955
 956     (void)5, (void)6;
 957
 958     1 ? 0 : 1;
 959     __is_trivial(int);
 960
 961     (int){1};
 962     (int[]){1,2,3};
 963     int arr[] = {1,2,3};
 964     arr[0];
 965     "a";
 966     'b';
 967     sizeof(int);
 968     alignof(int);
 969
 970     (short)5;
 971     (bool)1;
 972     __null;
 973     __builtin_offsetof(A, a);
 974     1,2;
 975     (int)1.0;
 976     (float)1;
 977     (double)1.0f;
 978     (signed)4u;
 979     __uuidof(GuidType);
 980     __uuidof(number); // both-error {{cannot call operator __uuidof on a type with no GUID}}
 981
 982     requires{false;};
 983
 984     return 0;
 985   }
 986   static_assert(ignoredExprs() == 0, "");
 987
 988   constexpr int oh_my(int x) {
 989     (int){ x++ };
 990     return x;
 991   }
 992   static_assert(oh_my(0) == 1, "");
 993
 994   constexpr int oh_my2(int x) {
 995     int y{x++};
 996     return x;
 997   }
 998
 999   static_assert(oh_my2(0) == 1, "");
1000
1001
1002   /// Ignored comma expressions still have their
1003   /// expressions evaluated.
1004   constexpr int Comma(int start) {
1005       int i = start;
1006
1007       (void)i++;
1008       (void)i++,(void)i++;
1009       return i;
1010   }
1011   constexpr int Value = Comma(5);
1012   static_assert(Value == 8, "");
1013
1014   /// Ignored MemberExprs need to still evaluate the Base
1015   /// expr.
1016   constexpr A callme(int &i) {
1017     ++i;
1018     return A{};
1019   }
1020   constexpr int ignoredMemberExpr() {
1021     int i = 0;
1022     callme(i).a;
1023     return i;
1024   }
1025   static_assert(ignoredMemberExpr() == 1, "");
1026
1027   template <int I>
1028   constexpr int foo() {
1029     I;
1030     return I;
1031   }
1032   static_assert(foo<3>() == 3, "");
1033
1034   struct ATemp {
1035     consteval ATemp ret_a() const { return ATemp{}; }
1036   };
1037
1038   void test() {
1039     int k = (ATemp().ret_a(), 0);
1040   }
1041
1042 #pragma clang diagnostic pop
1043 }
1044 #endif
1045
1046 namespace PredefinedExprs {
1047 #if __cplusplus >= 201402L
1048   template<typename CharT>
1049   constexpr bool strings_match(const CharT *str1, const CharT *str2) {
1050     while (*str1 && *str2) {
1051       if (*str1++ != *str2++)
1052         return false;
1053     };
1054
1055     return *str1 == *str2;
1056   }
1057
1058   void foo() {
1059     static_assert(strings_match(__FUNCSIG__, "void __cdecl PredefinedExprs::foo(void)"), "");
1060     static_assert(strings_match(L__FUNCSIG__, L"void __cdecl PredefinedExprs::foo(void)"), "");
1061     static_assert(strings_match(L__FUNCTION__, L"foo"), "");
1062     static_assert(strings_match(__FUNCTION__, "foo"), "");
1063     static_assert(strings_match(__func__, "foo"), "");
1064     static_assert(strings_match(__PRETTY_FUNCTION__, "void PredefinedExprs::foo()"), "");
1065   }
1066
1067   constexpr char heh(unsigned index) {
1068     __FUNCTION__;               // both-warning {{result unused}}
1069     __extension__ __FUNCTION__; // both-warning {{result unused}}
1070     return __FUNCTION__[index];
1071   }
1072   static_assert(heh(0) == 'h', "");
1073   static_assert(heh(1) == 'e', "");
1074   static_assert(heh(2) == 'h', "");
1075 #endif
1076 }
1077
1078 namespace NE {
1079   constexpr int foo() noexcept {
1080     return 1;
1081   }
1082   static_assert(noexcept(foo()), "");
1083   constexpr int foo2() {
1084     return 1;
1085   }
1086   static_assert(!noexcept(foo2()), "");
1087
1088 #if __cplusplus > 201402L
1089   constexpr int a() {
1090     int b = 0;
1091     (void)noexcept(++b); // both-warning {{expression with side effects has no effect in an unevaluated context}}
1092
1093     return b;
1094   }
1095   static_assert(a() == 0, "");
1096 #endif
1097 }
1098
1099 namespace PointerCasts {
1100   constexpr int M = 10;
1101   constexpr const int *P = &M;
1102   constexpr intptr_t A = (intptr_t)P; // both-error {{must be initialized by a constant expression}} \
1103                                       // both-note {{cast that performs the conversions of a reinterpret_cast}}
1104
1105   int array[(intptr_t)(char*)0]; // both-warning {{variable length array folded to constant array}}
1106 }
1107
1108 namespace InvalidDeclRefs {
1109   bool b00; // both-note {{declared here}}
1110   static_assert(b00, ""); // both-error {{not an integral constant expression}} \
1111                           // both-note {{read of non-const variable}}
1112
1113   float b01; // both-note {{declared here}}
1114   static_assert(b01, ""); // both-error {{not an integral constant expression}} \
1115                           // both-note {{read of non-constexpr variable}}
1116
1117   extern const int b02; // both-note {{declared here}}
1118   static_assert(b02, ""); // both-error {{not an integral constant expression}} \
1119                           // both-note {{initializer of 'b02' is unknown}}
1120
1121   int b03 = 3; // both-note {{declared here}}
1122   static_assert(b03, ""); // both-error {{not an integral constant expression}} \
1123                           // both-note {{read of non-const variable}}
1124
1125   extern int var;
1126   constexpr int *varp = &var; // Ok.
1127 }
1128
1129 namespace NonConstReads {
1130   void *p = nullptr; // both-note {{declared here}}
1131   static_assert(!p, ""); // both-error {{not an integral constant expression}} \
1132                          // both-note {{read of non-constexpr variable 'p'}}
1133
1134   int arr[!p]; // both-error {{variable length array}}
1135
1136   int z; // both-note {{declared here}}
1137   static_assert(z == 0, ""); // both-error {{not an integral constant expression}} \
1138                              // both-note {{read of non-const variable 'z'}}
1139 }
1140
1141 /// This test passes a MaterializedTemporaryExpr to evaluateAsRValue.
1142 /// That needs to return a null pointer after the lvalue-to-rvalue conversion.
1143 /// We used to fail to do that.
1144 namespace rdar8769025 {
1145   __attribute__((nonnull)) void f1(int * const &p);
1146   void test_f1() {
1147     f1(0); // both-warning{{null passed to a callee that requires a non-null argument}}
1148   }
1149 }
1150
1151 namespace nullptrsub {
1152   void a() {
1153     char *f = (char *)0;
1154     f = (char *)((char *)0 - (char *)0);
1155   }
1156 }
1157
1158 namespace incdecbool {
1159 #if __cplusplus >= 201402L
1160   constexpr bool incb(bool c) {
1161     if (!c)
1162       ++c;
1163     else {++c; c++; }
1164 #if __cplusplus >= 202002L
1165     // both-error@-3 {{ISO C++17 does not allow incrementing expression of type bool}}
1166     // both-error@-3 2{{ISO C++17 does not allow incrementing expression of type bool}}
1167 #else
1168     // both-warning@-6 {{incrementing expression of type bool is deprecated and incompatible with C++17}}
1169 #endif
1170     return c;
1171   }
1172   static_assert(incb(false), "");
1173   static_assert(incb(true), "");
1174   static_assert(incb(true) == 1, "");
1175 #endif
1176
1177
1178 #if __cplusplus == 201103L
1179   constexpr bool foo() { // both-error {{never produces a constant expression}}
1180     bool b = true; // both-warning {{variable declaration in a constexpr function is a C++14 extension}}
1181     b++; // both-warning {{incrementing expression of type bool is deprecated and incompatible with C++17}} \
1182          // both-warning {{use of this statement in a constexpr function is a C++14 extension}} \
1183          // both-note 2{{subexpression not valid in a constant expression}}
1184
1185     return b;
1186   }
1187   static_assert(foo() == 1, ""); // both-error {{not an integral constant expression}} \
1188                                  // both-note {{in call to}}
1189 #endif
1190
1191
1192
1193 }
1194
1195 #if __cplusplus >= 201402L
1196 constexpr int externvar1() { // both-error {{never produces a constant expression}}
1197   extern char arr[]; // both-note {{declared here}}
1198    return arr[0]; // both-note {{read of non-constexpr variable 'arr'}}
1199 }
1200 namespace externarr {
1201   extern int arr[];
1202   constexpr int *externarrindex = &arr[0]; /// No diagnostic.
1203 }
1204
1205
1206 namespace StmtExprs {
1207   constexpr int foo() {
1208      ({
1209        int i;
1210        for (i = 0; i < 76; i++) {}
1211        i; // both-warning {{expression result unused}}
1212     });
1213     return 76;
1214   }
1215   static_assert(foo() == 76, "");
1216
1217   namespace CrossFuncLabelDiff {
1218     constexpr long a(bool x) { return x ? 0 : (intptr_t)&&lbl + (0 && ({lbl: 0;})); }
1219   }
1220 }
1221 #endif
1222
1223 namespace Extern {
1224   constexpr extern char Oops = 1;
1225   static_assert(Oops == 1, "");
1226
1227 #if __cplusplus >= 201402L
1228   struct NonLiteral {
1229     NonLiteral() {}
1230   };
1231   NonLiteral nl;
1232   constexpr NonLiteral &ExternNonLiteralVarDecl() {
1233     extern NonLiteral nl;
1234     return nl;
1235   }
1236   static_assert(&ExternNonLiteralVarDecl() == &nl, "");
1237 #endif
1238
1239   struct A {
1240     int b;
1241   };
1242
1243   extern constexpr A a{12};
1244   static_assert(a.b == 12, "");
1245 }
1246
1247 #if __cplusplus >= 201402L
1248 constexpr int StmtExprEval() {
1249   if (({
1250     while (0);
1251     true;
1252   })) {
1253     return 2;
1254   }
1255   return 1;
1256 }
1257 static_assert(StmtExprEval() == 2, "");
1258
1259 constexpr int ReturnInStmtExpr() { // both-error {{never produces a constant expression}}
1260   return ({
1261       return 1; // both-note 2{{this use of statement expressions is not supported in a constant expression}}
1262       2;
1263       });
1264 }
1265 static_assert(ReturnInStmtExpr() == 1, ""); // both-error {{not an integral constant expression}} \
1266                                             // both-note {{in call to}}
1267
1268 #endif
1269
1270 namespace ComparisonAgainstOnePastEnd {
1271   int a, b;
1272   static_assert(&a + 1 == &b, ""); // both-error {{not an integral constant expression}} \
1273                                    // both-note {{comparison against pointer '&a + 1' that points past the end of a complete object has unspecified value}}
1274   static_assert(&a == &b + 1, ""); // both-error {{not an integral constant expression}} \
1275                                    // both-note {{comparison against pointer '&b + 1' that points past the end of a complete object has unspecified value}}
1276
1277   static_assert(&a + 1 == &b + 1, ""); // both-error {{static assertion failed}}
1278 };
1279
1280 namespace NTTP {
1281   template <typename _Tp, unsigned _Nm>
1282     constexpr unsigned
1283     size(const _Tp (&)[_Nm]) noexcept
1284     { return _Nm; }
1285
1286   template <char C>
1287   static int write_padding() {
1288     static const char Chars[] = {C};
1289
1290     return size(Chars);
1291   }
1292 }
1293
1294 #if __cplusplus >= 201402L
1295 namespace UnaryOpError {
1296   constexpr int foo() {
1297     int f = 0;
1298     ++g; // both-error {{use of undeclared identifier 'g'}}
1299     return f;
1300   }
1301 }
1302 #endif
1303
1304 namespace VolatileReads {
1305   const volatile int b = 1;
1306   static_assert(b, ""); // both-error {{not an integral constant expression}} \
1307                         // both-note {{read of volatile-qualified type 'const volatile int' is not allowed in a constant expression}}
1308 }
1309 #if __cplusplus >= 201703L
1310 namespace {
1311   struct C {
1312     int x;
1313   };
1314
1315   template <const C *p> void f() {
1316     const auto &[c] = *p;
1317     &c; // both-warning {{expression result unused}}
1318   }
1319 }
1320 #endif