Refactor: Simplify boolean conditional return statements in tools/libclang

[LegalizeAdulthood]

Summary

Use clang-tidy to simplify boolean conditional return statements.

[chfast]

tools/libclang/IndexingContext.cpp

807

Restore the comment.

1155

I'm not sure about that. It breaks the symmetry.

[LegalizeAdulthood]

Update to latest.
Update from comments.
I don't have commit access.

[alexfh]

LG

tools/libclang/CIndex.cpp

if (TypeSourceInfo *SpecType = D->getTypeAsWritten()) {
     TypeLoc TL = SpecType->getTypeLoc();
     if (TemplateSpecializationTypeLoc TSTLoc =
             TL.getAs<TemplateSpecializationTypeLoc>()) {
       for (unsigned I = 0, N = TSTLoc.getNumArgs(); I != N; ++I)
         if (VisitTemplateArgumentLoc(TSTLoc.getArgLoc(I)))
           return true;
     }
   }
-  
-  if (ShouldVisitBody && VisitCXXRecordDecl(D))
-    return true;
-  
-  return false;
+  return ShouldVisitBody && VisitCXXRecordDecl(D);
 }
 
 bool CursorVisitor::VisitClassTemplatePartialSpecializationDecl(
                                    ClassTemplatePartialSpecializationDecl *D) {
   // FIXME: Visit the "outer" template parameter lists on the TagDecl
   // before visiting these template parameters.
   if (VisitTemplateParameters(D->getTemplateParameters()))
     return true;
if (VisitTemplateParameters(D->getTemplateParameters()))
     return true;
   
   return VisitCXXRecordDecl(D->getTemplatedDecl());
 }
 
 bool CursorVisitor::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
   if (VisitTemplateParameters(D->getTemplateParameters()))
     return true;
-  
-  if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited() &&
-      VisitTemplateArgumentLoc(D->getDefaultArgument()))
-    return true;
-  
-  return false;
+  return D->hasDefaultArgument() && !D->defaultArgumentWasInherited() &&
+         VisitTemplateArgumentLoc(D->getDefaultArgument());
 }
 
 bool CursorVisitor::VisitObjCMethodDecl(ObjCMethodDecl *ND) {
   if (TypeSourceInfo *TSInfo = ND->getReturnTypeSourceInfo())
     if (Visit(TSInfo->getTypeLoc()))
       return true;
 
   for (const auto *P : ND->params()) {
     if (Visit(MakeCXCursor(P, TU, RegionOfInterest)))
       return true;
   }
 
-  if (ND->isThisDeclarationADefinition() &&
-      Visit(MakeCXCursor(ND->getBody(), StmtParent, TU, RegionOfInterest)))
-    return true;
-
-  return false;
+  return ND->isThisDeclarationADefinition() &&
+         Visit(MakeCXCursor(ND->getBody(), StmtParent, TU, RegionOfInterest));
 }
 
 template <typename DeclIt>
 static void addRangedDeclsInContainer(DeclIt *DI_current, DeclIt DE_current,
                                       SourceManager &SM, SourceLocation EndLoc,
                                       SmallVectorImpl<Decl *> &Decls) {
   DeclIt next = *DI_current;
   while (++next != DE_current) {
bool CursorVisitor::VisitTagTypeLoc(TagTypeLoc TL) {
   return Visit(MakeCursorTypeRef(TL.getDecl(), TL.getNameLoc(), TU));
 }
 
 bool CursorVisitor::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
   return Visit(MakeCursorTypeRef(TL.getDecl(), TL.getNameLoc(), TU));
 }
 
 bool CursorVisitor::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) {
-  if (Visit(MakeCursorObjCClassRef(TL.getIFaceDecl(), TL.getNameLoc(), TU)))
-    return true;
-
-  return false;
+  return Visit(MakeCursorObjCClassRef(TL.getIFaceDecl(), TL.getNameLoc(), TU));
 }
 
 bool CursorVisitor::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) {
   if (TL.hasBaseTypeAsWritten() && Visit(TL.getBaseLoc()))
     return true;
 
   for (unsigned I = 0, N = TL.getNumProtocols(); I != N; ++I) {
     if (Visit(MakeCursorObjCProtocolRef(TL.getProtocol(I), TL.getProtocolLoc(I),

 bool CursorVisitor::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) {
   if (TypeSourceInfo *TSInfo = TL.getUnderlyingTInfo())
     return Visit(TSInfo->getTypeLoc());
 
   return false;
 }
 
 bool CursorVisitor::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) {
-  if (VisitNestedNameSpecifierLoc(TL.getQualifierLoc()))
-    return true;
-  
-  return false;
+  return VisitNestedNameSpecifierLoc(TL.getQualifierLoc());
 }
 
 bool CursorVisitor::VisitDependentTemplateSpecializationTypeLoc(
                                     DependentTemplateSpecializationTypeLoc TL) {
   // Visit the nested-name-specifier, if there is one.
   if (TL.getQualifierLoc() &&
       VisitNestedNameSpecifierLoc(TL.getQualifierLoc()))
     return true;

 /// \returns true if lexing was finished, false otherwise.
 static bool lexNext(Lexer &Lex, Token &Tok,
                    unsigned &NextIdx, unsigned NumTokens) {
   if (NextIdx >= NumTokens)
     return true;
 
   ++NextIdx;
   Lex.LexFromRawLexer(Tok);
-  if (Tok.is(tok::eof))
-    return true;
-
-  return false;
+  return Tok.is(tok::eof);
 }
 
 static void annotatePreprocessorTokens(CXTranslationUnit TU,
                                        SourceRange RegionOfInterest,
                                        CXCursor *Cursors,
                                        CXToken *Tokens,
                                        unsigned NumTokens) {
   ASTUnit *CXXUnit = cxtu::getASTUnit(TU);

tools/libclang/Indexing.cpp

if (InclusionDirective *ID = dyn_cast<InclusionDirective>(PPE)) {
                             !ID->wasInQuotes(), ID->importedModule());
     }
   }
 }
 
 static bool topLevelDeclVisitor(void *context, const Decl *D) {
   IndexingContext &IdxCtx = *static_cast<IndexingContext*>(context);
   IdxCtx.indexTopLevelDecl(D);
-  if (IdxCtx.shouldAbort())
-    return false;
-  return true;
+  return !IdxCtx.shouldAbort();
 }
 
 static void indexTranslationUnit(ASTUnit &Unit, IndexingContext &IdxCtx) {
   Unit.visitLocalTopLevelDecls(&IdxCtx, topLevelDeclVisitor);
 }
 
 static void indexDiagnostics(CXTranslationUnit TU, IndexingContext &IdxCtx) {
   if (!IdxCtx.hasDiagnosticCallback())

tools/libclang/IndexingContext.cpp

if (FID.isInvalid())
     return true;
   
   const FileEntry *FE = SM.getFileEntryForID(FID);
   if (!FE)
     return true;
   RefFileOccurrence RefOccur(FE, D);
   std::pair<llvm::DenseSet<RefFileOccurrence>::iterator, bool>
   res = RefFileOccurrences.insert(RefOccur);
-  if (!res.second)
-    return true; // already in map.
-
-  return false;
+  return !res.second;
 }
 
 const NamedDecl *IndexingContext::getEntityDecl(const NamedDecl *D) const {
   assert(D);
   D = cast<NamedDecl>(D->getCanonicalDecl());
 
   if (const ObjCImplementationDecl *
                ImplD = dyn_cast<ObjCImplementationDecl>(D)) {
bool IndexingContext::shouldIgnoreIfImplicit(const Decl *D) {
   if (isa<ObjCInterfaceDecl>(D))
     return false;
   if (isa<ObjCCategoryDecl>(D))
     return false;
   if (isa<ObjCIvarDecl>(D))
     return false;
   if (isa<ObjCMethodDecl>(D))
     return false;
-  if (isa<ImportDecl>(D))
-    return false;
-  return true;
+  return !isa<ImportDecl>(D);
 }
 
 bool IndexingContext::isTemplateImplicitInstantiation(const Decl *D) {
   if (const ClassTemplateSpecializationDecl *
         SD = dyn_cast<ClassTemplateSpecializationDecl>(D)) {
     return SD->getSpecializationKind() == TSK_ImplicitInstantiation;
   }
   if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
     return FD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation;
   }
   return false;
 }