Clang Project

clang_source_code/test/SemaCXX/lambda-expressions.cpp
1// RUN: %clang_cc1 -std=c++14 -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 'G'}}
81    (void)^{ return [=]{ const G* gg = &g; return gg->a; }(); }; // expected-error 2 {{no matching constructor for initialization of 'const 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    // References can appear in constant expressions if they are initialized by
87    // reference constant expressions.
88    int i;
89    int &ref_i = i; // expected-note {{declared}}
90    [] { 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}}
91
92    static int j;
93    int &ref_j = j;
94    [] { return ref_j; }; // ok
95  }
96}
97
98namespace SpecialMembers {
99  void f() {
100    auto a = []{}; // expected-note 2{{here}} expected-note 2{{candidate}}
101    decltype(a) b; // expected-error {{no matching constructor}}
102    decltype(a) c = a;
103    decltype(a) d = static_cast<decltype(a)&&>(a);
104    a = a; // expected-error {{copy assignment operator is implicitly deleted}}
105    a = static_cast<decltype(a)&&>(a); // expected-error {{copy assignment operator is implicitly deleted}}
106  }
107  struct P {
108    P(const P&) = delete; // expected-note {{deleted here}}
109  };
110  struct Q {
111    ~Q() = delete; // expected-note {{deleted here}}
112  };
113  struct R {
114    R(const R&) = default;
115    R(R&&) = delete;
116    R &operator=(const R&) = delete;
117    R &operator=(R&&) = delete;
118  };
119  void g(P &p, Q &q, R &r) {
120    auto pp = [p]{}; // expected-error {{deleted constructor}}
121    auto qq = [q]{}; // expected-error {{deleted function}} expected-note {{because}}
122
123    auto a = [r]{}; // expected-note 2{{here}}
124    decltype(a) b = a;
125    decltype(a) c = static_cast<decltype(a)&&>(a); // ok, copies R
126    a = a; // expected-error {{copy assignment operator is implicitly deleted}}
127    a = static_cast<decltype(a)&&>(a); // expected-error {{copy assignment operator is implicitly deleted}}
128  }
129}
130
131namespace PR12031 {
132  struct X {
133    template<typename T>
134    X(const T&);
135    ~X();
136  };
137
138  void f(int i, X x);
139  void g() {
140    const int v = 10;
141    f(v, [](){});
142  }
143}
144
145namespace Array {
146  int &f(int *p);
147  char &f(...);
148  void g() {
149    int n = -1;
150    [=] {
151      int arr[n]; // VLA
152    } ();
153
154    const int m = -1;
155    [] {
156      int arr[m]; // expected-error{{negative size}}
157    } ();
158
159    [&] {
160      int arr[m]; // expected-error{{negative size}}
161    } ();
162
163    [=] {
164      int arr[m]; // expected-error{{negative size}}
165    } ();
166
167    [m] {
168      int arr[m]; // expected-error{{negative size}}
169    } ();
170  }
171}
172
173void PR12248()
174{
175  unsigned int result = 0;
176  auto l = [&]() { ++result; };
177}
178
179namespace ModifyingCapture {
180  void test() {
181    int n = 0;
182    [=] {
183      n = 1; // expected-error {{cannot assign to a variable captured by copy in a non-mutable lambda}}
184    };
185  }
186}
187
188namespace VariadicPackExpansion {
189  template<typename T, typename U> using Fst = T;
190  template<typename...Ts> bool g(Fst<bool, Ts> ...bools);
191  template<typename...Ts> bool f(Ts &&...ts) {
192    return g<Ts...>([&ts] {
193      if (!ts)
194        return false;
195      --ts;
196      return true;
197    } () ...);
198  }
199  void h() {
200    int a = 5, b = 2, c = 3;
201    while (f(a, b, c)) {
202    }
203  }
204
205  struct sink {
206    template<typename...Ts> sink(Ts &&...) {}
207  };
208
209  template<typename...Ts> void local_class() {
210    sink {
211      [] (Ts t) {
212        struct S : Ts {
213          void f(Ts t) {
214            Ts &that = *this;
215            that = t;
216          }
217          Ts g() { return *this; };
218        };
219        S s;
220        s.f(t);
221        return s;
222      } (Ts()).g() ...
223    };
224  };
225  struct X {}; struct Y {};
226  template void local_class<X, Y>();
227
228  template<typename...Ts> void nested(Ts ...ts) {
229    f(
230      // Each expansion of this lambda implicitly captures all of 'ts', because
231      // the inner lambda also expands 'ts'.
232      [&] {
233        return ts + [&] { return f(ts...); } ();
234      } () ...
235    );
236  }
237  template void nested(int, int, int);
238
239  template<typename...Ts> void nested2(Ts ...ts) { // expected-note 2{{here}}
240    // Capture all 'ts', use only one.
241    f([&ts...] { return ts; } ()...);
242    // Capture each 'ts', use it.
243    f([&ts] { return ts; } ()...);
244    // Capture all 'ts', use all of them.
245    f([&ts...] { return (int)f(ts...); } ());
246    // Capture each 'ts', use all of them. Ill-formed. In more detail:
247    //
248    // We instantiate two lambdas here; the first captures ts$0, the second
249    // captures ts$1. Both of them reference both ts parameters, so both are
250    // ill-formed because ts can't be implicitly captured.
251    //
252    // FIXME: This diagnostic does not explain what's happening. We should
253    // specify which 'ts' we're referring to in its diagnostic name. We should
254    // also say which slice of the pack expansion is being performed in the
255    // instantiation backtrace.
256    f([&ts] { return (int)f(ts...); } ()...); // \
257    // expected-error 2{{'ts' cannot be implicitly captured}} \
258    // expected-note 2{{lambda expression begins here}}
259  }
260  template void nested2(int); // ok
261  template void nested2(int, int); // expected-note {{in instantiation of}}
262}
263
264namespace PR13860 {
265  void foo() {
266    auto x = PR13860UndeclaredIdentifier(); // expected-error {{use of undeclared identifier 'PR13860UndeclaredIdentifier'}}
267    auto y = [x]() { };
268    static_assert(sizeof(y), "");
269  }
270}
271
272namespace PR13854 {
273  auto l = [](void){};
274}
275
276namespace PR14518 {
277  auto f = [](void) { return __func__; }; // no-warning
278}
279
280namespace PR16708 {
281  auto L = []() {
282    auto ret = 0;
283    return ret;
284    return 0;
285  };
286}
287
288namespace TypeDeduction {
289  struct S {};
290  void f() {
291    const S s {};
292    S &&t = [&] { return s; } ();
293#if __cplusplus > 201103L
294    S &&u = [&] () -> auto { return s; } ();
295#endif
296  }
297}
298
299
300namespace lambdas_in_NSDMIs {
301  template<class T>
302  struct L {
303      T t{};
304      T t2 = ([](int a) { return [](int b) { return b; };})(t)(t);    
305  };
306  L<int> l; 
307  
308  namespace non_template {
309    struct L {
310      int t = 0;
311      int t2 = ([](int a) { return [](int b) { return b; };})(t)(t);    
312    };
313    L l; 
314  }
315}
316
317// PR18477: don't try to capture 'this' from an NSDMI encountered while parsing
318// a lambda.
319namespace NSDMIs_in_lambdas {
320  template<typename T> struct S { int a = 0; int b = a; };
321  void f() { []() { S<int> s; }; }
322
323  auto x = []{ struct S { int n, m = n; }; };
324  auto y = [&]{ struct S { int n, m = n; }; }; // expected-error {{non-local lambda expression cannot have a capture-default}}
325  void g() { auto z = [&]{ struct S { int n, m = n; }; }; }
326}
327
328namespace CaptureIncomplete {
329  struct Incomplete; // expected-note 2{{forward decl}}
330  void g(const Incomplete &a);
331  void f(Incomplete &a) {
332    (void) [a] {}; // expected-error {{incomplete}}
333    (void) [&a] {};
334
335    (void) [=] { g(a); }; // expected-error {{incomplete}}
336    (void) [&] { f(a); };
337  }
338}
339
340namespace CaptureAbstract {
341  struct S {
342    virtual void f() = 0; // expected-note {{unimplemented}}
343    int n = 0;
344  };
345  struct T : S {
346    constexpr T() {}
347    void f();
348  };
349  void f() {
350    constexpr T t = T();
351    S &s = const_cast<T&>(t);
352    // FIXME: Once we properly compute odr-use per DR712, this should be
353    // accepted (and should not capture 's').
354    [=] { return s.n; }; // expected-error {{abstract}}
355  }
356}
357
358namespace PR18128 {
359  auto l = [=]{}; // expected-error {{non-local lambda expression cannot have a capture-default}}
360
361  struct S {
362    int n;
363    int (*f())[true ? 1 : ([=]{ return n; }(), 0)];
364    // expected-error@-1 {{non-local lambda expression cannot have a capture-default}}
365    // expected-error@-2 {{invalid use of non-static data member 'n'}}
366    // expected-error@-3 {{a lambda expression may not appear inside of a constant expression}}
367    int g(int k = ([=]{ return n; }(), 0));
368    // expected-error@-1 {{non-local lambda expression cannot have a capture-default}}
369    // expected-error@-2 {{invalid use of non-static data member 'n'}}
370
371    int a = [=]{ return n; }(); // ok
372    int b = [=]{ return [=]{ return n; }(); }(); // ok
373    int c = []{ int k = 0; return [=]{ return k; }(); }(); // ok
374    int d = []{ return [=]{ return n; }(); }(); // expected-error {{'this' cannot be implicitly captured in this context}}
375  };
376}
377
378namespace PR18473 {
379  template<typename T> void f() {
380    T t(0);
381    (void) [=]{ int n = t; }; // expected-error {{deleted}}
382  }
383
384  template void f<int>();
385  struct NoCopy {
386    NoCopy(int);
387    NoCopy(const NoCopy &) = delete; // expected-note {{deleted}}
388    operator int() const;
389  };
390  template void f<NoCopy>(); // expected-note {{instantiation}}
391}
392
393void PR19249() {
394  auto x = [&x]{}; // expected-error {{cannot appear in its own init}}
395}
396
397namespace PR20731 {
398template <class L, int X = sizeof(L)>
399void Job(L l);
400
401template <typename... Args>
402void Logger(Args &&... args) {
403  auto len = Invalid_Function((args)...);
404  // expected-error@-1 {{use of undeclared identifier 'Invalid_Function'}}
405  Job([len]() {});
406}
407
408void GetMethod() {
409  Logger();
410  // expected-note@-1 {{in instantiation of function template specialization 'PR20731::Logger<>' requested here}}
411}
412
413template <typename T>
414struct A {
415  T t;
416  // expected-error@-1 {{field has incomplete type 'void'}}
417};
418
419template <typename F>
420void g(F f) {
421  auto a = A<decltype(f())>{};
422  // expected-note@-1 {{in instantiation of template class 'PR20731::A<void>' requested here}}
423  auto xf = [a, f]() {};
424  int x = sizeof(xf);
425};
426void f() {
427  g([] {});
428  // expected-note-re@-1 {{in instantiation of function template specialization 'PR20731::g<(lambda at {{.*}}>' requested here}}
429}
430
431template <class _Rp> struct function {
432  template <class _Fp>
433  function(_Fp) {
434    static_assert(sizeof(_Fp) > 0, "Type must be complete.");
435  }
436};
437
438template <typename T> void p(T t) {
439  auto l = some_undefined_function(t);
440  // expected-error@-1 {{use of undeclared identifier 'some_undefined_function'}}
441  function<void()>(([l]() {}));
442}
443void q() { p(0); }
444// expected-note@-1 {{in instantiation of function template specialization 'PR20731::p<int>' requested here}}
445}
446
447namespace lambda_in_default_mem_init {
448  template<typename T> void f() {
449    struct S { int n = []{ return 0; }(); };
450  }
451  template void f<int>();
452
453  template<typename T> void g() {
454    struct S { int n = [](int n){ return n; }(0); };
455  }
456  template void g<int>();
457}
458
459namespace error_in_transform_prototype {
460  template<class T>
461  void f(T t) {
462    // expected-error@+2 {{type 'int' cannot be used prior to '::' because it has no members}}
463    // expected-error@+1 {{no member named 'ns' in 'error_in_transform_prototype::S'}}
464    auto x = [](typename T::ns::type &k) {};
465  }
466  class S {};
467  void foo() {
468    f(5); // expected-note {{requested here}}
469    f(S()); // expected-note {{requested here}}
470  }
471}
472
473namespace PR21857 {
474  template<typename Fn> struct fun : Fn {
475    fun() = default;
476    using Fn::operator();
477  };
478  template<typename Fn> fun<Fn> wrap(Fn fn);
479  auto x = wrap([](){});
480}
481
482namespace PR13987 {
483class Enclosing {
484  void Method(char c = []()->char {
485    int d = []()->int {
486        struct LocalClass {
487          int Method() { return 0; }
488        };
489      return 0;
490    }();
491    return d; }()
492  );
493};
494}
495
496namespace PR23860 {
497template <class> struct A {
498  void f(int x = []() {
499    struct B {
500      void g() {}
501    };
502    return 0;
503  }());
504};
505
506int main() {
507}
508
509A<int> a;
510}
511
512// rdar://22032373
513namespace rdar22032373 {
514void foo() {
515  auto blk = [](bool b) {
516    if (b)
517      return undeclared_error; // expected-error {{use of undeclared identifier}}
518    return 0;
519  };
520}
521}
522
523namespace nested_lambda {
524template <int N>
525class S {};
526
527void foo() {
528  const int num = 18; 
529  auto outer = []() {
530    auto inner = [](S<num> &X) {};  
531  };
532}
533}
534
535namespace PR27994 {
536struct A { template <class T> A(T); };
537
538template <class T>
539struct B {
540  int x;
541  A a = [&] { int y = x; };
542  A b = [&] { [&] { [&] { int y = x; }; }; };
543  A d = [&](auto param) { int y = x; };
544  A e = [&](auto param) { [&] { [&](auto param2) { int y = x; }; }; };
545};
546
547B<int> b;
548
549template <class T> struct C {
550  struct D {
551    int x;
552    A f = [&] { int y = x; };
553  };
554};
555
556int func() {
557  C<int> a;
558  decltype(a)::D b;
559}
560}
561
562namespace PR30566 {
563int name1; // expected-note {{'name1' declared here}}
564
565struct S1 {
566  template<class T>
567  S1(T t) { s = sizeof(t); }
568  int s;
569};
570
571void foo1() {
572  auto s0 = S1{[name=]() {}}; // expected-error 2 {{expected expression}}
573  auto s1 = S1{[name=name]() {}}; // expected-error {{use of undeclared identifier 'name'; did you mean 'name1'?}}
574}
575}
576
577namespace PR25627_dont_odr_use_local_consts {
578  
579  template<int> struct X {};
580  
581  void foo() {
582    const int N = 10;
583    (void) [] { X<N> x; };
584  }
585}
586
587namespace ConversionOperatorDoesNotHaveDeducedReturnType {
588  auto x = [](int){};
589  auto y = [](auto) -> void {};
590  using T = decltype(x);
591  using U = decltype(y);
592  using ExpectedTypeT = void (*)(int);
593  template<typename T>
594    using ExpectedTypeU = void (*)(T);
595
596  struct X {
597    friend T::operator ExpectedTypeT() const;
598
599    // Formally, this is invalid, because the return type of the conversion
600    // function for a generic lambda expression is an unspecified decltype
601    // type, which this should not match. However, this declaration is
602    // functionally equivalent to that one, so we're permitted to choose to
603    // accept this.
604    template<typename T>
605      friend U::operator ExpectedTypeU<T>() const;
606  };
607
608  // This used to crash in return type deduction for the conversion opreator.
609  struct A { int n; void f() { +[](decltype(n)) {}; } };
610}
611
612namespace TypoCorrection {
613template <typename T> struct X {};
614// expected-note@-1 {{template parameter is declared here}}
615
616template <typename T>
617void Run(const int& points) {
618// expected-note@-1 {{'points' declared here}}
619  auto outer_lambda = []() {
620    auto inner_lambda = [](const X<Points>&) {};
621    // expected-error@-1 {{use of undeclared identifier 'Points'; did you mean 'points'?}}
622    // expected-error@-2 {{template argument for template type parameter must be a type}}
623  };
624}
625}
626
CodeThinker, Enjoy your reading code