[analyzer] Print a fully qualified name for functions in RetainCountChecker diagnostics

[george.karpenkov]

Summary

Attempt to get a fully qualified name from AST if an SVal corresponding to the object is not available.

[NoQ]

clang/test/Analysis/osobject-retain-release.cpp

69 ↗

(On Diff #175779)

Do we actually need the word "function" here?
Should we try to use the word "method" for the OSObject case?

cfe/trunk/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountDiagnostics.cpp

if (isa<ObjCArrayLiteral>(S)) {
         }
 
         os << "oxed expression produces an object with a +0 retain count";
       }
     } else if (isa<ObjCIvarRefExpr>(S)) {
       os << "Object loaded from instance variable";
     } else {
       if (const CallExpr *CE = dyn_cast<CallExpr>(S)) {
-        // Get the name of the callee (if it is available).
+        // Get the name of the callee (if it is available)
+        // from the tracked SVal.
         SVal X = CurrSt->getSValAsScalarOrLoc(CE->getCallee(), LCtx);
-        if (const FunctionDecl *FD = X.getAsFunctionDecl()) {
-          os << "Call to function '" << *FD << '\'';
+        const FunctionDecl *FD = X.getAsFunctionDecl();
+
+        // If failed, try to get it from AST.
+        if (!FD)
+          FD = dyn_cast<FunctionDecl>(CE->getCalleeDecl());
+
+        if (const auto *MD = dyn_cast<CXXMethodDecl>(CE->getCalleeDecl())) {
+          os << "Call to method '" << MD->getQualifiedNameAsString() << '\'';
+        } else if (FD) {
+          os << "Call to function '" << FD->getQualifiedNameAsString() << '\'';
         } else {
           os << "function call";
         }
       } else {
         assert(isa<ObjCMessageExpr>(S));
         CallEventManager &Mgr = CurrSt->getStateManager().getCallEventManager();
         CallEventRef<ObjCMethodCall> Call
           = Mgr.getObjCMethodCall(cast<ObjCMessageExpr>(S), CurrSt, LCtx);

cfe/trunk/test/Analysis/osobject-retain-release.cpp

struct OSMetaClassBase {
   static OSObject *safeMetaCast(const OSObject *inst, const OSMetaClass *meta);
 };
 
 void check_custom_iterator_rule(OSArray *arr) {
   OSIterator *it = arr->getIterator();
   it->release();
 }
 
+void check_iterator_leak(OSArray *arr) {
+  arr->getIterator(); // expected-note{{Call to method 'OSArray::getIterator' returns an OSObject of type struct OSIterator * with a +1 retain count}}
+} // expected-note{{Object leaked: allocated object of type struct OSIterator * is not referenced later}}
+  // expected-warning@-1{{Potential leak of an object of type struct OSIterator *}}n this execution path and has a retain count of +1}}
+
 void check_no_invalidation() {
-  OSArray *arr = OSArray::withCapacity(10); // expected-note{{Call to function 'withCapacity' returns an OSObject of type OSArray with a +1 retain count}}
+  OSArray *arr = OSArray::withCapacity(10); // expected-note{{Call to method 'OSArray::withCapacity' returns an OSObject of type OSArray with a +1 retain count}}
   OtherStruct::doNothingToArray(arr);
 } // expected-warning{{Potential leak of an object stored into 'arr'}}
   // expected-note@-1{{Object leaked}}
 
 void check_no_invalidation_other_struct() {
-  OSArray *arr = OSArray::withCapacity(10); // expected-note{{Call to function 'withCapacity' returns an OSObject of type OSArray with a +1 retain count}}
+  OSArray *arr = OSArray::withCapacity(10); // expected-note{{Call to method 'OSArray::withCapacity' returns an OSObject of type OSArray with a +1 retain count}}
   OtherStruct other(arr); // expected-warning{{Potential leak}}
                           // expected-note@-1{{Object leaked}}
 }
 
 struct ArrayOwner : public OSObject {
   OSArray *arr;
   ArrayOwner(OSArray *arr) : arr(arr) {}
 
struct ArrayOwner : public OSObject {
   }
 
   OSArray *createArraySourceUnknown();
 
   OSArray *getArraySourceUnknown();
 };
 
 OSArray *generateArray() {
-  return OSArray::withCapacity(10); // expected-note{{Call to function 'withCapacity' returns an OSObject of type OSArray with a +1 retain count}}
-                                    // expected-note@-1{{Call to function 'withCapacity' returns an OSObject of type OSArray with a +1 retain count}}
+  return OSArray::withCapacity(10); // expected-note{{Call to method 'withCapacity' returns an OSObject of type OSArray with a +1 retain count}}
+                                    // expected-note@-1{{Call to method 'withCapacity' returns an OSObject of type OSArray with a +1 retain count}}
 }
 
 unsigned int check_leak_good_error_message() {
   unsigned int out;
   {
     OSArray *leaked = generateArray(); // expected-note{{Calling 'generateArray'}}
                                        // expected-note@-1{{Returning from 'generateArray'}}
     out = leaked->getCount(); // expected-warning{{Potential leak of an object stored into 'leaked'}}
if (arr) {
 
     // The fact that dynamic cast has failed should not imply that
     // the input object was null.
     return obj->foo(); // no-warning
   }
 }
 
 void check_dynamic_cast_null_branch(OSObject *obj) {
-  OSArray *arr1 = OSArray::withCapacity(10); // expected-note{{Call to function 'withCapacity' returns an OSObject}}
+  OSArray *arr1 = OSArray::withCapacity(10); // expected-note{{Call to method 'OSArray::withCapacity' returns an OSObject}}
   OSArray *arr = OSDynamicCast(OSArray, obj);
   if (!arr) // expected-note{{Taking true branch}}
     return; // expected-warning{{Potential leak of an object stored into 'arr1'}}
             // expected-note@-1{{Object leaked}}
   arr1->release();
 }
 
 void check_dynamic_cast_null_check() {
-  OSArray *arr = OSDynamicCast(OSArray, OSObject::generateObject(1)); // expected-note{{Call to function 'generateObject' returns an OSObject}}
+  OSArray *arr = OSDynamicCast(OSArray, OSObject::generateObject(1)); // expected-note{{Call to method 'OSObject::generateObject' returns an OSObject}}
     // expected-warning@-1{{Potential leak of an object}}
     // expected-note@-2{{Object leaked}}
   if (!arr)
     return;
   arr->release();
 }
 
 void use_after_release() {
-  OSArray *arr = OSArray::withCapacity(10); // expected-note{{Call to function 'withCapacity' returns an OSObject of type OSArray with a +1 retain count}}
+  OSArray *arr = OSArray::withCapacity(10); // expected-note{{Call to method 'withCapacity' returns an OSObject of type OSArray with a +1 retain count}}
   arr->release(); // expected-note{{Object released}}
   arr->getCount(); // expected-warning{{Reference-counted object is used after it is released}}
                    // expected-note@-1{{Reference-counted object is used after it is released}}
 }
 
 void potential_leak() {
-  OSArray *arr = OSArray::withCapacity(10); // expected-note{{Call to function 'withCapacity' returns an OSObject of type OSArray with a +1 retain count}}
+  OSArray *arr = OSArray::withCapacity(10); // expected-note{{Call to method 'withCapacity' returns an OSObject of type OSArray with a +1 retain count}}
   arr->retain(); // expected-note{{Reference count incremented. The object now has a +2 retain count}}
   arr->release(); // expected-note{{Reference count decremented. The object now has a +1 retain count}}
   arr->getCount();
 } // expected-warning{{Potential leak of an object stored into 'arr'}}
   // expected-note@-1{{Object leaked: object allocated and stored into 'arr' is not referenced later in this execution path and has a retain count of +1}}
 
 void proper_cleanup() {
   OSArray *arr = OSArray::withCapacity(10); // +1

 unsigned int no_warn_ok_release(ArrayOwner *owner) {
   OSArray *arr = owner->getArray(); // +0
   arr->retain(); // +1
   arr->release(); // +0
   return arr->getCount(); // no-warning
 }
 
 unsigned int warn_on_overrelease_with_unknown_source(ArrayOwner *owner) {
-  OSArray *arr = owner->getArraySourceUnknown(); // expected-note{{function call returns an OSObject of type OSArray with a +0 retain count}}
+  OSArray *arr = owner->getArraySourceUnknown(); // expected-note{{Call to method 'ArrayOwner::getArraySourceUnknown' returns an OSObject of type OSArray with a +0 retain count}}
   arr->release(); // expected-warning{{Incorrect decrement of the reference count of an object that is not owned at this point by the caller}}
                   // expected-note@-1{{Incorrect decrement of the reference count of an object that is not owned at this point by the caller}}
   return arr->getCount();
 }
 
 unsigned int ok_release_with_unknown_source(ArrayOwner *owner) {
   OSArray *arr = owner->getArraySourceUnknown(); // +0
   arr->retain(); // +1
   arr->release(); // +0
   return arr->getCount();
 }