Clang Project

clang_source_code/test/ARCMT/checking.m
1// RUN: %clang_cc1 -arcmt-check -verify -triple x86_64-apple-darwin10 -fblocks -Werror %s
2
3#if __has_feature(objc_arc)
4#define NS_AUTOMATED_REFCOUNT_UNAVAILABLE __attribute__((unavailable("not available in automatic reference counting mode")))
5#else
6#define NS_AUTOMATED_REFCOUNT_UNAVAILABLE
7#endif
8
9typedef const void * CFTypeRef;
10CFTypeRef CFBridgingRetain(id X);
11id CFBridgingRelease(CFTypeRef);
12
13typedef int BOOL;
14typedef unsigned NSUInteger;
15
16@protocol NSObject
17- (id)retain NS_AUTOMATED_REFCOUNT_UNAVAILABLE;
18- (NSUInteger)retainCount NS_AUTOMATED_REFCOUNT_UNAVAILABLE;
19- (oneway void)release NS_AUTOMATED_REFCOUNT_UNAVAILABLE;
20- (id)autorelease NS_AUTOMATED_REFCOUNT_UNAVAILABLE;
21@end
22
23@interface NSObject <NSObject> {}
24- (id)init;
25
26+ (id)new;
27+ (id)alloc;
28- (void)dealloc;
29
30- (void)finalize;
31
32- (id)copy;
33- (id)mutableCopy;
34@end
35
36typedef const struct __CFString * CFStringRef;
37extern const CFStringRef kUTTypePlainText;
38extern const CFStringRef kUTTypeRTF;
39@class NSString;
40@class A;
41
42struct UnsafeS {
43  A *__unsafe_unretained unsafeObj;
44};
45
46@interface A : NSObject
47- (id)retain __attribute__((unavailable)); // expected-note {{'retain' has been explicitly marked unavailable here}}
48- (id)retainCount __attribute__((unavailable)); // expected-note {{'retainCount' has been explicitly marked unavailable here}}
49- (id)autorelease __attribute__((unavailable)); // expected-note 2 {{'autorelease' has been explicitly marked unavailable here}}
50- (id)init;
51- (oneway void)release;
52- (void)dealloc;
53-(void)test;
54-(id)delegate;
55@end
56
57@implementation A
58-(void)test {
59  [super dealloc];
60}
61-(void)dealloc {
62  [super dealloc];
63}
64
65- (id)retain { return self; } // expected-error {{ARC forbids implementation}}
66- (id)retainCount { return self; } // expected-error {{ARC forbids implementation}}
67- (id)autorelease { return self; } // expected-error {{ARC forbids implementation}}
68- (oneway void)release { } // expected-error {{ARC forbids implementation}}
69
70-(id)delegate { return self; }
71@end
72
73id global_foo;
74
75void test1(A *a, BOOL b, struct UnsafeS *unsafeS) {
76  [[a delegate] release]; // expected-error {{it is not safe to remove 'retain' message on the result of a 'delegate' message; the object that was passed to 'setDelegate:' may not be properly retained}} \
77                          // expected-error {{ARC forbids explicit message send}}
78  [a.delegate release]; // expected-error {{it is not safe to remove 'retain' message on the result of a 'delegate' message; the object that was passed to 'setDelegate:' may not be properly retained}} \
79                        // expected-error {{ARC forbids explicit message send}}
80  [unsafeS->unsafeObj retain]; // expected-error {{it is not safe to remove 'retain' message on an __unsafe_unretained type}} \
81                               // expected-error {{ARC forbids explicit message send}} \
82                               // expected-error {{'retain' is unavailable}}
83  id foo = [unsafeS->unsafeObj retain]; // no warning.
84  [global_foo retain]; // expected-error {{it is not safe to remove 'retain' message on a global variable}} \
85                       // expected-error {{ARC forbids explicit message send}}
86  [global_foo release]; // expected-error {{it is not safe to remove 'release' message on a global variable}} \
87                        // expected-error {{ARC forbids explicit message send}}
88  [a dealloc];
89  [a retain];
90  [a retainCount]; // expected-error {{ARC forbids explicit message send of 'retainCount'}} \
91                   // expected-error {{'retainCount' is unavailable}}
92  [a release];
93  [a autorelease]; // expected-error {{it is not safe to remove an unused 'autorelease' message; its receiver may be destroyed immediately}} \
94                   // expected-error {{ARC forbids explicit message send}} \
95                   // expected-error {{'autorelease' is unavailable}}
96  [a autorelease]; // expected-error {{it is not safe to remove an unused 'autorelease' message; its receiver may be destroyed immediately}} \
97                   // expected-error {{ARC forbids explicit message send}} \
98                   // expected-error {{'autorelease' is unavailable}}
99  a = 0;
100
101  CFStringRef cfstr;
102  NSString *str = (NSString *)cfstr; // expected-error {{cast of C pointer type 'CFStringRef' (aka 'const struct __CFString *') to Objective-C pointer type 'NSString *' requires a bridged cast}} \
103  // expected-note {{use __bridge to convert directly (no change in ownership)}} \
104  // expected-note {{use CFBridgingRelease call to transfer ownership of a +1 'CFStringRef' (aka 'const struct __CFString *') into ARC}} \
105  str = (NSString *)kUTTypePlainText;
106  str = b ? kUTTypeRTF : kUTTypePlainText;
107  str = (NSString *)(b ? kUTTypeRTF : kUTTypePlainText);
108  str = (NSString *)a; // no change.
109
110  SEL s = @selector(retain);  // expected-error {{ARC forbids use of 'retain' in a @selector}}
111  s = @selector(release); // expected-error {{ARC forbids use of 'release' in a @selector}}
112  s = @selector(autorelease); // expected-error {{ARC forbids use of 'autorelease' in a @selector}}
113  s = @selector(dealloc); // expected-error {{ARC forbids use of 'dealloc' in a @selector}}
114
115  static id __autoreleasing X1; // expected-error {{global variables cannot have __autoreleasing ownership}}
116}
117
118struct S {
119  A* a;
120};
121
122@interface B
123-(id)alloc;
124- (id)initWithInt: (int) i;
125@end
126
127void rdar8861761() {
128  B *o1 = [[B alloc] initWithInt:0];
129  B *o2 = [B alloc];
130  [o2 initWithInt:0];
131}
132
133@interface Test13
134- (id) init0;
135- (void) noninit;
136@end
137@implementation Test13
138- (id) init0 {
139  self = 0;
140}
141- (void) noninit {
142  self = 0; // expected-error {{cannot assign to 'self' outside of a method in the init family}}
143
144  for (__strong id x in collection) { // expected-error {{use of undeclared identifier 'collection'}}
145    x = 0;
146  }
147}
148@end
149
150void * cvt(id arg)
151{
152  void* voidp_val;
153  (void)(int*)arg; // expected-error {{disallowed}}
154  (void)(id)arg;
155  (void)(__autoreleasing id*)arg; // expected-error {{disallowed}}
156  (void)(id*)arg; // expected-error {{disallowed}}
157
158  (void)(__autoreleasing id**)voidp_val;
159  (void)(void*)voidp_val;
160  (void)(void**)arg; // expected-error {{disallowed}}
161  cvt((void*)arg); // expected-error 2 {{requires a bridged cast}} \
162                   // expected-note 2 {{use __bridge to}} expected-note {{use CFBridgingRelease call}} expected-note {{use CFBridgingRetain call}}
163  cvt(0);
164  (void)(__strong id**)(0);
165  return arg; // expected-error {{requires a bridged cast}} expected-note {{use __bridge}} expected-note {{use CFBridgingRetain call}}
166}
167
168
169void test12(id collection) {
170  for (id x in collection) {
171    x = 0;
172  }
173
174  for (__strong id x in collection) {
175    x = 0;
176  }
177}
178
179void test6(unsigned cond) {
180  switch (cond) {
181  case 0:
182    ;
183    id x; // expected-note {{jump bypasses initialization of __strong variable}}
184
185  case 1: // expected-error {{cannot jump}}
186    x = 0;
187    break;
188  }
189}
190
191@class Test8_incomplete;
192@interface Test8_complete @end;
193@interface Test8_super @end;
194@interface Test8 : Test8_super
195- (id) init00;
196- (id) init01; // expected-note {{declaration in interface}}
197- (id) init02;
198- (id) init03; // covariance
199- (id) init04; // covariance
200- (id) init05;
201
202- (void) init10; // expected-note {{declaration in interface is not in the 'init' family because its result type is not an object pointer}}
203- (void) init11;
204- (void) init12;
205- (void) init13; // expected-note {{declaration in interface is not in the 'init' family because its result type is not an object pointer}}
206- (void) init14; // expected-note {{declaration in interface is not in the 'init' family because its result type is not an object pointer}}
207- (void) init15;
208
209// These should be invalid to actually call.
210- (Test8_incomplete*) init20;
211- (Test8_incomplete*) init21; // expected-note {{declaration in interface}}
212- (Test8_incomplete*) init22;
213- (Test8_incomplete*) init23;
214- (Test8_incomplete*) init24;
215- (Test8_incomplete*) init25;
216
217- (Test8_super*) init30; // id exception to covariance
218- (Test8_super*) init31; // expected-note {{declaration in interface}}
219- (Test8_super*) init32;
220- (Test8_super*) init33;
221- (Test8_super*) init34; // covariance
222- (Test8_super*) init35;
223
224- (Test8*) init40; // id exception to covariance
225- (Test8*) init41; // expected-note {{declaration in interface}}
226- (Test8*) init42;
227- (Test8*) init43; // this should be a warning, but that's a general language thing, not an ARC thing
228- (Test8*) init44;
229- (Test8*) init45;
230
231- (Test8_complete*) init50; // expected-error {{init methods must return a type related to the receiver type}}
232- (Test8_complete*) init51; // expected-error {{init methods must return a type related to the receiver type}}
233- (Test8_complete*) init52; // expected-error {{init methods must return a type related to the receiver type}}
234- (Test8_complete*) init53; // expected-error {{init methods must return a type related to the receiver type}}
235- (Test8_complete*) init54; // expected-error {{init methods must return a type related to the receiver type}}
236- (Test8_complete*) init55; // expected-error {{init methods must return a type related to the receiver type}}
237@end
238@implementation Test8
239- (id) init00 { return 0; }
240- (id) init10 { return 0; } // expected-error {{method implementation does not match its declaration}}
241- (id) init20 { return 0; }
242- (id) init30 { return 0; }
243- (id) init40 { return 0; }
244- (id) init50 { return 0; }
245
246- (void) init01 {} // expected-error {{method was declared as an 'init' method, but its implementation doesn't match because its result type is not an object pointer}}
247- (void) init11 {}
248- (void) init21 {} // expected-error {{method was declared as an 'init' method, but its implementation doesn't match because its result type is not an object pointer}}
249- (void) init31 {} // expected-error {{method was declared as an 'init' method, but its implementation doesn't match because its result type is not an object pointer}}
250- (void) init41 {} // expected-error {{method was declared as an 'init' method, but its implementation doesn't match because its result type is not an object pointer}}
251- (void) init51 {}
252
253- (Test8_incomplete*) init02 { return 0; } // expected-error {{init methods must return a type related to the receiver type}}
254- (Test8_incomplete*) init12 { return 0; } // expected-error {{init methods must return a type related to the receiver type}}
255- (Test8_incomplete*) init22 { return 0; } // expected-error {{init methods must return a type related to the receiver type}}
256- (Test8_incomplete*) init32 { return 0; } // expected-error {{init methods must return a type related to the receiver type}}
257- (Test8_incomplete*) init42 { return 0; } // expected-error {{init methods must return a type related to the receiver type}}
258- (Test8_incomplete*) init52 { return 0; } // expected-error {{init methods must return a type related to the receiver type}}
259
260- (Test8_super*) init03 { return 0; }
261- (Test8_super*) init13 { return 0; } // expected-error {{method implementation does not match its declaration}}
262- (Test8_super*) init23 { return 0; }
263- (Test8_super*) init33 { return 0; }
264- (Test8_super*) init43 { return 0; }
265- (Test8_super*) init53 { return 0; }
266
267- (Test8*) init04 { return 0; }
268- (Test8*) init14 { return 0; } // expected-error {{method implementation does not match its declaration}}
269- (Test8*) init24 { return 0; }
270- (Test8*) init34 { return 0; }
271- (Test8*) init44 { return 0; }
272- (Test8*) init54 { return 0; }
273
274- (Test8_complete*) init05 { return 0; } // expected-error {{init methods must return a type related to the receiver type}}
275- (Test8_complete*) init15 { return 0; } // expected-error {{init methods must return a type related to the receiver type}}
276- (Test8_complete*) init25 { return 0; } // expected-error {{init methods must return a type related to the receiver type}}
277- (Test8_complete*) init35 { return 0; } // expected-error {{init methods must return a type related to the receiver type}}
278- (Test8_complete*) init45 { return 0; } // expected-error {{init methods must return a type related to the receiver type}}
279- (Test8_complete*) init55 { return 0; } // expected-error {{init methods must return a type related to the receiver type}}
280@end
281
282@class Test9_incomplete;
283@interface Test9
284- (Test9_incomplete*) init1; // expected-error {{init methods must return a type related to the receiver type}}
285- (Test9_incomplete*) init2;
286@end
287id test9(Test9 *v) {
288  return [v init1];
289}
290
291// rdar://9491791
292void rdar9491791(int p) {
293  switch (p) {
294  case 3:;
295    NSObject *o = [[NSObject alloc] init];
296    [o release];
297    break;
298  default:
299    break;
300  }
301}
302
303#define RELEASE_MACRO(x) do { [x release]; } while(1)
304
305// rdar://9504750
306void rdar9504750(id p) {
307  RELEASE_MACRO(p); // expected-error {{ARC forbids explicit message send of 'release'}} 
308}
309
310// rdar://8939557
311@interface TestReadonlyProperty : NSObject
312@property(assign,readonly) NSObject *value;
313@end
314
315@implementation TestReadonlyProperty
316@synthesize value;
317- (void)viewDidLoad {
318  value = [NSObject new]; // expected-error {{assigning retained object}}
319}
320@end
321
322// rdar://9601437
323@interface I9601437 {
324  __unsafe_unretained id x;
325}
326-(void)Meth;
327@end
328
329@implementation I9601437
330-(void)Meth {
331  self->x = [NSObject new]; // expected-error {{assigning retained object}}
332}
333@end
334
335@interface Test10 : NSObject {
336  CFStringRef cfstr;
337}
338@property (retain) id prop;
339-(void)foo;
340@end
341
342void test(Test10 *x) {
343  x.prop = ^{ [x foo]; }; // expected-warning {{likely to lead to a retain cycle}} \
344                          // expected-note {{retained by the captured object}}
345}
346
347@implementation Test10
348-(void)foo {
349  ^{
350    NSString *str = (NSString *)cfstr; // expected-error {{cast of C pointer type 'CFStringRef' (aka 'const struct __CFString *') to Objective-C pointer type 'NSString *' requires a bridged cast}} \
351    // expected-note {{use __bridge to convert directly (no change in ownership)}} \
352    // expected-note {{use CFBridgingRelease call to transfer ownership of a +1 'CFStringRef' (aka 'const struct __CFString *') into ARC}}
353  };
354}
355@end
356
CodeThinker, Enjoy your reading code