Modify CXXMethodDecl::isMoveAssignmentOperator() to look through type sugar

[shafik]

Summary

Currently CXXMethodDecl::isMoveAssignmentOperator() does not look though type sugar and so if the parameter is a type alias it will not be able to detect that the method is a move assignment operator. This PR fixes that and adds a set of tests that covers that we correctly detect special member functions when defaulting or deleting them.

This fixes: https://github.com/llvm/llvm-project/issues/56456

[aaron.ballman]

LGTM, that's a great catch! You should also add a release note for the fix (to the bug fixes section) before landing.

[erichkeane]

Code changes LGTM! Thanks!

[shafik]

Adding release notes.

clang/docs/ReleaseNotes.rst

- An initializer for a static variable declaration, which is nested
   emitted as a dynamic initializer. Previously the variable would
   incorrectly be zero-initialized. In contexts where a dynamic
   initializer is not allowed this is now diagnosed as an error.
 - Clang now correctly emits symbols for implicitly instantiated constexpr
   template function. Fixes `Issue 55560 <https://github.com/llvm/llvm-project/issues/55560>`_.
 - Clang now checks ODR violations when merging concepts from different modules.
   Note that this may possibly break existing code, and is done so intentionally.
   Fixes `Issue 56310 <https://github.com/llvm/llvm-project/issues/56310>`_.
+- Clang will now look through type sugar when checking a member function is a
+  move assignment operator. Fixes `Issue 56456 <https://github.com/llvm/llvm-project/issues/56456>`_.
 
 Improvements to Clang's diagnostics
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 - ``-Wliteral-range`` will warn on floating-point equality comparisons with
   constants that are not representable in a casted value. For example,
   ``(float) f == 0.1`` is always false.
 - ``-Winline-namespace-reopened-noninline`` now takes into account that the
   ``inline`` keyword must appear on the original but not necessarily all

clang/lib/AST/DeclCXX.cpp

bool CXXMethodDecl::isMoveAssignmentOperator() const {
   //  non-template member function of class X with exactly one parameter of type
   //  X&&, const X&&, volatile X&&, or const volatile X&&.
   if (getOverloadedOperator() != OO_Equal || isStatic() ||
       getPrimaryTemplate() || getDescribedFunctionTemplate() ||
       getNumParams() != 1)
     return false;
 
   QualType ParamType = getParamDecl(0)->getType();
-  if (!isa<RValueReferenceType>(ParamType))
+  if (!ParamType->isRValueReferenceType())
     return false;
   ParamType = ParamType->getPointeeType();
 
   ASTContext &Context = getASTContext();
   QualType ClassType
     = Context.getCanonicalType(Context.getTypeDeclType(getParent()));
   return Context.hasSameUnqualifiedType(ClassType, ParamType);
 }

clang/test/SemaCXX/cxx0x-defaulted-functions.cpp

struct A {
     };
     decltype(B()) b;
     static constexpr bool value = true;
   };
   A::B b;
 
   static_assert(noexcept(A::B()), "");
 }
+
+namespace GH56456 {
+template <typename T>
+using RC=T const&;
+template <typename T>
+using RV=T&;
+template <typename T>
+using RM=T&&;
+
+struct A {
+  A(RC<A>) = default;
+  A(RM<A>) = default;
+
+  auto operator=(RC<A>) -> RV<A> = default;
+  auto operator=(RM<A>) -> RV<A> = default;
+};
+
+struct B {
+  B (RC<B>) = delete;
+  B (RM<B>) = delete;
+
+  auto operator = (RC<B>) -> RV<B> = delete;
+  auto operator = (RM<B>) -> RV<B> = delete;
+};
+}