[clang-tidy] Move more checks from misc- to performance-

[alexfh]

Summary

rename_check.py misc-move-const-arg performance-move-const-arg
rename_check.py misc-noexcept-move-constructor performance-noexcept-move-constructor

[alexfh]

• clang-format -style=llvm

[alexfh]

• Reverted formatting in tests.

[xazax.hun]

Found one possible problem. Once fixed, LG!

clang-tidy/hicpp/HICPPTidyModule.cpp

33

Don't you need to add performance module to link to the HICPP module to avoid link errors?

clang-tidy/performance/MoveConstArgCheck.h

18–19

Is there any specific reason to rename this class? I am ok with the change, just wondering.

[alexfh]

• Add dependencies to prevent a link error

[alexfh]

clang-tidy/hicpp/HICPPTidyModule.cpp

33

Indeed. I should probably teach the script to do this ;)

clang-tidy/performance/MoveConstArgCheck.h

18–19

The reason is to make the class name consistent with the check name (which is the case for all checks added by the add_new_check script, but not the case for some checks that predate this script).

clang-tidy/hicpp/HICPPTidyModule.cpp

 #include "../bugprone/UseAfterMoveCheck.h"
 #include "../cppcoreguidelines/NoMallocCheck.h"
 #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/MoveConstantArgumentCheck.h"
 #include "../misc/NewDeleteOverloadsCheck.h"
-#include "../misc/NoexceptMoveConstructorCheck.h"
 #include "../misc/StaticAssertCheck.h"
 #include "../misc/UndelegatedConstructor.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"
+#include "../performance/MoveConstArgCheck.h"
+#include "../performance/NoexceptMoveConstructorCheck.h"
 #include "../readability/BracesAroundStatementsCheck.h"
 #include "../readability/FunctionSizeCheck.h"
 #include "../readability/IdentifierNamingCheck.h"
 #include "ExceptionBaseclassCheck.h"
 #include "NoAssemblerCheck.h"
 #include "SignedBitwiseCheck.h"
 
 namespace clang {
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     CheckFactories.registerCheck<readability::FunctionSizeCheck>(
         "hicpp-function-size");
     CheckFactories.registerCheck<readability::IdentifierNamingCheck>(
         "hicpp-named-parameter");
     CheckFactories.registerCheck<bugprone::UseAfterMoveCheck>(
         "hicpp-invalid-access-moved");
     CheckFactories.registerCheck<cppcoreguidelines::ProTypeMemberInitCheck>(
         "hicpp-member-init");
-    CheckFactories.registerCheck<misc::MoveConstantArgumentCheck>(
+    CheckFactories.registerCheck<performance::MoveConstArgCheck>(
         "hicpp-move-const-arg");
     CheckFactories.registerCheck<misc::NewDeleteOverloadsCheck>(
         "hicpp-new-delete-operators");
-    CheckFactories.registerCheck<misc::NoexceptMoveConstructorCheck>(
+    CheckFactories.registerCheck<performance::NoexceptMoveConstructorCheck>(
         "hicpp-noexcept-move");
     CheckFactories
         .registerCheck<cppcoreguidelines::ProBoundsArrayToPointerDecayCheck>(
             "hicpp-no-array-decay");
     CheckFactories.registerCheck<NoAssemblerCheck>("hicpp-no-assembler");
     CheckFactories.registerCheck<cppcoreguidelines::NoMallocCheck>(
         "hicpp-no-malloc");
     CheckFactories

clang-tidy/misc/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS support)
 
 add_clang_library(clangTidyMiscModule
   ForwardingReferenceOverloadCheck.cpp
   LambdaFunctionNameCheck.cpp
   MisplacedConstCheck.cpp
   UnconventionalAssignOperatorCheck.cpp
   DefinitionsInHeadersCheck.cpp
   IncorrectRoundings.cpp
   MacroParenthesesCheck.cpp
   MacroRepeatedSideEffectsCheck.cpp
   MiscTidyModule.cpp
   MisplacedWideningCastCheck.cpp
-  MoveConstantArgumentCheck.cpp
   NewDeleteOverloadsCheck.cpp
-  NoexceptMoveConstructorCheck.cpp
   NonCopyableObjects.cpp
   RedundantExpressionCheck.cpp
   SizeofContainerCheck.cpp
   SizeofExpressionCheck.cpp
   StaticAssertCheck.cpp
   StringCompareCheck.cpp
   StringIntegerAssignmentCheck.cpp
   StringLiteralWithEmbeddedNulCheck.cpp

clang-tidy/misc/MiscTidyModule.cpp

 #include "DefinitionsInHeadersCheck.h"
 #include "ForwardingReferenceOverloadCheck.h"
 #include "IncorrectRoundings.h"
 #include "LambdaFunctionNameCheck.h"
 #include "MacroParenthesesCheck.h"
 #include "MacroRepeatedSideEffectsCheck.h"
 #include "MisplacedConstCheck.h"
 #include "MisplacedWideningCastCheck.h"
-#include "MoveConstantArgumentCheck.h"
 #include "NewDeleteOverloadsCheck.h"
-#include "NoexceptMoveConstructorCheck.h"
 #include "NonCopyableObjects.h"
 #include "RedundantExpressionCheck.h"
 #include "SizeofContainerCheck.h"
 #include "SizeofExpressionCheck.h"
 #include "StaticAssertCheck.h"
 #include "StringCompareCheck.h"
 #include "StringIntegerAssignmentCheck.h"
 #include "StringLiteralWithEmbeddedNulCheck.h"
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     CheckFactories.registerCheck<IncorrectRoundings>(
         "misc-incorrect-roundings");
     CheckFactories.registerCheck<MacroParenthesesCheck>(
         "misc-macro-parentheses");
     CheckFactories.registerCheck<MacroRepeatedSideEffectsCheck>(
         "misc-macro-repeated-side-effects");
     CheckFactories.registerCheck<MisplacedWideningCastCheck>(
         "misc-misplaced-widening-cast");
-    CheckFactories.registerCheck<MoveConstantArgumentCheck>(
-        "misc-move-const-arg");
     CheckFactories.registerCheck<NewDeleteOverloadsCheck>(
         "misc-new-delete-overloads");
-    CheckFactories.registerCheck<NoexceptMoveConstructorCheck>(
-        "misc-noexcept-move-constructor");
     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");

clang-tidy/modernize/PassByValueCheck.cpp

void PassByValueCheck::check(const MatchFinder::MatchResult &Result) {
   SourceManager &SM = *Result.SourceManager;
 
   // If the parameter is used or anything other than the copy, do not apply
   // the changes.
   if (!paramReferredExactlyOnce(Ctor, ParamDecl))
     return;
 
   // If the parameter is trivial to copy, don't move it. Moving a trivivally
-  // copyable type will cause a problem with misc-move-const-arg
+  // copyable type will cause a problem with performance-move-const-arg
   if (ParamDecl->getType().getNonReferenceType().isTriviallyCopyableType(
           *Result.Context))
     return;
 
   auto Diag = diag(ParamDecl->getLocStart(), "pass by value and use std::move");
 
   // Iterate over all declarations of the constructor.
   for (const ParmVarDecl *ParmDecl : collectParamDecls(Ctor, ParamDecl)) {

clang-tidy/performance/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS support)
 
 add_clang_library(clangTidyPerformanceModule
   FasterStringFindCheck.cpp
   ForRangeCopyCheck.cpp
   ImplicitConversionInLoopCheck.cpp
   InefficientAlgorithmCheck.cpp
   InefficientStringConcatenationCheck.cpp
   InefficientVectorOperationCheck.cpp
+  MoveConstArgCheck.cpp
   MoveConstructorInitCheck.cpp
+  NoexceptMoveConstructorCheck.cpp
   PerformanceTidyModule.cpp
   TypePromotionInMathFnCheck.cpp
   UnnecessaryCopyInitialization.cpp
   UnnecessaryValueParamCheck.cpp
 
   LINK_LIBS
   clangAST
   clangASTMatchers
   clangBasic
   clangLex
   clangTidy
   clangTidyUtils
   )

clang-tidy/performance/MoveConstArgCheck.h

-//===--- MoveConstantArgumentCheck.h - clang-tidy -------------------------===//
+//===--- MoveConstArgCheck.h - clang-tidy -------------------------===//
 //
 //                     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_MOVECONSTANTARGUMENTCHECK_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_MOVECONSTANTARGUMENTCHECK_H
 
 #include "../ClangTidy.h"
 
 namespace clang {
 namespace tidy {
-namespace misc {
+namespace performance {
 
-class MoveConstantArgumentCheck : public ClangTidyCheck {
+class MoveConstArgCheck : public ClangTidyCheck {
  public:
-  MoveConstantArgumentCheck(StringRef Name, ClangTidyContext *Context)
+  MoveConstArgCheck(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 tidy
-} // namespace clang
+}  // namespace performance
+}  // namespace tidy
+}  // namespace clang
 
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_MOVECONSTANTARGUMENTCHECK_H
+#endif  // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_MOVECONSTANTARGUMENTCHECK_H

clang-tidy/performance/MoveConstArgCheck.cpp

-//===--- MoveConstantArgumentCheck.cpp - clang-tidy -----------------------===//
+//===--- MoveConstArgCheck.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 "MoveConstantArgumentCheck.h"
+#include "MoveConstArgCheck.h"
 
 #include "clang/Lex/Lexer.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
-namespace misc {
+namespace performance {
 
 static void ReplaceCallWithArg(const CallExpr *Call, DiagnosticBuilder &Diag,
                                const SourceManager &SM,
                                const LangOptions &LangOpts) {
   const Expr *Arg = Call->getArg(0);
 
   CharSourceRange BeforeArgumentsRange = Lexer::makeFileCharRange(
       CharSourceRange::getCharRange(Call->getLocStart(), Arg->getLocStart()),
       SM, LangOpts);
   CharSourceRange AfterArgumentsRange = Lexer::makeFileCharRange(
       CharSourceRange::getCharRange(Call->getLocEnd(),
                                     Call->getLocEnd().getLocWithOffset(1)),
       SM, LangOpts);
 
   if (BeforeArgumentsRange.isValid() && AfterArgumentsRange.isValid()) {
     Diag << FixItHint::CreateRemoval(BeforeArgumentsRange)
          << FixItHint::CreateRemoval(AfterArgumentsRange);
   }
 }
 
-void MoveConstantArgumentCheck::registerMatchers(MatchFinder *Finder) {
-  if (!getLangOpts().CPlusPlus)
-    return;
+void MoveConstArgCheck::registerMatchers(MatchFinder *Finder) {
+  if (!getLangOpts().CPlusPlus) return;
 
   auto MoveCallMatcher =
       callExpr(callee(functionDecl(hasName("::std::move"))), argumentCountIs(1),
                unless(isInTemplateInstantiation()))
           .bind("call-move");
 
   Finder->addMatcher(MoveCallMatcher, this);
 
   auto ConstParamMatcher = forEachArgumentWithParam(
       MoveCallMatcher, parmVarDecl(hasType(references(isConstQualified()))));
 
   Finder->addMatcher(callExpr(ConstParamMatcher).bind("receiving-expr"), this);
   Finder->addMatcher(cxxConstructExpr(ConstParamMatcher).bind("receiving-expr"),
                      this);
 }
 
-void MoveConstantArgumentCheck::check(const MatchFinder::MatchResult &Result) {
+void MoveConstArgCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *CallMove = Result.Nodes.getNodeAs<CallExpr>("call-move");
   const auto *ReceivingExpr = Result.Nodes.getNodeAs<Expr>("receiving-expr");
   const Expr *Arg = CallMove->getArg(0);
   SourceManager &SM = Result.Context->getSourceManager();
 
   CharSourceRange MoveRange =
       CharSourceRange::getCharRange(CallMove->getSourceRange());
   CharSourceRange FileMoveRange =
       Lexer::makeFileCharRange(MoveRange, SM, getLangOpts());
-  if (!FileMoveRange.isValid())
-    return;
+  if (!FileMoveRange.isValid()) return;
 
   bool IsConstArg = Arg->getType().isConstQualified();
   bool IsTriviallyCopyable =
       Arg->getType().isTriviallyCopyableType(*Result.Context);
 
   if (IsConstArg || IsTriviallyCopyable) {
     if (const CXXRecordDecl *R = Arg->getType()->getAsCXXRecordDecl()) {
       // According to [expr.prim.lambda]p3, "whether the closure type is
       // trivially copyable" property can be changed by the implementation of
       // the language, so we shouldn't rely on it when issuing diagnostics.
-      if (R->isLambda())
-        return;
+      if (R->isLambda()) return;
       // Don't warn when the type is not copyable.
       for (const auto *Ctor : R->ctors()) {
-        if (Ctor->isCopyConstructor() && Ctor->isDeleted())
-          return;
+        if (Ctor->isCopyConstructor() && Ctor->isDeleted()) return;
       }
     }
     bool IsVariable = isa<DeclRefExpr>(Arg);
     const auto *Var =
         IsVariable ? dyn_cast<DeclRefExpr>(Arg)->getDecl() : nullptr;
     auto Diag = diag(FileMoveRange.getBegin(),
                      "std::move of the %select{|const }0"
                      "%select{expression|variable %4}1 "
if (IsConstArg || IsTriviallyCopyable) {
     auto Diag = diag(FileMoveRange.getBegin(),
                      "passing result of std::move() as a const reference "
                      "argument; no move will actually happen");
 
     ReplaceCallWithArg(CallMove, Diag, SM, getLangOpts());
   }
 }
 
-} // namespace misc
-} // namespace tidy
-} // namespace clang
+}  // namespace performance
+}  // namespace tidy
+}  // namespace clang

clang-tidy/performance/NoexceptMoveConstructorCheck.h

 //===--- NoexceptMoveConstructorCheck.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_NOEXCEPTMOVECONSTRUCTORCHECK_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_NOEXCEPTMOVECONSTRUCTORCHECK_H
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_NOEXCEPTMOVECONSTRUCTORCHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_NOEXCEPTMOVECONSTRUCTORCHECK_H
 
 #include "../ClangTidy.h"
 
 namespace clang {
 namespace tidy {
-namespace misc {
+namespace performance {
 
 /// The check flags user-defined move constructors and assignment operators not
 /// marked with `noexcept` or marked with `noexcept(expr)` where `expr`
 /// evaluates to `false` (but is not a `false` literal itself).
 ///
 /// Move constructors of all the types used with STL containers, for example,
 /// need to be declared `noexcept`. Otherwise STL will choose copy constructors
 /// instead. The same is valid for move assignment operations.
 class NoexceptMoveConstructorCheck : public ClangTidyCheck {
  public:
   NoexceptMoveConstructorCheck(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 tidy
-} // namespace clang
+}  // namespace performance
+}  // namespace tidy
+}  // namespace clang
 
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_NOEXCEPTMOVECONSTRUCTORCHECK_H
+#endif  // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_NOEXCEPTMOVECONSTRUCTORCHECK_H

clang-tidy/performance/NoexceptMoveConstructorCheck.cpp

 #include "NoexceptMoveConstructorCheck.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
-namespace misc {
+namespace performance {
 
 void NoexceptMoveConstructorCheck::registerMatchers(MatchFinder *Finder) {
   // Only register the matchers for C++11; the functionality currently does not
   // provide any benefit to other languages, despite being benign.
-  if (!getLangOpts().CPlusPlus11)
-    return;
+  if (!getLangOpts().CPlusPlus11) return;
 
   Finder->addMatcher(
       cxxMethodDecl(anyOf(cxxConstructorDecl(), hasOverloadedOperatorName("=")),
                     unless(isImplicit()), unless(isDeleted()))
           .bind("decl"),
       this);
 }
 
 void NoexceptMoveConstructorCheck::check(
     const MatchFinder::MatchResult &Result) {
   if (const auto *Decl = Result.Nodes.getNodeAs<CXXMethodDecl>("decl")) {
     StringRef MethodType = "assignment operator";
     if (const auto *Ctor = dyn_cast<CXXConstructorDecl>(Decl)) {
-      if (!Ctor->isMoveConstructor())
-        return;
+      if (!Ctor->isMoveConstructor()) return;
       MethodType = "constructor";
     } else if (!Decl->isMoveAssignmentOperator()) {
       return;
     }
 
     const auto *ProtoType = Decl->getType()->getAs<FunctionProtoType>();
 
-    if (isUnresolvedExceptionSpec(ProtoType->getExceptionSpecType()))
-      return;
+    if (isUnresolvedExceptionSpec(ProtoType->getExceptionSpecType())) return;
 
     switch (ProtoType->getNoexceptSpec(*Result.Context)) {
       case FunctionProtoType::NR_NoNoexcept:
         diag(Decl->getLocation(), "move %0s should be marked noexcept")
             << MethodType;
         // FIXME: Add a fixit.
         break;
       case FunctionProtoType::NR_Throw:
         // Don't complain about nothrow(false), but complain on nothrow(expr)
         // where expr evaluates to false.
         if (const Expr *E = ProtoType->getNoexceptExpr()) {
-          if (isa<CXXBoolLiteralExpr>(E))
-            break;
+          if (isa<CXXBoolLiteralExpr>(E)) break;
           diag(E->getExprLoc(),
                "noexcept specifier on the move %0 evaluates to 'false'")
               << MethodType;
         }
         break;
       case FunctionProtoType::NR_Nothrow:
       case FunctionProtoType::NR_Dependent:
       case FunctionProtoType::NR_BadNoexcept:
         break;
     }
   }
 }
 
-} // namespace misc
-} // namespace tidy
-} // namespace clang
+}  // namespace performance
+}  // namespace tidy
+}  // namespace clang

clang-tidy/performance/PerformanceTidyModule.cpp

 #include "../ClangTidyModule.h"
 #include "../ClangTidyModuleRegistry.h"
 #include "FasterStringFindCheck.h"
 #include "ForRangeCopyCheck.h"
 #include "ImplicitConversionInLoopCheck.h"
 #include "InefficientAlgorithmCheck.h"
 #include "InefficientStringConcatenationCheck.h"
 #include "InefficientVectorOperationCheck.h"
+#include "MoveConstArgCheck.h"
 #include "MoveConstructorInitCheck.h"
+#include "NoexceptMoveConstructorCheck.h"
 #include "TypePromotionInMathFnCheck.h"
 #include "UnnecessaryCopyInitialization.h"
 #include "UnnecessaryValueParamCheck.h"
 
 namespace clang {
 namespace tidy {
 namespace performance {
 
 class PerformanceModule : public ClangTidyModule {
 public:
   void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     CheckFactories.registerCheck<FasterStringFindCheck>(
         "performance-faster-string-find");
     CheckFactories.registerCheck<ForRangeCopyCheck>(
         "performance-for-range-copy");
     CheckFactories.registerCheck<ImplicitConversionInLoopCheck>(
         "performance-implicit-conversion-in-loop");
     CheckFactories.registerCheck<InefficientAlgorithmCheck>(
         "performance-inefficient-algorithm");
     CheckFactories.registerCheck<InefficientStringConcatenationCheck>(
         "performance-inefficient-string-concatenation");
     CheckFactories.registerCheck<InefficientVectorOperationCheck>(
         "performance-inefficient-vector-operation");
+    CheckFactories.registerCheck<MoveConstArgCheck>(
+        "performance-move-const-arg");
     CheckFactories.registerCheck<MoveConstructorInitCheck>(
         "performance-move-constructor-init");
+    CheckFactories.registerCheck<NoexceptMoveConstructorCheck>(
+        "performance-noexcept-move-constructor");
     CheckFactories.registerCheck<TypePromotionInMathFnCheck>(
         "performance-type-promotion-in-math-fn");
     CheckFactories.registerCheck<UnnecessaryCopyInitialization>(
         "performance-unnecessary-copy-initialization");
     CheckFactories.registerCheck<UnnecessaryValueParamCheck>(
         "performance-unnecessary-value-param");
   }
 };

docs/ReleaseNotes.rst

 Improvements to clang-rename
 ----------------------------
 
 The improvements are...
 
 Improvements to clang-tidy
 --------------------------
 
+- The 'misc-move-const-arg' check was renamed to `performance-move-const-arg
+  <http://clang.llvm.org/extra/clang-tidy/checks/performance-move-const-arg.html>`_
+
+- The 'misc-noexcept-move-constructor' check was renamed to `performance-noexcept-move-constructor
+  <http://clang.llvm.org/extra/clang-tidy/checks/performance-noexcept-move-constructor.html>`_
+
 - The 'misc-move-constructor-init' check was renamed to `performance-move-constructor-init
   <http://clang.llvm.org/extra/clang-tidy/checks/performance-move-constructor-init.html>`_
 
 - The 'misc-inefficient-algorithm' check was renamed to `performance-inefficient-algorithm
   <http://clang.llvm.org/extra/clang-tidy/checks/performance-inefficient-algorithm.html>`_
 
 - The 'misc-virtual-near-miss' check was renamed to `bugprone-virtual-near-miss
   <http://clang.llvm.org/extra/clang-tidy/checks/bugprone-virtual-near-miss.html>`_

docs/clang-tidy/checks/hicpp-move-const-arg.rst

 .. title:: clang-tidy - hicpp-move-const-arg
 .. meta::
-   :http-equiv=refresh: 5;URL=misc-move-const-arg.html
+   :http-equiv=refresh: 5;URL=performance-move-const-arg.html
 
 hicpp-move-const-arg
 ====================
 
 The `hicpp-move-const-arg` check is an alias, please see
-`misc-move-const-arg <misc-move-const-arg.html>`_ for more information.
+`performance-move-const-arg <performance-move-const-arg.html>`_ for more information.
 It enforces the `rule 17.3.1 <http://www.codingstandard.com/rule/17-3-1-do-not-use-stdmove-on-objects-declared-with-const-or-const-type/>`_.

docs/clang-tidy/checks/list.rst

.. toctree::
    google-runtime-references
    hicpp-braces-around-statements (redirects to readability-braces-around-statements) <hicpp-braces-around-statements>
    hicpp-deprecated-headers (redirects to modernize-deprecated-headers) <hicpp-deprecated-headers>
    hicpp-exception-baseclass
    hicpp-explicit-conversions (redirects to google-explicit-constructor) <hicpp-explicit-conversions>
    hicpp-function-size (redirects to readability-function-size) <hicpp-function-size>
    hicpp-invalid-access-moved (redirects to bugprone-use-after-move) <hicpp-invalid-access-moved>
    hicpp-member-init (redirects to cppcoreguidelines-pro-type-member-init) <hicpp-member-init>
-   hicpp-move-const-arg (redirects to misc-move-const-arg) <hicpp-move-const-arg>
+   hicpp-move-const-arg (redirects to performance-move-const-arg) <hicpp-move-const-arg>
    hicpp-named-parameter (redirects to readability-named-parameter) <hicpp-named-parameter>
    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>
.. toctree::
    misc-definitions-in-headers
    misc-forwarding-reference-overload
    misc-incorrect-roundings
    misc-lambda-function-name
    misc-macro-parentheses
    misc-macro-repeated-side-effects
    misc-misplaced-const
    misc-misplaced-widening-cast
-   misc-move-const-arg
    misc-new-delete-overloads
-   misc-noexcept-move-constructor
    misc-non-copyable-objects
    misc-redundant-expression
    misc-sizeof-container
    misc-sizeof-expression
    misc-static-assert
    misc-string-compare
    misc-string-integer-assignment
    misc-string-literal-with-embedded-nul
.. toctree::
    objc-forbidden-subclassing
    objc-property-declaration
    performance-faster-string-find
    performance-for-range-copy
    performance-implicit-conversion-in-loop
    performance-inefficient-algorithm
    performance-inefficient-string-concatenation
    performance-inefficient-vector-operation
+   performance-move-const-arg
    performance-move-constructor-init
+   performance-noexcept-move-constructor
    performance-type-promotion-in-math-fn
    performance-unnecessary-copy-initialization
    performance-unnecessary-value-param
    readability-avoid-const-params-in-decls
    readability-braces-around-statements
    readability-container-size-empty
    readability-delete-null-pointer
    readability-deleted-default

docs/clang-tidy/checks/performance-move-const-arg.rst

-.. title:: clang-tidy - misc-move-const-arg
+.. title:: clang-tidy - performance-move-const-arg
 
-misc-move-const-arg
-===================
+performance-move-const-arg
+==========================
 
 The check warns
 
 - if ``std::move()`` is called with a constant argument,
 
 - if ``std::move()`` is called with an argument of a trivially-copyable type,
 
 - if the result of ``std::move()`` is passed as a const reference argument.

docs/clang-tidy/checks/performance-noexcept-move-constructor.rst

-.. title:: clang-tidy - misc-noexcept-move-constructor
+.. title:: clang-tidy - performance-noexcept-move-constructor
 
-misc-noexcept-move-constructor
-==============================
+performance-noexcept-move-constructor
+=====================================
 
 
 The check flags user-defined move constructors and assignment operators not
 marked with ``noexcept`` or marked with ``noexcept(expr)`` where ``expr``
 evaluates to ``false`` (but is not a ``false`` literal itself).
 
 Move constructors of all the types used with STL containers, for example,
 need to be declared ``noexcept``. Otherwise STL will choose copy constructors
 instead. The same is valid for move assignment operations.

test/clang-tidy/modernize-pass-by-value.cpp

struct S {
   S(Movable &&M) : M(M) {}
   // CHECK-FIXES: S(Movable &&M) : M(M) {}
   Movable M;
 };
 
 template <typename T, int N> struct array { T A[N]; };
 
 // Test that types that are trivially copyable will not use std::move. This will
-// cause problems with misc-move-const-arg, as it will revert it.
+// cause problems with performance-move-const-arg, as it will revert it.
 struct T {
   T(array<int, 10> a) : a_(a) {}
   // CHECK-FIXES: T(array<int, 10> a) : a_(a) {}
   array<int, 10> a_;
 };
 
 struct U {
   U(const POD &M) : M(M) {}
   POD M;
 };

test/clang-tidy/performance-move-const-arg.cpp

-// RUN: %check_clang_tidy %s misc-move-const-arg %t
+// RUN: %check_clang_tidy %s performance-move-const-arg %t
 
 namespace std {
-template <typename> struct remove_reference;
+template <typename>
+struct remove_reference;
 
-template <typename _Tp> struct remove_reference { typedef _Tp type; };
+template <typename _Tp>
+struct remove_reference {
+  typedef _Tp type;
+};
 
-template <typename _Tp> struct remove_reference<_Tp &> { typedef _Tp type; };
+template <typename _Tp>
+struct remove_reference<_Tp &> {
+  typedef _Tp type;
+};
 
-template <typename _Tp> struct remove_reference<_Tp &&> { typedef _Tp type; };
+template <typename _Tp>
+struct remove_reference<_Tp &&> {
+  typedef _Tp type;
+};
 
 template <typename _Tp>
 constexpr typename std::remove_reference<_Tp>::type &&move(_Tp &&__t) {
   return static_cast<typename std::remove_reference<_Tp>::type &&>(__t);
 }
 
-} // namespace std
+}  // namespace std
 
 class A {
  public:
   A() {}
   A(const A &rhs) {}
   A(A &&rhs) {}
 };
 
 int f1() {
   return std::move(42);
-  // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: std::move of the expression of the trivially-copyable type 'int' has no effect; remove std::move() [misc-move-const-arg]
-  // CHECK-FIXES: return 42;
+  // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: std::move of the expression of
+  // the trivially-copyable type 'int' has no effect; remove std::move()
+  // [performance-move-const-arg] CHECK-FIXES: return 42;
 }
 
 int f2(int x2) {
   return std::move(x2);
-  // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: std::move of the variable 'x2' of the trivially-copyable type 'int'
-  // CHECK-FIXES: return x2;
+  // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: std::move of the variable 'x2' of
+  // the trivially-copyable type 'int' CHECK-FIXES: return x2;
 }
 
 int *f3(int *x3) {
   return std::move(x3);
-  // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: std::move of the variable 'x3' of the trivially-copyable type 'int *'
-  // CHECK-FIXES: return x3;
+  // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: std::move of the variable 'x3' of
+  // the trivially-copyable type 'int *' CHECK-FIXES: return x3;
 }
 
 A f4(A x4) { return std::move(x4); }
 
 A f5(const A x5) {
   return std::move(x5);
-  // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: std::move of the const variable 'x5' has no effect; remove std::move() or make the variable non-const [misc-move-const-arg]
-  // CHECK-FIXES: return x5;
+  // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: std::move of the const variable
+  // 'x5' has no effect; remove std::move() or make the variable non-const
+  // [performance-move-const-arg] CHECK-FIXES: return x5;
 }
 
-template <typename T> T f6(const T x6) { return std::move(x6); }
+template <typename T>
+T f6(const T x6) {
+  return std::move(x6);
+}
 
 void f7() { int a = f6(10); }
 
 #define M1(x) x
 void f8() {
   const A a;
   M1(A b = std::move(a);)
-  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: std::move of the const variable 'a' has no effect; remove std::move() or make the variable non-const
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: std::move of the const variable
+  // 'a' has no effect; remove std::move() or make the variable non-const
   // CHECK-FIXES: M1(A b = a;)
 }
 
 #define M2(x) std::move(x)
 int f9() { return M2(1); }
 
-template <typename T> T f10(const int x10) {
+template <typename T>
+T f10(const int x10) {
   return std::move(x10);
-  // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: std::move of the const variable 'x10' of the trivially-copyable type 'const int' has no effect; remove std::move() [misc-move-const-arg]
-  // CHECK-FIXES: return x10;
+  // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: std::move of the const variable
+  // 'x10' of the trivially-copyable type 'const int' has no effect; remove
+  // std::move() [performance-move-const-arg] CHECK-FIXES: return x10;
 }
 void f11() {
   f10<int>(1);
   f10<double>(1);
 }
 
 class NoMoveSemantics {
  public:
void moveToConstReferenceNegatives() {
   // a lambda that is, in turn, an argument to a macro.
   CALL([no_move_semantics] { M3(NoMoveSemantics, no_move_semantics); });
 
   auto lambda = [] {};
   auto lambda2 = std::move(lambda);
 }
 
 class MoveOnly {
  public:
   MoveOnly(const MoveOnly &other) = delete;
   MoveOnly &operator=(const MoveOnly &other) = delete;
   MoveOnly(MoveOnly &&other) = default;
   MoveOnly &operator=(MoveOnly &&other) = default;
 };
 template <class T>
 void Q(T);
-void moveOnlyNegatives(MoveOnly val) {
-  Q(std::move(val));
-}
+void moveOnlyNegatives(MoveOnly val) { Q(std::move(val)); }

test/clang-tidy/performance-noexcept-move-constructor.cpp

-// RUN: %check_clang_tidy %s misc-noexcept-move-constructor %t
+// RUN: %check_clang_tidy %s performance-noexcept-move-constructor %t
 
 class A {
   A(A &&);
-  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: move constructors should be marked noexcept [misc-noexcept-move-constructor]
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: move constructors should be marked
+  // noexcept [performance-noexcept-move-constructor]
   A &operator=(A &&);
   // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: move assignment operators should
 };
 
 struct B {
   static constexpr bool kFalse = false;
   B(B &&) noexcept(kFalse);
-  // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: noexcept specifier on the move constructor evaluates to 'false' [misc-noexcept-move-constructor]
+  // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: noexcept specifier on the move
+  // constructor evaluates to 'false' [performance-noexcept-move-constructor]
 };
 
 class OK {};
 
 void f() {
   OK a;
   a = OK();
 }
 
 class OK1 {
  public:
   OK1();
   OK1(const OK1 &);
-  OK1(OK1&&) noexcept;
+  OK1(OK1 &&) noexcept;
   OK1 &operator=(OK1 &&) noexcept;
   void f();
   void g() noexcept;
 };
 
 class OK2 {
   static constexpr bool kTrue = true;
 
  public:
   OK2(OK2 &&) noexcept(true) {}
   OK2 &operator=(OK2 &&) noexcept(kTrue) { return *this; }
 };
 
 struct OK3 {
   OK3(OK3 &&) noexcept(false) {}
   OK3 &operator=(OK3 &&) = delete;
 };