Translate operators that receive by value arguments (#408)

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -4506,18 +4506,34 @@ std::string Converter::GetComparisonCall(const clang::FunctionDecl *op,
                                          const clang::CXXRecordDecl *decl,
                                          std::string_view lhs,
                                          std::string_view rhs) {
-  auto record = GetRecordName(decl);
-  auto arg = std::format("{} as *const {}", rhs, record);
+  auto arg = [&](unsigned i, std::string_view value) {
+    if (op->getParamDecl(i)->getType()->isReferenceType()) {
+      return GetComparisonReferenceArg(decl, value);
+    }
+    return std::format("{}.clone()", value);
+  };
   if (const auto *method = clang::dyn_cast<clang::CXXMethodDecl>(op)) {
-    auto recv = !MethodNeedsMutableReceiver(method)
-                    ? std::string(lhs)
-                    : std::format("&mut *(&raw const *{}).cast_mut()", lhs);
     return std::format("{}::{}({}, {})", GetUFCSName(method),
-                       GetMethodName(method), recv, arg);
+                       GetMethodName(method),
+                       GetComparisonReceiver(method, decl, lhs), arg(0, rhs));
+  }
+  return std::format("{}({}, {})", GetNamedDeclAsString(op->getCanonicalDecl()),
+                     arg(0, lhs), arg(1, rhs));
+}
+
+std::string
+Converter::GetComparisonReferenceArg(const clang::CXXRecordDecl *decl,
+                                     std::string_view value) {
+  return std::format("{} as *const {}", value, GetRecordName(decl));
+}
+
+std::string Converter::GetComparisonReceiver(const clang::CXXMethodDecl *method,
+                                             const clang::CXXRecordDecl *,
+                                             std::string_view lhs) {
+  if (!MethodNeedsMutableReceiver(method)) {
+    return std::string(lhs);
   }
-  return std::format("{}({} as *const {}, {})",
-                     GetNamedDeclAsString(op->getCanonicalDecl()), lhs, record,
-                     arg);
+  return std::format("&mut *(&raw const *{}).cast_mut()", lhs);
 }
 
 void Converter::ConvertOrdAndPartialOrdTraits(const clang::CXXRecordDecl *decl,

cpp2rust/converter/converter.h

@@ -614,10 +614,17 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
                                          std::string_view eq_body,
                                          std::string_view record_name);
 
-  virtual std::string GetComparisonCall(const clang::FunctionDecl *op,
-                                        const clang::CXXRecordDecl *decl,
-                                        std::string_view lhs,
-                                        std::string_view rhs);
+  std::string GetComparisonCall(const clang::FunctionDecl *op,
+                                const clang::CXXRecordDecl *decl,
+                                std::string_view lhs, std::string_view rhs);
+
+  virtual std::string
+  GetComparisonReferenceArg(const clang::CXXRecordDecl *decl,
+                            std::string_view value);
+
+  virtual std::string GetComparisonReceiver(const clang::CXXMethodDecl *method,
+                                            const clang::CXXRecordDecl *decl,
+                                            std::string_view lhs);
 
   virtual void AddCloneTrait(const clang::RecordDecl *decl);
 

cpp2rust/converter/models/converter_refcount.cpp

@@ -443,18 +443,19 @@ bool ConverterRefCount::VisitOffsetOfExpr(clang::OffsetOfExpr *expr) {
   return false;
 }
 
-std::string ConverterRefCount::GetComparisonCall(
-    const clang::FunctionDecl *op, const clang::CXXRecordDecl *decl,
-    std::string_view lhs, std::string_view rhs) {
+std::string
+ConverterRefCount::GetComparisonReferenceArg(const clang::CXXRecordDecl *decl,
+                                             std::string_view value) {
+  PushConversionKind push(*this, ConversionKind::FullRefCount);
+  return BoxValue(GetShallowCopy(decl, value)) + ".as_pointer()";
+}
+
+std::string
+ConverterRefCount::GetComparisonReceiver(const clang::CXXMethodDecl *,
+                                         const clang::CXXRecordDecl *decl,
+                                         std::string_view lhs) {
   PushConversionKind push(*this, ConversionKind::FullRefCount);
-  auto lhs_ptr = BoxValue(GetShallowCopy(decl, lhs)) + ".as_pointer()";
-  auto rhs_ptr = BoxValue(GetShallowCopy(decl, rhs)) + ".as_pointer()";
-  if (const auto *method = clang::dyn_cast<clang::CXXMethodDecl>(op)) {
-    return std::format("{}::{}(&{}, {})", GetUFCSName(method),
-                       GetMethodName(method), lhs_ptr, rhs_ptr);
-  }
-  return std::format("{}({}, {})", GetNamedDeclAsString(op->getCanonicalDecl()),
-                     lhs_ptr, rhs_ptr);
+  return std::format("&{}.as_pointer()", BoxValue(GetShallowCopy(decl, lhs)));
 }
 
 std::string ConverterRefCount::GetShallowCopy(const clang::RecordDecl *decl,

cpp2rust/converter/models/converter_refcount.h

@@ -36,10 +36,12 @@ class ConverterRefCount final : public Converter {
 
   const char *CharRustType() const override { return "u8"; }
 
-  std::string GetComparisonCall(const clang::FunctionDecl *op,
-                                const clang::CXXRecordDecl *decl,
-                                std::string_view lhs,
-                                std::string_view rhs) override;
+  std::string GetComparisonReferenceArg(const clang::CXXRecordDecl *decl,
+                                        std::string_view value) override;
+
+  std::string GetComparisonReceiver(const clang::CXXMethodDecl *method,
+                                    const clang::CXXRecordDecl *decl,
+                                    std::string_view lhs) override;
 
   std::string GetShallowCopy(const clang::RecordDecl *decl,
                              std::string_view src);

tests/unit/operator_comparison_free.cpp

@@ -13,7 +13,23 @@ bool operator>=(const S &a, const S &b) { return a.v >= b.v; }
 bool operator<(const S &a, int b) { return a.v < b; }
 bool operator<(int a, const S &b) { return a < b.v; }
 
+struct V {
+  int v;
+};
+
+bool operator==(V a, V b) { return a.v == b.v; }
+bool operator!=(V a, V b) { return a.v != b.v; }
+bool operator<(V a, V b) { return a.v < b.v; }
+bool operator>(V a, V b) { return a.v > b.v; }
+
 int main() {
+  V x{1}, y{2}, z{1};
+  assert(x == z);
+  assert(x != y);
+  assert(x < y);
+  assert(y > x);
+  assert(!(y < x));
+
   S a{1}, b{2}, c{1};
   assert(a == c);
   assert(a != b);

tests/unit/out/refcount/operator_comparison_free.rs

@@ -117,11 +117,120 @@ pub fn operator_lt_7(a: i32, b: Ptr<S>) -> bool {
         _lhs < (*(*b.upgrade().deref()).v.borrow())
     };
 }
+#[derive(Default)]
+pub struct V {
+    pub v: Value<i32>,
+}
+impl std::cmp::Ord for V {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        {
+            if operator_lt_8(self.clone(), other.clone()) {
+                std::cmp::Ordering::Less
+            } else if operator_lt_8(other.clone(), self.clone()) {
+                std::cmp::Ordering::Greater
+            } else {
+                std::cmp::Ordering::Equal
+            }
+        }
+    }
+}
+impl std::cmp::PartialOrd for V {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+impl std::cmp::PartialEq for V {
+    fn eq(&self, other: &Self) -> bool {
+        { operator_eq_9(self.clone(), other.clone()) }
+    }
+}
+impl std::cmp::Eq for V {}
+impl Clone for V {
+    fn clone(&self) -> Self {
+        let __this: Value<V> = Rc::new(RefCell::new(Self {
+            v: Rc::new(RefCell::new((*self.v.borrow()))),
+        }));
+        let this: Ptr<V> = __this.as_pointer();
+        Rc::try_unwrap(__this).ok().unwrap().into_inner()
+    }
+}
+impl ByteRepr for V {
+    fn byte_size() -> usize {
+        4
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.v.borrow()).to_bytes(&mut buf[0..4]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            v: Rc::new(RefCell::new(<i32>::from_bytes(&buf[0..4]))),
+        }
+    }
+}
+pub fn operator_eq_9(a: V, b: V) -> bool {
+    let a: Value<V> = Rc::new(RefCell::new(a));
+    let b: Value<V> = Rc::new(RefCell::new(b));
+    return ((*(*a.borrow()).v.borrow()) == (*(*b.borrow()).v.borrow()));
+}
+pub fn operator_ne_10(a: V, b: V) -> bool {
+    let a: Value<V> = Rc::new(RefCell::new(a));
+    let b: Value<V> = Rc::new(RefCell::new(b));
+    return ((*(*a.borrow()).v.borrow()) != (*(*b.borrow()).v.borrow()));
+}
+pub fn operator_lt_8(a: V, b: V) -> bool {
+    let a: Value<V> = Rc::new(RefCell::new(a));
+    let b: Value<V> = Rc::new(RefCell::new(b));
+    return ((*(*a.borrow()).v.borrow()) < (*(*b.borrow()).v.borrow()));
+}
+pub fn operator_gt_11(a: V, b: V) -> bool {
+    let a: Value<V> = Rc::new(RefCell::new(a));
+    let b: Value<V> = Rc::new(RefCell::new(b));
+    return ((*(*a.borrow()).v.borrow()) > (*(*b.borrow()).v.borrow()));
+}
 pub fn main() {
     __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
+    let x: Value<V> = Rc::new(RefCell::new(V {
+        v: Rc::new(RefCell::new(1)),
+    }));
+    let y: Value<V> = Rc::new(RefCell::new(V {
+        v: Rc::new(RefCell::new(2)),
+    }));
+    let z: Value<V> = Rc::new(RefCell::new(V {
+        v: Rc::new(RefCell::new(1)),
+    }));
+    assert!(
+        ({
+            let _a: V = (*x.borrow()).clone();
+            operator_eq_9(_a, (*z.borrow()).clone())
+        })
+    );
+    assert!(
+        ({
+            let _a: V = (*x.borrow()).clone();
+            operator_ne_10(_a, (*y.borrow()).clone())
+        })
+    );
+    assert!(
+        ({
+            let _a: V = (*x.borrow()).clone();
+            operator_lt_8(_a, (*y.borrow()).clone())
+        })
+    );
+    assert!(
+        ({
+            let _a: V = (*y.borrow()).clone();
+            operator_gt_11(_a, (*x.borrow()).clone())
+        })
+    );
+    assert!(
+        !({
+            let _a: V = (*y.borrow()).clone();
+            operator_lt_8(_a, (*x.borrow()).clone())
+        })
+    );
     let a: Value<S> = Rc::new(RefCell::new(S {
         v: Rc::new(RefCell::new(1)),
     }));

tests/unit/out/unsafe/operator_comparison_free.rs

@@ -59,13 +59,87 @@ pub unsafe fn operator_lt_6(a: *const S, mut b: i32) -> bool {
 pub unsafe fn operator_lt_7(mut a: i32, b: *const S) -> bool {
     return ((a) < ((*b).v));
 }
+#[repr(C)]
+#[derive(Copy, Clone, Default)]
+pub struct V {
+    pub v: i32,
+}
+impl std::cmp::Ord for V {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        unsafe {
+            if operator_lt_8(self.clone(), other.clone()) {
+                std::cmp::Ordering::Less
+            } else if operator_lt_8(other.clone(), self.clone()) {
+                std::cmp::Ordering::Greater
+            } else {
+                std::cmp::Ordering::Equal
+            }
+        }
+    }
+}
+impl std::cmp::PartialOrd for V {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+impl std::cmp::PartialEq for V {
+    fn eq(&self, other: &Self) -> bool {
+        unsafe { operator_eq_9(self.clone(), other.clone()) }
+    }
+}
+impl std::cmp::Eq for V {}
+pub unsafe fn operator_eq_9(mut a: V, mut b: V) -> bool {
+    return ((a.v) == (b.v));
+}
+pub unsafe fn operator_ne_10(mut a: V, mut b: V) -> bool {
+    return ((a.v) != (b.v));
+}
+pub unsafe fn operator_lt_8(mut a: V, mut b: V) -> bool {
+    return ((a.v) < (b.v));
+}
+pub unsafe fn operator_gt_11(mut a: V, mut b: V) -> bool {
+    return ((a.v) > (b.v));
+}
 pub fn main() {
     unsafe {
         __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
 unsafe fn main_0() -> i32 {
+    let mut x: V = V { v: 1 };
+    let mut y: V = V { v: 2 };
+    let mut z: V = V { v: 1 };
+    assert!(
+        (unsafe {
+            let _a: V = x;
+            operator_eq_9(_a, z)
+        })
+    );
+    assert!(
+        (unsafe {
+            let _a: V = x;
+            operator_ne_10(_a, y)
+        })
+    );
+    assert!(
+        (unsafe {
+            let _a: V = x;
+            operator_lt_8(_a, y)
+        })
+    );
+    assert!(
+        (unsafe {
+            let _a: V = y;
+            operator_gt_11(_a, x)
+        })
+    );
+    assert!(
+        !(unsafe {
+            let _a: V = y;
+            operator_lt_8(_a, x)
+        })
+    );
     let mut a: S = S { v: 1 };
     let mut b: S = S { v: 2 };
     let mut c: S = S { v: 1 };