[clang-tidy] Bring order to check registration.

[alexfh]

Summary

Register readability checks in a separate module. Renamed the checks
and test file names accordingly.

[klimek]

lg

clang-tidy/google/CMakeLists.txt

add_clang_library(clangTidyGoogleModule
   UsingNamespaceDirectiveCheck.cpp
 
   LINK_LIBS
   clangAST
   clangASTMatchers
   clangBasic
   clangLex
   clangTidy
-  clangTidyReadability
+  clangTidyReadabilityModule
   )

clang-tidy/google/GoogleTidyModule.cpp

 #include "MemsetZeroLengthCheck.h"
 #include "NamedParameterCheck.h"
 #include "OverloadedUnaryAndCheck.h"
 #include "StringReferenceMemberCheck.h"
 #include "TodoCommentCheck.h"
 #include "UnnamedNamespaceInHeaderCheck.h"
 #include "UsingNamespaceDirectiveCheck.h"
 #include "../readability/BracesAroundStatementsCheck.h"
+#include "../readability/FunctionSize.h"
 #include "../readability/NamespaceCommentCheck.h"
+#include "../readability/RedundantSmartptrGet.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 
 class GoogleModule : public ClangTidyModule {
 public:
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     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::NamespaceCommentCheck>(
-        "google-readability-namespace-comments");
     CheckFactories.registerCheck<readability::BracesAroundStatementsCheck>(
         "google-readability-braces-around-statements");
+    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"] = "1";
     Opts["google-readability-namespace-comments.SpacesBeforeComments"] = "2";
     return Options;
   }
 };
 
 // Register the GoogleTidyModule using this statically initialized variable.
 static ClangTidyModuleRegistry::Add<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/llvm/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS support)
 
 add_clang_library(clangTidyLLVMModule
   HeaderGuardCheck.cpp
   IncludeOrderCheck.cpp
   LLVMTidyModule.cpp
   TwineLocalCheck.cpp
 
   LINK_LIBS
   clangAST
   clangASTMatchers
   clangBasic
   clangLex
   clangTidy
-  clangTidyReadability
+  clangTidyReadabilityModule
   clangTidyUtils
   clangTooling
   )

clang-tidy/misc/CMakeLists.txt

add_clang_library(clangTidyMiscModule
   UseOverride.cpp
 
   LINK_LIBS
   clangAST
   clangASTMatchers
   clangBasic
   clangLex
   clangTidy
-  # Some readability checks are currently registered in the misc module.
-  clangTidyReadability
   )

clang-tidy/misc/MiscTidyModule.cpp

 //===--- MiscTidyModule.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 "../ClangTidy.h"
 #include "../ClangTidyModule.h"
 #include "../ClangTidyModuleRegistry.h"
-// FIXME: Figure out if we want to create a separate module for readability
-// checks instead of registering them here.
-#include "../readability/BracesAroundStatementsCheck.h"
-#include "../readability/FunctionSize.h"
-#include "../readability/RedundantSmartptrGet.h"
 #include "ArgumentCommentCheck.h"
 #include "BoolPointerImplicitConversion.h"
 #include "SwappedArgumentsCheck.h"
 #include "UndelegatedConstructor.h"
 #include "UnusedRAII.h"
 #include "UseOverride.h"
 
 namespace clang {
 namespace tidy {
 
 class MiscModule : public ClangTidyModule {
 public:
   void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     CheckFactories.registerCheck<ArgumentCommentCheck>("misc-argument-comment");
     CheckFactories.registerCheck<BoolPointerImplicitConversion>(
         "misc-bool-pointer-implicit-conversion");
-    CheckFactories.registerCheck<readability::BracesAroundStatementsCheck>(
-        "misc-braces-around-statements");
-    CheckFactories.registerCheck<readability::FunctionSizeCheck>(
-        "misc-function-size");
-    CheckFactories.registerCheck<readability::RedundantSmartptrGet>(
-        "misc-redundant-smartptr-get");
     CheckFactories.registerCheck<SwappedArgumentsCheck>(
         "misc-swapped-arguments");
     CheckFactories.registerCheck<UndelegatedConstructorCheck>(
         "misc-undelegated-constructor");
     CheckFactories.registerCheck<UnusedRAIICheck>("misc-unused-raii");
     CheckFactories.registerCheck<UseOverride>("misc-use-override");
   }
 };

clang-tidy/readability/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS support)
 
-add_clang_library(clangTidyReadability
+add_clang_library(clangTidyReadabilityModule
   BracesAroundStatementsCheck.cpp
   FunctionSize.cpp
   NamespaceCommentCheck.cpp
+  ReadabilityTidyModule.cpp
   RedundantSmartptrGet.cpp
 
   LINK_LIBS
   clangAST
   clangASTMatchers
   clangBasic
   clangLex
   clangTidy
   clangTooling
   )

clang-tidy/readability/ReadabilityTidyModule.cpp

+//===--- ReadabilityTidyModule.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 "../ClangTidy.h"
+#include "../ClangTidyModule.h"
+#include "../ClangTidyModuleRegistry.h"
+#include "BracesAroundStatementsCheck.h"
+#include "FunctionSize.h"
+#include "RedundantSmartptrGet.h"
+
+namespace clang {
+namespace tidy {
+namespace readability {
+
+class ReadabilityModule : public ClangTidyModule {
+public:
+  void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
+    CheckFactories.registerCheck<BracesAroundStatementsCheck>(
+        "readability-braces-around-statements");
+    CheckFactories.registerCheck<FunctionSizeCheck>(
+        "readability-function-size");
+    CheckFactories.registerCheck<RedundantSmartptrGet>(
+        "readability-redundant-smartptr-get");
+  }
+};
+
+} // namespace readability
+
+// Register the MiscTidyModule using this statically initialized variable.
+static ClangTidyModuleRegistry::Add<readability::ReadabilityModule>
+X("readability-module", "Adds readability-related checks.");
+
+// This anchor is used to force the linker to link in the generated object file
+// and thus register the MiscModule.
+volatile int ReadabilityModuleAnchorSource = 0;
+
+} // namespace tidy
+} // namespace clang

clang-tidy/tool/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   support
   )
 
 add_clang_executable(clang-tidy
   ClangTidyMain.cpp
   )
 target_link_libraries(clang-tidy
   clangAST
   clangASTMatchers
   clangTidy
   clangTidyGoogleModule
   clangTidyLLVMModule
   clangTidyMiscModule
+  clangTidyReadabilityModule
   clangTooling
   )
 
 install(TARGETS clang-tidy
   RUNTIME DESTINATION bin)
 

clang-tidy/tool/ClangTidyMain.cpp

 // This anchor is used to force the linker to link the GoogleModule.
 extern volatile int GoogleModuleAnchorSource;
 static int GoogleModuleAnchorDestination = GoogleModuleAnchorSource;
 
 // This anchor is used to force the linker to link the MiscModule.
 extern volatile int MiscModuleAnchorSource;
 static int MiscModuleAnchorDestination = MiscModuleAnchorSource;
 
+// This anchor is used to force the linker to link the ReadabilityModule.
+extern volatile int ReadabilityModuleAnchorSource;
+static int ReadabilityModuleAnchorDestination = ReadabilityModuleAnchorSource;
+
 } // namespace tidy
 } // namespace clang
 
 int main(int argc, const char **argv) {
   return clang::tidy::clangTidyMain(argc, argv);
 }

test/clang-tidy/google-module.cpp

 // RUN: clang-tidy -checks='-*,google*' -config='{}' -dump-config - -- | FileCheck %s
 // CHECK: CheckOptions:
 // CHECK: {{- key: *google-readability-braces-around-statements.ShortStatementLines}}
 // CHECK-NEXT: {{value: *'1'}}
+// CHECK: {{- key: *google-readability-function-size.StatementThreshold}}
+// CHECK-NEXT: {{value: *'800'}}
 // CHECK: {{- key: *google-readability-namespace-comments.ShortNamespaceLines}}
 // CHECK-NEXT: {{value: *'1'}}
 // CHECK: {{- key: *google-readability-namespace-comments.SpacesBeforeComments}}
 // CHECK-NEXT: {{value: *'2'}}

test/clang-tidy/google-readability-casting.c

 // RUN: $(dirname %s)/check_clang_tidy_fix.sh %s google-readability-casting %t -- -x c
 // REQUIRES: shell
 
 void f(const char *cpc) {
   const char *cpc2 = (const char*)cpc;
   // CHECK-MESSAGES: :[[@LINE-1]]:22: warning: Redundant cast to the same type. [google-readability-casting]
   // CHECK-FIXES: const char *cpc2 = cpc;
   char *pc = (char*)cpc;
 }
 

test/clang-tidy/google-readability-casting.cpp

 // RUN: $(dirname %s)/check_clang_tidy_fix.sh %s google-readability-casting %t
 // REQUIRES: shell
 
 bool g() { return false; }
 
 enum Enum { Enum1 };
 struct X {};
 struct Y : public X {};
 
 void f(int a, double b, const char *cpc, const void *cpv, X *pX) {
   const char *cpc2 = (const char*)cpc;
   // CHECK-MESSAGES: :[[@LINE-1]]:22: warning: Redundant cast to the same type. [google-readability-casting]
   // CHECK-FIXES: const char *cpc2 = cpc;
 
   char *pc = (char*)cpc;
   // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: C-style casts are discouraged. Use const_cast. {{.*}}
   // CHECK-FIXES: char *pc = const_cast<char*>(cpc);
 
   char *pc2 = (char*)(cpc + 33);
   // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: C-style casts are discouraged. Use const_cast. {{.*}}
   // CHECK-FIXES: char *pc2 = const_cast<char*>(cpc + 33);
 
   const char &crc = *cpc;
   char &rc = (char&)crc;
   // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: C-style casts are discouraged. Use const_cast. {{.*}}
   // CHECK-FIXES: char &rc = const_cast<char&>(crc);
 
   char &rc2 = (char&)*cpc;
   // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: C-style casts are discouraged. Use const_cast. {{.*}}
   // CHECK-FIXES: char &rc2 = const_cast<char&>(*cpc);
 
   char ** const* const* ppcpcpc;
   char ****ppppc = (char****)ppcpcpc;
   // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: C-style casts are discouraged. Use const_cast. {{.*}}
   // CHECK-FIXES: char ****ppppc = const_cast<char****>(ppcpcpc);
 
   char ***pppc = (char***)*(ppcpcpc);
   // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: C-style casts are discouraged. Use const_cast. {{.*}}
   // CHECK-FIXES: char ***pppc = const_cast<char***>(*(ppcpcpc));
 
   char ***pppc2 = (char***)(*ppcpcpc);
   // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: C-style casts are discouraged. Use const_cast. {{.*}}
   // CHECK-FIXES: char ***pppc2 = const_cast<char***>(*ppcpcpc);
 
   char *pc5 = (char*)(const char*)(cpv);
   // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: C-style casts are discouraged. Use const_cast. {{.*}}
   // CHECK-MESSAGES: :[[@LINE-2]]:22: warning: C-style casts are discouraged. Use reinterpret_cast. {{.*}}
   // CHECK-FIXES: char *pc5 = const_cast<char*>(reinterpret_cast<const char*>(cpv));
 
   int b1 = (int)b;
   // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: C-style casts are discouraged. Use static_cast. [google-readability-casting]
   // CHECK-FIXES: int b1 = static_cast<int>(b);
 
   Y *pB = (Y*)pX;
   // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: C-style casts are discouraged. Use static_cast/const_cast/reinterpret_cast. [google-readability-casting]
   Y &rB = (Y&)*pX;
   // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: C-style casts are discouraged. Use static_cast/const_cast/reinterpret_cast. [google-readability-casting]
 
   const char *pc3 = (const char*)cpv;
   // CHECK-MESSAGES: :[[@LINE-1]]:21: warning: C-style casts are discouraged. Use reinterpret_cast. [google-readability-casting]
   // CHECK-FIXES: const char *pc3 = reinterpret_cast<const char*>(cpv);
 
   char *pc4 = (char*)cpv;
   // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: C-style casts are discouraged. Use static_cast/const_cast/reinterpret_cast. [google-readability-casting]
   // CHECK-FIXES: char *pc4 = (char*)cpv;
 
   b1 = (int)Enum1;
   // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: C-style casts are discouraged. Use static_cast. [google-readability-casting]
   // CHECK-FIXES: b1 = static_cast<int>(Enum1);
 
   Enum e = (Enum)b1;
   // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: C-style casts are discouraged. Use static_cast. [google-readability-casting]
   // CHECK-FIXES: Enum e = static_cast<Enum>(b1);
 
   // CHECK-MESSAGES-NOT: warning:
   int b2 = int(b);
   int b3 = static_cast<double>(b);
   int b4 = b;
   double aa = a;
   (void)b2;
   return (void)g();
 }
 
 template <typename T>
 void template_function(T t, int n) {
   int i = (int)t;
   // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: C-style casts are discouraged. Use static_cast/const_cast/reinterpret_cast.
   // CHECK-FIXES: int i = (int)t;
   int j = (int)n;
   // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: Redundant cast to the same type.
   // CHECK-FIXES: int j = n;
 }
 
 template <typename T>
 struct TemplateStruct {
   void f(T t, int n) {
     int k = (int)t;
     // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: C-style casts are discouraged. Use static_cast/const_cast/reinterpret_cast.
     // CHECK-FIXES: int k = (int)t;
     int l = (int)n;
     // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: Redundant cast to the same type.
     // CHECK-FIXES: int l = n;
   }
 };
 
 void test_templates() {
   template_function(1, 42);
   template_function(1.0, 42);
   TemplateStruct<int>().f(1, 42);
   TemplateStruct<double>().f(1.0, 42);
 }
 
 #define CAST(type, value) (type)(value)
 void macros(double d) {
   int i = CAST(int, d);
 }
 
 enum E { E1 = 1 };
 template <E e>
 struct A {
   // Usage of template argument e = E1 is represented as (E)1 in the AST for
   // some reason. We have a special treatment of this case to avoid warnings
   // here.
   static const E ee = e;
 };
 struct B : public A<E1> {};
 

test/clang-tidy/misc-use-override.cpp

 // RUN: $(dirname %s)/check_clang_tidy_fix.sh %s misc-use-override %t
 // REQUIRES: shell
 
 #define ABSTRACT = 0
 
 #define OVERRIDE override
 #define VIRTUAL virtual
 #define NOT_VIRTUAL
 #define NOT_OVERRIDE
 
 #define MUST_USE_RESULT __attribute__((warn_unused_result))
 
 struct MUST_USE_RESULT MustUseResultObject {};
 
 struct Base {
   virtual ~Base() {}
   virtual void a();
   virtual void b();
   virtual void c();
   virtual void d();
   virtual void e() = 0;
   virtual void f() = 0;
   virtual void g() = 0;
 
   virtual void j() const;
   virtual MustUseResultObject k();
   virtual bool l() MUST_USE_RESULT;
 
   virtual void m();
 };
 
 struct SimpleCases : public Base {
 public:
   virtual ~SimpleCases();
   // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: Prefer using 'override' or (rarely) 'final' instead of 'virtual'
   // CHECK-FIXES: {{^  ~SimpleCases\(\) override;}}
 
   void a();
   // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: Annotate this
   // CHECK-FIXES: {{^  void a\(\) override;}}
 
   void b() override;
   // CHECK-MESSAGES-NOT: warning:
   // CHECK-FIXES: {{^  void b\(\) override;}}
 
   virtual void c();
   // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: Prefer using
   // CHECK-FIXES: {{^  void c\(\) override;}}
 
   virtual void d() override;
   // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: Annotate this
   // CHECK-FIXES: {{^  void d\(\) override;}}
 
   virtual void e() = 0;
   // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: Prefer using
   // CHECK-FIXES: {{^  void e\(\) override = 0;}}
 
   virtual void f()=0;
   // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: Prefer using
   // CHECK-FIXES: {{^  void f\(\)override =0;}}
 
   virtual void g() ABSTRACT;
   // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: Prefer using
   // CHECK-FIXES: {{^  void g\(\) override ABSTRACT;}}
 
   virtual void j() const;
   // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: Prefer using
   // CHECK-FIXES: {{^  void j\(\) const override;}}
 
   virtual MustUseResultObject k();  // Has an implicit attribute.
   // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: Prefer using
   // CHECK-FIXES: {{^  MustUseResultObject k\(\) override;}}
 
   virtual bool l() MUST_USE_RESULT; // Has an explicit attribute
   // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: Prefer using
   // CHECK-FIXES: {{^  bool l\(\) override MUST_USE_RESULT;}}
 
   virtual void m() override final;
   // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: Annotate this
   // CHECK-FIXES: {{^  void m\(\) final;}}
 };
 
 // CHECK-MESSAGES-NOT: warning:
 
 void SimpleCases::c() {}
 // CHECK-FIXES: {{^void SimpleCases::c\(\) {}}}
 
 SimpleCases::~SimpleCases() {}
 // CHECK-FIXES: {{^SimpleCases::~SimpleCases\(\) {}}}
 
 struct DefaultedDestructor : public Base {
   DefaultedDestructor() {}
   virtual ~DefaultedDestructor() = default;
   // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: Prefer using
   // CHECK-FIXES: {{^  ~DefaultedDestructor\(\) override = default;}}
 };
 
 struct FinalSpecified : public Base {
 public:
   virtual ~FinalSpecified() final;
   // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: Annotate this
   // CHECK-FIXES: {{^  ~FinalSpecified\(\) final;}}
 
   void b() final;
   // CHECK-MESSAGES-NOT: warning:
   // CHECK-FIXES: {{^  void b\(\) final;}}
 
   virtual void d() final;
   // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: Annotate this
   // CHECK-FIXES: {{^  void d\(\) final;}}
 
   virtual void e() final = 0;
   // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: Annotate this
   // CHECK-FIXES: {{^  void e\(\) final = 0;}}
 
   virtual void j() const final;
   // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: Annotate this
   // CHECK-FIXES: {{^  void j\(\) const final;}}
 
   virtual bool l() final MUST_USE_RESULT;
   // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: Annotate this
   // CHECK-FIXES: {{^  bool l\(\) final MUST_USE_RESULT;}}
 };
 
 struct InlineDefinitions : public Base {
 public:
   virtual ~InlineDefinitions() {}
   // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: Prefer using
   // CHECK-FIXES: {{^  ~InlineDefinitions\(\) override {}}}
 
   void a() {}
   // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: Annotate this
   // CHECK-FIXES: {{^  void a\(\) override {}}}
 
   void b() override {}
   // CHECK-MESSAGES-NOT: warning:
   // CHECK-FIXES: {{^  void b\(\) override {}}}
 
   virtual void c() {}
   // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: Prefer using
   // CHECK-FIXES: {{^  void c\(\) override {}}}
 
   virtual void d() override {}
   // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: Annotate this
   // CHECK-FIXES: {{^  void d\(\) override {}}}
 
   virtual void j() const {}
   // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: Prefer using
   // CHECK-FIXES: {{^  void j\(\) const override {}}}
 
   virtual MustUseResultObject k() {}  // Has an implicit attribute.
   // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: Prefer using
   // CHECK-FIXES: {{^  MustUseResultObject k\(\) override {}}}
 
   virtual bool l() MUST_USE_RESULT {} // Has an explicit attribute
   // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: Prefer using
   // CHECK-FIXES: {{^  bool l\(\) override MUST_USE_RESULT {}}}
 };
 
 struct Macros : public Base {
   // Tests for 'virtual' and 'override' being defined through macros. Basically
   // give up for now.
   NOT_VIRTUAL void a() NOT_OVERRIDE;
   // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: Annotate this
   // CHECK-FIXES: {{^  NOT_VIRTUAL void a\(\) override NOT_OVERRIDE;}}
 
   VIRTUAL void b() NOT_OVERRIDE;
   // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: Prefer using
   // CHECK-FIXES: {{^  VIRTUAL void b\(\) override NOT_OVERRIDE;}}
 
   NOT_VIRTUAL void c() OVERRIDE;
   // CHECK-MESSAGES-NOT: warning:
   // CHECK-FIXES: {{^  NOT_VIRTUAL void c\(\) OVERRIDE;}}
 
   VIRTUAL void d() OVERRIDE;
   // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: Annotate this
   // CHECK-FIXES: {{^  VIRTUAL void d\(\) OVERRIDE;}}
 
 #define FUNC(return_type, name) return_type name()
   FUNC(void, e);
   // CHECK-FIXES: {{^  FUNC\(void, e\);}}
 
 #define F virtual void f();
   F
   // CHECK-FIXES: {{^  F}}
 
   VIRTUAL void g() OVERRIDE final;
   // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: Annotate this
   // CHECK-FIXES: {{^  VIRTUAL void g\(\) final;}}
 };
 
 // Tests for templates.
 template <typename T> struct TemplateBase {
   virtual void f(T t);
 };
 
 template <typename T> struct DerivedFromTemplate : public TemplateBase<T> {
   virtual void f(T t);
   // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: Prefer using
   // CHECK-FIXES: {{^  void f\(T t\) override;}}
 };
 void f() { DerivedFromTemplate<int>().f(2); }
 
 template <class C>
 struct UnusedMemberInstantiation : public C {
   virtual ~UnusedMemberInstantiation() {}
   // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: Prefer using
   // CHECK-FIXES: {{^  ~UnusedMemberInstantiation\(\) override {}}}
 };
 struct IntantiateWithoutUse : public UnusedMemberInstantiation<Base> {};
 
 struct Base2 {
   virtual ~Base2() {}
   virtual void a();
 };
 
 // The OverrideAttr isn't propagated to specializations in all cases. Make sure
 // we don't add "override" a second time.
 template <int I>
 struct MembersOfSpecializations : public Base2 {
   void a() override;
   // CHECK-MESSAGES-NOT: warning:
   // CHECK-FIXES: {{^  void a\(\) override;}}
 };
 template <> void MembersOfSpecializations<3>::a() {}
 void ff() { MembersOfSpecializations<3>().a(); };
 

test/clang-tidy/readability-braces-around-statements-few-lines.cpp

-// RUN: $(dirname %s)/check_clang_tidy_fix.sh %s misc-braces-around-statements %t -config="{CheckOptions: [{key: misc-braces-around-statements.ShortStatementLines, value: 4}]}" --
+// RUN: $(dirname %s)/check_clang_tidy_fix.sh %s readability-braces-around-statements %t -config="{CheckOptions: [{key: readability-braces-around-statements.ShortStatementLines, value: 4}]}" --
 // REQUIRES: shell
 
 void do_something(const char *) {}
 
 bool cond(const char *) {
   return false;
 }
 

test/clang-tidy/readability-braces-around-statements-same-line.cpp

-// RUN: $(dirname %s)/check_clang_tidy_fix.sh %s misc-braces-around-statements %t -config="{CheckOptions: [{key: misc-braces-around-statements.ShortStatementLines, value: 1}]}" --
+// RUN: $(dirname %s)/check_clang_tidy_fix.sh %s readability-braces-around-statements %t -config="{CheckOptions: [{key: readability-braces-around-statements.ShortStatementLines, value: 1}]}" --
 // REQUIRES: shell
 
 void do_something(const char *) {}
 
 bool cond(const char *) {
   return false;
 }
 

test/clang-tidy/readability-braces-around-statements-single-line.cpp

-// RUN: $(dirname %s)/check_clang_tidy_fix.sh %s misc-braces-around-statements %t -config="{CheckOptions: [{key: misc-braces-around-statements.ShortStatementLines, value: 2}]}" --
+// RUN: $(dirname %s)/check_clang_tidy_fix.sh %s readability-braces-around-statements %t -config="{CheckOptions: [{key: readability-braces-around-statements.ShortStatementLines, value: 2}]}" --
 // REQUIRES: shell
 
 void do_something(const char *) {}
 
 bool cond(const char *) {
   return false;
 }
 

test/clang-tidy/readability-braces-around-statements.cpp

-// RUN: $(dirname %s)/check_clang_tidy_fix.sh %s misc-braces-around-statements %t
+// RUN: $(dirname %s)/check_clang_tidy_fix.sh %s readability-braces-around-statements %t
 // REQUIRES: shell
 
 void do_something(const char *) {}
 
 bool cond(const char *) {
   return false;
 }
 

test/clang-tidy/readability-function-size.cpp

 // RUN: rm -rf %t
 // RUN: mkdir -p %t
 // RUN: sed 's#// *[A-Z-][A-Z-]*:.*#//#' %s > %t/t.cpp
-// RUN: echo '{ Checks: "-*,misc-function-size", CheckOptions: [{key: misc-function-size.LineThreshold, value: 0}, {key: misc-function-size.StatementThreshold, value: 0}, {key: misc-function-size.BranchThreshold, value: 0}]}' > %t/.clang-tidy
+// RUN: echo '{ Checks: "-*,readability-function-size", CheckOptions: [{key: readability-function-size.LineThreshold, value: 0}, {key: readability-function-size.StatementThreshold, value: 0}, {key: readability-function-size.BranchThreshold, value: 0}]}' > %t/.clang-tidy
 // RUN: clang-tidy %t/t.cpp -- -std=c++11 2>&1 | FileCheck %s -implicit-check-not='{{warning:|error:|note:}}'
 
 void foo1() {
 }
 
 void foo2() {;}
 // CHECK: warning: function 'foo2' exceeds recommended size/complexity thresholds
 // CHECK: note: 1 statements (threshold 0)

test/clang-tidy/readability-redundant-smartptr-get.cpp

-// RUN: $(dirname %s)/check_clang_tidy_fix.sh %s misc-redundant-smartptr-get %t
+// RUN: $(dirname %s)/check_clang_tidy_fix.sh %s readability-redundant-smartptr-get %t
 // REQUIRES: shell
 
 #define NULL __null
 
 namespace std {
 
 template <typename T>
 struct unique_ptr {
struct Fail2 {
   int* operator->();
   int& operator*();
 };
 
 void Positive() {
   BarPtr u;
   // CHECK-FIXES: BarPtr u;
   BarPtr().get()->Do();
-  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: Redundant get() call on smart pointer. [misc-redundant-smartptr-get]
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: Redundant get() call on smart pointer. [readability-redundant-smartptr-get]
   // CHECK-MESSAGES: BarPtr().get()->Do();
   // CHECK-FIXES: BarPtr()->Do();
 
   u.get()->ConstDo();
   // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: Redundant get() call on smart pointer.
   // CHECK-MESSAGES: u.get()->ConstDo();
   // CHECK-FIXES: u->ConstDo();
 

unittests/clang-tidy/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   support
   )
 
 get_filename_component(CLANG_LINT_SOURCE_DIR
   ${CMAKE_CURRENT_SOURCE_DIR}/../../clang-tidy REALPATH)
 include_directories(${CLANG_LINT_SOURCE_DIR})
 
 add_extra_unittest(ClangTidyTests
   ClangTidyDiagnosticConsumerTest.cpp
   ClangTidyOptionsTest.cpp
-  LLVMModuleTest.cpp
-  ReadabilityChecksTest.cpp
   GoogleModuleTest.cpp
-  MiscModuleTest.cpp)
+  LLVMModuleTest.cpp
+  MiscModuleTest.cpp
+  ReadabilityModuleTest.cpp)
 
 target_link_libraries(ClangTidyTests
   clangAST
   clangASTMatchers
   clangBasic
   clangFrontend
   clangTidy
   clangTidyGoogleModule
   clangTidyLLVMModule
   clangTidyMiscModule
-  clangTidyReadability
+  clangTidyReadabilityModule
   clangTidyUtils
   clangTooling
   )

unittests/clang-tidy/ReadabilityModuleTest.cpp

 #include "ClangTidyTest.h"
 #include "readability/NamespaceCommentCheck.h"
 #include "gtest/gtest.h"
 
 namespace clang {
 namespace tidy {
 namespace test {
 
 using readability::NamespaceCommentCheck;
 
 TEST(NamespaceCommentCheckTest, Basic) {
   EXPECT_EQ("namespace i {\n} // namespace i",
             runCheckOnCode<NamespaceCommentCheck>("namespace i {\n}"));
   EXPECT_EQ("namespace {\n} // namespace",
             runCheckOnCode<NamespaceCommentCheck>("namespace {\n}"));
   EXPECT_EQ(
       "namespace i { namespace j {\n} // namespace j\n } // namespace i",
       runCheckOnCode<NamespaceCommentCheck>("namespace i { namespace j {\n} }"));
 }
 
 TEST(NamespaceCommentCheckTest, SingleLineNamespaces) {
   EXPECT_EQ(
       "namespace i { namespace j { } }",
       runCheckOnCode<NamespaceCommentCheck>("namespace i { namespace j { } }"));
 }
 
 TEST(NamespaceCommentCheckTest, CheckExistingComments) {
   EXPECT_EQ("namespace i { namespace j {\n"
             "} /* namespace j */ } // namespace i\n"
             " /* random comment */",
             runCheckOnCode<NamespaceCommentCheck>(
                 "namespace i { namespace j {\n"
                 "} /* namespace j */ } /* random comment */"));
   EXPECT_EQ("namespace {\n"
             "} // namespace",
             runCheckOnCode<NamespaceCommentCheck>("namespace {\n"
                                                   "} // namespace"));
   EXPECT_EQ("namespace {\n"
             "} //namespace",
             runCheckOnCode<NamespaceCommentCheck>("namespace {\n"
                                                   "} //namespace"));
   EXPECT_EQ("namespace {\n"
             "} // anonymous namespace",
             runCheckOnCode<NamespaceCommentCheck>("namespace {\n"
                                                   "} // anonymous namespace"));
   EXPECT_EQ("namespace {\n"
             "} // Anonymous namespace.",
             runCheckOnCode<NamespaceCommentCheck>("namespace {\n"
                                                   "} // Anonymous namespace."));
   EXPECT_EQ("namespace q {\n"
             "} // namespace q",
             runCheckOnCode<NamespaceCommentCheck>("namespace q {\n"
                                                   "} // anonymous namespace q"));
   EXPECT_EQ(
       "namespace My_NameSpace123 {\n"
       "} // namespace My_NameSpace123",
       runCheckOnCode<NamespaceCommentCheck>("namespace My_NameSpace123 {\n"
                                             "} // namespace My_NameSpace123"));
   EXPECT_EQ(
       "namespace My_NameSpace123 {\n"
       "} //namespace My_NameSpace123",
       runCheckOnCode<NamespaceCommentCheck>("namespace My_NameSpace123 {\n"
                                             "} //namespace My_NameSpace123"));
   EXPECT_EQ("namespace My_NameSpace123 {\n"
             "} //  end namespace   My_NameSpace123",
             runCheckOnCode<NamespaceCommentCheck>(
                 "namespace My_NameSpace123 {\n"
                 "} //  end namespace   My_NameSpace123"));
   // Understand comments only on the same line.
   EXPECT_EQ("namespace {\n"
             "} // namespace\n"
             "// namespace",
             runCheckOnCode<NamespaceCommentCheck>("namespace {\n"
                                                   "}\n"
                                                   "// namespace"));
   // Leave unknown comments.
   EXPECT_EQ("namespace {\n"
             "} // namespace // random text",
             runCheckOnCode<NamespaceCommentCheck>("namespace {\n"
                                                   "} // random text"));
 }
 
 TEST(NamespaceCommentCheckTest, FixWrongComments) {
   EXPECT_EQ("namespace i { namespace jJ0_ {\n"
             "} // namespace jJ0_\n"
             " } // namespace i\n"
             " /* random comment */",
             runCheckOnCode<NamespaceCommentCheck>(
                 "namespace i { namespace jJ0_ {\n"
                 "} /* namespace qqq */ } /* random comment */"));
   EXPECT_EQ("namespace {\n"
             "} // namespace",
             runCheckOnCode<NamespaceCommentCheck>("namespace {\n"
                                                   "} // namespace asdf"));
 }
 
 } // namespace test
 } // namespace tidy
 } // namespace clang