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