231 lines · cpp
1// RUN: %clang_cc1 -std=c++1y %s -verify -emit-llvm-only2// RUN: %clang_cc1 -std=c++1z %s -verify -emit-llvm-only3 4namespace variadic_expansion {5 int f(int &, char &) { return 0; }6 template<class ... Ts> char fv(Ts ... ts) { return 0; }7 // FIXME: why do we get 2 error messages8 template <typename ... T> void g(T &... t) { //expected-note3{{declared here}}9 f([&a(t)]()->decltype(auto) {10 return a;11 }() ...);12 13 auto L = [x = f([&a(t)]()->decltype(auto) { return a; }()...)]() { return x; };14 const int y = 10;15 auto M = [x = y, 16 &z = y](T& ... t) { }; 17 auto N = [x = y, 18 &z = y, n = f(t...), 19 o = f([&a(t)](T& ... t)->decltype(auto) { return a; }(t...)...), t...](T& ... s) { 20 fv([&a(t)]()->decltype(auto) { 21 return a;22 }() ...);23 }; 24 auto N2 = [x = y, //expected-note3{{begins here}} expected-note 6 {{default capture by}}25 &z = y, n = f(t...), 26 o = f([&a(t)](T& ... t)->decltype(auto) { return a; }(t...)...)](T& ... s) { // expected-note 6 {{capture 't' by}} expected-note {{substituting into a lambda}}27 fv([&a(t)]()->decltype(auto) { //expected-error 3{{captured}}28 return a;29 }() ...);30 }; 31 32 }33 34 void h(int i, char c) { g(i, c); } // expected-note {{requested here}}35}36 37namespace odr_use_within_init_capture {38 39int test() {40 41 { // no captures42 const int x = 10;43 auto L = [z = x + 2](int a) {44 auto M = [y = x - 2](char b) {45 return y;46 };47 return M;48 };49 50 }51 { // should not capture52 const int x = 10;53 auto L = [&z = x](int a) {54 return a;;55 };56 57 }58 {59 const int x = 10;60 auto L = [k = x](char a) { //expected-note {{declared}}61 return [](int b) { //expected-note {{begins}} expected-note 2 {{capture 'k' by}} expected-note 2 {{default capture by}}62 return [j = k](int c) { //expected-error {{cannot be implicitly captured}}63 return c;64 };65 };66 };67 }68 {69 const int x = 10;70 auto L = [k = x](char a) { 71 return [=](int b) { 72 return [j = k](int c) { 73 return c;74 };75 };76 };77 }78 {79 const int x = 10;80 auto L = [k = x](char a) { 81 return [k](int b) { 82 return [j = k](int c) { 83 return c;84 };85 };86 };87 }88 89 return 0;90}91 92int run = test();93 94}95 96namespace odr_use_within_init_capture_template {97 98template<class T = int>99int test(T t = T{}) {100 101 { // no captures102 const T x = 10;103 auto L = [z = x](char a) {104 auto M = [y = x](T b) {105 return y;106 };107 return M;108 };109 110 }111 { // should not capture112 const T x = 10;113 auto L = [&z = x](T a) {114 return a;;115 };116 117 }118 { // will need to capture x in outer lambda119 const T x = 10; //expected-note {{declared}}120 auto L = [z = x](char a) { //expected-note {{begins}} expected-note 2 {{capture 'x' by}} expected-note 2 {{default capture by}} expected-note {{substituting into a lambda}}121 auto M = [&y = x](T b) { //expected-error {{cannot be implicitly captured}}122 return y;123 };124 return M;125 };126 }127 { // will need to capture x in outer lambda128 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 lambda138 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 lambda147 const int x = 10; //expected-note {{declared}}148 auto L = [z = x](char a) { //expected-note {{begins}} expected-note 2 {{capture 'x' by}} expected-note 2 {{default capture by}} expected-note {{substituting into a lambda}}149 auto M = [&y = x](T b) { //expected-error {{cannot be implicitly captured}}150 return y;151 };152 return M;153 };154 }155 {156 // no captures157 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 167int run = test(); //expected-note 2 {{instantiation}}168 169}170 171namespace classification_of_captures_of_init_captures {172 173template <typename T>174void f() {175 [a = 24] () mutable {176 [&a] { a = 3; }();177 }();178}179 180template <typename T>181void h() {182 [a = 24] (auto param) mutable {183 [&a] { a = 3; }();184 }(42);185}186 187int run() {188 f<int>();189 h<int>();190}191 192}193 194namespace N3922 {195 struct X { X(); explicit X(const X&); int n; };196 auto a = [x{X()}] { return x.n; }; // ok197 auto b = [x = {X()}] {}; // expected-error{{<initializer_list>}}198}199 200namespace init_capture_non_mutable {201void 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 210namespace init_capture_undeclared_identifier {211 auto a = [x = y]{}; // expected-error{{use of undeclared identifier 'y'}}212 213 int typo_foo; // expected-note 2 {{'typo_foo' declared here}}214 auto b = [x = typo_boo]{}; // expected-error{{use of undeclared identifier 'typo_boo'; did you mean 'typo_foo'}}215 auto c = [x(typo_boo)]{}; // expected-error{{use of undeclared identifier 'typo_boo'; did you mean 'typo_foo'}}216}217 218namespace copy_evasion {219 struct A {220 A();221 A(const A&) = delete;222 };223 auto x = [a{A()}] {};224#if __cplusplus >= 201702L225 // ok, does not copy an 'A'226#else227 // expected-error@-4 {{call to deleted}}228 // expected-note@-7 {{deleted}}229#endif230}231