[analyzer] [NFC] Minor refactoring of ISL-specific code in RetainCountChecker

[NoQ]

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

485–489

Ok, so now we no longer promise to initialize isTrustedReferenceCountImplementation.

Maybe just return a pair of bool?

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

bool RetainCountChecker::evalCall(const CallExpr *CE, CheckerContext &C) const {
   RetainSummaryManager &SmrMgr = getSummaryManager(C);
   QualType ResultTy = CE->getCallReturnType(C.getASTContext());
 
   // See if the function has 'rc_ownership_trusted_implementation'
   // annotate attribute. If it does, we will not inline it.
   bool hasTrustedImplementationAnnotation = false;
 
   // See if it's one of the specific functions we know how to eval.
-  bool canEval = SmrMgr.canEval(CE, FD, hasTrustedImplementationAnnotation);
-
-  if (!canEval)
+  if (!SmrMgr.canEval(CE, FD, hasTrustedImplementationAnnotation))
     return false;
 
   // Bind the return value.
   const LocationContext *LCtx = C.getLocationContext();
   SVal RetVal = state->getSVal(CE->getArg(0), LCtx);
   if (RetVal.isUnknown() ||
       (hasTrustedImplementationAnnotation && !ResultTy.isNull())) {
     // If the receiver is unknown or the function has
for (SmallVectorImpl<SymbolRef>::iterator
           new CFRefLeakReport(*BT, LOpts, SummaryLog, N, *I, Ctx,
                               IncludeAllocationLine)));
     }
   }
 
   return N;
 }
 
-static bool isGeneralizedObjectRef(QualType Ty) {
-  if (Ty.getAsString().substr(0, 4) == "isl_")
-    return true;
-  else
-    return false;
+static bool isISLObjectRef(QualType Ty) {
+  return StringRef(Ty.getAsString()).startswith("isl_");
 }
 
 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());
 
   if (!FD || SmrMgr.isTrustedReferenceCountImplementation(FD))
     return;
 
   ProgramStateRef state = Ctx.getState();
   const RetainSummary *FunctionSummary = SmrMgr.getFunctionSummary(FD);
   ArgEffects CalleeSideArgEffects = FunctionSummary->getArgEffects();
 
   for (unsigned idx = 0, e = FD->getNumParams(); idx != e; ++idx) {
     const ParmVarDecl *Param = FD->getParamDecl(idx);
     SymbolRef Sym = state->getSVal(state->getRegion(Param, LCtx)).getAsSymbol();
 
     QualType Ty = Param->getType();
     const ArgEffect *AE = CalleeSideArgEffects.lookup(idx);
-    if (AE && *AE == DecRef && isGeneralizedObjectRef(Ty)) {
+    if (AE && *AE == DecRef && isISLObjectRef(Ty)) {
       state = setRefBinding(state, Sym, RefVal::makeOwned(RetEffect::ObjKind::Generalized, Ty));
-    } else if (isGeneralizedObjectRef(Ty)) {
+    } else if (isISLObjectRef(Ty)) {
       state = setRefBinding(
           state, Sym,
           RefVal::makeNotOwned(RetEffect::ObjKind::Generalized, Ty));
     }
   }
 
   Ctx.addTransition(state);
 }

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

if (ResultTy->isObjCIdType()) {
     //         CFAutorelease
     // It's okay to be a little sloppy here.
     if (cocoa::isRefType(ResultTy, "CF", FName) ||
         cocoa::isRefType(ResultTy, "CG", FName) ||
         cocoa::isRefType(ResultTy, "CV", FName))
       return isRetain(FD, FName) || isAutorelease(FD, FName) ||
              isMakeCollectable(FName);
 
-    if (FD->getDefinition()) {
-      bool out = isTrustedReferenceCountImplementation(FD->getDefinition());
-      hasTrustedImplementationAnnotation = out;
-      return out;
+    const FunctionDecl* FDD = FD->getDefinition();
+    if (FDD && isTrustedReferenceCountImplementation(FDD)) {
+      hasTrustedImplementationAnnotation = true;
+      return true;
     }
   }
 
   return false;
 
 }
 
 const RetainSummary *
 RetainSummaryManager::getUnarySummary(const FunctionType* FT,