[clang-tidy] Alias defintions for checks

[njames93]

Summary

Child of https://reviews.llvm.org/D72566 - just implementing the checks and a test case

[merge_guards_bot]

Unit tests: pass. 61774 tests passed, 0 failed and 780 were skipped.

clang-tidy: fail. Please fix clang-tidy findings.

clang-format: fail. Please format your changes with clang-format by running git-clang-format HEAD^ or applying this patch.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

clang-tools-extra/clang-tidy/bugprone/BugproneTidyModule.cpp

CheckFactories.registerCheck<MisplacedOperatorInStrlenInAllocCheck>(
         "bugprone-misplaced-operator-in-strlen-in-alloc");
     CheckFactories.registerCheck<MisplacedWideningCastCheck>(
         "bugprone-misplaced-widening-cast");
     CheckFactories.registerCheck<MoveForwardingReferenceCheck>(
         "bugprone-move-forwarding-reference");
     CheckFactories.registerCheck<MultipleStatementMacroCheck>(
         "bugprone-multiple-statement-macro");
     CheckFactories.registerCheck<cppcoreguidelines::NarrowingConversionsCheck>(
-        "bugprone-narrowing-conversions");
+        "bugprone-narrowing-conversions",
+        "cppcoreguidelines-narrowing-conversions");
     CheckFactories.registerCheck<NotNullTerminatedResultCheck>(
         "bugprone-not-null-terminated-result");
     CheckFactories.registerCheck<ParentVirtualCallCheck>(
         "bugprone-parent-virtual-call");
     CheckFactories.registerCheck<PosixReturnCheck>(
         "bugprone-posix-return");
     CheckFactories.registerCheck<SignedCharMisuseCheck>(
         "bugprone-signed-char-misuse");

clang-tools-extra/clang-tidy/cert/CERTTidyModule.cpp

 public:
   void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     // C++ checkers
     // DCL
     CheckFactories.registerCheck<PostfixOperatorCheck>(
         "cert-dcl21-cpp");
     CheckFactories.registerCheck<VariadicFunctionDefCheck>("cert-dcl50-cpp");
     CheckFactories.registerCheck<misc::NewDeleteOverloadsCheck>(
-        "cert-dcl54-cpp");
+        "cert-dcl54-cpp", "misc-new-delete-overloads");
     CheckFactories.registerCheck<DontModifyStdNamespaceCheck>(
         "cert-dcl58-cpp");
     CheckFactories.registerCheck<google::build::UnnamedNamespaceInHeaderCheck>(
-        "cert-dcl59-cpp");
+        "cert-dcl59-cpp", "google-build-namespaces");
     // ERR
     CheckFactories.registerCheck<misc::ThrowByValueCatchByReferenceCheck>(
-        "cert-err09-cpp");
+        "cert-err09-cpp", "misc-throw-by-value-catch-by-reference");
     CheckFactories.registerCheck<SetLongJmpCheck>("cert-err52-cpp");
     CheckFactories.registerCheck<StaticObjectExceptionCheck>("cert-err58-cpp");
     CheckFactories.registerCheck<ThrownExceptionTypeCheck>("cert-err60-cpp");
     CheckFactories.registerCheck<misc::ThrowByValueCatchByReferenceCheck>(
-        "cert-err61-cpp");
+        "cert-err61-cpp", "misc-throw-by-value-catch-by-reference");
     // MEM
     CheckFactories.registerCheck<DefaultOperatorNewAlignmentCheck>(
         "cert-mem57-cpp");
     // MSC
     CheckFactories.registerCheck<LimitedRandomnessCheck>("cert-msc50-cpp");
     CheckFactories.registerCheck<ProperlySeededRandomGeneratorCheck>(
         "cert-msc51-cpp");
     // OOP
     CheckFactories.registerCheck<performance::MoveConstructorInitCheck>(
-        "cert-oop11-cpp");
+        "cert-oop11-cpp", "performance-move-constructor-init");
     CheckFactories.registerCheck<bugprone::UnhandledSelfAssignmentCheck>(
-        "cert-oop54-cpp");
+        "cert-oop54-cpp", "bugprone-unhandled-self-assignment");
     CheckFactories.registerCheck<MutatingCopyCheck>(
         "cert-oop58-cpp");
 
     // C checkers
     // DCL
-    CheckFactories.registerCheck<misc::StaticAssertCheck>("cert-dcl03-c");
+    CheckFactories.registerCheck<misc::StaticAssertCheck>("cert-dcl03-c",
+                                                          "misc-static-assert");
     CheckFactories.registerCheck<readability::UppercaseLiteralSuffixCheck>(
-        "cert-dcl16-c");
+        "cert-dcl16-c", "readability-uppercase-literal-suffix");
     // ENV
     CheckFactories.registerCheck<CommandProcessorCheck>("cert-env33-c");
     // FLP
     CheckFactories.registerCheck<FloatLoopCounter>("cert-flp30-c");
     // FIO
-    CheckFactories.registerCheck<misc::NonCopyableObjectsCheck>("cert-fio38-c");
+    CheckFactories.registerCheck<misc::NonCopyableObjectsCheck>(
+        "cert-fio38-c", "misc-non-copyable-objects");
     // ERR
     CheckFactories.registerCheck<StrToNumCheck>("cert-err34-c");
     // MSC
     CheckFactories.registerCheck<LimitedRandomnessCheck>("cert-msc30-c");
     CheckFactories.registerCheck<ProperlySeededRandomGeneratorCheck>(
         "cert-msc32-c");
     // POS
     CheckFactories.registerCheck<bugprone::BadSignalToKillThreadCheck>(
-        "cert-pos44-c");
+        "cert-pos44-c", "bugprone-bad-signal-to-kill-thread");
   }
 
   ClangTidyOptions getModuleOptions() override {
     ClangTidyOptions Options;
     ClangTidyOptions::OptionMap &Opts = Options.CheckOptions;
     Opts["cert-dcl16-c.NewSuffixes"] = "L;LL;LU;LLU";
     Opts["cert-oop54-cpp.WarnOnlyIfThisHasSuspiciousField"] = "0";
     return Options;

clang-tools-extra/clang-tidy/cppcoreguidelines/CppCoreGuidelinesTidyModule.cpp

 namespace tidy {
 namespace cppcoreguidelines {
 
 /// A module containing checks of the C++ Core Guidelines
 class CppCoreGuidelinesModule : public ClangTidyModule {
 public:
   void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     CheckFactories.registerCheck<modernize::AvoidCArraysCheck>(
-        "cppcoreguidelines-avoid-c-arrays");
+        "cppcoreguidelines-avoid-c-arrays", "modernize-avoid-c-arrays");
     CheckFactories.registerCheck<AvoidGotoCheck>(
         "cppcoreguidelines-avoid-goto");
     CheckFactories.registerCheck<readability::MagicNumbersCheck>(
-        "cppcoreguidelines-avoid-magic-numbers");
+        "cppcoreguidelines-avoid-magic-numbers", "readability-magic-numbers");
     CheckFactories.registerCheck<modernize::UseOverrideCheck>(
-        "cppcoreguidelines-explicit-virtual-functions");
+        "cppcoreguidelines-explicit-virtual-functions",
+        "modernize-use-override");
     CheckFactories.registerCheck<InitVariablesCheck>(
         "cppcoreguidelines-init-variables");
     CheckFactories.registerCheck<InterfacesGlobalInitCheck>(
         "cppcoreguidelines-interfaces-global-init");
     CheckFactories.registerCheck<MacroUsageCheck>(
         "cppcoreguidelines-macro-usage");
     CheckFactories.registerCheck<NarrowingConversionsCheck>(
         "cppcoreguidelines-narrowing-conversions");
     CheckFactories.registerCheck<NoMallocCheck>("cppcoreguidelines-no-malloc");
     CheckFactories.registerCheck<misc::NonPrivateMemberVariablesInClassesCheck>(
-        "cppcoreguidelines-non-private-member-variables-in-classes");
+        "cppcoreguidelines-non-private-member-variables-in-classes",
+        "misc-non-private-member-variables-in-classes");
     CheckFactories.registerCheck<OwningMemoryCheck>(
         "cppcoreguidelines-owning-memory");
     CheckFactories.registerCheck<ProBoundsArrayToPointerDecayCheck>(
         "cppcoreguidelines-pro-bounds-array-to-pointer-decay");
     CheckFactories.registerCheck<ProBoundsConstantArrayIndexCheck>(
         "cppcoreguidelines-pro-bounds-constant-array-index");
     CheckFactories.registerCheck<ProBoundsPointerArithmeticCheck>(
         "cppcoreguidelines-pro-bounds-pointer-arithmetic");
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     CheckFactories.registerCheck<ProTypeUnionAccessCheck>(
         "cppcoreguidelines-pro-type-union-access");
     CheckFactories.registerCheck<ProTypeVarargCheck>(
         "cppcoreguidelines-pro-type-vararg");
     CheckFactories.registerCheck<SpecialMemberFunctionsCheck>(
         "cppcoreguidelines-special-member-functions");
     CheckFactories.registerCheck<SlicingCheck>("cppcoreguidelines-slicing");
     CheckFactories.registerCheck<misc::UnconventionalAssignOperatorCheck>(
-        "cppcoreguidelines-c-copy-assignment-signature");
+        "cppcoreguidelines-c-copy-assignment-signature",
+        "misc-unconventional-assignment-operator");
   }
 
   ClangTidyOptions getModuleOptions() override {
     ClangTidyOptions Options;
     ClangTidyOptions::OptionMap &Opts = Options.CheckOptions;
 
     Opts["cppcoreguidelines-non-private-member-variables-in-classes."
          "IgnoreClassesWithAllMemberVariablesBeingPublic"] = "1";

clang-tools-extra/clang-tidy/fuchsia/FuchsiaTidyModule.cpp

 class FuchsiaModule : public ClangTidyModule {
 public:
   void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     CheckFactories.registerCheck<DefaultArgumentsCallsCheck>(
         "fuchsia-default-arguments-calls");
     CheckFactories.registerCheck<DefaultArgumentsDeclarationsCheck>(
         "fuchsia-default-arguments-declarations");
     CheckFactories.registerCheck<google::build::UnnamedNamespaceInHeaderCheck>(
-        "fuchsia-header-anon-namespaces");
+        "fuchsia-header-anon-namespaces", "google-build-namespaces");
     CheckFactories.registerCheck<MultipleInheritanceCheck>(
         "fuchsia-multiple-inheritance");
     CheckFactories.registerCheck<OverloadedOperatorCheck>(
         "fuchsia-overloaded-operator");
     CheckFactories.registerCheck<RestrictSystemIncludesCheck>(
         "fuchsia-restrict-system-includes");
     CheckFactories.registerCheck<StaticallyConstructedObjectsCheck>(
         "fuchsia-statically-constructed-objects");

clang-tools-extra/clang-tidy/google/GoogleTidyModule.cpp

CheckFactories
         .registerCheck<readability::AvoidUnderscoreInGoogletestNameCheck>(
             "google-readability-avoid-underscore-in-googletest-name");
     CheckFactories.registerCheck<readability::AvoidCStyleCastsCheck>(
         "google-readability-casting");
     CheckFactories.registerCheck<readability::TodoCommentCheck>(
         "google-readability-todo");
     CheckFactories
         .registerCheck<clang::tidy::readability::BracesAroundStatementsCheck>(
-            "google-readability-braces-around-statements");
+            "google-readability-braces-around-statements",
+            "readability-braces-around-statements");
     CheckFactories.registerCheck<clang::tidy::readability::FunctionSizeCheck>(
-        "google-readability-function-size");
+        "google-readability-function-size", "readability-function-size");
     CheckFactories
         .registerCheck<clang::tidy::readability::NamespaceCommentCheck>(
-            "google-readability-namespace-comments");
+            "google-readability-namespace-comments",
+            "readability-namespace-comments");
     CheckFactories.registerCheck<UpgradeGoogletestCaseCheck>(
         "google-upgrade-googletest-case");
   }
 
   ClangTidyOptions getModuleOptions() override {
     ClangTidyOptions Options;
     auto &Opts = Options.CheckOptions;
     Opts["google-readability-braces-around-statements.ShortStatementLines"] =

clang-tools-extra/clang-tidy/hicpp/HICPPTidyModule.cpp

 namespace clang {
 namespace tidy {
 namespace hicpp {
 
 class HICPPModule : public ClangTidyModule {
 public:
   void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     CheckFactories.registerCheck<modernize::AvoidCArraysCheck>(
-        "hicpp-avoid-c-arrays");
+        "hicpp-avoid-c-arrays", "modernize-avoid-c-arrays");
     CheckFactories.registerCheck<cppcoreguidelines::AvoidGotoCheck>(
-        "hicpp-avoid-goto");
+        "hicpp-avoid-goto", "cppcoreguidelines-avoid-goto");
     CheckFactories.registerCheck<readability::BracesAroundStatementsCheck>(
-        "hicpp-braces-around-statements");
+        "hicpp-braces-around-statements",
+        "readability-braces-around-statements");
     CheckFactories.registerCheck<modernize::DeprecatedHeadersCheck>(
-        "hicpp-deprecated-headers");
+        "hicpp-deprecated-headers", "modernize-deprecated-headers");
     CheckFactories.registerCheck<ExceptionBaseclassCheck>(
         "hicpp-exception-baseclass");
     CheckFactories.registerCheck<MultiwayPathsCoveredCheck>(
         "hicpp-multiway-paths-covered");
     CheckFactories.registerCheck<SignedBitwiseCheck>("hicpp-signed-bitwise");
     CheckFactories.registerCheck<google::ExplicitConstructorCheck>(
-        "hicpp-explicit-conversions");
+        "hicpp-explicit-conversions", "google-explicit-constructor");
     CheckFactories.registerCheck<readability::FunctionSizeCheck>(
-        "hicpp-function-size");
+        "hicpp-function-size", "readability-function-size");
     CheckFactories.registerCheck<readability::IdentifierNamingCheck>(
-        "hicpp-named-parameter");
+        "hicpp-named-parameter", "readability-identifier-naming");
     CheckFactories.registerCheck<bugprone::UseAfterMoveCheck>(
-        "hicpp-invalid-access-moved");
+        "hicpp-invalid-access-moved", "bugprone-use-after-move");
     CheckFactories.registerCheck<cppcoreguidelines::ProTypeMemberInitCheck>(
-        "hicpp-member-init");
+        "hicpp-member-init", "cppcoreguidelines-pro-type-member-init");
     CheckFactories.registerCheck<performance::MoveConstArgCheck>(
-        "hicpp-move-const-arg");
+        "hicpp-move-const-arg", "performance-move-const-arg");
     CheckFactories.registerCheck<misc::NewDeleteOverloadsCheck>(
-        "hicpp-new-delete-operators");
+        "hicpp-new-delete-operators", "misc-new-delete-operators");
     CheckFactories.registerCheck<performance::NoexceptMoveConstructorCheck>(
-        "hicpp-noexcept-move");
+        "hicpp-noexcept-move", "performance-noexcept-move-constructor");
     CheckFactories
         .registerCheck<cppcoreguidelines::ProBoundsArrayToPointerDecayCheck>(
             "hicpp-no-array-decay");
     CheckFactories.registerCheck<NoAssemblerCheck>("hicpp-no-assembler");
     CheckFactories.registerCheck<cppcoreguidelines::NoMallocCheck>(
-        "hicpp-no-malloc");
+        "hicpp-no-malloc", "cppcoreguidelines-no-malloc");
     CheckFactories
         .registerCheck<cppcoreguidelines::SpecialMemberFunctionsCheck>(
             "hicpp-special-member-functions");
-    CheckFactories.registerCheck<misc::StaticAssertCheck>(
-        "hicpp-static-assert");
-    CheckFactories.registerCheck<modernize::UseAutoCheck>("hicpp-use-auto");
+    CheckFactories.registerCheck<misc::StaticAssertCheck>("hicpp-static-assert",
+                                                          "misc-static-assert");
+    CheckFactories.registerCheck<modernize::UseAutoCheck>("hicpp-use-auto",
+                                                          "modernize-use-auto");
     CheckFactories.registerCheck<bugprone::UndelegatedConstructorCheck>(
-        "hicpp-undelegated-constructor");
+        "hicpp-undelegated-constructor", "bugprone-undelegated-constructor");
     CheckFactories.registerCheck<modernize::UseEmplaceCheck>(
-        "hicpp-use-emplace");
+        "hicpp-use-emplace", "modernize-use-emplace");
     CheckFactories.registerCheck<modernize::UseEqualsDefaultCheck>(
-        "hicpp-use-equals-default");
+        "hicpp-use-equals-default", "modernize-use-equals-default");
     CheckFactories.registerCheck<modernize::UseEqualsDeleteCheck>(
-        "hicpp-use-equals-delete");
+        "hicpp-use-equals-delete", "modernize-use-equals-delete");
     CheckFactories.registerCheck<modernize::UseNoexceptCheck>(
-        "hicpp-use-noexcept");
+        "hicpp-use-noexcept", "modernize-use-noexcept");
     CheckFactories.registerCheck<modernize::UseNullptrCheck>(
-        "hicpp-use-nullptr");
+        "hicpp-use-nullptr", "modernize-use-nullptr");
     CheckFactories.registerCheck<modernize::UseOverrideCheck>(
-        "hicpp-use-override");
+        "hicpp-use-override", "modernize-use-override");
     CheckFactories.registerCheck<readability::UppercaseLiteralSuffixCheck>(
-        "hicpp-uppercase-literal-suffix");
+        "hicpp-uppercase-literal-suffix",
+        "readability-uppercase-literal-suffix");
     CheckFactories.registerCheck<cppcoreguidelines::ProTypeVarargCheck>(
-        "hicpp-vararg");
+        "hicpp-vararg", "cppcoreguidelines-pro-type-vararg");
   }
 };
 
 // Register the HICPPModule using this statically initialized variable.
 static ClangTidyModuleRegistry::Add<HICPPModule>
     X("hicpp-module", "Adds High-Integrity C++ checks.");
 
 } // namespace hicpp
 
 // This anchor is used to force the linker to link in the generated object file
 // and thus register the HICPPModule.
 volatile int HICPPModuleAnchorSource = 0;
 
 } // namespace tidy
 } // namespace clang

clang-tools-extra/clang-tidy/llvm/LLVMTidyModule.cpp

 namespace llvm_check {
 
 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");
+        "llvm-namespace-comment", "readability-namespace-comment");
     CheckFactories.registerCheck<PreferIsaOrDynCastInConditionalsCheck>(
         "llvm-prefer-isa-or-dyn-cast-in-conditionals");
     CheckFactories.registerCheck<PreferRegisterOverUnsignedCheck>(
         "llvm-prefer-register-over-unsigned");
     CheckFactories.registerCheck<TwineLocalCheck>("llvm-twine-local");
   }
 };
 

clang-tools-extra/clang-tidy/readability/ReadabilityTidyModule.cpp

void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     CheckFactories.registerCheck<SimplifySubscriptExprCheck>(
         "readability-simplify-subscript-expr");
     CheckFactories.registerCheck<StaticAccessedThroughInstanceCheck>(
         "readability-static-accessed-through-instance");
     CheckFactories.registerCheck<StaticDefinitionInAnonymousNamespaceCheck>(
         "readability-static-definition-in-anonymous-namespace");
     CheckFactories.registerCheck<StringCompareCheck>(
         "readability-string-compare");
-    CheckFactories.registerCheck<readability::NamedParameterCheck>(
+    CheckFactories.registerCheck<NamedParameterCheck>(
         "readability-named-parameter");
     CheckFactories.registerCheck<NonConstParameterCheck>(
         "readability-non-const-parameter");
     CheckFactories.registerCheck<RedundantControlFlowCheck>(
         "readability-redundant-control-flow");
     CheckFactories.registerCheck<RedundantDeclarationCheck>(
         "readability-redundant-declaration");
     CheckFactories.registerCheck<RedundantSmartptrGetCheck>(

clang-tools-extra/test/clang-tidy/infrastructure/duplicate-reports.cpp

-// RUN: %check_clang_tidy %s cert-err09-cpp,cert-err61-cpp %t -- -- -fexceptions
+// RUN: %check_clang_tidy %s "cert-err09-cpp,cert-err61-cpp, \
+// RUN: google-readability-braces-around-statements, \
+// RUN: readability-braces-around-statements, \
+// RUN: hicpp=braces-around-statements" %t -- -- -fexceptions
 
 void alwaysThrows() {
   int ex = 42;
-  // CHECK-MESSAGES: warning: throw expression should throw anonymous temporary values instead [cert-err09-cpp]
-  // CHECK-MESSAGES: warning: throw expression should throw anonymous temporary values instead [cert-err61-cpp]
   throw ex;
+  // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: throw expression should throw anonymous temporary values instead
+  // ^^ Dont specify which check as could be either.
+  // Original name is misc-throw-by-value-catch-by-reference.
 }
 
 void doTheJob() {
   try {
     alwaysThrows();
-  } catch (int&) {
+  } catch (int &) {
   }
 }
+
+void bracesStatements() {
+  for (;;)
+    ;
+  // CHECK-MESSAGES: :[[@LINE-2]]:11: warning: statement should be inside braces [readability-braces-around-statements]
+  // Specify check name as readability-braces-around-statements is the non
+  // aliased name of the check
+  // CHECK-FIXES:      {{^}}  for (;;) {
+  // CHECK-FIXES-NEXT: {{^}}    ;
+  // CHECK-FIXES-NEXT: {{^}}}
+}