[clang-tidy] Cleanup namespace in utils folder.

[etienneb]

Summary

This is a step forward cleaning up the namespaces in clang-tidy/utils.
There is no behavior change.

[etienneb]

add missing case

[etienneb]

fix unittests

[alexfh]

LG. Thank you!

clang-tidy/cppcoreguidelines/ProBoundsConstantArrayIndexCheck.h

 
 /// This checks that all array subscriptions on static arrays and std::arrays
 /// have a constant index and are within bounds
 ///
 /// For the user-facing documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-pro-bounds-constant-array-index.html
 class ProBoundsConstantArrayIndexCheck : public ClangTidyCheck {
   const std::string GslHeader;
-  const IncludeSorter::IncludeStyle IncludeStyle;
-  std::unique_ptr<IncludeInserter> Inserter;
+  const utils::IncludeSorter::IncludeStyle IncludeStyle;
+  std::unique_ptr<utils::IncludeInserter> Inserter;
 
 public:
   ProBoundsConstantArrayIndexCheck(StringRef Name, ClangTidyContext *Context);
   void registerPPCallbacks(CompilerInstance &Compiler) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
 } // namespace cppcoreguidelines
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_BOUNDS_CONSTANT_ARRAY_INDEX_H

clang-tidy/cppcoreguidelines/ProBoundsConstantArrayIndexCheck.cpp

 
 namespace clang {
 namespace tidy {
 namespace cppcoreguidelines {
 
 ProBoundsConstantArrayIndexCheck::ProBoundsConstantArrayIndexCheck(
     StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context), GslHeader(Options.get("GslHeader", "")),
-      IncludeStyle(IncludeSorter::parseIncludeStyle(
+      IncludeStyle(utils::IncludeSorter::parseIncludeStyle(
           Options.get("IncludeStyle", "llvm"))) {}
 
 void ProBoundsConstantArrayIndexCheck::storeOptions(
     ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "GslHeader", GslHeader);
   Options.store(Opts, "IncludeStyle", IncludeStyle);
 }
 
 void ProBoundsConstantArrayIndexCheck::registerPPCallbacks(
     CompilerInstance &Compiler) {
   if (!getLangOpts().CPlusPlus)
     return;
 
-  Inserter.reset(new IncludeInserter(Compiler.getSourceManager(),
-                                     Compiler.getLangOpts(), IncludeStyle));
+  Inserter.reset(new utils::IncludeInserter(
+      Compiler.getSourceManager(), Compiler.getLangOpts(), IncludeStyle));
   Compiler.getPreprocessor().addPPCallbacks(Inserter->CreatePPCallbacks());
 }
 
 void ProBoundsConstantArrayIndexCheck::registerMatchers(MatchFinder *Finder) {
   if (!getLangOpts().CPlusPlus)
     return;
 
   Finder->addMatcher(arraySubscriptExpr(hasBase(ignoringImpCasts(hasType(

clang-tidy/cppcoreguidelines/ProTypeMemberInitCheck.cpp

 namespace {
 
 void fieldsRequiringInit(const RecordDecl::field_range &Fields,
                          ASTContext &Context,
                          SmallPtrSetImpl<const FieldDecl *> &FieldsToInit) {
   for (const FieldDecl *F : Fields) {
     QualType Type = F->getType();
     if (!F->hasInClassInitializer() &&
-        type_traits::isTriviallyDefaultConstructible(Type, Context))
+        utils::type_traits::isTriviallyDefaultConstructible(Type, Context))
       FieldsToInit.insert(F);
   }
 }
 
 void removeFieldsInitializedInBody(
     const Stmt &Stmt, ASTContext &Context,
     SmallPtrSetImpl<const FieldDecl *> &FieldDecls) {
   auto Matches =
struct IntializerInsertion {
   SourceLocation getLocation(const ASTContext &Context,
                              const CXXConstructorDecl &Constructor) const {
     assert((Where != nullptr || Placement == InitializerPlacement::New) &&
            "Location should be relative to an existing initializer or this "
            "insertion represents a new initializer list.");
     SourceLocation Location;
     switch (Placement) {
     case InitializerPlacement::New:
-      Location = lexer_utils::getPreviousNonCommentToken(
+      Location = utils::lexer::getPreviousNonCommentToken(
                      Context, Constructor.getBody()->getLocStart())
                      .getLocation();
       break;
     case InitializerPlacement::Before:
-      Location = lexer_utils::getPreviousNonCommentToken(
+      Location = utils::lexer::getPreviousNonCommentToken(
                      Context, Where->getSourceRange().getBegin())
                      .getLocation();
       break;
     case InitializerPlacement::After:
       Location = Where->getRParenLoc();
       break;
     }
     return getLocationForEndOfToken(Context, Location);
void ProTypeMemberInitCheck::checkMissingBaseClassInitializer(
 
   // Gather any base classes that need to be initialized.
   SmallVector<const RecordDecl *, 4> AllBases;
   SmallPtrSet<const RecordDecl *, 4> BasesToInit;
   for (const CXXBaseSpecifier &Base : ClassDecl->bases()) {
     if (const auto *BaseClassDecl = getCanonicalRecordDecl(Base.getType())) {
       AllBases.emplace_back(BaseClassDecl);
       if (!BaseClassDecl->field_empty() &&
-          type_traits::isTriviallyDefaultConstructible(Base.getType(), Context))
+          utils::type_traits::isTriviallyDefaultConstructible(
+              Base.getType(), Context))
         BasesToInit.insert(BaseClassDecl);
     }
   }
 
   if (BasesToInit.empty())
     return;
 
   // Remove any bases that were explicitly written in the initializer list.

clang-tidy/llvm/HeaderGuardCheck.h

 
 #include "../utils/HeaderGuard.h"
 
 namespace clang {
 namespace tidy {
 namespace llvm {
 
 /// Finds and fixes header guards that do not adhere to LLVM style.
-class LLVMHeaderGuardCheck : public HeaderGuardCheck {
+class LLVMHeaderGuardCheck : public utils::HeaderGuardCheck {
 public:
   LLVMHeaderGuardCheck(StringRef Name, ClangTidyContext *Context)
       : HeaderGuardCheck(Name, Context) {}
   bool shouldSuggestEndifComment(StringRef Filename) override { return false; }
   bool shouldFixHeaderGuard(StringRef Filename) override;
   std::string getHeaderGuard(StringRef Filename, StringRef OldGuard) override;
 };
 
 } // namespace llvm
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVM_HEADER_GUARD_CHECK_H

clang-tidy/misc/MoveConstructorInitCheck.h

public:
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
 
 private:
   void
   handleMoveConstructor(const ast_matchers::MatchFinder::MatchResult &Result);
   void
   handleParamNotMoved(const ast_matchers::MatchFinder::MatchResult &Result);
 
-  std::unique_ptr<IncludeInserter> Inserter;
-  const IncludeSorter::IncludeStyle IncludeStyle;
+  std::unique_ptr<utils::IncludeInserter> Inserter;
+  const utils::IncludeSorter::IncludeStyle IncludeStyle;
   const bool UseCERTSemantics;
 };
 
 } // namespace misc
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_MOVECONSTRUCTORINITCHECK_H

clang-tidy/misc/MoveConstructorInitCheck.cpp

parmVarDeclRefExprOccurences(const ParmVarDecl &MovableParam,
   return Occurrences;
 }
 
 } // namespace
 
 MoveConstructorInitCheck::MoveConstructorInitCheck(StringRef Name,
                                                    ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
-      IncludeStyle(IncludeSorter::parseIncludeStyle(
+      IncludeStyle(utils::IncludeSorter::parseIncludeStyle(
           Options.get("IncludeStyle", "llvm"))),
       UseCERTSemantics(Context->isCheckEnabled("cert-oop11-cpp")) {}
 
 void MoveConstructorInitCheck::registerMatchers(MatchFinder *Finder) {
   // Only register the matchers for C++11; the functionality currently does not
   // provide any benefit to other languages, despite being benign.
   if (!getLangOpts().CPlusPlus11)
     return;
if (Candidate) {
     diag(CopyCtor->getLocation(), "copy constructor being called",
          DiagnosticIDs::Note);
     diag(Candidate->getLocation(), "candidate move constructor here",
          DiagnosticIDs::Note);
   }
 }
 
 void MoveConstructorInitCheck::registerPPCallbacks(CompilerInstance &Compiler) {
-  Inserter.reset(new IncludeInserter(Compiler.getSourceManager(),
-                                     Compiler.getLangOpts(), IncludeStyle));
+  Inserter.reset(new utils::IncludeInserter(
+      Compiler.getSourceManager(), Compiler.getLangOpts(), IncludeStyle));
   Compiler.getPreprocessor().addPPCallbacks(Inserter->CreatePPCallbacks());
 }
 
 void MoveConstructorInitCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
-  Options.store(Opts, "IncludeStyle", IncludeSorter::toString(IncludeStyle));
+  Options.store(Opts, "IncludeStyle",
+                utils::IncludeSorter::toString(IncludeStyle));
 }
 
 } // namespace misc
 } // namespace tidy
 } // namespace clang

clang-tidy/misc/SuspiciousSemicolonCheck.cpp

void SuspiciousSemicolonCheck::check(const MatchFinder::MatchResult &Result) {
 
   const auto *Semicolon = Result.Nodes.getNodeAs<NullStmt>("semi");
   SourceLocation LocStart = Semicolon->getLocStart();
 
   if (LocStart.isMacroID())
     return;
 
   ASTContext &Ctxt = *Result.Context;
-  auto Token = lexer_utils::getPreviousNonCommentToken(Ctxt, LocStart);
+  auto Token = utils::lexer::getPreviousNonCommentToken(Ctxt, LocStart);
   auto &SM = *Result.SourceManager;
   unsigned SemicolonLine = SM.getSpellingLineNumber(LocStart);
 
   const auto *Statement = Result.Nodes.getNodeAs<Stmt>("stmt");
   const bool IsIfStmt = isa<IfStmt>(Statement);
 
   if (!IsIfStmt &&
       SM.getSpellingLineNumber(Token.getLocation()) != SemicolonLine)

clang-tidy/modernize/PassByValueCheck.h

 public:
   PassByValueCheck(StringRef Name, ClangTidyContext *Context);
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   void registerPPCallbacks(clang::CompilerInstance &Compiler) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
-  std::unique_ptr<IncludeInserter> Inserter;
-  const IncludeSorter::IncludeStyle IncludeStyle;
+  std::unique_ptr<utils::IncludeInserter> Inserter;
+  const utils::IncludeSorter::IncludeStyle IncludeStyle;
 };
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_PASS_BY_VALUE_H

clang-tidy/modernize/PassByValueCheck.cpp

collectParamDecls(const CXXConstructorDecl *Ctor,
 
   for (const FunctionDecl *Redecl : Ctor->redecls())
     Results.push_back(Redecl->getParamDecl(ParamIdx));
   return Results;
 }
 
 PassByValueCheck::PassByValueCheck(StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
-      IncludeStyle(IncludeSorter::parseIncludeStyle(
+      IncludeStyle(utils::IncludeSorter::parseIncludeStyle(
           Options.get("IncludeStyle", "llvm"))) {}
 
 void PassByValueCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
-  Options.store(Opts, "IncludeStyle", IncludeSorter::toString(IncludeStyle));
+  Options.store(Opts, "IncludeStyle",
+                utils::IncludeSorter::toString(IncludeStyle));
 }
 
 void PassByValueCheck::registerMatchers(MatchFinder *Finder) {
   // Only register the matchers for C++; the functionality currently does not
   // provide any benefit to other languages, despite being benign.
   if (!getLangOpts().CPlusPlus)
     return;
 
Finder->addMatcher(
       this);
 }
 
 void PassByValueCheck::registerPPCallbacks(CompilerInstance &Compiler) {
   // Only register the preprocessor callbacks for C++; the functionality
   // currently does not provide any benefit to other languages, despite being
   // benign.
   if (getLangOpts().CPlusPlus) {
-    Inserter.reset(new IncludeInserter(Compiler.getSourceManager(),
-                                       Compiler.getLangOpts(), IncludeStyle));
+    Inserter.reset(new utils::IncludeInserter(
+        Compiler.getSourceManager(), Compiler.getLangOpts(), IncludeStyle));
     Compiler.getPreprocessor().addPPCallbacks(Inserter->CreatePPCallbacks());
   }
 }
 
 void PassByValueCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *Ctor = Result.Nodes.getNodeAs<CXXConstructorDecl>("Ctor");
   const auto *ParamDecl = Result.Nodes.getNodeAs<ParmVarDecl>("Param");
   const auto *Initializer =

clang-tidy/modernize/ReplaceAutoPtrCheck.h

 public:
   ReplaceAutoPtrCheck(StringRef Name, ClangTidyContext *Context);
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void registerPPCallbacks(CompilerInstance &Compiler) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
-  std::unique_ptr<IncludeInserter> Inserter;
-  const IncludeSorter::IncludeStyle IncludeStyle;
+  std::unique_ptr<utils::IncludeInserter> Inserter;
+  const utils::IncludeSorter::IncludeStyle IncludeStyle;
 };
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_REPLACE_AUTO_PTR_H

clang-tidy/modernize/ReplaceAutoPtrCheck.cpp

static bool checkTokenIsAutoPtr(SourceLocation TokenStart,
   StringRef Res = Lexer::getSpelling(TokenStart, Buffer, SM, LO, &Invalid);
 
   return (!Invalid && Res == "auto_ptr");
 }
 
 ReplaceAutoPtrCheck::ReplaceAutoPtrCheck(StringRef Name,
                                          ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
-      IncludeStyle(IncludeSorter::parseIncludeStyle(
+      IncludeStyle(utils::IncludeSorter::parseIncludeStyle(
           Options.get("IncludeStyle", "llvm"))) {}
 
 void ReplaceAutoPtrCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
-  Options.store(Opts, "IncludeStyle", IncludeSorter::toString(IncludeStyle));
+  Options.store(Opts, "IncludeStyle",
+                utils::IncludeSorter::toString(IncludeStyle));
 }
 
 void ReplaceAutoPtrCheck::registerMatchers(MatchFinder *Finder) {
   // Only register the matchers for C++; the functionality currently does not
   // provide any benefit to other languages, despite being benign.
   if (getLangOpts().CPlusPlus) {
     Finder->addMatcher(makeAutoPtrTypeLocMatcher(), this);
     Finder->addMatcher(makeAutoPtrUsingDeclMatcher(), this);
     Finder->addMatcher(makeTransferOwnershipExprMatcher(), this);
   }
 }
 
 void ReplaceAutoPtrCheck::registerPPCallbacks(CompilerInstance &Compiler) {
   // Only register the preprocessor callbacks for C++; the functionality
   // currently does not provide any benefit to other languages, despite being
   // benign.
   if (getLangOpts().CPlusPlus) {
-    Inserter.reset(new IncludeInserter(Compiler.getSourceManager(),
-                                       Compiler.getLangOpts(), IncludeStyle));
+    Inserter.reset(new utils::IncludeInserter(
+        Compiler.getSourceManager(), Compiler.getLangOpts(), IncludeStyle));
     Compiler.getPreprocessor().addPPCallbacks(Inserter->CreatePPCallbacks());
   }
 }
 
 void ReplaceAutoPtrCheck::check(const MatchFinder::MatchResult &Result) {
   SourceManager &SM = *Result.SourceManager;
   if (const auto *E =
           Result.Nodes.getNodeAs<Expr>(AutoPtrOwnershipTransferId)) {

clang-tidy/performance/ForRangeCopyCheck.cpp

bool ForRangeCopyCheck::handleConstValueCopy(const VarDecl &LoopVar,
   if (WarnOnAllAutoCopies) {
     // For aggressive check just test that loop variable has auto type.
     if (!isa<AutoType>(LoopVar.getType()))
       return false;
   } else if (!LoopVar.getType().isConstQualified()) {
     return false;
   }
   llvm::Optional<bool> Expensive =
-      type_traits::isExpensiveToCopy(LoopVar.getType(), Context);
+      utils::type_traits::isExpensiveToCopy(LoopVar.getType(), Context);
   if (!Expensive || !*Expensive)
     return false;
   auto Diagnostic =
       diag(LoopVar.getLocation(),
            "the loop variable's type is not a reference type; this creates a "
            "copy in each iteration; consider making this a reference")
-      << utils::create_fix_it::changeVarDeclToReference(LoopVar, Context);
+      << utils::fixit::changeVarDeclToReference(LoopVar, Context);
   if (!LoopVar.getType().isConstQualified())
-    Diagnostic << utils::create_fix_it::changeVarDeclToConst(LoopVar);
+    Diagnostic << utils::fixit::changeVarDeclToConst(LoopVar);
   return true;
 }
 
 bool ForRangeCopyCheck::handleCopyIsOnlyConstReferenced(
     const VarDecl &LoopVar, const CXXForRangeStmt &ForRange,
     ASTContext &Context) {
   llvm::Optional<bool> Expensive =
-      type_traits::isExpensiveToCopy(LoopVar.getType(), Context);
+      utils::type_traits::isExpensiveToCopy(LoopVar.getType(), Context);
   if (LoopVar.getType().isConstQualified() || !Expensive || !*Expensive)
     return false;
-  if (!decl_ref_expr_utils::isOnlyUsedAsConst(LoopVar, *ForRange.getBody(), Context))
+  if (!utils::decl_ref_expr::isOnlyUsedAsConst(LoopVar, *ForRange.getBody(),
+                                               Context))
     return false;
   diag(LoopVar.getLocation(),
        "loop variable is copied but only used as const reference; consider "
        "making it a const reference")
-      << utils::create_fix_it::changeVarDeclToConst(LoopVar)
-      << utils::create_fix_it::changeVarDeclToReference(LoopVar, Context);
+      << utils::fixit::changeVarDeclToConst(LoopVar)
+      << utils::fixit::changeVarDeclToReference(LoopVar, Context);
   return true;
 }
 
 } // namespace performance
 } // namespace tidy
 } // namespace clang

clang-tidy/performance/UnnecessaryCopyInitialization.cpp

 namespace {
 
 void recordFixes(const VarDecl &Var, ASTContext &Context,
                  DiagnosticBuilder &Diagnostic) {
   // Do not propose fixes in macros since we cannot place them correctly.
   if (Var.getLocation().isMacroID())
     return;
 
-  Diagnostic << utils::create_fix_it::changeVarDeclToReference(Var, Context);
+  Diagnostic << utils::fixit::changeVarDeclToReference(Var, Context);
   if (!Var.getType().isLocalConstQualified())
-    Diagnostic << utils::create_fix_it::changeVarDeclToConst(Var);
+    Diagnostic << utils::fixit::changeVarDeclToConst(Var);
 }
 
 } // namespace
 
 
 using namespace ::clang::ast_matchers;
-using decl_ref_expr_utils::isOnlyUsedAsConst;
+using utils::decl_ref_expr::isOnlyUsedAsConst;
 
 void UnnecessaryCopyInitialization::registerMatchers(MatchFinder *Finder) {
   auto ConstReference = referenceType(pointee(qualType(isConstQualified())));
   auto ConstOrConstReference =
       allOf(anyOf(ConstReference, isConstQualified()),
             unless(allOf(pointerType(), unless(pointerType(pointee(
                                             qualType(isConstQualified())))))));
 

clang-tidy/performance/UnnecessaryValueParamCheck.cpp

if (!Function->getBody())
     return;
 
   // Do not trigger on non-const value parameters when:
   // 1. they are in a constructor definition since they can likely trigger
   //    misc-move-constructor-init which will suggest to move the argument.
   // 2. they are not only used as const.
   if (!IsConstQualified && (llvm::isa<CXXConstructorDecl>(Function) ||
                             !Function->doesThisDeclarationHaveABody() ||
-                            !decl_ref_expr_utils::isOnlyUsedAsConst(
+                            !utils::decl_ref_expr::isOnlyUsedAsConst(
                                 *Param, *Function->getBody(), *Result.Context)))
     return;
   auto Diag =
       diag(Param->getLocation(),
            IsConstQualified ? "the const qualified parameter %0 is "
                               "copied for each invocation; consider "
                               "making it a reference"
                             : "the parameter %0 is copied for each "
                               "invocation but only used as a const reference; "
                               "consider making it a const reference")
       << paramNameOrIndex(Param->getName(), Index);
   // Do not propose fixes in macros since we cannot place them correctly.
   if (Param->getLocStart().isMacroID())
     return;
   for (const auto *FunctionDecl = Function; FunctionDecl != nullptr;
        FunctionDecl = FunctionDecl->getPreviousDecl()) {
     const auto &CurrentParam = *FunctionDecl->getParamDecl(Index);
-    Diag << utils::create_fix_it::changeVarDeclToReference(CurrentParam,
+    Diag << utils::fixit::changeVarDeclToReference(CurrentParam,
                                                            *Result.Context);
     if (!IsConstQualified)
-      Diag << utils::create_fix_it::changeVarDeclToConst(CurrentParam);
+      Diag << utils::fixit::changeVarDeclToConst(CurrentParam);
   }
 }
 
 } // namespace performance
 } // namespace tidy
 } // namespace clang

clang-tidy/utils/DeclRefExprUtils.h

 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_UTILS_DECLREFEXPRUTILS_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_UTILS_DECLREFEXPRUTILS_H
 
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/Type.h"
 
 namespace clang {
 namespace tidy {
-namespace decl_ref_expr_utils {
+namespace utils {
+namespace decl_ref_expr {
 
 /// \brief Returns true if all DeclRefExpr to the variable within Stmt do not
 /// modify it.
 ///
 /// Returns true if only const methods or operators are called on the variable
 /// or the variable is a const reference or value argument to a callExpr().
 bool isOnlyUsedAsConst(const VarDecl &Var, const Stmt &Stmt,
                        ASTContext &Context);
 
-} // namespace decl_ref_expr_utils
+} // namespace decl_ref_expr
+} // namespace utils
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_UTILS_DECLREFEXPRUTILS_H

clang-tidy/utils/DeclRefExprUtils.cpp

 #include "DeclRefExprUtils.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "llvm/ADT/SmallPtrSet.h"
 
 namespace clang {
 namespace tidy {
-namespace decl_ref_expr_utils {
+namespace utils {  
+namespace decl_ref_expr {
 
 using namespace ::clang::ast_matchers;
 using llvm::SmallPtrSet;
 
 namespace {
 
 template <typename S> bool isSetDifferenceEmpty(const S &S1, const S &S2) {
   for (const auto &E : S1)
bool isOnlyUsedAsConst(const VarDecl &Var, const Stmt &Stmt,
   // reference parameter.
   // If the difference is empty it is safe for the loop variable to be a const
   // reference.
   auto AllDeclRefs = declRefExprs(Var, Stmt, Context);
   auto ConstReferenceDeclRefs = constReferenceDeclRefExprs(Var, Stmt, Context);
   return isSetDifferenceEmpty(AllDeclRefs, ConstReferenceDeclRefs);
 }
 
-} // namespace decl_ref_expr_utils
+} // namespace decl_ref_expr
+} // namespace utils
 } // namespace tidy
 } // namespace clang

clang-tidy/utils/FixItHintUtils.h

 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_UTILS_FIXITHINTUTILS_H
 
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/Decl.h"
 
 namespace clang {
 namespace tidy {
 namespace utils {
-namespace create_fix_it {
+namespace fixit {
 
 /// \brief Creates fix to make VarDecl a reference by adding '&'.
 FixItHint changeVarDeclToReference(const VarDecl &Var, ASTContext &Context);
 
 /// \brief Creates fix to make VarDecl const qualified.
 FixItHint changeVarDeclToConst(const VarDecl &Var);
 
-} // namespace create_fix_it
-} // utils
+} // namespace fixit
+} // namespace utils
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_UTILS_FIXITHINTUTILS_H

clang-tidy/utils/FixItHintUtils.cpp

 //===--- FixItHintUtils.cpp - clang-tidy-----------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "FixItHintUtils.h"
 #include "LexerUtils.h"
 #include "clang/AST/ASTContext.h"
 
 namespace clang {
 namespace tidy {
 namespace utils {
-namespace create_fix_it {
+namespace fixit {
 
 FixItHint changeVarDeclToReference(const VarDecl &Var, ASTContext &Context) {
   SourceLocation AmpLocation = Var.getLocation();
-  auto Token = lexer_utils::getPreviousNonCommentToken(Context, AmpLocation);
+  auto Token = utils::lexer::getPreviousNonCommentToken(Context, AmpLocation);
   if (!Token.is(tok::unknown))
     AmpLocation = Lexer::getLocForEndOfToken(Token.getLocation(), 0,
                                              Context.getSourceManager(),
                                              Context.getLangOpts());
   return FixItHint::CreateInsertion(AmpLocation, "&");
 }
 
 FixItHint changeVarDeclToConst(const VarDecl &Var) {
   return FixItHint::CreateInsertion(Var.getTypeSpecStartLoc(), "const ");
 }
 
-} // namespace create_fix_it
+} // namespace fixit
 } // namespace utils
 } // namespace tidy
 } // namespace clang

clang-tidy/utils/HeaderGuard.h

 //===--- HeaderGuard.h - clang-tidy -----------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_UTILS_HEADERGUARD_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_UTILS_HEADERGUARD_H
 
 #include "../ClangTidy.h"
 
 namespace clang {
 namespace tidy {
+namespace utils {
 
 /// Finds and fixes header guards.
 class HeaderGuardCheck : public ClangTidyCheck {
 public:
   HeaderGuardCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
   void registerPPCallbacks(CompilerInstance &Compiler) override;
 
public:
   /// \brief Returns a replacement for endif line with a comment mentioning
   /// \p HeaderGuard. The replacement should start with "endif".
   virtual std::string formatEndIf(StringRef HeaderGuard);
   /// \brief Get the canonical header guard for a file.
   virtual std::string getHeaderGuard(StringRef Filename,
                                      StringRef OldGuard = StringRef()) = 0;
 };
 
+} // namespace utils
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_UTILS_HEADERGUARD_H

clang-tidy/utils/HeaderGuard.cpp

 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Lex/PPCallbacks.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Tooling/Tooling.h"
 #include "llvm/Support/Path.h"
 
 namespace clang {
 namespace tidy {
+namespace utils {
 
 /// \brief canonicalize a path by removing ./ and ../ components.
 // FIXME: Consider moving this to llvm::sys::path.
 static std::string cleanPath(StringRef Path) {
   SmallString<256> NewPath;
   for (auto I = llvm::sys::path::begin(Path), E = llvm::sys::path::end(Path);
        I != E; ++I) {
     if (*I == ".")

 bool HeaderGuardCheck::shouldSuggestToAddHeaderGuard(StringRef FileName) {
   return FileName.endswith(".h");
 }
 
 std::string HeaderGuardCheck::formatEndIf(StringRef HeaderGuard) {
   return "endif // " + HeaderGuard.str();
 }
 
+} // namespace utils
 } // namespace tidy
 } // namespace clang

clang-tidy/utils/IncludeInserter.h

 #include "clang/Basic/LangOptions.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Lex/PPCallbacks.h"
 #include <memory>
 #include <string>
 
 namespace clang {
 namespace tidy {
+namespace utils {
 
 // IncludeInserter can be used by ClangTidyChecks in the following fashion:
 // class MyCheck : public ClangTidyCheck {
 //  public:
 //   void registerPPCallbacks(CompilerInstance& Compiler) override {
 //     Inserter.reset(new IncludeInserter(&Compiler.getSourceManager(),
 //                                        &Compiler.getLangOpts()));
 //     Compiler.getPreprocessor().addPPCallbacks(
private:
   llvm::DenseMap<FileID, std::unique_ptr<IncludeSorter>> IncludeSorterByFile;
   llvm::DenseMap<FileID, std::set<std::string>> InsertedHeaders;
   const SourceManager &SourceMgr;
   const LangOptions &LangOpts;
   const IncludeSorter::IncludeStyle Style;
   friend class IncludeInserterCallback;
 };
 
+} // namespace utils
 } // namespace tidy
 } // namespace clang
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_INCLUDEINSERTER_H

clang-tidy/utils/IncludeInserter.cpp

 //===-------- IncludeInserter.cpp - clang-tidy ----------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "IncludeInserter.h"
 #include "clang/Lex/Token.h"
 
 namespace clang {
 namespace tidy {
+namespace utils {
 
 class IncludeInserterCallback : public PPCallbacks {
 public:
   explicit IncludeInserterCallback(IncludeInserter *Inserter)
       : Inserter(Inserter) {}
   // Implements PPCallbacks::InclusionDerective(). Records the names and source
   // locations of the inclusions in the main source file being processed.
   void InclusionDirective(SourceLocation HashLocation,
IncludeSorterByFile.insert(std::make_pair(
         FileID, llvm::make_unique<IncludeSorter>(
                     &SourceMgr, &LangOpts, FileID,
                     SourceMgr.getFilename(HashLocation), Style)));
   }
   IncludeSorterByFile[FileID]->AddInclude(file_name, IsAngled, HashLocation,
                                           end_location);
 }
 
+} // namespace utils
 } // namespace tidy
 } // namespace clang

clang-tidy/utils/IncludeSorter.h

 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_INCLUDESORTER_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_INCLUDESORTER_H
 
 #include "../ClangTidy.h"
 #include <string>
 
 namespace clang {
 namespace tidy {
+namespace utils {  
 
 // Class used by IncludeSorterCallback and IncludeInserterCallback to record the
 // names of the inclusions in a given source file being processed and generate
 // the necessary commands to sort the inclusions according to the precedence
 // enocded in IncludeKinds.
 class IncludeSorter {
 public:
   // Supported include styles.
private:
   // Locations of visited include directives.
   SourceRangeVector SourceLocations;
   // Mapping from file name to #include locations.
   llvm::StringMap<SourceRangeVector> IncludeLocations;
   // Includes sorted into buckets.
   SmallVector<std::string, 1> IncludeBucket[IK_InvalidInclude];
 };
 
+} // namespace utils
 } // namespace tidy
 } // namespace clang
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_INCLUDESORTER_H

clang-tidy/utils/IncludeSorter.cpp

 //===---------- IncludeSorter.cpp - clang-tidy ----------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "IncludeSorter.h"
 #include "clang/Lex/Lexer.h"
 
 namespace clang {
 namespace tidy {
+namespace utils {  
 
 namespace {
 
 StringRef RemoveFirstSuffix(StringRef Str, ArrayRef<const char *> Suffixes) {
   for (StringRef Suffix : Suffixes) {
     if (Str.endswith(Suffix)) {
       return Str.substr(0, Str.size() - Suffix.size());
     }

 IncludeSorter::parseIncludeStyle(const std::string &Value) {
   return Value == "llvm" ? IS_LLVM : IS_Google;
 }
 
 StringRef IncludeSorter::toString(IncludeStyle Style) {
   return Style == IS_LLVM ? "llvm" : "google";
 }
 
+} // namespace utils
 } // namespace tidy
 } // namespace clang

clang-tidy/utils/LexerUtils.h

 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_UTILS_LEXER_UTILS_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_UTILS_LEXER_UTILS_H
 
 #include "clang/AST/ASTContext.h"
 #include "clang/Lex/Lexer.h"
 
 namespace clang {
 namespace tidy {
-namespace lexer_utils {
+namespace utils {
+namespace lexer {
 
 // Returns previous non-comment token skipping over any comment text or
 // tok::unknown if not found.
 Token getPreviousNonCommentToken(const ASTContext &Context,
                                  SourceLocation Location);
 
-} // namespace lexer_utils
+} // namespace lexer
+} // namespace utils
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_UTILS_LEXER_UTILS_H

clang-tidy/utils/LexerUtils.cpp

 //===--- LexerUtils.cpp - clang-tidy---------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "LexerUtils.h"
 
 namespace clang {
 namespace tidy {
-namespace lexer_utils {
+namespace utils {
+namespace lexer {
 
 Token getPreviousNonCommentToken(const ASTContext &Context,
                                  SourceLocation Location) {
   const auto &SourceManager = Context.getSourceManager();
   Token Token;
   Token.setKind(tok::unknown);
   Location = Location.getLocWithOffset(-1);
   auto StartOfFile =
       SourceManager.getLocForStartOfFile(SourceManager.getFileID(Location));
   while (Location != StartOfFile) {
     Location = Lexer::GetBeginningOfToken(Location, SourceManager,
                                           Context.getLangOpts());
     if (!Lexer::getRawToken(Location, Token, SourceManager,
                             Context.getLangOpts()) &&
         !Token.is(tok::comment)) {
       break;
     }
     Location = Location.getLocWithOffset(-1);
   }
   return Token;
 }
 
-} // namespace lexer_utils
+} // namespace lexer
+} // namespace utils
 } // namespace tidy
 } // namespace clang

clang-tidy/utils/Matchers.h

 }
 
 AST_MATCHER(BinaryOperator, isComparisonOperator) {
   return Node.isComparisonOp();
 }
 
 AST_MATCHER(QualType, isExpensiveToCopy) {
   llvm::Optional<bool> IsExpensive =
-      type_traits::isExpensiveToCopy(Node, Finder->getASTContext());
+      utils::type_traits::isExpensiveToCopy(Node, Finder->getASTContext());
   return IsExpensive && *IsExpensive;
 }
 
 AST_MATCHER(RecordDecl, isTriviallyDefaultConstructible) {
-  return type_traits::recordIsTriviallyDefaultConstructible(
+  return utils::type_traits::recordIsTriviallyDefaultConstructible(
       Node, Finder->getASTContext());
 }
 
 } // namespace matchers
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_UTILS_MATCHERS_H

clang-tidy/utils/TypeTraits.h

 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_UTILS_TYPETRAITS_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_UTILS_TYPETRAITS_H
 
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/Type.h"
 
 namespace clang {
 namespace tidy {
+namespace utils {
 namespace type_traits {
 
 // \brief Returns true If \c Type is expensive to copy.
 llvm::Optional<bool> isExpensiveToCopy(QualType Type, ASTContext &Context);
 
 // \brief Returns true If \c Type is trivially default constructible.
 bool isTriviallyDefaultConstructible(QualType Type, const ASTContext &Context);
 
 // \brief Returns true If \c RecordDecl is trivially default constructible.
 bool recordIsTriviallyDefaultConstructible(const RecordDecl &RecordDecl,
                                            const ASTContext &Context);
 
 } // type_traits
+} // namespace utils
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_UTILS_TYPETRAITS_H

clang-tidy/utils/TypeTraits.cpp

 //===--- TypeTraits.cpp - clang-tidy---------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "TypeTraits.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/DeclCXX.h"
 
 namespace clang {
 namespace tidy {
+namespace utils {
 namespace type_traits {
 
 namespace {
 bool classHasTrivialCopyAndDestroy(QualType Type) {
   auto *Record = Type->getAsCXXRecordDecl();
   return Record && Record->hasDefinition() &&
          !Record->hasNonTrivialCopyConstructor() &&
          !Record->hasNonTrivialDestructor();
bool isTriviallyDefaultConstructible(QualType Type, const ASTContext &Context) {
   if (const auto *RT = CanonicalType->getAs<RecordType>()) {
     return recordIsTriviallyDefaultConstructible(*RT->getDecl(), Context);
   }
 
   // No other types can match.
   return false;
 }
 
-} // type_traits
+} // namespace type_traits
+} // namespace utils
 } // namespace tidy
 } // namespace clang

unittests/clang-tidy/IncludeInserterTest.cpp

 namespace {
 
 class IncludeInserterCheckBase : public ClangTidyCheck {
 public:
   IncludeInserterCheckBase(StringRef CheckName, ClangTidyContext *Context)
       : ClangTidyCheck(CheckName, Context) {}
 
   void registerPPCallbacks(CompilerInstance &Compiler) override {
-    Inserter.reset(new IncludeInserter(Compiler.getSourceManager(),
-                                       Compiler.getLangOpts(),
-                                       IncludeSorter::IS_Google));
+    Inserter.reset(new utils::IncludeInserter(
+        Compiler.getSourceManager(),
+        utils::IncludeSorter::IS_Google));
     Compiler.getPreprocessor().addPPCallbacks(Inserter->CreatePPCallbacks());
   }
 
   void registerMatchers(ast_matchers::MatchFinder *Finder) override {
     Finder->addMatcher(ast_matchers::declStmt().bind("stmt"), this);
   }
 
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override {
     auto Diag = diag(Result.Nodes.getStmtAs<DeclStmt>("stmt")->getLocStart(),
                      "foo, bar");
     for (StringRef header : HeadersToInclude()) {
       auto Fixit = Inserter->CreateIncludeInsertion(
           Result.SourceManager->getMainFileID(), header, IsAngledInclude());
       if (Fixit) {
         Diag << *Fixit;
       }
     }
   }
 
   virtual std::vector<StringRef> HeadersToInclude() const = 0;
   virtual bool IsAngledInclude() const = 0;
 
-  std::unique_ptr<IncludeInserter> Inserter;
+  std::unique_ptr<utils::IncludeInserter> Inserter;
 };
 
 class NonSystemHeaderInserterCheck : public IncludeInserterCheckBase {
 public:
   NonSystemHeaderInserterCheck(StringRef CheckName, ClangTidyContext *Context)
       : IncludeInserterCheckBase(CheckName, Context) {}
 
   std::vector<StringRef> HeadersToInclude() const override {