Home | History | Annotate | Download | only in expr.prim.lambda
      1 // RUN: %clang_cc1 -fsyntax-only -std=c++11 %s -verify
      2 
      3 template<typename T> void capture(const T&);
      4 
      5 class NonCopyable {
      6   NonCopyable(const NonCopyable&); // expected-note 2 {{implicitly declared private here}}
      7 public:
      8   void foo() const;
      9 };
     10 
     11 class NonConstCopy {
     12 public:
     13   NonConstCopy(NonConstCopy&); // expected-note{{would lose const}}
     14 };
     15 
     16 void capture_by_copy(NonCopyable nc, NonCopyable &ncr, const NonConstCopy nco) {
     17   (void)[nc] { }; // expected-error{{capture of variable 'nc' as type 'NonCopyable' calls private copy constructor}}
     18   (void)[=] {
     19     ncr.foo(); // expected-error{{capture of variable 'ncr' as type 'NonCopyable' calls private copy constructor}}
     20   }();
     21 
     22   [nco] {}(); // expected-error{{no matching constructor for initialization of 'const NonConstCopy'}}
     23 }
     24 
     25 struct NonTrivial {
     26   NonTrivial();
     27   NonTrivial(const NonTrivial &);
     28   ~NonTrivial();
     29 };
     30 
     31 struct CopyCtorDefault {
     32   CopyCtorDefault();
     33   CopyCtorDefault(const CopyCtorDefault&, NonTrivial nt = NonTrivial());
     34 
     35   void foo() const;
     36 };
     37 
     38 void capture_with_default_args(CopyCtorDefault cct) {
     39   (void)[=] () -> void { cct.foo(); };
     40 }
     41 
     42 struct ExpectedArrayLayout {
     43   CopyCtorDefault array[3];
     44 };
     45 
     46 void capture_array() {
     47   CopyCtorDefault array[3];
     48   auto x = [=]() -> void {
     49     capture(array[0]);
     50   };
     51   static_assert(sizeof(x) == sizeof(ExpectedArrayLayout), "layout mismatch");
     52 }
     53 
     54 // Check for the expected non-static data members.
     55 
     56 struct ExpectedLayout {
     57   char a;
     58   short b;
     59 };
     60 
     61 void test_layout(char a, short b) {
     62   auto x = [=] () -> void {
     63     capture(a);
     64     capture(b);
     65   };
     66   static_assert(sizeof(x) == sizeof(ExpectedLayout), "Layout mismatch!");
     67 }
     68 
     69 struct ExpectedThisLayout {
     70   ExpectedThisLayout* a;
     71   void f() {
     72     auto x = [this]() -> void {};
     73     static_assert(sizeof(x) == sizeof(ExpectedThisLayout), "Layout mismatch!");
     74   }
     75 };
     76 
     77 struct CaptureArrayAndThis {
     78   int value;
     79 
     80   void f() {
     81     int array[3];
     82     [=]() -> int {
     83       int result = value;
     84       for (unsigned i = 0; i < 3; ++i)
     85         result += array[i];
     86       return result;
     87     }();
     88   }
     89 };
     90 
     91 namespace rdar14468891 {
     92   class X {
     93   public:
     94     virtual ~X() = 0; // expected-note{{unimplemented pure virtual method '~X' in 'X'}}
     95   };
     96 
     97   class Y : public X { };
     98 
     99   void capture(X &x) {
    100     [x]() {}(); // expected-error{{by-copy capture of value of abstract type 'rdar14468891::X'}}
    101   }
    102 }
    103 
    104 namespace rdar15560464 {
    105   struct X; // expected-note{{forward declaration of 'rdar15560464::X'}}
    106   void foo(const X& param) {
    107     auto x = ([=]() {
    108         auto& y = param; // expected-error{{by-copy capture of variable 'param' with incomplete type 'const rdar15560464::X'}}
    109       });
    110   }
    111 }
    112