[clang-tidy] Improve `performance-move-const-arg` message when no move constructor is available

[AMS21]

Summary

We now display a simple note if the reason is that the used class does not
support move semantics.

This fixes llvm#62550

[AMS21]

clang-tools-extra/test/clang-tidy/checkers/performance/move-const-arg.cpp

482

I've tried to add

// CHECK-MESSAGES: [[@LINE+1]]:1: note: 'NonMoveConstructable' is not move constructible

here. But doing so actually fails the tests and I'm not quite sure why.

[PiotrZSL]

Overall looks ok,
Add some test with records being used via typedef.

clang-tools-extra/clang-tidy/performance/MoveConstArgCheck.cpp

117

make sure you use here canonical type, or it may not work correctly with typedefs, like typedefs to records.
same in line 120, in fact only on line 154 would be good to use original type.

209

getLocation ()

211

<< RecordDecl
should work, do not use getName, it could cause crash for unnamed records.

clang-tools-extra/docs/ReleaseNotes.rst

382

"check to warn when ..."

clang-tools-extra/test/clang-tidy/checkers/performance/move-const-arg.cpp

482

There are 2 ways to deal with this.
If you use CHECK-MESSAGES, then order of issues is checked, and that why for current notes you may see thing like @LINE-27, so you would need to put it into places when its emited.
Other way is to use CHECK-NOTES, then all warnings are checked out of order.
So simply I would put those CHECK-MESSAGES, after a warning in lines 256, 372, 384, 387

[AMS21]

Implement suggested changes
Add tests with typedefs

[PiotrZSL]

+- LGTM

clang-tools-extra/clang-tidy/performance/MoveConstArgCheck.cpp

210

You need t check RecordDecl here also.
like if (...; RecordDecl && !(RecordDecl->hasMoveConstructor() && RecordDecl->hasMoveAssignment()))

212

maybe this should be constructible/assignable depend on what we are missing (constructor, assign operator)...
Simply this may be strange to get warn about construct when we assign.
Still things like std::optional cold use move constructor instead of assign operator on assign.
So this wound need to be checked... It's fine if we won't be very detailed here

clang-tools-extra/docs/ReleaseNotes.rst

382

remove :

[AMS21]

Implemented suggested changes

clang-tools-extra/test/clang-tidy/checkers/performance/move-const-arg.cpp

482

Ah yes that makes total sense. Thanks for clarifying that :)

[PiotrZSL]

LGTM

clang-tools-extra/docs/ReleaseNotes.rst

382–383

NOTE: check to warn when no move constructor is available. -> check to warn when move special member functions are not available. or something similar, to not limit this only to construction

[AMS21]

Improve doc

[AMS21]

As always if there are no more problems, I would kindly ask for someone to push this on my behalf :)

clang-tools-extra/clang-tidy/performance/MoveConstArgCheck.cpp

void MoveConstArgCheck::check(const MatchFinder::MatchResult &Result) {
   // Skipping matchers which have been matched.
   if (!ReceivingExpr && AlreadyCheckedMoves.contains(CallMove))
     return;
 
   if (ReceivingExpr)
     AlreadyCheckedMoves.insert(CallMove);
 
   const Expr *Arg = CallMove->getArg(0);
+  const QualType ArgType = Arg->getType().getCanonicalType();
   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);
+  bool IsConstArg = ArgType.isConstQualified();
+  bool IsTriviallyCopyable = ArgType.isTriviallyCopyableType(*Result.Context);
 
   if (IsConstArg || IsTriviallyCopyable) {
-    if (const CXXRecordDecl *R = Arg->getType()->getAsCXXRecordDecl()) {
+    if (const CXXRecordDecl *R = ArgType->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())
if (IsRVRefParam) {
            DiagnosticIDs::Note)
           << (InvocationParm->getFunctionScopeIndex() + 1) << FunctionName
           << *InvocationParmType << ExpectParmTypeName;
     }
   } else if (ReceivingExpr && CheckMoveToConstRef) {
     if ((*InvocationParmType)->isRValueReferenceType())
       return;
 
+    {
       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());
     }
+
+    if (const CXXRecordDecl *RecordDecl = ArgType->getAsCXXRecordDecl();
+        RecordDecl && !(RecordDecl->hasMoveConstructor() &&
+                        RecordDecl->hasMoveAssignment())) {
+      const bool MissingMoveAssignment = !RecordDecl->hasMoveAssignment();
+      const bool MissingMoveConstructor = !RecordDecl->hasMoveConstructor();
+      const bool MissingBoth = MissingMoveAssignment && MissingMoveConstructor;
+
+      diag(RecordDecl->getLocation(),
+           "%0 is not move "
+           "%select{|assignable}1%select{|/}2%select{|constructible}3",
+           DiagnosticIDs::Note)
+          << RecordDecl << MissingMoveAssignment << MissingBoth
+          << MissingMoveConstructor;
+    }
+  }
 }
 
 } // namespace clang::tidy::performance

clang-tools-extra/docs/ReleaseNotes.rst

- Fixed false positive in :doc:`modernize-use-equals-default
   functions containing macros or preprocessor directives, and out-of-line special
   member functions in unions.
 
 - Improved :doc:`modernize-use-override
   <clang-tidy/checks/modernize/use-override>` check with new
   `IgnoreTemplateInstantiations` option to optionally ignore virtual function
   overrides that are part of template instantiations.
 
+- Improved :doc:`performance-move-const-arg
+  <clang-tidy/checks/performance/move-const-arg>` check to warn when move
+  special member functions are not available.
+
 - Improved :doc:`performance-no-automatic-move
   <clang-tidy/checks/performance/no-automatic-move>`: warn on ``const &&``
   constructors.
 
 - Fixed a false positive in :doc:`performance-no-automatic-move
   <clang-tidy/checks/performance/no-automatic-move>` when warning would be
   emitted for a const local variable to which NRVO is applied.
 

clang-tools-extra/test/clang-tidy/checkers/performance/move-const-arg.cpp

 
 class A {
 public:
   A() {}
   A(const A &rhs) {}
   A(A &&rhs) {}
 };
 
+using AlsoA = A;
+
 struct TriviallyCopyable {
   int i;
 };
 
+using TrivialAlias = TriviallyCopyable;
+
 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);
+
+  TrivialAlias obj2;
+  f(std::move(obj2));
+  // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: std::move of the variable 'obj2' of the trivially-copyable type 'TrivialAlias' (aka 'TriviallyCopyable') has no effect; remove std::move() [performance-move-const-arg]
+  // CHECK-FIXES: f(obj2);
 }
 
 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); }
 
+AlsoA f4_a(AlsoA 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;
 }
 
+AlsoA f5_a(const AlsoA 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

 class NoMoveSemantics {
 public:
   NoMoveSemantics();
   NoMoveSemantics(const NoMoveSemantics &);
 
   NoMoveSemantics &operator=(const NoMoveSemantics &);
 };
 
+using NoMoveSemanticsAlias = NoMoveSemantics;
+
 void callByConstRef(const NoMoveSemantics &);
 void callByConstRef(int i, const NoMoveSemantics &);
 
 void moveToConstReferencePositives() {
   NoMoveSemantics obj;
 
   // Basic case.
   callByConstRef(std::move(obj));
void moveToConstReferencePositives() {
   // 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;
 }
 
+void moveToConstReferencePositivesAlias() {
+  NoMoveSemanticsAlias obj;
+
+  // Basic 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);
+
+  // Also works for second argument.
+  callByConstRef(1, std::move(obj));
+  // CHECK-MESSAGES: :[[@LINE-1]]:21: warning: passing result of std::move() as a const reference argument; no move will actually happen [performance-move-const-arg]
+  // CHECK-FIXES: callByConstRef(1, obj);
+
+  // Works if std::move() applied to a temporary.
+  callByConstRef(std::move(NoMoveSemanticsAlias()));
+  // 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(NoMoveSemanticsAlias());
+
+  // Works if calling a copy constructor.
+  NoMoveSemanticsAlias other(std::move(obj));
+  // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: passing result of std::move() as a const reference argument; no move will actually happen [performance-move-const-arg]
+  // CHECK-FIXES: NoMoveSemanticsAlias other(obj);
+
+  // Works if calling assignment operator.
+  other = std::move(obj);
+  // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: passing result of std::move() as a const reference argument; no move will actually happen [performance-move-const-arg]
+  // CHECK-FIXES: other = obj;
+}
+
 class MoveSemantics {
 public:
   MoveSemantics();
   MoveSemantics(MoveSemantics &&);
 
   MoveSemantics &operator=(MoveSemantics &&);
 };
 
+using MoveSemanticsAlias = MoveSemantics;
+
 void callByValue(MoveSemantics);
 
 void callByRValueRef(MoveSemantics &&);
 
 template <class T>
 void templateFunction(T obj) {
   T other = std::move(obj);
 }
void moveToConstReferenceNegatives() {
   // 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);
 }
 
+void moveToConstReferenceNegativesAlias() {
+  // No warning when actual move takes place.
+  MoveSemanticsAlias move_semantics;
+  callByValue(std::move(move_semantics));
+  callByRValueRef(std::move(move_semantics));
+  MoveSemanticsAlias other(std::move(move_semantics));
+  other = std::move(move_semantics);
+
+  // No warning if std::move() not used.
+  NoMoveSemanticsAlias no_move_semantics;
+  callByConstRef(no_move_semantics);
+
+  // No warning if instantiating a template.
+  templateFunction(no_move_semantics);
+
+  // No warning inside of macro expansions.
+  M3(NoMoveSemanticsAlias, 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(NoMoveSemanticsAlias, 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));
 }
 
+using MoveOnlyAlias = MoveOnly;
+
 void fmovable(MoveSemantics);
 
 void lambda1() {
   auto f = [](MoveSemantics m) {
     fmovable(std::move(m));
   };
   f(MoveSemantics());
 }

 };
 
 void functionInvocation() {
   function<void(MoveSemantics)> callback;
   MoveSemantics m;
   callback(std::move(m));
 }
 
+void functionInvocationAlias() {
+  function<void(MoveSemanticsAlias)> callback;
+  MoveSemanticsAlias 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());
 }
 
+void lambda2Alias() {
+  function<void(MoveSemanticsAlias)> callback;
+
+  auto f = [callback = std::move(callback)](MoveSemanticsAlias m) mutable {
+    // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: std::move of the variable 'callback' of the trivially-copyable type 'function<void (MoveSemanticsAlias)>' (aka 'function<void (MoveSemantics)>') has no effect; remove std::move() [performance-move-const-arg]
+    // CHECK-FIXES: auto f = [callback = callback](MoveSemanticsAlias m) mutable {
+    callback(std::move(m));
+  };
+  f(MoveSemanticsAlias());
+}
+
 void showInt(int &&v);
 void showInt(int v1, int &&v2);
 void showPointer(const char *&&s);
 void showPointer2(const char *const &&s);
 void showTriviallyCopyable(TriviallyCopyable &&obj);
 void showTriviallyCopyablePointer(const TriviallyCopyable *&&obj);
 void testFunctions() {
   int a = 10;
   showInt(std::move(a));
   // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: std::move of the variable 'a' of the trivially-copyable type 'int' has no effect [performance-move-const-arg]
   // CHECK-MESSAGES: :[[@LINE-10]]:20: note: consider changing the 1st parameter of 'showInt' from 'int &&' to 'const int &'
   showInt(int());
   showInt(a, std::move(a));
   // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: std::move of the variable 'a' of the trivially-copyable type 'int' has no effect [performance-move-const-arg]
   // CHECK-MESSAGES: :[[@LINE-13]]:28: note: consider changing the 2nd parameter of 'showInt' from 'int &&' to 'const int &'
   const char* s = "";
   showPointer(std::move(s));
   // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: std::move of the variable 's' of the trivially-copyable type 'const char *' has no effect [performance-move-const-arg]
   // CHECK-MESSAGES: :[[@LINE-16]]:32: note: consider changing the 1st parameter of 'showPointer' from 'const char *&&' to 'const char *'
-  showPointer2(std::move(s)); 
+  showPointer2(std::move(s));
   // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: std::move of the variable 's' of the trivially-copyable type 'const char *' has no effect [performance-move-const-arg]
   // CHECK-MESSAGES: :[[@LINE-18]]:39: note: consider changing the 1st parameter of 'showPointer2' from 'const char *const &&' to 'const char *const'
   TriviallyCopyable *obj = new TriviallyCopyable();
   showTriviallyCopyable(std::move(*obj));
   // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: std::move of the expression of the trivially-copyable type 'TriviallyCopyable' has no effect [performance-move-const-arg]
   // CHECK-MESSAGES: :[[@LINE-21]]:48: note: consider changing the 1st parameter of 'showTriviallyCopyable' from 'TriviallyCopyable &&' to 'const TriviallyCopyable &'
   showTriviallyCopyablePointer(std::move(obj));
   // CHECK-MESSAGES: :[[@LINE-1]]:32: warning: std::move of the variable 'obj' of the trivially-copyable type 'TriviallyCopyable *' has no effect [performance-move-const-arg]
   // CHECK-MESSAGES: :[[@LINE-23]]:62: note: consider changing the 1st parameter of 'showTriviallyCopyablePointer' from 'const TriviallyCopyable *&&' to 'const TriviallyCopyable *'
+  TrivialAlias* obj2 = new TrivialAlias();
+  showTriviallyCopyable(std::move(*obj));
+  // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: std::move of the expression of the trivially-copyable type 'TriviallyCopyable' has no effect [performance-move-const-arg]
+  // CHECK-MESSAGES: :[[@LINE-28]]:48: note: consider changing the 1st parameter of 'showTriviallyCopyable' from 'TriviallyCopyable &&' to 'const TriviallyCopyable &'
+  showTriviallyCopyablePointer(std::move(obj));
+  // CHECK-MESSAGES: :[[@LINE-1]]:32: warning: std::move of the variable 'obj' of the trivially-copyable type 'TriviallyCopyable *' has no effect [performance-move-const-arg]
+  // CHECK-MESSAGES: :[[@LINE-30]]:62: note: consider changing the 1st parameter of 'showTriviallyCopyablePointer' from 'const TriviallyCopyable *&&' to 'const TriviallyCopyable *'
 }
 template <class T>
 void forwardToShowInt(T && t) {
   showInt(static_cast<T &&>(t));
 }
 void testTemplate() {
   int a = 10;
   forwardToShowInt(std::move(a));
   // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: std::move of the variable 'a' of the trivially-copyable type 'int' has no effect [performance-move-const-arg]
 }
 
 struct Tmp {
   Tmp();
   Tmp(int &&a);
   Tmp(int v1, int &&a);
   Tmp(const char *&&s);
   Tmp(TriviallyCopyable&& obj);
   Tmp(const TriviallyCopyable *&&obj);
   void showTmp(TriviallyCopyable&& t);
   static void showTmpStatic(TriviallyCopyable&& t);
 };
+using TmpAlias = Tmp;
+
 void testMethods() {
   Tmp t;
   int a = 10;
   Tmp t1(std::move(a));
   // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: std::move of the variable 'a' of the trivially-copyable type 'int' has no effect [performance-move-const-arg]
-  // CHECK-MESSAGES: :[[@LINE-13]]:13: note: consider changing the 1st parameter of 'Tmp' from 'int &&' to 'const int &'
+  // CHECK-MESSAGES: :[[@LINE-15]]:13: note: consider changing the 1st parameter of 'Tmp' from 'int &&' to 'const int &'
   Tmp t2(a, std::move(a));
   // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: std::move of the variable 'a' of the trivially-copyable type 'int' has no effect [performance-move-const-arg]
-  // CHECK-MESSAGES: :[[@LINE-15]]:21: note: consider changing the 2nd parameter of 'Tmp' from 'int &&' to 'const int &'
+  // CHECK-MESSAGES: :[[@LINE-17]]:21: note: consider changing the 2nd parameter of 'Tmp' from 'int &&' to 'const int &'
   const char* s = "";
   Tmp t3(std::move(s));
   // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: std::move of the variable 's' of the trivially-copyable type 'const char *' has no effect [performance-move-const-arg]
-  // CHECK-MESSAGES: :[[@LINE-18]]:21: note: consider changing the 1st parameter of 'Tmp' from 'const char *&&' to 'const char *'
+  // CHECK-MESSAGES: :[[@LINE-20]]:21: note: consider changing the 1st parameter of 'Tmp' from 'const char *&&' to 'const char *'
   TriviallyCopyable *obj = new TriviallyCopyable();
   Tmp t4(std::move(*obj));
   // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: std::move of the expression of the trivially-copyable type 'TriviallyCopyable' has no effect [performance-move-const-arg]
-  // CHECK-MESSAGES: :[[@LINE-21]]:27: note: consider changing the 1st parameter of 'Tmp' from 'TriviallyCopyable &&' to 'const TriviallyCopyable &'
+  // CHECK-MESSAGES: :[[@LINE-23]]:27: note: consider changing the 1st parameter of 'Tmp' from 'TriviallyCopyable &&' to 'const TriviallyCopyable &'
   Tmp t5(std::move(obj));
   // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: std::move of the variable 'obj' of the trivially-copyable type 'TriviallyCopyable *' has no effect [performance-move-const-arg]
-  // CHECK-MESSAGES: :[[@LINE-23]]:34: note: consider changing the 1st parameter of 'Tmp' from 'const TriviallyCopyable *&&' to 'const TriviallyCopyable *'
+  // CHECK-MESSAGES: :[[@LINE-25]]:34: note: consider changing the 1st parameter of 'Tmp' from 'const TriviallyCopyable *&&' to 'const TriviallyCopyable *'
   t.showTmp(std::move(*obj));
   // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: std::move of the expression of the trivially-copyable type 'TriviallyCopyable' has no effect [performance-move-const-arg]
-  // CHECK-MESSAGES: :[[@LINE-25]]:36: note: consider changing the 1st parameter of 'showTmp' from 'TriviallyCopyable &&' to 'const TriviallyCopyable &'
+  // CHECK-MESSAGES: :[[@LINE-27]]:36: note: consider changing the 1st parameter of 'showTmp' from 'TriviallyCopyable &&' to 'const TriviallyCopyable &'
   Tmp::showTmpStatic(std::move(*obj));
   // CHECK-MESSAGES: :[[@LINE-1]]:22: warning: std::move of the expression of the trivially-copyable type 'TriviallyCopyable' has no effect [performance-move-const-arg]
-  // CHECK-MESSAGES: :[[@LINE-27]]:49: note: consider changing the 1st parameter of 'showTmpStatic' from 'TriviallyCopyable &&' to 'const TriviallyCopyable &'
+  // CHECK-MESSAGES: :[[@LINE-29]]:49: note: consider changing the 1st parameter of 'showTmpStatic' from 'TriviallyCopyable &&' to 'const TriviallyCopyable &'
+}
+
+void testMethodsAlias() {
+  TmpAlias t;
+  int a = 10;
+  TmpAlias t1(std::move(a));
+  // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: std::move of the variable 'a' of the trivially-copyable type 'int' has no effect [performance-move-const-arg]
+  // CHECK-MESSAGES: :[[@LINE-43]]:13: note: consider changing the 1st parameter of 'Tmp' from 'int &&' to 'const int &'
+  TmpAlias t2(a, std::move(a));
+  // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: std::move of the variable 'a' of the trivially-copyable type 'int' has no effect [performance-move-const-arg]
+  // CHECK-MESSAGES: :[[@LINE-45]]:21: note: consider changing the 2nd parameter of 'Tmp' from 'int &&' to 'const int &'
+  const char* s = "";
+  TmpAlias t3(std::move(s));
+  // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: std::move of the variable 's' of the trivially-copyable type 'const char *' has no effect [performance-move-const-arg]
+  // CHECK-MESSAGES: :[[@LINE-48]]:21: note: consider changing the 1st parameter of 'Tmp' from 'const char *&&' to 'const char *'
+  TrivialAlias *obj = new TrivialAlias();
+  TmpAlias t4(std::move(*obj));
+  // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: std::move of the expression of the trivially-copyable type 'TrivialAlias' (aka 'TriviallyCopyable') has no effect [performance-move-const-arg]
+  // CHECK-MESSAGES: :[[@LINE-51]]:27: note: consider changing the 1st parameter of 'Tmp' from 'TriviallyCopyable &&' to 'const TriviallyCopyable &'
+  TmpAlias t5(std::move(obj));
+  // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: std::move of the variable 'obj' of the trivially-copyable type 'TrivialAlias *' (aka 'TriviallyCopyable *') has no effect [performance-move-const-arg]
+  // CHECK-MESSAGES: :[[@LINE-53]]:34: note: consider changing the 1st parameter of 'Tmp' from 'const TriviallyCopyable *&&' to 'const TriviallyCopyable *'
+  t.showTmp(std::move(*obj));
+  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: std::move of the expression of the trivially-copyable type 'TrivialAlias' (aka 'TriviallyCopyable') has no effect [performance-move-const-arg]
+  // CHECK-MESSAGES: :[[@LINE-55]]:36: note: consider changing the 1st parameter of 'showTmp' from 'TriviallyCopyable &&' to 'const TriviallyCopyable &'
+  TmpAlias::showTmpStatic(std::move(*obj));
+  // CHECK-MESSAGES: :[[@LINE-1]]:27: warning: std::move of the expression of the trivially-copyable type 'TrivialAlias' (aka 'TriviallyCopyable') has no effect [performance-move-const-arg]
+  // CHECK-MESSAGES: :[[@LINE-57]]:49: note: consider changing the 1st parameter of 'showTmpStatic' from 'TriviallyCopyable &&' to 'const TriviallyCopyable &'
 }
 
 void showA(A &&v) {}
 void testA() {
   A a;
   showA(std::move(a));
 }
 
+void testAAlias() {
+  AlsoA a;
+  showA(std::move(a));
+}
+
 void testFuncPointer() {
   int a = 10;
   void (*choice)(int, int &&);
   choice = showInt;
   choice(std::move(a), std::move(a));
   // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: std::move of the variable 'a' of the trivially-copyable type 'int' has no effect; remove std::move() [performance-move-const-arg]
   // CHECK-FIXES: choice(a, std::move(a));
   // CHECK-MESSAGES: :[[@LINE-3]]:24: warning: std::move of the variable 'a' of the trivially-copyable type 'int' has no effect [performance-move-const-arg]
 }
+
+namespace issue_62550 {
+
+struct NonMoveConstructable {
+  NonMoveConstructable();
+  NonMoveConstructable(const NonMoveConstructable&);
+  NonMoveConstructable& operator=(const NonMoveConstructable&);
+  NonMoveConstructable& operator=(NonMoveConstructable&&);
+};
+
+void testNonMoveConstructible() {
+  NonMoveConstructable t1;
+  NonMoveConstructable t2{std::move(t1)};
+  // CHECK-MESSAGES: :[[@LINE-1]]:27: warning: passing result of std::move() as a const reference argument; no move will actually happen [performance-move-const-arg]
+  // CHECK-MESSAGES: :[[@LINE-11]]:8: note: 'NonMoveConstructable' is not move constructible
+}
+
+struct NonMoveAssignable {
+  NonMoveAssignable();
+  NonMoveAssignable(const NonMoveAssignable&);
+  NonMoveAssignable(NonMoveAssignable&&);
+
+  NonMoveAssignable& operator=(const NonMoveAssignable&);
+};
+
+void testNonMoveAssignable() {
+  NonMoveAssignable t1;
+  NonMoveAssignable t2;
+
+  t2 = std::move(t1);
+  // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: passing result of std::move() as a const reference argument; no move will actually happen [performance-move-const-arg]
+  // CHECK-MESSAGES: :[[@LINE-14]]:8: note: 'NonMoveAssignable' is not move assignable
+}
+
+struct NonMoveable {
+  NonMoveable();
+  NonMoveable(const NonMoveable&);
+  NonMoveable& operator=(const NonMoveable&);
+};
+
+void testNonMoveable() {
+  NonMoveable t1;
+  NonMoveable t2{std::move(t1)};
+  // 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-MESSAGES: :[[@LINE-10]]:8: note: 'NonMoveable' is not move assignable/constructible
+
+  t1 = std::move(t2);
+  // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: passing result of std::move() as a const reference argument; no move will actually happen [performance-move-const-arg]
+  // CHECK-MESSAGES: :[[@LINE-14]]:8: note: 'NonMoveable' is not move assignable/constructible
+}
+
+using AlsoNonMoveable = NonMoveable;
+
+void testAlsoNonMoveable() {
+  AlsoNonMoveable t1;
+  AlsoNonMoveable t2{std::move(t1)};
+  // CHECK-MESSAGES: :[[@LINE-1]]:22: warning: passing result of std::move() as a const reference argument; no move will actually happen [performance-move-const-arg]
+  // CHECK-MESSAGES: :[[@LINE-23]]:8: note: 'NonMoveable' is not move assignable/constructible
+
+  t1 = std::move(t2);
+  // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: passing result of std::move() as a const reference argument; no move will actually happen [performance-move-const-arg]
+  // CHECK-MESSAGES: :[[@LINE-27]]:8: note: 'NonMoveable' is not move assignable/constructible
+}
+
+} // namespace issue_62550