Refactor: Simplify boolean conditional return statements in lib/ARCMigrate

[LegalizeAdulthood]

Summary

Use clang-tidy to simplify boolean conditional return statements

[aaron.ballman]

LGTM!

~Aaron

[alexfh]

lib/ARCMigrate/TransRetainReleaseDealloc.cpp

177 ↗

(On Diff #26475)

I'd replace both ifs with return isPlusOneAssignBeforeOrAfterAutorelease(E) || isReturnedAfterAutorelease(E);.

226 ↗

(On Diff #26475)

I'd replace both ifs with return RefD == getReferencedDecl(Bop->getLHS()) && isPlusOneAssign(Bop);

cfe/trunk/lib/ARCMigrate/ObjCMT.cpp

bool ObjCMigrateAction::BeginInvocation(CompilerInstance &CI) {
   CI.getDiagnostics().setIgnoreAllWarnings(true);
   return true;
 }
 
 namespace {
   // FIXME. This duplicates one in RewriteObjCFoundationAPI.cpp
   bool subscriptOperatorNeedsParens(const Expr *FullExpr) {
     const Expr* Expr = FullExpr->IgnoreImpCasts();
-    if (isa<ArraySubscriptExpr>(Expr) ||
-        isa<CallExpr>(Expr) ||
-        isa<DeclRefExpr>(Expr) ||
-        isa<CXXNamedCastExpr>(Expr) ||
-        isa<CXXConstructExpr>(Expr) ||
-        isa<CXXThisExpr>(Expr) ||
+    return !(isa<ArraySubscriptExpr>(Expr) || isa<CallExpr>(Expr) ||
+             isa<DeclRefExpr>(Expr) || isa<CXXNamedCastExpr>(Expr) ||
+             isa<CXXConstructExpr>(Expr) || isa<CXXThisExpr>(Expr) ||
              isa<CXXTypeidExpr>(Expr) ||
              isa<CXXUnresolvedConstructExpr>(Expr) ||
-        isa<ObjCMessageExpr>(Expr) ||
-        isa<ObjCPropertyRefExpr>(Expr) ||
-        isa<ObjCProtocolExpr>(Expr) ||
-        isa<MemberExpr>(Expr) ||
-        isa<ObjCIvarRefExpr>(Expr) ||
-        isa<ParenExpr>(FullExpr) ||
-        isa<ParenListExpr>(Expr) ||
-        isa<SizeOfPackExpr>(Expr))
-      return false;
-    
-    return true;
+             isa<ObjCMessageExpr>(Expr) || isa<ObjCPropertyRefExpr>(Expr) ||
+             isa<ObjCProtocolExpr>(Expr) || isa<MemberExpr>(Expr) ||
+             isa<ObjCIvarRefExpr>(Expr) || isa<ParenExpr>(FullExpr) ||
+             isa<ParenListExpr>(Expr) || isa<SizeOfPackExpr>(Expr));
   }
   
   /// \brief - Rewrite message expression for Objective-C setter and getters into
   /// property-dot syntax.
   bool rewriteToPropertyDotSyntax(const ObjCMessageExpr *Msg,
                                   Preprocessor &PP,
                                   const NSAPI &NS, edit::Commit &commit,
                                   const ParentMap *PMap) {
for (const auto *MD : PDecl->methods()) {
           if (Ctx.ObjCMethodsAreEqual(MD, ImpMD)) {
             match = true;
             break;
           }
       if (!match)
         return false;
     }
   }
-  if (HasAtleastOneRequiredProperty || HasAtleastOneRequiredMethod)
-    return true;
-  return false;
+  return HasAtleastOneRequiredProperty || HasAtleastOneRequiredMethod;
 }
 
 static bool rewriteToObjCInterfaceDecl(const ObjCInterfaceDecl *IDecl,
                     llvm::SmallVectorImpl<ObjCProtocolDecl*> &ConformingProtocols,
                     const NSAPI &NS, edit::Commit &commit) {
   const ObjCList<ObjCProtocolDecl> &Protocols = IDecl->getReferencedProtocols();
   std::string ClassString;
   SourceLocation EndLoc =

cfe/trunk/lib/ARCMigrate/TransEmptyStatementsAndDealloc.cpp

if (S->getConditionVariable())
       return false;
     Expr *condE = S->getCond();
     if (!condE)
       return false;
     if (hasSideEffects(condE, Ctx))
       return false;
     if (!S->getThen() || !Visit(S->getThen()))
       return false;
-    if (S->getElse() && !Visit(S->getElse()))
-      return false;
-    return true;
+    return !S->getElse() || Visit(S->getElse());
   }
   bool VisitWhileStmt(WhileStmt *S) {
     if (S->getConditionVariable())
       return false;
     Expr *condE = S->getCond();
     if (!condE)
       return false;
     if (hasSideEffects(condE, Ctx))

cfe/trunk/lib/ARCMigrate/TransGCAttrs.cpp

public:
   static bool hasObjCImpl(Decl *D) {
     if (!D)
       return false;
     if (ObjCContainerDecl *ContD = dyn_cast<ObjCContainerDecl>(D)) {
       if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(ContD))
         return ID->getImplementation() != nullptr;
       if (ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(ContD))
         return CD->getImplementation() != nullptr;
-      if (isa<ObjCImplDecl>(ContD))
-        return true;
-      return false;
+      return isa<ObjCImplDecl>(ContD);
     }
     return false;
   }
 
   bool isInMainFile(Decl *D) {
     if (!D)
       return false;
 

cfe/trunk/lib/ARCMigrate/TransRetainReleaseDealloc.cpp

if (Msg->getMethodFamily() == OMF_release &&
       // when an exception is thrown.
       Pass.TA.replace(RecContainer->getSourceRange(), RecRange);
       std::string str = " = ";
       str += getNilString(Pass);
       Pass.TA.insertAfterToken(RecRange.getEnd(), str);
       return true;
     }
 
-    if (!hasSideEffects(rec, Pass.Ctx)) {
-      if (tryRemoving(RecContainer))
-        return true;
-    }
+    if (hasSideEffects(rec, Pass.Ctx) || !tryRemoving(RecContainer))
       Pass.TA.replace(RecContainer->getSourceRange(), RecRange);
 
     return true;
   }
 
 private:
   /// \brief Checks for idioms where an unused -autorelease is common.
   ///
   /// Returns true for this idiom which is common in property
   /// setters:
   ///
   ///   [backingValue autorelease];
   ///   backingValue = [newValue retain]; // in general a +1 assign
   ///
   /// For these as well:
   ///
   ///   [[var retain] autorelease];
   ///   return var;
   ///
   bool isCommonUnusedAutorelease(ObjCMessageExpr *E) {
-    if (isPlusOneAssignBeforeOrAfterAutorelease(E))
-      return true;
-    if (isReturnedAfterAutorelease(E))
-      return true;
-    return false;
+    return isPlusOneAssignBeforeOrAfterAutorelease(E) ||
+           isReturnedAfterAutorelease(E);
   }
 
   bool isReturnedAfterAutorelease(ObjCMessageExpr *E) {
     Expr *Rec = E->getInstanceReceiver();
     if (!Rec)
       return false;
 
     Decl *RefD = getReferencedDecl(Rec);
private:
 
   bool isPlusOneAssignToVar(Stmt *S, Decl *RefD) {
     if (!S)
       return false;
 
     // Check for "RefD = [+1 retained object];".
 
     if (BinaryOperator *Bop = dyn_cast<BinaryOperator>(S)) {
-      if (RefD != getReferencedDecl(Bop->getLHS()))
-        return false;
-      if (isPlusOneAssign(Bop))
-        return true;
-      return false;
+      return (RefD == getReferencedDecl(Bop->getLHS())) && isPlusOneAssign(Bop);
     }
 
     if (DeclStmt *DS = dyn_cast<DeclStmt>(S)) {
       if (DS->isSingleDecl() && DS->getSingleDecl() == RefD) {
         if (VarDecl *VD = dyn_cast<VarDecl>(RefD))
           return isPlusOne(VD->getInit());
       }
       return false;

cfe/trunk/lib/ARCMigrate/Transforms.cpp

if (const FunctionDecl *FD = callE->getDirectCallee()) {
       }
     }
   }
 
   const ImplicitCastExpr *implCE = dyn_cast<ImplicitCastExpr>(E);
   while (implCE && implCE->getCastKind() ==  CK_BitCast)
     implCE = dyn_cast<ImplicitCastExpr>(implCE->getSubExpr());
 
-  if (implCE && implCE->getCastKind() == CK_ARCConsumeObject)
-    return true;
-
-  return false;
+  return implCE && implCE->getCastKind() == CK_ARCConsumeObject;
 }
 
 /// \brief 'Loc' is the end of a statement range. This returns the location
 /// immediately after the semicolon following the statement.
 /// If no semicolon is found or the location is inside a macro, the returned
 /// source location will be invalid.
 SourceLocation trans::findLocationAfterSemi(SourceLocation loc,
                                             ASTContext &Ctx, bool IsDecl) {