clang/test/Analysis/DeallocUseAfterFreeErrors.m

   1 // RUN: %clang_analyze_cc1 -analyzer-checker=core,osx.cocoa.SuperDealloc,debug.ExprInspection -analyzer-output=text -verify %s
   2
   3 void clang_analyzer_warnIfReached(void);
   4
   5 #define nil ((id)0)
   6
   7 typedef unsigned long NSUInteger;
   8 @protocol NSObject
   9 - (instancetype)retain;
  10 - (oneway void)release;
  11 @end
  12
  13 @interface NSObject <NSObject> { }
  14 - (void)dealloc;
  15 - (instancetype)init;
  16 @end
  17
  18 typedef struct objc_selector *SEL;
  19
  20 //===------------------------------------------------------------------------===
  21 //  <rdar://problem/6953275>
  22 //  Check that 'self' is not referenced after calling '[super dealloc]'.
  23
  24 @interface SuperDeallocThenReleaseIvarClass : NSObject {
  25   NSObject *_ivar;
  26 }
  27 @end
  28
  29 @implementation SuperDeallocThenReleaseIvarClass
  30 - (instancetype)initWithIvar:(NSObject *)ivar {
  31   self = [super init];
  32   if (!self)
  33     return nil;
  34   _ivar = [ivar retain];
  35   return self;
  36 }
  37 - (void)dealloc {
  38   [super dealloc]; // expected-note {{[super dealloc] called here}}
  39   [_ivar release]; // expected-warning {{Use of instance variable '_ivar' after 'self' has been deallocated}}
  40   // expected-note@-1 {{Use of instance variable '_ivar' after 'self' has been deallocated}}
  41 }
  42 @end
  43
  44 @interface SuperDeallocThenAssignNilToIvarClass : NSObject {
  45   NSObject *_delegate;
  46 }
  47 @end
  48
  49 @implementation SuperDeallocThenAssignNilToIvarClass
  50 - (instancetype)initWithDelegate:(NSObject *)delegate {
  51   self = [super init];
  52   if (!self)
  53     return nil;
  54   _delegate = delegate;
  55   return self;
  56 }
  57 - (void)dealloc {
  58   [super dealloc]; // expected-note {{[super dealloc] called here}}
  59   _delegate = nil; // expected-warning {{Use of instance variable '_delegate' after 'self' has been deallocated}}
  60       // expected-note@-1 {{Use of instance variable '_delegate' after 'self' has been deallocated}}
  61 }
  62 @end
  63
  64
  65 struct SomeStruct {
  66   int f;
  67 };
  68
  69 @interface SuperDeallocThenAssignIvarField : NSObject {
  70   struct SomeStruct _s;
  71 }
  72 @end
  73
  74 @implementation SuperDeallocThenAssignIvarField
  75 - (void)dealloc {
  76   [super dealloc]; // expected-note {{[super dealloc] called here}}
  77   _s.f = 7; // expected-warning {{Use of instance variable '_s' after 'self' has been deallocated}}
  78       // expected-note@-1 {{Use of instance variable '_s' after 'self' has been deallocated}}
  79 }
  80 @end
  81
  82 @interface OtherClassWithIvar {
  83 @public
  84   int _otherIvar;
  85 }
  86 @end;
  87
  88 @interface SuperDeallocThenAssignIvarIvar : NSObject {
  89   OtherClassWithIvar *_ivar;
  90 }
  91 @end
  92
  93 @implementation SuperDeallocThenAssignIvarIvar
  94 - (void)dealloc {
  95   [super dealloc]; // expected-note {{[super dealloc] called here}}
  96   _ivar->_otherIvar = 7; // expected-warning {{Use of instance variable '_ivar' after 'self' has been deallocated}}
  97       // expected-note@-1 {{Use of instance variable '_ivar' after 'self' has been deallocated}}
  98 }
  99 @end
 100
 101 @interface SuperDeallocThenAssignSelfIvar : NSObject {
 102   NSObject *_ivar;
 103 }
 104 @end
 105
 106 @implementation SuperDeallocThenAssignSelfIvar
 107 - (void)dealloc {
 108   [super dealloc]; // expected-note {{[super dealloc] called here}}
 109   self->_ivar = nil; // expected-warning {{Use of instance variable '_ivar' after 'self' has been deallocated}}
 110       // expected-note@-1 {{Use of instance variable '_ivar' after 'self' has been deallocated}}
 111 }
 112 @end
 113
 114 @interface SuperDeallocThenReleasePropertyClass : NSObject { }
 115 @property (retain) NSObject *ivar;
 116 @end
 117
 118 @implementation SuperDeallocThenReleasePropertyClass
 119 - (instancetype)initWithProperty:(NSObject *)ivar {
 120   self = [super init];
 121   if (!self)
 122     return nil;
 123   self.ivar = ivar;
 124   return self;
 125 }
 126 - (void)dealloc {
 127   [super dealloc]; // expected-note {{[super dealloc] called here}}
 128   self.ivar = nil; // expected-warning {{Use of 'self' after it has been deallocated}}
 129       // expected-note@-1 {{Use of 'self' after it has been deallocated}}
 130 }
 131 @end
 132
 133 @interface SuperDeallocThenAssignNilToPropertyClass : NSObject { }
 134 @property (assign) NSObject *delegate;
 135 @end
 136
 137 @implementation SuperDeallocThenAssignNilToPropertyClass
 138 - (instancetype)initWithDelegate:(NSObject *)delegate {
 139   self = [super init];
 140   if (!self)
 141     return nil;
 142   self.delegate = delegate;
 143   return self;
 144 }
 145 - (void)dealloc {
 146   [super dealloc]; // expected-note {{[super dealloc] called here}}
 147   self.delegate = nil; // expected-warning {{Use of 'self' after it has been deallocated}}
 148       // expected-note@-1 {{Use of 'self' after it has been deallocated}}
 149 }
 150 @end
 151
 152 @interface SuperDeallocThenCallInstanceMethodClass : NSObject { }
 153 - (void)_invalidate;
 154 @end
 155
 156 @implementation SuperDeallocThenCallInstanceMethodClass
 157 - (void)_invalidate {
 158 }
 159 - (void)dealloc {
 160   [super dealloc]; // expected-note {{[super dealloc] called here}}
 161   [self _invalidate]; // expected-warning {{Use of 'self' after it has been deallocated}}
 162       // expected-note@-1 {{Use of 'self' after it has been deallocated}}
 163 }
 164 @end
 165
 166 @interface SuperDeallocThenCallNonObjectiveCMethodClass : NSObject { }
 167 @end
 168
 169 static void _invalidate(NSObject *object) {
 170   (void)object;
 171 }
 172
 173 @implementation SuperDeallocThenCallNonObjectiveCMethodClass
 174 - (void)dealloc {
 175   [super dealloc]; // expected-note {{[super dealloc] called here}}
 176   _invalidate(self); // expected-warning {{Use of 'self' after it has been deallocated}}
 177       // expected-note@-1 {{Use of 'self' after it has been deallocated}}
 178 }
 179 @end
 180
 181 @interface SuperDeallocThenCallObjectiveClassMethodClass : NSObject { }
 182 @end
 183
 184 @implementation SuperDeallocThenCallObjectiveClassMethodClass
 185 + (void) invalidate:(id)arg; {
 186 }
 187
 188 - (void)dealloc {
 189   [super dealloc]; // expected-note {{[super dealloc] called here}}
 190   [SuperDeallocThenCallObjectiveClassMethodClass invalidate:self]; // expected-warning {{Use of 'self' after it has been deallocated}}
 191       // expected-note@-1 {{Use of 'self' after it has been deallocated}}
 192 }
 193 @end
 194
 195 @interface TwoSuperDeallocCallsClass : NSObject {
 196   NSObject *_ivar;
 197 }
 198 - (void)_invalidate;
 199 @end
 200
 201 @implementation TwoSuperDeallocCallsClass
 202 - (void)_invalidate {
 203 }
 204 - (void)dealloc {
 205   if (_ivar) { // expected-note {{Assuming the condition is false}} expected-note {{Taking false branch}}
 206     [_ivar release];
 207     [super dealloc];
 208     return;
 209   }
 210   [super dealloc];    // expected-note {{[super dealloc] called here}}
 211   [self _invalidate]; // expected-warning {{Use of 'self' after it has been deallocated}}
 212       // expected-note@-1 {{Use of 'self' after it has been deallocated}}
 213 }
 214 @end
 215
 216 //===------------------------------------------------------------------------===
 217 // Warn about calling [super dealloc] twice due to missing return statement.
 218
 219 @interface MissingReturnCausesDoubleSuperDeallocClass : NSObject {
 220   NSObject *_ivar;
 221 }
 222 @end
 223
 224 @implementation MissingReturnCausesDoubleSuperDeallocClass
 225 - (void)dealloc {
 226   if (_ivar) { // expected-note {{Assuming the condition is true}} expected-note {{Taking true branch}}
 227     [_ivar release];
 228     [super dealloc]; // expected-note {{[super dealloc] called here}}
 229     // return;
 230   }
 231   [super dealloc]; // expected-warning{{[super dealloc] should not be called multiple times}}
 232   // expected-note@-1{{[super dealloc] should not be called multiple times}}
 233 }
 234 @end
 235
 236 //===------------------------------------------------------------------------===
 237 // Warn about calling [super dealloc] twice in two different methods.
 238
 239 @interface SuperDeallocInOtherMethodClass : NSObject {
 240   NSObject *_ivar;
 241 }
 242 - (void)_cleanup;
 243 @end
 244
 245 @implementation SuperDeallocInOtherMethodClass
 246 - (void)_cleanup {
 247   [_ivar release];
 248   [super dealloc]; // expected-note {{[super dealloc] called here}}
 249 }
 250 - (void)dealloc {
 251   [self _cleanup]; // expected-note {{Calling '_cleanup'}}
 252   //expected-note@-1 {{Returning from '_cleanup'}}
 253   [super dealloc]; // expected-warning {{[super dealloc] should not be called multiple times}}
 254   // expected-note@-1 {{[super dealloc] should not be called multiple times}}
 255 }
 256 @end
 257
 258 //===------------------------------------------------------------------------===
 259 // Do not warn about calling [super dealloc] recursively for different objects
 260 // of the same type with custom retain counting.
 261 //
 262 // A class that contains an ivar of itself with custom retain counting (such
 263 // as provided by _OBJC_SUPPORTED_INLINE_REFCNT_WITH_DEALLOC2MAIN) can generate
 264 // a false positive that [super dealloc] is called twice if each object instance
 265 // is not tracked separately by the checker. This test case is just a simple
 266 // approximation to trigger the false positive.
 267
 268 @class ClassWithOwnIvarInstanceClass;
 269 @interface ClassWithOwnIvarInstanceClass : NSObject {
 270   ClassWithOwnIvarInstanceClass *_ivar;
 271   NSUInteger _retainCount;
 272 }
 273 @end
 274
 275 @implementation ClassWithOwnIvarInstanceClass
 276 - (instancetype)retain {
 277   ++_retainCount;
 278   return self;
 279 }
 280 - (oneway void)release {
 281   --_retainCount;
 282   if (!_retainCount)
 283     [self dealloc];
 284 }
 285 - (void)dealloc {
 286   [_ivar release];
 287   [super dealloc]; // no warning: different instances of same class
 288 }
 289 @end
 290
 291 //===------------------------------------------------------------------------===
 292 // Do not warn about calling [super dealloc] twice if +dealloc is a class
 293 // method.
 294
 295 @interface SuperDeallocClassMethodIgnoredClass : NSObject { }
 296 + (void)dealloc;
 297 @end
 298
 299 @implementation SuperDeallocClassMethodIgnoredClass
 300 + (void)dealloc { }
 301 @end
 302
 303 @interface SuperDeallocClassMethodIgnoredSubClass : NSObject { }
 304 + (void)dealloc;
 305 @end
 306
 307 @implementation SuperDeallocClassMethodIgnoredSubClass
 308 + (void)dealloc {
 309   [super dealloc];
 310   [super dealloc]; // no warning: class method
 311 }
 312 @end
 313
 314 //===------------------------------------------------------------------------===
 315 // Do not warn about calling [super dealloc] twice if when the analyzer has
 316 // inlined the call to its super deallocator.
 317
 318 @interface SuperClassCallingSuperDealloc : NSObject {
 319   NSObject *_ivar;
 320 }
 321 @end
 322
 323 @implementation SuperClassCallingSuperDealloc
 324 - (void)dealloc; {
 325   [_ivar release]; // no-warning
 326
 327   [super dealloc];
 328 }
 329 @end
 330
 331 @interface SubclassCallingSuperDealloc : SuperClassCallingSuperDealloc
 332 @end
 333
 334 @implementation SubclassCallingSuperDealloc
 335 - (void)dealloc; {
 336   [super dealloc];
 337 }
 338 @end
 339
 340 //===------------------------------------------------------------------------===
 341 // Treat calling [super dealloc] twice as as a sink.
 342
 343 @interface CallingSuperDeallocTwiceIsSink : NSObject
 344 @end
 345
 346 @implementation CallingSuperDeallocTwiceIsSink
 347 - (void)dealloc; {
 348   [super dealloc]; // expected-note {{[super dealloc] called here}}
 349   [super dealloc]; // expected-warning {{[super dealloc] should not be called multiple times}}
 350   // expected-note@-1 {{[super dealloc] should not be called multiple times}}
 351
 352   clang_analyzer_warnIfReached(); // no-warning
 353 }
 354 @end
 355
 356
 357 //===------------------------------------------------------------------------===
 358 // Test path notes with intervening method call on self.
 359
 360 @interface InterveningMethodCallOnSelf : NSObject
 361 @end
 362
 363 @implementation InterveningMethodCallOnSelf
 364 - (void)anotherMethod {
 365 }
 366
 367 - (void)dealloc; {
 368   [super dealloc]; // expected-note {{[super dealloc] called here}}
 369   [self anotherMethod]; // expected-warning {{Use of 'self' after it has been deallocated}}
 370       // expected-note@-1 {{Use of 'self' after it has been deallocated}}
 371   [super dealloc];
 372 }
 373 @end