[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

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

204

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

test/Analysis/DeallocMissingRelease.m

143

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

test/Analysis/MissingDealloc.m

155

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

test/Analysis/PR2978.m

36–37

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–109

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).

204

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

251–253

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

143

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

143

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

This should use isObjCRetainableType, to handle blocks as well.

94–96

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

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

123–125

...or Weak.

203

'Weak' also doesn't require a release.

test/Analysis/DeallocMissingRelease.m

2–5

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

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.

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::child_iterator I = S->child_begin(), E= S->child_end(); I!=E; ++I)
     if (*I && scan_ivar_release(*I, ID, PD, Release, SelfII, Ctx))
       return true;
 
   return false;
 }
 
+static bool isSynthesizedWritablePointerProperty(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->isObjCObjectPointerType())
+    return false;
+
+  (*PD) = I->getPropertyDecl();
+  if (!(*PD))
+    return false;
+
+  if ((*PD)->isReadOnly())
+    return false;
+
+  return true;
+}
+
 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<...>)?
-  // 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.
+  // Does the class contain any properties that are retained, synthesized,
+  // writable pointers (or id<...>)?  If not, skip the check entirely.
+  bool containsRetainedSynthesizedWritablePointerProperty = false;
+  for (const auto *I : D->property_impls()) {
+    const ObjCIvarDecl *ID = nullptr;
+    const ObjCPropertyDecl *PD = nullptr;
+    if (!isSynthesizedWritablePointerProperty(I, &ID, &PD))
       continue;
 
-    containsPointerIvar = true;
+    // Property must be released if and only if the kind of setter
+    // was not 'assign'.
+    if (PD->getSetterKind() != ObjCPropertyDecl::Assign) {
+      containsRetainedSynthesizedWritablePointerProperty = true;
       break;
     }
+  }
 
-  if (!containsPointerIvar)
+  if (!containsRetainedSynthesizedWritablePointerProperty)
     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 (!isSynthesizedWritablePointerProperty(I, &ID, &PD))
       continue;
 
-    // ivar must be released if and only if the kind of setter was not 'assign'
+    // Property must be released if and only if the kind of setter
+    // was not 'assign'.
     bool requiresRelease = PD->getSetterKind() != ObjCPropertyDecl::Assign;
     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 stmt is missing, fall back to @property stmt.
+      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>();
 }

test/Analysis/DeallocMissingRelease.m

+// RUN: %clang_cc1 -analyze -analyzer-checker=alpha.osx.cocoa.Dealloc -fblocks %s 2>&1 | FileCheck -check-prefix=CHECK %s
+// CHECK: DeallocMissingRelease.m:99:1: warning: The '_ivar' instance variable in 'MyPropertyClass1' was retained by a synthesized property but was not released in 'dealloc'
+// CHECK: DeallocMissingRelease.m:110:1: warning: The '_ivar' instance variable in 'MyPropertyClass2' was retained by a synthesized property but was not released in 'dealloc'
+// CHECK: DeallocMissingRelease.m:127:1: warning: The '_ivar' instance variable in 'MyPropertyClass3' was retained by a synthesized property but was not released in 'dealloc'
+// CHECK: 3 warnings generated.
+
+// RUN: %clang_cc1 -analyze -analyzer-checker=alpha.osx.cocoa.Dealloc -fblocks -fobjc-gc %s 2>&1 | FileCheck -check-prefix=CHECK-GC %s
+// CHECK-GC: DeallocMissingRelease.m:99:1: warning: The '_ivar' instance variable in 'MyPropertyClass1' was retained by a synthesized property but was not released in 'dealloc'
+// CHECK-GC: DeallocMissingRelease.m:110:1: warning: The '_ivar' instance variable in 'MyPropertyClass2' was retained by a synthesized property but was not released in 'dealloc'
+// CHECK-GC: DeallocMissingRelease.m:127:1: warning: The '_ivar' instance variable in 'MyPropertyClass3' was retained by a synthesized property but was not released in 'dealloc'
+// CHECK-GC: 3 warnings generated.
+
+// RUN: %clang_cc1 -analyze -analyzer-checker=alpha.osx.cocoa.Dealloc -fblocks -fobjc-gc-only %s 2>&1
+
+// RUN: not %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 %s
+// CHECK-ARC: DeallocMissingRelease.m:58:17: error: ARC forbids explicit message send of 'retain'
+// CHECK-ARC: DeallocMissingRelease.m:63:10: error: ARC forbids explicit message send of 'dealloc'
+// CHECK-ARC: DeallocMissingRelease.m:82:10: error: ARC forbids explicit message send of 'dealloc'
+// CHECK-ARC: DeallocMissingRelease.m:90:10: error: ARC forbids explicit message send of 'release'
+// CHECK-ARC: DeallocMissingRelease.m:91:17: error: ARC forbids explicit message send of 'retain'
+// CHECK-ARC: DeallocMissingRelease.m:105:10: error: ARC forbids explicit message send of 'dealloc'
+// CHECK-ARC: DeallocMissingRelease.m:116:10: error: ARC forbids explicit message send of 'dealloc'
+// CHECK-ARC: DeallocMissingRelease.m:130:10: error: ARC forbids explicit message send of 'dealloc'
+// CHECK-ARC: DeallocMissingRelease.m:150:10: error: ARC forbids explicit message send of 'dealloc'
+// CHECK-ARC: 9 errors generated.
+
+#define nil ((id)0)
+
+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;
+  _ivar = [ivar retain];
+  return self;
+}
+- (void)dealloc
+{
+  [super dealloc];
+}
+@end
+
+@interface MyIvarClass2 : NSObject {
+  NSObject *_ivar;
+}
+- (NSObject *)ivar;
+- (void)setIvar:(NSObject *)ivar;
+@end
+
+@implementation MyIvarClass2
+- (instancetype)init
+{
+  self = [super init];
+  return self;
+}
+- (void)dealloc
+{
+  [super dealloc];
+}
+- (NSObject *)ivar
+{
+  return _ivar;
+}
+- (void)setIvar:(NSObject *)ivar
+{
+  [_ivar release];
+  _ivar = [ivar retain];
+}
+@end
+
+//===------------------------------------------------------------------------===
+// Warn about missing release in -dealloc for properties.
+
+@interface MyPropertyClass1 : NSObject
+@property (copy) NSObject *ivar;
+@end
+
+@implementation MyPropertyClass1
+- (void)dealloc
+{
+  [super dealloc];
+}
+@end
+
+@interface MyPropertyClass2 : NSObject
+@property (retain) NSObject *ivar;
+@end
+
+@implementation MyPropertyClass2
+- (void)dealloc
+{
+  [super dealloc];
+}
+@end
+
+@interface MyPropertyClass3 : NSObject {
+  NSObject *_ivar;
+}
+@property (retain) NSObject *ivar;
+@end
+
+@implementation MyPropertyClass3
+@synthesize ivar = _ivar;
+- (void)dealloc
+{
+  [super dealloc];
+}
+@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
+  [super dealloc];
+}
+@end

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
+// CHECK: MissingDealloc.m:74:1: warning: Objective-C class 'MissingDeallocWithCopyProperty' lacks a 'dealloc' instance method
+// CHECK: MissingDealloc.m:81:1: warning: Objective-C class 'MissingDeallocWithRetainProperty' lacks a 'dealloc' instance method
+// CHECK: MissingDealloc.m:90:1: warning: Objective-C class 'MissingDeallocWithIVarAndRetainProperty' lacks a 'dealloc' instance method
+// CHECK: 3 warnings generated.
+
+// RUN: %clang_cc1 -analyze -analyzer-checker=alpha.osx.cocoa.Dealloc -fblocks -fobjc-gc %s 2>&1 | FileCheck -check-prefix=CHECK-GC %s
+// CHECK-GC: MissingDealloc.m:74:1: warning: Objective-C class 'MissingDeallocWithCopyProperty' lacks a 'dealloc' instance method
+// CHECK-GC: MissingDealloc.m:81:1: warning: Objective-C class 'MissingDeallocWithRetainProperty' lacks a 'dealloc' instance method
+// CHECK-GC: MissingDealloc.m:90:1: warning: Objective-C class 'MissingDeallocWithIVarAndRetainProperty' lacks a 'dealloc' instance method
+// CHECK-GC: 3 warnings generated.
+
+// RUN: %clang_cc1 -analyze -analyzer-checker=alpha.osx.cocoa.Dealloc -fblocks -fobjc-gc-only %s 2>&1
+
+// RUN: %clang_cc1 -analyze -analyzer-checker=alpha.osx.cocoa.Dealloc -fblocks -triple x86_64-apple-darwin10 -fobjc-arc %s 2>&1
+
 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, synthesized or writeable pointers.
+
+@interface MissingDeallocWithIntProperty : NSObject
+@property (assign) int ivar;
+@end
+
+@implementation MissingDeallocWithIntProperty
+@end
+
+@interface MissingDeallocWithSELProperty : NSObject
+@property (assign) SEL ivar;
+@end
+
+@implementation MissingDeallocWithSELProperty
+@end
+
+@interface MissingDeallocWithReadOnlyRetainedProperty : NSObject
+@property (readonly,retain) NSObject *ivar;
+@end
+
+@implementation MissingDeallocWithReadOnlyRetainedProperty
+@end
+
+//===------------------------------------------------------------------------===
+// Warn about missing -dealloc method.
+
+@interface MissingDeallocWithCopyProperty : NSObject
+@property (copy) NSObject *ivar;
+@end
+
+@implementation MissingDeallocWithCopyProperty
+@end
+
+@interface MissingDeallocWithRetainProperty : NSObject
+@property (retain) NSObject *ivar;
+@end
+
+@implementation MissingDeallocWithRetainProperty
+@end
+
+@interface MissingDeallocWithIVarAndRetainProperty : NSObject {
+  NSObject *_ivar2;
 }
+@property (retain) NSObject *ivar1;
+@end
+
+@implementation MissingDeallocWithIVarAndRetainProperty
 @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

test/Analysis/PR2978.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 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];