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