[PATCH] [clang] p2085 out-of-class comparison operator defaulting

[urnathan]

Summary

In committing D104478 (commit 5fbe21a7748f91adbd1b16c95bbfe180642320a3) I messed up. Some parts of the diff,were omitted as I got confused about which of my trees was which. Significantly the out-of-class checking of parameter types was dropped (and an unneeded type setting).

Sorry about that.

[urnathan]

Ah, phabricator copes with mutiple commits per diff

clang/lib/Sema/SemaDeclCXX.cpp

if (!KnownParm) {
       } else {
         // Don't diagnose an implicit 'operator=='; we will have diagnosed the
         // corresponding defaulted 'operator<=>' already.
         if (!FD->isImplicit()) {
           if (RD) {
             QualType PlainTy = Context.getRecordType(RD);
             QualType RefTy =
                 Context.getLValueReferenceType(PlainTy.withConst());
-            if (IsMethod)
-              PlainTy = QualType();
             Diag(FD->getLocation(), diag::err_defaulted_comparison_param)
                 << int(DCK) << ParmTy << RefTy << int(!IsMethod) << PlainTy
                 << Param->getSourceRange();
           } else {
             assert(!IsMethod && "should know expected type for method");
             Diag(FD->getLocation(),
                  diag::err_defaulted_comparison_param_unknown)
                 << int(DCK) << ParmTy << Param->getSourceRange();
void Sema::SetDeclDefaulted(Decl *Dcl, SourceLocation DefaultLoc) {
   if (FD->isDependentContext())
     return;
 
   // Unset that we will have a body for this function. We might not,
   // if it turns out to be trivial, and we don't need this marking now
   // that we've marked it as defaulted.
   FD->setWillHaveBody(false);
 
-  // If this is a comparison's defaulted definition within the record, do
-  // the checking when the record is complete.
-  if (DefKind.isComparison() && isa<CXXRecordDecl>(FD->getLexicalDeclContext()))
+  if (DefKind.isComparison()) {
+    // If this comparison's defaulting occurs within the definition of its
+    // lexical class context, we have to do the checking when complete.
+    if (auto const *RD = dyn_cast<CXXRecordDecl>(FD->getLexicalDeclContext()))
+      if (!RD->isCompleteDefinition())
         return;
+  }
 
   // If this member fn was defaulted on its first declaration, we will have
   // already performed the checking in CheckCompletedCXXClass. Such a
   // declaration doesn't trigger an implicit definition.
   if (isa<CXXMethodDecl>(FD)) {
     const FunctionDecl *Primary = FD;
     if (const FunctionDecl *Pattern = FD->getTemplateInstantiationPattern())
       // Ask the template instantiation pattern that actually had the

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

void use_h() {
       N::h() < N::h(); // expected-error {{implicitly deleted}}
       N::h() <= N::h(); // expected-error {{implicitly deleted}}
       N::h() > N::h(); // expected-error {{implicitly deleted}}
       N::h() >= N::h(); // expected-error {{implicitly deleted}}
     }
   }
 }
 
+namespace evil1 {
+template <class T> struct Bad {
+  // expected-error@+1{{found 'const float &'}}
+  bool operator==(T const &) const = default;
+  Bad(int = 0);
+};
+
+template <class T> struct Weird {
+  // expected-error@+1{{'float' cannot be used prior to '::'}}
+  bool operator==(typename T::Weird_ const &) const = default;
+  Weird(int = 0);
+};
+
+struct evil {
+  using Weird_ = Weird<evil>;
+};
+template struct Bad<float>;   // expected-note{{evil1::Bad<float>' requested}}
+template struct Weird<float>; // expected-note{{evil1::Weird<float>' requested}}
+template struct Weird<evil>;
+
+} // 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}}
     friend bool operator==(B, B) = default; // ok
     friend bool operator==(const B&, const B&) = default; // expected-warning {{deleted}}

 
 struct S5;                         // expected-note 3{{forward declaration}}
 bool operator==(S5, S5) = default; // expected-error{{not a friend}} expected-error 2{{has incomplete type}}
 
 enum e {};
 bool operator==(e, int) = default; // expected-error{{expected class or reference to a constant class}}
 
 bool operator==(e *, int *) = default; // expected-error{{must have at least one}}
-
 } // namespace p2085
+
+namespace p2085_2 {
+template <class T> struct S6 {
+  // expected-error@+2{{found 'const int &'}}
+  // expected-error@+1{{found 'const float &'}}
+  bool operator==(T const &) const;
+};
+template <class T> bool S6<T>::operator==(T const &) const = default;
+
+template struct S6<int>; // expected-note{{S6<int>::operator==' requested}}
+
+void f1() {
+  S6<float> a;
+  (void)(a == 0); // expected-note{{S6<float>::operator==' requested}}
+}
+
+template <class T> struct S7 {
+  // expected-error@+2{{'float' cannot be used}}
+  // expected-error@+1{{'int' cannot be used}}
+  bool operator==(typename T::S7_ const &) const;
+  S7(int = 0);
+};
+template <class T> bool S7<T>::operator==(typename T::S7_ const &) const = default;
+
+struct evil {
+  using S7_ = S7<evil>;
+};
+template struct S7<float>; // expected-note{{S7<float>' requested}}
+
+void f2() {
+  S7<int> a; // expected-note{{S7<int>' requested}}
+  S7<evil> b;
+  (void)(a == 0); // expected-error{{invalid operands}}
+  (void)(b == 0);
+}
+} // namespace p2085_2