[analyzer] [RetainCountChecker] Bugfix for tracking top-level parameters of Objective-C methods

[NoQ]

I like AnyCall.

clang/include/clang/Analysis/RetainSummaryManager.h

public:
 
   Optional<BehaviorSummary> canEval(const CallExpr *CE, const FunctionDecl *FD,
                                     bool &hasTrustedImplementationAnnotation);
 
   /// \return Whether the type corresponds to a known smart pointer
   /// implementation (that is, everything about it is inlineable).
   static bool isKnownSmartPointer(QualType QT);
 
-  bool isTrustedReferenceCountImplementation(const FunctionDecl *FD);
+  bool isTrustedReferenceCountImplementation(const Decl *FD);
 
   const RetainSummary *getSummary(AnyCall C,
                                   bool HasNonZeroCallbackArg=false,
                                   bool IsReceiverUnconsumedSelf=false,
                                   QualType ReceiverType={});
 
   RetEffect getObjAllocRetEffect() const { return ObjCAllocRetE; }
 

clang/lib/Analysis/RetainSummaryManager.cpp

case AnyCall::Deallocator:
     break;
   case AnyCall::Block:
   case AnyCall::Destructor:
     // FIXME: These calls are currently unsupported.
     return getPersistentStopSummary();
   case AnyCall::ObjCMethod: {
     const auto *ME = cast_or_null<ObjCMessageExpr>(C.getExpr());
     if (!ME) {
-      return getMethodSummary(cast<ObjCMethodDecl>(C.getDecl()));
+      Summ = getMethodSummary(cast<ObjCMethodDecl>(C.getDecl()));
     } else if (ME->isInstanceMessage()) {
       Summ = getInstanceMethodSummary(ME, ReceiverType);
     } else {
       Summ = getClassMethodSummary(ME);
     }
     break;
   }
   }

 RetainSummaryManager::getCFCreateGetRuleSummary(const FunctionDecl *FD) {
   if (coreFoundation::followsCreateRule(FD))
     return getCFSummaryCreateRule(FD);
 
   return getCFSummaryGetRule(FD);
 }
 
 bool RetainSummaryManager::isTrustedReferenceCountImplementation(
-    const FunctionDecl *FD) {
+    const Decl *FD) {
   return hasRCAnnotation(FD, "rc_ownership_trusted_implementation");
 }
 
 Optional<RetainSummaryManager::BehaviorSummary>
 RetainSummaryManager::canEval(const CallExpr *CE, const FunctionDecl *FD,
                               bool &hasTrustedImplementationAnnotation) {
 
   IdentifierInfo *II = FD->getIdentifier();

clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountChecker.cpp

 }
 
 void RetainCountChecker::checkBeginFunction(CheckerContext &Ctx) const {
   if (!Ctx.inTopFrame())
     return;
 
   RetainSummaryManager &SmrMgr = getSummaryManager(Ctx);
   const LocationContext *LCtx = Ctx.getLocationContext();
-  const FunctionDecl *FD = dyn_cast<FunctionDecl>(LCtx->getDecl());
+  const Decl *D = LCtx->getDecl();
+  Optional<AnyCall> C = AnyCall::forDecl(D);
 
-  if (!FD || SmrMgr.isTrustedReferenceCountImplementation(FD))
+  if (!C || SmrMgr.isTrustedReferenceCountImplementation(D))
     return;
 
   ProgramStateRef state = Ctx.getState();
-  const RetainSummary *FunctionSummary = SmrMgr.getSummary(AnyCall(FD));
+  const RetainSummary *FunctionSummary = SmrMgr.getSummary(*C);
   ArgEffects CalleeSideArgEffects = FunctionSummary->getArgEffects();
 
-  for (unsigned idx = 0, e = FD->getNumParams(); idx != e; ++idx) {
-    const ParmVarDecl *Param = FD->getParamDecl(idx);
+  for (unsigned idx = 0, e = C->param_size(); idx != e; ++idx) {
+    const ParmVarDecl *Param = C->parameters()[idx];
     SymbolRef Sym = state->getSVal(state->getRegion(Param, LCtx)).getAsSymbol();
 
     QualType Ty = Param->getType();
     const ArgEffect *AE = CalleeSideArgEffects.lookup(idx);
     if (AE) {
       ObjKind K = AE->getObjKind();
       if (K == ObjKind::Generalized || K == ObjKind::OS ||
           (TrackNSCFStartParam && (K == ObjKind::ObjC || K == ObjKind::CF))) {

clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountDiagnostics.cpp

if (&Src->getParent()->getEntry() != Src || !CurrT ||
     return nullptr;
 
   const auto *VR = cast<VarRegion>(cast<SymbolRegionValue>(Sym)->getRegion());
   const auto *PVD = cast<ParmVarDecl>(VR->getDecl());
   PathDiagnosticLocation L = PathDiagnosticLocation(PVD, SM);
 
   std::string s;
   llvm::raw_string_ostream os(s);
-  os << "Parameter '" << PVD->getNameAsString()
-    << "' starts at +";
+  os << "Parameter '" << PVD->getNameAsString() << "' starts at +";
   if (CurrT->getCount() == 1) {
     os << "1, as it is marked as consuming";
   } else {
     assert(CurrT->getCount() == 0);
     os << "0";
   }
   return std::make_shared<PathDiagnosticEventPiece>(L, os.str());
 }

clang/test/Analysis/retain-release.m

void f16(int x, CFTypeRef p) {
   case 3:
     CFAutorelease(p); // expected-warning{{Null pointer argument in call to CFAutorelease}}
     break;
   default:
     break;
   }
 }
 
+#ifdef TRACK_START_PARAM
+@interface TestParam : NSObject
+- (void) f:(id) object;
+@end
+
+@implementation TestParam
+- (void) f:(id) object { // expected-warning{{Potential leak of an object of type 'id'}}
+  [object retain];
+  [object retain];
+}
+@end
+#endif
+
 // Test that an object is non-null after CFRetain/CFRelease/CFMakeCollectable/CFAutorelease.
 void f17(int x, CFTypeRef p) {
 #ifdef TRACK_START_PARAM
   // expected-warning@-2{{Potential leak of an object of type 'CFTypeRef'}}
 #endif
   switch (x) {
   case 0:
     CFRelease(p);