1 // RUN: %clang_cc1 -std=c++1z -verify -fsyntax-only -fblocks %s -fcxx-exceptions 2 // RUN: %clang_cc1 -std=c++20 -verify -fsyntax-only -fblocks %s -fcxx-exceptions 3 // RUN: %clang_cc1 -std=c++1z -verify -fsyntax-only -fblocks -fdelayed-template-parsing %s -fcxx-exceptions 4 // RUN: %clang_cc1 -std=c++14 -verify -fsyntax-only -fblocks %s -DCPP14_AND_EARLIER -fcxx-exceptions 5 6 7 namespace test_lambda_is_literal { 8 #ifdef CPP14_AND_EARLIER 9 //expected-error@+4{{not a literal type}} 10 //expected-note@+2{{lambda closure types are non-literal types before C++17}} 11 #endif 12 auto L = [] { }; 13 constexpr int foo(decltype(L) l) { return 0; } 14 15 } 16 17 #ifndef CPP14_AND_EARLIER 18 namespace test_constexpr_checking { 19 20 namespace ns1 { 21 struct NonLit { ~NonLit(); }; //expected-note{{not literal}} 22 auto L = [](NonLit NL) constexpr { }; //expected-error{{not a literal type}} 23 } // end ns1 24 25 namespace ns2 { 26 auto L = [](int I) constexpr { if (I == 5) asm("non-constexpr"); }; 27 #if __cpp_constexpr < 201907L 28 //expected-warning@-2{{use of this statement in a constexpr function is a C++20 extension}} 29 #endif 30 } // end ns1 31 32 // This is not constexpr until C++20, as the requirements on constexpr 33 // functions don't permit try-catch blocks. 34 #if __cplusplus <= 201703L 35 // expected-error@#try-catch {{constant expression}} 36 // expected-note@#try-catch {{non-constexpr function 'operator()'}} 37 // expected-note@#try-catch {{declared here}} 38 #endif 39 constexpr int try_catch = [] { // #try-catch 40 try { return 0; } catch (...) { return 1; } 41 }(); 42 43 // These lambdas have constexpr operator() even though they can never produce a 44 // constant expression. 45 auto never_constant_1 = [] { // expected-note {{here}} 46 volatile int n = 0; 47 return n; 48 }; 49 auto never_constant_2 = [] () -> int { // expected-note {{here}} 50 }; 51 struct test_never_constant { 52 #if __cplusplus >= 201703L 53 // expected-error@+3 {{non-constexpr declaration of 'operator()' follows constexpr declaration}} 54 // expected-error@+3 {{non-constexpr declaration of 'operator()' follows constexpr declaration}} 55 #endif 56 friend auto decltype(never_constant_1)::operator()() const; 57 friend int decltype(never_constant_2)::operator()() const; 58 }; 59 60 } // end ns test_constexpr_checking 61 62 namespace test_constexpr_call { 63 64 namespace ns1 { 65 auto L = [](int I) { return I; }; 66 static_assert(L(3) == 3); 67 } // end ns1 68 namespace ns2 { 69 auto L = [](auto a) { return a; }; 70 static_assert(L(3) == 3); 71 static_assert(L(3.14) == 3.14); 72 } 73 namespace ns3 { 74 auto L = [](auto a) { asm("non-constexpr"); return a; }; 75 constexpr int I = //expected-error{{must be initialized by a constant expression}} 76 L(3); 77 #if __cpp_constexpr < 201907L 78 //expected-note@-2{{non-constexpr function}} 79 //expected-note@-5{{declared here}} 80 #else 81 //expected-note@-7{{subexpression not valid in a constant expression}} 82 //expected-note@-6{{in call to}} 83 #endif 84 } 85 86 } // end ns test_constexpr_call 87 88 namespace test_captureless_lambda { 89 void f() { 90 const char c = 'c'; 91 auto L = [] { return c; }; 92 constexpr char C = L(); 93 } 94 95 void f(char c) { //expected-note{{declared here}} 96 auto L = [] { return c; }; //expected-error{{cannot be implicitly captured}} expected-note{{lambda expression begins here}} expected-note 2 {{capture 'c' by}} expected-note 2 {{default capture by}} 97 int I = L(); 98 } 99 100 } 101 102 namespace test_conversion_function_for_non_capturing_lambdas { 103 104 namespace ns1 { 105 auto L = [](int i) { return i; }; 106 constexpr int (*fpi)(int) = L; 107 static_assert(fpi(3) == 3); 108 auto GL = [](auto a) { return a; }; 109 110 constexpr char (*fp2)(char) = GL; 111 constexpr double (*fp3)(double) = GL; 112 constexpr const char* (*fp4)(const char*) = GL; 113 static_assert(fp2('3') == '3'); 114 static_assert(fp3(3.14) == 3.14); 115 constexpr const char *Str = "abc"; 116 static_assert(fp4(Str) == Str); 117 118 auto NCL = [](int i) { static int j; return j; }; //expected-note{{declared here}} 119 constexpr int (*fp5)(int) = NCL; 120 constexpr int I = //expected-error{{must be initialized by a constant expression}} 121 fp5(5); //expected-note{{non-constexpr function}} 122 123 namespace test_dont_always_instantiate_constexpr_templates { 124 125 auto explicit_return_type = [](auto x) -> int { return x.get(); }; 126 decltype(explicit_return_type(0)) c; // OK 127 128 auto deduced_return_type = [](auto x) { return x.get(); }; //expected-error{{not a structure or union}} 129 decltype(deduced_return_type(0)) d; //expected-note{{requested here}} 130 131 132 133 } // end ns test_dont_always_instantiate_constexpr_templates 134 } // end ns1 135 136 } // end ns test_conversion_function_for_non_capturing_lambdas 137 138 namespace test_lambda_is_cce { 139 namespace ns1_simple_lambda { 140 141 namespace ns0 { 142 constexpr int I = [](auto a) { return a; }(10); 143 144 static_assert(I == 10); 145 static_assert(10 == [](auto a) { return a; }(10)); 146 static_assert(3.14 == [](auto a) { return a; }(3.14)); 147 148 } //end ns0 149 150 namespace ns1 { 151 constexpr auto f(int i) { 152 double d = 3.14; 153 auto L = [=](auto a) { 154 int Isz = sizeof(i); 155 return sizeof(i) + sizeof(a) + sizeof(d); 156 }; 157 int I = L("abc") + L(nullptr); 158 return L; 159 } 160 constexpr auto L = f(3); 161 constexpr auto M = L("abc") + L(nullptr); 162 163 static_assert(M == sizeof(int) * 2 + sizeof(double) * 2 + sizeof(nullptr) + sizeof(const char*)); 164 165 } // end ns1 166 167 namespace ns2 { 168 constexpr auto f(int i) { 169 auto L = [](auto a) { return a + a; }; 170 return L; 171 } 172 constexpr auto L = f(3); 173 constexpr int I = L(6); 174 static_assert(I == 12); 175 } // end ns2 176 177 namespace contained_lambdas_call_operator_is_not_constexpr { 178 constexpr auto f(int i) { 179 double d = 3.14; 180 auto L = [=](auto a) { 181 int Isz = sizeof(i); 182 asm("hello"); 183 return sizeof(i) + sizeof(a) + sizeof(d); 184 }; 185 return L; 186 } 187 188 constexpr auto L = f(3); 189 190 constexpr auto M = // expected-error{{must be initialized by}} 191 L("abc"); 192 #if __cpp_constexpr < 201907L 193 //expected-note@-2{{non-constexpr function}} 194 //expected-note@-14{{declared here}} 195 #else 196 //expected-note@-14{{subexpression not valid in a constant expression}} 197 //expected-note@-6{{in call to}} 198 #endif 199 } // end ns contained_lambdas_call_operator_is_not_constexpr 200 201 202 203 } // end ns1_simple_lambda 204 205 namespace test_captures_1 { 206 namespace ns1 { 207 constexpr auto f(int i) { 208 struct S { int x; } s = { i * 2 }; 209 auto L = [=](auto a) { 210 return i + s.x + a; 211 }; 212 return L; 213 } 214 constexpr auto M = f(3); 215 216 static_assert(M(10) == 19); 217 218 } // end test_captures_1::ns1 219 220 namespace ns2 { 221 222 constexpr auto foo(int n) { 223 auto L = [i = n] (auto N) mutable { 224 if (!N(i)) throw "error"; 225 return [&i] { 226 return ++i; 227 }; 228 }; 229 auto M = L([n](int p) { return p == n; }); 230 M(); M(); 231 L([n](int p) { return p == n + 2; }); 232 233 return L; 234 } 235 236 constexpr auto L = foo(3); 237 238 } // end test_captures_1::ns2 239 namespace ns3 { 240 241 constexpr auto foo(int n) { 242 auto L = [i = n] (auto N) mutable { 243 if (!N(i)) throw "error"; 244 return [&i] { 245 return [i]() mutable { 246 return ++i; 247 }; 248 }; 249 }; 250 auto M = L([n](int p) { return p == n; }); 251 M()(); M()(); 252 L([n](int p) { return p == n; }); 253 254 return L; 255 } 256 257 constexpr auto L = foo(3); 258 } // end test_captures_1::ns3 259 260 namespace ns2_capture_this_byval { 261 struct S { 262 int s; 263 constexpr S(int s) : s{s} { } 264 constexpr auto f(S o) { 265 return [*this,o] (auto a) { return s + o.s + a.s; }; 266 } 267 }; 268 269 constexpr auto L = S{5}.f(S{10}); 270 static_assert(L(S{100}) == 115); 271 } // end test_captures_1::ns2_capture_this_byval 272 273 namespace ns2_capture_this_byref { 274 275 struct S { 276 int s; 277 constexpr S(int s) : s{s} { } 278 constexpr auto f() const { 279 return [this] { return s; }; 280 } 281 }; 282 283 constexpr S SObj{5}; 284 constexpr auto L = SObj.f(); 285 constexpr int I = L(); 286 static_assert(I == 5); 287 288 } // end ns2_capture_this_byref 289 290 } // end test_captures_1 291 292 namespace test_capture_array { 293 namespace ns1 { 294 constexpr auto f(int I) { 295 int arr[] = { I, I *2, I * 3 }; 296 auto L1 = [&] (auto a) { return arr[a]; }; 297 int r = L1(2); 298 struct X { int x, y; }; 299 return [=](auto a) { return X{arr[a],r}; }; 300 } 301 constexpr auto L = f(3); 302 static_assert(L(0).x == 3); 303 static_assert(L(0).y == 9); 304 static_assert(L(1).x == 6); 305 static_assert(L(1).y == 9); 306 } // end ns1 307 308 } // end test_capture_array 309 namespace ns1_test_lvalue_type { 310 void f() { 311 volatile int n; 312 constexpr bool B = [&]{ return &n; }() == &n; // should be accepted 313 } 314 } // end ns1_unimplemented 315 316 } // end ns test_lambda_is_cce 317 318 namespace PR36054 { 319 constexpr int fn() { 320 int Capture = 42; 321 return [=]() constexpr { return Capture; }(); 322 } 323 324 static_assert(fn() == 42, ""); 325 326 template <class T> 327 constexpr int tfn() { 328 int Capture = 42; 329 return [=]() constexpr { return Capture; }(); 330 } 331 332 static_assert(tfn<int>() == 42, ""); 333 334 constexpr int gfn() { 335 int Capture = 42; 336 return [=](auto P) constexpr { return Capture + P; }(58); 337 } 338 339 static_assert(gfn() == 100, ""); 340 341 constexpr bool OtherCaptures() { 342 int Capture = 42; 343 constexpr auto Outer = [](auto P) constexpr { return 42 + P; }; 344 auto Inner = [&](auto O) constexpr { return O(58) + Capture; }; 345 return Inner(Outer) == 142; 346 } 347 348 static_assert(OtherCaptures(), ""); 349 } // namespace PR36054 350 351 #endif // ndef CPP14_AND_EARLIER 352 353 354 #if __cpp_constexpr >= 201907L 355 namespace GH114234 { 356 template <auto Arg> 357 auto g() { return Arg; } 358 359 template <typename> 360 auto f() { 361 []<typename>() { 362 g<[] { return 123; }()>(); 363 }.template operator()<int>(); 364 } 365 366 void test() { f<int>(); } 367 } 368 369 namespace GH97958 { 370 static_assert( 371 []<int I=0>() -> decltype([]{ return true; }) 372 { return {}; }()()); 373 } 374 375 #endif 376