Refactor: Simplify boolean conditional return statements in lib/StaticAnalyzer/Core

[LegalizeAdulthood]

Summary

Use clang-tidy to simplify boolean conditional return statements

[alexfh]

lib/StaticAnalyzer/Core/ExprEngineCallAndReturn.cpp

692–693

I'd leave alone code that is structured like a chain of conditions with a default in the end:

if (X)
  return true;
if (Y)
  return true;
...
if (Z)
  return true;
return false;

It's arguable whether changing the last if + return to return Z; makes the code more readable, so I'd just keep them as is.

[LegalizeAdulthood]

Update from latest

[LegalizeAdulthood]

lib/StaticAnalyzer/Core/ExprEngineCallAndReturn.cpp

692–693

In this case it isn't a simple if-return, if-return, if-return.

[zaks.anna]

lib/StaticAnalyzer/Core/ExprEngineCallAndReturn.cpp

692–693

I agree that we should keep these as is for better readability and maintainability.

lib/StaticAnalyzer/Core/SValBuilder.cpp

397

Same chaining pattern here. I do not think it should change.

lib/StaticAnalyzer/Core/SymbolManager.cpp

496

I am OK with changing this one.

lib/StaticAnalyzer/Core/ExprEngineCallAndReturn.cpp

 /// Returns true if the given C++ class contains a member with the given name.
 static bool hasMember(const ASTContext &Ctx, const CXXRecordDecl *RD,
                       StringRef Name) {
   const IdentifierInfo &II = Ctx.Idents.get(Name);
   DeclarationName DeclName = Ctx.DeclarationNames.getIdentifier(&II);
   if (!RD->lookup(DeclName).empty())
     return true;
 
   CXXBasePaths Paths(false, false, false);
-  if (RD->lookupInBases(
-          [DeclName](const CXXBaseSpecifier *Specifier, CXXBasePath &Path) {
-            return CXXRecordDecl::FindOrdinaryMember(Specifier, Path, DeclName);
-          },
-          Paths))
-    return true;
-
-  return false;
+  return RD->lookupInBases(
+      Paths);
 }
 
 /// Returns true if the given C++ class is a container or iterator.
 ///
 /// Our heuristic for this is whether it contains a method named 'begin()' or a
 /// nested type named 'iterator' or 'iterator_category'.
 static bool isContainerClass(const ASTContext &Ctx, const CXXRecordDecl *RD) {
   return hasMember(Ctx, RD, "begin") ||

lib/StaticAnalyzer/Core/SValBuilder.cpp

if (Quals1 != Quals2)
       return false;
   }
 
   // If we are casting to void, the 'From' value can be used to represent the
   // 'To' value.
   if (ToTy->isVoidType())
     return true;
 
-  if (ToTy != FromTy)
-    return false;
-
-  return true;
+  return ToTy == FromTy;
 }
 
 // FIXME: should rewrite according to the cast kind.
 SVal SValBuilder::evalCast(SVal val, QualType castTy, QualType originalTy) {
   castTy = Context.getCanonicalType(castTy);
   originalTy = Context.getCanonicalType(originalTy);
   if (val.isUnknownOrUndef() || castTy == originalTy)
     return val;

lib/StaticAnalyzer/Core/SymbolManager.cpp

 bool
 SymbolReaper::isLive(const Stmt *ExprVal, const LocationContext *ELCtx) const {
   if (LCtx == nullptr)
     return false;
 
   if (LCtx != ELCtx) {
     // If the reaper's location context is a parent of the expression's
     // location context, then the expression value is now "out of scope".
-    if (LCtx->isParentOf(ELCtx))
-      return false;
-    return true;
+    return !LCtx->isParentOf(ELCtx);
   }
 
   // If no statement is provided, everything is this and parent contexts is live.
   if (!Loc)
     return true;
 
   return LCtx->getAnalysis<RelaxedLiveVariables>()->isLive(Loc, ExprVal);
 }