Home | History | Annotate | Download | only in SemaCXX
      1 // RUN: %clang_cc1 -std=c++1y %s -verify -emit-llvm-only
      2 
      3 namespace variadic_expansion {
      4   int f(int &, char &) { return 0; }
      5   template<class ... Ts> char fv(Ts ... ts) { return 0; }
      6   // FIXME: why do we get 2 error messages
      7   template <typename ... T> void g(T &... t) { //expected-note3{{declared here}}
      8     f([&a(t)]()->decltype(auto) {
      9       return a;
     10     }() ...);
     11 
     12     auto L = [x = f([&a(t)]()->decltype(auto) { return a; }()...)]() { return x; };
     13     const int y = 10;
     14     auto M = [x = y,
     15                 &z = y](T& ... t) { };
     16     auto N = [x = y,
     17                 &z = y, n = f(t...),
     18                 o = f([&a(t)](T& ... t)->decltype(auto) { return a; }(t...)...), t...](T& ... s) {
     19                   fv([&a(t)]()->decltype(auto) {
     20                     return a;
     21                   }() ...);
     22                 };
     23     auto N2 = [x = y,                     //expected-note3{{begins here}}
     24                 &z = y, n = f(t...),
     25                 o = f([&a(t)](T& ... t)->decltype(auto) { return a; }(t...)...)](T& ... s) {
     26                   fv([&a(t)]()->decltype(auto) { //expected-error 3{{captured}}
     27                     return a;
     28                   }() ...);
     29                 };
     30 
     31   }
     32 
     33   void h(int i, char c) { g(i, c); } //expected-note{{in instantiation}}
     34 }
     35 
     36 namespace odr_use_within_init_capture {
     37 
     38 int test() {
     39 
     40   { // no captures
     41     const int x = 10;
     42     auto L = [z = x + 2](int a) {
     43       auto M = [y = x - 2](char b) {
     44         return y;
     45       };
     46       return M;
     47     };
     48 
     49   }
     50   { // should not capture
     51     const int x = 10;
     52     auto L = [&z = x](int a) {
     53       return a;;
     54     };
     55 
     56   }
     57   {
     58     const int x = 10;
     59     auto L = [k = x](char a) { //expected-note {{declared}}
     60       return [](int b) { //expected-note {{begins}}
     61         return [j = k](int c) { //expected-error {{cannot be implicitly captured}}
     62           return c;
     63         };
     64       };
     65     };
     66   }
     67   {
     68     const int x = 10;
     69     auto L = [k = x](char a) {
     70       return [=](int b) {
     71         return [j = k](int c) {
     72           return c;
     73         };
     74       };
     75     };
     76   }
     77   {
     78     const int x = 10;
     79     auto L = [k = x](char a) {
     80       return [k](int b) {
     81         return [j = k](int c) {
     82           return c;
     83         };
     84       };
     85     };
     86   }
     87 
     88   return 0;
     89 }
     90 
     91 int run = test();
     92 
     93 }
     94 
     95 namespace odr_use_within_init_capture_template {
     96 
     97 template<class T = int>
     98 int test(T t = T{}) {
     99 
    100   { // no captures
    101     const T x = 10;
    102     auto L = [z = x](char a) {
    103       auto M = [y = x](T b) {
    104         return y;
    105       };
    106       return M;
    107     };
    108 
    109   }
    110   { // should not capture
    111     const T x = 10;
    112     auto L = [&z = x](T a) {
    113       return a;;
    114     };
    115 
    116   }
    117   { // will need to capture x in outer lambda
    118     const T x = 10; //expected-note {{declared}}
    119     auto L = [z = x](char a) { //expected-note {{begins}}
    120       auto M = [&y = x](T b) { //expected-error {{cannot be implicitly captured}}
    121         return y;
    122       };
    123       return M;
    124     };
    125 
    126   }
    127   { // will need to capture x in outer lambda
    128     const T x = 10;
    129     auto L = [=,z = x](char a) {
    130       auto M = [&y = x](T b) {
    131         return y;
    132       };
    133       return M;
    134     };
    135 
    136   }
    137   { // will need to capture x in outer lambda
    138     const T x = 10;
    139     auto L = [x, z = x](char a) {
    140       auto M = [&y = x](T b) {
    141         return y;
    142       };
    143       return M;
    144     };
    145   }
    146   { // will need to capture x in outer lambda
    147     const int x = 10; //expected-note 2{{declared}}
    148     auto L = [z = x](char a) { //expected-note 2{{begins}}
    149       auto M = [&y = x](T b) { //expected-error 2{{cannot be implicitly captured}}
    150         return y;
    151       };
    152       return M;
    153     };
    154   }
    155   {
    156     // no captures
    157     const T x = 10;
    158     auto L = [z =
    159                   [z = x, &y = x](char a) { return z + y; }('a')](char a)
    160       { return z; };
    161 
    162   }
    163 
    164   return 0;
    165 }
    166 
    167 int run = test(); //expected-note {{instantiation}}
    168 
    169 }