Clang Project

clang_source_code/test/SemaObjC/block-type-safety.m
1// RUN: %clang_cc1 -fsyntax-only -verify -fblocks -Wno-objc-root-class %s
2// test for block type safety.
3
4@interface Super  @end
5@interface Sub : Super @end
6
7void f2(void(^f)(Super *)) { // expected-note{{passing argument to parameter 'f' here}}
8    Super *o;
9    f(o);
10}
11
12void f3(void(^f)(Sub *)) {
13    Sub *o;
14    f(o);
15}
16
17void r0(Super* (^f)()) {
18     Super *o = f();
19}
20
21void r1(Sub* (^f)()) { // expected-note{{passing argument to parameter 'f' here}}
22    Sub *o = f();
23}
24
25@protocol NSObject;
26@class NSObject;
27
28void r2 (id<NSObject> (^f) (void)) {
29  id o = f();
30}
31
32void test1() {
33    f2(^(Sub *o) { });    // expected-error {{incompatible block pointer types passing}}
34    f3(^(Super *o) { });  // OK, block taking Super* may be called with a Sub*
35
36    r0(^Super* () { return 0; });  // OK
37    r0(^Sub* () { return 0; });    // OK, variable of type Super* gets return value of type Sub*
38    r0(^id () { return 0; });
39
40    r1(^Super* () { return 0; });  // expected-error {{incompatible block pointer types passing}}
41    r1(^Sub* () { return 0; });    // OK
42    r1(^id () { return 0; }); 
43     
44    r2(^id<NSObject>() { return 0; });
45}
46
47
48@interface A @end
49@interface B @end
50
51void f0(void (^f)(A* x)) {
52  A* a;
53  f(a);
54}
55
56void f1(void (^f)(id x)) {
57  B *b;
58  f(b);
59}
60
61void test2(void) 
62{ 
63  f0(^(id a) { }); // OK
64  f1(^(A* a) { });
65   f1(^(id<NSObject> a) { }); // OK
66}
67
68@interface NSArray
69   // Calls block() with every object in the array
70   -enumerateObjectsWithBlock:(void (^)(id obj))block;
71@end
72
73@interface MyThing
74-(void) printThing;
75@end
76
77@implementation MyThing
78    static NSArray* myThings;  // array of MyThing*
79
80   -(void) printThing {  }
81
82// programmer wants to write this:
83   -printMyThings1 {
84       [myThings enumerateObjectsWithBlock: ^(MyThing *obj) {
85           [obj printThing];
86       }];
87   }
88
89// strict type safety requires this:
90   -printMyThings {
91       [myThings enumerateObjectsWithBlock: ^(id obj) {
92           MyThing *obj2 = (MyThing *)obj;
93           [obj2 printThing];
94       }];
95   }
96@end
97
98@protocol P, P2;
99void f4(void (^f)(id<P> x)) { // expected-note{{passing argument to parameter 'f' here}}
100    NSArray<P2> *b;
101    f(b); // expected-warning {{passing 'NSArray<P2> *' to parameter of incompatible type 'id<P>'}}
102}
103
104void test3() {
105  f4(^(NSArray<P2>* a) { });  // expected-error {{incompatible block pointer types passing 'void (^)(NSArray<P2> *)' to parameter of type 'void (^)(id<P>)'}}
106}
107
108// rdar : //8302845
109@protocol Foo @end
110
111@interface Baz @end
112
113@interface Baz(FooConformance) <Foo>
114@end
115
116@implementation Baz @end
117
118int test4 () {
119    id <Foo> (^b)() = ^{ // Doesn't work
120        return (Baz *)0;
121    };
122    return 0;
123}
124
125// rdar:// 9118343
126
127@protocol NSCopying @end
128
129@interface NSAllArray <NSCopying>
130@end
131
132@interface NSAllArray (FooConformance) <Foo>
133@end
134
135int test5() {
136    NSAllArray *(^block)(id);
137    id <Foo> (^genericBlock)(id);
138    genericBlock = block;
139    return 0;
140}
141
142// rdar://10798770
143typedef int NSInteger;
144
145typedef enum : NSInteger {NSOrderedAscending = -1L, NSOrderedSame, NSOrderedDescending} NSComparisonResult;
146
147typedef NSComparisonResult (^NSComparator)(id obj1, id obj2);
148
149@interface radar10798770
150- (void)sortUsingComparator:(NSComparator)c;
151@end
152
153void f() {
154   radar10798770 *f;
155   [f sortUsingComparator:^(id a, id b) {
156        return NSOrderedSame;
157   }];
158}
159
160// rdar://16739120
161@protocol P1 @end
162@protocol P2 @end
163
164void Test() {
165void (^aBlock)();
166id anId = aBlock;  // OK
167
168id<P1,P2> anQualId = aBlock;  // expected-error {{initializing 'id<P1,P2>' with an expression of incompatible type 'void (^)()'}}
169
170NSArray* anArray = aBlock; // expected-error {{initializing 'NSArray *' with an expression of incompatible type 'void (^)()'}}
171
172aBlock = anId; // OK
173
174id<P1,P2> anQualId1;
175aBlock = anQualId1; // expected-error {{assigning to 'void (^)()' from incompatible type 'id<P1,P2>'}}
176
177NSArray* anArray1;
178aBlock = anArray1; // expected-error {{assigning to 'void (^)()' from incompatible type 'NSArray *'}}
179}
180
181void Test2() {
182  void (^aBlock)();
183  id<NSObject> anQualId1 = aBlock; // Ok
184  id<NSObject, NSCopying> anQualId2 = aBlock; // Ok
185  id<NSObject, NSCopying, NSObject, NSCopying> anQualId3 = aBlock; // Ok
186  id <P1>  anQualId4  = aBlock; // expected-error {{initializing 'id<P1>' with an expression of incompatible type 'void (^)()'}}
187  id<NSObject, P1, NSCopying> anQualId5 = aBlock; // expected-error {{initializing 'id<NSObject,P1,NSCopying>' with an expression of incompatible type 'void (^)()'}}
188  id<NSCopying> anQualId6 = aBlock; // Ok
189}
190
191void Test3() {
192  void (^aBlock)();
193  NSObject *NSO = aBlock; // Ok
194  NSObject<NSObject> *NSO1 = aBlock; // Ok
195  NSObject<NSObject, NSCopying> *NSO2 = aBlock; // Ok
196  NSObject<NSObject, NSCopying, NSObject, NSCopying> *NSO3 = aBlock; // Ok
197  NSObject <P1>  *NSO4  = aBlock; // expected-error {{initializing 'NSObject<P1> *' with an expression of incompatible type 'void (^)()'}}
198  NSObject<NSObject, P1, NSCopying> *NSO5 = aBlock; // expected-error {{initializing 'NSObject<NSObject,P1,NSCopying> *' with an expression of incompatible type 'void (^)()'}}
199  NSObject<NSCopying> *NSO6 = aBlock; // Ok
200}
201
202// rdar://problem/19420731
203typedef NSObject<P1> NSObject_P1;
204typedef NSObject_P1<P2> NSObject_P1_P2;
205
206void Test4(void (^handler)(NSObject_P1_P2 *p)) {
207  Test4(^(NSObject<P2> *p) { });
208}
209
CodeThinker, Enjoy your reading code