1 // RUN: %clang_cc1 -std=c++0x -Wno-unused-value -fsyntax-only -verify -fblocks %s 2 3 namespace std { class type_info; }; 4 5 namespace ExplicitCapture { 6 class C { 7 int Member; 8 9 static void Overload(int); 10 void Overload(); 11 virtual C& Overload(float); 12 13 void ImplicitThisCapture() { 14 [](){(void)Member;}; // expected-error {{'this' cannot be implicitly captured in this context}} 15 [&](){(void)Member;}; 16 17 [this](){(void)Member;}; 18 [this]{[this]{};}; 19 []{[this]{};};// expected-error {{'this' cannot be implicitly captured in this context}} 20 []{Overload(3);}; 21 []{Overload();}; // expected-error {{'this' cannot be implicitly captured in this context}} 22 []{(void)typeid(Overload());}; 23 []{(void)typeid(Overload(.5f));};// expected-error {{'this' cannot be implicitly captured in this context}} 24 } 25 }; 26 27 void f() { 28 [this] () {}; // expected-error {{'this' cannot be captured in this context}} 29 } 30 } 31 32 namespace ReturnDeduction { 33 void test() { 34 [](){ return 1; }; 35 [](){ return 1; }; 36 [](){ return ({return 1; 1;}); }; 37 [](){ return ({return 'c'; 1;}); }; // expected-error {{must match previous return type}} \ 38 // expected-warning{{omitted result type}} 39 []()->int{ return 'c'; return 1; }; 40 [](){ return 'c'; return 1; }; // expected-error {{must match previous return type}} 41 []() { return; return (void)0; }; 42 [](){ return 1; return 1; }; // expected-warning{{omitted result type}} 43 } 44 } 45 46 namespace ImplicitCapture { 47 void test() { 48 int a = 0; // expected-note 5 {{declared}} 49 []() { return a; }; // expected-error {{variable 'a' cannot be implicitly captured in a lambda with no capture-default specified}} expected-note {{begins here}} 50 [&]() { return a; }; 51 [=]() { return a; }; 52 [=]() { int* b = &a; }; // expected-error {{cannot initialize a variable of type 'int *' with an rvalue of type 'const int *'}} 53 [=]() { return [&]() { return a; }; }; 54 []() { return [&]() { return a; }; }; // expected-error {{variable 'a' cannot be implicitly captured in a lambda with no capture-default specified}} expected-note {{lambda expression begins here}} 55 []() { return ^{ return a; }; };// expected-error {{variable 'a' cannot be implicitly captured in a lambda with no capture-default specified}} expected-note {{lambda expression begins here}} 56 []() { return [&a] { return a; }; }; // expected-error 2 {{variable 'a' cannot be implicitly captured in a lambda with no capture-default specified}} expected-note 2 {{lambda expression begins here}} 57 [=]() { return [&a] { return a; }; }; // 58 59 const int b = 2; 60 []() { return b; }; 61 62 union { // expected-note {{declared}} 63 int c; 64 float d; 65 }; 66 d = 3; 67 [=]() { return c; }; // expected-error {{unnamed variable cannot be implicitly captured in a lambda expression}} 68 69 __block int e; // expected-note 3 {{declared}} 70 [&]() { return e; }; // expected-error {{__block variable 'e' cannot be captured in a lambda expression}} 71 [&e]() { return e; }; // expected-error 2 {{__block variable 'e' cannot be captured in a lambda expression}} 72 73 int f[10]; // expected-note {{declared}} 74 [&]() { return f[2]; }; 75 (void) ^{ return []() { return f[2]; }; }; // expected-error {{variable 'f' cannot be implicitly captured in a lambda with no capture-default specified}} \ 76 // expected-note{{lambda expression begins here}} 77 78 struct G { G(); G(G&); int a; }; // expected-note 6 {{not viable}} 79 G g; 80 [=]() { const G* gg = &g; return gg->a; }; // expected-warning{{omitted result type}} 81 [=]() { return [=]{ const G* gg = &g; return gg->a; }(); }; // expected-error {{no matching constructor for initialization of 'ImplicitCapture::G'}} \ 82 // expected-warning{{omitted result type}} 83 (void)^{ return [=]{ const G* gg = &g; return gg->a; }(); }; // expected-error 2 {{no matching constructor for initialization of 'const ImplicitCapture::G'}} \ 84 // expected-warning{{omitted result type}} 85 86 const int h = a; // expected-note {{declared}} 87 []() { return h; }; // expected-error {{variable 'h' cannot be implicitly captured in a lambda with no capture-default specified}} expected-note {{lambda expression begins here}} 88 89 // The exemption for variables which can appear in constant expressions 90 // applies only to objects (and not to references). 91 // FIXME: This might be a bug in the standard. 92 static int i; 93 constexpr int &ref_i = i; // expected-note {{declared}} 94 [] { return ref_i; }; // expected-error {{variable 'ref_i' cannot be implicitly captured in a lambda with no capture-default specified}} expected-note {{lambda expression begins here}} 95 } 96 } 97 98 namespace PR12031 { 99 struct X { 100 template<typename T> 101 X(const T&); 102 ~X(); 103 }; 104 105 void f(int i, X x); 106 void g() { 107 const int v = 10; 108 f(v, [](){}); 109 } 110 } 111 112 namespace NullPtr { 113 int &f(int *p); 114 char &f(...); 115 void g() { 116 int n = 0; 117 [=] { 118 char &k = f(n); // not a null pointer constant 119 } (); 120 121 const int m = 0; 122 [=] { 123 int &k = f(m); // a null pointer constant 124 } (); 125 126 [=] () -> bool { 127 int &k = f(m); // a null pointer constant 128 return &m == 0; 129 } (); 130 131 [m] { 132 int &k = f(m); // a null pointer constant 133 } (); 134 } 135 } 136 137 void PR12248() 138 { 139 unsigned int result = 0; 140 auto l = [&]() { ++result; }; 141 } 142 143 namespace ModifyingCapture { 144 void test() { 145 int n = 0; 146 [=] { 147 n = 1; // expected-error {{cannot assign to a variable captured by copy in a non-mutable lambda}} 148 }; 149 } 150 } 151