1 // RUN: %clang_cc1 -std=c++2a -emit-llvm-only -Wno-unused-value %s -verify
2 
3 typedef __SIZE_TYPE__ size_t;
4 
5 namespace basic_sema {
6 
f1(int i)7 consteval int f1(int i) {
8   return i;
9 }
10 
f2(int i)11 consteval constexpr int f2(int i) {
12   //expected-error@-1 {{cannot combine}}
13   return i;
14 }
15 
__anon5fac8c860102(int i) 16 constexpr auto l_eval = [](int i) consteval {
17 // expected-note@-1+ {{declared here}}
18 
19   return i;
20 };
21 
f3(int i)22 constexpr consteval int f3(int i) {
23   //expected-error@-1 {{cannot combine}}
24   return i;
25 }
26 
27 struct A {
f1basic_sema::A28   consteval int f1(int i) const {
29 // expected-note@-1 {{declared here}}
30     return i;
31   }
32   consteval A(int i);
33   consteval A() = default;
34   consteval ~A() = default; // expected-error {{destructor cannot be declared consteval}}
35 };
36 
37 consteval struct B {}; // expected-error {{struct cannot be marked consteval}}
38 
39 consteval typedef B b; // expected-error {{typedef cannot be consteval}}
40 
redecl()41 consteval int redecl() {return 0;} // expected-note {{previous declaration is here}}
redecl()42 constexpr int redecl() {return 0;} // expected-error {{constexpr declaration of 'redecl' follows consteval declaration}}
43 
44 consteval int i = 0; // expected-error {{consteval can only be used in function declarations}}
45 
46 consteval int; // expected-error {{consteval can only be used in function declarations}}
47 
f1()48 consteval int f1() {} // expected-error {{no return statement in consteval function}}
49 
50 struct C {
Cbasic_sema::C51   C() {}
~Cbasic_sema::C52   ~C() {}
53 };
54 
55 struct D {
56   C c;
57   consteval D() = default; // expected-error {{cannot be consteval}}
58   consteval ~D() = default; // expected-error {{destructor cannot be declared consteval}}
59 };
60 
61 struct E : C {
~Ebasic_sema::E62   consteval ~E() {} // expected-error {{cannot be declared consteval}}
63 };
64 }
65 
main()66 consteval int main() { // expected-error {{'main' is not allowed to be declared consteval}}
67   return 0;
68 }
69 
f_eval(int i)70 consteval int f_eval(int i) {
71 // expected-note@-1+ {{declared here}}
72   return i;
73 }
74 
75 namespace taking_address {
76 
77 using func_type = int(int);
78 
79 func_type* p1 = (&f_eval);
80 // expected-error@-1 {{take address}}
81 func_type* p7 = __builtin_addressof(f_eval);
82 // expected-error@-1 {{take address}}
83 
84 auto p = f_eval;
85 // expected-error@-1 {{take address}}
86 
87 auto m1 = &basic_sema::A::f1;
88 // expected-error@-1 {{take address}}
89 auto l1 = &decltype(basic_sema::l_eval)::operator();
90 // expected-error@-1 {{take address}}
91 
f(int i)92 consteval int f(int i) {
93 // expected-note@-1+ {{declared here}}
94   return i;
95 }
96 
97 auto ptr = &f;
98 // expected-error@-1 {{take address}}
99 
f1()100 auto f1() {
101   return &f;
102 // expected-error@-1 {{take address}}
103 }
104 
105 }
106 
107 namespace invalid_function {
108 
109 struct A {
110   consteval void *operator new(size_t count);
111   // expected-error@-1 {{'operator new' cannot be declared consteval}}
112   consteval void *operator new[](size_t count);
113   // expected-error@-1 {{'operator new[]' cannot be declared consteval}}
114   consteval void operator delete(void* ptr);
115   // expected-error@-1 {{'operator delete' cannot be declared consteval}}
116   consteval void operator delete[](void* ptr);
117   // expected-error@-1 {{'operator delete[]' cannot be declared consteval}}
~Ainvalid_function::A118   consteval ~A() {}
119   // expected-error@-1 {{destructor cannot be declared consteval}}
120 };
121 
122 }
123 
124 namespace nested {
f()125 consteval int f() {
126   return 0;
127 }
128 
f1(...)129 consteval int f1(...) {
130   return 1;
131 }
132 
133 enum E {};
134 
135 using T = int(&)();
136 
operator +(E,int (* a)())137 consteval auto operator+ (E, int(*a)()) {
138   return 0;
139 }
140 
d()141 void d() {
142   auto i = f1(E() + &f);
143 }
144 
__anon5fac8c860202(auto) 145 auto l0 = [](auto) consteval {
146   return 0;
147 };
148 
149 int i0 = l0(&f1);
150 
151 int i1 = f1(l0(4));
152 
153 int i2 = f1(&f1, &f1, &f1, &f1, &f1, &f1, &f1);
154 
155 int i3 = f1(f1(f1(&f1, &f1), f1(&f1, &f1), f1(f1(&f1, &f1), &f1)));
156 
157 }
158 
159 namespace user_defined_literal {
160 
operator ""_test(unsigned long long i)161 consteval int operator"" _test(unsigned long long i) {
162 // expected-note@-1+ {{declared here}}
163   return 0;
164 }
165 
166 int i = 0_test;
167 
168 auto ptr = &operator"" _test;
169 // expected-error@-1 {{take address}}
170 
operator ""_test1(unsigned long long i)171 consteval auto operator"" _test1(unsigned long long i) {
172   return &f_eval;
173 }
174 
175 auto i1 = 0_test1; // expected-error {{is not a constant expression}}
176 // expected-note@-1 {{is not a constant expression}}
177 
178 }
179 
180 namespace return_address {
181 
f()182 consteval int f() {
183 // expected-note@-1 {{declared here}}
184   return 0;
185 }
186 
ret1(int i)187 consteval int(*ret1(int i))() {
188   return &f;
189 }
190 
191 auto ptr = ret1(0);
192 // expected-error@-1 {{is not a constant expression}}
193 // expected-note@-2 {{pointer to a consteval}}
194 
195 struct A {
freturn_address::A196   consteval int f(int) {
197     // expected-note@-1+ {{declared here}}
198     return 0;
199   }
200 };
201 
202 using mem_ptr_type = int (A::*)(int);
203 
204 template<mem_ptr_type ptr>
205 struct C {};
206 
207 C<&A::f> c;
208 // expected-error@-1 {{is not a constant expression}}
209 // expected-note@-2 {{pointer to a consteval}}
210 
ret2()211 consteval mem_ptr_type ret2() {
212   return &A::f;
213 }
214 
215 C<ret2()> c1;
216 // expected-error@-1 {{is not a constant expression}}
217 // expected-note@-2 {{pointer to a consteval}}
218 
219 }
220 
221 namespace context {
222 
223 int g_i;
224 // expected-note@-1 {{declared here}}
225 
f(int)226 consteval int f(int) {
227   return 0;
228 }
229 
230 constexpr int c_i = 0;
231 
232 int t1 = f(g_i);
233 // expected-error@-1 {{is not a constant expression}}
234 // expected-note@-2 {{read of non-const variable}}
235 int t3 = f(c_i);
236 
f_c(int i)237 constexpr int f_c(int i) {
238 // expected-note@-1 {{declared here}}
239   int t = f(i);
240 // expected-error@-1 {{is not a constant expression}}
241 // expected-note@-2 {{function parameter}}
242   return f(0);
243 }
244 
f_eval(int i)245 consteval int f_eval(int i) {
246   return f(i);
247 }
248 
__anon5fac8c860302(int i) 249 auto l0 = [](int i) consteval {
250   return f(i);
251 };
252 
__anon5fac8c860402(int i) 253 auto l1 = [](int i) constexpr {
254 // expected-note@-1 {{declared here}}
255   int t = f(i);
256 // expected-error@-1 {{is not a constant expression}}
257 // expected-note@-2 {{function parameter}}
258   return f(0);
259 };
260 
261 }
262 
263 namespace std {
264 
265 template <typename T> struct remove_reference { using type = T; };
266 template <typename T> struct remove_reference<T &> { using type = T; };
267 template <typename T> struct remove_reference<T &&> { using type = T; };
268 
269 template <typename T>
move(T && t)270 constexpr typename std::remove_reference<T>::type&& move(T &&t) noexcept {
271   return static_cast<typename std::remove_reference<T>::type &&>(t);
272 }
273 
274 }
275 
276 namespace temporaries {
277 
278 struct A {
ret_itemporaries::A279   consteval int ret_i() const { return 0; }
ret_atemporaries::A280   consteval A ret_a() const { return A{}; }
~Atemporaries::A281   constexpr ~A() { }
282 };
283 
by_value_a(A a)284 consteval int by_value_a(A a) { return a.ret_i(); }
285 
const_a_ref(const A & a)286 consteval int const_a_ref(const A &a) {
287   return a.ret_i();
288 }
289 
rvalue_ref(const A && a)290 consteval int rvalue_ref(const A &&a) {
291   return a.ret_i();
292 }
293 
to_lvalue_ref(const A && a)294 consteval const A &to_lvalue_ref(const A &&a) {
295   return a;
296 }
297 
test()298 void test() {
299   constexpr A a {};
300   { int k = A().ret_i(); }
301   { A k = A().ret_a(); }
302   { A k = to_lvalue_ref(A()); }// expected-error {{is not a constant expression}}
303   // expected-note@-1 {{is not a constant expression}} expected-note@-1 {{temporary created here}}
304   { A k = to_lvalue_ref(A().ret_a()); } // expected-error {{is not a constant expression}}
305   // expected-note@-1 {{is not a constant expression}} expected-note@-1 {{temporary created here}}
306   { int k = A().ret_a().ret_i(); }
307   { int k = by_value_a(A()); }
308   { int k = const_a_ref(A()); }
309   { int k = const_a_ref(a); }
310   { int k = rvalue_ref(A()); }
311   { int k = rvalue_ref(std::move(a)); }
312   { int k = const_a_ref(A().ret_a()); }
313   { int k = const_a_ref(to_lvalue_ref(A().ret_a())); }
314   { int k = const_a_ref(to_lvalue_ref(std::move(a))); }
315   { int k = by_value_a(A().ret_a()); }
316   { int k = by_value_a(to_lvalue_ref(std::move(a))); }
317   { int k = (A().ret_a(), A().ret_i()); }
318   { int k = (const_a_ref(A().ret_a()), A().ret_i()); }//
319 }
320 
321 }
322 
323 namespace alloc {
324 
f()325 consteval int f() {
326   int *A = new int(0);
327 // expected-note@-1+ {{allocation performed here was not deallocated}}
328   return *A;
329 }
330 
331 int i1 = f(); // expected-error {{is not a constant expression}}
332 
333 struct A {
334   int* p = new int(42);
335   // expected-note@-1+ {{heap allocation performed here}}
ret_ialloc::A336   consteval int ret_i() const { return p ? *p : 0; }
ret_aalloc::A337   consteval A ret_a() const { return A{}; }
~Aalloc::A338   constexpr ~A() { delete p; }
339 };
340 
by_value_a(A a)341 consteval int by_value_a(A a) { return a.ret_i(); }
342 
const_a_ref(const A & a)343 consteval int const_a_ref(const A &a) {
344   return a.ret_i();
345 }
346 
rvalue_ref(const A && a)347 consteval int rvalue_ref(const A &&a) {
348   return a.ret_i();
349 }
350 
to_lvalue_ref(const A && a)351 consteval const A &to_lvalue_ref(const A &&a) {
352   return a;
353 }
354 
test()355 void test() {
356   constexpr A a{ nullptr };
357   { int k = A().ret_i(); }
358   { A k = A().ret_a(); } // expected-error {{is not a constant expression}}
359   // expected-note@-1 {{is not a constant expression}}
360   { A k = to_lvalue_ref(A()); } // expected-error {{is not a constant expression}}
361   // expected-note@-1 {{is not a constant expression}} expected-note@-1 {{temporary created here}}
362   { A k = to_lvalue_ref(A().ret_a()); } // expected-error {{is not a constant expression}}
363   // expected-note@-1 {{is not a constant expression}} expected-note@-1 {{temporary created here}}
364   { int k = A().ret_a().ret_i(); }
365   { int k = by_value_a(A()); }
366   { int k = const_a_ref(A()); }
367   { int k = const_a_ref(a); }
368   { int k = rvalue_ref(A()); }
369   { int k = rvalue_ref(std::move(a)); }
370   { int k = const_a_ref(A().ret_a()); }
371   { int k = const_a_ref(to_lvalue_ref(A().ret_a())); }
372   { int k = const_a_ref(to_lvalue_ref(std::move(a))); }
373   { int k = by_value_a(A().ret_a()); }
374   { int k = by_value_a(to_lvalue_ref(static_cast<const A&&>(a))); }
375   { int k = (A().ret_a(), A().ret_i()); }// expected-error {{is not a constant expression}}
376   // expected-note@-1 {{is not a constant expression}}
377   { int k = (const_a_ref(A().ret_a()), A().ret_i()); }
378 }
379 
380 }
381 
382 namespace self_referencing {
383 
384 struct S {
385   S* ptr = nullptr;
Sself_referencing::S386   constexpr S(int i) : ptr(this) {
387     if (this == ptr && i)
388       ptr = nullptr;
389   }
~Sself_referencing::S390   constexpr ~S() {}
391 };
392 
f(int i)393 consteval S f(int i) {
394   return S(i);
395 }
396 
test()397 void test() {
398   S s(1);
399   s = f(1);
400   s = f(0); // expected-error {{is not a constant expression}}
401   // expected-note@-1 {{is not a constant expression}} expected-note@-1 {{temporary created here}}
402 }
403 
404 struct S1 {
405   S1* ptr = nullptr;
S1self_referencing::S1406   consteval S1(int i) : ptr(this) {
407     if (this == ptr && i)
408       ptr = nullptr;
409   }
~S1self_referencing::S1410   constexpr ~S1() {}
411 };
412 
test1()413 void test1() {
414   S1 s(1);
415   s = S1(1);
416   s = S1(0); // expected-error {{is not a constant expression}}
417   // expected-note@-1 {{is not a constant expression}} expected-note@-1 {{temporary created here}}
418 }
419 
420 }
421 namespace ctor {
422 
f_eval()423 consteval int f_eval() { // expected-note+ {{declared here}}
424   return 0;
425 }
426 
427 namespace std {
428   struct strong_ordering {
429     int n;
430     static const strong_ordering less, equal, greater;
431   };
432   constexpr strong_ordering strong_ordering::less = {-1};
433   constexpr strong_ordering strong_ordering::equal = {0};
434   constexpr strong_ordering strong_ordering::greater = {1};
435   constexpr bool operator!=(strong_ordering, int);
436 }
437 
438 namespace override {
439   struct A {
440     virtual consteval void f(); // expected-note {{overridden}}
441     virtual void g(); // expected-note {{overridden}}
442   };
443   struct B : A {
444     consteval void f();
445     void g();
446   };
447   struct C : A {
448     void f(); // expected-error {{non-consteval function 'f' cannot override a consteval function}}
449     consteval void g(); // expected-error {{consteval function 'g' cannot override a non-consteval function}}
450   };
451 
452   namespace implicit_equals_1 {
453     struct Y;
454     struct X {
455       std::strong_ordering operator<=>(const X&) const;
456       constexpr bool operator==(const X&) const;
457       virtual consteval bool operator==(const Y&) const; // expected-note {{here}}
458     };
459     struct Y : X {
460       std::strong_ordering operator<=>(const Y&) const = default;
461       // expected-error@-1 {{non-consteval function 'operator==' cannot override a consteval function}}
462     };
463   }
464 
465   namespace implicit_equals_2 {
466     struct Y;
467     struct X {
468       constexpr std::strong_ordering operator<=>(const X&) const;
469       constexpr bool operator==(const X&) const;
470       virtual bool operator==(const Y&) const; // expected-note {{here}}
471     };
472     struct Y : X {
473       consteval std::strong_ordering operator<=>(const Y&) const = default;
474       // expected-error@-1 {{consteval function 'operator==' cannot override a non-consteval function}}
475     };
476   }
477 }
478 
479 namespace operator_rewrite {
480   struct A {
operator <=>(const A &,const A &)481     friend consteval int operator<=>(const A&, const A&) { return 0; }
482   };
483   const bool k = A() < A();
484   static_assert(!k);
485 
486   A a;
487   bool k2 = A() < a; // OK, does not access 'a'.
488 
489   struct B {
operator <=>(const B & l,const B & r)490     friend consteval int operator<=>(const B &l, const B &r) { return r.n - l.n; } // expected-note {{read of }}
491     int n;
492   };
493   static_assert(B() >= B());
494   B b; // expected-note {{here}}
495   bool k3 = B() < b; // expected-error-re {{call to consteval function '{{.*}}::operator<=>' is not a constant expression}} expected-note {{in call}}
496 }
497 
498 struct A {
499   int(*ptr)();
Actor::A500   consteval A(int(*p)() = nullptr) : ptr(p) {}
501 };
502 
503 struct B {
504   int(*ptr)();
Bctor::B505   B() : ptr(nullptr) {}
Bctor::B506   consteval B(int(*p)(), int) : ptr(p) {}
507 };
508 
test()509 void test() {
510   { A a; }
511   { A a(&f_eval); } // expected-error {{is not a constant expression}} expected-note {{to a consteval}}
512   { B b(nullptr, 0); }
513   { B b(&f_eval, 0); } // expected-error {{is not a constant expression}} expected-note {{to a consteval}}
514   { A a{}; }
515   { A a{&f_eval}; } // expected-error {{is not a constant expression}} expected-note {{to a consteval}}
516   { B b{nullptr, 0}; }
517   { B b{&f_eval, 0}; } // expected-error {{is not a constant expression}} expected-note {{to a consteval}}
518   { A a = A(); }
519   { A a = A(&f_eval); } // expected-error {{is not a constant expression}} expected-note {{to a consteval}}
520   { B b = B(nullptr, 0); }
521   { B b = B(&f_eval, 0); } // expected-error {{is not a constant expression}} expected-note {{to a consteval}}
522   { A a = A{}; }
523   { A a = A{&f_eval}; } // expected-error {{is not a constant expression}} expected-note {{to a consteval}}
524   { B b = B{nullptr, 0}; }
525   { B b = B{&f_eval, 0}; } // expected-error {{is not a constant expression}} expected-note {{to a consteval}}
526   { A a; a = A(); }
527   { A a; a = A(&f_eval); } // expected-error {{is not a constant expression}} expected-note {{to a consteval}}
528   { B b; b = B(nullptr, 0); }
529   { B b; b = B(&f_eval, 0); } // expected-error {{is not a constant expression}} expected-note {{to a consteval}}
530   { A a; a = A{}; }
531   { A a; a = A{&f_eval}; } // expected-error {{is not a constant expression}} expected-note {{to a consteval}}
532   { B b; b = B{nullptr, 0}; }
533   { B b; b = B{&f_eval, 0}; } // expected-error {{is not a constant expression}} expected-note {{to a consteval}}
534   { A* a; a = new A(); }
535   { A* a; a = new A(&f_eval); } // expected-error {{is not a constant expression}} expected-note {{to a consteval}}
536   { B* b; b = new B(nullptr, 0); }
537   { B* b; b = new B(&f_eval, 0); } // expected-error {{is not a constant expression}} expected-note {{to a consteval}}
538   { A* a; a = new A{}; }
539   { A* a; a = new A{&f_eval}; } // expected-error {{is not a constant expression}} expected-note {{to a consteval}}
540   { B* b; b = new B{nullptr, 0}; }
541   { B* b; b = new B{&f_eval, 0}; } // expected-error {{is not a constant expression}} expected-note {{to a consteval}}
542 }
543 
544 }
545 
546 namespace copy_ctor {
547 
f_eval()548 consteval int f_eval() { // expected-note+ {{declared here}}
549   return 0;
550 }
551 
552 struct Copy {
553   int(*ptr)();
Copycopy_ctor::Copy554   constexpr Copy(int(*p)() = nullptr) : ptr(p) {}
555   consteval Copy(const Copy&) = default;
556 };
557 
to_lvalue_ref(const Copy && a)558 constexpr const Copy &to_lvalue_ref(const Copy &&a) {
559   return a;
560 }
561 
test()562 void test() {
563   constexpr const Copy C;
564   // there is no the copy constructor call when its argument is a prvalue because of garanteed copy elision.
565   // so we need to test with both prvalue and xvalues.
566   { Copy c(C); }
567   { Copy c((Copy(&f_eval))); }// expected-error {{cannot take address of consteval}}
568   { Copy c(std::move(C)); }
569   { Copy c(std::move(Copy(&f_eval))); }// expected-error {{is not a constant expression}} expected-note {{to a consteval}}
570   { Copy c(to_lvalue_ref((Copy(&f_eval)))); }// expected-error {{is not a constant expression}} expected-note {{to a consteval}}
571   { Copy c(to_lvalue_ref(std::move(C))); }
572   { Copy c(to_lvalue_ref(std::move(Copy(&f_eval)))); }// expected-error {{is not a constant expression}} expected-note {{to a consteval}}
573   { Copy c = Copy(C); }
574   { Copy c = Copy(Copy(&f_eval)); }// expected-error {{cannot take address of consteval}}
575   { Copy c = Copy(std::move(C)); }
576   { Copy c = Copy(std::move(Copy(&f_eval))); }// expected-error {{is not a constant expression}} expected-note {{to a consteval}}
577   { Copy c = Copy(to_lvalue_ref(Copy(&f_eval))); }// expected-error {{is not a constant expression}} expected-note {{to a consteval}}
578   { Copy c = Copy(to_lvalue_ref(std::move(C))); }
579   { Copy c = Copy(to_lvalue_ref(std::move(Copy(&f_eval)))); }// expected-error {{is not a constant expression}} expected-note {{to a consteval}}
580   { Copy c; c = Copy(C); }
581   { Copy c; c = Copy(Copy(&f_eval)); }// expected-error {{cannot take address of consteval}}
582   { Copy c; c = Copy(std::move(C)); }
583   { Copy c; c = Copy(std::move(Copy(&f_eval))); }// expected-error {{is not a constant expression}} expected-note {{to a consteval}}
584   { Copy c; c = Copy(to_lvalue_ref(Copy(&f_eval))); }// expected-error {{is not a constant expression}} expected-note {{to a consteval}}
585   { Copy c; c = Copy(to_lvalue_ref(std::move(C))); }
586   { Copy c; c = Copy(to_lvalue_ref(std::move(Copy(&f_eval)))); }// expected-error {{is not a constant expression}} expected-note {{to a consteval}}
587   { Copy* c; c = new Copy(C); }
588   { Copy* c; c = new Copy(Copy(&f_eval)); }// expected-error {{cannot take address of consteval}}
589   { Copy* c; c = new Copy(std::move(C)); }
590   { Copy* c; c = new Copy(std::move(Copy(&f_eval))); }// expected-error {{is not a constant expression}} expected-note {{to a consteval}}
591   { Copy* c; c = new Copy(to_lvalue_ref(Copy(&f_eval))); }// expected-error {{is not a constant expression}} expected-note {{to a consteval}}
592   { Copy* c; c = new Copy(to_lvalue_ref(std::move(C))); }
593   { 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}}
594 }
595 
596 } // namespace special_ctor
597 
598 namespace unevaluated {
599 
600 template <typename T, typename U> struct is_same { static const bool value = false; };
601 template <typename T> struct is_same<T, T> { static const bool value = true; };
602 
603 long f(); // expected-note {{declared here}}
g(auto a)604 auto consteval g(auto a) {
605   return a;
606 }
607 
608 auto e = g(f()); // expected-error {{is not a constant expression}}
609                  // expected-note@-1 {{non-constexpr function 'f' cannot be used in a constant expression}}
610 
611 using T = decltype(g(f()));
612 static_assert(is_same<long, T>::value);
613 
614 } // namespace unevaluated
615