[clang] Fix diagnostics for defaulted, implicitly deleted 'operator=='.

[AMP999]

Summary

https://godbolt.org/z/cMKE3o1aG

According to the issue https://github.com/llvm/llvm-project/issues/63960 , compiler falsely complains that no viable operator<=> was found while we are actually looking for a operator==.
This bug has been fixed through adding a check of the OverloadedOperatorKind type's object, OO, to see if it is OO_EqualEqual in addition to OO_ExclaimEqual.

[AMP999]

Revised the formatting of the change.

[cor3ntin]

Looks generally good to me. can you add an entry in clang/docs/ReleaseNotes.rst? Thanks!

[AMP999]

An entry added to clang/docs/ReleaseNotes.rst
Thank You for the review!

[AMP999]

I appreciate if you take a look at another patch I sent to address the ci build failure when calling clang/utils/ci/run-buildbot check-format caused by some extra white spaces.
https://reviews.llvm.org/D155814

[AMP999]

By the way I don't have permissions to commit so I'll send you my name and email:
Name: Amirreza Ashouri
Email: [e-mail]

[cor3ntin]

Thanks for the patch, it looks good to me. I'll commit on your behalf

clang/docs/ReleaseNotes.rst

 - Clang now diagnoses unexpected tokens after a
   ``#pragma clang|GCC diagnostic push|pop`` directive.
   (`#13920: <https://github.com/llvm/llvm-project/issues/13920>`_)
 - Clang now does not try to analyze cast validity on variables with dependent alignment (`#63007: <https://github.com/llvm/llvm-project/issues/63007>`_).
 - Clang constexpr evaluator now displays member function calls more precisely
   by making use of the syntactical structure of function calls. This avoids display
   of syntactically invalid codes in diagnostics.
   (`#57081: <https://github.com/llvm/llvm-project/issues/57081>`_)
-- Clang no longer emits inappropriate notes about the loss of ``__unaligned`` qualifier
-  on overload resolution, when the actual reason for the failure is loss of other qualifiers.
+- The note emitted when an ``operator==`` was defaulted as deleted used to refer to
+  the lack of a data member's "three-way comparison operator". It now refers correctly
+  to the data member's ``operator==``.
+  (`#63960: <https://github.com/llvm/llvm-project/issues/63960>`_)
 - Clang's notes about unconvertible types in overload resolution failure now covers
   the source range of parameter declaration of the candidate function declaration.
 
   *Example Code*:
 
   .. code-block:: c++
 
      void func(int aa, int bb);

clang/lib/Sema/SemaDeclCXX.cpp

case OR_No_Viable_Function:
         if (!R.add(visitBinaryOperator(OO_EqualEqual, Args, Subobj,
                                        &CandidateSet)))
           R.add(visitBinaryOperator(OO_Less, Args, Subobj, &CandidateSet));
         break;
       }
 
       if (Diagnose == ExplainDeleted) {
         S.Diag(Subobj.Loc, diag::note_defaulted_comparison_no_viable_function)
-            << FD << (OO == OO_ExclaimEqual) << Subobj.Kind << Subobj.Decl;
+            << FD << (OO == OO_EqualEqual || OO == OO_ExclaimEqual)
+            << Subobj.Kind << Subobj.Decl;
 
         // For a three-way comparison, list both the candidates for the
         // original operator and the candidates for the synthesized operator.
         if (SpaceshipCandidates) {
           SpaceshipCandidates->NoteCandidates(
               S, Args,
               SpaceshipCandidates->CompleteCandidates(S, OCD_AllCandidates,
                                                       Args, FD->getLocation()));

clang/test/CXX/class/class.compare/class.compare.default/p1.cpp

 
 } // namespace evil1
 
 namespace P1946 {
   struct A {
     friend bool operator==(A &, A &); // expected-note {{would lose const qualifier}}
   };
   struct B {
-    A a; // expected-note {{no viable three-way comparison}}
+    A a; // expected-note {{no viable 'operator=='}}
     friend bool operator==(B, B) = default; // ok
     friend bool operator==(const B&, const B&) = default; // expected-warning {{deleted}} expected-note{{replace 'default'}}
   };
 }
 
 namespace p2085 {
 // out-of-class defaulting
 

clang/test/CXX/class/class.compare/class.compare.default/p4.cpp

void use_j(J j) {
   void(j == j); // expected-error {{ambiguous}}
 }
 
 namespace DeleteAfterFirstDecl {
   bool operator==(const struct Q&, const struct Q&);
   struct Q {
     struct X {
       friend std::strong_ordering operator<=>(const X&, const X&);
-    } x; // expected-note {{no viable three-way comparison}}
+    } x; // expected-note {{no viable 'operator=='}}
     // expected-error@+1 {{defaulting the corresponding implicit 'operator==' for this defaulted 'operator<=>' would delete it after its first declaration}}
     friend std::strong_ordering operator<=>(const Q&, const Q&) = default;
   };
 }
 
 // Note, substitution here results in the second parameter of 'operator=='
 // referring to the first parameter of 'operator==', not to the first parameter
 // of 'operator<=>'.

clang/test/CXX/class/class.compare/class.compare.secondary/p2.cpp

 // RUN: %clang_cc1 -std=c++20 -verify %s
 
 struct A {
   bool operator!=(const A&) const = default; // expected-warning {{explicitly defaulted equality comparison operator is implicitly deleted}} expected-note{{replace 'default'}}
   // expected-note@-1 {{defaulted 'operator!=' is implicitly deleted because there is no viable 'operator==' for 'A'}}
 };
 
+struct A2 {
+  struct E {};
+  E e;
+  bool operator==(const A2&) const = default; // expected-warning {{explicitly defaulted equality comparison operator is implicitly deleted}} expected-note{{replace 'default'}}
+  // expected-note@-2 {{defaulted 'operator==' is implicitly deleted because there is no viable 'operator==' for member 'e'}}
+};
+
+
 struct Q {};
 bool operator!=(Q, Q); // expected-note {{defaulted 'operator!=' is implicitly deleted because this non-rewritten comparison function would be the best match for the comparison}}
 struct B {
   operator Q() const;
   bool operator!=(const B&) const = default; // expected-warning {{explicitly defaulted equality comparison operator is implicitly deleted}} expected-note{{replace 'default'}}
 };
 
 struct R {};

clang/test/CXX/class/class.compare/class.eq/p2.cpp

struct H3 {
   bool operator<(const H3 &) const = default; // expected-warning {{implicitly deleted}} expected-note{{replace 'default'}}
   // expected-note@-1 {{because there is no viable three-way comparison function for 'H3'}}
   int H3::*x;
 };
 
 template<typename T> struct X {
   X();
   bool operator==(const X&) const = default; // #x expected-note 4{{deleted here}}
-  T t; // expected-note 3{{because there is no viable three-way comparison function for member 't'}}
+  T t; // expected-note 3{{because there is no viable 'operator==' for member 't'}}
        // expected-note@-1 {{because it would invoke a deleted comparison function for member 't'}}
 };
 
 struct Mutable {
   bool operator==(const Mutable&) const = default;
   mutable D d;
 };
 

clang/test/CXX/class/class.compare/class.spaceship/p1.cpp

namespace Deletedness {
   };
   struct H {
     void operator<=>(const H&) const;
   };
 
   // expected-note@#base {{deleted comparison function for base class 'C'}}
   // expected-note@#base {{no viable three-way comparison function for base class 'D1'}}
   // expected-note@#base {{three-way comparison cannot be synthesized because there is no viable function for '<' comparison}}
-  // expected-note@#base {{no viable three-way comparison function for base class 'D2'}}
+  // expected-note@#base {{no viable 'operator==' for base class 'D2'}}
   // expected-note@#base {{three-way comparison cannot be synthesized because there is no viable function for '==' comparison}}
   // expected-note@#base {{deleted comparison function for base class 'E'}}
   // expected-note@#base {{implied comparison for base class 'F' is ambiguous}}
   template<typename T> struct Cmp : T { // #base
     std::strong_ordering operator<=>(const Cmp&) const = default; // #cmp expected-note 5{{here}}
   };
 
   void use(...);
use(
       Cmp<H>() <=> Cmp<H>(), // expected-note-re {{in defaulted three-way comparison operator for '{{.*}}Cmp<{{.*}}H>' first required here}}j
       0
     );
   }
 
   // expected-note@#arr {{deleted comparison function for member 'arr'}}
   // expected-note@#arr {{no viable three-way comparison function for member 'arr'}}
   // expected-note@#arr {{three-way comparison cannot be synthesized because there is no viable function for '<' comparison}}
-  // expected-note@#arr {{no viable three-way comparison function for member 'arr'}}
+  // expected-note@#arr {{no viable 'operator==' for member 'arr'}}
   // expected-note@#arr {{three-way comparison cannot be synthesized because there is no viable function for '==' comparison}}
   // expected-note@#arr {{deleted comparison function for member 'arr'}}
   // expected-note@#arr {{implied comparison for member 'arr' is ambiguous}}
   template<typename T> struct CmpArray {
     T arr[3]; // #arr
     std::strong_ordering operator<=>(const CmpArray&) const = default; // #cmparray expected-note 5{{here}}
   };
   void g() {