[analyzer] Fix ObjC Dealloc Checker to operate only on classes with retained properties

[dcoughlin]

Summary

Previously the ObjC Dealloc Checker only checked classes with ivars, not retained properties, which caused three bugs:

1. False positive warnings about a missing -dealloc method in classes with only ivars. (rdar://problem/6074390&6244594)
2. Missing warnings about a missing -dealloc method on classes with only properties. (rdar://problem/13089741)
3. Missing warnings about an over-released or under-released ivar associated with a retained property in classes with only properties. (rdar://problem/8154447)

The fix is to check only classes with at least one retained, synthesized, writable property.

This also exposed a bug when reporting an over-released or under-released property that did not contain a synthesize statement. The checker tried to associate the warning with an @synthesize statement that did not exist, which caused an assertion failure in debug builds. The fix is to fall back to the @property statement in this case.

[ddkilzer]

Note that I removed whitespace from the end of line 29 (line 41 on the right), but Phabricator is not showing that as a changed line: https://secure.phabricator.com/T5948

[ddkilzer]

I would have added a similar test for a class with a @property, but I need to fix a couple of bugs before posting that patch.

Currently the checker doesn't warn at all for classes with no -dealloc method and a (retain) @property, and after fixing that issue, leaving out the @synthesize statement causes the checker to crash (apparently because it's trying to attach the warning to the @synthesize statement when it doesn't exist).

[jordan_rose]

Yup, this checker predates property auto-synthesis!

I'm actually not sure we want to have this particular check; from just the ivar, you can't tell its ownership convention. The properties are very valuable though.

Also, while you're here, make sure we don't do any of this under ARC!

[ddkilzer]

In D5023#6, @jordan_rose wrote:

Yup, this checker predates property auto-synthesis!

I'm actually not sure we want to have this particular check; from just the ivar, you can't tell its ownership convention. The properties are very valuable though.

This false positive is filed as rdar://problem/6074390.

Also, while you're here, make sure we don't do any of this under ARC!

Will do. I guess I need to change the test file to include multiple "RUN" commands like this one:

test/SemaObjC/warn-missing-super.m

[ddkilzer]

Address Jordan's concern about the false-positive warning for the missing -dealloc method (rdar://problem/6074390) and fix bugs for missing warnings with retained properties.

[zaks.anna]

lib/StaticAnalyzer/Checkers/CheckObjCDealloc.cpp

115 ↗

(On Diff #12883)

We try to keep the codebase clear of radar (and PR) numbers. These are very welcome in the commit messages and test cases.

206 ↗

(On Diff #12883)

Would it be possible to move the checking of the setter (to be not 'assign') into the body of isSynthesizedWritablePointerProperty() ?

test/Analysis/DeallocMissingRelease.m

142 ↗

(On Diff #12883)

All of the run lines are usually placed in the front of the test file.

test/Analysis/MissingDealloc.m

139 ↗

(On Diff #12883)

Run commands need to go into the beginning of the file.

test/Analysis/PR2978.m

36 ↗

(On Diff #12883)

We prefer to keep the warning messages as short as possible. (One reason is that the IDE real estate is at a premium.) So here, I would drop "Objective-C class".

[ddkilzer]

Thanks for the comments, Anna! I will post a new patch soon.

lib/StaticAnalyzer/Checkers/CheckObjCDealloc.cpp

108 ↗

(On Diff #12883)

None of these checks is useful for ARC (-fobjc-arc), so I need to assert this is never called in ARC mode (which Jordan alluded to in a previous comment).

206 ↗

(On Diff #12883)

I can, but it makes it harder to share code with the patch in D5042, since I need that bit of information separately.

255–256 ↗

(On Diff #12883)

None of these checks is useful for ARC (-fobjc-arc), so I need to return early for ARC mode as well (which Jordan alluded to in a previous comment).

[ddkilzer]

test/Analysis/DeallocMissingRelease.m

142 ↗

(On Diff #12883)

Just the RUN lines, but not the CHECK* lines? Or both of them together? (Sorry, I was working off a poor example when I moved them to the end of the file.)

[ddkilzer]

test/Analysis/DeallocMissingRelease.m

142 ↗

(On Diff #12883)

Ignore me. I found the answer in more recent test files: All the Things™ at the top.

[ddkilzer]

Properly address Jordan's comment about this checker not running with ARC, and address all but one of Anna's comments.

Note that I can't move the check for the setter not being 'assign' into isSynthesizedWritablePointerProperty() since I need that value separately (not logically and-ed with the other checks) in both places where isSynthesizedWritablePointerPropert() is called.

[jordan_rose]

More comments. Thanks for working on this!

lib/StaticAnalyzer/Checkers/CheckObjCDealloc.cpp

91 ↗

(On Diff #13121)

This should use isObjCRetainableType, to handle blocks as well.

94–96 ↗

(On Diff #13121)

I think you can just assert this. Sema should already reject @synthesize without @property, and it will certainly never auto-synthesize a property that doesn't exist.

98 ↗

(On Diff #13121)

I don't think this matters. As soon as the property is synthesized, it needs to be released, right?

123–125 ↗

(On Diff #13121)

...or Weak.

203 ↗

(On Diff #13121)

'Weak' also doesn't require a release.

test/Analysis/DeallocMissingRelease.m

2–5 ↗

(On Diff #13121)

Please move these checks inline. That way they're associated with what they're checking, and you can use [[@LINE]] (or [[@LINE+1]] or [[@LINE-1]] to provide a relative line number.

16–25 ↗

(On Diff #13121)

This is not helpful; the analyzer doesn't even get run when there are AST-level errors. Can you #if out the problematic lines when testing under ARC?

[dcoughlin]

I am commandeering this revision!

[dcoughlin]

I've updated ddkilzer's patch to address Jordan's last round of comments.

Specifically, I have:

• Changed the patch to use isObjCRetainableType() to additional warn about properties of block type(and added a test).
• Added an assertion that a synthesized property implementation has a property declaration.
• Changed the patch to warn on readonly synthesized properties (and added tests).
• Changed the patch to not warn on weak properties.
• Removed tests for GC environments.
• Moved CHECK lines to be in-line with test code.

cfe/trunk/lib/StaticAnalyzer/Checkers/CheckObjCDealloc.cpp

 #include "clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h"
 #include "clang/StaticAnalyzer/Core/Checker.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace clang;
 using namespace ento;
 
-static bool scan_ivar_release(Stmt *S, ObjCIvarDecl *ID,
+static bool scan_ivar_release(Stmt *S, const ObjCIvarDecl *ID,
                               const ObjCPropertyDecl *PD,
                               Selector Release,
                               IdentifierInfo* SelfII,
                               ASTContext &Ctx) {
 
   // [mMyIvar release]
   if (ObjCMessageExpr *ME = dyn_cast<ObjCMessageExpr>(S))
     if (ME->getSelector() == Release)
static bool scan_ivar_release(Stmt *S, const ObjCIvarDecl *ID,
   // Recurse to children.
   for (Stmt *SubStmt : S->children())
     if (SubStmt && scan_ivar_release(SubStmt, ID, PD, Release, SelfII, Ctx))
       return true;
 
   return false;
 }
 
+static bool isSynthesizedRetainableProperty(const ObjCPropertyImplDecl *I,
+                                            const ObjCIvarDecl **ID,
+                                            const ObjCPropertyDecl **PD) {
+
+  if (I->getPropertyImplementation() != ObjCPropertyImplDecl::Synthesize)
+    return false;
+
+  (*ID) = I->getPropertyIvarDecl();
+  if (!(*ID))
+    return false;
+
+  QualType T = (*ID)->getType();
+  if (!T->isObjCRetainableType())
+    return false;
+
+  (*PD) = I->getPropertyDecl();
+  // Shouldn't be able to synthesize a property that doesn't exist.
+  assert(*PD);
+
+  return true;
+}
+
+static bool synthesizedPropertyRequiresRelease(const ObjCPropertyDecl *PD) {
+  // A synthesized property must be released if and only if the kind of setter
+  // was neither 'assign' or 'weak'.
+  ObjCPropertyDecl::SetterKind SK = PD->getSetterKind();
+  return (SK != ObjCPropertyDecl::Assign && SK != ObjCPropertyDecl::Weak);
+}
+
 static void checkObjCDealloc(const CheckerBase *Checker,
                              const ObjCImplementationDecl *D,
                              const LangOptions &LOpts, BugReporter &BR) {
 
-  assert (LOpts.getGC() != LangOptions::GCOnly);
+  assert(LOpts.getGC() != LangOptions::GCOnly);
+  assert(!LOpts.ObjCAutoRefCount);
 
   ASTContext &Ctx = BR.getContext();
   const ObjCInterfaceDecl *ID = D->getClassInterface();
 
-  // Does the class contain any ivars that are pointers (or id<...>)?
+  // Does the class contain any synthesized properties that are retainable?
   // If not, skip the check entirely.
-  // NOTE: This is motivated by PR 2517:
-  //        http://llvm.org/bugs/show_bug.cgi?id=2517
-
-  bool containsPointerIvar = false;
-
-  for (const auto *Ivar : ID->ivars()) {
-    QualType T = Ivar->getType();
-
-    if (!T->isObjCObjectPointerType() ||
-        Ivar->hasAttr<IBOutletAttr>() || // Skip IBOutlets.
-        Ivar->hasAttr<IBOutletCollectionAttr>()) // Skip IBOutletCollections.
+  bool containsRetainedSynthesizedProperty = false;
+  for (const auto *I : D->property_impls()) {
+    const ObjCIvarDecl *ID = nullptr;
+    const ObjCPropertyDecl *PD = nullptr;
+    if (!isSynthesizedRetainableProperty(I, &ID, &PD))
       continue;
 
-    containsPointerIvar = true;
+    if (synthesizedPropertyRequiresRelease(PD)) {
+      containsRetainedSynthesizedProperty = true;
       break;
     }
+  }
 
-  if (!containsPointerIvar)
+  if (!containsRetainedSynthesizedProperty)
     return;
 
   // Determine if the class subclasses NSObject.
   IdentifierInfo* NSObjectII = &Ctx.Idents.get("NSObject");
   IdentifierInfo* SenTestCaseII = &Ctx.Idents.get("SenTestCase");
 
-
   for ( ; ID ; ID = ID->getSuperClass()) {
     IdentifierInfo *II = ID->getIdentifier();
 
     if (II == NSObjectII)
       break;
 
     // FIXME: For now, ignore classes that subclass SenTestCase, as these don't
     // need to implement -dealloc.  They implement tear down in another way,
static void checkObjCDealloc(const CheckerBase *Checker,
   // Scan the instance methods for "dealloc".
   for (const auto *I : D->instance_methods()) {
     if (I->getSelector() == S) {
       MD = I;
       break;
     }
   }
 
-  PathDiagnosticLocation DLoc =
-    PathDiagnosticLocation::createBegin(D, BR.getSourceManager());
-
   if (!MD) { // No dealloc found.
 
     const char* name = LOpts.getGC() == LangOptions::NonGC
                        ? "missing -dealloc"
                        : "missing -dealloc (Hybrid MM, non-GC)";
 
     std::string buf;
     llvm::raw_string_ostream os(buf);
     os << "Objective-C class '" << *D << "' lacks a 'dealloc' instance method";
 
+    PathDiagnosticLocation DLoc =
+        PathDiagnosticLocation::createBegin(D, BR.getSourceManager());
+
     BR.EmitBasicReport(D, Checker, name, categories::CoreFoundationObjectiveC,
                        os.str(), DLoc);
     return;
   }
 
   // Get the "release" selector.
   IdentifierInfo* RII = &Ctx.Idents.get("release");
   Selector RS = Ctx.Selectors.getSelector(0, &RII);
 
   // Get the "self" identifier
   IdentifierInfo* SelfII = &Ctx.Idents.get("self");
 
   // Scan for missing and extra releases of ivars used by implementations
   // of synthesized properties
   for (const auto *I : D->property_impls()) {
-    // We can only check the synthesized properties
-    if (I->getPropertyImplementation() != ObjCPropertyImplDecl::Synthesize)
-      continue;
-
-    ObjCIvarDecl *ID = I->getPropertyIvarDecl();
-    if (!ID)
-      continue;
-
-    QualType T = ID->getType();
-    if (!T->isObjCObjectPointerType()) // Skip non-pointer ivars
-      continue;
-
-    const ObjCPropertyDecl *PD = I->getPropertyDecl();
-    if (!PD)
-      continue;
-
-    // ivars cannot be set via read-only properties, so we'll skip them
-    if (PD->isReadOnly())
+    const ObjCIvarDecl *ID = nullptr;
+    const ObjCPropertyDecl *PD = nullptr;
+    if (!isSynthesizedRetainableProperty(I, &ID, &PD))
       continue;
 
-    // ivar must be released if and only if the kind of setter was not 'assign'
-    bool requiresRelease = PD->getSetterKind() != ObjCPropertyDecl::Assign;
+    bool requiresRelease = synthesizedPropertyRequiresRelease(PD);
     if (scan_ivar_release(MD->getBody(), ID, PD, RS, SelfII, Ctx)
        != requiresRelease) {
       const char *name = nullptr;
       std::string buf;
       llvm::raw_string_ostream os(buf);
 
       if (requiresRelease) {
         name = LOpts.getGC() == LangOptions::NonGC
                ? "missing ivar release (leak)"
                : "missing ivar release (Hybrid MM, non-GC)";
 
-        os << "The '" << *ID
-           << "' instance variable was retained by a synthesized property but "
-              "wasn't released in 'dealloc'";
+        os << "The '" << *ID << "' instance variable in '" << *D
+           << "' was retained by a synthesized property "
+              "but was not released in 'dealloc'";
       } else {
         name = LOpts.getGC() == LangOptions::NonGC
                ? "extra ivar release (use-after-release)"
                : "extra ivar release (Hybrid MM, non-GC)";
 
-        os << "The '" << *ID
-           << "' instance variable was not retained by a synthesized property "
+        os << "The '" << *ID << "' instance variable in '" << *D
+           << "' was not retained by a synthesized property "
               "but was released in 'dealloc'";
       }
 
-      PathDiagnosticLocation SDLoc =
-        PathDiagnosticLocation::createBegin(I, BR.getSourceManager());
+      // If @synthesize statement is missing, fall back to @property statement.
+      const Decl *SPDecl = I->getLocation().isValid()
+                               ? static_cast<const Decl *>(I)
+                               : static_cast<const Decl *>(PD);
+      PathDiagnosticLocation SPLoc =
+          PathDiagnosticLocation::createBegin(SPDecl, BR.getSourceManager());
 
       BR.EmitBasicReport(MD, Checker, name,
-                         categories::CoreFoundationObjectiveC, os.str(), SDLoc);
+                         categories::CoreFoundationObjectiveC, os.str(), SPLoc);
     }
   }
 }
 
 //===----------------------------------------------------------------------===//
 // ObjCDeallocChecker
 //===----------------------------------------------------------------------===//
 
 namespace {
 class ObjCDeallocChecker : public Checker<
                                       check::ASTDecl<ObjCImplementationDecl> > {
 public:
   void checkASTDecl(const ObjCImplementationDecl *D, AnalysisManager& mgr,
                     BugReporter &BR) const {
-    if (mgr.getLangOpts().getGC() == LangOptions::GCOnly)
+    if (mgr.getLangOpts().getGC() == LangOptions::GCOnly ||
+        mgr.getLangOpts().ObjCAutoRefCount)
       return;
     checkObjCDealloc(this, cast<ObjCImplementationDecl>(D), mgr.getLangOpts(),
                      BR);
   }
 };
 }
 
 void ento::registerObjCDeallocChecker(CheckerManager &mgr) {
   mgr.registerChecker<ObjCDeallocChecker>();
 }

cfe/trunk/test/Analysis/DeallocMissingRelease.m

+// RUN: %clang_cc1 -analyze -analyzer-checker=alpha.osx.cocoa.Dealloc -fblocks %s 2>&1 | FileCheck -check-prefix=CHECK %s
+// RUN: %clang_cc1 -analyze -analyzer-checker=alpha.osx.cocoa.Dealloc -fblocks -triple x86_64-apple-darwin10 -fobjc-arc -fobjc-runtime-has-weak %s 2>&1 | FileCheck -check-prefix=CHECK-ARC -allow-empty '--implicit-check-not=error:' '--implicit-check-not=warning:' %s
+
+#define nil ((id)0)
+
+#define NON_ARC !__has_feature(objc_arc)
+
+#if NON_ARC
+#define WEAK_ON_ARC
+#else
+#define WEAK_ON_ARC __weak
+#endif
+
+typedef signed char BOOL;
+@protocol NSObject
+- (BOOL)isEqual:(id)object;
+- (Class)class;
+@end
+
+@interface NSObject <NSObject> {}
+- (void)dealloc;
+- (id)init;
+- (id)retain;
+- (oneway void)release;
+@end
+
+typedef struct objc_selector *SEL;
+
+//===------------------------------------------------------------------------===
+// Do not warn about missing release in -dealloc for ivars.
+
+@interface MyIvarClass1 : NSObject {
+  NSObject *_ivar;
+}
+@end
+
+@implementation MyIvarClass1
+- (instancetype)initWithIvar:(NSObject *)ivar
+{
+  self = [super init];
+  if (!self)
+    return nil;
+#if NON_ARC
+  _ivar = [ivar retain];
+#endif
+  return self;
+}
+- (void)dealloc
+{
+#if NON_ARC
+  [super dealloc];
+#endif
+}
+@end
+
+@interface MyIvarClass2 : NSObject {
+  NSObject *_ivar;
+}
+- (NSObject *)ivar;
+- (void)setIvar:(NSObject *)ivar;
+@end
+
+@implementation MyIvarClass2
+- (instancetype)init
+{
+  self = [super init];
+  return self;
+}
+- (void)dealloc
+{
+#if NON_ARC
+  [super dealloc];
+#endif
+}
+- (NSObject *)ivar
+{
+  return _ivar;
+}
+- (void)setIvar:(NSObject *)ivar
+{
+#if NON_ARC
+  [_ivar release];
+  _ivar = [ivar retain];
+#else
+ _ivar = ivar;
+#endif
+}
+@end
+
+//===------------------------------------------------------------------------===
+// Warn about missing release in -dealloc for properties.
+
+@interface MyPropertyClass1 : NSObject
+// CHECK: DeallocMissingRelease.m:[[@LINE+1]]:1: warning: The '_ivar' instance variable in 'MyPropertyClass1' was retained by a synthesized property but was not released in 'dealloc'
+@property (copy) NSObject *ivar;
+@end
+
+@implementation MyPropertyClass1
+- (void)dealloc
+{
+#if NON_ARC
+  [super dealloc];
+#endif
+}
+@end
+
+@interface MyPropertyClass2 : NSObject
+// CHECK: DeallocMissingRelease.m:[[@LINE+1]]:1: warning: The '_ivar' instance variable in 'MyPropertyClass2' was retained by a synthesized property but was not released in 'dealloc'
+@property (retain) NSObject *ivar;
+@end
+
+@implementation MyPropertyClass2
+- (void)dealloc
+{
+#if NON_ARC
+  [super dealloc];
+#endif
+}
+@end
+
+@interface MyPropertyClass3 : NSObject {
+  NSObject *_ivar;
+}
+@property (retain) NSObject *ivar;
+@end
+
+@implementation MyPropertyClass3
+// CHECK: DeallocMissingRelease.m:[[@LINE+1]]:1: warning: The '_ivar' instance variable in 'MyPropertyClass3' was retained by a synthesized property but was not released in 'dealloc'
+@synthesize ivar = _ivar;
+- (void)dealloc
+{
+#if NON_ARC
+  [super dealloc];
+#endif
+}
+@end
+
+@interface MyPropertyClass4 : NSObject {
+  void (^_blockPropertyIvar)(void);
+}
+@property (copy) void (^blockProperty)(void);
+@end
+
+@implementation MyPropertyClass4
+// CHECK: DeallocMissingRelease.m:[[@LINE+1]]:1: warning: The '_blockPropertyIvar' instance variable in 'MyPropertyClass4' was retained by a synthesized property but was not released in 'dealloc'
+@synthesize blockProperty = _blockPropertyIvar;
+- (void)dealloc
+{
+#if NON_ARC
+  [super dealloc];
+#endif
+}
+@end
+
+@interface MyPropertyClass5 : NSObject {
+  WEAK_ON_ARC NSObject *_ivar;
+}
+@property (weak) NSObject *ivar;
+@end
+
+@implementation MyPropertyClass5
+@synthesize ivar = _ivar; // no-warning
+- (void)dealloc
+{
+#if NON_ARC
+  [super dealloc];
+#endif
+}
+@end
+
+//===------------------------------------------------------------------------===
+// <rdar://problem/6380411>: 'myproperty' has kind 'assign' and thus the
+//  assignment through the setter does not perform a release.
+
+@interface MyObject : NSObject {
+  id __unsafe_unretained _myproperty;
+}
+@property(assign) id myproperty;
+@end
+
+@implementation MyObject
+@synthesize myproperty=_myproperty; // no-warning
+- (void)dealloc {
+  // Don't claim that myproperty is released since it the property
+  // has the 'assign' attribute.
+  self.myproperty = 0; // no-warning
+#if NON_ARC
+  [super dealloc];
+#endif
+}
+@end
+// CHECK: 4 warnings generated.

cfe/trunk/test/Analysis/MissingDealloc.m

-// RUN: %clang_cc1 -analyze -analyzer-checker=alpha.osx.cocoa.Dealloc %s -verify
-// expected-no-diagnostics
+// RUN: %clang_cc1 -analyze -analyzer-checker=alpha.osx.cocoa.Dealloc -fblocks %s 2>&1 | FileCheck -check-prefix=CHECK %s
+// RUN: %clang_cc1 -analyze -analyzer-checker=alpha.osx.cocoa.Dealloc -fblocks -triple x86_64-apple-darwin10 -fobjc-arc %s 2>&1 | FileCheck -check-prefix=CHECK-ARC -allow-empty '--implicit-check-not=error:' '--implicit-check-not=warning:' %s
+
 typedef signed char BOOL;
 @protocol NSObject
 - (BOOL)isEqual:(id)object;
 - (Class)class;
 @end
 
 @interface NSObject <NSObject> {}
 - (void)dealloc;
 - (id)init;
 @end
 
 typedef struct objc_selector *SEL;
 
-// <rdar://problem/6380411>: 'myproperty' has kind 'assign' and thus the
-//  assignment through the setter does not perform a release.
+//===------------------------------------------------------------------------===
+// Do not warn about missing -dealloc method.  Not enough context to know
+// whether the ivar is retained or not.
 
-@interface MyObject : NSObject {
-  id _myproperty;  
+@interface MissingDeallocWithIvar : NSObject {
+  NSObject *_ivar;
 }
-@property(assign) id myproperty;
 @end
 
-@implementation MyObject
-@synthesize myproperty=_myproperty; // no-warning
-- (void)dealloc {
-  self.myproperty = 0;
-  [super dealloc]; 
+@implementation MissingDeallocWithIvar
+@end
+
+//===------------------------------------------------------------------------===
+// Do not warn about missing -dealloc method.  These properties are not
+// retained or synthesized.
+
+@interface MissingDeallocWithIntProperty : NSObject
+@property (assign) int ivar;
+@end
+
+@implementation MissingDeallocWithIntProperty
+@end
+
+@interface MissingDeallocWithSELProperty : NSObject
+@property (assign) SEL ivar;
+@end
+
+@implementation MissingDeallocWithSELProperty
+@end
+
+//===------------------------------------------------------------------------===
+// Warn about missing -dealloc method.
+
+@interface MissingDeallocWithCopyProperty : NSObject
+@property (copy) NSObject *ivar;
+@end
+
+// CHECK: MissingDealloc.m:[[@LINE+1]]:1: warning: Objective-C class 'MissingDeallocWithCopyProperty' lacks a 'dealloc' instance method
+@implementation MissingDeallocWithCopyProperty
+@end
+
+@interface MissingDeallocWithRetainProperty : NSObject
+@property (retain) NSObject *ivar;
+@end
+
+// CHECK: MissingDealloc.m:[[@LINE+1]]:1: warning: Objective-C class 'MissingDeallocWithRetainProperty' lacks a 'dealloc' instance method
+@implementation MissingDeallocWithRetainProperty
+@end
+
+@interface MissingDeallocWithIVarAndRetainProperty : NSObject {
+  NSObject *_ivar2;
 }
+@property (retain) NSObject *ivar1;
+@end
+
+// CHECK: MissingDealloc.m:[[@LINE+1]]:1: warning: Objective-C class 'MissingDeallocWithIVarAndRetainProperty' lacks a 'dealloc' instance method
+@implementation MissingDeallocWithIVarAndRetainProperty
 @end
 
+@interface MissingDeallocWithReadOnlyRetainedProperty : NSObject
+@property (readonly,retain) NSObject *ivar;
+@end
+
+// CHECK: MissingDealloc.m:[[@LINE+1]]:1: warning: Objective-C class 'MissingDeallocWithReadOnlyRetainedProperty' lacks a 'dealloc' instance method
+@implementation MissingDeallocWithReadOnlyRetainedProperty
+@end
+
+
 //===------------------------------------------------------------------------===
 //  Don't warn about iVars that are selectors.
 
 @interface TestSELs : NSObject {
   SEL a;
   SEL b;
 }
 

 IBOutlet NSWindow *window;
 }
 @end
 
 @implementation HasOutlet // no-warning
 @end
 
 //===------------------------------------------------------------------------===
-// <rdar://problem/6380411>
-// Was bogus warning: "The '_myproperty' instance variable was not retained by a
-//  synthesized property but was released in 'dealloc'"
-
-@interface MyObject_rdar6380411 : NSObject {
-    id _myproperty;
-}
-@property(assign) id myproperty;
-@end
-
-@implementation MyObject_rdar6380411
-@synthesize myproperty=_myproperty;
-- (void)dealloc {
-    // Don't claim that myproperty is released since it the property
-    // has the 'assign' attribute.
-    self.myproperty = 0; // no-warning
-    [super dealloc];
-}
-@end
-
-//===------------------------------------------------------------------------===
 // PR 3187: http://llvm.org/bugs/show_bug.cgi?id=3187
 // - Disable the missing -dealloc check for classes that subclass SenTestCase
 
 @class NSString;
 
 @interface SenTestCase : NSObject {}
 @end
 

 @implementation MyClassTest
 - (void)setUp {
   resourcePath = [[NSBundle bundleForClass:[self class]] resourcePath];
 }
 - (void)testXXX {
   // do something which uses resourcepath
 }
 @end
+// CHECK: 4 warnings generated.

cfe/trunk/test/Analysis/PR2978.m

 // RUN: %clang_cc1 -analyze -analyzer-checker=core,alpha.core -analyzer-checker=alpha.osx.cocoa.Dealloc %s -verify
 
 // Tests for the checker which checks missing/extra ivar 'release' calls 
 // in dealloc.
 
 @interface NSObject
 - (void)release;
 - dealloc;
 @end
 
 @interface MyClass : NSObject {
 @private
   id _X;
   id _Y;
   id _Z;
   id _K;
+  id _L;
   id _N;
   id _M;
   id _V;
   id _W;
 }
 @property(retain) id X;
 @property(retain) id Y;
 @property(assign) id Z;
 @property(assign) id K;
+@property(weak) id L;
 @property(readonly) id N;
 @property(retain) id M;
 @property(retain) id V;
 @property(retain) id W;
 -(id) O;
 -(void) setO: (id) arg;
 @end
 
 @implementation MyClass
 @synthesize X = _X;
-@synthesize Y = _Y; // expected-warning{{The '_Y' instance variable was retained by a synthesized property but wasn't released in 'dealloc'}}
-@synthesize Z = _Z; // expected-warning{{The '_Z' instance variable was not retained by a synthesized property but was released in 'dealloc'}}
+@synthesize Y = _Y; // expected-warning{{The '_Y' instance variable in 'MyClass' was retained by a synthesized property but was not released in 'dealloc'}}
+@synthesize Z = _Z; // expected-warning{{The '_Z' instance variable in 'MyClass' was not retained by a synthesized property but was released in 'dealloc'}}
 @synthesize K = _K;
-@synthesize N = _N;
+@synthesize L = _L; // no-warning
+@synthesize N = _N; // expected-warning{{The '_N' instance variable in 'MyClass' was not retained by a synthesized property but was released in 'dealloc'}}
 @synthesize M = _M;
 @synthesize V = _V;
-@synthesize W = _W; // expected-warning{{The '_W' instance variable was retained by a synthesized property but wasn't released in 'dealloc'}}
+@synthesize W = _W; // expected-warning{{The '_W' instance variable in 'MyClass' was retained by a synthesized property but was not released in 'dealloc'}}
 
 -(id) O{ return 0; }
 -(void) setO:(id)arg { }
 
 - (id)dealloc
 {
   [_X release];
   [_Z release];