// RUN: %clang_cc1 -std=c++2a -emit-llvm-only -Wno-unused-value -Wno-vla %s -verify
typedef __SIZE_TYPE__ size_t;
namespace basic_sema {
consteval int f1(int i) {
return i;
}
consteval constexpr int f2(int i) {
//expected-error@-1 {{cannot combine}}
return i;
}
constexpr auto l_eval = [](int i) consteval {
// expected-note@-1+ {{declared here}}
return i;
};
constexpr consteval int f3(int i) {
//expected-error@-1 {{cannot combine}}
return i;
}
struct A {
consteval int f1(int i) const {
// expected-note@-1 {{declared here}}
return i;
}
consteval A(int i);
consteval A() = default;
consteval ~A() = default; // expected-error {{destructor cannot be declared consteval}}
};
consteval struct B {}; // expected-error {{struct cannot be marked consteval}}
consteval typedef B b; // expected-error {{typedef cannot be consteval}}
consteval int redecl() {return 0;} // expected-note {{previous declaration is here}}
constexpr int redecl() {return 0;} // expected-error {{constexpr declaration of 'redecl' follows consteval declaration}}
consteval int i = 0; // expected-error {{consteval can only be used in function declarations}}
consteval int; // expected-error {{consteval can only be used in function declarations}}
consteval int f1() {} // expected-error {{no return statement in consteval function}}
struct C {
C() {}
~C() {}
};
struct D {
C c;
consteval D() = default; // expected-error {{cannot be marked consteval}}
consteval ~D() = default; // expected-error {{destructor cannot be declared consteval}}
};
struct E : C {
consteval ~E() {} // expected-error {{cannot be declared consteval}}
};
}
consteval int main() { // expected-error {{'main' is not allowed to be declared consteval}}
return 0;
}
consteval int f_eval(int i) {
// expected-note@-1+ {{declared here}}
return i;
}
namespace taking_address {
using func_type = int(int);
func_type* p1 = (&f_eval);
// expected-error@-1 {{take address}}
func_type* p7 = __builtin_addressof(f_eval);
// expected-error@-1 {{take address}}
auto p = f_eval;
// expected-error@-1 {{take address}}
auto m1 = &basic_sema::A::f1;
// expected-error@-1 {{take address}}
auto l1 = &decltype(basic_sema::l_eval)::operator();
// expected-error@-1 {{take address}}
consteval int f(int i) {
// expected-note@-1+ {{declared here}}
return i;
}
auto ptr = &f;
// expected-error@-1 {{take address}}
auto f1() {
return &f;
// expected-error@-1 {{take address}}
}
}
namespace invalid_function {
struct A {
consteval void *operator new(size_t count);
// expected-error@-1 {{'operator new' cannot be declared consteval}}
consteval void *operator new[](size_t count);
// expected-error@-1 {{'operator new[]' cannot be declared consteval}}
consteval void operator delete(void* ptr);
// expected-error@-1 {{'operator delete' cannot be declared consteval}}
consteval void operator delete[](void* ptr);
// expected-error@-1 {{'operator delete[]' cannot be declared consteval}}
consteval ~A() {}
// expected-error@-1 {{destructor cannot be declared consteval}}
};
}
namespace nested {
consteval int f() {
return 0;
}
consteval int f1(...) {
return 1;
}
enum E {};
using T = int(&)();
consteval auto operator+ (E, int(*a)()) {
return 0;
}
void d() {
auto i = f1(E() + &f);
}
auto l0 = [](auto) consteval {
return 0;
};
int i0 = l0(&f1);
int i1 = f1(l0(4));
int i2 = f1(&f1, &f1, &f1, &f1, &f1, &f1, &f1);
int i3 = f1(f1(f1(&f1, &f1), f1(&f1, &f1), f1(f1(&f1, &f1), &f1)));
}
namespace user_defined_literal {
consteval int operator""_test(unsigned long long i) {
// expected-note@-1+ {{declared here}}
return 0;
}
int i = 0_test;
auto ptr = &operator""_test;
// expected-error@-1 {{take address}}
consteval auto operator""_test1(unsigned long long i) {
return &f_eval;
}
auto i1 = 0_test1; // expected-error {{is not a constant expression}}
// expected-note@-1 {{is not a constant expression}}
}
namespace return_address {
consteval int f() {
// expected-note@-1 {{declared here}}
return 0;
}
consteval int(*ret1(int i))() {
return &f;
}
auto ptr = ret1(0);
// expected-error@-1 {{is not a constant expression}}
// expected-note@-2 {{pointer to a consteval}}
struct A {
consteval int f(int) {
// expected-note@-1+ {{declared here}}
return 0;
}
};
using mem_ptr_type = int (A::*)(int);
template<mem_ptr_type ptr>
struct C {};
C<&A::f> c;
// expected-error@-1 {{is not a constant expression}}
// expected-note@-2 {{pointer to a consteval}}
consteval mem_ptr_type ret2() {
return &A::f;
}
C<ret2()> c1;
// expected-error@-1 {{is not a constant expression}}
// expected-note@-2 {{pointer to a consteval}}
}
namespace context {
int g_i;
// expected-note@-1 {{declared here}}
consteval int f(int) {
return 0;
}
constexpr int c_i = 0;
int t1 = f(g_i);
// expected-error@-1 {{is not a constant expression}}
// expected-note@-2 {{read of non-const variable}}
int t3 = f(c_i);
constexpr int f_c(int i) {
// expected-note@-1 {{declared here}}
int t = f(i);
// expected-error@-1 {{is not a constant expression}}
// expected-note@-2 {{function parameter}}
return f(0);
}
consteval int f_eval(int i) {
return f(i);
}
auto l0 = [](int i) consteval {
return f(i);
};
auto l1 = [](int i) constexpr { // expected-error{{cannot take address of immediate call operator}} \
// expected-note {{declared here}}
int t = f(i);
return f(0);
};
int(*test)(int) = l1;
}
namespace consteval_lambda_in_template {
struct S {
int *value;
constexpr S(int v) : value(new int {v}) {}
constexpr ~S() { delete value; }
};
consteval S fn() { return S(5); }
template <typename T>
void fn2() {
(void)[]() consteval -> int {
return *(fn().value); // OK, immediate context
};
}
void caller() {
fn2<int>();
}
}
namespace std {
template <typename T> struct remove_reference { using type = T; };
template <typename T> struct remove_reference<T &> { using type = T; };
template <typename T> struct remove_reference<T &&> { using type = T; };
template <typename T>
constexpr typename std::remove_reference<T>::type&& move(T &&t) noexcept {
return static_cast<typename std::remove_reference<T>::type &&>(t);
}
}
namespace temporaries {
struct A {
consteval int ret_i() const { return 0; }
consteval A ret_a() const { return A{}; }
constexpr ~A() { }
};
consteval int by_value_a(A a) { return a.ret_i(); }
consteval int const_a_ref(const A &a) {
return a.ret_i();
}
consteval int rvalue_ref(const A &&a) {
return a.ret_i();
}
consteval const A &to_lvalue_ref(const A &&a) {
return a;
}
void test() {
constexpr A a {};
{ int k = A().ret_i(); }
{ A k = A().ret_a(); }
{ A k = to_lvalue_ref(A()); }// expected-error {{is not a constant expression}}
// expected-note@-1 {{is not a constant expression}} expected-note@-1 {{temporary created here}}
{ A k = to_lvalue_ref(A().ret_a()); } // expected-error {{is not a constant expression}}
// expected-note@-1 {{is not a constant expression}} expected-note@-1 {{temporary created here}}
{ int k = A().ret_a().ret_i(); }
{ int k = by_value_a(A()); }
{ int k = const_a_ref(A()); }
{ int k = const_a_ref(a); }
{ int k = rvalue_ref(A()); }
{ int k = rvalue_ref(std::move(a)); }
{ int k = const_a_ref(A().ret_a()); }
{ int k = const_a_ref(to_lvalue_ref(A().ret_a())); }
{ int k = const_a_ref(to_lvalue_ref(std::move(a))); }
{ int k = by_value_a(A().ret_a()); }
{ int k = by_value_a(to_lvalue_ref(std::move(a))); }
{ int k = (A().ret_a(), A().ret_i()); }
{ int k = (const_a_ref(A().ret_a()), A().ret_i()); }//
}
}
namespace alloc {
consteval int f() {
int *A = new int(0);
// expected-note@-1+ {{allocation performed here was not deallocated}}
return *A;
}
int i1 = f(); // expected-error {{is not a constant expression}}
struct A {
int* p = new int(42);
// expected-note@-1+ {{heap allocation performed here}}
consteval int ret_i() const { return p ? *p : 0; }
consteval A ret_a() const { return A{}; }
constexpr ~A() { delete p; }
};
consteval int by_value_a(A a) { return a.ret_i(); }
consteval int const_a_ref(const A &a) {
return a.ret_i();
}
consteval int rvalue_ref(const A &&a) {
return a.ret_i();
}
consteval const A &to_lvalue_ref(const A &&a) {
return a;
}
void test() {
constexpr A a{ nullptr };
{ int k = A().ret_i(); }
{ A k = A().ret_a(); } // expected-error {{is not a constant expression}}
// expected-note@-1 {{is not a constant expression}}
{ A k = to_lvalue_ref(A()); } // expected-error {{is not a constant expression}}
// expected-note@-1 {{is not a constant expression}} expected-note@-1 {{temporary created here}}
{ A k = to_lvalue_ref(A().ret_a()); }
// expected-note@-1 {{reference to temporary is not a constant expression}}
// expected-error@-2 {{'alloc::to_lvalue_ref' is not a constant expression}}
// expected-note@-3 {{temporary created here}}
{ int k = A().ret_a().ret_i(); }
// expected-error@-1 {{'alloc::A::ret_a' is not a constant expression}}
// expected-note@-2 {{heap-allocated object is not a constant expression}}
{ int k = by_value_a(A()); }
{ int k = const_a_ref(A()); }
{ int k = const_a_ref(a); }
{ int k = rvalue_ref(A()); }
{ int k = rvalue_ref(std::move(a)); }
{ int k = const_a_ref(A().ret_a()); }
{ int k = const_a_ref(to_lvalue_ref(A().ret_a())); }
{ int k = const_a_ref(to_lvalue_ref(std::move(a))); }
{ int k = by_value_a(A().ret_a()); }
{ int k = by_value_a(to_lvalue_ref(static_cast<const A&&>(a))); }
{ int k = (A().ret_a(), A().ret_i()); }// expected-error {{is not a constant expression}}
// expected-note@-1 {{is not a constant expression}}
{ int k = (const_a_ref(A().ret_a()), A().ret_i()); }
}
}
namespace self_referencing {
struct S {
S* ptr = nullptr;
constexpr S(int i) : ptr(this) {
if (this == ptr && i)
ptr = nullptr;
}
constexpr ~S() {}
};
consteval S f(int i) {
return S(i);
}
void test() {
S s(1);
s = f(1);
s = f(0); // expected-error {{is not a constant expression}}
// expected-note@-1 {{is not a constant expression}} expected-note@-1 {{temporary created here}}
}
struct S1 {
S1* ptr = nullptr;
consteval S1(int i) : ptr(this) {
if (this == ptr && i)
ptr = nullptr;
}
constexpr ~S1() {}
};
void test1() {
S1 s(1);
s = S1(1);
s = S1(0); // expected-error {{is not a constant expression}}
// expected-note@-1 {{is not a constant expression}} expected-note@-1 {{temporary created here}}
}
}
namespace ctor {
consteval int f_eval() { // expected-note+ {{declared here}}
return 0;
}
namespace std {
struct strong_ordering {
int n;
static const strong_ordering less, equal, greater;
};
constexpr strong_ordering strong_ordering::less = {-1};
constexpr strong_ordering strong_ordering::equal = {0};
constexpr strong_ordering strong_ordering::greater = {1};
constexpr bool operator!=(strong_ordering, int);
}
namespace override {
struct A {
virtual consteval void f(); // expected-note {{overridden}}
virtual void g(); // expected-note {{overridden}}
};
struct B : A {
consteval void f();
void g();
};
struct C : A {
void f(); // expected-error {{non-consteval function 'f' cannot override a consteval function}}
consteval void g(); // expected-error {{consteval function 'g' cannot override a non-consteval function}}
};
namespace implicit_equals_1 {
struct Y;
struct X {
std::strong_ordering operator<=>(const X&) const;
constexpr bool operator==(const X&) const;
virtual consteval bool operator==(const Y&) const; // expected-note {{here}}
};
struct Y : X {
std::strong_ordering operator<=>(const Y&) const = default;
// expected-error@-1 {{non-consteval function 'operator==' cannot override a consteval function}}
};
}
namespace implicit_equals_2 {
struct Y;
struct X {
constexpr std::strong_ordering operator<=>(const X&) const;
constexpr bool operator==(const X&) const;
virtual bool operator==(const Y&) const; // expected-note {{here}}
};
struct Y : X {
consteval std::strong_ordering operator<=>(const Y&) const = default;
// expected-error@-1 {{consteval function 'operator==' cannot override a non-consteval function}}
};
}
}
namespace operator_rewrite {
struct A {
friend consteval int operator<=>(const A&, const A&) { return 0; }
};
const bool k = A() < A();
static_assert(!k);
A a;
bool k2 = A() < a; // OK, does not access 'a'.
struct B {
friend consteval int operator<=>(const B &l, const B &r) { return r.n - l.n; } // expected-note {{read of }}
int n;
};
static_assert(B() >= B());
B b; // expected-note {{here}}
bool k3 = B() < b; // expected-error-re {{call to consteval function '{{.*}}::operator<=>' is not a constant expression}} expected-note {{in call}}
}
struct A {
int(*ptr)();
consteval A(int(*p)() = nullptr) : ptr(p) {}
};
struct B {
int(*ptr)();
B() : ptr(nullptr) {}
consteval B(int(*p)(), int) : ptr(p) {}
};
void test() {
{ A a; }
{ A a(&f_eval); } // expected-error {{is not a constant expression}} expected-note {{to a consteval}}
{ B b(nullptr, 0); }
{ B b(&f_eval, 0); } // expected-error {{is not a constant expression}} expected-note {{to a consteval}}
{ A a{}; }
{ A a{&f_eval}; } // expected-error {{is not a constant expression}} expected-note {{to a consteval}}
{ B b{nullptr, 0}; }
{ B b{&f_eval, 0}; } // expected-error {{is not a constant expression}} expected-note {{to a consteval}}
{ A a = A(); }
{ A a = A(&f_eval); } // expected-error {{is not a constant expression}} expected-note {{to a consteval}}
{ B b = B(nullptr, 0); }
{ B b = B(&f_eval, 0); } // expected-error {{is not a constant expression}} expected-note {{to a consteval}}
{ A a = A{}; }
{ A a = A{&f_eval}; } // expected-error {{is not a constant expression}} expected-note {{to a consteval}}
{ B b = B{nullptr, 0}; }
{ B b = B{&f_eval, 0}; } // expected-error {{is not a constant expression}} expected-note {{to a consteval}}
{ A a; a = A(); }
{ A a; a = A(&f_eval); } // expected-error {{is not a constant expression}} expected-note {{to a consteval}}
{ B b; b = B(nullptr, 0); }
{ B b; b = B(&f_eval, 0); } // expected-error {{is not a constant expression}} expected-note {{to a consteval}}
{ A a; a = A{}; }
{ A a; a = A{&f_eval}; } // expected-error {{is not a constant expression}} expected-note {{to a consteval}}
{ B b; b = B{nullptr, 0}; }
{ B b; b = B{&f_eval, 0}; } // expected-error {{is not a constant expression}} expected-note {{to a consteval}}
{ A* a; a = new A(); }
{ A* a; a = new A(&f_eval); } // expected-error {{is not a constant expression}} expected-note {{to a consteval}}
{ B* b; b = new B(nullptr, 0); }
{ B* b; b = new B(&f_eval, 0); } // expected-error {{is not a constant expression}} expected-note {{to a consteval}}
{ A* a; a = new A{}; }
{ A* a; a = new A{&f_eval}; } // expected-error {{is not a constant expression}} expected-note {{to a consteval}}
{ B* b; b = new B{nullptr, 0}; }
{ B* b; b = new B{&f_eval, 0}; } // expected-error {{is not a constant expression}} expected-note {{to a consteval}}
}
}
namespace copy_ctor {
consteval int f_eval() { // expected-note+ {{declared here}}
return 0;
}
struct Copy {
int(*ptr)();
constexpr Copy(int(*p)() = nullptr) : ptr(p) {}
consteval Copy(const Copy&) = default;
};
constexpr const Copy &to_lvalue_ref(const Copy &&a) {
return a;
}
void test() {
constexpr const Copy C;
// there is no the copy constructor call when its argument is a prvalue because of garanteed copy elision.
// so we need to test with both prvalue and xvalues.
{ Copy c(C); }
{ Copy c((Copy(&f_eval))); }// expected-error {{cannot take address of consteval}}
{ Copy c(std::move(C)); }
{ Copy c(std::move(Copy(&f_eval))); }// expected-error {{is not a constant expression}} expected-note {{to a consteval}}
{ Copy c(to_lvalue_ref((Copy(&f_eval)))); }// expected-error {{is not a constant expression}} expected-note {{to a consteval}}
{ Copy c(to_lvalue_ref(std::move(C))); }
{ Copy c(to_lvalue_ref(std::move(Copy(&f_eval)))); }// expected-error {{is not a constant expression}} expected-note {{to a consteval}}
{ Copy c = Copy(C); }
{ Copy c = Copy(Copy(&f_eval)); }// expected-error {{cannot take address of consteval}}
{ Copy c = Copy(std::move(C)); }
{ Copy c = Copy(std::move(Copy(&f_eval))); }// expected-error {{is not a constant expression}} expected-note {{to a consteval}}
{ Copy c = Copy(to_lvalue_ref(Copy(&f_eval))); }// expected-error {{is not a constant expression}} expected-note {{to a consteval}}
{ Copy c = Copy(to_lvalue_ref(std::move(C))); }
{ Copy c = Copy(to_lvalue_ref(std::move(Copy(&f_eval)))); }// expected-error {{is not a constant expression}} expected-note {{to a consteval}}
{ Copy c; c = Copy(C); }
{ Copy c; c = Copy(Copy(&f_eval)); }// expected-error {{cannot take address of consteval}}
{ Copy c; c = Copy(std::move(C)); }
{ Copy c; c = Copy(std::move(Copy(&f_eval))); }// expected-error {{is not a constant expression}} expected-note {{to a consteval}}
{ Copy c; c = Copy(to_lvalue_ref(Copy(&f_eval))); }// expected-error {{is not a constant expression}} expected-note {{to a consteval}}
{ Copy c; c = Copy(to_lvalue_ref(std::move(C))); }
{ Copy c; c = Copy(to_lvalue_ref(std::move(Copy(&f_eval)))); }// expected-error {{is not a constant expression}} expected-note {{to a consteval}}
{ Copy* c; c = new Copy(C); }
{ Copy* c; c = new Copy(Copy(&f_eval)); }// expected-error {{cannot take address of consteval}}
{ Copy* c; c = new Copy(std::move(C)); }
{ Copy* c; c = new Copy(std::move(Copy(&f_eval))); }// expected-error {{is not a constant expression}} expected-note {{to a consteval}}
{ Copy* c; c = new Copy(to_lvalue_ref(Copy(&f_eval))); }// expected-error {{is not a constant expression}} expected-note {{to a consteval}}
{ Copy* c; c = new Copy(to_lvalue_ref(std::move(C))); }
{ Copy* c; c = new Copy(to_lvalue_ref(std::move(Copy(&f_eval)))); }// expected-error {{is not a constant expression}} expected-note {{to a consteval}}
}
} // namespace special_ctor
namespace unevaluated {
template <typename T, typename U> struct is_same { static const bool value = false; };
template <typename T> struct is_same<T, T> { static const bool value = true; };
long f(); // expected-note {{declared here}}
auto consteval g(auto a) {
return a;
}
auto e = g(f()); // expected-error {{is not a constant expression}}
// expected-note@-1 {{non-constexpr function 'f' cannot be used in a constant expression}}
using T = decltype(g(f()));
static_assert(is_same<long, T>::value);
} // namespace unevaluated
namespace value_dependent {
consteval int foo(int x) {
return x;
}
template <int X> constexpr int bar() {
// Previously this call was rejected as value-dependent constant expressions
// can't be immediately evaluated. Now we show that we don't immediately
// evaluate them until they are instantiated.
return foo(X);
}
template <typename T> constexpr int baz() {
constexpr int t = sizeof(T);
// Previously this call was rejected as `t` is value-dependent and its value
// is unknown until the function is instantiated. Now we show that we don't
// reject such calls.
return foo(t);
}
static_assert(bar<15>() == 15);
static_assert(baz<int>() == sizeof(int));
} // namespace value_dependent
// https://github.com/llvm/llvm-project/issues/55601
namespace issue_55601 {
template<typename T>
class Bar {
consteval static T x() { return 5; } // expected-note {{non-constexpr constructor 'derp' cannot be used in a constant expression}}
public:
Bar() : a(x()) {} // expected-error {{call to consteval function 'issue_55601::Bar<issue_55601::derp>::x' is not a constant expression}}
// expected-error@-1 {{call to consteval function 'issue_55601::derp::operator int' is not a constant expression}}
// expected-note@-2 {{in call to 'x()'}}
// expected-note@-3 {{non-literal type 'issue_55601::derp' cannot be used in a constant expression}}
private:
int a;
};
Bar<int> f;
Bar<float> g;
struct derp {
// Can't be used in a constant expression
derp(int); // expected-note {{declared here}}
consteval operator int() const { return 5; }
};
Bar<derp> a; // expected-note {{in instantiation of member function 'issue_55601::Bar<issue_55601::derp>::Bar' requested here}}
struct constantDerp {
// Can be used in a constant expression.
consteval constantDerp(int) {}
consteval operator int() const { return 5; }
};
Bar<constantDerp> b;
} // namespace issue_55601
namespace default_argument {
// Previously calls of consteval functions in default arguments were rejected.
// Now we show that we don't reject such calls.
consteval int foo() { return 1; }
consteval int bar(int i = foo()) { return i * i; }
struct Test1 {
Test1(int i = bar(13)) {}
void v(int i = bar(13) * 2 + bar(15)) {}
};
Test1 t1;
struct Test2 {
constexpr Test2(int i = bar()) {}
constexpr void v(int i = bar(bar(bar(foo())))) {}
};
Test2 t2;
} // namespace default_argument
namespace PR50779 {
struct derp {
int b = 0;
};
constexpr derp d;
struct test {
consteval int operator[](int i) const { return {}; }
consteval const derp * operator->() const { return &d; }
consteval int f() const { return 12; } // expected-note 2{{declared here}}
};
constexpr test a;
// We previously rejected both of these overloaded operators as taking the
// address of a consteval function outside of an immediate context, but we
// accepted direct calls to the overloaded operator. Now we show that we accept
// both forms.
constexpr int s = a.operator[](1);
constexpr int t = a[1];
constexpr int u = a.operator->()->b;
constexpr int v = a->b;
// FIXME: I believe this case should work, but we currently reject.
constexpr int w = (a.*&test::f)(); // expected-error {{cannot take address of consteval function 'f' outside of an immediate invocation}}
constexpr int x = a.f();
// Show that we reject when not in an immediate context.
int w2 = (a.*&test::f)(); // expected-error {{cannot take address of consteval function 'f' outside of an immediate invocation}}
}
namespace PR48235 {
consteval int d() {
return 1;
}
struct A {
consteval int a() const { return 1; }
void b() {
this->a() + d(); // expected-error {{call to consteval function 'PR48235::A::a' is not a constant expression}} \
// expected-note {{use of 'this' pointer is only allowed within the evaluation of a call to a 'constexpr' member function}}
}
void c() {
a() + d(); // expected-error {{call to consteval function 'PR48235::A::a' is not a constant expression}} \
// expected-note {{use of 'this' pointer is only allowed within the evaluation of a call to a 'constexpr' member function}}
}
};
} // PR48235
namespace NamespaceScopeConsteval {
struct S {
int Val; // expected-note {{subobject declared here}}
consteval S() {}
};
S s1; // expected-error {{call to consteval function 'NamespaceScopeConsteval::S::S' is not a constant expression}} \
expected-note {{subobject 'Val' is not initialized}}
template <typename Ty>
struct T {
Ty Val; // expected-note {{subobject declared here}}
consteval T() {}
};
T<int> t; // expected-error {{call to consteval function 'NamespaceScopeConsteval::T<int>::T' is not a constant expression}} \
expected-note {{subobject 'Val' is not initialized}}
} // namespace NamespaceScopeConsteval
namespace Issue54578 {
// We expect the user-defined literal to be resovled entirely at compile time
// despite being instantiated through a template.
inline consteval unsigned char operator""_UC(const unsigned long long n) {
return static_cast<unsigned char>(n);
}
inline constexpr char f1(const auto octet) {
return 4_UC;
}
template <typename Ty>
inline constexpr char f2(const Ty octet) {
return 4_UC;
}
void test() {
static_assert(f1('a') == 4);
static_assert(f2('a') == 4);
constexpr int c = f1('a') + f2('a');
static_assert(c == 8);
}
}
namespace defaulted_special_member_template {
template <typename T>
struct default_ctor {
T data;
consteval default_ctor() = default; // expected-note {{non-constexpr constructor 'foo' cannot be used in a constant expression}}
};
template <typename T>
struct copy {
T data;
consteval copy(const copy &) = default; // expected-note {{non-constexpr constructor 'foo' cannot be used in a constant expression}}
consteval copy &operator=(const copy &) = default; // expected-note {{non-constexpr function 'operator=' cannot be used in a constant expression}}
copy() = default;
};
template <typename T>
struct move {
T data;
consteval move(move &&) = default; // expected-note {{non-constexpr constructor 'foo' cannot be used in a constant expression}}
consteval move &operator=(move &&) = default; // expected-note {{non-constexpr function 'operator=' cannot be used in a constant expression}}
move() = default;
};
struct foo {
foo() {} // expected-note {{declared here}}
foo(const foo &) {} // expected-note {{declared here}}
foo(foo &&) {} // expected-note {{declared here}}
foo& operator=(const foo &) { return *this; } // expected-note {{declared here}}
foo& operator=(foo &&) { return *this; } // expected-note {{declared here}}
};
void func() {
default_ctor<foo> fail0; // expected-error {{call to consteval function 'defaulted_special_member_template::default_ctor<defaulted_special_member_template::foo>::default_ctor' is not a constant expression}} \
expected-note {{in call to 'default_ctor()'}}
copy<foo> good0;
copy<foo> fail1{good0}; // expected-error {{call to consteval function 'defaulted_special_member_template::copy<defaulted_special_member_template::foo>::copy' is not a constant expression}} \
expected-note {{in call to 'copy(good0)'}}
fail1 = good0; // expected-error {{call to consteval function 'defaulted_special_member_template::copy<defaulted_special_member_template::foo>::operator=' is not a constant expression}} \
expected-note {{in call to 'fail1.operator=(good0)'}}
move<foo> good1;
move<foo> fail2{static_cast<move<foo>&&>(good1)}; // expected-error {{call to consteval function 'defaulted_special_member_template::move<defaulted_special_member_template::foo>::move' is not a constant expression}} \
expected-note {{in call to 'move(good1)'}}
fail2 = static_cast<move<foo>&&>(good1); // expected-error {{call to consteval function 'defaulted_special_member_template::move<defaulted_special_member_template::foo>::operator=' is not a constant expression}} \
expected-note {{in call to 'fail2.operator=(good1)'}}
}
} // namespace defaulted_special_member_template
namespace multiple_default_constructors {
struct Foo {
Foo() {} // expected-note {{declared here}}
};
struct Bar {
Bar() = default;
};
struct Baz {
consteval Baz() {}
};
template <typename T, unsigned N>
struct S {
T data;
S() requires (N==1) = default;
// This cannot be used in constexpr context.
S() requires (N==2) {} // expected-note {{declared here}}
consteval S() requires (N==3) = default; // expected-note {{non-constexpr constructor 'Foo' cannot be used in a constant expression}}
};
void func() {
// Explicitly defaulted constructor.
S<Foo, 1> s1;
S<Bar, 1> s2;
// User provided constructor.
S<Foo, 2> s3;
S<Bar, 2> s4;
// Consteval explicitly defaulted constructor.
S<Foo, 3> s5; // expected-error {{call to consteval function 'multiple_default_constructors::S<multiple_default_constructors::Foo, 3>::S' is not a constant expression}} \
expected-note {{in call to 'S()'}}
S<Bar, 3> s6;
S<Baz, 3> s7;
}
consteval int aConstevalFunction() { // expected-error {{consteval function never produces a constant expression}}
// Defaulted default constructors are implicitly consteval.
S<Bar, 1> s1;
S<Baz, 2> s4; // expected-note {{non-constexpr constructor 'S' cannot be used in a constant expression}}
S<Bar, 3> s2;
S<Baz, 3> s3;
return 0;
}
} // namespace multiple_default_constructors
namespace GH50055 {
enum E {e1=0, e2=1};
consteval int testDefaultArgForParam(E eParam = (E)-1) {
// expected-note@-1 {{integer value -1 is outside the valid range of values [0, 1] for the enumeration type 'E'}}
return (int)eParam;
}
int test() {
return testDefaultArgForParam() + testDefaultArgForParam((E)1);
// expected-error@-1 {{call to consteval function 'GH50055::testDefaultArgForParam' is not a constant expression}}
}
}
namespace GH51182 {
// Nested consteval function.
consteval int f(int v) {
return v;
}
template <typename T>
consteval int g(T a) {
// An immediate function context.
int n = f(a);
return n;
}
static_assert(g(100) == 100);
// --------------------------------------
template <typename T>
consteval T max(const T& a, const T& b) {
return (a > b) ? a : b;
}
template <typename T>
consteval T mid(const T& a, const T& b, const T& c) {
T m = max(max(a, b), c);
if (m == a)
return max(b, c);
if (m == b)
return max(a, c);
return max(a, b);
}
static_assert(max(1,2)==2);
static_assert(mid(1,2,3)==2);
} // namespace GH51182
// https://github.com/llvm/llvm-project/issues/56183
namespace GH56183 {
consteval auto Foo(auto c) { return c; }
consteval auto Bar(auto f) { return f(); }
void test() {
constexpr auto x = Foo(Bar([] { return 'a'; }));
static_assert(x == 'a');
}
} // namespace GH56183
// https://github.com/llvm/llvm-project/issues/51695
namespace GH51695 {
// Original ========================================
template <typename T>
struct type_t {};
template <typename...>
struct list_t {};
template <typename T, typename... Ts>
consteval auto pop_front(list_t<T, Ts...>) -> auto {
return list_t<Ts...>{};
}
template <typename... Ts, typename F>
consteval auto apply(list_t<Ts...>, F fn) -> auto {
return fn(type_t<Ts>{}...);
}
void test1() {
constexpr auto x = apply(pop_front(list_t<char, char>{}),
[]<typename... Us>(type_t<Us>...) { return 42; });
static_assert(x == 42);
}
// Reduced 1 ========================================
consteval bool zero() { return false; }
template <typename F>
consteval bool foo(bool, F f) {
return f();
}
void test2() {
constexpr auto x = foo(zero(), []() { return true; });
static_assert(x);
}
// Reduced 2 ========================================
template <typename F>
consteval auto bar(F f) { return f;}
void test3() {
constexpr auto t1 = bar(bar(bar(bar([]() { return true; }))))();
static_assert(t1);
int a = 1; // expected-note {{declared here}}
auto t2 = bar(bar(bar(bar([=]() { return a; }))))(); // expected-error-re {{call to consteval function 'GH51695::bar<(lambda at {{.*}})>' is not a constant expression}}
// expected-note@-1 {{read of non-const variable 'a' is not allowed in a constant expression}}
constexpr auto t3 = bar(bar([x=bar(42)]() { return x; }))();
static_assert(t3==42);
constexpr auto t4 = bar(bar([x=bar(42)]() consteval { return x; }))();
static_assert(t4==42);
}
} // namespace GH51695
// https://github.com/llvm/llvm-project/issues/50455
namespace GH50455 {
void f() {
[]() consteval { int i{}; }();
[]() consteval { int i{}; ++i; }();
}
void g() {
(void)[](int i) consteval { return i; }(0);
(void)[](int i) consteval { return i; }(0);
}
} // namespace GH50455
namespace GH58302 {
struct A {
consteval A(){}
consteval operator int() { return 1;}
};
int f() {
int x = A{};
}
}
namespace GH57682 {
void test() {
constexpr auto l1 = []() consteval { // expected-error {{cannot take address of consteval call operator of '(lambda at}} \
// expected-note 2{{declared here}}
return 3;
};
constexpr int (*f1)(void) = l1; // expected-error {{constexpr variable 'f1' must be initialized by a constant expression}} \
// expected-note {{pointer to a consteval declaration is not a constant expression}}
constexpr auto lstatic = []() static consteval { // expected-error {{cannot take address of consteval call operator of '(lambda at}} \
// expected-note 2{{declared here}} \
// expected-warning {{extension}}
return 3;
};
constexpr int (*f2)(void) = lstatic; // expected-error {{constexpr variable 'f2' must be initialized by a constant expression}} \
// expected-note {{pointer to a consteval declaration is not a constant expression}}
int (*f3)(void) = []() consteval { return 3; }; // expected-error {{cannot take address of consteval call operator of '(lambda at}} \
// expected-note {{declared here}}
}
consteval void consteval_test() {
constexpr auto l1 = []() consteval { return 3; };
int (*f1)(void) = l1; // ok
}
}
namespace GH60286 {
struct A {
int i = 0;
consteval A() {}
A(const A&) { i = 1; }
consteval int f() { return i; }
};
constexpr auto B = A{A{}}.f();
static_assert(B == 0);
}
namespace GH58207 {
struct tester {
consteval tester(const char* name) noexcept { }
};
consteval const char* make_name(const char* name) { return name;}
consteval const char* pad(int P) { return "thestring"; }
int bad = 10; // expected-note 6{{declared here}}
tester glob1(make_name("glob1"));
tester glob2(make_name("glob2"));
constexpr tester cglob(make_name("cglob"));
tester paddedglob(make_name(pad(bad))); // expected-error {{call to consteval function 'GH58207::tester::tester' is not a constant expression}} \
// expected-note {{read of non-const variable 'bad' is not allowed in a constant expression}}
constexpr tester glob3 = { make_name("glob3") };
constexpr tester glob4 = { make_name(pad(bad)) }; // expected-error {{call to consteval function 'GH58207::tester::tester' is not a constant expression}} \
// expected-error {{constexpr variable 'glob4' must be initialized by a constant expression}} \
// expected-note 2{{read of non-const variable 'bad' is not allowed in a constant expression}}
auto V = make_name(pad(3));
auto V1 = make_name(pad(bad)); // expected-error {{call to consteval function 'GH58207::make_name' is not a constant expression}} \
// expected-note {{read of non-const variable 'bad' is not allowed in a constant expression}}
void foo() {
static tester loc1(make_name("loc1"));
static constexpr tester loc2(make_name("loc2"));
static tester paddedloc(make_name(pad(bad))); // expected-error {{call to consteval function 'GH58207::tester::tester' is not a constant expression}} \
// expected-note {{read of non-const variable 'bad' is not allowed in a constant expression}}
}
void bar() {
static tester paddedloc(make_name(pad(bad))); // expected-error {{call to consteval function 'GH58207::tester::tester' is not a constant expression}} \
// expected-note {{read of non-const variable 'bad' is not allowed in a constant expression}}
}
}
namespace GH64949 {
struct f {
int g; // expected-note 2{{subobject declared here}}
constexpr ~f() {}
};
class h {
public:
consteval h(char *) {}
consteval operator int() const { return 1; }
f i;
};
void test() { (int)h{nullptr}; }
// expected-error@-1 {{call to consteval function 'GH64949::h::h' is not a constant expression}}
// expected-note@-2 {{subobject 'g' is not initialized}}
int test2() { return h{nullptr}; }
// expected-error@-1 {{call to consteval function 'GH64949::h::h' is not a constant expression}}
// expected-note@-2 {{subobject 'g' is not initialized}}
}
namespace GH65985 {
int consteval operator""_foo(unsigned long long V) {
return 0;
}
int consteval operator""_bar(unsigned long long V); // expected-note 3{{here}}
int consteval f() {
return 0;
}
int consteval g(); // expected-note {{here}}
struct C {
static const int a = 1_foo;
static constexpr int b = 1_foo;
static const int c = 1_bar; // expected-error {{call to consteval function 'GH65985::operator""_bar' is not a constant expression}} \
// expected-note {{undefined function 'operator""_bar' cannot be used in a constant expression}} \
// expected-error {{in-class initializer for static data member is not a constant expression}}
// FIXME: remove duplicate diagnostics
static constexpr int d = 1_bar; // expected-error {{call to consteval function 'GH65985::operator""_bar' is not a constant expression}} \
// expected-note {{undefined function 'operator""_bar' cannot be used in a constant expression}} \
// expected-error {{constexpr variable 'd' must be initialized by a constant expression}} \
// expected-note {{undefined function 'operator""_bar' cannot be used in a constant expression}}
static const int e = f();
static const int f = g(); // expected-error {{call to consteval function 'GH65985::g' is not a constant expression}} \
// expected-error {{in-class initializer for static data member is not a constant expression}} \
// expected-note {{undefined function 'g' cannot be used in a constant expression}}
};
}
namespace GH66562 {
namespace ns
{
consteval int foo(int x) { return 1; } // expected-note {{declared here}} \
// expected-note {{passing argument to parameter 'x' here}}
}
template <class A>
struct T {
static constexpr auto xx = ns::foo(A{}); // expected-error {{cannot take address of consteval function 'foo' outside of an immediate invocation}} \
// expected-error {{cannot initialize a parameter of type 'int' with an rvalue of type 'char *'}}
};
template class T<char*>; // expected-note {{in instantiation}}
}
namespace GH65520 {
consteval int bar (int i) { if (i != 1) return 1/0; return 0; }
// expected-note@-1{{division by zero}}
void
g ()
{
int a_ok[bar(1)];
int a_err[bar(3)]; // expected-error {{call to consteval function 'GH65520::bar' is not a constant expression}} \
// expected-note {{in call to 'bar(3)'}}
}
consteval int undefined(); // expected-note {{declared here}}
consteval void immediate() {
int a [undefined()]; // expected-note {{undefined function 'undefined' cannot be used in a constant expression}} \
// expected-error {{call to consteval function 'GH65520::undefined' is not a constant expression}} \
// expected-error {{variable of non-literal type 'int[undefined()]' cannot be defined in a constexpr function before C++23}}
}
}
namespace GH105558 {
consteval int* alloc() { return new int(0); }
consteval void f(int* p) { delete p; }
consteval void g1(int*&& p) { delete p; }
consteval void g2(const int* p) { delete p; }
consteval void g3(int*const& p) { delete p; }
struct X {
int* p;
explicit(false) constexpr X(int* p) : p(p) {}
};
consteval void g4(X x) { delete x.p; }
void test() {
f(alloc());
g1(alloc());
g2(alloc());
g3(alloc());
g4(alloc());
}
}
// Test that we don't redundantly instantiate the friend declaration in
// RemoveNestedImmediateInvocation(). Otherwise, we would end up with spurious
// redefinition errors.
namespace GH107175 {
consteval void consteval_func() {}
template <auto> struct define_f {
friend void foo() {}
};
template <auto = [] {}> struct A {};
struct B {
template <auto T> consteval void func() { (void)define_f<T>{}; }
};
int main() {
B{}.func<A{}>();
consteval_func();
}
} // namespace GH107175
Codebase Browser
llvm