[clang] use correct builtin type for defaulted comparison analyzer

[mizvekov]

Summary

Fixes PR50591.

When analyzing classes with members which have user-defined conversion
operators to builtin types, the defaulted comparison analyzer was
picking the member type instead of the type for the builtin operator
which was selected as the best match.

This could either result in wrong comparison category being selected,
or a crash when runtime checks are enabled.

Signed-off-by: Matheus Izvekov <[e-mail]>

[mizvekov]

Since we can still crash with user defined conversion operators for any builtin types not supported by getComparisonCategoryForBuiltinCmp (many others), I will make a follow up patch to just replace that assert with a deleted result.

[mizvekov]

@rsmith what do you think of the following strategy as a follow up to this patch:

• First step we replace the assert at line 7866 with a deleted result. I don't really think it's sustainable to keep returning incorrect results / crashing for builtin types that are to be supported in the future. We create a new diagnostic for unimplemented builtin type for three-way comparison or something along these lines. This will gloss over for now function pointers, the only other type which we are adding to the candidate set which we should not be doing. As a consequence, we produce slightly unhelpful diagnostics here, for now.
• Second step we modify AddTypesConvertedFrom so it can ignore function pointers, when used for purposes of building a candidate set for three-way comparison. Here, we would correct the diagnostics from step one.

Thoughts?

clang/lib/Sema/SemaDeclCXX.cpp

case OR_Success: {
                   << BestFD->getCallResultType().withoutLocalFastQualifiers();
               S.Diag(BestFD->getLocation(),
                      diag::note_defaulted_comparison_cannot_deduce_callee)
                   << Subobj.Kind << Subobj.Decl;
             }
             return Result::deleted();
           }
         } else {
+          QualType T = Best->BuiltinParamTypes[0];
+          assert(T == Best->BuiltinParamTypes[1] &&
+                 "builtin comparison for different types?");
+          assert(Best->BuiltinParamTypes[2].isNull() &&
+                 "invalid builtin comparison");
           Optional<ComparisonCategoryType> Cat =
-              getComparisonCategoryForBuiltinCmp(Args[0]->getType());
+              getComparisonCategoryForBuiltinCmp(T);
           assert(Cat && "no category for builtin comparison?");
           R.Category = *Cat;
         }
       }
 
       // Note that we might be rewriting to a different operator. That call is
       // not considered until we come to actually build the comparison function.
       break;

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

struct B {
     void (B::*x)();                              // expected-note {{because there is no viable three-way comparison function for member 'x'}}
   };
 
   struct C {
     auto operator<=>(const C &) const = default; // expected-warning {{implicitly deleted}}
     int C::*x;                                   // expected-note {{because there is no viable three-way comparison function for member 'x'}}
   };
 }
+
+namespace PR50591 {
+  struct a1 {
+    operator int() const;
+  };
+  struct b1 {
+    auto operator<=>(b1 const &) const = default;
+    a1 f;
+  };
+  std::strong_ordering cmp_b1 = b1() <=> b1();
+
+  struct a2 {
+    operator float() const;
+  };
+  struct b2 {
+    auto operator<=>(b2 const &) const = default;
+    a2 f;
+  };
+  std::partial_ordering cmp_b2 = b2() <=> b2();
+}