1 // RUN: %clang_cc1 -fsyntax-only -verify %s -fblocks
2 void donotwarn();
3
4 int (^IFP) ();
5 int (^II) (int);
test1()6 int test1() {
7 int (^PFR) (int) = 0; // OK
8 PFR = II; // OK
9
10 if (PFR == II) // OK
11 donotwarn();
12
13 if (PFR == IFP) // OK
14 donotwarn();
15
16 if (PFR == (int (^) (int))IFP) // OK
17 donotwarn();
18
19 if (PFR == 0) // OK
20 donotwarn();
21
22 if (PFR) // OK
23 donotwarn();
24
25 if (!PFR) // OK
26 donotwarn();
27
28 return PFR != IFP; // OK
29 }
30
31 int test2(double (^S)()) {
32 double (^I)(int) = (void*) S;
33 (void*)I = (void *)S; // expected-error {{assignment to cast is illegal, lvalue casts are not supported}}
34
35 void *pv = I;
36
37 pv = S;
38
39 I(1);
40
41 return (void*)I == (void *)S;
42 }
43
44 int^ x; // expected-error {{block pointer to non-function type is invalid}}
45 int^^ x1; // expected-error {{block pointer to non-function type is invalid}} expected-error {{block pointer to non-function type is invalid}}
46
test3()47 void test3() {
48 char *^ y; // expected-error {{block pointer to non-function type is invalid}}
49 }
50
51
52
53 enum {NSBIRLazilyAllocated = 0};
54
test4(int argc)55 int test4(int argc) { // rdar://6251437
56 ^{
57 switch (argc) {
58 case NSBIRLazilyAllocated: // is an integer constant expression.
59 default:
60 break;
61 }
62 }();
63 return 0;
64 }
65
66
67 void bar(void*);
68 // rdar://6257721 - reference to static/global is byref by default.
69 static int test5g;
test5()70 void test5() {
71 bar(^{ test5g = 1; });
72 }
73
74 // rdar://6405429 - __func__ in a block refers to the containing function name.
test6()75 const char*test6() {
76 return ^{
77 return __func__;
78 } ();
79 }
80
81 // radr://6732116 - block comparisons
82 void (^test7a)();
83 int test7(void (^p)()) {
84 return test7a == p;
85 }
86
87
test8()88 void test8() {
89 somelabel:
90 ^{ goto somelabel; }(); // expected-error {{use of undeclared label 'somelabel'}}
91 }
92
test9()93 void test9() {
94 goto somelabel; // expected-error {{use of undeclared label 'somelabel'}}
95 ^{ somelabel: ; }();
96 }
97
test10(int i)98 void test10(int i) {
99 switch (i) {
100 case 41: ;
101 ^{ case 42: ; }(); // expected-error {{'case' statement not in switch statement}}
102 }
103 }
104
test11(int i)105 void test11(int i) {
106 switch (i) {
107 case 41: ;
108 ^{ break; }(); // expected-error {{'break' statement not in loop or switch statement}}
109 }
110
111 for (; i < 100; ++i)
112 ^{ break; }(); // expected-error {{'break' statement not in loop or switch statement}}
113 }
114
115 void (^test12f)(void);
test12()116 void test12() {
117 test12f = ^test12f; // expected-error {{type name requires a specifier or qualifier}} expected-error {{expected expression}}
118 }
119
120 // rdar://6808730
121 void *test13 = ^{
122 int X = 32;
123
124 void *P = ^{
125 return X+4; // References outer block's "X", so outer block is constant.
126 };
127 };
128
test14()129 void test14() {
130 int X = 32;
131 static void *P = ^{ // expected-error {{initializer element is not a compile-time constant}}
132
133 void *Q = ^{
134 // References test14's "X": outer block is non-constant.
135 return X+4;
136 };
137 };
138 }
139
140 enum { LESS };
141
142 void foo(long (^comp)()) { // expected-note{{passing argument to parameter 'comp' here}}
143 }
144
145 void (^test15f)(void);
test15()146 void test15() {
147 foo(^{ return LESS; }); // expected-error {{incompatible block pointer types passing 'int (^)(void)' to parameter of type 'long (^)()'}}
148 }
149
150 __block int test16i; // expected-error {{__block attribute not allowed, only allowed on local variables}}
151
test16(__block int i)152 void test16(__block int i) { // expected-error {{__block attribute not allowed, only allowed on local variables}}
153 int size = 5;
154 extern __block double extern_var; // expected-error {{__block attribute not allowed, only allowed on local variables}}
155 static __block char * pch; // expected-error {{__block attribute not allowed, only allowed on local variables}}
156 __block int a[size]; // expected-error {{__block attribute not allowed on declaration with a variably modified type}}
157 __block int (*ap)[size]; // expected-error {{__block attribute not allowed on declaration with a variably modified type}}
158 }
159
160 void f();
161
test17()162 void test17() {
163 void (^bp)(int);
164 void (*rp)(int);
165 void (^bp1)();
166 void *vp = bp;
167
168 f(1 ? bp : vp);
169 f(1 ? vp : bp);
170 f(1 ? bp : bp1);
171 (void)(bp > rp); // expected-error {{invalid operands}}
172 (void)(bp > 0); // expected-error {{invalid operands}}
173 (void)(bp > bp); // expected-error {{invalid operands}}
174 (void)(bp > vp); // expected-error {{invalid operands}}
175 f(1 ? bp : rp); // expected-error {{incompatible operand types ('void (^)(int)' and 'void (*)(int)')}}
176 (void)(bp == 1); // expected-error {{invalid operands to binary expression}}
177 (void)(bp == 0);
178 (void)(1 == bp); // expected-error {{invalid operands to binary expression}}
179 (void)(0 == bp);
180 (void)(bp < 1); // expected-error {{invalid operands to binary expression}}
181 (void)(bp < 0); // expected-error {{invalid operands to binary expression}}
182 (void)(1 < bp); // expected-error {{invalid operands to binary expression}}
183 (void)(0 < bp); // expected-error {{invalid operands to binary expression}}
184 }
185
test18()186 void test18() {
187 void (^const blockA)(void) = ^{ }; // expected-note {{variable 'blockA' declared const here}}
188 blockA = ^{ }; // expected-error {{cannot assign to variable 'blockA' with const-qualified type 'void (^const)(void)}}
189 }
190
191 // rdar://7072507
test19()192 int test19() {
193 goto L0; // expected-error {{cannot jump}}
194
195 __block int x; // expected-note {{jump bypasses setup of __block variable}}
196 L0:
197 x = 0;
198 ^(){ ++x; }();
199 return x;
200 }
201
202 // radr://7438948
test20()203 void test20() {
204 int n = 7;
205 int vla[n]; // expected-note {{declared here}}
206 int (*vm)[n] = 0; // expected-note {{declared here}}
207 vla[1] = 4341;
208 ^{
209 (void)vla[1]; // expected-error {{cannot refer to declaration with a variably modified type inside block}}
210 (void)(vm+1); // expected-error {{cannot refer to declaration with a variably modified type inside block}}
211 }();
212 }
213
214 // radr://7438948
test21()215 void test21() {
216 int a[7]; // expected-note {{declared here}}
217 __block int b[10]; // expected-note {{declared here}}
218 a[1] = 1;
219 ^{
220 (void)a[1]; // expected-error {{cannot refer to declaration with an array type inside block}}
221 (void)b[1]; // expected-error {{cannot refer to declaration with an array type inside block}}
222 }();
223 }
224
225 // rdar ://8218839
226 const char * (^func)(void) = ^{ return __func__; };
227 const char * (^function)(void) = ^{ return __FUNCTION__; };
228 const char * (^pretty)(void) = ^{ return __PRETTY_FUNCTION__; };
229