Refactor: Simplify boolean conditional return statements in lib/AST

[LegalizeAdulthood]

Summary

Use clang-tidy to simplify boolean conditional return statements

[LegalizeAdulthood]

diff -U9999

[dblaikie]

lib/AST/ASTImporter.cpp

401 ↗

(On Diff #26487)

Isn't this the sort of chained conditional you/we decided not to flag/suggest changes on?

lib/AST/Decl.cpp

2380

this should probably be:

if (auto *CS = dyn_cast<CompoundStmt>(S))
  return CS->body_empty();
return false;

lib/AST/DeclBase.cpp

305 ↗

(On Diff #26487)

another possible 'chain' style return

lib/AST/DeclCXX.cpp

409

Another chain return

lib/AST/Expr.cpp

2677

Possible chain

lib/AST/ExprConstant.cpp

225

possible chain

2274

possible chain

lib/AST/ItaniumMangle.cpp

1869 ↗

(On Diff #26487)

chain

3728 ↗

(On Diff #26487)

chain

[LegalizeAdulthood]

Update from latest.
I do not have commit access.

lib/AST/ASTContext.cpp

bool ASTContext::areCompatibleVectorTypes(QualType FirstVec,
 
   if (hasSameUnqualifiedType(FirstVec, SecondVec))
     return true;
 
   // Treat Neon vector types and most AltiVec vector types as if they are the
   // equivalent GCC vector types.
   const VectorType *First = FirstVec->getAs<VectorType>();
   const VectorType *Second = SecondVec->getAs<VectorType>();
-  if (First->getNumElements() == Second->getNumElements() &&
+  return First->getNumElements() == Second->getNumElements() &&
          hasSameType(First->getElementType(), Second->getElementType()) &&
          First->getVectorKind() != VectorType::AltiVecPixel &&
          First->getVectorKind() != VectorType::AltiVecBool &&
          Second->getVectorKind() != VectorType::AltiVecPixel &&
-      Second->getVectorKind() != VectorType::AltiVecBool)
-    return true;
-
-  return false;
+         Second->getVectorKind() != VectorType::AltiVecBool;
 }
 
 //===----------------------------------------------------------------------===//
 // ObjCQualifiedIdTypesAreCompatible - Compatibility testing for qualified id's.
 //===----------------------------------------------------------------------===//
 
 /// ProtocolCompatibleWithProtocol - return 'true' if 'lProto' is in the
 /// inheritance hierarchy of 'rProto'.
static bool canAssignObjCObjectTypes(ASTContext &ctx, QualType lhs,
   // Two block pointers.
   const BlockPointerType *lhsBlock = lhs->getAs<BlockPointerType>();
   const BlockPointerType *rhsBlock = rhs->getAs<BlockPointerType>();
   if (lhsBlock && rhsBlock)
     return ctx.typesAreBlockPointerCompatible(lhs, rhs);
 
   // If either is an unqualified 'id' and the other is a block, it's
   // acceptable.
-  if ((lhsOPT && lhsOPT->isObjCIdType() && rhsBlock) ||
-      (rhsOPT && rhsOPT->isObjCIdType() && lhsBlock))
-    return true;
-
-  return false;
+  return (lhsOPT && lhsOPT->isObjCIdType() && rhsBlock) ||
+         (rhsOPT && rhsOPT->isObjCIdType() && lhsBlock);
 }
 
 // Check that the given Objective-C type argument lists are equivalent.
 static bool sameObjCTypeArgs(ASTContext &ctx,
                              const ObjCInterfaceDecl *iface,
                              ArrayRef<QualType> lhsArgs,
                              ArrayRef<QualType> rhsArgs,
                              bool stripKindOf) {
if (getTargetInfo().getCXXABI().canKeyFunctionBeInline()) {
       }
     }
 
     GVALinkage Linkage = GetGVALinkageForFunction(FD);
 
     // static, static inline, always_inline, and extern inline functions can
     // always be deferred.  Normal inline functions can be deferred in C99/C++.
     // Implicit template instantiations can also be deferred in C++.
-    if (Linkage == GVA_Internal || Linkage == GVA_AvailableExternally ||
-        Linkage == GVA_DiscardableODR)
-      return false;
-    return true;
+    return !(Linkage == GVA_Internal || Linkage == GVA_AvailableExternally ||
+             Linkage == GVA_DiscardableODR);
   }
-  
   const VarDecl *VD = cast<VarDecl>(D);
   assert(VD->isFileVarDecl() && "Expected file scoped var");
 
   if (VD->isThisDeclarationADefinition() == VarDecl::DeclarationOnly &&
       !isMSStaticDataMemberInlineDefinition(VD))
     return false;
 
   // Variables that can be needed in other TUs are required.

lib/AST/ASTDiagnostic.cpp

if (E) {
       if (UnaryOperator *UO = dyn_cast<UnaryOperator>(E->IgnoreParens())) {
         if (UO->getOpcode() == UO_AddrOf) {
           return true;
         }
       }
       return false;
     }
 
-    if (!Default->getType()->isReferenceType()) {
-      return true;
-    }
-
-    return false;
+    return !Default->getType()->isReferenceType();
   }
 
   /// DiffNonTypes - Handles any template parameters not handled by DiffTypes
   /// of DiffTemplatesTemplates, such as integer and declaration parameters.
   void DiffNonTypes(const TSTiterator &FromIter, const TSTiterator &ToIter,
                     NonTypeTemplateParmDecl *FromDefaultNonTypeDecl,
                     NonTypeTemplateParmDecl *ToDefaultNonTypeDecl) {
     Expr *FromExpr = nullptr, *ToExpr = nullptr;

lib/AST/Decl.cpp

 {
   Stmt *S = getBody();
   if (!S) {
     // Since we don't have a body for this function, we don't know if it's
     // trivial or not.
     return false;
   }
 
-  if (isa<CompoundStmt>(S) && cast<CompoundStmt>(S)->body_empty())
-    return true;
-  return false;
+  return isa<CompoundStmt>(S) && cast<CompoundStmt>(S)->body_empty();
 }
 
 bool FunctionDecl::isDefined(const FunctionDecl *&Definition) const {
   for (auto I : redecls()) {
     if (I->IsDeleted || I->IsDefaulted || I->Body || I->IsLateTemplateParsed ||
         I->hasAttr<AliasAttr>()) {
       Definition = I->IsDeleted ? I->getCanonicalDecl() : I;
       return true;
static bool RedeclForcesDefC99(const FunctionDecl *Redecl) {
   if (!Redecl->getLexicalDeclContext()->isTranslationUnit())
     return false;
 
   // Only consider explicit declarations; the presence of a builtin for a
   // libcall shouldn't affect whether a definition is externally visible.
   if (Redecl->isImplicit())
     return false;
 
-  if (!Redecl->isInlineSpecified() || Redecl->getStorageClass() == SC_Extern) 
-    return true; // Not an inline definition
-
-  return false;
+  return !Redecl->isInlineSpecified() || Redecl->getStorageClass() == SC_Extern;
 }
 
 /// \brief For a function declaration in C or C++, determine whether this
 /// declaration causes the definition to be externally visible.
 ///
 /// For instance, this determines if adding the current declaration to the set
 /// of redeclarations of the given functions causes
 /// isInlineDefinitionExternallyVisible to change from false to true.

lib/AST/DeclCXX.cpp

bool CXXRecordDecl::isTriviallyCopyable() const {
   if (hasNonTrivialMoveConstructor()) return false;
   //   -- has no non-trivial copy assignment operators,
   if (hasNonTrivialCopyAssignment()) return false;
   //   -- has no non-trivial move assignment operators, and
   if (hasNonTrivialMoveAssignment()) return false;
   //   -- has a trivial destructor.
   if (!hasTrivialDestructor()) return false;
 
   return true;
 }
 
 void CXXRecordDecl::markedVirtualFunctionPure() {
   // C++ [class.abstract]p2: 
   //   A class is abstract if it has at least one pure virtual function.
   data().Abstract = true;
 }
 
bool CXXConstructorDecl::isSpecializationCopyingObject() const {
   const ParmVarDecl *Param = getParamDecl(0);
 
   ASTContext &Context = getASTContext();
   CanQualType ParamType = Context.getCanonicalType(Param->getType());
   
   // Is it the same as our our class type?
   CanQualType ClassTy 
     = Context.getCanonicalType(Context.getTagDeclType(getParent()));
-  if (ParamType.getUnqualifiedType() != ClassTy)
-    return false;
-  
-  return true;  
+  return ParamType.getUnqualifiedType() == ClassTy;
 }
 
 const CXXConstructorDecl *CXXConstructorDecl::getInheritedConstructor() const {
   // Hack: we store the inherited constructor in the overridden method table
   method_iterator It = getASTContext().overridden_methods_begin(this);
   if (It == getASTContext().overridden_methods_end(this))
     return nullptr;
 

lib/AST/Expr.cpp

bool Expr::isTemporaryObject(ASTContext &C, const CXXRecordDecl *TempTy) const {
   if (const BinaryOperator *BO = dyn_cast<BinaryOperator>(E))
     if (BO->isPtrMemOp())
       return false;
 
   // - opaque values (all)
   if (isa<OpaqueValueExpr>(E))
     return false;
 
   return true;
 }
 
 bool Expr::isImplicitCXXThis() const {
   const Expr *E = this;
   
   // Strip away parentheses and casts we don't care about.
   while (true) {
     if (const ParenExpr *Paren = dyn_cast<ParenExpr>(E)) {
if (ICE->getValueKind() != VK_RValue &&
       E = ICE->getSubExpr()->IgnoreParens();
     else
       break;
   }
   
   if (const ArraySubscriptExpr *ASE = dyn_cast<ArraySubscriptExpr>(E))
     return ASE->getBase()->getType()->isVectorType();
 
-  if (isa<ExtVectorElementExpr>(E))
-    return true;
-
-  return false;
+  return isa<ExtVectorElementExpr>(E);
 }
 
 bool Expr::refersToGlobalRegisterVar() const {
   const Expr *E = this->IgnoreParenImpCasts();
 
   if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
     if (const auto *VD = dyn_cast<VarDecl>(DRE->getDecl()))
       if (VD->getStorageClass() == SC_Register &&

lib/AST/ExprConstant.cpp

struct SubobjectDesignator {
     /// Determine whether this is a one-past-the-end pointer.
     bool isOnePastTheEnd() const {
       assert(!Invalid);
       if (IsOnePastTheEnd)
         return true;
       if (MostDerivedIsArrayElement &&
           Entries[MostDerivedPathLength - 1].ArrayIndex == MostDerivedArraySize)
         return true;
       return false;
     }
 
     /// Check that this refers to a valid subobject.
     bool isValidSubobject() const {
       if (Invalid)
         return false;
       return !isOnePastTheEnd();
     }
if (I == N) {
         return false;
 
       // If we modified a bit-field, truncate it to the right width.
       if (handler.AccessKind != AK_Read &&
           LastField && LastField->isBitField() &&
           !truncateBitfieldValue(Info, E, *O, LastField))
         return false;
 
       return true;
     }
 
     LastField = nullptr;
     if (ObjType->isArrayType()) {
       // Next subobject is an array element.
       const ConstantArrayType *CAT = Info.Ctx.getAsConstantArrayType(ObjType);
       assert(CAT && "vla in literal type?");
       uint64_t Index = Sub.Entries[I].ArrayIndex;
if (E->isLogicalOp()) {
     }
 
     return true;
   }
 
   assert(E->getLHS()->getType()->isIntegralOrEnumerationType() &&
          E->getRHS()->getType()->isIntegralOrEnumerationType());
 
-  if (LHSResult.Failed && !Info.keepEvaluatingAfterFailure())
-    return false; // Ignore RHS;
-
-  return true;
+  return !(LHSResult.Failed && !Info.keepEvaluatingAfterFailure());
 }
 
 bool DataRecursiveIntBinOpEvaluator::
        VisitBinOp(const EvalResult &LHSResult, const EvalResult &RHSResult,
                   const BinaryOperator *E, APValue &Result) {
   if (E->getOpcode() == BO_Comma) {
     if (RHSResult.Failed)
       return false;

lib/AST/Type.cpp

case MemberPointer: {
     ASTContext &Context = RD->getASTContext();
     // Member pointers not in the MS ABI don't get special treatment.
     if (!Context.getTargetInfo().getCXXABI().isMicrosoft())
       return false;
     // The inheritance attribute might only be present on the most recent
     // CXXRecordDecl, use that one.
     RD = RD->getMostRecentDecl();
     // Nothing interesting to do if the inheritance attribute is already set.
-    if (RD->hasAttr<MSInheritanceAttr>())
-      return false;
-    return true;
+    return !RD->hasAttr<MSInheritanceAttr>();
   }
   case ObjCObject:
     return cast<ObjCObjectType>(CanonicalType)->getBaseType()
              ->isIncompleteType(Def);
   case ObjCInterface: {
     // ObjC interfaces are incomplete if they are @class, not @interface.
     ObjCInterfaceDecl *Interface
       = cast<ObjCInterfaceType>(CanonicalType)->getDecl();
case BuiltinType::Char32:
       return true;
     default:
       return false;
     }
 
   // Enumerated types are promotable to their compatible integer types
   // (C99 6.3.1.1) a.k.a. its underlying type (C++ [conv.prom]p2).
   if (const EnumType *ET = getAs<EnumType>()){
-    if (this->isDependentType() || ET->getDecl()->getPromotionType().isNull()
-        || ET->getDecl()->isScoped())
-      return false;
-    
-    return true;
+    return !(this->isDependentType() ||
+             ET->getDecl()->getPromotionType().isNull() ||
+             ET->getDecl()->isScoped());
   }
-  
   return false;
 }
 
 bool Type::isSpecifierType() const {
   // Note that this intentionally does not use the canonical type.
   switch (getTypeClass()) {
   case Builtin:
   case Record: