[Clang][C++20] Error out if parameter types of a defaulted comparison operator aren't as expected.

[massberg]

Summary

A defaulted comparison operator C should be

• a member of C having one parameter of type const C& or
• a friend of C having either two parameters of type const C& or two parameters of type C

see e.g. https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2020/p2002r1.html

C++20 allows defaulted comparison operators for dependent types. This patch adds the logic to check whether the parameters have the right form
for dependent types.

This fixes #62880

[massberg]

I just realized that we should probably also enable the other check (err_defaulted_comparison_param) for dependent types.

[massberg]

Also error out if the comparion operator has a single parameter that isn't a const reference. See also https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2020/p2002r1.html on how it shpuld behave in C++20.

[shafik]

LGTM assuming precommit CI comes back green

clang/lib/Sema/SemaDeclCXX.cpp

if (FD->getNumParams() != (IsMethod ? 1 : 2)) {
     Diag(FD->getLocation(), diag::err_defaulted_comparison_num_args)
         << int(IsMethod) << int(DCK);
     return true;
   }
 
   const ParmVarDecl *KnownParm = nullptr;
   for (const ParmVarDecl *Param : FD->parameters()) {
     QualType ParmTy = Param->getType();
-    if (ParmTy->isDependentType())
-      continue;
+
     if (!KnownParm) {
       auto CTy = ParmTy;
       // Is it `T const &`?
       bool Ok = !IsMethod;
       QualType ExpectedTy;
       if (RD)
         ExpectedTy = Context.getRecordType(RD);
       if (auto *Ref = CTy->getAs<ReferenceType>()) {

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

struct A {
   friend bool operator>(A, const A&) = default; // expected-error {{must have the same type}} expected-note {{would be the best match}}
 
   template<typename T = void>
     friend bool operator==(const A&, const A&) = default; // expected-error {{comparison operator template cannot be defaulted}}
   template<typename T = void>
     bool operator==(const A&) const = default; // expected-error {{comparison operator template cannot be defaulted}}
 };
 
+template<class C> struct D {
+  C i;
+  friend bool operator==(const D&, D) = default; // expected-error {{must have the same type}}
+  friend bool operator>(D, const D&) = default; // expected-error {{must have the same type}}
+  friend bool operator<(const D&, const D&) = default;
+  friend bool operator<=(D, D) = default;
+
+  bool operator!=(D) const = default; // expected-error {{invalid parameter type for defaulted equality comparison operator}}
+};
+
 template<typename T> struct Dependent {
   using U = typename T::type;
   bool operator==(U) const = default; // expected-error {{found 'U'}}
   friend bool operator==(U, U) = default; // expected-error {{found 'U'}}
 };
 
 struct Good { using type = const Dependent<Good>&; };
 template struct Dependent<Good>;