Update tests

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -4223,11 +4223,12 @@ std::string Converter::GetUnsafeTypeAsString(clang::QualType qual_type) const {
 std::string
 Converter::GetOverloadParamTypeAsString(clang::QualType type) const {
   auto str = GetUnsafeTypeAsString(type);
-  if (type->isVoidPointerType() && type->getPointeeType().isConstQualified()) {
+  if ((type->isPointerType() || type->isReferenceType()) &&
+      type->getPointeeType().isConstQualified()) {
     str += "_const";
   }
   if (type->isRValueReferenceType()) {
-    name += "_rv";
+    str += "_rv";
   }
   return str;
 }

cpp2rust/converter/converter.h

@@ -588,6 +588,7 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
   GetStructAttributes(const clang::RecordDecl *decl);
 
   virtual std::string GetUnsafeTypeAsString(clang::QualType qual_type) const;
+
   virtual std::string GetOverloadParamTypeAsString(clang::QualType type) const;
 
   virtual bool NeedsMut(const clang::VarDecl *decl, clang::QualType type,

cpp2rust/converter/models/converter_refcount.cpp

@@ -141,7 +141,7 @@ ConverterRefCount::GetOverloadParamTypeAsString(clang::QualType type) const {
     str += "_const";
   }
   if (type->isRValueReferenceType()) {
-    name += "_rv";
+    str += "_rv";
   }
   return str;
 }

cpp2rust/converter/models/converter_refcount.h

@@ -329,8 +329,8 @@ class ConverterRefCount final : public Converter {
   std::string ConvertSubscriptIndex(clang::Expr *idx);
 
   std::string GetSafeTypeAsString(clang::QualType qual_type) const;
-  std::string
-  GetOverloadParamTypeAsString(clang::QualType type) const override;
+
+  std::string GetOverloadParamTypeAsString(clang::QualType type) const override;
 
   bool NeedsMut(const clang::VarDecl *decl, clang::QualType type,
                 llvm::StringRef /*name*/) const override;

tests/unit/out/refcount/copy_assign.rs

@@ -254,9 +254,12 @@ fn main_0() -> i32 {
     let n1: Value<NonConstAssign> = Rc::new(RefCell::new(NonConstAssign::new()));
     let n2: Value<NonConstAssign> = Rc::new(RefCell::new(NonConstAssign::new()));
     let cn: Value<NonConstAssign> = Rc::new(RefCell::new(NonConstAssign::new()));
-    ({ NonConstAssignImpl::operator_assign_pmutNonConstAssign(&n1.as_pointer(), n.as_pointer()) });
+    ({ NonConstAssignImpl::operator_assign_PtrNonConstAssign(&n1.as_pointer(), n.as_pointer()) });
     ({
-        NonConstAssignImpl::operator_assign_pconstNonConstAssign(&n2.as_pointer(), cn.as_pointer())
+        NonConstAssignImpl::operator_assign_PtrNonConstAssign_const(
+            &n2.as_pointer(),
+            cn.as_pointer(),
+        )
     });
     assert!(((*(*n1.borrow()).mark.borrow()) == 1));
     assert!(((*(*n2.borrow()).mark.borrow()) == 10));
@@ -267,16 +270,22 @@ fn main_0() -> i32 {
     return 0;
 }
 pub trait NonConstAssignImpl {
-    fn operator_assign_pmutNonConstAssign(&self, o: Ptr<NonConstAssign>) -> Ptr<NonConstAssign>;
-    fn operator_assign_pconstNonConstAssign(&self, o: Ptr<NonConstAssign>) -> Ptr<NonConstAssign>;
+    fn operator_assign_PtrNonConstAssign(&self, o: Ptr<NonConstAssign>) -> Ptr<NonConstAssign>;
+    fn operator_assign_PtrNonConstAssign_const(
+        &self,
+        o: Ptr<NonConstAssign>,
+    ) -> Ptr<NonConstAssign>;
 }
 impl NonConstAssignImpl for Ptr<NonConstAssign> {
-    fn operator_assign_pmutNonConstAssign(&self, o: Ptr<NonConstAssign>) -> Ptr<NonConstAssign> {
+    fn operator_assign_PtrNonConstAssign(&self, o: Ptr<NonConstAssign>) -> Ptr<NonConstAssign> {
         let __rhs = ((*(*o.upgrade().deref()).mark.borrow()) + 1);
         (*(*(*self).upgrade().deref()).mark.borrow_mut()) = __rhs;
         return (*self).clone();
     }
-    fn operator_assign_pconstNonConstAssign(&self, o: Ptr<NonConstAssign>) -> Ptr<NonConstAssign> {
+    fn operator_assign_PtrNonConstAssign_const(
+        &self,
+        o: Ptr<NonConstAssign>,
+    ) -> Ptr<NonConstAssign> {
         let __rhs = ((*(*o.upgrade().deref()).mark.borrow()) + 10);
         (*(*(*self).upgrade().deref()).mark.borrow_mut()) = __rhs;
         return (*self).clone();

tests/unit/out/refcount/copy_ctor.rs

@@ -62,14 +62,14 @@ impl NonConst {
         let this: Ptr<NonConst> = __this.as_pointer();
         Rc::try_unwrap(__this).ok().unwrap().into_inner()
     }
-    pub fn NonConst_pmutNonConst(o: Ptr<NonConst>) -> Self {
+    pub fn NonConst_PtrNonConst(o: Ptr<NonConst>) -> Self {
         let __this: Value<NonConst> = Rc::new(RefCell::new(Self {
             mark: Rc::new(RefCell::new(((*(*o.upgrade().deref()).mark.borrow()) + 1))),
         }));
         let this: Ptr<NonConst> = __this.as_pointer();
         Rc::try_unwrap(__this).ok().unwrap().into_inner()
     }
-    pub fn NonConst_pconstNonConst(o: Ptr<NonConst>) -> Self {
+    pub fn NonConst_PtrNonConst_const(o: Ptr<NonConst>) -> Self {
         let __this: Value<NonConst> = Rc::new(RefCell::new(Self {
             mark: Rc::new(RefCell::new(((*(*o.upgrade().deref()).mark.borrow()) + 10))),
         }));
@@ -82,7 +82,7 @@ impl Clone for NonConst {
         let __src: Value<NonConst> = Rc::new(RefCell::new(NonConst {
             mark: self.mark.clone(),
         }));
-        NonConst::NonConst_pmutNonConst(__src.as_pointer())
+        NonConst::NonConst_PtrNonConst(__src.as_pointer())
     }
 }
 impl Default for NonConst {
@@ -259,11 +259,11 @@ fn main_0() -> i32 {
     assert!(((*(*i1.borrow()).v.borrow()) == 1) && ((*(*i2.borrow()).v.borrow()) == -1_i32));
     assert!((copies_0.with(|rc| *rc.borrow()) == 11));
     let n: Value<NonConst> = Rc::new(RefCell::new(NonConst::new()));
-    let n1: Value<NonConst> = Rc::new(RefCell::new(NonConst::NonConst_pmutNonConst({
+    let n1: Value<NonConst> = Rc::new(RefCell::new(NonConst::NonConst_PtrNonConst({
         n.as_pointer()
     })));
     let cn: Value<NonConst> = Rc::new(RefCell::new(NonConst::new()));
-    let n2: Value<NonConst> = Rc::new(RefCell::new(NonConst::NonConst_pconstNonConst({
+    let n2: Value<NonConst> = Rc::new(RefCell::new(NonConst::NonConst_PtrNonConst_const({
         cn.as_pointer()
     })));
     assert!(((*(*n1.borrow()).mark.borrow()) == 1));

tests/unit/out/refcount/move_assign.rs

@@ -141,13 +141,10 @@ fn main_0() -> i32 {
     let m2: Value<ConstMoveAssign> = Rc::new(RefCell::new(ConstMoveAssign::new()));
     let cm: Value<ConstMoveAssign> = Rc::new(RefCell::new(ConstMoveAssign::new()));
     ({
-        ConstMoveAssignImpl::operator_assign_pmutConstMoveAssign_rv(
-            &m1.as_pointer(),
-            m.as_pointer(),
-        )
+        ConstMoveAssignImpl::operator_assign_PtrConstMoveAssign_rv(&m1.as_pointer(), m.as_pointer())
     });
     ({
-        ConstMoveAssignImpl::operator_assign_pconstConstMoveAssign_rv(
+        ConstMoveAssignImpl::operator_assign_PtrConstMoveAssign_const_rv(
             &m2.as_pointer(),
             cm.as_pointer(),
         )
@@ -157,25 +154,25 @@ fn main_0() -> i32 {
     return 0;
 }
 pub trait ConstMoveAssignImpl {
-    fn operator_assign_pmutConstMoveAssign_rv(
+    fn operator_assign_PtrConstMoveAssign_rv(
         &self,
         o: Ptr<ConstMoveAssign>,
     ) -> Ptr<ConstMoveAssign>;
-    fn operator_assign_pconstConstMoveAssign_rv(
+    fn operator_assign_PtrConstMoveAssign_const_rv(
         &self,
         o: Ptr<ConstMoveAssign>,
     ) -> Ptr<ConstMoveAssign>;
 }
 impl ConstMoveAssignImpl for Ptr<ConstMoveAssign> {
-    fn operator_assign_pmutConstMoveAssign_rv(
+    fn operator_assign_PtrConstMoveAssign_rv(
         &self,
         o: Ptr<ConstMoveAssign>,
     ) -> Ptr<ConstMoveAssign> {
         let __rhs = ((*(*o.upgrade().deref()).mark.borrow()) + 1);
         (*(*(*self).upgrade().deref()).mark.borrow_mut()) = __rhs;
         return (*self).clone();
     }
-    fn operator_assign_pconstConstMoveAssign_rv(
+    fn operator_assign_PtrConstMoveAssign_const_rv(
         &self,
         o: Ptr<ConstMoveAssign>,
     ) -> Ptr<ConstMoveAssign> {

tests/unit/out/refcount/move_ctor.rs

@@ -53,14 +53,14 @@ impl ConstMove {
         let this: Ptr<ConstMove> = __this.as_pointer();
         Rc::try_unwrap(__this).ok().unwrap().into_inner()
     }
-    pub fn ConstMove_pmutConstMove_rv(o: Ptr<ConstMove>) -> Self {
+    pub fn ConstMove_PtrConstMove_rv(o: Ptr<ConstMove>) -> Self {
         let __this: Value<ConstMove> = Rc::new(RefCell::new(Self {
             mark: Rc::new(RefCell::new(((*(*o.upgrade().deref()).mark.borrow()) + 1))),
         }));
         let this: Ptr<ConstMove> = __this.as_pointer();
         Rc::try_unwrap(__this).ok().unwrap().into_inner()
     }
-    pub fn ConstMove_pconstConstMove_rv(o: Ptr<ConstMove>) -> Self {
+    pub fn ConstMove_PtrConstMove_const_rv(o: Ptr<ConstMove>) -> Self {
         let __this: Value<ConstMove> = Rc::new(RefCell::new(Self {
             mark: Rc::new(RefCell::new(((*(*o.upgrade().deref()).mark.borrow()) + 10))),
         }));
@@ -269,11 +269,11 @@ fn main_0() -> i32 {
     );
     assert!(((*(*f.borrow()).v.borrow()) == 0));
     let m: Value<ConstMove> = Rc::new(RefCell::new(ConstMove::new()));
-    let m1: Value<ConstMove> = Rc::new(RefCell::new(ConstMove::ConstMove_pmutConstMove_rv({
+    let m1: Value<ConstMove> = Rc::new(RefCell::new(ConstMove::ConstMove_PtrConstMove_rv({
         m.as_pointer()
     })));
     let cm: Value<ConstMove> = Rc::new(RefCell::new(ConstMove::new()));
-    let m2: Value<ConstMove> = Rc::new(RefCell::new(ConstMove::ConstMove_pconstConstMove_rv({
+    let m2: Value<ConstMove> = Rc::new(RefCell::new(ConstMove::ConstMove_PtrConstMove_const_rv({
         cm.as_pointer()
     })));
     assert!(((*(*m1.borrow()).mark.borrow()) == 1));

tests/unit/out/refcount/operator_arithmetic_member.rs

@@ -44,13 +44,13 @@ fn main_0() -> i32 {
         v: Rc::new(RefCell::new(2)),
     }));
     assert!(
-        ((*({ SImpl::operator_add_pconstS_const(&a.as_pointer(), b.as_pointer(),) })
+        ((*({ SImpl::operator_add_PtrS_const_const(&a.as_pointer(), b.as_pointer(),) })
             .v
             .borrow())
             == 9)
     );
     assert!(
-        ((*({ SImpl::operator_sub_pconstS_const(&a.as_pointer(), b.as_pointer(),) })
+        ((*({ SImpl::operator_sub_PtrS_const_const(&a.as_pointer(), b.as_pointer(),) })
             .v
             .borrow())
             == 5)
@@ -118,7 +118,7 @@ fn main_0() -> i32 {
             let _o: Value<S> = Rc::new(RefCell::new(S {
                 v: Rc::new(RefCell::new(4)),
             }));
-            SImpl::operator_add_pconstS_const(
+            SImpl::operator_add_PtrS_const_const(
                 &Rc::new(RefCell::new(S {
                     v: Rc::new(RefCell::new(3)),
                 }))
@@ -133,8 +133,8 @@ fn main_0() -> i32 {
     return 0;
 }
 pub trait SImpl {
-    fn operator_add_pconstS_const(&self, o: Ptr<S>) -> S;
-    fn operator_sub_pconstS_const(&self, o: Ptr<S>) -> S;
+    fn operator_add_PtrS_const_const(&self, o: Ptr<S>) -> S;
+    fn operator_sub_PtrS_const_const(&self, o: Ptr<S>) -> S;
     fn operator_mul(&self, o: Ptr<S>) -> S;
     fn operator_div(&self, o: Ptr<S>) -> S;
     fn operator_rem(&self, o: Ptr<S>) -> S;
@@ -146,15 +146,15 @@ pub trait SImpl {
     fn operator_post_dec_i32(&self, _a0: i32) -> S;
 }
 impl SImpl for Ptr<S> {
-    fn operator_add_pconstS_const(&self, o: Ptr<S>) -> S {
+    fn operator_add_PtrS_const_const(&self, o: Ptr<S>) -> S {
         return S {
             v: Rc::new(RefCell::new({
                 let _lhs = (*(*(*self).upgrade().deref()).v.borrow());
                 _lhs + (*(*o.upgrade().deref()).v.borrow())
             })),
         };
     }
-    fn operator_sub_pconstS_const(&self, o: Ptr<S>) -> S {
+    fn operator_sub_PtrS_const_const(&self, o: Ptr<S>) -> S {
         return S {
             v: Rc::new(RefCell::new({
                 let _lhs = (*(*(*self).upgrade().deref()).v.borrow());

tests/unit/out/refcount/operator_comparison_member.rs

@@ -13,12 +13,12 @@ pub struct S {
 impl std::cmp::Ord for S {
     fn cmp(&self, other: &Self) -> std::cmp::Ordering {
         {
-            if SImpl::operator_lt_pconstS_const(
+            if SImpl::operator_lt_PtrS_const_const(
                 &Rc::new(RefCell::new(S { v: self.v.clone() })).as_pointer(),
                 Rc::new(RefCell::new(S { v: other.v.clone() })).as_pointer(),
             ) {
                 std::cmp::Ordering::Less
-            } else if SImpl::operator_lt_pconstS_const(
+            } else if SImpl::operator_lt_PtrS_const_const(
                 &Rc::new(RefCell::new(S { v: other.v.clone() })).as_pointer(),
                 Rc::new(RefCell::new(S { v: self.v.clone() })).as_pointer(),
             ) {
@@ -83,18 +83,18 @@ fn main_0() -> i32 {
     }));
     assert!(({ SImpl::operator_eq(&a.as_pointer(), c.as_pointer(),) }));
     assert!(({ SImpl::operator_ne(&a.as_pointer(), b.as_pointer(),) }));
-    assert!(({ SImpl::operator_lt_pconstS_const(&a.as_pointer(), b.as_pointer(),) }));
+    assert!(({ SImpl::operator_lt_PtrS_const_const(&a.as_pointer(), b.as_pointer(),) }));
     assert!(({ SImpl::operator_gt(&b.as_pointer(), a.as_pointer(),) }));
     assert!(({ SImpl::operator_le(&a.as_pointer(), c.as_pointer(),) }));
     assert!(({ SImpl::operator_ge(&a.as_pointer(), c.as_pointer(),) }));
-    assert!(!({ SImpl::operator_lt_pconstS_const(&b.as_pointer(), a.as_pointer(),) }));
+    assert!(!({ SImpl::operator_lt_PtrS_const_const(&b.as_pointer(), a.as_pointer(),) }));
     assert!(({ SImpl::operator_lt_i32_const(&a.as_pointer(), 5,) }));
     return 0;
 }
 pub trait SImpl {
     fn operator_eq(&self, o: Ptr<S>) -> bool;
     fn operator_ne(&self, o: Ptr<S>) -> bool;
-    fn operator_lt_pconstS_const(&self, o: Ptr<S>) -> bool;
+    fn operator_lt_PtrS_const_const(&self, o: Ptr<S>) -> bool;
     fn operator_gt(&self, o: Ptr<S>) -> bool;
     fn operator_le(&self, o: Ptr<S>) -> bool;
     fn operator_ge(&self, o: Ptr<S>) -> bool;
@@ -113,7 +113,7 @@ impl SImpl for Ptr<S> {
             _lhs != (*(*o.upgrade().deref()).v.borrow())
         };
     }
-    fn operator_lt_pconstS_const(&self, o: Ptr<S>) -> bool {
+    fn operator_lt_PtrS_const_const(&self, o: Ptr<S>) -> bool {
         return {
             let _lhs = (*(*(*self).upgrade().deref()).v.borrow());
             _lhs < (*(*o.upgrade().deref()).v.borrow())