Lines Matching full:constant
6 static_assert(++x, "test"); // expected-error {{not an integral constant expression}}
110 constexpr int &Recurse3 = Recurse2; // expected-error {{must be initialized by a constant expression}} expected-note {{initializer of 'Recurse2' is not a constant expression}}
115 constexpr int RecurseC = RecurseB; // expected-error {{must be initialized by a constant expression}} expected-note {{initializer of 'RecurseB' is not a constant expression}}
151 static_assert(F(4, k) == 3, ""); // expected-error {{constant expression}} expected-note {{read of non-const variable 'k'}}
203 constexpr int a = MaybeReturnJunk(true, 0); // expected-error {{constant expression}} expected-note {{read of variable whose lifetime has ended}}
214 constexpr int n3 = InternalReturnJunk(0); // expected-error {{must be initialized by a constant expression}} expected-note {{in call to 'InternalReturnJunk(0)'}}
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)'}}
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}}
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}}
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}}
300 constexpr bool dyncast = sptr == dynamic_cast<S*>(sptr); // expected-error {{constant expression}} expected-note {{dynamic_cast}}
305 expected-warning {{not an integral constant expression}} \
306 expected-note {{dynamic_cast is not allowed in a constant expression}}
308 expected-warning {{not an integral constant expression}} \
309 expected-note {{reinterpret_cast is not allowed in a constant expression}}
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}}
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}}
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}}
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}}
323 expected-warning {{not an integral constant expression}} \
324 expected-note {{cast from 'void *' is not allowed in a constant expression}}
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}}
352 static_assert(&b1.a1.r != &b1.a2.r, ""); // expected-error {{constant expression}} expected-note {{outside the expression that created the temporary}}
356 static_assert(&b1.a1 != &b2.a1, ""); // expected-error {{constant expression}} expected-note {{outside the expression that created the temporary}}
358 constexpr thread_local B b3 { { 1 }, { 2 } }; // expected-error {{constant expression}} expected-note {{reference to temporary}} expected-note {{here}}
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}}
369 constexpr B b5 = B{ {0}, {0} }; // expected-error {{constant expression}} expected-note {{reference to temporary}} expected-note {{here}}
372 // Proposed DR: for a reference constant expression to refer to a static
374 // by a constant expression (a core constant expression is not enough).
378 constexpr B b = { A(A{0}) }; // expected-error {{constant expression}} expected-note {{reference to temporary}} expected-note {{here}}
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}}
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}}
448 static_assert(t.c[6] == 0, ""); // expected-error {{constant expression}} expected-note {{one-past-the-end}}
472 static_assert(f[6] == 0, ""); // expected-error {{constant expression}} expected-note {{one-past-the-end}}
507 expected-error {{constant expression}} \
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}}
515 constexpr int xs_1 = p[-4]; // expected-error {{constant expression}} expected-note {{cannot refer to element -1}}
520 static_assert(zs[0][0][0][2] == 3, ""); // expected-error {{constant expression}} expected-note {{read of dereferenced one-past-the-end pointer}}
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}}
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}}
531 expected-error {{static_assert expression is not an integral constant expression}} \
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.
650 static_assert(g.t.u1.a == 42, ""); // expected-error {{constant expression}} expected-note {{read of member 'a' of union with active member 'b'}}
653 static_assert(g.t.u2.d == 42, ""); // expected-error {{constant expression}} expected-note {{read of member 'd' of union with active member 'c'}}
697 static_assert(agg1.arr[-1] == 0, ""); // expected-error {{constant expression}} expected-note {{cannot refer to element -1}}
700 static_assert(agg1.arr[5] == 0, ""); // expected-error {{constant expression}} expected-note {{read of dereferenced one-past-the-end}}
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'}}
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'}}
777 // Core issue 903: we do not perform constant evaluation when checking for a
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()'}}
874 static_assert(u[0].b, ""); // expected-error {{constant expression}} expected-note {{read of member 'b' of union with active member 'a'}}
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}}
890 static_assert(y.b == 42, ""); // expected-error {{constant expression}} expected-note {{'b' of union with active member 'a'}}
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}}
972 constexpr int *pbad = &(t17.*deepm); // expected-error {{constant expression}}
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>'}}
982 constexpr int *pbad2 = &(p17_13->*(int(T<9>::*))deepm); // expected-error {{constant expression}}
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'}}
1029 constexpr Derived *err_pd4 = (Derived*)pb4; // expected-error {{constant expression}} expected-note {{cannot access derived class of pointer past the end}}
1039 constexpr int err_pd10n = pd10->n; // expected-error {{constant expression}} expected-note {{cannot access base class of pointer past the end}}
1041 constexpr int err_pdminus1n = pd10[-11].n; // expected-error {{constant expression}} expected-note {{cannot refer to element -1 of}}
1113 static_assert(B().x == 3, ""); // expected-error {{constant expression}} expected-note {{non-literal type 'PR11595::B' cannot be used in a constant expression}}
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}}
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'}}
1144 return const_cast<int&>(r); // expected-note {{read of volatile temporary is not allowed in a constant expression}}
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}}
1181 static_assert(t2p[-1] == 0.0, ""); // expected-error {{constant expr}} expected-note {{cannot refer to element -1 of array of 2 elements}}
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}}
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}}
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}}
1198 // _Atomic(T) is exactly like T for the purposes of constant expression
1237 // useless note and instead just point to the non-constant subexpression.
1240 en = n, // expected-error {{not a constant expression}}
1242 n // expected-error {{not a constant expression}}
1244 eq = reinterpret_cast<int>((int*)0) // expected-error {{not a constant expression}} expected-note {{reinterpret_cast}}
1275 static_assert(s1.c == 0, ""); // expected-error {{constant expression}} expected-note {{union with active member}}
1278 static_assert(s1.f == 0, ""); // expected-error {{constant expression}} expected-note {{union with active member}}
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}}
1284 static_assert(s2.e == 0, ""); // expected-error {{constant expression}} expected-note {{union with active member}}
1288 // DR1405: don't allow reading mutable members in constant expressions.
1293 constexpr int mmn = mm.n; // expected-error {{constant expression}} expected-note {{read of mutable member 'n' is not allowed in a constant expression}}
1295 constexpr int mmn2 = mm.n; // expected-error {{constant expression}} expected-note {{read of mutable member 'n' is not allowed in a constant expression}}
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}}
1309 constexpr int k = c[1].b.a.n; // expected-error {{constant expression}} expected-note {{mutable}}
1314 // This macro forces its argument to be constant-folded, even if it's not
1315 // otherwise a constant expression.
1318 constexpr int n = (int)(char*)123; // expected-error {{constant expression}} expected-note {{reinterpret_cast}}
1347 constexpr const int l = k; // expected-error {{constant expression}} expected-note {{read of temporary}}
1352 constexpr const int &i = 1; // expected-error {{constant expression}} expected-note 2{{temporary}}
1386 sizeof(arr) // expected-error {{constant expression}}
1396 // pointer to it. This is OK: we're not required to treat this as a constant
1398 constexpr int *p = (int*)(int[1]){0}; // expected-warning {{C99}} expected-error {{constant expression}} expected-note 2{{temporary}}
1516 constexpr int *p = &n; // expected-error{{constexpr variable 'p' must be initialized by a constant expression}}
1519 constexpr int *q = f(); // expected-error{{constexpr variable 'q' must be initialized by a constant expression}}
1540 static_assert(get(arr, 0) == 4, ""); // expected-error{{not an integral constant expression}} \
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}}
1571 // this would be a constant expression. For now, we generate a move
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}}
1609 constexpr int k = error(); // expected-error {{must be initialized by a constant expression}}
1666 constexpr int h() { // expected-error {{never produces a constant}}
1690 static_assert(p->f() == sizeof(X<S1>), ""); // expected-error {{constant expression}} expected-note {{virtual function call}}
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}}
1728 constexpr int k2 = S(0).t; // expected-error {{constant expression}} expected-note {{in call}}
