Refactor: Move llvm clang-tidy checks to namespace clang::tidy::llvm

[LegalizeAdulthood]

Summary

clang-tidy checks are organized into modules. This refactoring moves the llvm module checks to clang::tidy::llvm

[alexfh]

Looks good! Thanks!

I'll commit the patch for you.

clang-tidy/llvm/IncludeOrderCheck.cpp

50

Wow, just one case of compiler being confused with another namespace llvm ;)

clang-tidy/llvm/LLVMTidyModule.cpp

36

I'd put it inside namespace llvm to avoid the need to qualify LLVMModule.

[alexfh]

Committed revision 230952.

Modified before commit: fixed issues pointed out in the comments.

clang-tidy/llvm/IncludeOrderCheck.cpp

50

BTW, this needs to be clang-formatted.

[LegalizeAdulthood]

clang-tidy/llvm/IncludeOrderCheck.cpp

50

Yes, I noticed a bunch of files in clang-tidy are deviating from clang-format style=LLVM. I planned to submit a separate changeset that will just clang-format everything.

clang-tidy/llvm/LLVMTidyModule.cpp

36

I was following the existing example of the readability module where they had it arranged this way. I was getting an error when the static was inside the namespace. I'll try it out and see if I can resolve the error.

[alexfh]

clang-tidy/llvm/IncludeOrderCheck.cpp

50

The fragment formatting was off because of this patch, I've fixed this already.

clang-tidy/llvm/LLVMTidyModule.cpp

36

I've fixed and committed this already. Seems to work fine.

clang-tidy/llvm/HeaderGuardCheck.h

 //===--- HeaderGuardCheck.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_LLVM_HEADER_GUARD_CHECK_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVM_HEADER_GUARD_CHECK_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 {
 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/llvm/HeaderGuardCheck.cpp

 //===--- HeaderGuardCheck.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 "HeaderGuardCheck.h"
 
 namespace clang {
 namespace tidy {
+namespace llvm {
 
 bool LLVMHeaderGuardCheck::shouldFixHeaderGuard(StringRef Filename) {
   return Filename.endswith(".h");
 }
 
 std::string LLVMHeaderGuardCheck::getHeaderGuard(StringRef Filename,
                                                  StringRef OldGuard) {
   std::string Guard = tooling::getAbsolutePath(Filename);
std::string LLVMHeaderGuardCheck::getHeaderGuard(StringRef Filename,
 
   // The prevalent style in clang is LLVM_CLANG_FOO_BAR_H
   if (StringRef(Guard).startswith("clang"))
     Guard = "LLVM_" + Guard;
 
   return StringRef(Guard).upper();
 }
 
+} // namespace llvm
 } // namespace tidy
 } // namespace clang

clang-tidy/llvm/IncludeOrderCheck.h

 //===--- IncludeOrderCheck.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_LLVM_INCLUDE_ORDER_CHECK_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVM_INCLUDE_ORDER_CHECK_H
 
 #include "../ClangTidy.h"
 
 namespace clang {
 namespace tidy {
+namespace llvm {
 
 /// \brief Checks the correct order of \c #includes.
 ///
 /// see: http://llvm.org/docs/CodingStandards.html#include-style
 class IncludeOrderCheck : public ClangTidyCheck {
 public:
   IncludeOrderCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
   void registerPPCallbacks(CompilerInstance &Compiler) override;
 };
 
+} // namespace llvm
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVM_INCLUDE_ORDER_CHECK_H

clang-tidy/llvm/IncludeOrderCheck.cpp

 //===--- IncludeOrderCheck.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 "IncludeOrderCheck.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Lex/PPCallbacks.h"
 #include "clang/Lex/Preprocessor.h"
 
 namespace clang {
 namespace tidy {
+namespace llvm {
 
 namespace {
 class IncludeOrderPPCallbacks : public PPCallbacks {
 public:
   explicit IncludeOrderPPCallbacks(ClangTidyCheck &Check, SourceManager &SM)
       : LookForMainModule(true), Check(Check), SM(SM) {}
 
   void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
private:
 
   ClangTidyCheck &Check;
   SourceManager &SM;
 };
 } // namespace
 
 void IncludeOrderCheck::registerPPCallbacks(CompilerInstance &Compiler) {
   Compiler.getPreprocessor().addPPCallbacks(
-      llvm::make_unique<IncludeOrderPPCallbacks>(*this,
+      ::llvm::make_unique<IncludeOrderPPCallbacks>(*this,
                                                  Compiler.getSourceManager()));
 }
 
 static int getPriority(StringRef Filename, bool IsAngled, bool IsMainModule) {
   // We leave the main module header at the top.
   if (IsMainModule)
     return 0;
 
for (; I != E; ++I) {
 
       D << FixItHint::CreateReplacement(ToRange, FixedName);
     }
   }
 
   IncludeDirectives.clear();
 }
 
+} // namespace llvm
 } // namespace tidy
 } // namespace clang

clang-tidy/llvm/LLVMTidyModule.cpp

 #include "../ClangTidyModuleRegistry.h"
 #include "../readability/NamespaceCommentCheck.h"
 #include "HeaderGuardCheck.h"
 #include "IncludeOrderCheck.h"
 #include "TwineLocalCheck.h"
 
 namespace clang {
 namespace tidy {
+namespace llvm {
 
 class LLVMModule : public ClangTidyModule {
 public:
   void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     CheckFactories.registerCheck<LLVMHeaderGuardCheck>("llvm-header-guard");
     CheckFactories.registerCheck<IncludeOrderCheck>("llvm-include-order");
     CheckFactories.registerCheck<readability::NamespaceCommentCheck>(
         "llvm-namespace-comment");
     CheckFactories.registerCheck<TwineLocalCheck>("llvm-twine-local");
   }
 };
 
+} // namespace llvm
+
 // Register the LLVMTidyModule using this statically initialized variable.
-static ClangTidyModuleRegistry::Add<LLVMModule> X("llvm-module",
-                                                  "Adds LLVM lint checks.");
+static ClangTidyModuleRegistry::Add<llvm::LLVMModule>
+    X("llvm-module", "Adds LLVM lint checks.");
 
 // This anchor is used to force the linker to link in the generated object file
 // and thus register the LLVMModule.
 volatile int LLVMModuleAnchorSource = 0;
 
 } // namespace tidy
 } // namespace clang

clang-tidy/llvm/TwineLocalCheck.h

 //===--- TwineLocalCheck.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_LLVM_TWINE_LOCAL_CHECK_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVM_TWINE_LOCAL_CHECK_H
 
 #include "../ClangTidy.h"
 
 namespace clang {
 namespace tidy {
+namespace llvm {
 
 /// \brief Looks for local Twine variables which are prone to use after frees
 /// and should be generally avoided.
 class TwineLocalCheck : public ClangTidyCheck {
 public:
   TwineLocalCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
+} // namespace llvm
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVM_TWINE_LOCAL_CHECK_H

clang-tidy/llvm/TwineLocalCheck.cpp

 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
 #include "clang/Lex/Lexer.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
+namespace llvm {
 
 void TwineLocalCheck::registerMatchers(MatchFinder *Finder) {
   auto TwineType =
       qualType(hasDeclaration(recordDecl(hasName("::llvm::Twine"))));
   Finder->addMatcher(varDecl(hasType(TwineType)).bind("variable"), this);
 }
 
 void TwineLocalCheck::check(const MatchFinder::MatchResult &Result) {
if (VD->getType()->getCanonicalTypeUnqualified() ==
       // Just an implicit conversion. Insert the real type.
       Diag << FixItHint::CreateReplacement(
           TypeRange,
           C->getType().getAsString(Result.Context->getPrintingPolicy()));
     }
   }
 }
 
+} // namespace llvm
 } // namespace tidy
 } // namespace clang

unittests/clang-tidy/LLVMModuleTest.cpp

 #include "ClangTidyTest.h"
 #include "llvm/HeaderGuardCheck.h"
 #include "llvm/IncludeOrderCheck.h"
 #include "gtest/gtest.h"
 
+using namespace clang::tidy::llvm;
+
 namespace clang {
 namespace tidy {
 namespace test {
 
 // FIXME: It seems this might be incompatible to dos path. Investigating.
 #if !defined(_WIN32)
 static std::string runHeaderGuardCheck(StringRef Code, const Twine &Filename,
                                        unsigned ExpectedWarnings) {