[clang-tidy] Another batch of checks to rename from misc- to bugprone-.

[alexfh]

Summary

clang-tidy/rename_check.py {misc,bugprone}-suspicious-semicolon
clang-tidy/rename_check.py {misc,bugprone}-suspicious-string-compare
clang-tidy/rename_check.py {misc,bugprone}-swapped-arguments
clang-tidy/rename_check.py {misc,bugprone}-undelegated-constructor --check_class_name UndelegatedConstructor

[aaron.ballman]

LGTM with a couple of drive-by nits that could be fixed if you wanted to.

docs/clang-tidy/checks/bugprone-swapped-arguments.rst

6

Can get rid of the extra newline while you're at it.

docs/clang-tidy/checks/bugprone-undelegated-constructor.rst

6

Same here, if you'd like.

[Eugene.Zelenko]

docs/ReleaseNotes.rst

60

Please sort checks alphabetically. Will be also good idea to move renamed checks after new checks/modules.

[alexfh]

docs/ReleaseNotes.rst

60

I've sorted the entries manually. I hope I can change the rename_check.py script to insert new notes into the right place in the list.

clang-tidy/bugprone/BugproneTidyModule.cpp

 #include "MoveForwardingReferenceCheck.h"
 #include "MultipleStatementMacroCheck.h"
 #include "StringConstructorCheck.h"
 #include "StringIntegerAssignmentCheck.h"
 #include "StringLiteralWithEmbeddedNulCheck.h"
 #include "SuspiciousEnumUsageCheck.h"
 #include "SuspiciousMemsetUsageCheck.h"
 #include "SuspiciousMissingCommaCheck.h"
+#include "SuspiciousSemicolonCheck.h"
+#include "SuspiciousStringCompareCheck.h"
+#include "SwappedArgumentsCheck.h"
 #include "ThrowKeywordMissingCheck.h"
 #include "UndefinedMemoryManipulationCheck.h"
+#include "UndelegatedConstructorCheck.h"
 #include "UseAfterMoveCheck.h"
 #include "VirtualNearMissCheck.h"
 
 namespace clang {
 namespace tidy {
 namespace bugprone {
 
 class BugproneModule : public ClangTidyModule {
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     CheckFactories.registerCheck<StringLiteralWithEmbeddedNulCheck>(
         "bugprone-string-literal-with-embedded-nul");
     CheckFactories.registerCheck<SuspiciousEnumUsageCheck>(
         "bugprone-suspicious-enum-usage");
     CheckFactories.registerCheck<SuspiciousMemsetUsageCheck>(
         "bugprone-suspicious-memset-usage");
     CheckFactories.registerCheck<SuspiciousMissingCommaCheck>(
         "bugprone-suspicious-missing-comma");
+    CheckFactories.registerCheck<SuspiciousSemicolonCheck>(
+        "bugprone-suspicious-semicolon");
+    CheckFactories.registerCheck<SuspiciousStringCompareCheck>(
+        "bugprone-suspicious-string-compare");
+    CheckFactories.registerCheck<SwappedArgumentsCheck>(
+        "bugprone-swapped-arguments");
     CheckFactories.registerCheck<ThrowKeywordMissingCheck>(
         "bugprone-throw-keyword-missing");
     CheckFactories.registerCheck<UndefinedMemoryManipulationCheck>(
         "bugprone-undefined-memory-manipulation");
+    CheckFactories.registerCheck<UndelegatedConstructorCheck>(
+        "bugprone-undelegated-constructor");
     CheckFactories.registerCheck<UseAfterMoveCheck>(
         "bugprone-use-after-move");
     CheckFactories.registerCheck<VirtualNearMissCheck>(
         "bugprone-virtual-near-miss");
   }
 };
 
 } // namespace bugprone

clang-tidy/bugprone/CMakeLists.txt

add_clang_library(clangTidyBugproneModule
   MoveForwardingReferenceCheck.cpp
   MultipleStatementMacroCheck.cpp
   StringConstructorCheck.cpp
   StringIntegerAssignmentCheck.cpp
   StringLiteralWithEmbeddedNulCheck.cpp
   SuspiciousEnumUsageCheck.cpp
   SuspiciousMemsetUsageCheck.cpp
   SuspiciousMissingCommaCheck.cpp
+  SuspiciousSemicolonCheck.cpp
+  SuspiciousStringCompareCheck.cpp
+  SwappedArgumentsCheck.cpp
   ThrowKeywordMissingCheck.cpp
   UndefinedMemoryManipulationCheck.cpp
+  UndelegatedConstructorCheck.cpp
   UseAfterMoveCheck.cpp
   VirtualNearMissCheck.cpp
 
   LINK_LIBS
   clangAnalysis
   clangAST
   clangASTMatchers
   clangBasic
   clangLex
   clangTidy
   clangTidyUtils
   clangTooling
   )

clang-tidy/bugprone/SuspiciousSemicolonCheck.h

 //===--- SuspiciousSemicolonCheck.h - clang-tidy-----------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_SUSPICIOUS_SEMICOLON_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_SUSPICIOUS_SEMICOLON_H
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SUSPICIOUSSEMICOLONCHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SUSPICIOUSSEMICOLONCHECK_H
 
 #include "../ClangTidy.h"
 
 namespace clang {
 namespace tidy {
-namespace misc {
+namespace bugprone {
 
 /// This check finds semicolon that modifies the meaning of the program
 /// unintendedly.
 ///
 /// For the user-facing documentation see:
-/// http://clang.llvm.org/extra/clang-tidy/checks/misc-suspicious-semicolon.html
+/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-suspicious-semicolon.html
 class SuspiciousSemicolonCheck : public ClangTidyCheck {
 public:
   SuspiciousSemicolonCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
-} // namespace misc
+} // namespace bugprone
 } // namespace tidy
 } // namespace clang
 
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_SUSPICIOUS_SEMICOLON_H
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SUSPICIOUSSEMICOLONCHECK_H

clang-tidy/bugprone/SuspiciousSemicolonCheck.cpp

 #include "../utils/LexerUtils.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
-namespace misc {
+namespace bugprone {
 
 void SuspiciousSemicolonCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(
       stmt(anyOf(ifStmt(hasThen(nullStmt().bind("semi")),
                         unless(hasElse(stmt()))),
                  forStmt(hasBody(nullStmt().bind("semi"))),
                  cxxForRangeStmt(hasBody(nullStmt().bind("semi"))),
                  whileStmt(hasBody(nullStmt().bind("semi")))))
void SuspiciousSemicolonCheck::check(const MatchFinder::MatchResult &Result) {
   if (!IsIfStmt && NewTokenIndent <= BaseIndent &&
       Token.getKind() != tok::l_brace && NewTokenLine != SemicolonLine)
     return;
 
   diag(LocStart, "potentially unintended semicolon")
       << FixItHint::CreateRemoval(SourceRange(LocStart, LocEnd));
 }
 
-} // namespace misc
+} // namespace bugprone
 } // namespace tidy
 } // namespace clang

clang-tidy/bugprone/SuspiciousStringCompareCheck.h

 //===--- SuspiciousStringCompareCheck.h - clang-tidy-------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_SUSPICIOUS_STRING_COMPARE_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_SUSPICIOUS_STRING_COMPARE_H
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SUSPICIOUSSTRINGCOMPARECHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SUSPICIOUSSTRINGCOMPARECHECK_H
 
 #include "../ClangTidy.h"
 
 namespace clang {
 namespace tidy {
-namespace misc {
+namespace bugprone {
 
 /// Find suspicious calls to string compare functions.
 ///
 /// For the user-facing documentation see:
-/// http://clang.llvm.org/extra/clang-tidy/checks/misc-suspicious-string-compare.html
+/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-suspicious-string-compare.html
 class SuspiciousStringCompareCheck : public ClangTidyCheck {
 public:
   SuspiciousStringCompareCheck(StringRef Name, ClangTidyContext *Context);
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
   const bool WarnOnImplicitComparison;
   const bool WarnOnLogicalNotComparison;
   const std::string StringCompareLikeFunctions;
 };
 
-} // namespace misc
+} // namespace bugprone
 } // namespace tidy
 } // namespace clang
 
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_SUSPICIOUS_STRING_COMPARE_H
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SUSPICIOUSSTRINGCOMPARECHECK_H

clang-tidy/bugprone/SuspiciousStringCompareCheck.cpp

 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/Lex/Lexer.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
-namespace misc {
+namespace bugprone {
 
 // Semicolon separated list of known string compare-like functions. The list
 // must ends with a semicolon.
 static const char KnownStringCompareFunctions[] = "__builtin_memcmp;"
                                                   "__builtin_strcasecmp;"
                                                   "__builtin_strcmp;"
                                                   "__builtin_strncasecmp;"
                                                   "__builtin_strncmp;"
void SuspiciousStringCompareCheck::check(
   }
 
   if (Result.Nodes.getNodeAs<Stmt>("invalid-conversion")) {
     diag(Call->getLocStart(), "function %0 has suspicious implicit cast")
         << Decl;
   }
 }
 
-} // namespace misc
+} // namespace bugprone
 } // namespace tidy
 } // namespace clang

clang-tidy/bugprone/SwappedArgumentsCheck.h

 //===--- SwappedArgumentsCheck.h - clang-tidy -------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_SWAPPEDARGUMENTSCHECK_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_SWAPPEDARGUMENTSCHECK_H
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SWAPPEDARGUMENTSCHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SWAPPEDARGUMENTSCHECK_H
 
 #include "../ClangTidy.h"
 
 namespace clang {
 namespace tidy {
-namespace misc {
+namespace bugprone {
 
 /// Finds potentially swapped arguments by looking at implicit conversions.
 class SwappedArgumentsCheck : public ClangTidyCheck {
 public:
   SwappedArgumentsCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
-} // namespace misc
+} // namespace bugprone
 } // namespace tidy
 } // namespace clang
 
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_SWAPPEDARGUMENTSCHECK_H
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SWAPPEDARGUMENTSCHECK_H

clang-tidy/bugprone/SwappedArgumentsCheck.cpp

 #include "clang/Lex/Lexer.h"
 #include "clang/Tooling/FixIt.h"
 #include "llvm/ADT/SmallPtrSet.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
-namespace misc {
+namespace bugprone {
 
 void SwappedArgumentsCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(callExpr().bind("call"), this);
 }
 
 /// \brief Look through lvalue to rvalue and nop casts. This filters out
 /// implicit conversions that have no effect on the input but block our view for
 /// other implicit casts.
diag(Call->getLocStart(), "argument with implicit conversion from %0 "
         << tooling::fixit::createReplacement(*LHS, *RHS, Ctx)
         << tooling::fixit::createReplacement(*RHS, *LHS, Ctx);
 
     // Remember that we emitted a warning for this argument.
     UsedArgs.insert(RHSCast);
   }
 }
 
-} // namespace misc
+} // namespace bugprone
 } // namespace tidy
 } // namespace clang

clang-tidy/bugprone/UndelegatedConstructorCheck.h

-//===--- UndelegatedConstructor.h - clang-tidy ------------------*- C++ -*-===//
+//===--- UndelegatedConstructorCheck.h - clang-tidy -------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNDELEGATEDCONSTRUCTOR_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNDELEGATEDCONSTRUCTOR_H
 
 #include "../ClangTidy.h"
 
 namespace clang {
 namespace tidy {
-namespace misc {
+namespace bugprone {
 
 /// Finds creation of temporary objects in constructors that look like a
 /// function call to another constructor of the same class.
 ///
 /// The user most likely meant to use a delegating constructor or base class
 /// initializer.
 class UndelegatedConstructorCheck : public ClangTidyCheck {
 public:
   UndelegatedConstructorCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
-} // namespace misc
+} // namespace bugprone
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNDELEGATEDCONSTRUCTOR_H

clang-tidy/bugprone/UndelegatedConstructorCheck.cpp

-//===--- UndelegatedConstructor.cpp - clang-tidy --------------------------===//
+//===--- UndelegatedConstructorCheck.cpp - clang-tidy --------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#include "UndelegatedConstructor.h"
+#include "UndelegatedConstructorCheck.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/Lex/Lexer.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
-namespace misc {
+namespace bugprone {
 
 namespace {
 AST_MATCHER_P(Stmt, ignoringTemporaryExpr,
               ast_matchers::internal::Matcher<Stmt>, InnerMatcher) {
   const Stmt *E = &Node;
   for (;;) {
     // Temporaries with non-trivial dtors.
     if (const auto *EWC = dyn_cast<ExprWithCleanups>(E))

 
 void UndelegatedConstructorCheck::check(
     const MatchFinder::MatchResult &Result) {
   const auto *E = Result.Nodes.getNodeAs<CXXConstructExpr>("construct");
   diag(E->getLocStart(), "did you intend to call a delegated constructor? "
                          "A temporary object is created here instead");
 }
 
-} // namespace misc
+} // namespace bugprone
 } // namespace tidy
 } // namespace clang

clang-tidy/hicpp/HICPPTidyModule.cpp

 #include "../cppcoreguidelines/ProBoundsArrayToPointerDecayCheck.h"
 #include "../cppcoreguidelines/ProTypeMemberInitCheck.h"
 #include "../cppcoreguidelines/ProTypeVarargCheck.h"
 #include "../cppcoreguidelines/SpecialMemberFunctionsCheck.h"
 #include "../google/DefaultArgumentsCheck.h"
 #include "../google/ExplicitConstructorCheck.h"
 #include "../misc/NewDeleteOverloadsCheck.h"
 #include "../misc/StaticAssertCheck.h"
-#include "../misc/UndelegatedConstructor.h"
+#include "../bugprone/UndelegatedConstructorCheck.h"
 #include "../modernize/DeprecatedHeadersCheck.h"
 #include "../modernize/UseAutoCheck.h"
 #include "../modernize/UseEmplaceCheck.h"
 #include "../modernize/UseEqualsDefaultCheck.h"
 #include "../modernize/UseEqualsDeleteCheck.h"
 #include "../modernize/UseNoexceptCheck.h"
 #include "../modernize/UseNullptrCheck.h"
 #include "../modernize/UseOverrideCheck.h"
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     CheckFactories.registerCheck<cppcoreguidelines::NoMallocCheck>(
         "hicpp-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::UndelegatedConstructorCheck>(
+    CheckFactories.registerCheck<bugprone::UndelegatedConstructorCheck>(
         "hicpp-undelegated-constructor");
     CheckFactories.registerCheck<modernize::UseEmplaceCheck>(
         "hicpp-use-emplace");
     CheckFactories.registerCheck<modernize::UseEqualsDefaultCheck>(
         "hicpp-use-equals-default");
     CheckFactories.registerCheck<modernize::UseEqualsDeleteCheck>(
         "hicpp-use-equals-delete");
     CheckFactories.registerCheck<modernize::UseNoexceptCheck>(

clang-tidy/misc/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS support)
 
 add_clang_library(clangTidyMiscModule
   MisplacedConstCheck.cpp
   UnconventionalAssignOperatorCheck.cpp
   DefinitionsInHeadersCheck.cpp
   MacroParenthesesCheck.cpp
   MiscTidyModule.cpp
   NewDeleteOverloadsCheck.cpp
   NonCopyableObjects.cpp
   RedundantExpressionCheck.cpp
   SizeofContainerCheck.cpp
   SizeofExpressionCheck.cpp
   StaticAssertCheck.cpp
-  SuspiciousSemicolonCheck.cpp
-  SuspiciousStringCompareCheck.cpp
-  SwappedArgumentsCheck.cpp
   ThrowByValueCatchByReferenceCheck.cpp
-  UndelegatedConstructor.cpp
   UniqueptrResetReleaseCheck.cpp
   UnusedAliasDeclsCheck.cpp
   UnusedParametersCheck.cpp
   UnusedRAIICheck.cpp
   UnusedUsingDeclsCheck.cpp
 
   LINK_LIBS
   clangAnalysis
   clangAST
   clangASTMatchers
   clangBasic
   clangLex
   clangTidy
   clangTidyUtils
   clangTooling
   )

clang-tidy/misc/MiscTidyModule.cpp

 #include "MacroParenthesesCheck.h"
 #include "MisplacedConstCheck.h"
 #include "NewDeleteOverloadsCheck.h"
 #include "NonCopyableObjects.h"
 #include "RedundantExpressionCheck.h"
 #include "SizeofContainerCheck.h"
 #include "SizeofExpressionCheck.h"
 #include "StaticAssertCheck.h"
-#include "SuspiciousSemicolonCheck.h"
-#include "SuspiciousStringCompareCheck.h"
-#include "SwappedArgumentsCheck.h"
 #include "ThrowByValueCatchByReferenceCheck.h"
 #include "UnconventionalAssignOperatorCheck.h"
-#include "UndelegatedConstructor.h"
 #include "UniqueptrResetReleaseCheck.h"
 #include "UnusedAliasDeclsCheck.h"
 #include "UnusedParametersCheck.h"
 #include "UnusedRAIICheck.h"
 #include "UnusedUsingDeclsCheck.h"
 
 namespace clang {
 namespace tidy {
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     CheckFactories.registerCheck<NonCopyableObjectsCheck>(
         "misc-non-copyable-objects");
     CheckFactories.registerCheck<RedundantExpressionCheck>(
         "misc-redundant-expression");
     CheckFactories.registerCheck<SizeofContainerCheck>("misc-sizeof-container");
     CheckFactories.registerCheck<SizeofExpressionCheck>(
         "misc-sizeof-expression");
     CheckFactories.registerCheck<StaticAssertCheck>("misc-static-assert");
-    CheckFactories.registerCheck<SuspiciousSemicolonCheck>(
-        "misc-suspicious-semicolon");
-    CheckFactories.registerCheck<SuspiciousStringCompareCheck>(
-        "misc-suspicious-string-compare");
-    CheckFactories.registerCheck<SwappedArgumentsCheck>(
-        "misc-swapped-arguments");
     CheckFactories.registerCheck<ThrowByValueCatchByReferenceCheck>(
         "misc-throw-by-value-catch-by-reference");
-    CheckFactories.registerCheck<UndelegatedConstructorCheck>(
-        "misc-undelegated-constructor");
     CheckFactories.registerCheck<UniqueptrResetReleaseCheck>(
         "misc-uniqueptr-reset-release");
     CheckFactories.registerCheck<UnusedAliasDeclsCheck>(
         "misc-unused-alias-decls");
     CheckFactories.registerCheck<UnusedParametersCheck>(
         "misc-unused-parameters");
     CheckFactories.registerCheck<UnusedRAIICheck>("misc-unused-raii");
     CheckFactories.registerCheck<UnusedUsingDeclsCheck>(

docs/ReleaseNotes.rst

 Improvements to clang-rename
 ----------------------------
 
 The improvements are...
 
 Improvements to clang-tidy
 --------------------------
 
+- The 'misc-undelegated-constructor' check was renamed to `bugprone-undelegated-constructor
+  <http://clang.llvm.org/extra/clang-tidy/checks/bugprone-undelegated-constructor.html>`_
+
+- The 'misc-swapped-arguments' check was renamed to `bugprone-swapped-arguments
+  <http://clang.llvm.org/extra/clang-tidy/checks/bugprone-swapped-arguments.html>`_
+
+- The 'misc-suspicious-string-compare' check was renamed to `bugprone-suspicious-string-compare
+  <http://clang.llvm.org/extra/clang-tidy/checks/bugprone-suspicious-string-compare.html>`_
+
+- The 'misc-suspicious-semicolon' check was renamed to `bugprone-suspicious-semicolon
+  <http://clang.llvm.org/extra/clang-tidy/checks/bugprone-suspicious-semicolon.html>`_
+
 - The 'misc-suspicious-missing-comma' check was renamed to `bugprone-suspicious-missing-comma
   <http://clang.llvm.org/extra/clang-tidy/checks/bugprone-suspicious-missing-comma.html>`_
 
 - The 'misc-suspicious-enum-usage' check was renamed to `bugprone-suspicious-enum-usage
   <http://clang.llvm.org/extra/clang-tidy/checks/bugprone-suspicious-enum-usage.html>`_
 
 - The 'misc-string-literal-with-embedded-nul' check was renamed to `bugprone-string-literal-with-embedded-nul
   <http://clang.llvm.org/extra/clang-tidy/checks/bugprone-string-literal-with-embedded-nul.html>`_

docs/clang-tidy/checks/bugprone-suspicious-semicolon.rst

-.. title:: clang-tidy - misc-suspicious-semicolon
+.. title:: clang-tidy - bugprone-suspicious-semicolon
 
-misc-suspicious-semicolon
-=========================
+bugprone-suspicious-semicolon
+=============================
 
 Finds most instances of stray semicolons that unexpectedly alter the meaning of
 the code. More specifically, it looks for ``if``, ``while``, ``for`` and
 ``for-range`` statements whose body is a single semicolon, and then analyzes the
 context of the code (e.g. indentation) in an attempt to determine whether that
 is intentional.
 
   .. code-block:: c++

docs/clang-tidy/checks/bugprone-suspicious-string-compare.rst

-.. title:: clang-tidy - misc-suspicious-string-compare
+.. title:: clang-tidy - bugprone-suspicious-string-compare
 
-misc-suspicious-string-compare
-==============================
+bugprone-suspicious-string-compare
+==================================
 
 Find suspicious usage of runtime string comparison functions.
 This check is valid in C and C++.
 
 Checks for calls with implicit comparator and proposed to explicitly add it.
 
 .. code-block:: c++
 

docs/clang-tidy/checks/bugprone-swapped-arguments.rst

+.. title:: clang-tidy - bugprone-swapped-arguments
+
+bugprone-swapped-arguments
+==========================
+
+
+Finds potentially swapped arguments by looking at implicit conversions.

docs/clang-tidy/checks/bugprone-undelegated-constructor.rst

-.. title:: clang-tidy - misc-undelegated-constructor
+.. title:: clang-tidy - bugprone-undelegated-constructor
 
-misc-undelegated-constructor
-============================
+bugprone-undelegated-constructor
+================================
 
 
 Finds creation of temporary objects in constructors that look like a
 function call to another constructor of the same class.
 
 The user most likely meant to use a delegating constructor or base class
 initializer.

docs/clang-tidy/checks/hicpp-undelegated-constructor.rst

 .. title:: clang-tidy - hicpp-undelegated-construtor
 .. meta::
-   :http-equiv=refresh: 5;URL=misc-undelegated-constructor.html
+   :http-equiv=refresh: 5;URL=bugprone-undelegated-constructor.html
 
 hicpp-undelegated-constructor
 =============================
 
-This check is an alias for `misc-undelegated-constructor <misc-undelegated-constructor.html>`_.
+This check is an alias for `bugprone-undelegated-constructor <bugprone-undelegated-constructor.html>`_.
 Partially implements `rule 12.4.5 <http://www.codingstandard.com/rule/12-4-5-use-delegating-constructors-to-reduce-code-duplication/>`_ 
 to find misplaced constructor calls inside a constructor.
 
 .. code-block:: c++
 
   struct Ctor {
     Ctor();
     Ctor(int);

docs/clang-tidy/checks/list.rst

.. toctree::
    bugprone-move-forwarding-reference
    bugprone-multiple-statement-macro
    bugprone-string-constructor
    bugprone-string-integer-assignment
    bugprone-string-literal-with-embedded-nul
    bugprone-suspicious-enum-usage
    bugprone-suspicious-memset-usage
    bugprone-suspicious-missing-comma
+   bugprone-suspicious-semicolon
+   bugprone-suspicious-string-compare
+   bugprone-swapped-arguments
    bugprone-throw-keyword-missing
    bugprone-undefined-memory-manipulation
+   bugprone-undelegated-constructor
    bugprone-use-after-move
    bugprone-virtual-near-miss
    cert-dcl03-c (redirects to misc-static-assert) <cert-dcl03-c>
    cert-dcl21-cpp
    cert-dcl50-cpp
    cert-dcl54-cpp (redirects to misc-new-delete-overloads) <cert-dcl54-cpp>
    cert-dcl58-cpp
    cert-dcl59-cpp (redirects to google-build-namespaces) <cert-dcl59-cpp>
.. toctree::
    hicpp-new-delete-operators (redirects to misc-new-delete-overloads) <hicpp-new-delete-operators>
    hicpp-no-array-decay (redirects to cppcoreguidelines-pro-bounds-array-to-pointer-decay) <hicpp-no-array-decay>
    hicpp-no-assembler
    hicpp-no-malloc (redirects to cppcoreguidelines-no-malloc) <hicpp-no-malloc>
    hicpp-noexcept-move (redirects to misc-noexcept-moveconstructor) <hicpp-noexcept-move>
    hicpp-signed-bitwise
    hicpp-special-member-functions (redirects to cppcoreguidelines-special-member-functions) <hicpp-special-member-functions>
    hicpp-static-assert (redirects to misc-static-assert) <hicpp-static-assert>
-   hicpp-undelegated-constructor (redirects to misc-undelegated-constructor) <hicpp-undelegated-constructor>
+   hicpp-undelegated-constructor (redirects to bugprone-undelegated-constructor) <hicpp-undelegated-constructor>
    hicpp-use-auto (redirects to modernize-use-auto) <hicpp-use-auto>
    hicpp-use-emplace (redirects to modernize-use-emplace) <hicpp-use-emplace>
    hicpp-use-equals-default (redirects to modernize-use-equals-default) <hicpp-use-equals-default>
    hicpp-use-equals-delete (redirects to modernize-use-equals-delete) <hicpp-use-equals-delete>
    hicpp-use-noexcept (redirects to modernize-use-noexcept) <hicpp-use-noexcept>
    hicpp-use-nullptr (redirects to modernize-use-nullptr) <hicpp-use-nullptr>
    hicpp-use-override (redirects to modernize-use-override) <hicpp-use-override>
    hicpp-vararg (redirects to cppcoreguidelines-pro-type-vararg) <hicpp-vararg>
    llvm-header-guard
    llvm-include-order
    llvm-namespace-comment
    llvm-twine-local
    misc-definitions-in-headers
    misc-macro-parentheses
    misc-misplaced-const
    misc-new-delete-overloads
    misc-non-copyable-objects
    misc-redundant-expression
    misc-sizeof-container
    misc-sizeof-expression
    misc-static-assert
-   misc-suspicious-semicolon
-   misc-suspicious-string-compare
-   misc-swapped-arguments
    misc-throw-by-value-catch-by-reference
    misc-unconventional-assign-operator
-   misc-undelegated-constructor
    misc-uniqueptr-reset-release
    misc-unused-alias-decls
    misc-unused-parameters
    misc-unused-raii
    misc-unused-using-decls
    modernize-avoid-bind
    modernize-deprecated-headers
    modernize-loop-convert

docs/clang-tidy/checks/misc-swapped-arguments.rst

-.. title:: clang-tidy - misc-swapped-arguments
-
-misc-swapped-arguments
-======================
-
-
-Finds potentially swapped arguments by looking at implicit conversions.

test/clang-tidy/bugprone-suspicious-semicolon-fail.cpp

-// RUN: clang-tidy %s -checks="-*,misc-suspicious-semicolon" -- -DERROR 2>&1 \
+// RUN: clang-tidy %s -checks="-*,bugprone-suspicious-semicolon" -- -DERROR 2>&1 \
 // RUN:   | FileCheck %s -check-prefix=CHECK-ERROR \
 // RUN:       -implicit-check-not="{{warning|error}}:"
-// RUN: clang-tidy %s -checks="-*,misc-suspicious-semicolon,clang-diagnostic*" \
+// RUN: clang-tidy %s -checks="-*,bugprone-suspicious-semicolon,clang-diagnostic*" \
 // RUN:    -- -DWERROR -Wno-everything -Werror=unused-variable 2>&1 \
 // RUN:   | FileCheck %s -check-prefix=CHECK-WERROR \
 // RUN:       -implicit-check-not="{{warning|error}}:"
 
 // Note: This test verifies that, the checker does not emit any warning for
 //       files that do not compile.
 
 bool g();
 
 void f() {
   if (g());
-  // CHECK-WERROR: :[[@LINE-1]]:11: warning: potentially unintended semicolon [misc-suspicious-semicolon]
+  // CHECK-WERROR: :[[@LINE-1]]:11: warning: potentially unintended semicolon [bugprone-suspicious-semicolon]
 #if ERROR
   int a
   // CHECK-ERROR: :[[@LINE-1]]:8: error: expected ';' at end of declaration [clang-diagnostic-error]
 #elif WERROR
   int a;
   // CHECK-WERROR: :[[@LINE-1]]:7: error: unused variable 'a' [clang-diagnostic-unused-variable]
 #else
 #error "One of ERROR or WERROR should be defined.
 #endif
 }

test/clang-tidy/bugprone-suspicious-semicolon.cpp

-// RUN: %check_clang_tidy %s misc-suspicious-semicolon %t
+// RUN: %check_clang_tidy %s bugprone-suspicious-semicolon %t
 
 int x = 5;
 
 void nop();
 
 void correct1()
 {
   if(x < 5) nop();
void correct3()
   {
     nop();
   }
 }
 
 void fail1()
 {
   if(x > 5); nop();
-  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: potentially unintended semicolon [misc-suspicious-semicolon]
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: potentially unintended semicolon [bugprone-suspicious-semicolon]
   // CHECK-FIXES: if(x > 5) nop();
 }
 
 void fail2()
 {
   if(x == 5);
     nop();
-  // CHECK-MESSAGES: :[[@LINE-2]]:12: warning: potentially unintended semicolon [misc-suspicious-semicolon]
+  // CHECK-MESSAGES: :[[@LINE-2]]:12: warning: potentially unintended semicolon [bugprone-suspicious-semicolon]
   // CHECK-FIXES: if(x == 5){{$}}
 }
 
 void fail3()
 {
   if(x < 5);
   {
     nop();

test/clang-tidy/bugprone-suspicious-string-compare.c

-// RUN: %check_clang_tidy %s misc-suspicious-string-compare %t -- \
+// RUN: %check_clang_tidy %s bugprone-suspicious-string-compare %t -- \
 // RUN: -config='{CheckOptions: \
-// RUN:  [{key: misc-suspicious-string-compare.WarnOnImplicitComparison, value: 1}, \
-// RUN:   {key: misc-suspicious-string-compare.WarnOnLogicalNotComparison, value: 1}]}' \
+// RUN:  [{key: bugprone-suspicious-string-compare.WarnOnImplicitComparison, value: 1}, \
+// RUN:   {key: bugprone-suspicious-string-compare.WarnOnLogicalNotComparison, value: 1}]}' \
 // RUN: -- -std=c99
 
 static const char A[] = "abc";
 
 int strcmp(const char *, const char *);
 
 int test_warning_patterns() {
   if (strcmp(A, "a"))
     return 0;
-  // CHECK-MESSAGES: [[@LINE-2]]:7: warning: function 'strcmp' is called without explicitly comparing result [misc-suspicious-string-compare]
+  // CHECK-MESSAGES: [[@LINE-2]]:7: warning: function 'strcmp' is called without explicitly comparing result [bugprone-suspicious-string-compare]
   // CHECK-FIXES: if (strcmp(A, "a") != 0)
 
   if (strcmp(A, "a") != 0 ||
       strcmp(A, "b"))
     return 0;
   // CHECK-MESSAGES: [[@LINE-2]]:7: warning: function 'strcmp' is called without explicitly comparing result
   // CHECK-FIXES: strcmp(A, "b") != 0)
 

test/clang-tidy/bugprone-suspicious-string-compare.cpp

-// RUN: %check_clang_tidy %s misc-suspicious-string-compare %t -- \
+// RUN: %check_clang_tidy %s bugprone-suspicious-string-compare %t -- \
 // RUN: -config='{CheckOptions: \
-// RUN:  [{key: misc-suspicious-string-compare.WarnOnImplicitComparison, value: 1}, \
-// RUN:   {key: misc-suspicious-string-compare.WarnOnLogicalNotComparison, value: 1}]}' \
+// RUN:  [{key: bugprone-suspicious-string-compare.WarnOnImplicitComparison, value: 1}, \
+// RUN:   {key: bugprone-suspicious-string-compare.WarnOnLogicalNotComparison, value: 1}]}' \
 // RUN: --
 
 typedef __SIZE_TYPE__ size;
 
 struct locale_t {
   void* dummy;
 } locale;
 

 int _mbsicmp_l(const unsigned char *, const unsigned char *, locale_t);
 int _mbsnicmp_l(const unsigned char *, const unsigned char *, size, locale_t);
 int _mbsnbcmp_l(const unsigned char *, const unsigned char *, size, locale_t);
 int _mbsnbicmp_l(const unsigned char *, const unsigned char *, size, locale_t);
 
 int test_warning_patterns() {
   if (strcmp(A, "a"))
     return 0;
-  // CHECK-MESSAGES: [[@LINE-2]]:7: warning: function 'strcmp' is called without explicitly comparing result [misc-suspicious-string-compare]
+  // CHECK-MESSAGES: [[@LINE-2]]:7: warning: function 'strcmp' is called without explicitly comparing result [bugprone-suspicious-string-compare]
   // CHECK-FIXES: if (strcmp(A, "a") != 0)
 
   if (strcmp(A, "a") == 0 ||
       strcmp(A, "b"))
     return 0;
   // CHECK-MESSAGES: [[@LINE-2]]:7: warning: function 'strcmp' is called without explicitly comparing result
   // CHECK-FIXES: strcmp(A, "b") != 0)
 

test/clang-tidy/bugprone-swapped-arguments.cpp

-// RUN: %check_clang_tidy %s misc-swapped-arguments %t
+// RUN: %check_clang_tidy %s bugprone-swapped-arguments %t
 
 void F(int, double);
 
 int SomeFunction();
 
 template <typename T, typename U>
 void G(T a, U b) {
   F(a, b); // no-warning

test/clang-tidy/bugprone-undelegated-constructor-cxx98.cpp

-// RUN: clang-tidy %s -checks=-*,misc-undelegated-constructor -- -std=c++98 | count 0
+// RUN: clang-tidy %s -checks=-*,bugprone-undelegated-constructor -- -std=c++98 | count 0
 
 // Note: this test expects no diagnostics, but FileCheck cannot handle that,
 // hence the use of | count 0.
 
 struct Ctor;
 Ctor foo();
 
 struct Ctor {

test/clang-tidy/bugprone-undelegated-constructor.cpp

-// RUN: %check_clang_tidy %s misc-undelegated-constructor %t
+// RUN: %check_clang_tidy %s bugprone-undelegated-constructor %t
 
 struct Ctor;
 Ctor foo();
 
 struct Ctor {
   Ctor();
   Ctor(int);
   Ctor(int, int);
   Ctor(Ctor *i) {
     Ctor();
-// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: did you intend to call a delegated constructor? A temporary object is created here instead [misc-undelegated-constructor]
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: did you intend to call a delegated constructor? A temporary object is created here instead [bugprone-undelegated-constructor]
     Ctor(0);
 // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: did you intend to call a delegated constructor?
     Ctor(1, 2);
 // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: did you intend to call a delegated constructor?
     foo();
   }
 };
 

test/clang-tidy/objc-arc-and-properties.m

-// RUN: %check_clang_tidy %s misc-suspicious-semicolon %t
+// RUN: %check_clang_tidy %s bugprone-suspicious-semicolon %t
 
 // This test checks if Objective-C 2.0 (@properties) and
 // Automatic Reference Counting (ARC) are enabled for .m files
 // checked via check_clang_tidy.py.
 
 #if !__has_feature(objc_arc)
 #error Objective-C ARC not enabled as expected
 #endif
 
 @interface Foo
 @property (nonatomic, assign) int shouldDoStuff;
 - (void)nop;
 @end
 
 void fail(Foo *f)
 {
   if(f.shouldDoStuff); [f nop];
-  // CHECK-MESSAGES: :[[@LINE-1]]:22: warning: potentially unintended semicolon [misc-suspicious-semicolon]
+  // CHECK-MESSAGES: :[[@LINE-1]]:22: warning: potentially unintended semicolon [bugprone-suspicious-semicolon]
   // CHECK-FIXES: if(f.shouldDoStuff) [f nop];
 }

test/clang-tidy/objc-no-arc-or-properties.m

-// RUN: %check_clang_tidy %s misc-suspicious-semicolon %t -- -- -fno-objc-arc -fobjc-abi-version=1
+// RUN: %check_clang_tidy %s bugprone-suspicious-semicolon %t -- -- -fno-objc-arc -fobjc-abi-version=1
 
 // This test ensures check_clang_tidy.py allows disabling Objective-C ARC and
 // Objective-C 2.0 via passing arguments after -- on the command line.
 //
 // (We could include a test which doesn't pass any arguments after --
 // to check if ARC and ObjC 2.0 are disabled by default, but that test
 // could change behavior based on the default Objective-C runtime for
 // the platform, which would make this test flaky.)

 @interface Foo
 - (int)shouldDoStuff;
 - (void)nop;
 @end
 
 void fail(Foo *f)
 {
   if([f shouldDoStuff]); [f nop];
-  // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: potentially unintended semicolon [misc-suspicious-semicolon]
+  // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: potentially unintended semicolon [bugprone-suspicious-semicolon]
   // CHECK-FIXES: if([f shouldDoStuff]) [f nop];
 }