clang/test/SemaObjC/warn-retain-cycle.m

   1 // RUN: %clang_cc1 -fsyntax-only -fobjc-runtime-has-weak -fobjc-arc -fblocks -verify -Wno-objc-root-class -Wno-implicit-retain-self %s
   2
   3 void *_Block_copy(const void *block);
   4
   5 @interface Test0
   6 - (void) setBlock: (void(^)(void)) block;
   7 - (void) addBlock: (void(^)(void)) block;
   8 - (void) actNow;
   9 @end
  10 void test0(Test0 *x) {
  11   [x setBlock: // expected-note {{block will be retained by the captured object}}
  12        ^{ [x actNow]; }]; // expected-warning {{capturing 'x' strongly in this block is likely to lead to a retain cycle}}
  13   x.block = // expected-note {{block will be retained by the captured object}}
  14        ^{ [x actNow]; }; // expected-warning {{capturing 'x' strongly in this block is likely to lead to a retain cycle}}
  15
  16   [x addBlock: // expected-note {{block will be retained by the captured object}}
  17        ^{ [x actNow]; }]; // expected-warning {{capturing 'x' strongly in this block is likely to lead to a retain cycle}}
  18
  19   // These actually don't cause retain cycles.
  20   __weak Test0 *weakx = x;
  21   [x addBlock: ^{ [weakx actNow]; }];
  22   [x setBlock: ^{ [weakx actNow]; }];
  23   x.block = ^{ [weakx actNow]; };
  24
  25   // These do cause retain cycles, but we're not clever enough to figure that out.
  26   [weakx addBlock: ^{ [x actNow]; }];
  27   [weakx setBlock: ^{ [x actNow]; }];
  28   weakx.block = ^{ [x actNow]; };
  29
  30   // rdar://11702054
  31   x.block = ^{ (void)x.actNow; };  // expected-warning {{capturing 'x' strongly in this block is likely to lead to a retain cycle}} \
  32                                    // expected-note {{block will be retained by the captured object}}
  33 }
  34
  35 @interface BlockOwner
  36 @property (retain) void (^strong)(void); // expected-warning {{retain'ed block property does not copy the block - use copy attribute instead}}
  37 @end
  38
  39 @interface Test1 {
  40 @public
  41   BlockOwner *owner;
  42 };
  43 @property (retain) BlockOwner *owner;
  44 @property (assign) __strong BlockOwner *owner2; // expected-error {{unsafe_unretained property 'owner2' may not also be declared __strong}}
  45 @property (assign) BlockOwner *owner3;
  46 @end
  47 void test1(Test1 *x) {
  48   x->owner.strong = ^{ (void) x; }; // expected-warning {{retain cycle}} expected-note {{block will be retained by an object strongly retained by the captured object}}
  49   x.owner.strong = ^{ (void) x; }; // expected-warning {{retain cycle}} expected-note {{block will be retained by an object strongly retained by the captured object}}
  50   x.owner2.strong = ^{ (void) x; };
  51   x.owner3.strong = ^{ (void) x; };
  52 }
  53
  54 @implementation Test1 {
  55   BlockOwner * __unsafe_unretained owner3ivar;
  56   __weak BlockOwner *weakowner;
  57 }
  58 @dynamic owner;
  59 @dynamic owner2;
  60 @synthesize owner3 = owner3ivar;
  61
  62 - (id) init {
  63   self.owner.strong = ^{ (void) owner; }; // expected-warning {{retain cycle}} expected-note {{block will be retained by an object strongly retained by the captured object}}
  64   self.owner2.strong = ^{ (void) owner; };
  65
  66   // TODO: should we warn here?  What's the story with this kind of mismatch?
  67   self.owner3.strong = ^{ (void) owner; };
  68
  69   owner.strong = ^{ (void) owner; }; // expected-warning {{retain cycle}} expected-note {{block will be retained by an object strongly retained by the captured object}}
  70
  71   owner.strong = ^{ ^{ (void) owner; }(); }; // expected-warning {{retain cycle}} expected-note {{block will be retained by an object strongly retained by the captured object}}
  72
  73   owner.strong = ^{ (void) sizeof(self); // expected-note {{block will be retained by an object strongly retained by the captured object}}
  74                     (void) owner; }; // expected-warning {{capturing 'self' strongly in this block is likely to lead to a retain cycle}}
  75
  76   weakowner.strong = ^{ (void) owner; };
  77
  78   return self;
  79 }
  80 - (void) foo {
  81   owner.strong = ^{ (void) owner; }; // expected-warning {{retain cycle}} expected-note {{block will be retained by an object strongly retained by the captured object}}
  82 }
  83 @end
  84
  85 void test2_helper(id);
  86 @interface Test2 {
  87   void (^block)(void);
  88   id x;
  89 }
  90 @end
  91 @implementation Test2
  92 - (void) test {
  93   block = ^{ // expected-note {{block will be retained by an object strongly retained by the captured object}}
  94     test2_helper(x); // expected-warning {{capturing 'self' strongly in this block is likely to lead to a retain cycle}}
  95   };
  96 }
  97 @end
  98
  99
 100 @interface NSOperationQueue {}
 101 - (void)addOperationWithBlock:(void (^)(void))block;
 102 - (void)addSomethingElse:(void (^)(void))block;
 103
 104 @end
 105
 106 @interface Test3 {
 107   NSOperationQueue *myOperationQueue;
 108   unsigned count;
 109 }
 110 @end
 111 void doSomething(unsigned v);
 112 @implementation Test3
 113 - (void) test {
 114   // 'addOperationWithBlock:' is specifically allowlisted.
 115   [myOperationQueue addOperationWithBlock:^() { // no-warning
 116     if (count > 20) {
 117       doSomething(count);
 118     }
 119   }];
 120 }
 121 - (void) test_positive {
 122   // Check that we are really allowlisting 'addOperationWithBlock:' and not doing
 123   // something funny.
 124   [myOperationQueue addSomethingElse:^() { // expected-note {{block will be retained by an object strongly retained by the captured object}}
 125     if (count > 20) {
 126       doSomething(count); // expected-warning {{capturing 'self' strongly in this block is likely to lead to a retain cycle}}
 127     }
 128   }];
 129 }
 130 @end
 131
 132
 133 void testBlockVariable(void) {
 134   typedef void (^block_t)(void);
 135
 136   // This case will be caught by -Wuninitialized, and does not create a
 137   // retain cycle.
 138   block_t a1 = ^{
 139     a1(); // no-warning
 140   };
 141
 142   // This case will also be caught by -Wuninitialized.
 143   block_t a2;
 144   a2 = ^{
 145     a2(); // no-warning
 146   };
 147
 148   __block block_t b1 = ^{ // expected-note{{block will be retained by the captured object}}
 149     b1(); // expected-warning{{capturing 'b1' strongly in this block is likely to lead to a retain cycle}}
 150   };
 151
 152   __block block_t b2;
 153   b2 = ^{ // expected-note{{block will be retained by the captured object}}
 154     b2(); // expected-warning{{capturing 'b2' strongly in this block is likely to lead to a retain cycle}}
 155   };
 156 }
 157
 158
 159 @interface NSObject
 160 - (id)copy;
 161
 162 - (void (^)(void))someRandomMethodReturningABlock;
 163 @end
 164
 165
 166 void testCopying(Test0 *obj) {
 167   typedef void (^block_t)(void);
 168
 169   [obj setBlock:[^{ // expected-note{{block will be retained by the captured object}}
 170     [obj actNow]; // expected-warning{{capturing 'obj' strongly in this block is likely to lead to a retain cycle}}
 171   } copy]];
 172
 173   [obj addBlock:(__bridge_transfer block_t)_Block_copy((__bridge void *)^{ // expected-note{{block will be retained by the captured object}}
 174     [obj actNow]; // expected-warning{{capturing 'obj' strongly in this block is likely to lead to a retain cycle}}
 175   })];
 176
 177   [obj addBlock:[^{
 178     [obj actNow]; // no-warning
 179   } someRandomMethodReturningABlock]];
 180
 181   extern block_t someRandomFunctionReturningABlock(block_t);
 182   [obj setBlock:someRandomFunctionReturningABlock(^{
 183     [obj actNow]; // no-warning
 184   })];
 185 }
 186
 187 // rdar://16944538
 188 void func(int someCondition) {
 189
 190 __block void(^myBlock)(void) = ^{
 191         if (someCondition) {
 192             doSomething(1);
 193             myBlock();
 194         }
 195         else {
 196             myBlock = ((void*)0);
 197         }
 198    };
 199
 200 }
 201
 202 typedef void (^a_block_t)(void);
 203
 204 @interface HonorNoEscape
 205 - (void)addStuffUsingBlock:(__attribute__((noescape)) a_block_t)block;
 206 @end
 207
 208 void testNoEscape(HonorNoEscape *obj) {
 209   [obj addStuffUsingBlock:^{
 210     (void)obj; // ok.
 211   }];
 212 }