Home | History | Annotate | Download | only in SemaCXX 
      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