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

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

lib/AST/Decl.cpp

2384

this should probably be:

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

lib/AST/DeclBase.cpp

305

another possible 'chain' style return

lib/AST/DeclCXX.cpp

413

Another chain return

lib/AST/Expr.cpp

2669

Possible chain

lib/AST/ExprConstant.cpp

207

possible chain

2220

possible chain

lib/AST/ItaniumMangle.cpp

1869

chain

3728

chain

[LegalizeAdulthood]

Update from latest.
I do not have commit access.

lib/AST/ASTContext.cpp

bool ASTContext::isSentinelNullExpr(const Expr *E) {
   if (E->getType()->isNullPtrType()) return true;
 
   if (E->getType()->isAnyPointerType() &&
       E->IgnoreParenCasts()->isNullPointerConstant(*this,
                                                 Expr::NPC_ValueDependentIsNull))
     return true;
 
   // Unfortunately, __null has type 'int'.
-  if (isa<GNUNullExpr>(E)) return true;
-
-  return false;
+  return isa<GNUNullExpr>(E);
 }
 
 /// \brief Get the implementation of ObjCInterfaceDecl,or NULL if none exists.
 ObjCImplementationDecl *ASTContext::getObjCImplementation(ObjCInterfaceDecl *D) {
   llvm::DenseMap<ObjCContainerDecl*, ObjCImplDecl*>::iterator
     I = ObjCImpls.find(D);
   if (I != ObjCImpls.end())
     return cast<ObjCImplementationDecl>(I->second);

 
 /// BlockRequiresCopying - Returns true if byref variable "D" of type "Ty"
 /// requires copy/dispose. Note that this must match the logic
 /// in buildByrefHelpers.
 bool ASTContext::BlockRequiresCopying(QualType Ty,
                                       const VarDecl *D) {
   if (const CXXRecordDecl *record = Ty->getAsCXXRecordDecl()) {
     const Expr *copyExpr = getBlockVarCopyInits(D);
-    if (!copyExpr && record->hasTrivialDestructor()) return false;
-    
-    return true;
+    return copyExpr || !record->hasTrivialDestructor();
   }
   
   if (!Ty->isObjCRetainableType()) return false;
   
   Qualifiers qs = Ty.getQualifiers();
   
   // If we have lifetime, that dominates.
   if (Qualifiers::ObjCLifetime lifetime = qs.getObjCLifetime()) {
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'.
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.
   GVALinkage L = GetGVALinkageForVariable(VD);
   if (L != GVA_Internal && L != GVA_AvailableExternally &&
       L != GVA_DiscardableODR)
     return true;
 
   // Variables that have destruction with side-effects are required.
   if (VD->getType().isDestructedType())
     return true;
 
   // Variables that have initialization with side-effects are required.
-  if (VD->getInit() && VD->getInit()->HasSideEffects(*this))
-    return true;
-
-  return false;
+  return VD->getInit() && VD->getInit()->HasSideEffects(*this);
 }
 
 CallingConv ASTContext::getDefaultCallingConvention(bool IsVariadic,
                                                     bool IsCXXMethod) const {
   // Pass through to the C++ ABI object
   if (IsCXXMethod)
     return ABI->getDefaultMethodCallConv(IsVariadic);
 

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/ASTImporter.cpp

static bool IsArrayStructurallyEquivalent(StructuralEquivalenceContext &Context,
                                           const ArrayType *Array1, 
                                           const ArrayType *Array2) {
   if (!IsStructurallyEquivalent(Context, 
                                 Array1->getElementType(), 
                                 Array2->getElementType()))
     return false;
   if (Array1->getSizeModifier() != Array2->getSizeModifier())
     return false;
-  if (Array1->getIndexTypeQualifiers() != Array2->getIndexTypeQualifiers())
-    return false;
-  
-  return true;
+  return Array1->getIndexTypeQualifiers() == Array2->getIndexTypeQualifiers();
 }
 
 /// \brief Determine structural equivalence of two types.
 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
                                      QualType T1, QualType T2) {
   if (T1.isNull() || T2.isNull())
     return T1.isNull() && T2.isNull();
   

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;

lib/AST/DeclBase.cpp

unsigned Decl::getMaxAlignment() const {
   return Align;
 }
 
 bool Decl::isUsed(bool CheckUsedAttr) const { 
   if (Used)
     return true;
   
   // Check for used attribute.
-  if (CheckUsedAttr && hasAttr<UsedAttr>())
-    return true;
-
-  return false; 
+  return CheckUsedAttr && hasAttr<UsedAttr>(); 
 }
 
 void Decl::markUsed(ASTContext &C) {
   if (Used)
     return;
 
   if (C.getASTMutationListener())
     C.getASTMutationListener()->DeclarationMarkedUsed(this);

lib/AST/DeclCXX.cpp

bool CXXRecordDecl::isTriviallyCopyable() const {
   if (hasNonTrivialCopyConstructor()) return false;
   //   -- has no non-trivial move constructors,
   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;
+  return hasTrivialDestructor();
 }
 
 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 (isa<MemberExpr>(E))
     return false;
 
   if (const BinaryOperator *BO = dyn_cast<BinaryOperator>(E))
     if (BO->isPtrMemOp())
       return false;
 
   // - opaque values (all)
-  if (isa<OpaqueValueExpr>(E))
-    return false;
-
-  return true;
+  return !isa<OpaqueValueExpr>(E);
 }
 
 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);
 }
 
 /// isArrow - Return true if the base expression is a pointer to vector,
 /// return false if the base expression is a vector.
 bool ExtVectorElementExpr::isArrow() const {
   return getBase()->getType()->isPointerType();
 }
 

lib/AST/ExprConstant.cpp

void setInvalid() {
       Entries.clear();
     }
 
     /// Determine whether this is a one-past-the-end pointer.
     bool isOnePastTheEnd() const {
       assert(!Invalid);
       if (IsOnePastTheEnd)
         return true;
-      if (MostDerivedArraySize &&
-          Entries[MostDerivedPathLength - 1].ArrayIndex == MostDerivedArraySize)
-        return true;
-      return false;
+      return MostDerivedArraySize &&
+             Entries[MostDerivedPathLength - 1].ArrayIndex ==
+                 MostDerivedArraySize;
     }
 
     /// Check that this refers to a valid subobject.
     bool isValidSubobject() const {
       if (Invalid)
         return false;
       return !isOnePastTheEnd();
     }
if (I == N) {
       if (ObjType->isRecordType() && handler.AccessKind == AK_Read &&
           diagnoseUnreadableFields(Info, E, ObjType))
         return handler.failed();
 
       if (!handler.found(*O, ObjType))
         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;
+      return handler.AccessKind == AK_Read || !LastField ||
+             !LastField->isBitField() ||
+             truncateBitfieldValue(Info, E, *O, LastField);
     }
 
     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;

lib/AST/ItaniumMangle.cpp

 
 static bool isTypeSubstitutable(Qualifiers Quals, const Type *Ty) {
   if (Quals)
     return true;
   if (Ty->isSpecificBuiltinType(BuiltinType::ObjCSel))
     return true;
   if (Ty->isOpenCLSpecificType())
     return true;
-  if (Ty->isBuiltinType())
-    return false;
-
-  return true;
+  return !Ty->isBuiltinType();
 }
 
 void CXXNameMangler::mangleType(QualType T) {
   // If our type is instantiation-dependent but not dependent, we mangle
   // it as it was written in the source, removing any top-level sugar. 
   // Otherwise, use the canonical type.
   //
   // FIXME: This is an approximation of the instantiation-dependent name 
static bool isStreamCharSpecialization(const ClassTemplateSpecializationDecl*SD,
 
   const TemplateArgumentList &TemplateArgs = SD->getTemplateArgs();
   if (TemplateArgs.size() != 2)
     return false;
 
   if (!isCharType(TemplateArgs[0].getAsType()))
     return false;
 
-  if (!isCharSpecialization(TemplateArgs[1].getAsType(), "char_traits"))
-    return false;
-
-  return true;
+  return isCharSpecialization(TemplateArgs[1].getAsType(), "char_traits");
 }
 
 bool CXXNameMangler::mangleStandardSubstitution(const NamedDecl *ND) {
   // <substitution> ::= St # ::std::
   if (const NamespaceDecl *NS = dyn_cast<NamespaceDecl>(ND)) {
     if (isStd(NS)) {
       Out << "St";
       return true;

lib/AST/Type.cpp

bool Type::isLiteralType(const ASTContext &Ctx) const {
   }
 
   // We treat _Atomic T as a literal type if T is a literal type.
   if (const AtomicType *AT = BaseTy->getAs<AtomicType>())
     return AT->getValueType()->isLiteralType(Ctx);
 
   // If this type hasn't been deduced yet, then conservatively assume that
   // it'll work out to be a literal type.
-  if (isa<AutoType>(BaseTy->getCanonicalTypeInternal()))
-    return true;
-
-  return false;
+  return isa<AutoType>(BaseTy->getCanonicalTypeInternal());
 }
 
 bool Type::isStandardLayoutType() const {
   if (isDependentType())
     return false;
 
   // C++0x [basic.types]p9:
   //   Scalar types, standard-layout class types, arrays of such types, and
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()) {