clang/test/SemaCXX/cxx1y-generic-lambdas.cpp

   1 // RUN: %clang_cc1 -std=c++1y -verify -fsyntax-only -fblocks -emit-llvm-only %s
   2 // RUN: %clang_cc1 -std=c++1y -verify -fsyntax-only -fblocks -fdelayed-template-parsing %s -DDELAYED_TEMPLATE_PARSING
   3 // RUN: %clang_cc1 -std=c++1y -verify -fsyntax-only -fblocks -fms-extensions %s -DMS_EXTENSIONS
   4 // RUN: %clang_cc1 -std=c++1y -verify -fsyntax-only -fblocks -fdelayed-template-parsing -fms-extensions %s -DMS_EXTENSIONS -DDELAYED_TEMPLATE_PARSING
   5 // RUN: %clang_cc1 -std=c++1y -verify -fsyntax-only -fblocks -triple i386-windows-pc -emit-llvm-only %s
   6 // RUN: %clang_cc1 -std=c++1y -verify -fsyntax-only -fblocks -triple i386-windows-pc -fdelayed-template-parsing %s -DDELAYED_TEMPLATE_PARSING
   7 // RUN: %clang_cc1 -std=c++1y -verify -fsyntax-only -fblocks -triple i386-windows-pc -fms-extensions %s -DMS_EXTENSIONS
   8 // RUN: %clang_cc1 -std=c++1y -verify -fsyntax-only -fblocks -triple i386-windows-pc -fdelayed-template-parsing -fms-extensions %s -DMS_EXTENSIONS -DDELAYED_TEMPLATE_PARSING
   9
  10 template<class F, class ...Rest> struct first_impl { typedef F type; };
  11 template<class ...Args> using first = typename first_impl<Args...>::type;
  12
  13 namespace 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
  21 namespace explicit_call {
  22 int 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 ns
  29
  30 namespace test_conversion_to_fptr_2 {
  31
  32 template<class T> struct X {
  33
  34   T (*fp)(T) = [](auto a) { return a; };
  35
  36 };
  37
  38 X<int> xi;
  39
  40 template<class T>
  41 void fooT(T t, T (*fp)(T) = [](auto a) { return a; }) {
  42   fp(t);
  43 }
  44
  45 int 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 }
 127 int run2 = test();
 128
 129 }
 130
 131
 132 namespace test_conversion_to_fptr {
 133
 134 void f1(int (*)(int)) { }
 135 void f2(char (*)(int)) { } // expected-note{{candidate}}
 136 void g(int (*)(int)) { } // #1 expected-note{{candidate}}
 137 void g(char (*)(char)) { } // #2 expected-note{{candidate}}
 138 void h(int (*)(int)) { } // #3
 139 void h(char (*)(int)) { } // #4
 140
 141 int test() {
 142 {
 143   auto glambda = [](auto a) { return a; };
 144   glambda(1);
 145   f1(glambda); // OK
 146   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 ID
 149
 150   int& (*fpi)(int*) = [](auto* a) -> auto& { return *a; }; // OK
 151
 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
 179 namespace more_converion_to_ptr_to_function_tests {
 180
 181
 182 int test() {
 183   {
 184     int& (*fpi)(int*) = [](auto* a) -> auto& { return *a; }; // OK
 185     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
 199 template<class ... Ts> void vfun(Ts ... ) { }
 200
 201 int 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 ns
 212
 213 namespace 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 (*)(type-parameter-0-0){{.*}}' 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)', and
 228     // 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
 235 namespace 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
 242 namespace generic_lambda_as_default_argument_ok {
 243   void test(int i = [](auto a)->int { return a; }(3)) {
 244   }
 245 }
 246
 247 namespace nested_non_capturing_lambda_tests {
 248 template<class ... Ts> void print(Ts ...) { }
 249 int 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);  //ok
 275       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 'int (*)(type-parameter-0-0){{.*}}' against '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 };
 395 X x;
 396 x.test();
 397 }
 398 // Make sure we can escape the function
 399 {
 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
 471 namespace wrapped_within_templates {
 472
 473 namespace explicit_return {
 474 template<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
 492 int run = fooT('a') + fooT(3.14);
 493
 494 } // end explicit_return
 495
 496 namespace implicit_return_deduction {
 497 template<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
 515 int run = fooT('a') + fooT(3.14);
 516
 517 template<class ... Ts> void print(Ts ... ts) { }
 518
 519 template<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
 540 int run2 = fooV(3.14, " ", '4', 5) + fooV("BC", 3, 2.77, 'A', float{}, short{}, unsigned{});
 541
 542 } //implicit_return_deduction
 543
 544
 545 } //wrapped_within_templates
 546
 547 namespace 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   }
 571 auto L = test();
 572 auto L_test = L('4');
 573 auto M = L('3');
 574 auto M_test = M('a');
 575 auto N = M('x');
 576 auto O = N("\n3 = ", 3, "\n6.14 = ", 6.14, "\n4'123'456 = ", 4'123'456);
 577 char (*np)(const char*, int, const char*, double, const char*, int) = O;
 578 auto NP_result = np("\n3 = ", 3, "\n6.14 = ", 6.14, "\n4'123'456 = ", 4'123'456);
 579 int (*np2)(const char*, int, const char*, double, const char*, int) = O; // expected-error{{no viable conversion}}
 580
 581
 582
 583 }
 584
 585 namespace variadic_tests_1 {
 586 template<class ... Ts> void print(Ts ... ts) { }
 587
 588 template<class F, class ... Rest> F& FirstArg(F& f, Rest...) { return f; }
 589
 590 template<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
 611 int run2 = fooV(3.14, " ", '4', 5) + fooV("BC", 3, 2.77, 'A', float{}, short{}, unsigned{});
 612
 613 namespace more_variadic_1 {
 614
 615 template<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
 663 int run2 = fooV(3.14, " ", '4', 5) + fooV("BC", 3, 2.77, 'A', float{}, short{}, unsigned{});
 664
 665
 666 } //end ns more_variadic_1
 667
 668 } // end ns variadic_tests_1
 669
 670 namespace 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 };
 696 X x;
 697 auto L = x.test();
 698 auto L_test = L('4');
 699 auto M = L('3');
 700 auto M_test = M('a');
 701 auto N = M('x');
 702 auto O = N("\n3 = ", 3, "\n6.14 = ", 6.14, "\n4'123'456 = ", 4'123'456);
 703 char (*np)(const char*, int, const char*, double, const char*, int) = O;
 704 auto NP_result = np("\n3 = ", 3, "\n6.14 = ", 6.14, "\n4'123'456 = ", 4'123'456);
 705 int (*np2)(const char*, int, const char*, double, const char*, int) = O; // expected-error{{no viable conversion}}
 706
 707 } //end at_ns_scope_within_class_member
 708
 709
 710 namespace 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 };
 738 X x;
 739 auto L = x.test();
 740 auto L_test = L('4');
 741 auto M = L('3');
 742 auto M_test = M('a');
 743 auto N = M('x');
 744 auto O = N("\n3 = ", 3, "\n6.14 = ", 6.14, "\n4'123'456 = ", 4'123'456);
 745 char (*np)(const char*, int, const char*, double, const char*, int) = O;
 746 auto NP_result = np("\n3 = ", 3, "\n6.14 = ", 6.14, "\n4'123'456 = ", 4'123'456);
 747 int (*np2)(const char*, int, const char*, double, const char*, int) = O; // expected-error{{no viable conversion}}
 748
 749 } //end at_ns_scope_within_class_member
 750
 751
 752 namespace nested_generic_lambdas_123 {
 753 void 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 }
 762 template<class T> void foo(T) {
 763  auto L = [](auto a) { return a; };
 764 }
 765 template void foo(int);
 766 } // end ns nested_generic_lambdas_123
 767
 768 namespace nested_fptr_235 {
 769 int 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 }
 785 int run = test();
 786 }
 787
 788
 789 namespace fptr_with_decltype_return_type {
 790 template<class F, class ... Rest> F& FirstArg(F& f, Rest& ... r) { return f; };
 791 template<class ... Ts> auto vfun(Ts&& ... ts) {
 792   print(ts...);
 793   return FirstArg(ts...);
 794 }
 795 int 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 }
 809 int run = test();
 810 }
 811
 812 } // end ns nested_non_capturing_lambda_tests
 813
 814 namespace PR17476 {
 815 struct string {
 816   string(const char *__s) { }
 817   string &operator+=(const string &__str) { return *this; }
 818 };
 819
 820 template <class T>
 821 void finalizeDefaultAtomValues() {
 822   auto startEnd = [](const char * sym) -> void {
 823     string start("__");
 824     start += sym;
 825   };
 826   startEnd("preinit_array");
 827 }
 828
 829 void f() { finalizeDefaultAtomValues<char>(); }
 830
 831 }
 832
 833 namespace PR17476_variant {
 834 struct string {
 835   string(const char *__s) { }
 836   string &operator+=(const string &__str) { return *this; }
 837 };
 838
 839 template <class T>
 840 void finalizeDefaultAtomValues() {
 841   auto startEnd = [](const T *sym) -> void {
 842     string start("__");
 843     start += sym;
 844   };
 845   startEnd("preinit_array");
 846 }
 847
 848 void f() { finalizeDefaultAtomValues<char>(); }
 849
 850 }
 851
 852 namespace PR17877_lambda_declcontext_and_get_cur_lambda_disconnect {
 853
 854
 855 template<class T> struct U {
 856   int t = 0;
 857 };
 858
 859 template<class T>
 860 struct V {
 861   U<T> size() const { return U<T>{}; }
 862 };
 863
 864 template<typename T>
 865 void Do() {
 866   V<int> v{};
 867   [=] { v.size(); };
 868 }
 869
 870 }
 871
 872 namespace inclass_lambdas_within_nested_classes {
 873 namespace ns1 {
 874
 875 struct 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 ns
 906
 907 namespace ns2 {
 908 struct 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 };
 939 template<class T>
 940 template<class U>
 941 int X1::X2<T>::fooG3(T (*fp)(U)) { return 0; }
 942 X1::X2<int> x2; //expected-note {{in instantiation of}}
 943 int run1 = x2.fooG2();
 944 int run2 = x2.fooG3();
 945 } // end ns
 946
 947
 948
 949 } //end ns inclass_lambdas_within_nested_classes
 950
 951 namespace pr21684_disambiguate_auto_followed_by_ellipsis_no_id {
 952 int a = [](auto ...) { return 0; }();
 953 }
 954
 955 namespace 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
 964 namespace 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
 973 namespace PR23716 {
 974 template<typename T>
 975 auto 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
 985 auto x = f(0)();
 986 }
 987
 988 namespace PR13987 {
 989 class 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
1001 class 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
1013 class 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
1026 namespace PR32638 {
1027  //https://bugs.llvm.org/show_bug.cgi?id=32638
1028  void test() {
1029     [](auto x) noexcept(noexcept(x)) { } (0);
1030  }
1031 }
1032
1033 namespace 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
1041 namespace GH37792 {
1042 struct A { int x; };
1043
1044 void f() {
1045   [](auto t) -> decltype(decltype(t)::x) { return 0; }(A());
1046 }
1047 }