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 } 170 171 namespace classification_of_captures_of_init_captures { 172 173 template <typename T> 174 void f() { 175 [a = 24] () mutable { 176 [&a] { a = 3; }(); 177 }(); 178 } 179 180 template <typename T> 181 void h() { 182 [a = 24] (auto param) mutable { 183 [&a] { a = 3; }(); 184 }(42); 185 } 186 187 int run() { 188 f<int>(); 189 h<int>(); 190 } 191 192 } 193 194 namespace N3922 { 195 struct X { X(); explicit X(const X&); int n; }; 196 auto a = [x{X()}] { return x.n; }; // ok 197 auto b = [x = {X()}] {}; // expected-error{{<initializer_list>}} 198 } 199 200 namespace init_capture_non_mutable { 201 void test(double weight) { 202 double init; 203 auto find = [max = init](auto current) { 204 max = current; // expected-error{{cannot assign to a variable captured by copy in a non-mutable lambda}} 205 }; 206 find(weight); // expected-note {{in instantiation of function template specialization}} 207 } 208 } 209
