1// RUN: %clang_cc1 -std=c++0x -Wno-unused-value -fsyntax-only -verify -fblocks %s
2
3namespace std { class type_info; };
4
5namespace 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
32namespace 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    []()->int{ return 'c'; return 1; };
39    [](){ return 'c'; return 1; };  // expected-error {{must match previous return type}}
40    []() { return; return (void)0; };
41    [](){ return 1; return 1; };
42  }
43}
44
45namespace ImplicitCapture {
46  void test() {
47    int a = 0; // expected-note 5 {{declared}}
48    []() { return a; }; // expected-error {{variable 'a' cannot be implicitly captured in a lambda with no capture-default specified}} expected-note {{begins here}}
49    [&]() { return a; };
50    [=]() { return a; };
51    [=]() { int* b = &a; }; // expected-error {{cannot initialize a variable of type 'int *' with an rvalue of type 'const int *'}}
52    [=]() { return [&]() { return a; }; };
53    []() { 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}}
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 [&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}}
56    [=]() { return [&a] { return a; }; }; //
57
58    const int b = 2;
59    []() { return b; };
60
61    union { // expected-note {{declared}}
62      int c;
63      float d;
64    };
65    d = 3;
66    [=]() { return c; }; // expected-error {{unnamed variable cannot be implicitly captured in a lambda expression}}
67
68    __block int e; // expected-note 3 {{declared}}
69    [&]() { return e; }; // expected-error {{__block variable 'e' cannot be captured in a lambda expression}}
70    [&e]() { return e; }; // expected-error 2 {{__block variable 'e' cannot be captured in a lambda expression}}
71
72    int f[10]; // expected-note {{declared}}
73    [&]() { return f[2]; };
74    (void) ^{ return []() { return f[2]; }; }; // expected-error {{variable 'f' cannot be implicitly captured in a lambda with no capture-default specified}} \
75    // expected-note{{lambda expression begins here}}
76
77    struct G { G(); G(G&); int a; }; // expected-note 6 {{not viable}}
78    G g;
79    [=]() { const G* gg = &g; return gg->a; };
80    [=]() { return [=]{ const G* gg = &g; return gg->a; }(); }; // expected-error {{no matching constructor for initialization of 'ImplicitCapture::G'}}
81    (void)^{ return [=]{ const G* gg = &g; return gg->a; }(); }; // expected-error 2 {{no matching constructor for initialization of 'const ImplicitCapture::G'}}
82
83    const int h = a; // expected-note {{declared}}
84    []() { return h; }; // expected-error {{variable 'h' cannot be implicitly captured in a lambda with no capture-default specified}} expected-note {{lambda expression begins here}}
85
86    // The exemption for variables which can appear in constant expressions
87    // applies only to objects (and not to references).
88    // FIXME: This might be a bug in the standard.
89    static int i;
90    constexpr int &ref_i = i; // expected-note {{declared}}
91    [] { 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}}
92  }
93}
94
95namespace PR12031 {
96  struct X {
97    template<typename T>
98    X(const T&);
99    ~X();
100  };
101
102  void f(int i, X x);
103  void g() {
104    const int v = 10;
105    f(v, [](){});
106  }
107}
108
109namespace NullPtr {
110  int &f(int *p);
111  char &f(...);
112  void g() {
113    int n = 0;
114    [=] {
115      char &k = f(n); // not a null pointer constant
116    } ();
117
118    const int m = 0;
119    [=] {
120      int &k = f(m); // expected-warning{{expression which evaluates to zero treated as a null pointer constant of type 'int *'}}
121    } ();
122
123    [=] () -> bool {
124      int &k = f(m); // expected-warning{{expression which evaluates to zero treated as a null pointer constant of type 'int *'}}
125      return &m == 0;
126    } ();
127
128    [m] {
129      int &k = f(m); // expected-warning{{expression which evaluates to zero treated as a null pointer constant of type 'int *'}}
130    } ();
131  }
132}
133
134void PR12248()
135{
136  unsigned int result = 0;
137  auto l = [&]() { ++result; };
138}
139
140namespace ModifyingCapture {
141  void test() {
142    int n = 0;
143    [=] {
144      n = 1; // expected-error {{cannot assign to a variable captured by copy in a non-mutable lambda}}
145    };
146  }
147}
148
149namespace VariadicPackExpansion {
150  template<typename T, typename U> using Fst = T;
151  template<typename...Ts> bool g(Fst<bool, Ts> ...bools);
152  template<typename...Ts> bool f(Ts &&...ts) {
153    return g<Ts...>([&ts] {
154      if (!ts)
155        return false;
156      --ts;
157      return true;
158    } () ...);
159  }
160  void h() {
161    int a = 5, b = 2, c = 3;
162    while (f(a, b, c)) {
163    }
164  }
165
166  struct sink {
167    template<typename...Ts> sink(Ts &&...) {}
168  };
169
170  template<typename...Ts> void local_class() {
171    sink {
172      [] (Ts t) {
173        struct S : Ts {
174          void f(Ts t) {
175            Ts &that = *this;
176            that = t;
177          }
178          Ts g() { return *this; };
179        };
180        S s;
181        s.f(t);
182        return s;
183      } (Ts()).g() ...
184    };
185  };
186  struct X {}; struct Y {};
187  template void local_class<X, Y>();
188
189  template<typename...Ts> void nested(Ts ...ts) {
190    f(
191      // Each expansion of this lambda implicitly captures all of 'ts', because
192      // the inner lambda also expands 'ts'.
193      [&] {
194        return ts + [&] { return f(ts...); } ();
195      } () ...
196    );
197  }
198  template void nested(int, int, int);
199
200  template<typename...Ts> void nested2(Ts ...ts) { // expected-note 2{{here}}
201    // Capture all 'ts', use only one.
202    f([&ts...] { return ts; } ()...);
203    // Capture each 'ts', use it.
204    f([&ts] { return ts; } ()...);
205    // Capture all 'ts', use all of them.
206    f([&ts...] { return (int)f(ts...); } ());
207    // Capture each 'ts', use all of them. Ill-formed. In more detail:
208    //
209    // We instantiate two lambdas here; the first captures ts$0, the second
210    // captures ts$1. Both of them reference both ts parameters, so both are
211    // ill-formed because ts can't be implicitly captured.
212    //
213    // FIXME: This diagnostic does not explain what's happening. We should
214    // specify which 'ts' we're referring to in its diagnostic name. We should
215    // also say which slice of the pack expansion is being performed in the
216    // instantiation backtrace.
217    f([&ts] { return (int)f(ts...); } ()...); // \
218    // expected-error 2{{'ts' cannot be implicitly captured}} \
219    // expected-note 2{{lambda expression begins here}}
220  }
221  template void nested2(int); // ok
222  template void nested2(int, int); // expected-note {{in instantiation of}}
223}
224