2 files changed, 101 insertions, 1 deletions
diff --git a/clang/test/Analysis/inlining/RetainCountExamples.m b/clang/test/Analysis/inlining/RetainCountExamples.m
index 2b682c2b4bf..c48e7b068d8 100644
--- a/clang/test/Analysis/inlining/RetainCountExamples.m
+++ b/clang/test/Analysis/inlining/RetainCountExamples.m
@@ -30,4 +30,36 @@ typedef struct objc_object {
 void selfStaysLive() {
     SelfStaysLive *foo = [[SelfStaysLive alloc] init]; 
     [foo release];
-}
-\ No newline at end of file
+}
+
+// Test that retain release checker warns on leaks and use-after-frees when 
+// self init is not enabled.  
+// radar://12115830
+@interface ParentOfCell : NSObject
+- (id)initWithInt: (int)inInt;
+@end
+@interface Cell : ParentOfCell{
+  int x;
+}
+- (id)initWithInt: (int)inInt;
++ (void)testOverRelease;
++ (void)testLeak;
+@property int x;
+@end
+@implementation Cell
+@synthesize x;
+- (id) initWithInt: (int)inInt {
+  [super initWithInt: inInt];
+  self.x = inInt; // no-warning 
+  return self; // Self Init checker would produce a warning here.
+}
++ (void) testOverRelease {
+  Cell *sharedCell3 = [[Cell alloc] initWithInt: 3];
+  [sharedCell3 release];
+  [sharedCell3 release]; // expected-warning {{Reference-counted object is used after it is released}}
+}
++ (void) testLeak {
+  Cell *sharedCell4 = [[Cell alloc] initWithInt: 3]; // expected-warning {{leak}}
+}
+@end
+
diff --git a/clang/test/Analysis/inlining/retain-count-self-init.m b/clang/test/Analysis/inlining/retain-count-self-init.m
new file mode 100644
index 00000000000..ee8dbe391c4
--- /dev/null
+++ b/clang/test/Analysis/inlining/retain-count-self-init.m
@@ -0,0 +1,68 @@
+// RUN: %clang_cc1 -analyze -analyzer-checker=core,osx.cocoa.RetainCount,osx.cocoa.SelfInit -analyzer-ipa=dynamic-bifurcate -verify %s
+
+typedef signed char BOOL;
+typedef struct objc_class *Class;
+typedef struct objc_object {
+    Class isa;
+} *id;
+@protocol NSObject  - (BOOL)isEqual:(id)object; @end
+@interface NSObject <NSObject> {}
++(id)alloc;
++(id)new;
+- (oneway void)release;
+-(id)init;
+-(id)autorelease;
+-(id)copy;
+- (Class)class;
+-(id)retain;
+@end
+
+// We do not want to overhelm user with error messages in case they forgot to 
+// assign to self and check that the result of [super init] is non-nil. So 
+// stop tracking the receiver of init with respect to Retain Release checker.  
+// radar://12115830
+@interface ParentOfCell : NSObject
+- (id)initWithInt: (int)inInt;
+@end
+@interface Cell : ParentOfCell{
+  int x;
+}
+- (id)init;
++ (void)test;
+@property int x;
+@end
+@implementation Cell
+@synthesize x;
+- (id) init {
+  [super init];
+  self.x = 3; // no-warning 
+  return self; // expected-warning {{Returning 'self' while it is not set to the result of '[(super or self)}} 
+}
+- (id) initWithInt: (int)inInt {
+  [super initWithInt: inInt];
+  self.x = inInt; // no-warning 
+  return self; // expected-warning {{Returning 'self' while it is not set to the result of '[(super or self)}} 
+}
+- (id) init2 {
+  [self init]; // The call [self init] is inlined. We will warn inside the inlined body.
+  self.x = 2; // no-warning 
+  return self; 
+}
+
+- (id) initWithIntGood: (int)inInt {
+    if (self = [super initWithInt: inInt]) {
+      self.x = inInt; 
+    }
+    return self; 
+}
++ (void) test {
+  Cell *sharedCell1 = [[Cell alloc] init];
+  [sharedCell1 release];
+  Cell *sharedCell2 = [[Cell alloc] initWithInt: 3];
+  [sharedCell2 release];
+  Cell *sharedCell3 = [[Cell alloc] initWithIntGood: 3];
+  [sharedCell3 release];
+}
+
+@end
+