[PATCH] D27740: [analyzer] Include type name in Retain Count Checker diagnostics
This revision was automatically updated to reflect the committed changes. Closed by commit rL289883: [analyzer] Include type name in Retain Count Checker diagnostics (authored by zaks). Changed prior to commit: https://reviews.llvm.org/D27740?vs=81482=81668#toc Repository: rL LLVM https://reviews.llvm.org/D27740 Files: cfe/trunk/lib/StaticAnalyzer/Checkers/RetainCountChecker.cpp cfe/trunk/test/Analysis/edges-new.mm cfe/trunk/test/Analysis/inlining/path-notes.m cfe/trunk/test/Analysis/objc-arc.m cfe/trunk/test/Analysis/plist-output-alternate.m cfe/trunk/test/Analysis/retain-release-arc.m cfe/trunk/test/Analysis/retain-release-path-notes-gc.m cfe/trunk/test/Analysis/retain-release-path-notes.m Index: cfe/trunk/test/Analysis/retain-release-path-notes.m === --- cfe/trunk/test/Analysis/retain-release-path-notes.m +++ cfe/trunk/test/Analysis/retain-release-path-notes.m @@ -44,12 +44,12 @@ void creationViaAlloc () { - id leaked = [[NSObject alloc] init]; // expected-note{{Method returns an Objective-C object with a +1 retain count}} + id leaked = [[NSObject alloc] init]; // expected-note{{Method returns an instance of NSObject with a +1 retain count}} return; // expected-warning{{leak}} expected-note{{Object leaked: object allocated and stored into 'leaked' is not referenced later in this execution path and has a retain count of +1}} } void creationViaCFCreate () { - CFTypeRef leaked = CFCreateSomething(); // expected-note{{Call to function 'CFCreateSomething' returns a Core Foundation object with a +1 retain count}} + CFTypeRef leaked = CFCreateSomething(); // expected-note{{Call to function 'CFCreateSomething' returns a Core Foundation object of type CFTypeRef with a +1 retain count}} return; // expected-warning{{leak}} expected-note{{Object leaked: object allocated and stored into 'leaked' is not referenced later in this execution path and has a retain count of +1}} } @@ -68,25 +68,25 @@ } void acquisitionViaCFFunction () { - CFTypeRef leaked = CFGetSomething(); // expected-note{{Call to function 'CFGetSomething' returns a Core Foundation object with a +0 retain count}} + CFTypeRef leaked = CFGetSomething(); // expected-note{{Call to function 'CFGetSomething' returns a Core Foundation object of type CFTypeRef with a +0 retain count}} CFRetain(leaked); // expected-note{{Reference count incremented. The object now has a +1 retain count}} return; // expected-warning{{leak}} expected-note{{Object leaked: object allocated and stored into 'leaked' is not referenced later in this execution path and has a retain count of +1}} } void explicitDealloc () { - id object = [[NSObject alloc] init]; // expected-note{{Method returns an Objective-C object with a +1 retain count}} + id object = [[NSObject alloc] init]; // expected-note{{Method returns an instance of NSObject with a +1 retain count}} [object dealloc]; // expected-note{{Object released by directly sending the '-dealloc' message}} [object class]; // expected-warning{{Reference-counted object is used after it is released}} // expected-note{{Reference-counted object is used after it is released}} } void implicitDealloc () { - id object = [[NSObject alloc] init]; // expected-note{{Method returns an Objective-C object with a +1 retain count}} + id object = [[NSObject alloc] init]; // expected-note{{Method returns an instance of NSObject with a +1 retain count}} [object release]; // expected-note{{Object released}} [object class]; // expected-warning{{Reference-counted object is used after it is released}} // expected-note{{Reference-counted object is used after it is released}} } void overAutorelease () { - id object = [[NSObject alloc] init]; // expected-note{{Method returns an Objective-C object with a +1 retain count}} + id object = [[NSObject alloc] init]; // expected-note{{Method returns an instance of NSObject with a +1 retain count}} [object autorelease]; // expected-note{{Object autoreleased}} [object autorelease]; // expected-note{{Object autoreleased}} return; // expected-warning{{Object autoreleased too many times}} expected-note{{Object was autoreleased 2 times but the object has a +1 retain count}} @@ -99,19 +99,19 @@ } void makeCollectableIgnored () { - CFTypeRef leaked = CFCreateSomething(); // expected-note{{Call to function 'CFCreateSomething' returns a Core Foundation object with a +1 retain count}} + CFTypeRef leaked = CFCreateSomething(); // expected-note{{Call to function 'CFCreateSomething' returns a Core Foundation object of type CFTypeRef with a +1 retain count}} CFMakeCollectable(leaked); // expected-note{{When GC is not enabled a call to 'CFMakeCollectable' has no effect on its argument}} NSMakeCollectable(leaked); // expected-note{{When GC is not enabled a call to 'NSMakeCollectable' has no effect on its argument}} return; // expected-warning{{leak}}
[PATCH] D27740: [analyzer] Include type name in Retain Count Checker diagnostics
dcoughlin accepted this revision. dcoughlin added a comment. This revision is now accepted and ready to land. LGTM. https://reviews.llvm.org/D27740 ___ cfe-commits mailing list cfe-commits@lists.llvm.org http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
[PATCH] D27740: [analyzer] Include type name in Retain Count Checker diagnostics
zaks.anna updated this revision to Diff 81482. zaks.anna added a comment. Address Devin's comment regarding 'id'. https://reviews.llvm.org/D27740 Files: lib/StaticAnalyzer/Checkers/RetainCountChecker.cpp test/Analysis/edges-new.mm test/Analysis/inlining/path-notes.m test/Analysis/objc-arc.m test/Analysis/plist-output-alternate.m test/Analysis/retain-release-arc.m test/Analysis/retain-release-path-notes-gc.m test/Analysis/retain-release-path-notes.m Index: test/Analysis/retain-release-path-notes.m === --- test/Analysis/retain-release-path-notes.m +++ test/Analysis/retain-release-path-notes.m @@ -44,12 +44,12 @@ void creationViaAlloc () { - id leaked = [[NSObject alloc] init]; // expected-note{{Method returns an Objective-C object with a +1 retain count}} + id leaked = [[NSObject alloc] init]; // expected-note{{Method returns an instance of NSObject with a +1 retain count}} return; // expected-warning{{leak}} expected-note{{Object leaked: object allocated and stored into 'leaked' is not referenced later in this execution path and has a retain count of +1}} } void creationViaCFCreate () { - CFTypeRef leaked = CFCreateSomething(); // expected-note{{Call to function 'CFCreateSomething' returns a Core Foundation object with a +1 retain count}} + CFTypeRef leaked = CFCreateSomething(); // expected-note{{Call to function 'CFCreateSomething' returns a Core Foundation object of type CFTypeRef with a +1 retain count}} return; // expected-warning{{leak}} expected-note{{Object leaked: object allocated and stored into 'leaked' is not referenced later in this execution path and has a retain count of +1}} } @@ -68,25 +68,25 @@ } void acquisitionViaCFFunction () { - CFTypeRef leaked = CFGetSomething(); // expected-note{{Call to function 'CFGetSomething' returns a Core Foundation object with a +0 retain count}} + CFTypeRef leaked = CFGetSomething(); // expected-note{{Call to function 'CFGetSomething' returns a Core Foundation object of type CFTypeRef with a +0 retain count}} CFRetain(leaked); // expected-note{{Reference count incremented. The object now has a +1 retain count}} return; // expected-warning{{leak}} expected-note{{Object leaked: object allocated and stored into 'leaked' is not referenced later in this execution path and has a retain count of +1}} } void explicitDealloc () { - id object = [[NSObject alloc] init]; // expected-note{{Method returns an Objective-C object with a +1 retain count}} + id object = [[NSObject alloc] init]; // expected-note{{Method returns an instance of NSObject with a +1 retain count}} [object dealloc]; // expected-note{{Object released by directly sending the '-dealloc' message}} [object class]; // expected-warning{{Reference-counted object is used after it is released}} // expected-note{{Reference-counted object is used after it is released}} } void implicitDealloc () { - id object = [[NSObject alloc] init]; // expected-note{{Method returns an Objective-C object with a +1 retain count}} + id object = [[NSObject alloc] init]; // expected-note{{Method returns an instance of NSObject with a +1 retain count}} [object release]; // expected-note{{Object released}} [object class]; // expected-warning{{Reference-counted object is used after it is released}} // expected-note{{Reference-counted object is used after it is released}} } void overAutorelease () { - id object = [[NSObject alloc] init]; // expected-note{{Method returns an Objective-C object with a +1 retain count}} + id object = [[NSObject alloc] init]; // expected-note{{Method returns an instance of NSObject with a +1 retain count}} [object autorelease]; // expected-note{{Object autoreleased}} [object autorelease]; // expected-note{{Object autoreleased}} return; // expected-warning{{Object autoreleased too many times}} expected-note{{Object was autoreleased 2 times but the object has a +1 retain count}} @@ -99,19 +99,19 @@ } void makeCollectableIgnored () { - CFTypeRef leaked = CFCreateSomething(); // expected-note{{Call to function 'CFCreateSomething' returns a Core Foundation object with a +1 retain count}} + CFTypeRef leaked = CFCreateSomething(); // expected-note{{Call to function 'CFCreateSomething' returns a Core Foundation object of type CFTypeRef with a +1 retain count}} CFMakeCollectable(leaked); // expected-note{{When GC is not enabled a call to 'CFMakeCollectable' has no effect on its argument}} NSMakeCollectable(leaked); // expected-note{{When GC is not enabled a call to 'NSMakeCollectable' has no effect on its argument}} return; // expected-warning{{leak}} expected-note{{Object leaked: object allocated and stored into 'leaked' is not referenced later in this execution path and has a retain count of +1}} } CFTypeRef CFCopyRuleViolation () { - CFTypeRef object = CFGetSomething(); // expected-note{{Call to function 'CFGetSomething' returns a Core
[PATCH] D27740: [analyzer] Include type name in Retain Count Checker diagnostics
dcoughlin added inline comments. Comment at: lib/StaticAnalyzer/Checkers/RetainCountChecker.cpp:2000 +if (Sym->getType().isNull()) { + os << " returns an Objective-C object with a "; +} else { I think we should use this diagnostic text when type is not an ObjCObjectPointerType also. Where this matters, I think, is for id. It seems weird to say "returns an instance of id"; I think it would be better in that case to say "returns an Objective-C object". https://reviews.llvm.org/D27740 ___ cfe-commits mailing list cfe-commits@lists.llvm.org http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
[PATCH] D27740: [analyzer] Include type name in Retain Count Checker diagnostics
zaks.anna updated this revision to Diff 81429. zaks.anna added a comment. Devin did not like the '*' in the diagnostic for ObjC objects, so remove the '*'. https://reviews.llvm.org/D27740 Files: lib/StaticAnalyzer/Checkers/RetainCountChecker.cpp test/Analysis/edges-new.mm test/Analysis/inlining/path-notes.m test/Analysis/objc-arc.m test/Analysis/plist-output-alternate.m test/Analysis/plist-output.m test/Analysis/retain-release-arc.m test/Analysis/retain-release-path-notes-gc.m test/Analysis/retain-release-path-notes.m Index: test/Analysis/retain-release-path-notes.m === --- test/Analysis/retain-release-path-notes.m +++ test/Analysis/retain-release-path-notes.m @@ -44,100 +44,100 @@ void creationViaAlloc () { - id leaked = [[NSObject alloc] init]; // expected-note{{Method returns an Objective-C object with a +1 retain count}} + id leaked = [[NSObject alloc] init]; // expected-note{{Method returns an instance of NSObject with a +1 retain count}} return; // expected-warning{{leak}} expected-note{{Object leaked: object allocated and stored into 'leaked' is not referenced later in this execution path and has a retain count of +1}} } void creationViaCFCreate () { - CFTypeRef leaked = CFCreateSomething(); // expected-note{{Call to function 'CFCreateSomething' returns a Core Foundation object with a +1 retain count}} + CFTypeRef leaked = CFCreateSomething(); // expected-note{{Call to function 'CFCreateSomething' returns a Core Foundation object of type CFTypeRef with a +1 retain count}} return; // expected-warning{{leak}} expected-note{{Object leaked: object allocated and stored into 'leaked' is not referenced later in this execution path and has a retain count of +1}} } void acquisitionViaMethod (Foo *foo) { - id leaked = [foo methodWithValue]; // expected-note{{Method returns an Objective-C object with a +0 retain count}} + id leaked = [foo methodWithValue]; // expected-note{{Method returns an instance of id with a +0 retain count}} [leaked retain]; // expected-note{{Reference count incremented. The object now has a +1 retain count}} [leaked retain]; // expected-note{{Reference count incremented. The object now has a +2 retain count}} [leaked release]; // expected-note{{Reference count decremented. The object now has a +1 retain count}} return; // expected-warning{{leak}} expected-note{{Object leaked: object allocated and stored into 'leaked' is not referenced later in this execution path and has a retain count of +1}} } void acquisitionViaProperty (Foo *foo) { - id leaked = foo.propertyValue; // expected-note{{Property returns an Objective-C object with a +0 retain count}} + id leaked = foo.propertyValue; // expected-note{{Property returns an instance of id with a +0 retain count}} [leaked retain]; // expected-note{{Reference count incremented. The object now has a +1 retain count}} return; // expected-warning{{leak}} expected-note{{Object leaked: object allocated and stored into 'leaked' is not referenced later in this execution path and has a retain count of +1}} } void acquisitionViaCFFunction () { - CFTypeRef leaked = CFGetSomething(); // expected-note{{Call to function 'CFGetSomething' returns a Core Foundation object with a +0 retain count}} + CFTypeRef leaked = CFGetSomething(); // expected-note{{Call to function 'CFGetSomething' returns a Core Foundation object of type CFTypeRef with a +0 retain count}} CFRetain(leaked); // expected-note{{Reference count incremented. The object now has a +1 retain count}} return; // expected-warning{{leak}} expected-note{{Object leaked: object allocated and stored into 'leaked' is not referenced later in this execution path and has a retain count of +1}} } void explicitDealloc () { - id object = [[NSObject alloc] init]; // expected-note{{Method returns an Objective-C object with a +1 retain count}} + id object = [[NSObject alloc] init]; // expected-note{{Method returns an instance of NSObject with a +1 retain count}} [object dealloc]; // expected-note{{Object released by directly sending the '-dealloc' message}} [object class]; // expected-warning{{Reference-counted object is used after it is released}} // expected-note{{Reference-counted object is used after it is released}} } void implicitDealloc () { - id object = [[NSObject alloc] init]; // expected-note{{Method returns an Objective-C object with a +1 retain count}} + id object = [[NSObject alloc] init]; // expected-note{{Method returns an instance of NSObject with a +1 retain count}} [object release]; // expected-note{{Object released}} [object class]; // expected-warning{{Reference-counted object is used after it is released}} // expected-note{{Reference-counted object is used after it is released}} } void overAutorelease () { - id object = [[NSObject alloc] init]; // expected-note{{Method returns an Objective-C object with a +1 retain
[PATCH] D27740: [analyzer] Include type name in Retain Count Checker diagnostics
zaks.anna created this revision. zaks.anna added a reviewer: dcoughlin. zaks.anna added subscribers: cfe-commits, dcoughlin. The more detailed diagnostic will make identifying which object the diagnostics refer to easier. https://reviews.llvm.org/D27740 Files: lib/StaticAnalyzer/Checkers/RetainCountChecker.cpp test/Analysis/edges-new.mm test/Analysis/inlining/path-notes.m test/Analysis/objc-arc.m test/Analysis/plist-output-alternate.m test/Analysis/plist-output.m test/Analysis/retain-release-arc.m test/Analysis/retain-release-path-notes-gc.m test/Analysis/retain-release-path-notes.m Index: test/Analysis/retain-release-path-notes.m === --- test/Analysis/retain-release-path-notes.m +++ test/Analysis/retain-release-path-notes.m @@ -44,100 +44,100 @@ void creationViaAlloc () { - id leaked = [[NSObject alloc] init]; // expected-note{{Method returns an Objective-C object with a +1 retain count}} + id leaked = [[NSObject alloc] init]; // expected-note{{Method returns an instance of NSObject * with a +1 retain count}} return; // expected-warning{{leak}} expected-note{{Object leaked: object allocated and stored into 'leaked' is not referenced later in this execution path and has a retain count of +1}} } void creationViaCFCreate () { - CFTypeRef leaked = CFCreateSomething(); // expected-note{{Call to function 'CFCreateSomething' returns a Core Foundation object with a +1 retain count}} + CFTypeRef leaked = CFCreateSomething(); // expected-note{{Call to function 'CFCreateSomething' returns a Core Foundation object of type CFTypeRef with a +1 retain count}} return; // expected-warning{{leak}} expected-note{{Object leaked: object allocated and stored into 'leaked' is not referenced later in this execution path and has a retain count of +1}} } void acquisitionViaMethod (Foo *foo) { - id leaked = [foo methodWithValue]; // expected-note{{Method returns an Objective-C object with a +0 retain count}} + id leaked = [foo methodWithValue]; // expected-note{{Method returns an instance of id with a +0 retain count}} [leaked retain]; // expected-note{{Reference count incremented. The object now has a +1 retain count}} [leaked retain]; // expected-note{{Reference count incremented. The object now has a +2 retain count}} [leaked release]; // expected-note{{Reference count decremented. The object now has a +1 retain count}} return; // expected-warning{{leak}} expected-note{{Object leaked: object allocated and stored into 'leaked' is not referenced later in this execution path and has a retain count of +1}} } void acquisitionViaProperty (Foo *foo) { - id leaked = foo.propertyValue; // expected-note{{Property returns an Objective-C object with a +0 retain count}} + id leaked = foo.propertyValue; // expected-note{{Property returns an instance of id with a +0 retain count}} [leaked retain]; // expected-note{{Reference count incremented. The object now has a +1 retain count}} return; // expected-warning{{leak}} expected-note{{Object leaked: object allocated and stored into 'leaked' is not referenced later in this execution path and has a retain count of +1}} } void acquisitionViaCFFunction () { - CFTypeRef leaked = CFGetSomething(); // expected-note{{Call to function 'CFGetSomething' returns a Core Foundation object with a +0 retain count}} + CFTypeRef leaked = CFGetSomething(); // expected-note{{Call to function 'CFGetSomething' returns a Core Foundation object of type CFTypeRef with a +0 retain count}} CFRetain(leaked); // expected-note{{Reference count incremented. The object now has a +1 retain count}} return; // expected-warning{{leak}} expected-note{{Object leaked: object allocated and stored into 'leaked' is not referenced later in this execution path and has a retain count of +1}} } void explicitDealloc () { - id object = [[NSObject alloc] init]; // expected-note{{Method returns an Objective-C object with a +1 retain count}} + id object = [[NSObject alloc] init]; // expected-note{{Method returns an instance of NSObject * with a +1 retain count}} [object dealloc]; // expected-note{{Object released by directly sending the '-dealloc' message}} [object class]; // expected-warning{{Reference-counted object is used after it is released}} // expected-note{{Reference-counted object is used after it is released}} } void implicitDealloc () { - id object = [[NSObject alloc] init]; // expected-note{{Method returns an Objective-C object with a +1 retain count}} + id object = [[NSObject alloc] init]; // expected-note{{Method returns an instance of NSObject * with a +1 retain count}} [object release]; // expected-note{{Object released}} [object class]; // expected-warning{{Reference-counted object is used after it is released}} // expected-note{{Reference-counted object is used after it is released}} } void overAutorelease () { - id object = [[NSObject alloc] init]; //