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

[LegalizeAdulthood]

Summary

clang-tidy checks are organized into modules. This refactoring moves the google module checks into the namespace clang::tidy::google

[alexfh]

clang-tidy/google/AvoidCStyleCastsCheck.cpp

21

Please don't remove the "readability" namespace. You can put the "google" namespace around it. Same for other checks.

[LegalizeAdulthood]

clang-tidy/google/AvoidCStyleCastsCheck.cpp

21

So you'd prefer clang::tidy::google::readability? I can do that.

[LegalizeAdulthood]

Observation: This review shows why it's a good idea to split large changes into multiple patches :-). The other parts were acceptable and only this one needed some tweaking.

[alexfh]

clang-tidy/google/AvoidCStyleCastsCheck.cpp

21

Yes, exactly. And the same for runtime and build namespaces.

[LegalizeAdulthood]

clang-tidy/google/AvoidCStyleCastsCheck.cpp

21

Fixed.

[LegalizeAdulthood]

Preserve child namespaces of clang::tidy::google

[LegalizeAdulthood]

clang-tidy/google/GlobalNamesInHeadersCheck.cpp

20

I will fix this.

clang-tidy/google/GlobalNamesInHeadersCheck.h

17

Looks like I missed one. On it.

clang-tidy/google/GoogleTidyModule.cpp

89–90

This will be moved into namespace google

[LegalizeAdulthood]

Fix some issues I noticed after viewing diffs in phabricator

[LegalizeAdulthood]

I think this fixes the last outstanding item.

[LegalizeAdulthood]

clang-format

[alexfh]

Looks good!

I'll commit the patch.

[alexfh]

Committed revision 231364.

Thanks for the patch!

clang-tidy/google/AvoidCStyleCastsCheck.h

 //===--- AvoidCStyleCastsCheck.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_GOOGLE_AVOID_C_STYLE_CASTS_CHECK_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_AVOID_C_STYLE_CASTS_CHECK_H
 
 #include "../ClangTidy.h"
 
 namespace clang {
 namespace tidy {
+namespace google {
 namespace readability {
 
 /// \brief Finds usages of C-style casts.
 ///
 /// http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml?showone=Casting#Casting
 /// Corresponding cpplint.py check name: 'readability/casting'.
 ///
 /// This check is similar to -Wold-style-cast, but it will suggest automated
 /// fixes eventually. The reported locations should not be different from the
 /// ones generated by -Wold-style-cast.
 class AvoidCStyleCastsCheck : public ClangTidyCheck {
 public:
   AvoidCStyleCastsCheck(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 google
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_AVOID_C_STYLE_CASTS_CHECK_H

clang-tidy/google/AvoidCStyleCastsCheck.cpp

 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
 #include "clang/Lex/Lexer.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
+namespace google {
 namespace readability {
 
 void
 AvoidCStyleCastsCheck::registerMatchers(ast_matchers::MatchFinder *Finder) {
   Finder->addMatcher(
       cStyleCastExpr(
           // Filter out (EnumType)IntegerLiteral construct, which is generated
           // for non-type template arguments of enum types.
           // FIXME: Remove this once this is fixed in the AST.
void AvoidCStyleCastsCheck::check(const MatchFinder::MatchResult &Result) {
   default:
     break;
   }
 
   diag_builder << "Use static_cast/const_cast/reinterpret_cast";
 }
 
 } // namespace readability
+} // namespace google
 } // namespace tidy
 } // namespace clang

clang-tidy/google/ExplicitConstructorCheck.h

 //===--- ExplicitConstructorCheck.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_GOOGLE_EXPLICIT_CONSTRUCTOR_CHECK_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_EXPLICIT_CONSTRUCTOR_CHECK_H
 
 #include "../ClangTidy.h"
 
 namespace clang {
 namespace tidy {
+namespace google {
 
 /// \brief Checks that all single-argument constructors are explicit.
 ///
 /// see:
 /// http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Explicit_Constructors
 class ExplicitConstructorCheck : public ClangTidyCheck {
 public:
   ExplicitConstructorCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
+} // namespace google
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_EXPLICIT_CONSTRUCTOR_CHECK_H

clang-tidy/google/ExplicitConstructorCheck.cpp

 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
 #include "clang/Lex/Lexer.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
+namespace google {
 
 void ExplicitConstructorCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(constructorDecl(unless(isInstantiated())).bind("ctor"),
                      this);
 }
 
 // Looks for the token matching the predicate and returns the range of the found
 // token including trailing whitespace.
if (Ctor->isExplicit() || Ctor->isCopyOrMoveConstructor() ||
       takesInitializerList)
     return;
 
   SourceLocation Loc = Ctor->getLocation();
   diag(Loc, "single-argument constructors must be explicit")
       << FixItHint::CreateInsertion(Loc, "explicit ");
 }
 
+} // namespace google
 } // namespace tidy
 } // namespace clang

clang-tidy/google/ExplicitMakePairCheck.h

 //===--- ExplicitMakePairCheck.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_GOOGLE_EXPLICIT_MAKE_PAIR_CHECK_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_EXPLICIT_MAKE_PAIR_CHECK_H
 
 #include "../ClangTidy.h"
 
 namespace clang {
 namespace tidy {
+namespace google {
 namespace build {
 
 /// \brief Check that make_pair's template arguments are deduced.
 ///
 /// G++ 4.6 in C++11 mode fails badly if make_pair's template arguments are
 /// specified explicitly, and such use isn't intended in any case.
 ///
 /// Corresponding cpplint.py check name: 'build/explicit_make_pair'.
 class ExplicitMakePairCheck : public ClangTidyCheck {
 public:
   ExplicitMakePairCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
 } // namespace build
+} // namespace google
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_EXPLICIT_MAKE_PAIR_CHECK_H

clang-tidy/google/ExplicitMakePairCheck.cpp

 
 namespace ast_matchers {
 AST_MATCHER(DeclRefExpr, hasExplicitTemplateArgs) {
   return Node.hasExplicitTemplateArgs();
 }
 } // namespace ast_matchers
 
 namespace tidy {
+namespace google {
 namespace build {
 
 void
 ExplicitMakePairCheck::registerMatchers(ast_matchers::MatchFinder *Finder) {
   // Look for std::make_pair with explicit template args. Ignore calls in
   // templates.
   Finder->addMatcher(
       callExpr(unless(isInTemplateInstantiation()),
if (Arg0->getType() != Call->getArg(0)->getType() ||
     diag(Call->getLocStart(),
          "for C++11-compatibility, omit template arguments from make_pair")
         << FixItHint::CreateRemoval(
             SourceRange(DeclRef->getLAngleLoc(), DeclRef->getRAngleLoc()));
   }
 }
 
 } // namespace build
+} // namespace google
 } // namespace tidy
 } // namespace clang

clang-tidy/google/GlobalNamesInHeadersCheck.h

 //===--- GlobalNamesInHeadersCheck.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_GOOGLE_GLOBAL_NAMES_IN_HEADERS_CHECK_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_GLOBAL_NAMES_IN_HEADERS_CHECK_H
 
 #include "../ClangTidy.h"
 
 namespace clang {
 namespace tidy {
-namespace readability {
+namespace google {
 
 // Flag global namespace pollution in header files.
 // Right now it only triggers on using declarations and directives.
 class GlobalNamesInHeadersCheck : public ClangTidyCheck {
 public:
   GlobalNamesInHeadersCheck(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 google
 } // namespace tidy
 } // namespace clang
 
 #endif  // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_GLOBAL_NAMES_IN_HEADERS_CHECK_H
-

clang-tidy/google/GlobalNamesInHeadersCheck.cpp

 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
 #include "clang/Lex/Lexer.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
-namespace readability {
+namespace google {
 
 void
 GlobalNamesInHeadersCheck::registerMatchers(ast_matchers::MatchFinder *Finder) {
   Finder->addMatcher(
       decl(anyOf(usingDecl(), usingDirectiveDecl()),
            hasDeclContext(translationUnitDecl())).bind("using_decl"),
       this);
 }
if (Result.SourceManager->isInMainFile(
     if (!Filename.endswith(".h"))
       return;
   }
 
   diag(D->getLocStart(),
        "using declarations in the global namespace in headers are prohibited");
 }
 
-} // namespace readability
+} // namespace google
 } // namespace tidy
 } // namespace clang

clang-tidy/google/GoogleTidyModule.cpp

 #include "TodoCommentCheck.h"
 #include "UnnamedNamespaceInHeaderCheck.h"
 #include "UsingNamespaceDirectiveCheck.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
+namespace google {
 
 class GoogleModule : public ClangTidyModule {
 public:
   void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
+    using namespace clang::tidy;
     CheckFactories.registerCheck<build::ExplicitMakePairCheck>(
         "google-build-explicit-make-pair");
     CheckFactories.registerCheck<build::UnnamedNamespaceInHeaderCheck>(
         "google-build-namespaces");
     CheckFactories.registerCheck<build::UsingNamespaceDirectiveCheck>(
         "google-build-using-namespace");
     CheckFactories.registerCheck<ExplicitConstructorCheck>(
         "google-explicit-constructor");
     CheckFactories.registerCheck<runtime::IntegerTypesCheck>(
         "google-runtime-int");
     CheckFactories.registerCheck<runtime::OverloadedUnaryAndCheck>(
         "google-runtime-operator");
     CheckFactories.registerCheck<runtime::StringReferenceMemberCheck>(
         "google-runtime-member-string-references");
     CheckFactories.registerCheck<runtime::MemsetZeroLengthCheck>(
         "google-runtime-memset");
     CheckFactories.registerCheck<readability::AvoidCStyleCastsCheck>(
         "google-readability-casting");
     CheckFactories.registerCheck<readability::NamedParameterCheck>(
         "google-readability-function");
     CheckFactories.registerCheck<readability::TodoCommentCheck>(
         "google-readability-todo");
     CheckFactories.registerCheck<readability::BracesAroundStatementsCheck>(
         "google-readability-braces-around-statements");
-    CheckFactories.registerCheck<readability::GlobalNamesInHeadersCheck>(
+    CheckFactories.registerCheck<GlobalNamesInHeadersCheck>(
         "google-global-names-in-headers");
     CheckFactories.registerCheck<readability::FunctionSizeCheck>(
         "google-readability-function-size");
     CheckFactories.registerCheck<readability::NamespaceCommentCheck>(
         "google-readability-namespace-comments");
     CheckFactories.registerCheck<readability::RedundantSmartptrGet>(
         "google-readability-redundant-smartptr-get");
   }
 
   ClangTidyOptions getModuleOptions() override {
     ClangTidyOptions Options;
     auto &Opts = Options.CheckOptions;
     Opts["google-readability-braces-around-statements.ShortStatementLines"] =
         "1";
     Opts["google-readability-function-size.StatementThreshold"] = "800";
     Opts["google-readability-namespace-comments.ShortNamespaceLines"] = "10";
     Opts["google-readability-namespace-comments.SpacesBeforeComments"] = "2";
     return Options;
   }
 };
 
+} // namespace google
+
 // Register the GoogleTidyModule using this statically initialized variable.
-static ClangTidyModuleRegistry::Add<GoogleModule> X("google-module",
-                                                    "Adds Google lint checks.");
+static ClangTidyModuleRegistry::Add<google::GoogleModule>
+    X("google-module", "Adds Google lint checks.");
 
 // This anchor is used to force the linker to link in the generated object file
 // and thus register the GoogleModule.
 volatile int GoogleModuleAnchorSource = 0;
 
 } // namespace tidy
 } // namespace clang

clang-tidy/google/IntegerTypesCheck.h

 //===--- IntegerTypesCheck.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_GOOGLE_INTEGERTYPESCHECK_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_INTEGERTYPESCHECK_H
 
 #include "../ClangTidy.h"
 
 namespace clang {
 namespace tidy {
+namespace google {
 namespace runtime {
 
 /// \brief Finds uses of short, long and long long and suggest replacing them
 /// with u?intXX(_t)?.
 /// Correspondig cpplint.py check: runtime/int.
 class IntegerTypesCheck : public ClangTidyCheck {
 public:
   IntegerTypesCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context), UnsignedTypePrefix("uint"),
         SignedTypePrefix("int"), AddUnderscoreT(false) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
   const StringRef UnsignedTypePrefix;
   const StringRef SignedTypePrefix;
   const bool AddUnderscoreT;
 };
 
 } // namespace runtime
+} // namespace google
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_INTEGERTYPESCHECK_H

clang-tidy/google/IntegerTypesCheck.cpp

 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
 #include "clang/Basic/CharInfo.h"
 #include "clang/Basic/TargetInfo.h"
 
 namespace clang {
 namespace tidy {
+namespace google {
 namespace runtime {
 
 using namespace ast_matchers;
 
 void IntegerTypesCheck::registerMatchers(MatchFinder *Finder) {
   // Find all TypeLocs.
   Finder->addMatcher(typeLoc().bind("tl"), this);
 }
void IntegerTypesCheck::check(const MatchFinder::MatchResult &Result) {
   // We don't add a fix-it as changing the type can easily break code,
   // e.g. when a function requires a 'long' argument on all platforms.
   // QualTypes are printed with implicit quotes.
   diag(Loc, "consider replacing %0 with '%1'") << BuiltinLoc.getType()
                                                << Replacement;
 }
 
 } // namespace runtime
+} // namespace google
 } // namespace tidy
 } // namespace clang

clang-tidy/google/MemsetZeroLengthCheck.h

 //===--- MemsetZeroLengthCheck.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_GOOGLE_MEMSET_ZERO_LENGTH_CHECK_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_MEMSET_ZERO_LENGTH_CHECK_H
 
 #include "../ClangTidy.h"
 
 namespace clang {
 namespace tidy {
+namespace google {
 namespace runtime {
 
 /// \brief Finds calls to memset with a literal zero in the length argument.
 ///
 /// This is most likely unintended and the length and value arguments are
 /// swapped.
 ///
 /// Corresponding cpplint.py check name: 'runtime/memset'.
 class MemsetZeroLengthCheck : public ClangTidyCheck {
 public:
   MemsetZeroLengthCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
 } // namespace runtime
+} // namespace google
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_MEMSET_ZERO_LENGTH_CHECK_H

clang-tidy/google/MemsetZeroLengthCheck.cpp

 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
 #include "clang/Lex/Lexer.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
+namespace google {
 namespace runtime {
 
 void
 MemsetZeroLengthCheck::registerMatchers(ast_matchers::MatchFinder *Finder) {
   // Look for memset(x, y, 0) as those is most likely an argument swap.
   // TODO: Also handle other standard functions that suffer from the same
   //       problem, e.g. memchr.
   Finder->addMatcher(
void MemsetZeroLengthCheck::check(const MatchFinder::MatchResult &Result) {
 
   D << FixItHint::CreateReplacement(CharSourceRange::getTokenRange(LHSRange),
                                     RHSString)
     << FixItHint::CreateReplacement(CharSourceRange::getTokenRange(RHSRange),
                                     LHSString);
 }
 
 } // namespace runtime
+} // namespace google
 } // namespace tidy
 } // namespace clang

clang-tidy/google/NamedParameterCheck.h

 //===--- NamedParameterCheck.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_GOOGLE_NAMED_PARAMETER_CHECK_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_NAMED_PARAMETER_CHECK_H
 
 #include "../ClangTidy.h"
 
 namespace clang {
 namespace tidy {
+namespace google {
 namespace readability {
 
 /// \brief Find functions with unnamed arguments.
 ///
 /// http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml?showone=Function_Declarations_and_Definitions#Function_Declarations_and_Definitions
 /// Corresponding cpplint.py check name: 'readability/function'.
 class NamedParameterCheck : public ClangTidyCheck {
 public:
   NamedParameterCheck(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 google
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_NAMED_PARAMETER_CHECK_H

clang-tidy/google/NamedParameterCheck.cpp

 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
+namespace google {
 namespace readability {
 
 void NamedParameterCheck::registerMatchers(ast_matchers::MatchFinder *Finder) {
   Finder->addMatcher(functionDecl(unless(isInstantiated())).bind("decl"), this);
 }
 
 void NamedParameterCheck::check(const MatchFinder::MatchResult &Result) {
   const SourceManager &SM = *Result.SourceManager;
for (auto P : UnnamedParams) {
       const ParmVarDecl *Parm = P.first->getParamDecl(P.second);
       D << FixItHint::CreateInsertion(Parm->getLocation(),
                                       " /*" + NewName.str() + "*/");
     }
   }
 }
 
 } // namespace readability
+} // namespace google
 } // namespace tidy
 } // namespace clang

clang-tidy/google/OverloadedUnaryAndCheck.h

 //===--- OverloadedUnaryAndCheck.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_GOOGLE_OVERLOADED_UNARY_AND_CHECK_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_OVERLOADED_UNARY_AND_CHECK_H
 
 #include "../ClangTidy.h"
 
 namespace clang {
 namespace tidy {
+namespace google {
 namespace runtime {
 
 /// \brief Finds overloads of unary operator &.
 ///
 /// http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml?showone=Operator_Overloading#Operator_Overloading
 /// Corresponding cpplint.py check name: 'runtime/operator'.
 class OverloadedUnaryAndCheck : public ClangTidyCheck {
 public:
   OverloadedUnaryAndCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
 } // namespace runtime
+} // namespace google
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_OVERLOADED_UNARY_AND_CHECK_H

clang-tidy/google/OverloadedUnaryAndCheck.cpp

 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
+namespace google {
 namespace runtime {
 
 void
 OverloadedUnaryAndCheck::registerMatchers(ast_matchers::MatchFinder *Finder) {
   // Match unary methods that overload operator&.
   Finder->addMatcher(methodDecl(parameterCountIs(0), hasOverloadedOperatorName(
                                                          "&")).bind("overload"),
                      this);

 
 void OverloadedUnaryAndCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *Decl = Result.Nodes.getNodeAs<FunctionDecl>("overload");
   diag(Decl->getLocStart(),
        "do not overload unary operator&, it is dangerous.");
 }
 
 } // namespace runtime
+} // namespace google
 } // namespace tidy
 } // namespace clang

clang-tidy/google/StringReferenceMemberCheck.h

 //===--- StringReferenceMemberCheck.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_GOOGLE_STRING_REF_MEMBER_CHECK_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_STRING_REF_MEMBER_CHECK_H
 
 #include "../ClangTidy.h"
 
 namespace clang {
 namespace tidy {
+namespace google {
 namespace runtime {
 
 /// \brief Finds members of type 'const string&'.
 ///
 /// const string reference members are generally considered unsafe as they can
 /// be created from a temporary quite easily.
 ///
 /// \code

 public:
   StringReferenceMemberCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
 } // namespace runtime
+} // namespace google
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_STRING_REF_MEMBER_CHECK_H

clang-tidy/google/StringReferenceMemberCheck.cpp

 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
+namespace google {
 namespace runtime {
 
 void StringReferenceMemberCheck::registerMatchers(
     ast_matchers::MatchFinder *Finder) {
   // Look for const references to std::string or ::string.
   auto String = anyOf(recordDecl(hasName("::std::basic_string")),
                       recordDecl(hasName("::string")));
   auto ConstString = qualType(isConstQualified(), hasDeclaration(String));
 
   // Ignore members in template instantiations.
   Finder->addMatcher(fieldDecl(hasType(references(ConstString)),
                                unless(isInstantiated())).bind("member"),
                      this);
 }
 
 void
 StringReferenceMemberCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *Member = Result.Nodes.getNodeAs<FieldDecl>("member");
   diag(Member->getLocStart(), "const string& members are dangerous. It is much "
                               "better to use alternatives, such as pointers or "
                               "simple constants.");
 }
 
 } // namespace runtime
+} // namespace google
 } // namespace tidy
 } // namespace clang

clang-tidy/google/TodoCommentCheck.h

 //===--- TodoCommentCheck.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_GOOGLE_TODOCOMMENTCHECK_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_TODOCOMMENTCHECK_H
 
 #include "../ClangTidy.h"
 
 namespace clang {
 namespace tidy {
+namespace google {
 namespace readability {
 
 /// \brief Finds TODO comments without a username or bug number.
 ///
 /// Corresponding cpplint.py check: readability/todo
 class TodoCommentCheck : public ClangTidyCheck {
 public:
   TodoCommentCheck(StringRef Name, ClangTidyContext *Context);
   void registerPPCallbacks(CompilerInstance &Compiler) override;
 
 private:
   class TodoCommentHandler;
   std::unique_ptr<TodoCommentHandler> Handler;
 };
 
 } // namespace readability
+} // namespace google
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_TODOCOMMENTCHECK_H

clang-tidy/google/TodoCommentCheck.cpp

 //===--- TodoCommentCheck.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 "TodoCommentCheck.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Lex/Preprocessor.h"
 
 namespace clang {
 namespace tidy {
+namespace google {
 namespace readability {
 
 class TodoCommentCheck::TodoCommentHandler : public CommentHandler {
 public:
   TodoCommentHandler(TodoCommentCheck &Check, llvm::Optional<std::string> User)
       : Check(Check), User(User ? *User : "unknown"),
         TodoMatch("^// *TODO *(\\(.*\\))?:?( )?(.*)$") {}
 
: ClangTidyCheck(Name, Context),
       Handler(llvm::make_unique<TodoCommentHandler>(
           *this, Context->getOptions().User)) {}
 
 void TodoCommentCheck::registerPPCallbacks(CompilerInstance &Compiler) {
   Compiler.getPreprocessor().addCommentHandler(Handler.get());
 }
 
 } // namespace readability
+} // namespace google
 } // namespace tidy
 } // namespace clang

clang-tidy/google/UnnamedNamespaceInHeaderCheck.h

 //===--- UnnamedNamespaceInHeaderCheck.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_GOOGLE_UNNAMED_NAMESPACE_IN_HEADER_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_UNNAMED_NAMESPACE_IN_HEADER_H
 
 #include "../ClangTidy.h"
 
 namespace clang {
 namespace tidy {
+namespace google {
 namespace build {
 
 /// \brief Finds anonymous namespaces in headers.
 ///
 /// http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml?showone=Namespaces#Namespaces
 /// Corresponding cpplint.py check name: 'build/namespaces'.
 class UnnamedNamespaceInHeaderCheck : public ClangTidyCheck {
 public:
   UnnamedNamespaceInHeaderCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
 } // namespace build
+} // namespace google
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_UNNAMED_NAMESPACE_IN_HEADER_H

clang-tidy/google/UnnamedNamespaceInHeaderCheck.cpp

 namespace clang {
 namespace ast_matchers {
 AST_MATCHER(NamespaceDecl, isAnonymousNamespace) {
   return Node.isAnonymousNamespace();
 }
 } // namespace ast_matchers
 
 namespace tidy {
+namespace google {
 namespace build {
 
 void UnnamedNamespaceInHeaderCheck::registerMatchers(
     ast_matchers::MatchFinder *Finder) {
   Finder->addMatcher(
       namespaceDecl(isAnonymousNamespace()).bind("anonymousNamespace"), this);
 }
 
UnnamedNamespaceInHeaderCheck::check(const MatchFinder::MatchResult &Result) {
   // TODO: Allow configuring the set of file extensions.
   StringRef FileName = SM->getPresumedLoc(Loc).getFilename();
   if (FileName.endswith(".h") || FileName.endswith(".hh") ||
       FileName.endswith(".hpp") || FileName.endswith(".hxx"))
     diag(Loc, "do not use unnamed namespaces in header files.");
 }
 
 } // namespace build
+} // namespace google
 } // namespace tidy
 } // namespace clang

clang-tidy/google/UsingNamespaceDirectiveCheck.h

 //===--- UsingNamespaceDirectiveCheck.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_GOOGLE_USING_NAMESPACE_CHECK_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_USING_NAMESPACE_CHECK_H
 
 #include "../ClangTidy.h"
 
 namespace clang {
 namespace tidy {
+namespace google {
 namespace build {
 
 /// \brief Finds using namespace directives.
 ///
 /// http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml?showone=Namespaces#Namespaces
 /// Corresponding cpplint.py check name: 'build/namespaces'.
 class UsingNamespaceDirectiveCheck : public ClangTidyCheck {
 public:
   UsingNamespaceDirectiveCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
 } // namespace build
+} // namespace google
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_USING_NAMESPACE_CHECK_H

clang-tidy/google/UsingNamespaceDirectiveCheck.cpp

 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
+namespace google {
 namespace build {
 
 void UsingNamespaceDirectiveCheck::registerMatchers(
     ast_matchers::MatchFinder *Finder) {
   Finder->addMatcher(usingDirectiveDecl().bind("usingNamespace"), this);
 }
 
 void
 UsingNamespaceDirectiveCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *U = Result.Nodes.getNodeAs<UsingDirectiveDecl>("usingNamespace");
   SourceLocation Loc = U->getLocStart();
   if (U->isImplicit() || !Loc.isValid())
     return;
 
   diag(Loc, "do not use namespace using-directives. Use using-declarations "
             "instead.");
   // TODO: We could suggest a list of using directives replacing the using
   //       namespace directive.
 }
 
 } // namespace build
+} // namespace google
 } // namespace tidy
 } // namespace clang

unittests/clang-tidy/GoogleModuleTest.cpp

 #include "ClangTidyTest.h"
 #include "google/ExplicitConstructorCheck.h"
 #include "google/GlobalNamesInHeadersCheck.h"
 #include "gtest/gtest.h"
 
+using namespace clang::tidy::google;
+
 namespace clang {
 namespace tidy {
 namespace test {
 
 TEST(ExplicitConstructorCheckTest, SingleArgumentConstructorsOnly) {
   EXPECT_NO_CHANGES(ExplicitConstructorCheck, "class C { C(); };");
   EXPECT_NO_CHANGES(ExplicitConstructorCheck, "class C { C(int i, int j); };");
   EXPECT_NO_CHANGES(ExplicitConstructorCheck, "class C { C(const C&); };");
static const char *const Header = "namespace std {\n"
                                       "}  // namespace std\n"
                                       "\n"
                                       "#define SOME_MACRO(x) using x\n";
     std::vector<ClangTidyError> Errors;
     std::vector<std::string> Args;
     if (!StringRef(Filename).endswith(".cpp")) {
       Args.emplace_back("-xc++-header");
     }
-    test::runCheckOnCode<readability::GlobalNamesInHeadersCheck>(
+    test::runCheckOnCode<GlobalNamesInHeadersCheck>(
         Header + Code, &Errors, Filename, Args);
     if (Errors.empty())
       return false;
     assert(Errors.size() == 1);
     assert(
         Errors[0].Message.Message ==
         "using declarations in the global namespace in headers are prohibited");
     return true;