1 // RUN: %clang_cc1 -triple i686-pc-linux -std=c++11 -fblocks %s -verify 2 3 void block_capture_errors() { 4 __block int var; // expected-note 2{{'var' declared here}} 5 (void)[var] { }; // expected-error{{__block variable 'var' cannot be captured in a lambda}} 6 7 (void)[=] { var = 17; }; // expected-error{{__block variable 'var' cannot be captured in a lambda}} 8 } 9 10 void conversion_to_block(int captured) { 11 int (^b1)(int) = [=](int x) { return x + captured; }; 12 13 const auto lambda = [=](int x) { return x + captured; }; 14 int (^b2)(int) = lambda; 15 } 16 17 template<typename T> 18 class ConstCopyConstructorBoom { 19 public: 20 ConstCopyConstructorBoom(ConstCopyConstructorBoom&); 21 22 ConstCopyConstructorBoom(const ConstCopyConstructorBoom&) { 23 T *ptr = 1; // expected-error{{cannot initialize a variable of type 'float *' with an rvalue of type 'int'}} 24 } 25 26 void foo() const; 27 }; 28 29 void conversion_to_block_init(ConstCopyConstructorBoom<int> boom, 30 ConstCopyConstructorBoom<float> boom2) { 31 const auto& lambda1([=] { boom.foo(); }); // okay 32 33 const auto& lambda2([=] { boom2.foo(); }); // expected-note{{in instantiation of member function}} 34 void (^block)(void) = lambda2; 35 } 36 37 38 void nesting() { 39 int array[7]; // expected-note 2{{'array' declared here}} 40 [=] () mutable { 41 [&] { 42 ^ { 43 int i = array[2]; 44 i += array[3]; 45 }(); 46 }(); 47 }(); 48 49 [&] { 50 [=] () mutable { 51 ^ { 52 int i = array[2]; // expected-error{{cannot refer to declaration with an array type inside block}} 53 i += array[3]; // expected-error{{cannot refer to declaration with an array type inside block}} 54 }(); 55 }(); 56 }(); 57 } 58 59 namespace overloading { 60 void bool_conversion() { 61 if ([](){}) { 62 } 63 64 bool b = []{}; 65 b = (bool)[]{}; 66 } 67 68 void conversions() { 69 int (*fp)(int) = [](int x) { return x + 1; }; 70 fp = [](int x) { return x + 1; }; 71 72 typedef int (*func_ptr)(int); 73 fp = (func_ptr)[](int x) { return x + 1; }; 74 75 int (^bp)(int) = [](int x) { return x + 1; }; 76 bp = [](int x) { return x + 1; }; 77 78 typedef int (^block_ptr)(int); 79 bp = (block_ptr)[](int x) { return x + 1; }; 80 } 81 82 int &accept_lambda_conv(int (*fp)(int)); 83 float &accept_lambda_conv(int (^bp)(int)); 84 85 void call_with_lambda() { 86 int &ir = accept_lambda_conv([](int x) { return x + 1; }); 87 } 88 89 template<typename T> using id = T; 90 91 auto a = [](){}; 92 struct C : decltype(a) { 93 using decltype(a)::operator id<void(*)()>; 94 private: 95 using decltype(a)::operator id<void(^)()>; 96 } extern c; 97 98 struct D : decltype(a) { 99 using decltype(a)::operator id<void(^)()>; 100 private: 101 using decltype(a)::operator id<void(*)()>; // expected-note {{here}} 102 } extern d; 103 104 bool r1 = c; 105 bool r2 = d; // expected-error {{private}} 106 } 107 108 namespace PR13117 { 109 struct A { 110 template<typename ... Args> static void f(Args...); 111 112 template<typename ... Args> static void f1() 113 { 114 (void)^(Args args) { // expected-error{{block contains unexpanded parameter pack 'Args'}} 115 }; 116 } 117 118 template<typename ... Args> static void f2() 119 { 120 // FIXME: Allow this. 121 f( 122 ^(Args args) // expected-error{{block contains unexpanded parameter pack 'Args'}} 123 { } 124 ... // expected-error{{pack expansion does not contain any unexpanded parameter packs}} 125 ); 126 } 127 128 template<typename ... Args> static void f3() 129 { 130 (void)[](Args args) { // expected-error{{expression contains unexpanded parameter pack 'Args'}} 131 }; 132 } 133 134 template<typename ... Args> static void f4() 135 { 136 f([](Args args) { } ...); 137 } 138 }; 139 140 void g() { 141 A::f1<int, int>(); 142 A::f2<int, int>(); 143 } 144 } 145
