1048 lines · cpp
1// RUN: %clang_cc1 -std=c++1y -verify -fblocks -emit-llvm-only %s2// RUN: %clang_cc1 -std=c++1y -verify -fsyntax-only -fblocks -fdelayed-template-parsing %s -DDELAYED_TEMPLATE_PARSING3// RUN: %clang_cc1 -std=c++1y -verify -fsyntax-only -fblocks -fms-extensions %s -DMS_EXTENSIONS4// RUN: %clang_cc1 -std=c++1y -verify -fsyntax-only -fblocks -fdelayed-template-parsing -fms-extensions %s -DMS_EXTENSIONS -DDELAYED_TEMPLATE_PARSING5// RUN: %clang_cc1 -std=c++1y -verify -fblocks -triple i386-windows-pc -emit-llvm-only %s6// RUN: %clang_cc1 -std=c++1y -verify -fsyntax-only -fblocks -triple i386-windows-pc -fdelayed-template-parsing %s -DDELAYED_TEMPLATE_PARSING7// RUN: %clang_cc1 -std=c++1y -verify -fsyntax-only -fblocks -triple i386-windows-pc -fms-extensions %s -DMS_EXTENSIONS8// RUN: %clang_cc1 -std=c++1y -verify -fsyntax-only -fblocks -triple i386-windows-pc -fdelayed-template-parsing -fms-extensions %s -DMS_EXTENSIONS -DDELAYED_TEMPLATE_PARSING9 10template<class F, class ...Rest> struct first_impl { typedef F type; };11template<class ...Args> using first = typename first_impl<Args...>::type;12 13namespace simple_explicit_capture {14 void test() {15 int i;16 auto L = [i](auto a) { return i + a; };17 L(3.14);18 }19}20 21namespace explicit_call {22int test() {23 auto L = [](auto a) { return a; };24 L.operator()(3);25 L.operator()<char>(3.14); //expected-warning{{implicit conversion}}26 return 0;27}28} //end ns29 30namespace test_conversion_to_fptr_2 {31 32template<class T> struct X {33 34 T (*fp)(T) = [](auto a) { return a; };35 36};37 38X<int> xi;39 40template<class T>41void fooT(T t, T (*fp)(T) = [](auto a) { return a; }) {42 fp(t);43}44 45int test() {46{47 auto L = [](auto a) { return a; };48 int (*fp)(int) = L;49 fp(5);50 L(3);51 char (*fc)(char) = L;52 fc('b');53 L('c');54 double (*fd)(double) = L;55 fd(3.14);56 fd(6.26);57 L(4.25);58}59{60 auto L = [](auto a) ->int { return a; }; //expected-note 2{{candidate template ignored}}61 int (*fp)(int) = L;62 char (*fc)(char) = L; //expected-error{{no viable conversion}}63 double (*fd)(double) = L; //expected-error{{no viable conversion}}64}65{66 int x = 5;67 auto L = [=](auto b, char c = 'x') {68 int i = x;69 return [](auto a) ->decltype(a) { return a; };70 };71 int (*fp)(int) = L(8);72 fp(5);73 L(3);74 char (*fc)(char) = L('a');75 fc('b');76 L('c');77 double (*fd)(double) = L(3.14);78 fd(3.14);79 fd(6.26);80 81}82{83 auto L = [=](auto b) {84 return [](auto a) ->decltype(b)* { return (decltype(b)*)0; };85 };86 int* (*fp)(int) = L(8);87 fp(5);88 L(3);89 char* (*fc)(char) = L('a');90 fc('b');91 L('c');92 double* (*fd)(double) = L(3.14);93 fd(3.14);94 fd(6.26);95}96{97 auto L = [=](auto b) {98 return [](auto a) ->decltype(b)* { return (decltype(b)*)0; }; //expected-note{{candidate template ignored}}99 };100 char* (*fp)(int) = L('8');101 fp(5);102 char* (*fc)(char) = L('a');103 fc('b');104 double* (*fi)(int) = L(3.14);105 fi(5);106 int* (*fi2)(int) = L(3.14); //expected-error{{no viable conversion}}107}108 109{110 auto L = [=](auto b) {111 return [](auto a) {112 return [=](auto c) {113 return [](auto d) ->decltype(a + b + c + d) { return d; };114 };115 };116 };117 int (*fp)(int) = L('8')(3)(short{});118 double (*fs)(char) = L(3.14)(short{})('4');119}120 121 fooT(3);122 fooT('a');123 fooT(3.14);124 fooT("abcdefg");125 return 0;126}127int run2 = test();128 129}130 131 132namespace test_conversion_to_fptr {133 134void f1(int (*)(int)) { }135void f2(char (*)(int)) { } // expected-note{{candidate}}136void g(int (*)(int)) { } // #1 expected-note{{candidate}}137void g(char (*)(char)) { } // #2 expected-note{{candidate}}138void h(int (*)(int)) { } // #3139void h(char (*)(int)) { } // #4140 141int test() {142{143 auto glambda = [](auto a) { return a; };144 glambda(1);145 f1(glambda); // OK146 f2(glambda); // expected-error{{no matching function}}147 g(glambda); // expected-error{{call to 'g' is ambiguous}}148 h(glambda); // OK: calls #3 since it is convertible from ID149 150 int& (*fpi)(int*) = [](auto* a) -> auto& { return *a; }; // OK151 152}153{154 155 auto L = [](auto a) { return a; };156 int (*fp)(int) = L;157 fp(5);158 L(3);159 char (*fc)(char) = L;160 fc('b');161 L('c');162 double (*fd)(double) = L;163 fd(3.14);164 fd(6.26);165 L(4.25);166}167{168 auto L = [](auto a) ->int { return a; }; //expected-note 2{{candidate template ignored}}169 int (*fp)(int) = L;170 char (*fc)(char) = L; //expected-error{{no viable conversion}}171 double (*fd)(double) = L; //expected-error{{no viable conversion}}172}173{174 int* (*fp)(int*) = [](auto *a) -> auto* { return a; };175 fp(0);176}177}178 179namespace more_converion_to_ptr_to_function_tests {180 181 182int test() {183 {184 int& (*fpi)(int*) = [](auto* a) -> auto& { return *a; }; // OK185 int (*fp2)(int) = [](auto b) -> int { return b; };186 int (*fp3)(char) = [](auto c) -> int { return c; };187 char (*fp4)(int) = [](auto d) { return d; }; //expected-error{{no viable conversion}}\188 //expected-note{{candidate function [with d:auto = int]}}189 char (*fp5)(char) = [](auto e) -> int { return e; }; //expected-error{{no viable conversion}}\190 //expected-note{{candidate template ignored}}191 192 fp2(3);193 fp3('\n');194 fp3('a');195 return 0;196 }197} // end test()198 199template<class ... Ts> void vfun(Ts ... ) { }200 201int variadic_test() {202 203 int (*fp)(int, char, double) = [](auto ... a) -> int { vfun(a...); return 4; };204 fp(3, '4', 3.14);205 206 int (*fp2)(int, char, double) = [](auto ... a) { vfun(a...); return 4; };207 fp(3, '4', 3.14);208 return 2;209}210 211} // end ns212 213namespace conversion_operator {214 void test() {215 auto L = [](auto a) -> int { return a; }; // expected-error {{cannot initialize}}216 int (*fp)(int) = L;217 int (&fp2)(int) = [](auto a) { return a; }; // expected-error{{non-const lvalue}}218 int (&&fp3)(int) = [](auto a) { return a; };219 // expected-error@-1 {{no viable conversion}}220 // expected-note-re@-2 {{candidate template ignored: could not match 'auto (*)(auto){{.*}}' against 'int (int)'}}221 222 using F = int(int);223 using G = int(void*);224 L.operator F*();225 L.operator G*(); // expected-note-re {{instantiation of function template specialization '{{.*}}::operator()<void *>'}}226 227 // Here, the conversion function is named 'operator auto (*)(int)', and228 // there is no way to write that name in valid C++.229 auto M = [](auto a) -> auto { return a; };230 M.operator F*(); // expected-error {{no member named 'operator int (*)(int)'}}231 }232}233}234 235namespace return_type_deduction_ok {236 auto l = [](auto a) ->auto { return a; }(2);237 auto l2 = [](auto a) ->decltype(auto) { return a; }(2);238 auto l3 = [](auto a) { return a; }(2);239 240}241 242namespace generic_lambda_as_default_argument_ok {243 void test(int i = [](auto a)->int { return a; }(3)) {244 }245}246 247namespace nested_non_capturing_lambda_tests {248template<class ... Ts> void print(Ts ...) { }249int test() {250{251 auto L = [](auto a) {252 return [](auto b) {253 return b;254 };255 };256 auto M = L(3);257 M(4.15);258 }259{260 int i = 10; //expected-note 3{{declared here}}261 auto L = [](auto a) {262 return [](auto b) { //expected-note 3{{begins here}} expected-note 6 {{capture 'i' by}} expected-note 6 {{default capture by}} expected-note {{while substituting into a lambda}}263 i = b; //expected-error 3{{cannot be implicitly captured}}264 return b;265 };266 };267 auto M = L(3); //expected-note{{instantiation}}268 M(4.15); //expected-note{{instantiation}}269 }270 {271 int i = 10;272 auto L = [](auto a) {273 return [](auto b) {274 b = sizeof(i); //ok275 return b;276 };277 };278 }279 {280 auto L = [](auto a) {281 print("a = ", a, "\n");282 return [](auto b) ->decltype(a) {283 print("b = ", b, "\n");284 return b;285 };286 };287 auto M = L(3);288 M(4.15);289 }290 291{292 auto L = [](auto a) ->decltype(a) {293 print("a = ", a, "\n");294 return [](auto b) ->decltype(a) {295 // expected-error@-1 {{no viable conversion}}296 // expected-note-re@-2 {{candidate template ignored: could not match 'auto (*)(auto){{.*}}' ({{.*}}) against 'decltype(a)' (aka 'int')}}297 print("b = ", b, "\n");298 return b;299 };300 };301 auto M = L(3); //expected-note{{in instantiation of}}302 }303{304 auto L = [](auto a) {305 print("a = ", a, "\n");306 return [](auto ... b) ->decltype(a) {307 print("b = ", b ..., "\n");308 return 4;309 };310 };311 auto M = L(3);312 M(4.15, 3, "fv");313}314 315{316 auto L = [](auto a) {317 print("a = ", a, "\n");318 return [](auto ... b) ->decltype(a) {319 print("b = ", b ..., "\n");320 return 4;321 };322 };323 auto M = L(3);324 int (*fp)(double, int, const char*) = M;325 fp(4.15, 3, "fv");326}327 328{329 auto L = [](auto a) {330 print("a = ", a, "\n");331 return [](char b) {332 return [](auto ... c) ->decltype(b) {333 print("c = ", c ..., "\n");334 return 42;335 };336 };337 };338 L(4);339 auto M = L(3);340 M('a');341 auto N = M('x');342 N("\n3 = ", 3, "\n6.14 = ", 6.14, "\n4'123'456 = ", 4'123'456);343 char (*np)(const char*, int, const char*, double, const char*, int) = N;344 np("\n3 = ", 3, "\n6.14 = ", 6.14, "\n4'123'456 = ", 4'123'456);345}346 347 348{349 auto L = [](auto a) {350 print("a = ", a, "\n");351 return [](decltype(a) b) {352 return [](auto ... c) ->decltype(b) {353 print("c = ", c ..., "\n");354 return 42;355 };356 };357 };358 L('4');359 auto M = L('3');360 M('a');361 auto N = M('x');362 N("\n3 = ", 3, "\n6.14 = ", 6.14, "\n4'123'456 = ", 4'123'456);363 char (*np)(const char*, int, const char*, double, const char*, int) = N;364 np("\n3 = ", 3, "\n6.14 = ", 6.14, "\n4'123'456 = ", 4'123'456);365}366 367 368{369 struct X {370 static void foo(double d) { }371 void test() {372 auto L = [](auto a) {373 print("a = ", a, "\n");374 foo(a);375 return [](decltype(a) b) {376 foo(b);377 foo(sizeof(a) + sizeof(b));378 return [](auto ... c) ->decltype(b) {379 print("c = ", c ..., "\n");380 foo(decltype(b){});381 foo(sizeof(decltype(a)*) + sizeof(decltype(b)*));382 return 42;383 };384 };385 };386 L('4');387 auto M = L('3');388 M('a');389 auto N = M('x');390 N("\n3 = ", 3, "\n6.14 = ", 6.14, "\n4'123'456 = ", 4'123'456);391 char (*np)(const char*, int, const char*, double, const char*, int) = N;392 np("\n3 = ", 3, "\n6.14 = ", 6.14, "\n4'123'456 = ", 4'123'456);393 }394};395X x;396x.test();397}398// Make sure we can escape the function399{400 struct X {401 static void foo(double d) { }402 auto test() {403 auto L = [](auto a) {404 print("a = ", a, "\n");405 foo(a);406 return [](decltype(a) b) {407 foo(b);408 foo(sizeof(a) + sizeof(b));409 return [](auto ... c) ->decltype(b) {410 print("c = ", c ..., "\n");411 foo(decltype(b){});412 foo(sizeof(decltype(a)*) + sizeof(decltype(b)*));413 return 42;414 };415 };416 };417 return L;418 }419};420 X x;421 auto L = x.test();422 L('4');423 auto M = L('3');424 M('a');425 auto N = M('x');426 N("\n3 = ", 3, "\n6.14 = ", 6.14, "\n4'123'456 = ", 4'123'456);427 char (*np)(const char*, int, const char*, double, const char*, int) = N;428 np("\n3 = ", 3, "\n6.14 = ", 6.14, "\n4'123'456 = ", 4'123'456);429}430 431{432 struct X {433 static void foo(double d) { }434 auto test() {435 auto L = [](auto a) {436 print("a = ", a, "\n");437 foo(a);438 return [](decltype(a) b) {439 foo(b);440 foo(sizeof(a) + sizeof(b));441 return [](auto ... c) {442 print("c = ", c ..., "\n");443 foo(decltype(b){});444 foo(sizeof(decltype(a)*) + sizeof(decltype(b)*));445 return [](decltype(c) ... d) ->decltype(a) { //expected-note{{candidate}}446 print("d = ", d ..., "\n");447 foo(decltype(b){});448 foo(sizeof(decltype(a)*) + sizeof(decltype(b)*));449 return decltype(a){};450 };451 };452 };453 };454 return L;455 }456};457 X x;458 auto L = x.test();459 L('4');460 auto M = L('3');461 M('a');462 auto N = M('x');463 auto O = N("\n3 = ", 3, "\n6.14 = ", 6.14, "\n4'123'456 = ", 4'123'456);464 char (*np)(const char*, int, const char*, double, const char*, int) = O;465 np("\n3 = ", 3, "\n6.14 = ", 6.14, "\n4'123'456 = ", 4'123'456);466 int (*np2)(const char*, int, const char*, double, const char*, int) = O; // expected-error{{no viable conversion}}467 468}469} // end test()470 471namespace wrapped_within_templates {472 473namespace explicit_return {474template<class T> int fooT(T t) {475 auto L = [](auto a) -> void {476 auto M = [](char b) -> void {477 auto N = [](auto c) -> void {478 int x = 0;479 x = sizeof(a);480 x = sizeof(b);481 x = sizeof(c);482 };483 N('a');484 N(decltype(a){});485 };486 };487 L(t);488 L(3.14);489 return 0;490}491 492int run = fooT('a') + fooT(3.14);493 494} // end explicit_return495 496namespace implicit_return_deduction {497template<class T> auto fooT(T t) {498 auto L = [](auto a) {499 auto M = [](char b) {500 auto N = [](auto c) {501 int x = 0;502 x = sizeof(a);503 x = sizeof(b);504 x = sizeof(c);505 };506 N('a');507 N(decltype(a){});508 };509 };510 L(t);511 L(3.14);512 return 0;513}514 515int run = fooT('a') + fooT(3.14);516 517template<class ... Ts> void print(Ts ... ts) { }518 519template<class ... Ts> auto fooV(Ts ... ts) {520 auto L = [](auto ... a) {521 auto M = [](decltype(a) ... b) {522 auto N = [](auto c) {523 int x = 0;524 x = sizeof...(a);525 x = sizeof...(b);526 x = sizeof(c);527 };528 N('a');529 N(N);530 N(first<Ts...>{});531 };532 M(a...);533 print("a = ", a..., "\n");534 };535 L(L, ts...);536 print("ts = ", ts..., "\n");537 return 0;538}539 540int run2 = fooV(3.14, " ", '4', 5) + fooV("BC", 3, 2.77, 'A', float{}, short{}, unsigned{});541 542} //implicit_return_deduction543 544 545} //wrapped_within_templates546 547namespace at_ns_scope {548 void foo(double d) { }549 auto test() {550 auto L = [](auto a) {551 print("a = ", a, "\n");552 foo(a);553 return [](decltype(a) b) {554 foo(b);555 foo(sizeof(a) + sizeof(b));556 return [](auto ... c) {557 print("c = ", c ..., "\n");558 foo(decltype(b){});559 foo(sizeof(decltype(a)*) + sizeof(decltype(b)*));560 return [](decltype(c) ... d) ->decltype(a) { //expected-note{{candidate}}561 print("d = ", d ..., "\n");562 foo(decltype(b){});563 foo(sizeof(decltype(a)*) + sizeof(decltype(b)*));564 return decltype(a){};565 };566 };567 };568 };569 return L;570 }571auto L = test();572auto L_test = L('4');573auto M = L('3');574auto M_test = M('a');575auto N = M('x');576auto O = N("\n3 = ", 3, "\n6.14 = ", 6.14, "\n4'123'456 = ", 4'123'456);577char (*np)(const char*, int, const char*, double, const char*, int) = O;578auto NP_result = np("\n3 = ", 3, "\n6.14 = ", 6.14, "\n4'123'456 = ", 4'123'456);579int (*np2)(const char*, int, const char*, double, const char*, int) = O; // expected-error{{no viable conversion}}580 581 582 583}584 585namespace variadic_tests_1 {586template<class ... Ts> void print(Ts ... ts) { }587 588template<class F, class ... Rest> F& FirstArg(F& f, Rest...) { return f; }589 590template<class ... Ts> int fooV(Ts ... ts) {591 auto L = [](auto ... a) -> void {592 auto M = [](decltype(a) ... b) -> void {593 auto N = [](auto c) -> void {594 int x = 0;595 x = sizeof...(a);596 x = sizeof...(b);597 x = sizeof(c);598 };599 N('a');600 N(N);601 N(first<Ts...>{});602 };603 M(a...);604 print("a = ", a..., "\n");605 };606 L(L, ts...);607 print("ts = ", ts..., "\n");608 return 0;609}610 611int run2 = fooV(3.14, " ", '4', 5) + fooV("BC", 3, 2.77, 'A', float{}, short{}, unsigned{});612 613namespace more_variadic_1 {614 615template<class ... Ts> int fooV(Ts ... ts) {616 auto L = [](auto ... a) {617 auto M = [](decltype(a) ... b) -> void {618 auto N = [](auto c) -> void {619 int x = 0;620 x = sizeof...(a);621 x = sizeof...(b);622 x = sizeof(c);623 };624 N('a');625 N(N);626 N(first<Ts...>{});627 };628 M(a...);629 return M;630 };631 auto M = L(L, ts...);632 decltype(L(L, ts...)) (*fp)(decltype(L), decltype(ts) ...) = L;633 void (*fp2)(decltype(L), decltype(ts) ...) = L(L, ts...);634 635 {636 auto L = [](auto ... a) {637 auto M = [](decltype(a) ... b) {638 auto N = [](auto c) -> void {639 int x = 0;640 x = sizeof...(a);641 x = sizeof...(b);642 x = sizeof(c);643 };644 N('a');645 N(N);646 N(first<Ts...>{});647 return N;648 };649 M(a...);650 return M;651 };652 auto M = L(L, ts...);653 decltype(L(L, ts...)) (*fp)(decltype(L), decltype(ts) ...) = L;654 fp(L, ts...);655 decltype(L(L, ts...)(L, ts...)) (*fp2)(decltype(L), decltype(ts) ...) = L(L, ts...);656 fp2 = fp(L, ts...);657 void (*fp3)(char) = fp2(L, ts...);658 fp3('a');659 }660 return 0;661}662 663int run2 = fooV(3.14, " ", '4', 5) + fooV("BC", 3, 2.77, 'A', float{}, short{}, unsigned{});664 665 666} //end ns more_variadic_1667 668} // end ns variadic_tests_1669 670namespace at_ns_scope_within_class_member {671 struct X {672 static void foo(double d) { }673 auto test() {674 auto L = [](auto a) {675 print("a = ", a, "\n");676 foo(a);677 return [](decltype(a) b) {678 foo(b);679 foo(sizeof(a) + sizeof(b));680 return [](auto ... c) {681 print("c = ", c ..., "\n");682 foo(decltype(b){});683 foo(sizeof(decltype(a)*) + sizeof(decltype(b)*));684 return [](decltype(c) ... d) ->decltype(a) { //expected-note{{candidate}}685 print("d = ", d ..., "\n");686 foo(decltype(b){});687 foo(sizeof(decltype(a)*) + sizeof(decltype(b)*));688 return decltype(a){};689 };690 };691 };692 };693 return L;694 }695};696X x;697auto L = x.test();698auto L_test = L('4');699auto M = L('3');700auto M_test = M('a');701auto N = M('x');702auto O = N("\n3 = ", 3, "\n6.14 = ", 6.14, "\n4'123'456 = ", 4'123'456);703char (*np)(const char*, int, const char*, double, const char*, int) = O;704auto NP_result = np("\n3 = ", 3, "\n6.14 = ", 6.14, "\n4'123'456 = ", 4'123'456);705int (*np2)(const char*, int, const char*, double, const char*, int) = O; // expected-error{{no viable conversion}}706 707} //end at_ns_scope_within_class_member708 709 710namespace at_ns_scope_within_class_template_member {711 struct X {712 static void foo(double d) { }713 template<class T = int>714 auto test(T = T{}) {715 auto L = [](auto a) {716 print("a = ", a, "\n");717 foo(a);718 return [](decltype(a) b) {719 foo(b);720 foo(sizeof(a) + sizeof(b));721 return [](auto ... c) {722 print("c = ", c ..., "\n");723 foo(decltype(b){});724 foo(sizeof(decltype(a)*) + sizeof(decltype(b)*));725 return [](decltype(c) ... d) ->decltype(a) { //expected-note{{candidate}}726 print("d = ", d ..., "\n");727 foo(decltype(b){});728 foo(sizeof(decltype(a)*) + sizeof(decltype(b)*));729 return decltype(a){};730 };731 };732 };733 };734 return L;735 }736 737};738X x;739auto L = x.test();740auto L_test = L('4');741auto M = L('3');742auto M_test = M('a');743auto N = M('x');744auto O = N("\n3 = ", 3, "\n6.14 = ", 6.14, "\n4'123'456 = ", 4'123'456);745char (*np)(const char*, int, const char*, double, const char*, int) = O;746auto NP_result = np("\n3 = ", 3, "\n6.14 = ", 6.14, "\n4'123'456 = ", 4'123'456);747int (*np2)(const char*, int, const char*, double, const char*, int) = O; // expected-error{{no viable conversion}}748 749} //end at_ns_scope_within_class_member750 751 752namespace nested_generic_lambdas_123 {753void test() {754 auto L = [](auto a) -> int {755 auto M = [](auto b, decltype(a) b2) -> int {756 return 1;757 };758 M(a, a);759 };760 L(3);761}762template<class T> void foo(T) {763 auto L = [](auto a) { return a; };764}765template void foo(int);766} // end ns nested_generic_lambdas_123767 768namespace nested_fptr_235 {769int test()770{771 auto L = [](auto b) {772 return [](auto a) ->decltype(a) { return a; };773 };774 int (*fp)(int) = L(8);775 fp(5);776 L(3);777 char (*fc)(char) = L('a');778 fc('b');779 L('c');780 double (*fd)(double) = L(3.14);781 fd(3.14);782 fd(6.26);783 return 0;784}785int run = test();786}787 788 789namespace fptr_with_decltype_return_type {790template<class F, class ... Rest> F& FirstArg(F& f, Rest& ... r) { return f; };791template<class ... Ts> auto vfun(Ts&& ... ts) {792 print(ts...);793 return FirstArg(ts...);794}795int test()796{797 {798 auto L = [](auto ... As) {799 return [](auto b) ->decltype(b) {800 vfun([](decltype(As) a) -> decltype(a) { return a; } ...)(first<decltype(As)...>{});801 return decltype(b){};802 };803 };804 auto LL = L(1, 'a', 3.14, "abc");805 LL("dim");806 }807 return 0;808}809int run = test();810}811 812} // end ns nested_non_capturing_lambda_tests813 814namespace PR17476 {815struct string {816 string(const char *__s) { }817 string &operator+=(const string &__str) { return *this; }818};819 820template <class T>821void finalizeDefaultAtomValues() {822 auto startEnd = [](const char * sym) -> void {823 string start("__");824 start += sym;825 };826 startEnd("preinit_array");827}828 829void f() { finalizeDefaultAtomValues<char>(); }830 831}832 833namespace PR17476_variant {834struct string {835 string(const char *__s) { }836 string &operator+=(const string &__str) { return *this; }837};838 839template <class T>840void finalizeDefaultAtomValues() {841 auto startEnd = [](const T *sym) -> void {842 string start("__");843 start += sym;844 };845 startEnd("preinit_array");846}847 848void f() { finalizeDefaultAtomValues<char>(); }849 850}851 852namespace PR17877_lambda_declcontext_and_get_cur_lambda_disconnect {853 854 855template<class T> struct U {856 int t = 0;857};858 859template<class T>860struct V {861 U<T> size() const { return U<T>{}; }862};863 864template<typename T>865void Do() {866 V<int> v{};867 [=] { v.size(); };868}869 870}871 872namespace inclass_lambdas_within_nested_classes {873namespace ns1 {874 875struct X1 {876 struct X2 {877 enum { E = [](auto i) { return i; }(3) }; //expected-error{{inside of a constant expression}}\878 //expected-error{{constant}}\879 //expected-note{{non-literal type}}880 int L = ([] (int i) { return i; })(2);881 void foo(int i = ([] (int i) { return i; })(2)) { }882 int B : ([](int i) { return i; })(3); //expected-error{{inside of a constant expression}}\883 //expected-error{{not an integral constant}}\884 //expected-note{{non-literal type}}885 int arr[([](int i) { return i; })(3)]; //expected-error{{inside of a constant expression}}\886 //expected-error{{must have a constant size}}\887 //expected-warning{{variable length arrays in C++ are a Clang extension}}\888 //expected-note-re{{non-literal type '{{.*}}' cannot be used in a constant expression}}889 int (*fp)(int) = [](int i) { return i; };890 void fooptr(int (*fp)(char) = [](char c) { return 0; }) { }891 int L2 = ([](auto i) { return i; })(2);892 void fooG(int i = ([] (auto i) { return i; })(2)) { }893 int BG : ([](auto i) { return i; })(3); //expected-error{{inside of a constant expression}} \894 //expected-error{{not an integral constant}}\895 //expected-note{{non-literal type}}896 int arrG[([](auto i) { return i; })(3)]; //expected-error{{inside of a constant expression}}\897 //expected-error{{must have a constant size}}\898 //expected-warning{{variable length arrays in C++ are a Clang extension}}\899 //expected-note-re{{non-literal type '{{.*}}' cannot be used in a constant expression}}900 901 int (*fpG)(int) = [](auto i) { return i; };902 void fooptrG(int (*fp)(char) = [](auto c) { return 0; }) { }903 };904};905} //end ns906 907namespace ns2 {908struct X1 {909 template<class T>910 struct X2 {911 int L = ([] (T i) { return i; })(2);912 void foo(int i = ([] (int i) { return i; })(2)) { }913 int B : ([](T i) { return i; })(3); //expected-error{{inside of a constant expression}}\914 //expected-error{{not an integral constant}}\915 //expected-note{{non-literal type}}916 int arr[([](T i) { return i; })(3)]; //expected-error{{inside of a constant expression}}\917 //expected-error{{must have a constant size}}\918 //expected-warning{{variable length arrays in C++ are a Clang extension}}\919 //expected-note-re{{non-literal type '{{.*}}' cannot be used in a constant expression}}920 921 int (*fp)(T) = [](T i) { return i; };922 void fooptr(T (*fp)(char) = [](char c) { return 0; }) { }923 int L2 = ([](auto i) { return i; })(2);924 void fooG(T i = ([] (auto i) { return i; })(2)) { }925 int BG : ([](auto i) { return i; })(3); //expected-error{{not an integral constant}}\926 //expected-note{{non-literal type}}\927 //expected-error{{inside of a constant expression}}928 int arrG[([](auto i) { return i; })(3)]; //expected-error{{must have a constant size}} \929 //expected-error{{inside of a constant expression}}\930 //expected-warning{{variable length arrays in C++ are a Clang extension}}\931 //expected-note-re{{non-literal type '{{.*}}' cannot be used in a constant expression}}932 933 int (*fpG)(T) = [](auto i) { return i; };934 void fooptrG(T (*fp)(char) = [](auto c) { return 0; }) { }935 template<class U = char> int fooG2(T (*fp)(U) = [](auto a) { return 0; }) { return 0; }936 template<class U = char> int fooG3(T (*fp)(U) = [](auto a) { return 0; });937 };938};939template<class T>940template<class U>941int X1::X2<T>::fooG3(T (*fp)(U)) { return 0; }942X1::X2<int> x2; //expected-note {{in instantiation of}}943int run1 = x2.fooG2();944int run2 = x2.fooG3();945} // end ns946 947 948 949} //end ns inclass_lambdas_within_nested_classes950 951namespace pr21684_disambiguate_auto_followed_by_ellipsis_no_id {952int a = [](auto ...) { return 0; }();953}954 955namespace PR22117 {956 int x = [](auto) {957 return [](auto... run_args) {958 using T = int(decltype(run_args)...);959 return 0;960 };961 }(0)(0);962}963 964namespace PR41139 {965 int y = [](auto outer) {966 return [](auto inner) {967 using T = int(decltype(outer), decltype(inner));968 return 0;969 };970 }(0)(0);971}972 973namespace PR23716 {974template<typename T>975auto f(T x) {976 auto g = [](auto&&... args) {977 auto h = [args...]() -> int {978 return 0;979 };980 return h;981 };982 return g;983}984 985auto x = f(0)();986}987 988namespace PR13987 {989class Enclosing {990 void Method(char c = []()->char {991 int d = [](auto x)->int {992 struct LocalClass {993 int Method() { return 0; }994 };995 return 0;996 }(0);997 return d; }()998 );999};1000 1001class Enclosing2 {1002 void Method(char c = [](auto x)->char {1003 int d = []()->int {1004 struct LocalClass {1005 int Method() { return 0; }1006 };1007 return 0;1008 }();1009 return d; }(0)1010 );1011};1012 1013class Enclosing3 {1014 void Method(char c = [](auto x)->char {1015 int d = [](auto y)->int {1016 struct LocalClass {1017 int Method() { return 0; }1018 };1019 return 0;1020 }(0);1021 return d; }(0)1022 );1023};1024}1025 1026namespace PR32638 {1027 //https://bugs.llvm.org/show_bug.cgi?id=326381028 void test() {1029 [](auto x) noexcept(noexcept(x)) { } (0);1030 }1031}1032 1033namespace PR46637 {1034 auto x = [](auto (*p)()) { return p(); };1035 auto y = [](auto (*p)() -> auto) { return p(); };1036 int f();1037 void *v = x(f); // expected-error {{cannot initialize a variable of type 'void *' with an rvalue of type 'int'}}1038 void *w = y(f); // expected-error {{cannot initialize a variable of type 'void *' with an rvalue of type 'int'}}1039}1040 1041namespace GH37792 {1042struct A { int x; };1043 1044void f() {1045 [](auto t) -> decltype(decltype(t)::x) { return 0; }(A());1046}1047}1048