Look through references for non-bool comparison operators

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -4753,14 +4753,19 @@ std::string Converter::GetComparisonBool(const clang::FunctionDecl *op,
   if (ret->isIntegerType()) {
     return std::format("(({}) != 0)", call);
   }
-  const auto *record = ret->getAsCXXRecordDecl();
+  bool returns_ref = ret->isReferenceType();
+  const auto *record = ret.getNonReferenceType()->getAsCXXRecordDecl();
   assert(record && "unsupported comparison operator return type");
   for (const auto *found : record->getVisibleConversionFunctions()) {
     const auto *conversion = clang::dyn_cast<clang::CXXConversionDecl>(found);
     if (conversion && conversion->getConversionType()->isBooleanType()) {
-      return std::format("{{ let __cmp = &{}; {}::{}({}) }}", call,
-                         GetUFCSName(conversion), GetMethodName(conversion),
-                         GetComparisonReceiver(conversion, record, "__cmp"));
+      auto receiver =
+          returns_ref
+              ? GetComparisonReferenceReceiver(conversion, record, "__cmp")
+              : GetComparisonReceiver(conversion, record, "__cmp");
+      return std::format("{{ let __cmp = {}{}; {}::{}({}) }}",
+                         returns_ref ? "" : "&", call, GetUFCSName(conversion),
+                         GetMethodName(conversion), receiver);
     }
   }
   assert(0 && "comparison operator result has no conversion to bool");
@@ -4773,6 +4778,13 @@ Converter::GetComparisonReferenceArg(const clang::CXXRecordDecl *decl,
   return std::format("{} as *const {}", value, GetRecordName(decl));
 }
 
+std::string
+Converter::GetComparisonReferenceReceiver(const clang::CXXMethodDecl *method,
+                                          const clang::CXXRecordDecl *decl,
+                                          std::string_view ptr) {
+  return GetComparisonReceiver(method, decl, std::format("&*{}", ptr));
+}
+
 std::string Converter::GetComparisonReceiver(const clang::CXXMethodDecl *method,
                                              const clang::CXXRecordDecl *,
                                              std::string_view lhs) {

cpp2rust/converter/converter.h

@@ -694,6 +694,11 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
   GetComparisonReferenceArg(const clang::CXXRecordDecl *decl,
                             std::string_view value);
 
+  virtual std::string
+  GetComparisonReferenceReceiver(const clang::CXXMethodDecl *method,
+                                 const clang::CXXRecordDecl *decl,
+                                 std::string_view ptr);
+
   virtual std::string GetComparisonReceiver(const clang::CXXMethodDecl *method,
                                             const clang::CXXRecordDecl *decl,
                                             std::string_view lhs);

cpp2rust/converter/models/converter_refcount.cpp

@@ -583,6 +583,12 @@ ConverterRefCount::GetComparisonReferenceArg(const clang::CXXRecordDecl *decl,
   return BoxValue(GetShallowCopy(decl, value)) + ".as_pointer()";
 }
 
+std::string ConverterRefCount::GetComparisonReferenceReceiver(
+    const clang::CXXMethodDecl *, const clang::CXXRecordDecl *,
+    std::string_view ptr) {
+  return std::format("&{}", ptr);
+}
+
 std::string
 ConverterRefCount::GetComparisonReceiver(const clang::CXXMethodDecl *,
                                          const clang::CXXRecordDecl *decl,

cpp2rust/converter/models/converter_refcount.h

@@ -45,6 +45,10 @@ class ConverterRefCount final : public Converter {
   std::string GetComparisonReferenceArg(const clang::CXXRecordDecl *decl,
                                         std::string_view value) override;
 
+  std::string GetComparisonReferenceReceiver(const clang::CXXMethodDecl *method,
+                                             const clang::CXXRecordDecl *decl,
+                                             std::string_view ptr) override;
+
   std::string GetComparisonReceiver(const clang::CXXMethodDecl *method,
                                     const clang::CXXRecordDecl *decl,
                                     std::string_view lhs) override;

tests/unit/operator_comparison_nonbool.cpp

@@ -42,6 +42,20 @@ struct Boolish {
 MyBool operator==(Boolish a, Boolish b) { return MyBool(a.v == b.v); }
 MyBool operator<(Boolish a, Boolish b) { return MyBool(a.v < b.v); }
 
+struct RefBool {
+  bool value;
+  explicit RefBool(bool v) : value(v) {}
+  RefBool(const RefBool &) = delete;
+  operator bool() const { return value; }
+};
+
+static RefBool ref_true{true};
+
+struct RefInt {
+  int v;
+  RefBool &operator==(const RefInt &) const { return ref_true; }
+};
+
 int main() {
   X a{1}, b{2}, c{1};
   assert((a == c) == 2);
@@ -76,5 +90,10 @@ int main() {
   Boolish bs[] = {{3}, {1}, {2}};
   std::sort(bs, bs + 3);
   assert(bs[0].v == 1 && bs[1].v == 2 && bs[2].v == 3);
+
+  RefInt ri1{1}, ri2{2};
+  assert(ri1 == ri2);
+  RefInt ris[] = {{1}, {2}};
+  assert(std::find(ris, ris + 2, ri2) == ris);
   return 0;
 }