[clang-tidy] Cleaning namespaces to be more consistant across checkers.

[etienneb]

Summary

The goal of the patch is to bring checkers in their appropriate namespace.
This patch doesn't change any behavior.

[alexfh]

LG. Thanks!

clang-tidy/cert/CERTTidyModule.cpp

void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     // DCL
     CheckFactories.registerCheck<VariadicFunctionDefCheck>(
         "cert-dcl50-cpp");
     CheckFactories.registerCheck<misc::NewDeleteOverloadsCheck>(
         "cert-dcl54-cpp");
     CheckFactories.registerCheck<google::build::UnnamedNamespaceInHeaderCheck>(
         "cert-dcl59-cpp");
     // OOP
-    CheckFactories.registerCheck<MoveConstructorInitCheck>(
+    CheckFactories.registerCheck<misc::MoveConstructorInitCheck>(
         "cert-oop11-cpp");
     // ERR
     CheckFactories.registerCheck<SetLongJmpCheck>(
         "cert-err52-cpp");
     CheckFactories.registerCheck<StaticObjectExceptionCheck>(
         "cert-err58-cpp");
     CheckFactories.registerCheck<ThrownExceptionTypeCheck>(
         "cert-err60-cpp");
-    CheckFactories.registerCheck<ThrowByValueCatchByReferenceCheck>(
+    CheckFactories.registerCheck<misc::ThrowByValueCatchByReferenceCheck>(
         "cert-err61-cpp");
 
     // C checkers
     // DCL
-    CheckFactories.registerCheck<StaticAssertCheck>(
+    CheckFactories.registerCheck<misc::StaticAssertCheck>(
         "cert-dcl03-c");
     // ENV
     CheckFactories.registerCheck<CommandProcessorCheck>(
         "cert-env33-c");
     // FLP
     CheckFactories.registerCheck<FloatLoopCounter>(
         "cert-flp30-c");
     // FIO
-    CheckFactories.registerCheck<NonCopyableObjectsCheck>(
+    CheckFactories.registerCheck<misc::NonCopyableObjectsCheck>(
         "cert-fio38-c");
     // ERR
     CheckFactories.registerCheck<StrToNumCheck>(
         "cert-err34-c");
   }
 };
 
 } // namespace cert

clang-tidy/cppcoreguidelines/ProBoundsArrayToPointerDecayCheck.h

 //===--- ProBoundsArrayToPointerDecayCheck.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_CPPCOREGUIDELINES_PRO_BOUNDS_ARRAY_TO_POINTER_DECAY_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_BOUNDS_ARRAY_TO_POINTER_DECAY_H
 
 #include "../ClangTidy.h"
 
 namespace clang {
 namespace tidy {
+namespace cppcoreguidelines {
   
 /// This check flags all array to pointer decays
 ///
 /// For the user-facing documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-pro-bounds-array-to-pointer-decay.html
 class ProBoundsArrayToPointerDecayCheck : public ClangTidyCheck {
 public:
   ProBoundsArrayToPointerDecayCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) 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_ARRAY_TO_POINTER_DECAY_H

clang-tidy/cppcoreguidelines/ProBoundsArrayToPointerDecayCheck.cpp

 #include "ProBoundsArrayToPointerDecayCheck.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
+namespace cppcoreguidelines {
 
 AST_MATCHER_P(CXXForRangeStmt, hasRangeBeginEndStmt,
               ast_matchers::internal::Matcher<DeclStmt>, InnerMatcher) {
   for (const DeclStmt *Stmt : {Node.getBeginStmt(), Node.getEndStmt()})
     if (Stmt != nullptr && InnerMatcher.matches(*Stmt, Finder, Builder))
       return true;
   return false;
 }
void ProBoundsArrayToPointerDecayCheck::check(
   if (MatchedCast->getCastKind() != CK_ArrayToPointerDecay)
     return;
 
   diag(MatchedCast->getExprLoc(), "do not implicitly decay an array into a "
                                   "pointer; consider using gsl::array_view or "
                                   "an explicit cast instead");
 }
 
+} // namespace cppcoreguidelines
 } // namespace tidy
 } // namespace clang

clang-tidy/cppcoreguidelines/ProBoundsConstantArrayIndexCheck.h

 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_BOUNDS_CONSTANT_ARRAY_INDEX_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_BOUNDS_CONSTANT_ARRAY_INDEX_H
 
 #include "../ClangTidy.h"
 #include "../utils/IncludeInserter.h"
 
 namespace clang {
 namespace tidy {
+namespace cppcoreguidelines {
 
 /// 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;
 
 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

 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Lex/Preprocessor.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
+namespace cppcoreguidelines {
 
 ProBoundsConstantArrayIndexCheck::ProBoundsConstantArrayIndexCheck(
     StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context), GslHeader(Options.get("GslHeader", "")),
       IncludeStyle(IncludeSorter::parseIncludeStyle(
           Options.get("IncludeStyle", "llvm"))) {}
 
 void ProBoundsConstantArrayIndexCheck::storeOptions(
void ProBoundsConstantArrayIndexCheck::check(
   // in APInt::uge.
   if (Index.getZExtValue() >= ArraySize.getZExtValue()) {
     diag(Matched->getExprLoc(), "std::array<> index %0 is past the end of the array "
                                 "(which contains %1 elements)")
         << Index.toString(10) << ArraySize.toString(10, false);
   }
 }
 
+} // namespace cppcoreguidelines
 } // namespace tidy
 } // namespace clang

clang-tidy/cppcoreguidelines/ProBoundsPointerArithmeticCheck.h

 //===--- ProBoundsPointerArithmeticCheck.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_CPPCOREGUIDELINES_PRO_BOUNDS_POINTER_ARITHMETIC_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_BOUNDS_POINTER_ARITHMETIC_H
 
 #include "../ClangTidy.h"
 
 namespace clang {
 namespace tidy {
+namespace cppcoreguidelines {
 
 /// Flags all kinds of pointer arithmetic that have result of pointer type, i.e.
 /// +, -, +=, -=, ++, --. In addition, the [] operator on pointers (not on arrays) is flagged.
 ///
 /// For the user-facing documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-pro-bounds-pointer-arithmetic.html
 class ProBoundsPointerArithmeticCheck : public ClangTidyCheck {
 public:
   ProBoundsPointerArithmeticCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) 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_POINTER_ARITHMETIC_H

clang-tidy/cppcoreguidelines/ProBoundsPointerArithmeticCheck.cpp

 #include "ProBoundsPointerArithmeticCheck.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
+namespace cppcoreguidelines {
 
 void ProBoundsPointerArithmeticCheck::registerMatchers(MatchFinder *Finder) {
   if (!getLangOpts().CPlusPlus)
     return;
 
   // Flag all operators +, -, +=, -=, ++, -- that result in a pointer
   Finder->addMatcher(
       binaryOperator(

 
 void
 ProBoundsPointerArithmeticCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *MatchedExpr = Result.Nodes.getNodeAs<Expr>("expr");
 
   diag(MatchedExpr->getExprLoc(), "do not use pointer arithmetic");
 }
 
+} // namespace cppcoreguidelines
 } // namespace tidy
 } // namespace clang

clang-tidy/cppcoreguidelines/ProTypeConstCastCheck.h

 //===--- ProTypeConstCastCheck.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_CPPCOREGUIDELINES_PRO_TYPE_CONST_CAST_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_TYPE_CONST_CAST_H
 
 #include "../ClangTidy.h"
 
 namespace clang {
 namespace tidy {
+namespace cppcoreguidelines {
   
 /// This check flags all instances of const_cast
 ///
 /// For the user-facing documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-pro-type-const-cast.html
 class ProTypeConstCastCheck : public ClangTidyCheck {
 public:
   ProTypeConstCastCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) 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_TYPE_CONST_CAST_H

clang-tidy/cppcoreguidelines/ProTypeConstCastCheck.cpp

 #include "ProTypeConstCastCheck.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
+namespace cppcoreguidelines {
   
 void ProTypeConstCastCheck::registerMatchers(MatchFinder *Finder) {
   if (!getLangOpts().CPlusPlus)
     return;
 
   Finder->addMatcher(cxxConstCastExpr().bind("cast"), this);
 }
 
 void ProTypeConstCastCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *MatchedCast = Result.Nodes.getNodeAs<CXXConstCastExpr>("cast");
   diag(MatchedCast->getOperatorLoc(), "do not use const_cast");
 }
 
+} // namespace cppcoreguidelines
 } // namespace tidy
 } // namespace clang

clang-tidy/cppcoreguidelines/ProTypeCstyleCastCheck.h

 //===--- ProTypeCstyleCastCheck.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_CPPCOREGUIDELINES_PRO_TYPE_CSTYLE_CAST_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_TYPE_CSTYLE_CAST_H
 
 #include "../ClangTidy.h"
 
 namespace clang {
 namespace tidy {
+namespace cppcoreguidelines {
 
 /// This check flags all use of C-style casts that perform a static_cast
 /// downcast, const_cast, or reinterpret_cast.
 ///
 /// For the user-facing documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-pro-type-cstyle-cast.html
 class ProTypeCstyleCastCheck : public ClangTidyCheck {
 public:
   ProTypeCstyleCastCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) 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_TYPE_CSTYLE_CAST_H

clang-tidy/cppcoreguidelines/ProTypeCstyleCastCheck.cpp

 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/Lex/Lexer.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
+namespace cppcoreguidelines {
 
 static bool needsConstCast(QualType SourceType, QualType DestType) {
   SourceType = SourceType.getNonReferenceType();
   DestType = DestType.getNonReferenceType();
   while (SourceType->isPointerType() && DestType->isPointerType()) {
     SourceType = SourceType->getPointeeType();
     DestType = DestType->getPointeeType();
     if (SourceType.isConstQualified() && !DestType.isConstQualified())
void ProTypeCstyleCastCheck::check(const MatchFinder::MatchResult &Result) {
 
   if (MatchedCast->getCastKind() == CK_NoOp &&
       needsConstCast(SourceType, MatchedCast->getType())) {
     diag(MatchedCast->getLocStart(),
          "do not use C-style cast to cast away constness");
   }
 }
 
+} // namespace cppcoreguidelines
 } // namespace tidy
 } // namespace clang

clang-tidy/cppcoreguidelines/ProTypeReinterpretCastCheck.h

 //===--- ProTypeReinterpretCast.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_CPPCOREGUIDELINES_PRO_TYPE_REINTERPRETCAST_CHECK_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_TYPE_REINTERPRETCAST_CHECK_H
 
 #include "../ClangTidy.h"
 
 namespace clang {
 namespace tidy {
+namespace cppcoreguidelines {
 
 /// Flags all occurrences of reinterpret_cast
 ///
 /// For the user-facing documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-pro-type-reinterpret-cast.html
 class ProTypeReinterpretCastCheck : public ClangTidyCheck {
 public:
   ProTypeReinterpretCastCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) 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_TYPE_REINTERPRETCAST_CHECK_H

clang-tidy/cppcoreguidelines/ProTypeReinterpretCastCheck.cpp

 #include "ProTypeReinterpretCastCheck.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
+namespace cppcoreguidelines {
 
 void ProTypeReinterpretCastCheck::registerMatchers(MatchFinder *Finder) {
   if (!getLangOpts().CPlusPlus)
     return;
 
   Finder->addMatcher(cxxReinterpretCastExpr().bind("cast"), this);
 }
 
 void ProTypeReinterpretCastCheck::check(
     const MatchFinder::MatchResult &Result) {
   const auto *MatchedCast =
       Result.Nodes.getNodeAs<CXXReinterpretCastExpr>("cast");
   diag(MatchedCast->getOperatorLoc(), "do not use reinterpret_cast");
 }
 
+} // namespace cppcoreguidelines
 } // namespace tidy
 } // namespace clang

clang-tidy/cppcoreguidelines/ProTypeStaticCastDowncastCheck.h

 //===--- ProTypeStaticCastDowncastCheck.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_CPPCOREGUIDELINES_PRO_TYPE_STATIC_CAST_DOWNCAST_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_TYPE_STATIC_CAST_DOWNCAST_H
 
 #include "../ClangTidy.h"
 
 namespace clang {
 namespace tidy {
+namespace cppcoreguidelines {
   
 /// Checks for usages of static_cast, where a base class is downcasted to a derived class.
 ///
 /// For the user-facing documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-pro-type-static-cast-downcast.html
 class ProTypeStaticCastDowncastCheck : public ClangTidyCheck {
 public:
   ProTypeStaticCastDowncastCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) 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_TYPE_STATIC_CAST_DOWNCAST_H

clang-tidy/cppcoreguidelines/ProTypeStaticCastDowncastCheck.cpp

 #include "ProTypeStaticCastDowncastCheck.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
+namespace cppcoreguidelines {
   
 void ProTypeStaticCastDowncastCheck::registerMatchers(MatchFinder *Finder) {
   if (!getLangOpts().CPlusPlus)
     return;
 
   Finder->addMatcher(
       cxxStaticCastExpr(unless(isInTemplateInstantiation())).bind("cast"),
       this);
 }
diag(MatchedCast->getOperatorLoc(),
          "use dynamic_cast instead")
         << FixItHint::CreateReplacement(MatchedCast->getOperatorLoc(),
                                         "dynamic_cast");
   else
     diag(MatchedCast->getOperatorLoc(),
          "do not use static_cast to downcast from a base to a derived class");
 }
 
+} // namespace cppcoreguidelines
 } // namespace tidy
 } // namespace clang

clang-tidy/cppcoreguidelines/ProTypeUnionAccessCheck.h

 //===--- ProTypeUnionAccessCheck.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_CPPCOREGUIDELINES_PRO_TYPE_UNION_ACCESS_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_TYPE_UNION_ACCESS_H
 
 #include "../ClangTidy.h"
 
 namespace clang {
 namespace tidy {
+namespace cppcoreguidelines {
 
 /// This check flags all access to members of unions.
 /// Access to a union as a whole (e.g. passing to a function) is not flagged.
 ///
 /// For the user-facing documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-pro-type-union-access.html
 class ProTypeUnionAccessCheck : public ClangTidyCheck {
 public:
   ProTypeUnionAccessCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) 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_TYPE_UNION_ACCESS_H
 

clang-tidy/cppcoreguidelines/ProTypeUnionAccessCheck.cpp

 #include "ProTypeUnionAccessCheck.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
+namespace cppcoreguidelines {
 
 void ProTypeUnionAccessCheck::registerMatchers(MatchFinder *Finder) {
   if (!getLangOpts().CPlusPlus)
     return;
 
   Finder->addMatcher(memberExpr(hasObjectExpression(hasType(recordDecl(isUnion())))).bind("expr"), this);
 }
 
 void ProTypeUnionAccessCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *Matched = Result.Nodes.getNodeAs<MemberExpr>("expr");
   diag(Matched->getMemberLoc(), "do not access members of unions; use (boost::)variant instead");
 }
 
+} // namespace cppcoreguidelines
 } // namespace tidy
 } // namespace clang
 

clang-tidy/cppcoreguidelines/ProTypeVarargCheck.h

 //===--- ProTypeVarargCheck.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_CPPCOREGUIDELINES_PRO_TYPE_VARARG_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_TYPE_VARARG_H
 
 #include "../ClangTidy.h"
 
 namespace clang {
 namespace tidy {
+namespace cppcoreguidelines {
 
 /// This check flags all calls to c-style variadic functions and all use
 /// of va_arg.
 ///
 /// For the user-facing documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-pro-type-vararg.html
 class ProTypeVarargCheck : public ClangTidyCheck {
 public:
   ProTypeVarargCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) 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_TYPE_VARARG_H

clang-tidy/cppcoreguidelines/ProTypeVarargCheck.cpp

 #include "ProTypeVarargCheck.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
+namespace cppcoreguidelines {
 
 const internal::VariadicDynCastAllOfMatcher<Stmt, VAArgExpr> vAArgExpr;
 
 void ProTypeVarargCheck::registerMatchers(MatchFinder *Finder) {
   if (!getLangOpts().CPlusPlus)
     return;
 
   Finder->addMatcher(vAArgExpr().bind("va_use"), this);
if (const auto *Matched = Result.Nodes.getNodeAs<VarDecl>("va_list")) {
     auto SR = Matched->getSourceRange();
     if (SR.isInvalid())
       return; // some implicitly generated builtins take va_list
     diag(SR.getBegin(), "do not declare variables of type va_list; "
                         "use variadic templates instead");
   }
 }
 
+} // namespace cppcoreguidelines
 } // namespace tidy
 } // namespace clang

clang-tidy/misc/AssertSideEffectCheck.h

 
 #include "../ClangTidy.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include <string>
 
 namespace clang {
 namespace tidy {
+namespace misc {
 
 /// Finds `assert()` with side effect.
 ///
 /// The condition of `assert()` is evaluated only in debug builds so a
 /// condition with side effect can cause different behavior in debug / release
 /// builds.
 ///
 /// There are two options:
public:
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
   const bool CheckFunctionCalls;
   const std::string RawAssertList;
   SmallVector<StringRef, 5> AssertMacros;
 };
 
+} // namespace misc
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_ASSERTSIDEEFFECTCHECK_H

clang-tidy/misc/AssertSideEffectCheck.cpp

 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Casting.h"
 #include <algorithm>
 #include <string>
 
 using namespace clang::ast_matchers;
 
 namespace clang {
+namespace tidy {
+namespace misc {
+
 namespace {
 
 AST_MATCHER_P(Expr, hasSideEffect, bool, CheckFunctionCalls) {
   const Expr *E = &Node;
 
   if (const auto *Op = dyn_cast<UnaryOperator>(E)) {
     UnaryOperator::Opcode OC = Op->getOpcode();
     return OC == UO_PostInc || OC == UO_PostDec || OC == UO_PreInc ||
if (const auto *CExpr = dyn_cast<CallExpr>(E)) {
     return Result;
   }
 
   return isa<CXXNewExpr>(E) || isa<CXXDeleteExpr>(E) || isa<CXXThrowExpr>(E);
 }
 
 } // namespace
 
-namespace tidy {
-
 AssertSideEffectCheck::AssertSideEffectCheck(StringRef Name,
                                              ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       CheckFunctionCalls(Options.get("CheckFunctionCalls", false)),
       RawAssertList(Options.get("AssertMacros", "assert")) {
   StringRef(RawAssertList).split(AssertMacros, ",", -1, false);
 }
 
while (Loc.isValid() && Loc.isMacroID()) {
     Loc = SM.getImmediateMacroCallerLoc(Loc);
   }
   if (AssertMacroName.empty())
     return;
 
   diag(Loc, "found %0() with side effect") << AssertMacroName;
 }
 
+} // namespace misc
 } // namespace tidy
 } // namespace clang

clang-tidy/misc/BoolPointerImplicitConversionCheck.cpp

 //===--- BoolPointerImplicitConversionCheck.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 "BoolPointerImplicitConversionCheck.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
+namespace tidy {
+namespace misc {
+
 namespace {
 
 AST_MATCHER(CastExpr, isPointerToBoolean) {
   return Node.getCastKind() == CK_PointerToBoolean;
 }
 
 } // namespace
 
-namespace tidy {
-namespace misc {
-
 void BoolPointerImplicitConversionCheck::registerMatchers(MatchFinder *Finder) {
   // Look for ifs that have an implicit bool* to bool conversion in the
   // condition. Filter negations.
   Finder->addMatcher(
       ifStmt(hasCondition(findAll(implicitCastExpr(
                  allOf(unless(hasParent(unaryOperator(hasOperatorName("!")))),
                        hasSourceExpression(expr(
                            hasType(pointerType(pointee(booleanType()))),

clang-tidy/misc/IncorrectRoundings.cpp

 //===--- IncorrectRoundings.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 "IncorrectRoundings.h"
 #include "clang/AST/DeclBase.h"
 #include "clang/AST/Type.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
 #include "clang/Lex/Lexer.h"
 
+using namespace clang::ast_matchers;
+
 namespace clang {
-namespace ast_matchers {
+namespace tidy {
+namespace misc {
+
+namespace {
 AST_MATCHER(FloatingLiteral, floatHalf) {
   const auto &literal = Node.getValue();
   if ((&Node.getSemantics()) == &llvm::APFloat::IEEEsingle)
     return literal.convertToFloat() == 0.5f;
   if ((&Node.getSemantics()) == &llvm::APFloat::IEEEdouble)
     return literal.convertToDouble() == 0.5;
   return false;
 }
-} // namespace ast_matchers
-} // namespace clang
+} // namespace
 
-using namespace clang::ast_matchers;
 
-namespace clang {
-namespace tidy {
-namespace misc {
 void IncorrectRoundings::registerMatchers(MatchFinder *MatchFinder) {
   // Match a floating literal with value 0.5.
   auto FloatHalf = floatLiteral(floatHalf());
 
   // Match a floating point expression.
   auto FloatType = expr(hasType(realFloatingPointType()));
 
   // Match a floating literal of 0.5 or a floating literal of 0.5 implicitly.

clang-tidy/misc/MacroParenthesesCheck.h

 //===--- MacroParenthesesCheck.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_MISC_MACRO_PARENTHESES_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_MACRO_PARENTHESES_H
 
 #include "../ClangTidy.h"
 
 namespace clang {
 namespace tidy {
+namespace misc {
 
 /// Finds macros that can have unexpected behaviour due to missing parentheses.
 ///
 /// Macros are expanded by the preprocessor as-is. As a result, there can be
 /// unexpected behaviour; operators may be evaluated in unexpected order and
 /// unary operators may become binary operators, etc.
 ///
 /// When the replacement list has an expression, it is recommended to surround
 /// it with parentheses. This ensures that the macro result is evaluated
 /// completely before it is used.
 ///
 /// It is also recommended to surround macro arguments in the replacement list
 /// with parentheses. This ensures that the argument value is calculated
 /// properly.
 class MacroParenthesesCheck : public ClangTidyCheck {
 public:
   MacroParenthesesCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
   void registerPPCallbacks(CompilerInstance &Compiler) override;
 };
 
+} // namespace misc
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_MACRO_PARENTHESES_H

clang-tidy/misc/MacroParenthesesCheck.cpp

 //===--- MacroParenthesesCheck.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 "MacroParenthesesCheck.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Lex/PPCallbacks.h"
 #include "clang/Lex/Preprocessor.h"
 
 namespace clang {
 namespace tidy {
+namespace misc {
 
 namespace {
 class MacroParenthesesPPCallbacks : public PPCallbacks {
 public:
   MacroParenthesesPPCallbacks(Preprocessor *PP,
                               MacroParenthesesCheck *Check)
       : PP(PP), Check(Check) {}
 

 }
 
 void MacroParenthesesCheck::registerPPCallbacks(CompilerInstance &Compiler) {
   Compiler.getPreprocessor().addPPCallbacks(
       llvm::make_unique<MacroParenthesesPPCallbacks>(
           &Compiler.getPreprocessor(), this));
 }
 
+} // namespace misc
 } // namespace tidy
 } // namespace clang

clang-tidy/misc/MoveConstantArgumentCheck.cpp

 //===--- MoveConstandArgumentCheck.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 "MoveConstantArgumentCheck.h"
 
-#include <clang/Lex/Lexer.h>
+#include "clang/Lex/Lexer.h"
+
+using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace misc {
 
-using namespace ast_matchers;
-
 void MoveConstantArgumentCheck::registerMatchers(MatchFinder *Finder) {
   if (!getLangOpts().CPlusPlus)
     return;
   Finder->addMatcher(callExpr(callee(functionDecl(hasName("::std::move"))),
                               argumentCountIs(1),
                               unless(isInTemplateInstantiation()))
                          .bind("call-move"),
                      this);

clang-tidy/misc/MoveConstructorInitCheck.h

 
 #include "../ClangTidy.h"
 #include "../utils/IncludeInserter.h"
 
 #include <memory>
 
 namespace clang {
 namespace tidy {
+namespace misc {
 
 /// The check flags user-defined move constructors that have a ctor-initializer
 /// initializing a member or base class through a copy constructor instead of a
 /// move constructor.
 /// For the user-facing documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/misc-move-constructor-init.html
 class MoveConstructorInitCheck : public ClangTidyCheck {
 public:
private:
   void
   handleParamNotMoved(const ast_matchers::MatchFinder::MatchResult &Result);
 
   std::unique_ptr<IncludeInserter> Inserter;
   const 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

 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Lex/Lexer.h"
 #include "clang/Lex/Preprocessor.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
+namespace misc {
 
 namespace {
 
 unsigned int
 parmVarDeclRefExprOccurences(const ParmVarDecl &MovableParam,
                              const CXXConstructorDecl &ConstructorDecl,
                              ASTContext &Context) {
   unsigned int Occurrences = 0;
Inserter.reset(new IncludeInserter(Compiler.getSourceManager(),
                                      Compiler.getLangOpts(), IncludeStyle));
   Compiler.getPreprocessor().addPPCallbacks(Inserter->CreatePPCallbacks());
 }
 
 void MoveConstructorInitCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "IncludeStyle", IncludeSorter::toString(IncludeStyle));
 }
 
+} // namespace misc
 } // namespace tidy
 } // namespace clang

clang-tidy/misc/NewDeleteOverloadsCheck.cpp

 //===--- NewDeleteOverloadsCheck.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 "NewDeleteOverloadsCheck.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
+namespace tidy {
+namespace misc {
+
 namespace {
+
 AST_MATCHER(FunctionDecl, isPlacementOverload) {
   bool New;
   switch (Node.getOverloadedOperator()) {
   default:
     return false;
   case OO_New:
   case OO_Array_New:
     New = true;
AST_MATCHER(FunctionDecl, isPlacementOverload) {
   const auto *FPT = Node.getType()->castAs<FunctionProtoType>();
   ASTContext &Ctx = Node.getASTContext();
   if (Ctx.getLangOpts().SizedDeallocation &&
       Ctx.hasSameType(FPT->getParamType(1), Ctx.getSizeType()))
     return false;
 
   return true;
 }
-} // namespace
 
-namespace tidy {
-namespace misc {
-
-namespace {
 OverloadedOperatorKind getCorrespondingOverload(const FunctionDecl *FD) {
   switch (FD->getOverloadedOperator()) {
   default: break;
   case OO_New:
     return OO_Delete;
   case OO_Delete:
     return OO_New;
   case OO_Array_New:
if (BS.getType()->isDependentType())
       return true;
     if (const auto *BaseRD = BS.getType()->getAsCXXRecordDecl())
       if (hasCorrespondingOverloadInBaseClass(MD, BaseRD))
         return true;
   }
 
   return false;
 }
+
 } // anonymous namespace
 
 void NewDeleteOverloadsCheck::registerMatchers(MatchFinder *Finder) {
   if (!getLangOpts().CPlusPlus)
     return;
 
   // Match all operator new and operator delete overloads (including the array
   // forms). Do not match implicit operators, placement operators, or

clang-tidy/misc/NoexceptMoveConstructorCheck.h

 //===--- NoexceptMoveConstructorCheck.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_MISC_NOEXCEPTMOVECONSTRUCTORCHECK_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_NOEXCEPTMOVECONSTRUCTORCHECK_H
 
 #include "../ClangTidy.h"
 
 namespace clang {
 namespace tidy {
+namespace misc {
 
 /// The check flags user-defined move constructors and assignment operators not
 /// marked with `noexcept` or marked with `noexcept(expr)` where `expr`
 /// evaluates to `false` (but is not a `false` literal itself).
 ///
 /// Move constructors of all the types used with STL containers, for example,
 /// need to be declared `noexcept`. Otherwise STL will choose copy constructors
 /// instead. The same is valid for move assignment operations.
 class NoexceptMoveConstructorCheck : public ClangTidyCheck {
 public:
   NoexceptMoveConstructorCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
+} // namespace misc
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_NOEXCEPTMOVECONSTRUCTORCHECK_H
 

clang-tidy/misc/NoexceptMoveConstructorCheck.cpp

 #include "NoexceptMoveConstructorCheck.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
+namespace misc {
 
 void NoexceptMoveConstructorCheck::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;
 
   Finder->addMatcher(
switch(ProtoType->getNoexceptSpec(*Result.Context)) {
       case FunctionProtoType::NR_Nothrow:
       case FunctionProtoType::NR_Dependent:
       case FunctionProtoType::NR_BadNoexcept:
         break;
     }
   }
 }
 
+} // namespace misc
 } // namespace tidy
 } // namespace clang
 

clang-tidy/misc/NonCopyableObjects.h

 //===--- NonCopyableObjects.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_MISC_NONCOPYABLEOBJECTS_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_NONCOPYABLEOBJECTS_H
 
 #include "../ClangTidy.h"
 
 namespace clang {
 namespace tidy {
+namespace misc {
 
 /// The check flags dereferences and non-pointer declarations of objects that
 /// are not meant to be passed by value, such as C FILE objects.
 class NonCopyableObjectsCheck : public ClangTidyCheck {
 public:
   NonCopyableObjectsCheck(StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
+} // namespace misc
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_NONCOPYABLEOBJECTS_H

clang-tidy/misc/NonCopyableObjects.cpp

 #include "NonCopyableObjects.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include <algorithm>
 
 using namespace clang::ast_matchers;
 
 namespace clang {
+namespace tidy {
+namespace misc {
+
 namespace {
 // FIXME: it would be good to make a list that is also user-configurable so that
 // users can add their own elements to the list. However, it may require some
 // extra thought since POSIX types and FILE types are usable in different ways.
 bool isPOSIXTypeName(StringRef ClassName) {
   static const char *const TypeNames[] = {
     "::pthread_cond_t",
     "::pthread_mutex_t",
AST_MATCHER(NamedDecl, isFILEType) {
   return isFILETypeName(Node.getQualifiedNameAsString());
 }
 
 AST_MATCHER(NamedDecl, isPOSIXType) {
   return isPOSIXTypeName(Node.getQualifiedNameAsString());
 }
 } // namespace
 
-namespace tidy {
 void NonCopyableObjectsCheck::registerMatchers(MatchFinder *Finder) {
   // There are two ways to get into trouble with objects like FILE *:
   // dereferencing the pointer type to be a non-pointer type, and declaring
   // the type as a non-pointer type in the first place. While the declaration
   // itself could technically be well-formed in the case where the type is not
   // an opaque type, it's highly suspicious behavior.
   //
   // POSIX types are a bit different in that it's reasonable to declare a
diag(D->getLocation(), "%0 declared as type '%1', which is unsafe to copy"
         << D << BD->getName();
   else if (E)
     diag(E->getExprLoc(),
          "expression has opaque data structure type %0; type should only be "
          "used as a pointer and not dereferenced")
         << BD;
 }
 
+} // namespace misc
 } // namespace tidy
 } // namespace clang
 

clang-tidy/misc/SizeofContainerCheck.h

 //===--- SizeofContainerCheck.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_MISC_SIZEOF_CONTAINER_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_SIZEOF_CONTAINER_H
 
 #include "../ClangTidy.h"
 
 namespace clang {
 namespace tidy {
+namespace misc {
 
 /// Find usages of sizeof on expressions of STL container types. Most likely the
 /// user wanted to use `.size()` instead.
 ///
 /// For the user-facing documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/misc-sizeof-container.html
 class SizeofContainerCheck : public ClangTidyCheck {
 public:
   SizeofContainerCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
+} // namespace misc
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_SIZEOF_CONTAINER_H
 

clang-tidy/misc/SizeofContainerCheck.cpp

 #include "SizeofContainerCheck.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
+namespace misc {  
 
 void SizeofContainerCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(
       expr(unless(isInTemplateInstantiation()),
            expr(sizeOfExpr(has(
                     expr(hasType(hasCanonicalType(hasDeclaration(cxxRecordDecl(
                         matchesName("^(::std::|::string)"),
                         unless(matchesName("^::std::(bitset|array)$")),
void SizeofContainerCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *SizeOf =
       Result.Nodes.getNodeAs<UnaryExprOrTypeTraitExpr>("sizeof");
 
   auto Diag =
       diag(SizeOf->getLocStart(), "sizeof() doesn't return the size of the "
                                   "container; did you mean .size()?");
 }
 
+} // namespace misc
 } // namespace tidy
 } // namespace clang
 

clang-tidy/misc/StaticAssertCheck.h

 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_STATICASSERTCHECK_H
 
 #include "../ClangTidy.h"
 #include "llvm/ADT/StringRef.h"
 #include <string>
 
 namespace clang {
 namespace tidy {
+namespace misc {  
 
 /// Replaces `assert()` with `static_assert()` if the condition is evaluatable
 /// at compile time.
 ///
 /// The condition of `static_assert()` is evaluated at compile time which is
 /// safer and more efficient.
 class StaticAssertCheck : public ClangTidyCheck {
 public:
   StaticAssertCheck(StringRef Name, ClangTidyContext *Context);
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
   SourceLocation getLastParenLoc(const ASTContext *ASTCtx,
                                  SourceLocation AssertLoc);
 };
 
+} // namespace misc
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_STATICASSERTCHECK_H

clang-tidy/misc/StaticAssertCheck.cpp

 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Casting.h"
 #include <string>
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
+namespace misc {  
 
 StaticAssertCheck::StaticAssertCheck(StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context) {}
 
 void StaticAssertCheck::registerMatchers(MatchFinder *Finder) {
   // This checker only makes sense for languages that have static assertion
   // capabilities: C++11 and C11.
   if (!(getLangOpts().CPlusPlus11 || getLangOpts().C11))
if (Token.is(tok::l_paren))
       ++ParenCount;
     else if (Token.is(tok::r_paren))
       --ParenCount;
   }
 
   return Token.getLocation();
 }
 
+} // namespace misc
 } // namespace tidy
 } // namespace clang

clang-tidy/misc/StringIntegerAssignmentCheck.h

 //===--- StringIntegerAssignmentCheck.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_MISC_STRING_INTEGER_ASSIGNMENT_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_STRING_INTEGER_ASSIGNMENT_H
 
 #include "../ClangTidy.h"
 
 namespace clang {
 namespace tidy {
+namespace misc {  
 
 /// Finds instances where an integer is assigned to a string.
 ///
 /// For more details see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/misc-string-assignment.html
 class StringIntegerAssignmentCheck : public ClangTidyCheck {
 public:
   StringIntegerAssignmentCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
+} // namespace misc
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_STRING_INTEGER_ASSIGNMENT_H
 

clang-tidy/misc/StringIntegerAssignmentCheck.cpp

 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/Lex/Lexer.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
+namespace misc {  
 
 void StringIntegerAssignmentCheck::registerMatchers(MatchFinder *Finder) {
   if (!getLangOpts().CPlusPlus)
     return;
   Finder->addMatcher(
       cxxOperatorCallExpr(
           anyOf(hasOverloadedOperatorName("="),
                 hasOverloadedOperatorName("+=")),
void StringIntegerAssignmentCheck::check(
 
   if (getLangOpts().CPlusPlus11) {
     Diag << FixItHint::CreateInsertion(Loc, IsWideCharType ? "std::to_wstring("
                                                            : "std::to_string(")
          << FixItHint::CreateInsertion(EndLoc, ")");
   }
 }
 
+} // namespace misc
 } // namespace tidy
 } // namespace clang

clang-tidy/misc/ThrowByValueCatchByReferenceCheck.h

 //===--- ThrowByValueCatchByReferenceCheck.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_MISC_THROW_BY_VALUE_CATCH_BY_REFERENCE_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_THROW_BY_VALUE_CATCH_BY_REFERENCE_H
 
 #include "../ClangTidy.h"
 
 namespace clang {
 namespace tidy {
+namespace misc {
 
 ///\brief checks for locations that do not throw by value
 // or catch by reference.
 // The check is C++ only. It checks that all throw locations
 // throw by value and not by pointer. Additionally it
 // contains an option ("CheckThrowTemporaries", default value "true") that
 // checks that thrown objects are anonymous temporaries. It is also
 // acceptable for this check to throw string literals.
private:
   void diagnoseCatchLocations(const CXXCatchStmt *catchStmt,
                               ASTContext &context);
   bool isFunctionParameter(const DeclRefExpr *declRefExpr);
   bool isCatchVariable(const DeclRefExpr *declRefExpr);
   bool isFunctionOrCatchVar(const DeclRefExpr *declRefExpr);
   const bool CheckAnonymousTemporaries;
 };
 
+} // namespace misc
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_THROW_BY_VALUE_CATCH_BY_REFERENCE_H

clang-tidy/misc/ThrowByValueCatchByReferenceCheck.cpp

 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/AST/OperationKinds.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
+namespace misc {  
 
 ThrowByValueCatchByReferenceCheck::ThrowByValueCatchByReferenceCheck(
     StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       CheckAnonymousTemporaries(Options.get("CheckThrowTemporaries", true)) {}
 
 void ThrowByValueCatchByReferenceCheck::registerMatchers(MatchFinder *Finder) {
   // This is a C++ only check thus we register the matchers only for C++
if (const auto *PT = caughtType.getCanonicalType()->getAs<PointerType>()) {
     // If it's not a pointer and not a reference then it must be thrown "by
     // value". In this case we should emit a diagnosis message unless the type
     // is trivial.
     if (!caughtType.isTrivialType(context))
       diag(varDecl->getLocStart(), diagMsgCatchReference);
   }
 }
 
+} // namespace misc
 } // namespace tidy
 } // namespace clang

clang-tidy/misc/UndelegatedConstructor.cpp

 //===--- UndelegatedConstructor.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 "UndelegatedConstructor.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/Lex/Lexer.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
+namespace tidy {
+namespace misc {
 
 namespace {
 AST_MATCHER_P(Stmt, ignoringTemporaryExpr,
               ast_matchers::internal::Matcher<Stmt>, InnerMatcher) {
   const Stmt *E = &Node;
   for (;;) {
     // Temporaries with non-trivial dtors.
     if (const auto *EWC = dyn_cast<ExprWithCleanups>(E))
AST_MATCHER_P(CXXRecordDecl, baseOfBoundNode, std::string, ID) {
   return Builder->removeBindings(
       [&](const ast_matchers::internal::BoundNodesMap &Nodes) {
         const auto *Derived = Nodes.getNodeAs<CXXRecordDecl>(ID);
         return Derived != &Node && !Derived->isDerivedFrom(&Node);
       });
 }
 } // namespace
 
-namespace tidy {
-namespace misc {
-
 void UndelegatedConstructorCheck::registerMatchers(MatchFinder *Finder) {
   // We look for calls to constructors of the same type in constructors. To do
   // this we have to look through a variety of nodes that occur in the path,
   // depending on the type's destructor and the number of arguments on the
   // constructor call, this is handled by ignoringTemporaryExpr. Ignore template
   // instantiations to reduce the number of duplicated warnings.
   //
   // Only register the matchers for C++11; the functionality currently does not

clang-tidy/misc/UnusedAliasDeclsCheck.h

 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNUSED_ALIAS_DECLS_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNUSED_ALIAS_DECLS_H
 
 #include "../ClangTidy.h"
 #include "llvm/ADT/DenseMap.h"
 
 namespace clang {
 namespace tidy {
+namespace misc {  
 
 /// Finds unused namespace alias declarations.
 class UnusedAliasDeclsCheck : public ClangTidyCheck {
 public:
   UnusedAliasDeclsCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
   void onEndOfTranslationUnit() override;
 
 private:
   llvm::DenseMap<const NamedDecl *, CharSourceRange> FoundDecls;
 };
 
+} // namespace misc
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNUSED_ALIAS_DECLS_H
 

clang-tidy/misc/UnusedAliasDeclsCheck.cpp

 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/Lex/Lexer.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
+namespace misc {
 
 void UnusedAliasDeclsCheck::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;
 
   // We cannot do anything about headers (yet), as the alias declarations
void UnusedAliasDeclsCheck::onEndOfTranslationUnit() {
   for (const auto &FoundDecl : FoundDecls) {
     if (!FoundDecl.second.isValid())
       continue;
     diag(FoundDecl.first->getLocation(), "namespace alias decl %0 is unused")
         << FoundDecl.first << FixItHint::CreateRemoval(FoundDecl.second);
   }
 }
 
+} // namespace misc
 } // namespace tidy
 } // namespace clang

clang-tidy/misc/UnusedParametersCheck.h

 //===--- UnusedParametersCheck.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_MISC_UNUSED_PARAMETERS_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNUSED_PARAMETERS_H
 
 #include "../ClangTidy.h"
 
 namespace clang {
 namespace tidy {
+namespace misc {  
 
 /// Finds unused parameters and fixes them, so that `-Wunused-parameter` can be
 /// turned on.
 class UnusedParametersCheck : public ClangTidyCheck {
 public:
   UnusedParametersCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
   void
   warnOnUnusedParameter(const ast_matchers::MatchFinder::MatchResult &Result,
                         const FunctionDecl *Function, unsigned ParamIndex);
 };
 
+} // namespace misc
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNUSED_PARAMETERS_H
 

clang-tidy/misc/UnusedParametersCheck.cpp

 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/Lex/Lexer.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
+namespace misc {
+
 namespace {
 bool isOverrideMethod(const FunctionDecl *Function) {
   if (const auto *MD = dyn_cast<CXXMethodDecl>(Function))
     return MD->size_overridden_methods() > 0 || MD->hasAttr<OverrideAttr>();
   return false;
 }
 } // namespace
 
for (unsigned i = 0, e = Function->getNumParams(); i != e; ++i) {
     const auto *Param = Function->getParamDecl(i);
     if (Param->isUsed() || Param->isReferenced() || !Param->getDeclName() ||
         Param->hasAttr<UnusedAttr>())
       continue;
     warnOnUnusedParameter(Result, Function, i);
   }
 }
 
+} // namespace misc
 } // namespace tidy
 } // namespace clang

clang-tidy/misc/UnusedRAIICheck.cpp

 //===--- UnusedRAIICheck.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 "UnusedRAIICheck.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/Lex/Lexer.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
+namespace tidy {
+namespace misc {
+
 namespace {
 AST_MATCHER(CXXRecordDecl, hasNonTrivialDestructor) {
   // TODO: If the dtor is there but empty we don't want to warn either.
   return Node.hasDefinition() && Node.hasNonTrivialDestructor();
 }
 } // namespace
 
-namespace tidy {
-namespace misc {
-
 void UnusedRAIICheck::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;
 
   // Look for temporaries that are constructed in-place and immediately
   // destroyed. Look for temporaries created by a functional cast but not for

clang-tidy/modernize/RawStringLiteralCheck.h

 //===--- RawStringLiteralCheck.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_MODERNIZE_RAW_STRING_LITERAL_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_RAW_STRING_LITERAL_H
 
 #include "../ClangTidy.h"
-//#include <string>
 
 namespace clang {
 namespace tidy {
 namespace modernize {
 
 /// This check replaces string literals with escaped characters to
 /// raw string literals.
 ///

clang-tidy/modernize/RedundantVoidArgCheck.cpp

 //===- RedundantVoidArgCheck.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 "RedundantVoidArgCheck.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Lex/Lexer.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
+namespace tidy {
+namespace modernize {
 
 namespace {
 
 // Determine if the given QualType is a nullary function or pointer to same.
 bool protoTypeHasNoParms(QualType QT) {
   if (auto PT = QT->getAs<PointerType>()) {
     QT = PT->getPointeeType();
   }

 const char VarId[] = "var";
 const char NamedCastId[] = "named-cast";
 const char CStyleCastId[] = "c-style-cast";
 const char ExplicitCastId[] = "explicit-cast";
 const char LambdaId[] = "lambda";
 
 } // namespace
 
-namespace tidy {
-namespace modernize {
-
 void RedundantVoidArgCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(functionDecl(parameterCountIs(0), unless(isImplicit()),
                                   unless(isExternC()))
                          .bind(FunctionId),
                      this);
   Finder->addMatcher(typedefNameDecl().bind(TypedefId), this);
   auto ParenFunctionType = parenType(innerType(functionType()));
   auto PointerToFunctionType = pointee(ParenFunctionType);

clang-tidy/performance/ForRangeCopyCheck.cpp

 //===--- ForRangeCopyCheck.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 "ForRangeCopyCheck.h"
 #include "../utils/DeclRefExprUtils.h"
 #include "../utils/FixItHintUtils.h"
 #include "../utils/TypeTraits.h"
 
+using namespace clang::ast_matchers;
+
 namespace clang {
 namespace tidy {
 namespace performance {
 
-using namespace ::clang::ast_matchers;
-
 ForRangeCopyCheck::ForRangeCopyCheck(StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       WarnOnAllAutoCopies(Options.get("WarnOnAllAutoCopies", 0)) {}
 
 void ForRangeCopyCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "WarnOnAllAutoCopies", WarnOnAllAutoCopies);
 }
 

clang-tidy/performance/ImplicitCastInLoopCheck.cpp

 #include "ImplicitCastInLoopCheck.h"
 
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/Decl.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
 #include "clang/Lex/Lexer.h"
 
-namespace clang {
-
-using namespace ast_matchers;
+using namespace clang::ast_matchers;
 
+namespace clang {
 namespace tidy {
 namespace performance {
 
 namespace {
 // Checks if the stmt is a ImplicitCastExpr with a CastKind that is not a NoOp.
 // The subtelty is that in some cases (user defined conversions), we can
 // get to ImplicitCastExpr inside each other, with the outer one a NoOp. In this
 // case we skip the first cast expr.

clang-tidy/readability/ImplicitBoolCastCheck.h

 //===--- ImplicitBoolCastCheck.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_READABILITY_IMPLICIT_BOOL_CAST_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_IMPLICIT_BOOL_CAST_H
 
 #include "../ClangTidy.h"
 
 namespace clang {
 namespace tidy {
+namespace readability {
 
 /// \brief Checks for use of implicit bool casts in expressions.
 ///
 /// For the user-facing documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/readability-implicit-bool-cast.html
 class ImplicitBoolCastCheck : public ClangTidyCheck {
 public:
   ImplicitBoolCastCheck(StringRef Name, ClangTidyContext *Context)
private:
   void handleCastFromBool(const ImplicitCastExpr *CastExpression,
                           const ImplicitCastExpr *FurtherImplicitCastExpression,
                           ASTContext &Context);
 
   bool AllowConditionalIntegerCasts;
   bool AllowConditionalPointerCasts;
 };
 
+} // namespace readability
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_IMPLICIT_BOOL_CAST_H

clang-tidy/readability/ImplicitBoolCastCheck.cpp

 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/Lex/Lexer.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
+namespace readability {
 
 namespace {
 
 AST_MATCHER_P(CastExpr, hasCastKind, CastKind, Kind) {
   return Node.getCastKind() == Kind;
 }
 
 AST_MATCHER(Stmt, isMacroExpansion) {
if (llvm::isa<CXXBoolLiteralExpr>(CastExpression->getSubExpr())) {
     addFixItHintsForLiteralCastFromBool(Diagnostic, CastExpression, Context,
                                         DestinationType);
   } else {
     addFixItHintsForGenericExpressionCastFromBool(
         Diagnostic, CastExpression, Context, DestinationTypeString);
   }
 }
 
+} // namespace readability
 } // namespace tidy
 } // namespace clang

clang-tidy/readability/InconsistentDeclarationParameterNameCheck.cpp

 #include "InconsistentDeclarationParameterNameCheck.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 
 #include <algorithm>
 #include <functional>
 #include <sstream>
 
+using namespace clang::ast_matchers;
+
 namespace clang {
 namespace tidy {
 namespace readability {
 
-using namespace ast_matchers;
-
 namespace {
 
 AST_MATCHER(FunctionDecl, hasOtherDeclarations) {
   auto It = Node.redecls_begin();
   auto EndIt = Node.redecls_end();
 
   if (It == EndIt)
     return false;

clang-tidy/readability/RedundantStringCStrCheck.cpp

 //===- RedundantStringCStrCheck.cpp - Check for redundant c_str calls -----===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file implements a check for redundant calls of c_str() on strings.
 //
 //===----------------------------------------------------------------------===//
 
 #include "RedundantStringCStrCheck.h"
 #include "clang/Lex/Lexer.h"
 
-namespace clang {
+using namespace clang::ast_matchers;
 
-using namespace ast_matchers;
+namespace clang {
+namespace tidy {
+namespace readability {
 
 namespace {
 
 template <typename T>
 StringRef getText(const ast_matchers::MatchFinder::MatchResult &Result,
                   T const &Node) {
   return Lexer::getSourceText(
       CharSourceRange::getTokenRange(Node.getSourceRange()),
formatDereference(const ast_matchers::MatchFinder::MatchResult &Result,
   if (needParensAfterUnaryOperator(ExprNode)) {
     return (llvm::Twine("*(") + Text + ")").str();
   }
   return (llvm::Twine("*") + Text).str();
 }
 
 } // end namespace
 
-namespace tidy {
-namespace readability {
-
 void RedundantStringCStrCheck::registerMatchers(
     ast_matchers::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;
 
   // Match expressions of type 'string' or 'string*'.

clang-tidy/readability/UniqueptrDeleteReleaseCheck.h

 //===--- UniqueptrDeleteReleaseCheck.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_READABILITY_UNIQUEPTR_DELETE_RELEASE_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_UNIQUEPTR_DELETE_RELEASE_H
 
 #include "../ClangTidy.h"
 
 namespace clang {
 namespace tidy {
+namespace readability {
 
 /// Flag statements of the form: delete <unique_ptr expr>.release()
 /// and replace them with: <unique_ptr expr> = nullptr
 ///
 /// For the user-facing documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/readability-uniqueptr-delete-release.html
 class UniqueptrDeleteReleaseCheck : public ClangTidyCheck {
 public:
   UniqueptrDeleteReleaseCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
+} // namespace readability
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_UNIQUEPTR_DELETE_RELEASE_H
 

clang-tidy/readability/UniqueptrDeleteReleaseCheck.cpp

 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/Lex/Lexer.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
+namespace readability {
 
 void UniqueptrDeleteReleaseCheck::registerMatchers(MatchFinder *Finder) {
   auto IsSusbstituted = qualType(anyOf(
       substTemplateTypeParmType(), hasDescendant(substTemplateTypeParmType())));
 
   auto UniquePtrWithDefaultDelete = classTemplateSpecializationDecl(
       hasName("std::unique_ptr"),
       hasTemplateArgument(1, refersToType(qualType(hasDeclaration(cxxRecordDecl(
diag(DeleteExpr->getLocStart(),
        "objects")
       << FixItHint::CreateRemoval(CharSourceRange::getCharRange(
              DeleteExpr->getLocStart(), PtrExpr->getLocStart()))
       << FixItHint::CreateReplacement(
              CharSourceRange::getTokenRange(AfterPtr, DeleteExpr->getLocEnd()),
              " = nullptr");
 }
 
+} // namespace readability
 } // namespace tidy
 } // namespace clang