[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

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

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/CMakeLists.txt

add_clang_library(clangTidyHICPPModule
   clangBasic
   clangLex
   clangTidy
   clangTidyBugproneModule
   clangTidyCppCoreGuidelinesModule
   clangTidyGoogleModule
   clangTidyMiscModule
   clangTidyModernizeModule
+  clangTidyPerformanceModule
   clangTidyReadabilityModule
   clangTidyUtils
   )

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/misc/MoveConstantArgumentCheck.h

-//===--- MoveConstantArgumentCheck.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 {
-
-/// Find casts of calculation results to bigger type. Typically from int to
-///
-/// There is one option:
-///
-///   - `CheckTriviallyCopyableMove`: Whether to check for trivially-copyable
-//      types as their objects are not moved but copied. Enabled by default.
-class MoveConstantArgumentCheck : public ClangTidyCheck {
-public:
-  MoveConstantArgumentCheck(StringRef Name, ClangTidyContext *Context)
-      : ClangTidyCheck(Name, Context),
-        CheckTriviallyCopyableMove(
-            Options.get("CheckTriviallyCopyableMove", true)) {}
-  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 CheckTriviallyCopyableMove;
-};
-
-} // namespace misc
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_MOVECONSTANTARGUMENTCHECK_H

clang-tidy/misc/MoveConstantArgumentCheck.cpp

-//===--- MoveConstantArgumentCheck.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 "clang/Lex/Lexer.h"
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-namespace misc {
-
-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::storeOptions(
-    ClangTidyOptions::OptionMap &Opts) {
-  Options.store(Opts, "CheckTriviallyCopyableMove", CheckTriviallyCopyableMove);
-}
-
-void MoveConstantArgumentCheck::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) {
-  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;
-
-  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;
-      // Don't warn when the type is not copyable.
-      for (const auto *Ctor : R->ctors()) {
-        if (Ctor->isCopyConstructor() && Ctor->isDeleted())
-          return;
-      }
-    }
-
-    if (!IsConstArg && IsTriviallyCopyable && !CheckTriviallyCopyableMove)
-      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 "
-                     "%select{|of the trivially-copyable type %5 }2"
-                     "has no effect; remove std::move()"
-                     "%select{| or make the variable non-const}3")
-                << IsConstArg << IsVariable << IsTriviallyCopyable
-                << (IsConstArg && IsVariable && !IsTriviallyCopyable) << Var
-                << Arg->getType();
-
-    ReplaceCallWithArg(CallMove, Diag, SM, getLangOpts());
-  } else if (ReceivingExpr) {
-    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

clang-tidy/misc/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
-
-#include "../ClangTidy.h"
-
-namespace clang {
-namespace tidy {
-namespace misc {
-
-/// 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
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_NOEXCEPTMOVECONSTRUCTORCHECK_H

clang-tidy/misc/NoexceptMoveConstructorCheck.cpp

-//===--- NoexceptMoveConstructorCheck.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 "NoexceptMoveConstructorCheck.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-namespace misc {
-
-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;
-
-  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;
-      MethodType = "constructor";
-    } else if (!Decl->isMoveAssignmentOperator()) {
-      return;
-    }
-
-    const auto *ProtoType = Decl->getType()->getAs<FunctionProtoType>();
-
-    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;
-          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

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

+//===--- 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 performance {
+
+/// Find casts of calculation results to bigger type. Typically from int to
+///
+/// There is one option:
+///
+///   - `CheckTriviallyCopyableMove`: Whether to check for trivially-copyable
+//      types as their objects are not moved but copied. Enabled by default.
+class MoveConstArgCheck : public ClangTidyCheck {
+public:
+  MoveConstArgCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context),
+        CheckTriviallyCopyableMove(
+            Options.get("CheckTriviallyCopyableMove", true)) {}
+  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 CheckTriviallyCopyableMove;
+};
+
+} // namespace performance
+} // namespace tidy
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_MOVECONSTANTARGUMENTCHECK_H

clang-tidy/performance/MoveConstArgCheck.cpp

+//===--- 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 "MoveConstArgCheck.h"
+
+#include "clang/Lex/Lexer.h"
+
+using namespace clang::ast_matchers;
+
+namespace clang {
+namespace tidy {
+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 MoveConstArgCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
+  Options.store(Opts, "CheckTriviallyCopyableMove", CheckTriviallyCopyableMove);
+}
+
+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 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;
+
+  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;
+      // Don't warn when the type is not copyable.
+      for (const auto *Ctor : R->ctors()) {
+        if (Ctor->isCopyConstructor() && Ctor->isDeleted())
+          return;
+      }
+    }
+
+    if (!IsConstArg && IsTriviallyCopyable && !CheckTriviallyCopyableMove)
+      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 "
+                     "%select{|of the trivially-copyable type %5 }2"
+                     "has no effect; remove std::move()"
+                     "%select{| or make the variable non-const}3")
+                << IsConstArg << IsVariable << IsTriviallyCopyable
+                << (IsConstArg && IsVariable && !IsTriviallyCopyable) << Var
+                << Arg->getType();
+
+    ReplaceCallWithArg(CallMove, Diag, SM, getLangOpts());
+  } else if (ReceivingExpr) {
+    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 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_PERFORMANCE_NOEXCEPTMOVECONSTRUCTORCHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_NOEXCEPTMOVECONSTRUCTORCHECK_H
+
+#include "../ClangTidy.h"
+
+namespace clang {
+namespace tidy {
+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 performance
+} // namespace tidy
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_NOEXCEPTMOVECONSTRUCTORCHECK_H

clang-tidy/performance/NoexceptMoveConstructorCheck.cpp

+//===--- NoexceptMoveConstructorCheck.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 "NoexceptMoveConstructorCheck.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+
+using namespace clang::ast_matchers;
+
+namespace clang {
+namespace tidy {
+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;
+
+  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;
+      MethodType = "constructor";
+    } else if (!Decl->isMoveAssignmentOperator()) {
+      return;
+    }
+
+    const auto *ProtoType = Decl->getType()->getAs<FunctionProtoType>();
+
+    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;
+        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 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-tidy
 --------------------------
 
 - New `objc-avoid-spinlock
   <http://clang.llvm.org/extra/clang-tidy/checks/objc-avoid-spinlock.html>`_ check
 
   Add new check to detect the use of OSSpinlock.
 
+- 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/misc-move-const-arg.rst

-.. title:: clang-tidy - misc-move-const-arg
-
-misc-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.
-
-In all three cases, the check will suggest a fix that removes the
-``std::move()``.
-
-Here are examples of each of the three cases:
-
-.. code-block:: c++
-
-  const string s;
-  return std::move(s);  // Warning: std::move of the const variable has no effect
-
-  int x;
-  return std::move(x);  // Warning: std::move of the variable of a trivially-copyable type has no effect
-
-  void f(const string &s);
-  string s;
-  f(std::move(s));  // Warning: passing result of std::move as a const reference argument; no move will actually happen
-
-Options
--------
-
-.. option:: CheckTriviallyCopyableMove
-
-   If non-zero, enables detection of trivially copyable types that do not
-   have a move constructor. Default is non-zero.

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

-.. title:: clang-tidy - misc-noexcept-move-constructor
-
-misc-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.

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

+.. title:: clang-tidy - performance-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.
+
+In all three cases, the check will suggest a fix that removes the
+``std::move()``.
+
+Here are examples of each of the three cases:
+
+.. code-block:: c++
+
+  const string s;
+  return std::move(s);  // Warning: std::move of the const variable has no effect
+
+  int x;
+  return std::move(x);  // Warning: std::move of the variable of a trivially-copyable type has no effect
+
+  void f(const string &s);
+  string s;
+  f(std::move(s));  // Warning: passing result of std::move as a const reference argument; no move will actually happen
+
+Options
+-------
+
+.. option:: CheckTriviallyCopyableMove
+
+   If non-zero, enables detection of trivially copyable types that do not
+   have a move constructor. Default is non-zero.

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

+.. title:: clang-tidy - performance-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/misc-move-const-arg-trivially-copyable.cpp

-// RUN: %check_clang_tidy %s misc-move-const-arg %t \
-// RUN: -config='{CheckOptions: \
-// RUN:  [{key: misc-move-const-arg.CheckTriviallyCopyableMove, value: 0}]}' \
-// RUN: -- -std=c++14
-
-namespace std {
-
-template <typename> struct remove_reference;
-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>
-constexpr typename std::remove_reference<_Tp>::type &&move(_Tp &&__t) {
-  return static_cast<typename std::remove_reference<_Tp>::type &&>(__t);
-}
-
-template <typename _Tp>
-constexpr _Tp &&
-forward(typename remove_reference<_Tp>::type &__t) noexcept {
-  return static_cast<_Tp &&>(__t);
-}
-
-} // namespace std
-
-class NoMoveSemantics {
- public:
-  NoMoveSemantics();
-  NoMoveSemantics(const NoMoveSemantics &);
-
-  NoMoveSemantics &operator=(const NoMoveSemantics &);
-};
-
-void callByConstRef(const NoMoveSemantics &);
-void callByConstRef(int i, const NoMoveSemantics &);
-
-void moveToConstReferencePositives() {
-  NoMoveSemantics obj;
-
-  // Basic case. It is here just to have a single "detected and fixed" case.
-  callByConstRef(std::move(obj));
-  // CHECK-MESSAGES: :[[@LINE-1]]:18:  warning: passing result of std::move() as a const reference argument; no move will actually happen [misc-move-const-arg]
-  // CHECK-FIXES: callByConstRef(obj);
-}
-
-struct TriviallyCopyable {
-  int i;
-};
-
-void f(TriviallyCopyable) {}
-
-void g() {
-  TriviallyCopyable obj;
-  f(std::move(obj));
-}
-
-class MoveSemantics {
- public:
-  MoveSemantics();
-  MoveSemantics(MoveSemantics &&);
-
-  MoveSemantics &operator=(MoveSemantics &&);
-};
-
-void fmovable(MoveSemantics);
-
-void lambda1() {
-  auto f = [](MoveSemantics m) {
-    fmovable(std::move(m));
-  };
-  f(MoveSemantics());
-}
-
-template<class T> struct function {};
-
-template<typename Result, typename... Args>
-class function<Result(Args...)> {
-public:
-  function() = default;
-  void operator()(Args... args) const {
-    fmovable(std::forward<Args>(args)...);
-  }
-};
-
-void functionInvocation() {
-  function<void(MoveSemantics)> callback;
-  MoveSemantics m;
-  callback(std::move(m));
-}
-
-void lambda2() {
-  function<void(MoveSemantics)> callback;
-
-  auto f = [callback = std::move(callback)](MoveSemantics m) mutable {
-    callback(std::move(m));
-  };
-  f(MoveSemantics());
-}

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

-// RUN: %check_clang_tidy %s misc-move-const-arg %t
-
-namespace std {
-template <typename> struct remove_reference;
-
-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>
-constexpr typename std::remove_reference<_Tp>::type &&move(_Tp &&__t) {
-  return static_cast<typename std::remove_reference<_Tp>::type &&>(__t);
-}
-
-template <typename _Tp>
-constexpr _Tp &&
-forward(typename remove_reference<_Tp>::type &__t) noexcept {
-  return static_cast<_Tp &&>(__t);
-}
-
-} // namespace std
-
-class A {
-public:
-  A() {}
-  A(const A &rhs) {}
-  A(A &&rhs) {}
-};
-
-struct TriviallyCopyable {
-  int i;
-};
-
-void f(TriviallyCopyable) {}
-
-void g() {
-  TriviallyCopyable obj;
-  f(std::move(obj));
-  // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: std::move of the variable 'obj' of the trivially-copyable type 'TriviallyCopyable' has no effect; remove std::move() [misc-move-const-arg]
-  // CHECK-FIXES: f(obj);
-}
-
-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;
-}
-
-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;
-}
-
-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;
-}
-
-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;
-}
-
-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-FIXES: M1(A b = a;)
-}
-
-#define M2(x) std::move(x)
-int f9() { return M2(1); }
-
-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;
-}
-void f11() {
-  f10<int>(1);
-  f10<double>(1);
-}
-
-class NoMoveSemantics {
- public:
-  NoMoveSemantics();
-  NoMoveSemantics(const NoMoveSemantics &);
-
-  NoMoveSemantics &operator=(const NoMoveSemantics &);
-};
-
-void callByConstRef(const NoMoveSemantics &);
-void callByConstRef(int i, const NoMoveSemantics &);
-
-void moveToConstReferencePositives() {
-  NoMoveSemantics obj;
-
-  // Basic case.
-  callByConstRef(std::move(obj));
-  // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: passing result of std::move() as
-  // CHECK-FIXES: callByConstRef(obj);
-
-  // Also works for second argument.
-  callByConstRef(1, std::move(obj));
-  // CHECK-MESSAGES: :[[@LINE-1]]:21: warning: passing result of std::move() as
-  // CHECK-FIXES: callByConstRef(1, obj);
-
-  // Works if std::move() applied to a temporary.
-  callByConstRef(std::move(NoMoveSemantics()));
-  // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: passing result of std::move() as
-  // CHECK-FIXES: callByConstRef(NoMoveSemantics());
-
-  // Works if calling a copy constructor.
-  NoMoveSemantics other(std::move(obj));
-  // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: passing result of std::move() as
-  // CHECK-FIXES: NoMoveSemantics other(obj);
-
-  // Works if calling assignment operator.
-  other = std::move(obj);
-  // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: passing result of std::move() as
-  // CHECK-FIXES: other = obj;
-}
-
-class MoveSemantics {
- public:
-  MoveSemantics();
-  MoveSemantics(MoveSemantics &&);
-
-  MoveSemantics &operator=(MoveSemantics &&);
-};
-
-void callByValue(MoveSemantics);
-
-void callByRValueRef(MoveSemantics &&);
-
-template <class T>
-void templateFunction(T obj) {
-  T other = std::move(obj);
-}
-
-#define M3(T, obj)            \
-  do {                        \
-    T other = std::move(obj); \
-  } while (true)
-
-#define CALL(func) (func)()
-
-void moveToConstReferenceNegatives() {
-  // No warning when actual move takes place.
-  MoveSemantics move_semantics;
-  callByValue(std::move(move_semantics));
-  callByRValueRef(std::move(move_semantics));
-  MoveSemantics other(std::move(move_semantics));
-  other = std::move(move_semantics);
-
-  // No warning if std::move() not used.
-  NoMoveSemantics no_move_semantics;
-  callByConstRef(no_move_semantics);
-
-  // No warning if instantiating a template.
-  templateFunction(no_move_semantics);
-
-  // No warning inside of macro expansions.
-  M3(NoMoveSemantics, no_move_semantics);
-
-  // No warning inside of macro expansion, even if the macro expansion is inside
-  // 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 fmovable(MoveSemantics);
-
-void lambda1() {
-  auto f = [](MoveSemantics m) {
-    fmovable(std::move(m));
-  };
-  f(MoveSemantics());
-}
-
-template<class T> struct function {};
-
-template<typename Result, typename... Args>
-class function<Result(Args...)> {
-public:
-  function() = default;
-  void operator()(Args... args) const {
-    fmovable(std::forward<Args>(args)...);
-  }
-};
-
-void functionInvocation() {
-  function<void(MoveSemantics)> callback;
-  MoveSemantics m;
-  callback(std::move(m));
-}
-
-void lambda2() {
-  function<void(MoveSemantics)> callback;
-
-  auto f = [callback = std::move(callback)](MoveSemantics m) mutable {
-    // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: std::move of the variable 'callback' of the trivially-copyable type 'function<void (MoveSemantics)>' has no effect; remove std::move()
-    // CHECK-FIXES: auto f = [callback = callback](MoveSemantics m) mutable {
-    callback(std::move(m));
-  };
-  f(MoveSemantics());
-}

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

-// RUN: %check_clang_tidy %s misc-noexcept-move-constructor %t
-
-class A {
-  A(A &&);
-  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: move constructors should be marked noexcept [misc-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]
-};
-
-class OK {};
-
-void f() {
-  OK a;
-  a = OK();
-}
-
-class OK1 {
- public:
-  OK1();
-  OK1(const OK1 &);
-  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;
-};
-
-struct OK4 {
-  OK4(OK4 &&) noexcept = default;
-  OK4 &operator=(OK4 &&) noexcept = default;
-};
-
-struct OK5 {
-  OK5(OK5 &&) noexcept(true) = default;
-  OK5 &operator=(OK5 &&) noexcept(true) = default;
-};

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-trivially-copyable.cpp

+// RUN: %check_clang_tidy %s performance-move-const-arg %t \
+// RUN: -config='{CheckOptions: \
+// RUN:  [{key: performance-move-const-arg.CheckTriviallyCopyableMove, value: 0}]}' \
+// RUN: -- -std=c++14
+
+namespace std {
+
+template <typename> struct remove_reference;
+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>
+constexpr typename std::remove_reference<_Tp>::type &&move(_Tp &&__t) {
+  return static_cast<typename std::remove_reference<_Tp>::type &&>(__t);
+}
+
+template <typename _Tp>
+constexpr _Tp &&
+forward(typename remove_reference<_Tp>::type &__t) noexcept {
+  return static_cast<_Tp &&>(__t);
+}
+
+} // namespace std
+
+class NoMoveSemantics {
+ public:
+  NoMoveSemantics();
+  NoMoveSemantics(const NoMoveSemantics &);
+
+  NoMoveSemantics &operator=(const NoMoveSemantics &);
+};
+
+void callByConstRef(const NoMoveSemantics &);
+void callByConstRef(int i, const NoMoveSemantics &);
+
+void moveToConstReferencePositives() {
+  NoMoveSemantics obj;
+
+  // Basic case. It is here just to have a single "detected and fixed" case.
+  callByConstRef(std::move(obj));
+  // CHECK-MESSAGES: :[[@LINE-1]]:18:  warning: passing result of std::move() as a const reference argument; no move will actually happen [performance-move-const-arg]
+  // CHECK-FIXES: callByConstRef(obj);
+}
+
+struct TriviallyCopyable {
+  int i;
+};
+
+void f(TriviallyCopyable) {}
+
+void g() {
+  TriviallyCopyable obj;
+  f(std::move(obj));
+}
+
+class MoveSemantics {
+ public:
+  MoveSemantics();
+  MoveSemantics(MoveSemantics &&);
+
+  MoveSemantics &operator=(MoveSemantics &&);
+};
+
+void fmovable(MoveSemantics);
+
+void lambda1() {
+  auto f = [](MoveSemantics m) {
+    fmovable(std::move(m));
+  };
+  f(MoveSemantics());
+}
+
+template<class T> struct function {};
+
+template<typename Result, typename... Args>
+class function<Result(Args...)> {
+public:
+  function() = default;
+  void operator()(Args... args) const {
+    fmovable(std::forward<Args>(args)...);
+  }
+};
+
+void functionInvocation() {
+  function<void(MoveSemantics)> callback;
+  MoveSemantics m;
+  callback(std::move(m));
+}
+
+void lambda2() {
+  function<void(MoveSemantics)> callback;
+
+  auto f = [callback = std::move(callback)](MoveSemantics m) mutable {
+    callback(std::move(m));
+  };
+  f(MoveSemantics());
+}

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

+// RUN: %check_clang_tidy %s performance-move-const-arg %t
+
+namespace std {
+template <typename>
+struct remove_reference;
+
+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>
+constexpr typename std::remove_reference<_Tp>::type &&move(_Tp &&__t) {
+  return static_cast<typename std::remove_reference<_Tp>::type &&>(__t);
+}
+
+template <typename _Tp>
+constexpr _Tp &&
+forward(typename remove_reference<_Tp>::type &__t) noexcept {
+  return static_cast<_Tp &&>(__t);
+}
+
+} // namespace std
+
+class A {
+public:
+  A() {}
+  A(const A &rhs) {}
+  A(A &&rhs) {}
+};
+
+struct TriviallyCopyable {
+  int i;
+};
+
+void f(TriviallyCopyable) {}
+
+void g() {
+  TriviallyCopyable obj;
+  f(std::move(obj));
+  // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: std::move of the variable 'obj' of the trivially-copyable type 'TriviallyCopyable' has no effect; remove std::move() [performance-move-const-arg]
+  // CHECK-FIXES: f(obj);
+}
+
+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() [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;
+}
+
+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;
+}
+
+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 [performance-move-const-arg]
+  // CHECK-FIXES: return x5;
+}
+
+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-FIXES: M1(A b = a;)
+}
+
+#define M2(x) std::move(x)
+int f9() { return M2(1); }
+
+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() [performance-move-const-arg]
+  // CHECK-FIXES: return x10;
+}
+void f11() {
+  f10<int>(1);
+  f10<double>(1);
+}
+
+class NoMoveSemantics {
+public:
+  NoMoveSemantics();
+  NoMoveSemantics(const NoMoveSemantics &);
+
+  NoMoveSemantics &operator=(const NoMoveSemantics &);
+};
+
+void callByConstRef(const NoMoveSemantics &);
+void callByConstRef(int i, const NoMoveSemantics &);
+
+void moveToConstReferencePositives() {
+  NoMoveSemantics obj;
+
+  // Basic case.
+  callByConstRef(std::move(obj));
+  // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: passing result of std::move() as
+  // CHECK-FIXES: callByConstRef(obj);
+
+  // Also works for second argument.
+  callByConstRef(1, std::move(obj));
+  // CHECK-MESSAGES: :[[@LINE-1]]:21: warning: passing result of std::move() as
+  // CHECK-FIXES: callByConstRef(1, obj);
+
+  // Works if std::move() applied to a temporary.
+  callByConstRef(std::move(NoMoveSemantics()));
+  // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: passing result of std::move() as
+  // CHECK-FIXES: callByConstRef(NoMoveSemantics());
+
+  // Works if calling a copy constructor.
+  NoMoveSemantics other(std::move(obj));
+  // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: passing result of std::move() as
+  // CHECK-FIXES: NoMoveSemantics other(obj);
+
+  // Works if calling assignment operator.
+  other = std::move(obj);
+  // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: passing result of std::move() as
+  // CHECK-FIXES: other = obj;
+}
+
+class MoveSemantics {
+public:
+  MoveSemantics();
+  MoveSemantics(MoveSemantics &&);
+
+  MoveSemantics &operator=(MoveSemantics &&);
+};
+
+void callByValue(MoveSemantics);
+
+void callByRValueRef(MoveSemantics &&);
+
+template <class T>
+void templateFunction(T obj) {
+  T other = std::move(obj);
+}
+
+#define M3(T, obj)            \
+  do {                        \
+    T other = std::move(obj); \
+  } while (true)
+
+#define CALL(func) (func)()
+
+void moveToConstReferenceNegatives() {
+  // No warning when actual move takes place.
+  MoveSemantics move_semantics;
+  callByValue(std::move(move_semantics));
+  callByRValueRef(std::move(move_semantics));
+  MoveSemantics other(std::move(move_semantics));
+  other = std::move(move_semantics);
+
+  // No warning if std::move() not used.
+  NoMoveSemantics no_move_semantics;
+  callByConstRef(no_move_semantics);
+
+  // No warning if instantiating a template.
+  templateFunction(no_move_semantics);
+
+  // No warning inside of macro expansions.
+  M3(NoMoveSemantics, no_move_semantics);
+
+  // No warning inside of macro expansion, even if the macro expansion is inside
+  // 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 fmovable(MoveSemantics);
+
+void lambda1() {
+  auto f = [](MoveSemantics m) {
+    fmovable(std::move(m));
+  };
+  f(MoveSemantics());
+}
+
+template<class T> struct function {};
+
+template<typename Result, typename... Args>
+class function<Result(Args...)> {
+public:
+  function() = default;
+  void operator()(Args... args) const {
+    fmovable(std::forward<Args>(args)...);
+  }
+};
+
+void functionInvocation() {
+  function<void(MoveSemantics)> callback;
+  MoveSemantics m;
+  callback(std::move(m));
+}
+
+void lambda2() {
+  function<void(MoveSemantics)> callback;
+
+  auto f = [callback = std::move(callback)](MoveSemantics m) mutable {
+    // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: std::move of the variable 'callback' of the trivially-copyable type 'function<void (MoveSemantics)>' has no effect; remove std::move()
+    // CHECK-FIXES: auto f = [callback = callback](MoveSemantics m) mutable {
+    callback(std::move(m));
+  };
+  f(MoveSemantics());
+}

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

+// 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 [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' [performance-noexcept-move-constructor]
+};
+
+class OK {};
+
+void f() {
+  OK a;
+  a = OK();
+}
+
+class OK1 {
+public:
+  OK1();
+  OK1(const OK1 &);
+  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;
+};
+
+struct OK4 {
+  OK4(OK4 &&) noexcept = default;
+  OK4 &operator=(OK4 &&) noexcept = default;
+};
+
+struct OK5 {
+  OK5(OK5 &&) noexcept(true) = default;
+  OK5 &operator=(OK5 &&) noexcept(true) = default;
+};