diff --git a/cpp2rust/converter/converter.cpp b/cpp2rust/converter/converter.cpp
index cf33029e6..61b8e7165 100644
--- a/cpp2rust/converter/converter.cpp
+++ b/cpp2rust/converter/converter.cpp
@@ -3984,6 +3984,9 @@ Converter::GetOverloadedFunctionName(const clang::FunctionDecl *decl) {
 
   for (auto *parameter : decl->parameters()) {
     name += GetUnsafeTypeAsString(parameter->getType());
+    if (parameter->getType()->isRValueReferenceType()) {
+      name += "_rv";
+    }
     name += '_';
   }
 
@@ -4042,10 +4045,12 @@ Converter::GetOverloadedFunctionName(const clang::FunctionDecl *decl) {
   ReplaceAll(name, "[", "arr");
   ReplaceAll(name, "]", "arr");
   ReplaceAll(name, ";", "_");
+  ReplaceAll(name, ",", "_");
   name.erase(std::remove_if(name.begin(), name.end(),
                             [](char c) {
                               return c == '<' || c == '>' || c == ' ' ||
-                                     c == ':';
+                                     c == ':' || c == '(' || c == ')' ||
+                                     c == '-';
                             }),
              name.end());
   std::replace(name.begin(), name.end(), '*', 'p');
diff --git a/tests/multi-file/defaulted_move_cross_tu/out/refcount/defaulted_move_cross_tu.rs b/tests/multi-file/defaulted_move_cross_tu/out/refcount/defaulted_move_cross_tu.rs
index ae955afd9..ca2556873 100644
--- a/tests/multi-file/defaulted_move_cross_tu/out/refcount/defaulted_move_cross_tu.rs
+++ b/tests/multi-file/defaulted_move_cross_tu/out/refcount/defaulted_move_cross_tu.rs
@@ -24,7 +24,7 @@ impl S {
         let this: Ptr<S> = __this.as_pointer();
         Rc::try_unwrap(__this).ok().unwrap().into_inner()
     }
-    pub fn S_pmutS(_a0: Ptr<S>) -> Self {
+    pub fn S_pmutS_rv(_a0: Ptr<S>) -> Self {
         let __this: Value<S> = Rc::new(RefCell::new(Self {
             v: Rc::new(RefCell::new(std::mem::take(
                 &mut (*(*_a0.upgrade().deref()).v.borrow_mut()),
@@ -84,18 +84,18 @@ fn main_0() -> i32 {
 pub fn shuffle_1(x: i32) -> i32 {
     let x: Value<i32> = Rc::new(RefCell::new(x));
     let a: Value<S> = Rc::new(RefCell::new(S::S({ (*x.borrow()) })));
-    let b: Value<S> = Rc::new(RefCell::new(S::S_pmutS({ a.as_pointer() })));
+    let b: Value<S> = Rc::new(RefCell::new(S::S_pmutS_rv({ a.as_pointer() })));
     assert!((*(*a.borrow()).v.borrow()).is_empty());
     let c: Value<S> = Rc::new(RefCell::new(S::S({ 1 })));
-    ({ SImpl::operator_assign_pmutS(&c.as_pointer(), b.as_pointer()) });
+    ({ SImpl::operator_assign_pmutS_rv(&c.as_pointer(), b.as_pointer()) });
     assert!((*(*b.borrow()).v.borrow()).is_empty());
     return ({ sum_0(c.as_pointer()) });
 }
 pub trait SImpl {
-    fn operator_assign_pmutS(&self, _a0: Ptr<S>) -> Ptr<S>;
+    fn operator_assign_pmutS_rv(&self, _a0: Ptr<S>) -> Ptr<S>;
 }
 impl SImpl for Ptr<S> {
-    fn operator_assign_pmutS(&self, _a0: Ptr<S>) -> Ptr<S> {
+    fn operator_assign_pmutS_rv(&self, _a0: Ptr<S>) -> Ptr<S> {
         ((*(*self).upgrade().deref()).v.as_pointer() as Ptr<Vec<i32>>).write(std::mem::take(
             &mut (*(*_a0.upgrade().deref()).v.borrow_mut()),
         ));
diff --git a/tests/multi-file/defaulted_move_cross_tu/out/unsafe/defaulted_move_cross_tu.rs b/tests/multi-file/defaulted_move_cross_tu/out/unsafe/defaulted_move_cross_tu.rs
index df813be9c..a18cb8864 100644
--- a/tests/multi-file/defaulted_move_cross_tu/out/unsafe/defaulted_move_cross_tu.rs
+++ b/tests/multi-file/defaulted_move_cross_tu/out/unsafe/defaulted_move_cross_tu.rs
@@ -20,14 +20,14 @@ impl S {
         };
         this
     }
-    pub unsafe fn S_pmutS(_a0: *mut S) -> Self {
+    pub unsafe fn S_pmutS_rv(_a0: *mut S) -> Self {
         let mut this = Self {
             v: std::mem::take(&mut (*_a0).v),
             n: std::array::from_fn::<_, 2, _>(|__i: usize| (*_a0).n[(__i)]),
         };
         this
     }
-    pub unsafe fn operator_assign_pmutS(&mut self, _a0: *mut S) -> *mut S {
+    pub unsafe fn operator_assign_pmutS_rv(&mut self, _a0: *mut S) -> *mut S {
         self.v = std::mem::take(&mut (*_a0).v);
         {
             if 8_usize != 0 {
@@ -67,10 +67,10 @@ unsafe fn main_0() -> i32 {
 }
 pub unsafe fn shuffle_1(mut x: i32) -> i32 {
     let mut a: S = S::S({ x });
-    let mut b: S = S::S_pmutS({ &mut a });
+    let mut b: S = S::S_pmutS_rv({ &mut a });
     assert!(a.v.is_empty());
     let mut c: S = S::S({ 1 });
-    (unsafe { S::operator_assign_pmutS(&mut c, &mut b) });
+    (unsafe { S::operator_assign_pmutS_rv(&mut c, &mut b) });
     assert!(b.v.is_empty());
     return (unsafe { sum_0(&c) });
 }
diff --git a/tests/unit/out/refcount/copy_move_defaulted.rs b/tests/unit/out/refcount/copy_move_defaulted.rs
index aca969c9f..80fb052dd 100644
--- a/tests/unit/out/refcount/copy_move_defaulted.rs
+++ b/tests/unit/out/refcount/copy_move_defaulted.rs
@@ -153,7 +153,7 @@ impl DefaultCopyUserMove {
         let this: Ptr<DefaultCopyUserMove> = __this.as_pointer();
         Rc::try_unwrap(__this).ok().unwrap().into_inner()
     }
-    pub fn DefaultCopyUserMove_pmutDefaultCopyUserMove(o: Ptr<DefaultCopyUserMove>) -> Self {
+    pub fn DefaultCopyUserMove_pmutDefaultCopyUserMove_rv(o: Ptr<DefaultCopyUserMove>) -> Self {
         let __this: Value<DefaultCopyUserMove> = Rc::new(RefCell::new(Self {
             v: Rc::new(RefCell::new((*(*o.upgrade().deref()).v.borrow()))),
         }));
@@ -204,7 +204,7 @@ impl UserCopyDefaultMove {
         let this: Ptr<UserCopyDefaultMove> = __this.as_pointer();
         Rc::try_unwrap(__this).ok().unwrap().into_inner()
     }
-    pub fn UserCopyDefaultMove_pmutUserCopyDefaultMove(_a0: Ptr<UserCopyDefaultMove>) -> Self {
+    pub fn UserCopyDefaultMove_pmutUserCopyDefaultMove_rv(_a0: Ptr<UserCopyDefaultMove>) -> Self {
         let __this: Value<UserCopyDefaultMove> = Rc::new(RefCell::new(Self {
             v: Rc::new(RefCell::new((*(*_a0.upgrade().deref()).v.borrow()))),
         }));
@@ -261,7 +261,7 @@ impl Buffer {
         );
         Rc::try_unwrap(__this).ok().unwrap().into_inner()
     }
-    pub fn Buffer_pmutBuffer(_a0: Ptr<Buffer>) -> Self {
+    pub fn Buffer_pmutBuffer_rv(_a0: Ptr<Buffer>) -> Self {
         let __this: Value<Buffer> = Rc::new(RefCell::new(Self {
             data: Rc::new(RefCell::new(std::mem::take(
                 &mut (*(*_a0.upgrade().deref()).data.borrow_mut()),
@@ -319,7 +319,7 @@ pub struct Owner {
     pub p: Value<Option<Value<i32>>>,
 }
 impl Owner {
-    pub fn Owner_pmutOwner(_a0: Ptr<Owner>) -> Self {
+    pub fn Owner_pmutOwner_rv(_a0: Ptr<Owner>) -> Self {
         let __this: Value<Owner> = Rc::new(RefCell::new(Self {
             data: Rc::new(RefCell::new(std::mem::take(
                 &mut (*(*_a0.upgrade().deref()).data.borrow_mut()),
@@ -386,7 +386,7 @@ impl Holder {
         let this: Ptr<Holder> = __this.as_pointer();
         Rc::try_unwrap(__this).ok().unwrap().into_inner()
     }
-    pub fn Holder_pmutHolder(_a0: Ptr<Holder>) -> Self {
+    pub fn Holder_pmutHolder_rv(_a0: Ptr<Holder>) -> Self {
         let __this: Value<Holder> = Rc::new(RefCell::new(Self {
             inner: Rc::new(RefCell::new(
                 (*(*_a0.upgrade().deref()).inner.borrow()).clone(),
@@ -526,7 +526,7 @@ fn main_0() -> i32 {
         })));
     let m1: Value<DefaultCopyUserMove> = Rc::new(RefCell::new((*m.borrow()).clone()));
     let m2: Value<DefaultCopyUserMove> = Rc::new(RefCell::new(
-        DefaultCopyUserMove::DefaultCopyUserMove_pmutDefaultCopyUserMove({ m.as_pointer() }),
+        DefaultCopyUserMove::DefaultCopyUserMove_pmutDefaultCopyUserMove_rv({ m.as_pointer() }),
     ));
     assert!(
         (((*(*m1.borrow()).v.borrow()) == 7) && ((*(*m2.borrow()).v.borrow()) == 7))
@@ -542,7 +542,7 @@ fn main_0() -> i32 {
         })));
     (*m3.borrow_mut()) = (*m1.borrow()).clone();
     ({
-        DefaultCopyUserMoveImpl::operator_assign_pmutDefaultCopyUserMove(
+        DefaultCopyUserMoveImpl::operator_assign_pmutDefaultCopyUserMove_rv(
             &m4.as_pointer(),
             m1.as_pointer(),
         )
@@ -559,7 +559,7 @@ fn main_0() -> i32 {
         UserCopyDefaultMove::UserCopyDefaultMove_pconstUserCopyDefaultMove({ u.as_pointer() }),
     ));
     let u2: Value<UserCopyDefaultMove> = Rc::new(RefCell::new(
-        UserCopyDefaultMove::UserCopyDefaultMove_pmutUserCopyDefaultMove({ u.as_pointer() }),
+        UserCopyDefaultMove::UserCopyDefaultMove_pmutUserCopyDefaultMove_rv({ u.as_pointer() }),
     ));
     assert!(
         (((*(*u1.borrow()).v.borrow()) == 108) && ((*(*u2.borrow()).v.borrow()) == 8))
@@ -580,14 +580,16 @@ fn main_0() -> i32 {
         )
     });
     ({
-        UserCopyDefaultMoveImpl::operator_assign_pmutUserCopyDefaultMove(
+        UserCopyDefaultMoveImpl::operator_assign_pmutUserCopyDefaultMove_rv(
             &u4.as_pointer(),
             u2.as_pointer(),
         )
     });
     assert!(((*(*u3.borrow()).v.borrow()) == 108) && ((*(*u4.borrow()).v.borrow()) == 8));
     let p: Value<Buffer> = Rc::new(RefCell::new(Buffer::Buffer({ 3 })));
-    let q: Value<Buffer> = Rc::new(RefCell::new(Buffer::Buffer_pmutBuffer({ p.as_pointer() })));
+    let q: Value<Buffer> = Rc::new(RefCell::new(Buffer::Buffer_pmutBuffer_rv({
+        p.as_pointer()
+    })));
     assert!(
         ((((*(*q.borrow()).n.borrow()) == 3) && ((*(*q.borrow()).data.borrow()).len() == 3_usize))
             && ((((*q.borrow()).data.as_pointer() as Ptr<i32>)
@@ -597,7 +599,7 @@ fn main_0() -> i32 {
             && ((*(*p.borrow()).data.borrow()).is_empty())
     );
     let r: Value<Buffer> = Rc::new(RefCell::new(Buffer::Buffer({ 1 })));
-    ({ BufferImpl::operator_assign_pmutBuffer(&r.as_pointer(), q.as_pointer()) });
+    ({ BufferImpl::operator_assign_pmutBuffer_rv(&r.as_pointer(), q.as_pointer()) });
     assert!(
         ((((*(*r.borrow()).n.borrow()) == 3) && ((*(*r.borrow()).data.borrow()).len() == 3_usize))
             && ((*(*r.borrow()).arr.borrow())[(1) as usize] == 4))
@@ -617,10 +619,10 @@ fn main_0() -> i32 {
             && ((*(*q.borrow()).rows.borrow()).is_empty())
     );
     let bufs: Value<Vec<Buffer>> = Rc::new(RefCell::new(Vec::new()));
-    (*bufs.borrow_mut()).push(Buffer::Buffer_pmutBuffer({ r.as_pointer() }));
+    (*bufs.borrow_mut()).push(Buffer::Buffer_pmutBuffer_rv({ r.as_pointer() }));
     {
         let __arg =
-            Buffer::Buffer_pmutBuffer({ (bufs.as_pointer() as Ptr<Buffer>).offset(0_usize) });
+            Buffer::Buffer_pmutBuffer_rv({ (bufs.as_pointer() as Ptr<Buffer>).offset(0_usize) });
         bufs.as_pointer()
             .with_mut(|__v: &mut Vec<Buffer>| __v.push(__arg))
     };
@@ -657,7 +659,7 @@ fn main_0() -> i32 {
         let _p: Ptr<_> = Ptr::alloc(7);
         (*(*o1.borrow()).p.borrow_mut()) = _p.to_owned_opt()
     };
-    let o2: Value<Owner> = Rc::new(RefCell::new(Owner::Owner_pmutOwner({ o1.as_pointer() })));
+    let o2: Value<Owner> = Rc::new(RefCell::new(Owner::Owner_pmutOwner_rv({ o1.as_pointer() })));
     assert!(
         ((((*(*o2.borrow()).n.borrow()) == 5)
             && ((*(*o2.borrow()).data.borrow()).len() == 1_usize))
@@ -669,7 +671,7 @@ fn main_0() -> i32 {
             && (((*(*o1.borrow()).p.borrow()).as_pointer()).is_null())
     );
     let o3: Value<Owner> = Rc::new(RefCell::new(<Owner>::default()));
-    ({ OwnerImpl::operator_assign_pmutOwner(&o3.as_pointer(), o2.as_pointer()) });
+    ({ OwnerImpl::operator_assign_pmutOwner_rv(&o3.as_pointer(), o2.as_pointer()) });
     assert!(
         ((((*(*o3.borrow()).n.borrow()) == 5)
             && ((((*o3.borrow()).data.as_pointer() as Ptr<i32>)
@@ -689,7 +691,9 @@ fn main_0() -> i32 {
         let _p: Ptr<_> = Ptr::alloc(9);
         (*(*h1.borrow()).p.borrow_mut()) = _p.to_owned_opt()
     };
-    let h2: Value<Holder> = Rc::new(RefCell::new(Holder::Holder_pmutHolder({ h1.as_pointer() })));
+    let h2: Value<Holder> = Rc::new(RefCell::new(Holder::Holder_pmutHolder_rv({
+        h1.as_pointer()
+    })));
     let _dtor_h2 = ScopedDestructor::new(&h2, |__p| __p.destructor());
     assert!(
         ((((*(*(*h2.borrow()).inner.borrow()).x.borrow()) == 4)
@@ -699,7 +703,7 @@ fn main_0() -> i32 {
     );
     let h3: Value<Holder> = Rc::new(RefCell::new(Holder::Holder({ 1 })));
     let _dtor_h3 = ScopedDestructor::new(&h3, |__p| __p.destructor());
-    ({ HolderImpl::operator_assign_pmutHolder(&h3.as_pointer(), h2.as_pointer()) });
+    ({ HolderImpl::operator_assign_pmutHolder_rv(&h3.as_pointer(), h2.as_pointer()) });
     assert!(
         ((((*(*(*h3.borrow()).inner.borrow()).x.borrow()) == 4)
             && ((*(*(*h3.borrow()).e.borrow()).arr.borrow())[(1) as usize] == 5))
@@ -709,10 +713,10 @@ fn main_0() -> i32 {
     return 0;
 }
 pub trait BufferImpl {
-    fn operator_assign_pmutBuffer(&self, _a0: Ptr<Buffer>) -> Ptr<Buffer>;
+    fn operator_assign_pmutBuffer_rv(&self, _a0: Ptr<Buffer>) -> Ptr<Buffer>;
 }
 impl BufferImpl for Ptr<Buffer> {
-    fn operator_assign_pmutBuffer(&self, _a0: Ptr<Buffer>) -> Ptr<Buffer> {
+    fn operator_assign_pmutBuffer_rv(&self, _a0: Ptr<Buffer>) -> Ptr<Buffer> {
         ((*(*self).upgrade().deref()).data.as_pointer() as Ptr<Vec<i32>>).write(std::mem::take(
             &mut (*(*_a0.upgrade().deref()).data.borrow_mut()),
         ));
@@ -734,13 +738,13 @@ impl BufferImpl for Ptr<Buffer> {
     }
 }
 pub trait DefaultCopyUserMoveImpl {
-    fn operator_assign_pmutDefaultCopyUserMove(
+    fn operator_assign_pmutDefaultCopyUserMove_rv(
         &self,
         o: Ptr<DefaultCopyUserMove>,
     ) -> Ptr<DefaultCopyUserMove>;
 }
 impl DefaultCopyUserMoveImpl for Ptr<DefaultCopyUserMove> {
-    fn operator_assign_pmutDefaultCopyUserMove(
+    fn operator_assign_pmutDefaultCopyUserMove_rv(
         &self,
         o: Ptr<DefaultCopyUserMove>,
     ) -> Ptr<DefaultCopyUserMove> {
@@ -757,11 +761,11 @@ impl ExplicitImpl for Ptr<Explicit> {
     fn destructor(&self) {}
 }
 pub trait HolderImpl {
-    fn operator_assign_pmutHolder(&self, _a0: Ptr<Holder>) -> Ptr<Holder>;
+    fn operator_assign_pmutHolder_rv(&self, _a0: Ptr<Holder>) -> Ptr<Holder>;
     fn destructor(&self);
 }
 impl HolderImpl for Ptr<Holder> {
-    fn operator_assign_pmutHolder(&self, _a0: Ptr<Holder>) -> Ptr<Holder> {
+    fn operator_assign_pmutHolder_rv(&self, _a0: Ptr<Holder>) -> Ptr<Holder> {
         let __rhs = (*(*_a0.upgrade().deref()).inner.borrow()).clone();
         (*(*(*self).upgrade().deref()).inner.borrow_mut()) = __rhs;
         let __rhs = (*(*_a0.upgrade().deref()).e.borrow()).clone();
@@ -775,10 +779,10 @@ impl HolderImpl for Ptr<Holder> {
     }
 }
 pub trait OwnerImpl {
-    fn operator_assign_pmutOwner(&self, _a0: Ptr<Owner>) -> Ptr<Owner>;
+    fn operator_assign_pmutOwner_rv(&self, _a0: Ptr<Owner>) -> Ptr<Owner>;
 }
 impl OwnerImpl for Ptr<Owner> {
-    fn operator_assign_pmutOwner(&self, _a0: Ptr<Owner>) -> Ptr<Owner> {
+    fn operator_assign_pmutOwner_rv(&self, _a0: Ptr<Owner>) -> Ptr<Owner> {
         ((*(*self).upgrade().deref()).data.as_pointer() as Ptr<Vec<i32>>).write(std::mem::take(
             &mut (*(*_a0.upgrade().deref()).data.borrow_mut()),
         ));
@@ -803,7 +807,7 @@ pub trait UserCopyDefaultMoveImpl {
         &self,
         o: Ptr<UserCopyDefaultMove>,
     ) -> Ptr<UserCopyDefaultMove>;
-    fn operator_assign_pmutUserCopyDefaultMove(
+    fn operator_assign_pmutUserCopyDefaultMove_rv(
         &self,
         _a0: Ptr<UserCopyDefaultMove>,
     ) -> Ptr<UserCopyDefaultMove>;
@@ -817,7 +821,7 @@ impl UserCopyDefaultMoveImpl for Ptr<UserCopyDefaultMove> {
         (*(*(*self).upgrade().deref()).v.borrow_mut()) = __rhs;
         return (*self).clone();
     }
-    fn operator_assign_pmutUserCopyDefaultMove(
+    fn operator_assign_pmutUserCopyDefaultMove_rv(
         &self,
         _a0: Ptr<UserCopyDefaultMove>,
     ) -> Ptr<UserCopyDefaultMove> {
diff --git a/tests/unit/out/refcount/copy_move_deleted.rs b/tests/unit/out/refcount/copy_move_deleted.rs
index a1c4ccf98..115529237 100644
--- a/tests/unit/out/refcount/copy_move_deleted.rs
+++ b/tests/unit/out/refcount/copy_move_deleted.rs
@@ -19,7 +19,7 @@ impl NoCopy {
         let this: Ptr<NoCopy> = __this.as_pointer();
         Rc::try_unwrap(__this).ok().unwrap().into_inner()
     }
-    pub fn NoCopy_pmutNoCopy(o: Ptr<NoCopy>) -> Self {
+    pub fn NoCopy_pmutNoCopy_rv(o: Ptr<NoCopy>) -> Self {
         let __this: Value<NoCopy> = Rc::new(RefCell::new(Self {
             v: Rc::new(RefCell::new((*(*o.upgrade().deref()).v.borrow()))),
         }));
@@ -53,7 +53,7 @@ impl PrivateCopy {
         let this: Ptr<PrivateCopy> = __this.as_pointer();
         Rc::try_unwrap(__this).ok().unwrap().into_inner()
     }
-    pub fn PrivateCopy_pmutPrivateCopy(o: Ptr<PrivateCopy>) -> Self {
+    pub fn PrivateCopy_pmutPrivateCopy_rv(o: Ptr<PrivateCopy>) -> Self {
         let __this: Value<PrivateCopy> = Rc::new(RefCell::new(Self {
             v: Rc::new(RefCell::new((*(*o.upgrade().deref()).v.borrow()))),
         }));
@@ -117,9 +117,9 @@ pub struct Container {
     pub tag: Value<i32>,
 }
 impl Container {
-    pub fn Container_pmutContainer(_a0: Ptr<Container>) -> Self {
+    pub fn Container_pmutContainer_rv(_a0: Ptr<Container>) -> Self {
         let __this: Value<Container> = Rc::new(RefCell::new(Self {
-            inner: Rc::new(RefCell::new(NoCopy::NoCopy_pmutNoCopy({
+            inner: Rc::new(RefCell::new(NoCopy::NoCopy_pmutNoCopy_rv({
                 (*_a0.upgrade().deref()).inner.as_pointer()
             }))),
             tag: Rc::new(RefCell::new((*(*_a0.upgrade().deref()).tag.borrow()))),
@@ -156,19 +156,22 @@ pub fn main() {
 }
 fn main_0() -> i32 {
     let a: Value<NoCopy> = Rc::new(RefCell::new(NoCopy::NoCopy({ 1 })));
-    let b: Value<NoCopy> = Rc::new(RefCell::new(NoCopy::NoCopy_pmutNoCopy({ a.as_pointer() })));
+    let b: Value<NoCopy> = Rc::new(RefCell::new(NoCopy::NoCopy_pmutNoCopy_rv({
+        a.as_pointer()
+    })));
     assert!(((*(*b.borrow()).v.borrow()) == 1) && ((*(*a.borrow()).v.borrow()) == 0));
-    ({ NoCopyImpl::operator_assign_pmutNoCopy(&a.as_pointer(), b.as_pointer()) });
+    ({ NoCopyImpl::operator_assign_pmutNoCopy_rv(&a.as_pointer(), b.as_pointer()) });
     assert!(((*(*a.borrow()).v.borrow()) == 1) && ((*(*b.borrow()).v.borrow()) == 0));
     ({ bump_0((a.as_pointer())) });
     assert!(((*(*a.borrow()).v.borrow()) == 2));
     let p: Value<PrivateCopy> = Rc::new(RefCell::new(PrivateCopy::PrivateCopy()));
     (*(*p.borrow()).v.borrow_mut()) = 3;
-    let q: Value<PrivateCopy> = Rc::new(RefCell::new(PrivateCopy::PrivateCopy_pmutPrivateCopy({
-        p.as_pointer()
-    })));
+    let q: Value<PrivateCopy> =
+        Rc::new(RefCell::new(PrivateCopy::PrivateCopy_pmutPrivateCopy_rv({
+            p.as_pointer()
+        })));
     assert!(((*(*q.borrow()).v.borrow()) == 3) && ((*(*p.borrow()).v.borrow()) == 0));
-    ({ PrivateCopyImpl::operator_assign_pmutPrivateCopy(&p.as_pointer(), q.as_pointer()) });
+    ({ PrivateCopyImpl::operator_assign_pmutPrivateCopy_rv(&p.as_pointer(), q.as_pointer()) });
     assert!(((*(*p.borrow()).v.borrow()) == 3) && ((*(*q.borrow()).v.borrow()) == 0));
     let im: Value<Immovable> = Rc::new(RefCell::new(Immovable::Immovable()));
     (*(*im.borrow()).v.borrow_mut()) = 4;
@@ -179,7 +182,7 @@ fn main_0() -> i32 {
         inner: Rc::new(RefCell::new(NoCopy::NoCopy({ 6 }))),
         tag: Rc::new(RefCell::new(7)),
     }));
-    let d: Value<Container> = Rc::new(RefCell::new(Container::Container_pmutContainer({
+    let d: Value<Container> = Rc::new(RefCell::new(Container::Container_pmutContainer_rv({
         c.as_pointer()
     })));
     assert!(
@@ -190,13 +193,13 @@ fn main_0() -> i32 {
     return 0;
 }
 pub trait ContainerImpl {
-    fn operator_assign_pmutContainer(&self, _a0: Ptr<Container>) -> Ptr<Container>;
+    fn operator_assign_pmutContainer_rv(&self, _a0: Ptr<Container>) -> Ptr<Container>;
 }
 impl ContainerImpl for Ptr<Container> {
-    fn operator_assign_pmutContainer(&self, _a0: Ptr<Container>) -> Ptr<Container> {
+    fn operator_assign_pmutContainer_rv(&self, _a0: Ptr<Container>) -> Ptr<Container> {
         ({
             let _o: Ptr<NoCopy> = (*_a0.upgrade().deref()).inner.as_pointer();
-            NoCopyImpl::operator_assign_pmutNoCopy(
+            NoCopyImpl::operator_assign_pmutNoCopy_rv(
                 &(*(*self).upgrade().deref()).inner.as_pointer(),
                 _o,
             )
@@ -207,10 +210,10 @@ impl ContainerImpl for Ptr<Container> {
     }
 }
 pub trait NoCopyImpl {
-    fn operator_assign_pmutNoCopy(&self, o: Ptr<NoCopy>) -> Ptr<NoCopy>;
+    fn operator_assign_pmutNoCopy_rv(&self, o: Ptr<NoCopy>) -> Ptr<NoCopy>;
 }
 impl NoCopyImpl for Ptr<NoCopy> {
-    fn operator_assign_pmutNoCopy(&self, o: Ptr<NoCopy>) -> Ptr<NoCopy> {
+    fn operator_assign_pmutNoCopy_rv(&self, o: Ptr<NoCopy>) -> Ptr<NoCopy> {
         let __rhs = (*(*o.upgrade().deref()).v.borrow());
         (*(*(*self).upgrade().deref()).v.borrow_mut()) = __rhs;
         (*(*o.upgrade().deref()).v.borrow_mut()) = 0;
@@ -218,10 +221,10 @@ impl NoCopyImpl for Ptr<NoCopy> {
     }
 }
 pub trait PrivateCopyImpl {
-    fn operator_assign_pmutPrivateCopy(&self, o: Ptr<PrivateCopy>) -> Ptr<PrivateCopy>;
+    fn operator_assign_pmutPrivateCopy_rv(&self, o: Ptr<PrivateCopy>) -> Ptr<PrivateCopy>;
 }
 impl PrivateCopyImpl for Ptr<PrivateCopy> {
-    fn operator_assign_pmutPrivateCopy(&self, o: Ptr<PrivateCopy>) -> Ptr<PrivateCopy> {
+    fn operator_assign_pmutPrivateCopy_rv(&self, o: Ptr<PrivateCopy>) -> Ptr<PrivateCopy> {
         let __rhs = (*(*o.upgrade().deref()).v.borrow());
         (*(*(*self).upgrade().deref()).v.borrow_mut()) = __rhs;
         (*(*o.upgrade().deref()).v.borrow_mut()) = 0;
diff --git a/tests/unit/out/refcount/huffman.rs b/tests/unit/out/refcount/huffman.rs
index bd74793c6..a03c2cc4c 100644
--- a/tests/unit/out/refcount/huffman.rs
+++ b/tests/unit/out/refcount/huffman.rs
@@ -83,7 +83,7 @@ pub struct MinHeap {
     pub alloc: Value<Option<Value<Box<[MinHeapNode]>>>>,
 }
 impl MinHeap {
-    pub fn MinHeap_pmutMinHeap(_a0: Ptr<MinHeap>) -> Self {
+    pub fn MinHeap_pmutMinHeap_rv(_a0: Ptr<MinHeap>) -> Self {
         let __this: Value<MinHeap> = Rc::new(RefCell::new(Self {
             size: Rc::new(RefCell::new((*(*_a0.upgrade().deref()).size.borrow()))),
             capacity: Rc::new(RefCell::new((*(*_a0.upgrade().deref()).capacity.borrow()))),
@@ -353,7 +353,7 @@ pub trait MinHeapImpl {
         freq: Ptr<Option<Value<Box<[i32]>>>>,
         n: i32,
     );
-    fn operator_assign_pmutMinHeap(&self, _a0: Ptr<MinHeap>) -> Ptr<MinHeap>;
+    fn operator_assign_pmutMinHeap_rv(&self, _a0: Ptr<MinHeap>) -> Ptr<MinHeap>;
 }
 impl MinHeapImpl for Ptr<MinHeap> {
     fn Alloc(&self, data: u8, freq: i32) -> Ptr<MinHeapNode> {
@@ -525,7 +525,7 @@ impl MinHeapImpl for Ptr<MinHeap> {
             (*i.borrow_mut()).prefix_dec();
         }
     }
-    fn operator_assign_pmutMinHeap(&self, _a0: Ptr<MinHeap>) -> Ptr<MinHeap> {
+    fn operator_assign_pmutMinHeap_rv(&self, _a0: Ptr<MinHeap>) -> Ptr<MinHeap> {
         let __rhs = (*(*_a0.upgrade().deref()).size.borrow());
         (*(*(*self).upgrade().deref()).size.borrow_mut()) = __rhs;
         let __rhs = (*(*_a0.upgrade().deref()).capacity.borrow());
diff --git a/tests/unit/out/refcount/kruskal.rs b/tests/unit/out/refcount/kruskal.rs
index 0b7692a73..f2a511bdb 100644
--- a/tests/unit/out/refcount/kruskal.rs
+++ b/tests/unit/out/refcount/kruskal.rs
@@ -222,7 +222,7 @@ pub struct DisjointSet {
     pub n: Value<i32>,
 }
 impl DisjointSet {
-    pub fn DisjointSet_pmutDisjointSet(_a0: Ptr<DisjointSet>) -> Self {
+    pub fn DisjointSet_pmutDisjointSet_rv(_a0: Ptr<DisjointSet>) -> Self {
         let __this: Value<DisjointSet> = Rc::new(RefCell::new(Self {
             rank: Rc::new(RefCell::new(
                 (*(*_a0.upgrade().deref()).rank.borrow_mut()).take(),
@@ -264,7 +264,7 @@ pub struct Graph {
     pub E: Value<i32>,
 }
 impl Graph {
-    pub fn Graph_pmutGraph(_a0: Ptr<Graph>) -> Self {
+    pub fn Graph_pmutGraph_rv(_a0: Ptr<Graph>) -> Self {
         let __this: Value<Graph> = Rc::new(RefCell::new(Self {
             edges: Rc::new(RefCell::new(
                 (*(*_a0.upgrade().deref()).edges.borrow_mut()).take(),
@@ -419,7 +419,7 @@ pub trait DisjointSetImpl {
     fn makeSet(&self);
     fn find(&self, x: i32) -> i32;
     fn merge(&self, x: i32, y: i32);
-    fn operator_assign_pmutDisjointSet(&self, _a0: Ptr<DisjointSet>) -> Ptr<DisjointSet>;
+    fn operator_assign_pmutDisjointSet_rv(&self, _a0: Ptr<DisjointSet>) -> Ptr<DisjointSet>;
 }
 impl DisjointSetImpl for Ptr<DisjointSet> {
     fn makeSet(&self) {
@@ -516,7 +516,7 @@ impl DisjointSetImpl for Ptr<DisjointSet> {
                 .borrow_mut()[((*xset.borrow()) as usize) as usize] = __rhs;
         }
     }
-    fn operator_assign_pmutDisjointSet(&self, _a0: Ptr<DisjointSet>) -> Ptr<DisjointSet> {
+    fn operator_assign_pmutDisjointSet_rv(&self, _a0: Ptr<DisjointSet>) -> Ptr<DisjointSet> {
         ((*(*self).upgrade().deref()).rank.as_pointer() as Ptr<Option<Value<Box<[i32]>>>>)
             .write((*(*_a0.upgrade().deref()).rank.borrow_mut()).take());
         ((*(*self).upgrade().deref()).parent.as_pointer() as Ptr<Option<Value<Box<[i32]>>>>)
@@ -527,10 +527,10 @@ impl DisjointSetImpl for Ptr<DisjointSet> {
     }
 }
 pub trait GraphImpl {
-    fn operator_assign_pmutGraph(&self, _a0: Ptr<Graph>) -> Ptr<Graph>;
+    fn operator_assign_pmutGraph_rv(&self, _a0: Ptr<Graph>) -> Ptr<Graph>;
 }
 impl GraphImpl for Ptr<Graph> {
-    fn operator_assign_pmutGraph(&self, _a0: Ptr<Graph>) -> Ptr<Graph> {
+    fn operator_assign_pmutGraph_rv(&self, _a0: Ptr<Graph>) -> Ptr<Graph> {
         ((*(*self).upgrade().deref()).edges.as_pointer() as Ptr<Option<Value<Box<[Edge]>>>>)
             .write((*(*_a0.upgrade().deref()).edges.borrow_mut()).take());
         let __rhs = (*(*_a0.upgrade().deref()).V.borrow());
diff --git a/tests/unit/out/refcount/move_assign.rs b/tests/unit/out/refcount/move_assign.rs
index a37b59de7..c07df46a0 100644
--- a/tests/unit/out/refcount/move_assign.rs
+++ b/tests/unit/out/refcount/move_assign.rs
@@ -19,7 +19,7 @@ impl MoveOnly {
         let this: Ptr<MoveOnly> = __this.as_pointer();
         Rc::try_unwrap(__this).ok().unwrap().into_inner()
     }
-    pub fn MoveOnly_pmutMoveOnly(o: Ptr<MoveOnly>) -> Self {
+    pub fn MoveOnly_pmutMoveOnly_rv(o: Ptr<MoveOnly>) -> Self {
         let __this: Value<MoveOnly> = Rc::new(RefCell::new(Self {
             v: Rc::new(RefCell::new((*(*o.upgrade().deref()).v.borrow()))),
         }));
@@ -75,7 +75,7 @@ impl ByteRepr for ConstMoveAssign {
 pub fn make_0(v: i32) -> MoveOnly {
     let v: Value<i32> = Rc::new(RefCell::new(v));
     let m: Value<MoveOnly> = Rc::new(RefCell::new(MoveOnly::MoveOnly({ (*v.borrow()) })));
-    return MoveOnly::MoveOnly_pmutMoveOnly({ m.as_pointer() });
+    return MoveOnly::MoveOnly_pmutMoveOnly_rv({ m.as_pointer() });
 }
 pub fn main() {
     __cpp2rust_init_globals();
@@ -85,17 +85,17 @@ fn main_0() -> i32 {
     let a: Value<MoveOnly> = Rc::new(RefCell::new(MoveOnly::MoveOnly({ 1 })));
     let b: Value<MoveOnly> = Rc::new(RefCell::new(MoveOnly::MoveOnly({ 2 })));
     let c: Value<MoveOnly> = Rc::new(RefCell::new(MoveOnly::MoveOnly({ 3 })));
-    ({ MoveOnlyImpl::operator_assign_pmutMoveOnly(&a.as_pointer(), b.as_pointer()) });
+    ({ MoveOnlyImpl::operator_assign_pmutMoveOnly_rv(&a.as_pointer(), b.as_pointer()) });
     assert!(((*(*a.borrow()).v.borrow()) == 2));
     assert!(((*(*b.borrow()).v.borrow()) == 0));
     ({
         let _o: Value<MoveOnly> = Rc::new(RefCell::new(MoveOnly::MoveOnly({ 3 })));
-        MoveOnlyImpl::operator_assign_pmutMoveOnly(&b.as_pointer(), _o.as_pointer())
+        MoveOnlyImpl::operator_assign_pmutMoveOnly_rv(&b.as_pointer(), _o.as_pointer())
     });
     ({
-        MoveOnlyImpl::operator_assign_pmutMoveOnly(
+        MoveOnlyImpl::operator_assign_pmutMoveOnly_rv(
             &c.as_pointer(),
-            ({ MoveOnlyImpl::operator_assign_pmutMoveOnly(&a.as_pointer(), b.as_pointer()) }),
+            ({ MoveOnlyImpl::operator_assign_pmutMoveOnly_rv(&a.as_pointer(), b.as_pointer()) }),
         )
     });
     assert!(
@@ -104,24 +104,24 @@ fn main_0() -> i32 {
     );
     ({
         let _o: Value<MoveOnly> = Rc::new(RefCell::new(MoveOnly::MoveOnly({ 5 })));
-        MoveOnlyImpl::operator_assign_pmutMoveOnly(&a.as_pointer(), _o.as_pointer())
+        MoveOnlyImpl::operator_assign_pmutMoveOnly_rv(&a.as_pointer(), _o.as_pointer())
     });
     assert!(((*(*a.borrow()).v.borrow()) == 5));
     ({
         let _o: Value<MoveOnly> = Rc::new(RefCell::new(({ make_0(6) })));
-        MoveOnlyImpl::operator_assign_pmutMoveOnly(&a.as_pointer(), _o.as_pointer())
+        MoveOnlyImpl::operator_assign_pmutMoveOnly_rv(&a.as_pointer(), _o.as_pointer())
     });
     assert!(((*(*a.borrow()).v.borrow()) == 6));
     ({
         let _o: Ptr<MoveOnly> = a.as_pointer();
-        MoveOnlyImpl::operator_assign_pmutMoveOnly(&a.as_pointer(), _o)
+        MoveOnlyImpl::operator_assign_pmutMoveOnly_rv(&a.as_pointer(), _o)
     });
     assert!(((*(*a.borrow()).v.borrow()) == 6));
     let vec_: Value<Vec<MoveOnly>> = Rc::new(RefCell::new(Vec::new()));
     (*vec_.borrow_mut()).push(MoveOnly::MoveOnly({ 7 }));
     let d: Value<MoveOnly> = Rc::new(RefCell::new(MoveOnly::MoveOnly({ 8 })));
     ({
-        MoveOnlyImpl::operator_assign_pmutMoveOnly(
+        MoveOnlyImpl::operator_assign_pmutMoveOnly_rv(
             &(vec_.as_pointer() as Ptr<MoveOnly>).offset(0_usize),
             d.as_pointer(),
         )
@@ -141,10 +141,13 @@ fn main_0() -> i32 {
     let m2: Value<ConstMoveAssign> = Rc::new(RefCell::new(ConstMoveAssign::ConstMoveAssign()));
     let cm: Value<ConstMoveAssign> = Rc::new(RefCell::new(ConstMoveAssign::ConstMoveAssign()));
     ({
-        ConstMoveAssignImpl::operator_assign_pmutConstMoveAssign(&m1.as_pointer(), m.as_pointer())
+        ConstMoveAssignImpl::operator_assign_pmutConstMoveAssign_rv(
+            &m1.as_pointer(),
+            m.as_pointer(),
+        )
     });
     ({
-        ConstMoveAssignImpl::operator_assign_pconstConstMoveAssign(
+        ConstMoveAssignImpl::operator_assign_pconstConstMoveAssign_rv(
             &m2.as_pointer(),
             cm.as_pointer(),
         )
@@ -154,19 +157,25 @@ fn main_0() -> i32 {
     return 0;
 }
 pub trait ConstMoveAssignImpl {
-    fn operator_assign_pmutConstMoveAssign(&self, o: Ptr<ConstMoveAssign>) -> Ptr<ConstMoveAssign>;
-    fn operator_assign_pconstConstMoveAssign(
+    fn operator_assign_pmutConstMoveAssign_rv(
+        &self,
+        o: Ptr<ConstMoveAssign>,
+    ) -> Ptr<ConstMoveAssign>;
+    fn operator_assign_pconstConstMoveAssign_rv(
         &self,
         o: Ptr<ConstMoveAssign>,
     ) -> Ptr<ConstMoveAssign>;
 }
 impl ConstMoveAssignImpl for Ptr<ConstMoveAssign> {
-    fn operator_assign_pmutConstMoveAssign(&self, o: Ptr<ConstMoveAssign>) -> Ptr<ConstMoveAssign> {
+    fn operator_assign_pmutConstMoveAssign_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(
+    fn operator_assign_pconstConstMoveAssign_rv(
         &self,
         o: Ptr<ConstMoveAssign>,
     ) -> Ptr<ConstMoveAssign> {
@@ -176,10 +185,10 @@ impl ConstMoveAssignImpl for Ptr<ConstMoveAssign> {
     }
 }
 pub trait MoveOnlyImpl {
-    fn operator_assign_pmutMoveOnly(&self, o: Ptr<MoveOnly>) -> Ptr<MoveOnly>;
+    fn operator_assign_pmutMoveOnly_rv(&self, o: Ptr<MoveOnly>) -> Ptr<MoveOnly>;
 }
 impl MoveOnlyImpl for Ptr<MoveOnly> {
-    fn operator_assign_pmutMoveOnly(&self, o: Ptr<MoveOnly>) -> Ptr<MoveOnly> {
+    fn operator_assign_pmutMoveOnly_rv(&self, o: Ptr<MoveOnly>) -> Ptr<MoveOnly> {
         if ((*self) == (o)) {
             return (*self).clone();
         }
diff --git a/tests/unit/out/refcount/move_ctor.rs b/tests/unit/out/refcount/move_ctor.rs
index 3f3d2269f..b1fb9c2dd 100644
--- a/tests/unit/out/refcount/move_ctor.rs
+++ b/tests/unit/out/refcount/move_ctor.rs
@@ -19,7 +19,7 @@ impl MoveOnly {
         let this: Ptr<MoveOnly> = __this.as_pointer();
         Rc::try_unwrap(__this).ok().unwrap().into_inner()
     }
-    pub fn MoveOnly_pmutMoveOnly(o: Ptr<MoveOnly>) -> Self {
+    pub fn MoveOnly_pmutMoveOnly_rv(o: Ptr<MoveOnly>) -> Self {
         let __this: Value<MoveOnly> = Rc::new(RefCell::new(Self {
             v: Rc::new(RefCell::new((*(*o.upgrade().deref()).v.borrow()))),
         }));
@@ -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(o: Ptr<ConstMove>) -> Self {
+    pub fn ConstMove_pmutConstMove_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(o: Ptr<ConstMove>) -> Self {
+    pub fn ConstMove_pconstConstMove_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))),
         }));
@@ -93,7 +93,7 @@ pub fn by_value_0(m: MoveOnly) -> i32 {
 pub fn make_1(v: i32) -> MoveOnly {
     let v: Value<i32> = Rc::new(RefCell::new(v));
     let m: Value<MoveOnly> = Rc::new(RefCell::new(MoveOnly::MoveOnly({ (*v.borrow()) })));
-    return MoveOnly::MoveOnly_pmutMoveOnly({ m.as_pointer() });
+    return MoveOnly::MoveOnly_pmutMoveOnly_rv({ m.as_pointer() });
 }
 pub fn main() {
     __cpp2rust_init_globals();
@@ -101,17 +101,17 @@ pub fn main() {
 }
 fn main_0() -> i32 {
     let a: Value<MoveOnly> = Rc::new(RefCell::new(MoveOnly::MoveOnly({ 1 })));
-    let b: Value<MoveOnly> = Rc::new(RefCell::new(MoveOnly::MoveOnly_pmutMoveOnly({
+    let b: Value<MoveOnly> = Rc::new(RefCell::new(MoveOnly::MoveOnly_pmutMoveOnly_rv({
         a.as_pointer()
     })));
     assert!(((*(*b.borrow()).v.borrow()) == 1));
     assert!(((*(*a.borrow()).v.borrow()) == 0));
-    let c: Value<MoveOnly> = Rc::new(RefCell::new(MoveOnly::MoveOnly_pmutMoveOnly({
+    let c: Value<MoveOnly> = Rc::new(RefCell::new(MoveOnly::MoveOnly_pmutMoveOnly_rv({
         b.as_pointer()
     })));
     assert!(((*(*c.borrow()).v.borrow()) == 1));
     assert!(((*(*b.borrow()).v.borrow()) == 0));
-    let d: Value<MoveOnly> = Rc::new(RefCell::new(MoveOnly::MoveOnly_pmutMoveOnly({
+    let d: Value<MoveOnly> = Rc::new(RefCell::new(MoveOnly::MoveOnly_pmutMoveOnly_rv({
         c.as_pointer()
     })));
     assert!(((*(*d.borrow()).v.borrow()) == 1));
@@ -119,12 +119,12 @@ fn main_0() -> i32 {
     let e: Value<MoveOnly> = Rc::new(RefCell::new(({ make_1(5) })));
     assert!(((*(*e.borrow()).v.borrow()) == 5));
     assert!((({ by_value_0(MoveOnly::MoveOnly({ 6 },),) }) == 6));
-    assert!((({ by_value_0(MoveOnly::MoveOnly_pmutMoveOnly({ e.as_pointer() },),) }) == 5));
+    assert!((({ by_value_0(MoveOnly::MoveOnly_pmutMoveOnly_rv({ e.as_pointer() },),) }) == 5));
     assert!(((*(*e.borrow()).v.borrow()) == 0));
     let vec_: Value<Vec<MoveOnly>> = Rc::new(RefCell::new(Vec::new()));
     (*vec_.borrow_mut()).push(MoveOnly::MoveOnly({ 7 }));
     let f: Value<MoveOnly> = Rc::new(RefCell::new(MoveOnly::MoveOnly({ 8 })));
-    (*vec_.borrow_mut()).push(MoveOnly::MoveOnly_pmutMoveOnly({ f.as_pointer() }));
+    (*vec_.borrow_mut()).push(MoveOnly::MoveOnly_pmutMoveOnly_rv({ f.as_pointer() }));
     assert!(
         ((*(*(vec_.as_pointer() as Ptr<MoveOnly>)
             .offset(0_usize)
@@ -143,11 +143,11 @@ fn main_0() -> i32 {
     );
     assert!(((*(*f.borrow()).v.borrow()) == 0));
     let m: Value<ConstMove> = Rc::new(RefCell::new(ConstMove::ConstMove()));
-    let m1: Value<ConstMove> = Rc::new(RefCell::new(ConstMove::ConstMove_pmutConstMove({
+    let m1: Value<ConstMove> = Rc::new(RefCell::new(ConstMove::ConstMove_pmutConstMove_rv({
         m.as_pointer()
     })));
     let cm: Value<ConstMove> = Rc::new(RefCell::new(ConstMove::ConstMove()));
-    let m2: Value<ConstMove> = Rc::new(RefCell::new(ConstMove::ConstMove_pconstConstMove({
+    let m2: Value<ConstMove> = Rc::new(RefCell::new(ConstMove::ConstMove_pconstConstMove_rv({
         cm.as_pointer()
     })));
     assert!(((*(*m1.borrow()).mark.borrow()) == 1));
diff --git a/tests/unit/out/refcount/move_this.rs b/tests/unit/out/refcount/move_this.rs
index aac859481..3f20e9ec1 100644
--- a/tests/unit/out/refcount/move_this.rs
+++ b/tests/unit/out/refcount/move_this.rs
@@ -26,7 +26,7 @@ impl Chain {
         let this: Ptr<Chain> = __this.as_pointer();
         Rc::try_unwrap(__this).ok().unwrap().into_inner()
     }
-    pub fn Chain_pmutChain(o: Ptr<Chain>) -> Self {
+    pub fn Chain_pmutChain_rv(o: Ptr<Chain>) -> Self {
         let __this: Value<Chain> = Rc::new(RefCell::new(Self {
             v: Rc::new(RefCell::new(((*(*o.upgrade().deref()).v.borrow()) + 1))),
         }));
@@ -67,7 +67,7 @@ fn main_0() -> i32 {
     ({ ChainImpl::add_i32_lref(&({ ChainImpl::add_i32_lref(&a.as_pointer(), 1) }), 1) });
     assert!(((*(*a.borrow()).v.borrow()) == 3));
     let b0: Value<Chain> = Rc::new(RefCell::new(Chain::Chain({ 5 })));
-    let b: Value<Chain> = Rc::new(RefCell::new(Chain::Chain_pmutChain({
+    let b: Value<Chain> = Rc::new(RefCell::new(Chain::Chain_pmutChain_rv({
         ({ ChainImpl::add_i32_rref(&({ ChainImpl::add_i32_rref(&b0.as_pointer(), 1) }), 1) })
     })));
     assert!(((*(*b.borrow()).v.borrow()) == 8) && ((*(*b0.borrow()).v.borrow()) == 0));
@@ -80,7 +80,7 @@ fn main_0() -> i32 {
     let g: Value<Chain> = Rc::new(RefCell::new(Chain::Chain({ 20 })));
     assert!(
         (({
-            consume_0(Chain::Chain_pmutChain({
+            consume_0(Chain::Chain_pmutChain_rv({
                 ({ ChainImpl::self_(&g.as_pointer()) })
             }))
         }) == 21)
@@ -109,7 +109,7 @@ impl ChainImpl for Ptr<Chain> {
         return (*self).clone();
     }
     fn take(&self) -> Chain {
-        return Chain::Chain_pmutChain({ (*self).clone() });
+        return Chain::Chain_pmutChain_rv({ (*self).clone() });
     }
     fn copy(&self) -> Chain {
         return Chain::Chain_pconstChain({ (*self).clone() });
diff --git a/tests/unit/out/refcount/operator_comparison_noncopyable.rs b/tests/unit/out/refcount/operator_comparison_noncopyable.rs
index 2532b1f7f..0907e9761 100644
--- a/tests/unit/out/refcount/operator_comparison_noncopyable.rs
+++ b/tests/unit/out/refcount/operator_comparison_noncopyable.rs
@@ -31,7 +31,7 @@ impl S {
         let this: Ptr<S> = __this.as_pointer();
         Rc::try_unwrap(__this).ok().unwrap().into_inner()
     }
-    pub fn S_pmutS(_a0: Ptr<S>) -> Self {
+    pub fn S_pmutS_rv(_a0: Ptr<S>) -> Self {
         let __this: Value<S> = Rc::new(RefCell::new(Self {
             data_: Rc::new(RefCell::new((*(*_a0.upgrade().deref()).data_.borrow()))),
         }));
diff --git a/tests/unit/out/refcount/overload_mangling.rs b/tests/unit/out/refcount/overload_mangling.rs
index 01647469c..1a27a8fd1 100644
--- a/tests/unit/out/refcount/overload_mangling.rs
+++ b/tests/unit/out/refcount/overload_mangling.rs
@@ -6,6 +6,26 @@ use std::io::prelude::*;
 use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
+pub fn inc_0(p: Ptr<i32>) {
+    let p: Value<Ptr<i32>> = Rc::new(RefCell::new(p));
+    {
+        let _ptr = (*p.borrow()).clone();
+        _ptr.write(_ptr.read() + 1)
+    };
+}
+pub fn add_1(p: Ptr<i32>, n: i32) {
+    let p: Value<Ptr<i32>> = Rc::new(RefCell::new(p));
+    let n: Value<i32> = Rc::new(RefCell::new(n));
+    let __rhs = (*n.borrow());
+    {
+        let _ptr = (*p.borrow()).clone();
+        _ptr.write(_ptr.read() + __rhs)
+    };
+}
+pub fn twice_2(n: i32) -> i32 {
+    let n: Value<i32> = Rc::new(RefCell::new(n));
+    return ((*n.borrow()) * 2);
+}
 #[derive(Default)]
 pub struct S {
     pub base: Value<i32>,
@@ -74,6 +94,63 @@ fn main_0() -> i32 {
     assert!((({ SImpl::count_i32__int_long_const(&s.as_pointer(), 1,) }) == 103));
     assert!((({ SImpl::plain_i32_const(&s.as_pointer(), 1,) }) == 101));
     assert!((({ SImpl::plain_i64_const(&s.as_pointer(), 1_i64,) }) == 102));
+    let y: Value<i32> = Rc::new(RefCell::new(1));
+    assert!((({ SImpl::take_pmuti32_const(&s.as_pointer(), y.as_pointer(),) }) == 102));
+    assert!(
+        (({
+            let _x: Value<i32> = Rc::new(RefCell::new(5));
+            SImpl::take_pmuti32_rv_const(&s.as_pointer(), _x.as_pointer())
+        }) == 107)
+    );
+    assert!(
+        (({
+            SImpl::pick_Valuei32_Valuei32_const(
+                &s.as_pointer(),
+                (
+                    Rc::new(RefCell::new(1.try_into().expect("failed conversion"))),
+                    Rc::new(RefCell::new(2.try_into().expect("failed conversion"))),
+                ),
+            )
+        }) == 101)
+    );
+    assert!(
+        (({
+            SImpl::pick_Valuei32_Valuei64_const(
+                &s.as_pointer(),
+                (
+                    Rc::new(RefCell::new(1.try_into().expect("failed conversion"))),
+                    Rc::new(RefCell::new(2_i64.try_into().expect("failed conversion"))),
+                ),
+            )
+        }) == 102)
+    );
+    assert!(
+        (({
+            SImpl::apply_OptionunsafefnPtri32__i32_const(
+                &s.as_pointer(),
+                FnPtr::<fn(Ptr<i32>)>::new(inc_0),
+                1,
+            )
+        }) == 102)
+    );
+    assert!(
+        (({
+            SImpl::apply_OptionunsafefnPtri32_i32__i32_const(
+                &s.as_pointer(),
+                FnPtr::<fn(Ptr<i32>, i32)>::new(add_1),
+                1,
+            )
+        }) == 111)
+    );
+    assert!(
+        (({
+            SImpl::apply_Optionunsafefni32_i32_i32_const(
+                &s.as_pointer(),
+                FnPtr::<fn(i32) -> i32>::new(twice_2),
+                3,
+            )
+        }) == 106)
+    );
     let b: Value<Box> = Rc::new(RefCell::new(Box {
         v: Rc::new(RefCell::new(4)),
     }));
@@ -83,6 +160,14 @@ fn main_0() -> i32 {
 pub trait SImpl {
     fn plain_i32_const(&self, x: i32) -> i32;
     fn plain_i64_const(&self, x: i64) -> i32;
+    fn take_pmuti32_const(&self, x: Ptr<i32>) -> i32;
+    fn take_pmuti32_rv_const(&self, x: Ptr<i32>) -> i32;
+    fn pick_Valuei32_Valuei32_const(&self, p: (Value<i32>, Value<i32>)) -> i32;
+    fn pick_Valuei32_Valuei64_const(&self, p: (Value<i32>, Value<i64>)) -> i32;
+    fn apply_OptionunsafefnPtri32__i32_const(&self, f: FnPtr<fn(Ptr<i32>)>, x: i32) -> i32;
+    fn apply_OptionunsafefnPtri32_i32__i32_const(&self, f: FnPtr<fn(Ptr<i32>, i32)>, x: i32)
+    -> i32;
+    fn apply_Optionunsafefni32_i32_i32_const(&self, f: FnPtr<fn(i32) -> i32>, x: i32) -> i32;
     fn width_i32__char_const(&self, x: i32) -> i32;
     fn width_i32__int_const(&self, x: i32) -> i32;
     fn scale_i32__2_const(&self, x: i32) -> i32;
@@ -99,6 +184,51 @@ impl SImpl for Ptr<S> {
         let x: Value<i64> = Rc::new(RefCell::new(x));
         return (((*(*(*self).upgrade().deref()).base.borrow()) + ((*x.borrow()) as i32)) + 1);
     }
+    fn take_pmuti32_const(&self, x: Ptr<i32>) -> i32 {
+        return ({
+            let _lhs = (*(*(*self).upgrade().deref()).base.borrow());
+            _lhs + (x.read())
+        } + 1);
+    }
+    fn take_pmuti32_rv_const(&self, x: Ptr<i32>) -> i32 {
+        return ({
+            let _lhs = (*(*(*self).upgrade().deref()).base.borrow());
+            _lhs + (x.read())
+        } + 2);
+    }
+    fn pick_Valuei32_Valuei32_const(&self, p: (Value<i32>, Value<i32>)) -> i32 {
+        let p: Value<(Value<i32>, Value<i32>)> = Rc::new(RefCell::new(p));
+        return ((*(*(*self).upgrade().deref()).base.borrow()) + (*(*p.borrow()).0.borrow()));
+    }
+    fn pick_Valuei32_Valuei64_const(&self, p: (Value<i32>, Value<i64>)) -> i32 {
+        let p: Value<(Value<i32>, Value<i64>)> = Rc::new(RefCell::new(p));
+        return ((*(*(*self).upgrade().deref()).base.borrow())
+            + ((*(*p.borrow()).1.borrow()) as i32));
+    }
+    fn apply_OptionunsafefnPtri32__i32_const(&self, f: FnPtr<fn(Ptr<i32>)>, x: i32) -> i32 {
+        let f: Value<FnPtr<fn(Ptr<i32>)>> = Rc::new(RefCell::new(f));
+        let x: Value<i32> = Rc::new(RefCell::new(x));
+        ({ (*(*f.borrow()))((x.as_pointer())) });
+        return ((*(*(*self).upgrade().deref()).base.borrow()) + (*x.borrow()));
+    }
+    fn apply_OptionunsafefnPtri32_i32__i32_const(
+        &self,
+        f: FnPtr<fn(Ptr<i32>, i32)>,
+        x: i32,
+    ) -> i32 {
+        let f: Value<FnPtr<fn(Ptr<i32>, i32)>> = Rc::new(RefCell::new(f));
+        let x: Value<i32> = Rc::new(RefCell::new(x));
+        ({ (*(*f.borrow()))((x.as_pointer()), 10) });
+        return ((*(*(*self).upgrade().deref()).base.borrow()) + (*x.borrow()));
+    }
+    fn apply_Optionunsafefni32_i32_i32_const(&self, f: FnPtr<fn(i32) -> i32>, x: i32) -> i32 {
+        let f: Value<FnPtr<fn(i32) -> i32>> = Rc::new(RefCell::new(f));
+        let x: Value<i32> = Rc::new(RefCell::new(x));
+        return {
+            let _lhs = (*(*(*self).upgrade().deref()).base.borrow());
+            _lhs + ({ (*(*f.borrow()))((*x.borrow())) })
+        };
+    }
     fn width_i32__char_const(&self, x: i32) -> i32 {
         let x: Value<i32> = Rc::new(RefCell::new(x));
         return ((*(*(*self).upgrade().deref()).base.borrow())
diff --git a/tests/unit/out/refcount/rule_of_five.rs b/tests/unit/out/refcount/rule_of_five.rs
index eae076f69..9c0a87802 100644
--- a/tests/unit/out/refcount/rule_of_five.rs
+++ b/tests/unit/out/refcount/rule_of_five.rs
@@ -61,7 +61,7 @@ impl Buffer {
         (*copies_1.with(Value::clone).borrow_mut()).prefix_inc();
         Rc::try_unwrap(__this).ok().unwrap().into_inner()
     }
-    pub fn Buffer_pmutBuffer(o: Ptr<Buffer>) -> Self {
+    pub fn Buffer_pmutBuffer_rv(o: Ptr<Buffer>) -> Self {
         let __this: Value<Buffer> = Rc::new(RefCell::new(Self {
             data: Rc::new(RefCell::new(
                 (0..4).map(|_| <i32>::default()).collect::<Box<[i32]>>(),
@@ -120,7 +120,7 @@ pub fn make_3(size: i32) -> Buffer {
     let size: Value<i32> = Rc::new(RefCell::new(size));
     let b: Value<Buffer> = Rc::new(RefCell::new(Buffer::Buffer({ (*size.borrow()) })));
     let _dtor_b = ScopedDestructor::new(&b, |__p| __p.destructor());
-    return Buffer::Buffer_pmutBuffer({ b.as_pointer() });
+    return Buffer::Buffer_pmutBuffer_rv({ b.as_pointer() });
 }
 pub fn main() {
     __cpp2rust_init_globals();
@@ -141,7 +141,9 @@ fn main_0() -> i32 {
         );
         (*(*b.borrow()).data.borrow_mut())[(0) as usize] = 100;
         assert!(((*(*a.borrow()).data.borrow())[(0) as usize] == 0));
-        let c: Value<Buffer> = Rc::new(RefCell::new(Buffer::Buffer_pmutBuffer({ a.as_pointer() })));
+        let c: Value<Buffer> = Rc::new(RefCell::new(Buffer::Buffer_pmutBuffer_rv({
+            a.as_pointer()
+        })));
         let _dtor_c = ScopedDestructor::new(&c, |__p| __p.destructor());
         assert!(
             (alive_0.with(|rc| rc.borrow().clone()) == 3)
@@ -166,7 +168,7 @@ fn main_0() -> i32 {
                 && ((*(*d.borrow()).data.borrow())[(0) as usize] == 100))
                 && (copies_1.with(|rc| rc.borrow().clone()) == 2)
         );
-        ({ BufferImpl::operator_assign_pmutBuffer(&d.as_pointer(), c.as_pointer()) });
+        ({ BufferImpl::operator_assign_pmutBuffer_rv(&d.as_pointer(), c.as_pointer()) });
         assert!(
             (((*(*d.borrow()).data.borrow())[(0) as usize] == 0)
                 && ((*(*c.borrow()).size.borrow()) == 0))
@@ -174,7 +176,7 @@ fn main_0() -> i32 {
         );
         ({
             let _o: Ptr<Buffer> = d.as_pointer();
-            BufferImpl::operator_assign_pmutBuffer(&d.as_pointer(), _o)
+            BufferImpl::operator_assign_pmutBuffer_rv(&d.as_pointer(), _o)
         });
         assert!(
             ((*(*d.borrow()).size.borrow()) == 4) && (moves_2.with(|rc| rc.borrow().clone()) == 3)
@@ -186,7 +188,7 @@ fn main_0() -> i32 {
 pub trait BufferImpl {
     fn destructor(&self);
     fn operator_assign_pconstBuffer(&self, o: Ptr<Buffer>) -> Ptr<Buffer>;
-    fn operator_assign_pmutBuffer(&self, o: Ptr<Buffer>) -> Ptr<Buffer>;
+    fn operator_assign_pmutBuffer_rv(&self, o: Ptr<Buffer>) -> Ptr<Buffer>;
 }
 impl BufferImpl for Ptr<Buffer> {
     fn destructor(&self) {
@@ -207,7 +209,7 @@ impl BufferImpl for Ptr<Buffer> {
         (*copies_1.with(Value::clone).borrow_mut()).prefix_inc();
         return (*self).clone();
     }
-    fn operator_assign_pmutBuffer(&self, o: Ptr<Buffer>) -> Ptr<Buffer> {
+    fn operator_assign_pmutBuffer_rv(&self, o: Ptr<Buffer>) -> Ptr<Buffer> {
         if ((*self) == (o)) {
             return (*self).clone();
         }
diff --git a/tests/unit/out/refcount/unique_ptr.rs b/tests/unit/out/refcount/unique_ptr.rs
index fd5adef18..8db13c61c 100644
--- a/tests/unit/out/refcount/unique_ptr.rs
+++ b/tests/unit/out/refcount/unique_ptr.rs
@@ -11,7 +11,7 @@ pub struct SafePointer {
     pub ptr: Value<Option<Value<i32>>>,
 }
 impl SafePointer {
-    pub fn SafePointer_pmutSafePointer(_a0: Ptr<SafePointer>) -> Self {
+    pub fn SafePointer_pmutSafePointer_rv(_a0: Ptr<SafePointer>) -> Self {
         let __this: Value<SafePointer> = Rc::new(RefCell::new(Self {
             ptr: Rc::new(RefCell::new(
                 (*(*_a0.upgrade().deref()).ptr.borrow_mut()).take(),
@@ -317,7 +317,7 @@ impl PairImpl for Ptr<Pair> {
 }
 pub trait SafePointerImpl {
     fn inc(&self);
-    fn operator_assign_pmutSafePointer(&self, _a0: Ptr<SafePointer>) -> Ptr<SafePointer>;
+    fn operator_assign_pmutSafePointer_rv(&self, _a0: Ptr<SafePointer>) -> Ptr<SafePointer>;
 }
 impl SafePointerImpl for Ptr<SafePointer> {
     fn inc(&self) {
@@ -327,7 +327,7 @@ impl SafePointerImpl for Ptr<SafePointer> {
             .borrow_mut())
         .prefix_inc();
     }
-    fn operator_assign_pmutSafePointer(&self, _a0: Ptr<SafePointer>) -> Ptr<SafePointer> {
+    fn operator_assign_pmutSafePointer_rv(&self, _a0: Ptr<SafePointer>) -> Ptr<SafePointer> {
         ((*(*self).upgrade().deref()).ptr.as_pointer() as Ptr<Option<Value<i32>>>)
             .write((*(*_a0.upgrade().deref()).ptr.borrow_mut()).take());
         return (*self).clone();
diff --git a/tests/unit/out/refcount/unique_ptr_const_deref.rs b/tests/unit/out/refcount/unique_ptr_const_deref.rs
index 4f0fa4500..e7bc2bd8e 100644
--- a/tests/unit/out/refcount/unique_ptr_const_deref.rs
+++ b/tests/unit/out/refcount/unique_ptr_const_deref.rs
@@ -11,7 +11,7 @@ pub struct Holder {
     pub val: Value<Option<Value<i32>>>,
 }
 impl Holder {
-    pub fn Holder_pmutHolder(_a0: Ptr<Holder>) -> Self {
+    pub fn Holder_pmutHolder_rv(_a0: Ptr<Holder>) -> Self {
         let __this: Value<Holder> = Rc::new(RefCell::new(Self {
             val: Rc::new(RefCell::new(
                 (*(*_a0.upgrade().deref()).val.borrow_mut()).take(),
@@ -62,10 +62,10 @@ fn main_0() -> i32 {
     return 0;
 }
 pub trait HolderImpl {
-    fn operator_assign_pmutHolder(&self, _a0: Ptr<Holder>) -> Ptr<Holder>;
+    fn operator_assign_pmutHolder_rv(&self, _a0: Ptr<Holder>) -> Ptr<Holder>;
 }
 impl HolderImpl for Ptr<Holder> {
-    fn operator_assign_pmutHolder(&self, _a0: Ptr<Holder>) -> Ptr<Holder> {
+    fn operator_assign_pmutHolder_rv(&self, _a0: Ptr<Holder>) -> Ptr<Holder> {
         ((*(*self).upgrade().deref()).val.as_pointer() as Ptr<Option<Value<i32>>>)
             .write((*(*_a0.upgrade().deref()).val.borrow_mut()).take());
         return (*self).clone();
diff --git a/tests/unit/out/refcount/unique_ptr_nested.rs b/tests/unit/out/refcount/unique_ptr_nested.rs
index 5fbf491d4..bc3173856 100644
--- a/tests/unit/out/refcount/unique_ptr_nested.rs
+++ b/tests/unit/out/refcount/unique_ptr_nested.rs
@@ -41,7 +41,7 @@ pub struct Outer {
     pub inner: Value<Option<Value<Inner>>>,
 }
 impl Outer {
-    pub fn Outer_pmutOuter(_a0: Ptr<Outer>) -> Self {
+    pub fn Outer_pmutOuter_rv(_a0: Ptr<Outer>) -> Self {
         let __this: Value<Outer> = Rc::new(RefCell::new(Self {
             inner: Rc::new(RefCell::new(
                 (*(*_a0.upgrade().deref()).inner.borrow_mut()).take(),
@@ -104,10 +104,10 @@ fn main_0() -> i32 {
     return 0;
 }
 pub trait OuterImpl {
-    fn operator_assign_pmutOuter(&self, _a0: Ptr<Outer>) -> Ptr<Outer>;
+    fn operator_assign_pmutOuter_rv(&self, _a0: Ptr<Outer>) -> Ptr<Outer>;
 }
 impl OuterImpl for Ptr<Outer> {
-    fn operator_assign_pmutOuter(&self, _a0: Ptr<Outer>) -> Ptr<Outer> {
+    fn operator_assign_pmutOuter_rv(&self, _a0: Ptr<Outer>) -> Ptr<Outer> {
         ((*(*self).upgrade().deref()).inner.as_pointer() as Ptr<Option<Value<Inner>>>)
             .write((*(*_a0.upgrade().deref()).inner.borrow_mut()).take());
         return (*self).clone();
diff --git a/tests/unit/out/refcount/void_cast.rs b/tests/unit/out/refcount/void_cast.rs
index 38e0cf36a..0d022b0e0 100644
--- a/tests/unit/out/refcount/void_cast.rs
+++ b/tests/unit/out/refcount/void_cast.rs
@@ -81,7 +81,7 @@ pub struct NonCopyable {
     pub value: Value<Option<Value<i32>>>,
 }
 impl NonCopyable {
-    pub fn NonCopyable_pmutNonCopyable(_a0: Ptr<NonCopyable>) -> Self {
+    pub fn NonCopyable_pmutNonCopyable_rv(_a0: Ptr<NonCopyable>) -> Self {
         let __this: Value<NonCopyable> = Rc::new(RefCell::new(Self {
             value: Rc::new(RefCell::new(
                 (*(*_a0.upgrade().deref()).value.borrow_mut()).take(),
@@ -181,10 +181,10 @@ fn main_0() -> i32 {
     return 0;
 }
 pub trait NonCopyableImpl {
-    fn operator_assign_pmutNonCopyable(&self, _a0: Ptr<NonCopyable>) -> Ptr<NonCopyable>;
+    fn operator_assign_pmutNonCopyable_rv(&self, _a0: Ptr<NonCopyable>) -> Ptr<NonCopyable>;
 }
 impl NonCopyableImpl for Ptr<NonCopyable> {
-    fn operator_assign_pmutNonCopyable(&self, _a0: Ptr<NonCopyable>) -> Ptr<NonCopyable> {
+    fn operator_assign_pmutNonCopyable_rv(&self, _a0: Ptr<NonCopyable>) -> Ptr<NonCopyable> {
         ((*(*self).upgrade().deref()).value.as_pointer() as Ptr<Option<Value<i32>>>)
             .write((*(*_a0.upgrade().deref()).value.borrow_mut()).take());
         return (*self).clone();
diff --git a/tests/unit/out/unsafe/copy_move_defaulted.rs b/tests/unit/out/unsafe/copy_move_defaulted.rs
index b62d9d9b6..65f84dd9f 100644
--- a/tests/unit/out/unsafe/copy_move_defaulted.rs
+++ b/tests/unit/out/unsafe/copy_move_defaulted.rs
@@ -64,12 +64,14 @@ impl DefaultCopyUserMove {
         let mut this = Self { v: v };
         this
     }
-    pub unsafe fn DefaultCopyUserMove_pmutDefaultCopyUserMove(o: *mut DefaultCopyUserMove) -> Self {
+    pub unsafe fn DefaultCopyUserMove_pmutDefaultCopyUserMove_rv(
+        o: *mut DefaultCopyUserMove,
+    ) -> Self {
         let mut this = Self { v: (*o).v };
         (*o).v = 0;
         this
     }
-    pub unsafe fn operator_assign_pmutDefaultCopyUserMove(
+    pub unsafe fn operator_assign_pmutDefaultCopyUserMove_rv(
         &mut self,
         o: *mut DefaultCopyUserMove,
     ) -> *mut DefaultCopyUserMove {
@@ -96,7 +98,7 @@ impl UserCopyDefaultMove {
         };
         this
     }
-    pub unsafe fn UserCopyDefaultMove_pmutUserCopyDefaultMove(
+    pub unsafe fn UserCopyDefaultMove_pmutUserCopyDefaultMove_rv(
         _a0: *mut UserCopyDefaultMove,
     ) -> Self {
         let mut this = Self { v: (*_a0).v };
@@ -109,7 +111,7 @@ impl UserCopyDefaultMove {
         self.v = (((*o).v) + (100));
         return &mut (*(self as *mut UserCopyDefaultMove));
     }
-    pub unsafe fn operator_assign_pmutUserCopyDefaultMove(
+    pub unsafe fn operator_assign_pmutUserCopyDefaultMove_rv(
         &mut self,
         _a0: *mut UserCopyDefaultMove,
     ) -> *mut UserCopyDefaultMove {
@@ -145,7 +147,7 @@ impl Buffer {
         this.rows.push(this.data.clone());
         this
     }
-    pub unsafe fn Buffer_pmutBuffer(_a0: *mut Buffer) -> Self {
+    pub unsafe fn Buffer_pmutBuffer_rv(_a0: *mut Buffer) -> Self {
         let mut this = Self {
             data: std::mem::take(&mut (*_a0).data),
             rows: std::mem::take(&mut (*_a0).rows),
@@ -154,7 +156,7 @@ impl Buffer {
         };
         this
     }
-    pub unsafe fn operator_assign_pmutBuffer(&mut self, _a0: *mut Buffer) -> *mut Buffer {
+    pub unsafe fn operator_assign_pmutBuffer_rv(&mut self, _a0: *mut Buffer) -> *mut Buffer {
         self.data = std::mem::take(&mut (*_a0).data);
         self.rows = std::mem::take(&mut (*_a0).rows);
         self.n = (*_a0).n;
@@ -191,7 +193,7 @@ pub struct Owner {
     pub p: Option<Box<i32>>,
 }
 impl Owner {
-    pub unsafe fn Owner_pmutOwner(_a0: *mut Owner) -> Self {
+    pub unsafe fn Owner_pmutOwner_rv(_a0: *mut Owner) -> Self {
         let mut this = Self {
             data: std::mem::take(&mut (*_a0).data),
             n: (*_a0).n,
@@ -200,7 +202,7 @@ impl Owner {
         };
         this
     }
-    pub unsafe fn operator_assign_pmutOwner(&mut self, _a0: *mut Owner) -> *mut Owner {
+    pub unsafe fn operator_assign_pmutOwner_rv(&mut self, _a0: *mut Owner) -> *mut Owner {
         self.data = std::mem::take(&mut (*_a0).data);
         self.n = (*_a0).n;
         {
@@ -244,7 +246,7 @@ impl Holder {
         };
         this
     }
-    pub unsafe fn Holder_pmutHolder(_a0: *mut Holder) -> Self {
+    pub unsafe fn Holder_pmutHolder_rv(_a0: *mut Holder) -> Self {
         let mut this = Self {
             inner: (*_a0).inner,
             e: (*_a0).e.clone(),
@@ -252,7 +254,7 @@ impl Holder {
         };
         this
     }
-    pub unsafe fn operator_assign_pmutHolder(&mut self, _a0: *mut Holder) -> *mut Holder {
+    pub unsafe fn operator_assign_pmutHolder_rv(&mut self, _a0: *mut Holder) -> *mut Holder {
         self.inner = (*_a0).inner;
         self.e = ((*_a0).e).clone();
         self.p = (*_a0).p.take();
@@ -328,32 +330,32 @@ unsafe fn main_0() -> i32 {
     let mut m: DefaultCopyUserMove = DefaultCopyUserMove::DefaultCopyUserMove({ 7 });
     let mut m1: DefaultCopyUserMove = m;
     let mut m2: DefaultCopyUserMove =
-        DefaultCopyUserMove::DefaultCopyUserMove_pmutDefaultCopyUserMove({ &mut m });
+        DefaultCopyUserMove::DefaultCopyUserMove_pmutDefaultCopyUserMove_rv({ &mut m });
     assert!((((m1.v) == (7)) && ((m2.v) == (7))) && ((m.v) == (0)));
     let mut m3: DefaultCopyUserMove = DefaultCopyUserMove::DefaultCopyUserMove({ 1 });
     let mut m4: DefaultCopyUserMove = DefaultCopyUserMove::DefaultCopyUserMove({ 1 });
     m3 = m1;
-    (unsafe { DefaultCopyUserMove::operator_assign_pmutDefaultCopyUserMove(&mut m4, &mut m1) });
+    (unsafe { DefaultCopyUserMove::operator_assign_pmutDefaultCopyUserMove_rv(&mut m4, &mut m1) });
     assert!((((m3.v) == (7)) && ((m4.v) == (7))) && ((m1.v) == (0)));
     let mut u: UserCopyDefaultMove = UserCopyDefaultMove::UserCopyDefaultMove({ 8 });
     let mut u1: UserCopyDefaultMove =
         UserCopyDefaultMove::UserCopyDefaultMove_pconstUserCopyDefaultMove({ &u });
     let mut u2: UserCopyDefaultMove =
-        UserCopyDefaultMove::UserCopyDefaultMove_pmutUserCopyDefaultMove({ &mut u });
+        UserCopyDefaultMove::UserCopyDefaultMove_pmutUserCopyDefaultMove_rv({ &mut u });
     assert!((((u1.v) == (108)) && ((u2.v) == (8))) && ((u.v) == (8)));
     let mut u3: UserCopyDefaultMove = UserCopyDefaultMove::UserCopyDefaultMove({ 1 });
     let mut u4: UserCopyDefaultMove = UserCopyDefaultMove::UserCopyDefaultMove({ 1 });
     (unsafe { UserCopyDefaultMove::operator_assign_pconstUserCopyDefaultMove(&mut u3, &u2) });
-    (unsafe { UserCopyDefaultMove::operator_assign_pmutUserCopyDefaultMove(&mut u4, &mut u2) });
+    (unsafe { UserCopyDefaultMove::operator_assign_pmutUserCopyDefaultMove_rv(&mut u4, &mut u2) });
     assert!(((u3.v) == (108)) && ((u4.v) == (8)));
     let mut p: Buffer = Buffer::Buffer({ 3 });
-    let mut q: Buffer = Buffer::Buffer_pmutBuffer({ &mut p });
+    let mut q: Buffer = Buffer::Buffer_pmutBuffer_rv({ &mut p });
     assert!(
         ((((q.n) == (3)) && ((q.data.len()) == (3_usize))) && ((q.data[(2_usize)]) == (3)))
             && (p.data.is_empty())
     );
     let mut r: Buffer = Buffer::Buffer({ 1 });
-    (unsafe { Buffer::operator_assign_pmutBuffer(&mut r, &mut q) });
+    (unsafe { Buffer::operator_assign_pmutBuffer_rv(&mut r, &mut q) });
     assert!(
         ((((r.n) == (3)) && ((r.data.len()) == (3_usize))) && ((r.arr[(1) as usize]) == (4)))
             && (q.data.is_empty())
@@ -363,9 +365,9 @@ unsafe fn main_0() -> i32 {
             && (q.rows.is_empty())
     );
     let mut bufs: Vec<Buffer> = Vec::new();
-    bufs.push(Buffer::Buffer_pmutBuffer({ &mut r }));
+    bufs.push(Buffer::Buffer_pmutBuffer_rv({ &mut r }));
     {
-        let __arg = Buffer::Buffer_pmutBuffer({ &mut bufs[(0_usize)] });
+        let __arg = Buffer::Buffer_pmutBuffer_rv({ &mut bufs[(0_usize)] });
         bufs.push(__arg)
     };
     assert!(
@@ -385,7 +387,7 @@ unsafe fn main_0() -> i32 {
             Some(Box::from_raw(_a0))
         }
     };
-    let mut o2: Owner = Owner::Owner_pmutOwner({ &mut o1 });
+    let mut o2: Owner = Owner::Owner_pmutOwner_rv({ &mut o1 });
     assert!(
         ((((o2.n) == (5)) && ((o2.data.len()) == (1_usize))) && ((o2.arr[(1) as usize]) == (6)))
             && ((*o2.p.as_deref_mut().unwrap()) == (7))
@@ -399,7 +401,7 @@ unsafe fn main_0() -> i32 {
             .is_null())
     );
     let mut o3: Owner = <Owner>::default();
-    (unsafe { Owner::operator_assign_pmutOwner(&mut o3, &mut o2) });
+    (unsafe { Owner::operator_assign_pmutOwner_rv(&mut o3, &mut o2) });
     assert!(
         ((((o3.n) == (5)) && ((o3.data[(0_usize)]) == (5))) && ((o3.arr[(0) as usize]) == (5)))
             && ((*o3.p.as_deref_mut().unwrap()) == (7))
@@ -422,7 +424,7 @@ unsafe fn main_0() -> i32 {
             Some(Box::from_raw(_a0))
         }
     };
-    let mut h2: Holder = Holder::Holder_pmutHolder({ &mut h1 });
+    let mut h2: Holder = Holder::Holder_pmutHolder_rv({ &mut h1 });
     let _dtor_h2 = ScopedDestructorUnsafe::new(&raw mut h2, Holder::destructor);
     assert!(
         ((((h2.inner.x) == (4)) && ((h2.e.v) == (4))) && ((*h2.p.as_deref_mut().unwrap()) == (9)))
@@ -434,7 +436,7 @@ unsafe fn main_0() -> i32 {
     );
     let mut h3: Holder = Holder::Holder({ 1 });
     let _dtor_h3 = ScopedDestructorUnsafe::new(&raw mut h3, Holder::destructor);
-    (unsafe { Holder::operator_assign_pmutHolder(&mut h3, &mut h2) });
+    (unsafe { Holder::operator_assign_pmutHolder_rv(&mut h3, &mut h2) });
     assert!(
         ((((h3.inner.x) == (4)) && ((h3.e.arr[(1) as usize]) == (5)))
             && ((*h3.p.as_deref_mut().unwrap()) == (9)))
diff --git a/tests/unit/out/unsafe/copy_move_deleted.rs b/tests/unit/out/unsafe/copy_move_deleted.rs
index 2e7fb4ea3..544e0f486 100644
--- a/tests/unit/out/unsafe/copy_move_deleted.rs
+++ b/tests/unit/out/unsafe/copy_move_deleted.rs
@@ -16,12 +16,12 @@ impl NoCopy {
         let mut this = Self { v: v };
         this
     }
-    pub unsafe fn NoCopy_pmutNoCopy(o: *mut NoCopy) -> Self {
+    pub unsafe fn NoCopy_pmutNoCopy_rv(o: *mut NoCopy) -> Self {
         let mut this = Self { v: (*o).v };
         (*o).v = 0;
         this
     }
-    pub unsafe fn operator_assign_pmutNoCopy(&mut self, o: *mut NoCopy) -> *mut NoCopy {
+    pub unsafe fn operator_assign_pmutNoCopy_rv(&mut self, o: *mut NoCopy) -> *mut NoCopy {
         self.v = (*o).v;
         (*o).v = 0;
         return &mut (*(self as *mut NoCopy));
@@ -37,12 +37,12 @@ impl PrivateCopy {
         let mut this = Self { v: 0 };
         this
     }
-    pub unsafe fn PrivateCopy_pmutPrivateCopy(o: *mut PrivateCopy) -> Self {
+    pub unsafe fn PrivateCopy_pmutPrivateCopy_rv(o: *mut PrivateCopy) -> Self {
         let mut this = Self { v: (*o).v };
         (*o).v = 0;
         this
     }
-    pub unsafe fn operator_assign_pmutPrivateCopy(
+    pub unsafe fn operator_assign_pmutPrivateCopy_rv(
         &mut self,
         o: *mut PrivateCopy,
     ) -> *mut PrivateCopy {
@@ -79,17 +79,20 @@ pub struct Container {
     pub tag: i32,
 }
 impl Container {
-    pub unsafe fn Container_pmutContainer(_a0: *mut Container) -> Self {
+    pub unsafe fn Container_pmutContainer_rv(_a0: *mut Container) -> Self {
         let mut this = Self {
-            inner: NoCopy::NoCopy_pmutNoCopy({ &mut (*_a0).inner }),
+            inner: NoCopy::NoCopy_pmutNoCopy_rv({ &mut (*_a0).inner }),
             tag: (*_a0).tag,
         };
         this
     }
-    pub unsafe fn operator_assign_pmutContainer(&mut self, _a0: *mut Container) -> *mut Container {
+    pub unsafe fn operator_assign_pmutContainer_rv(
+        &mut self,
+        _a0: *mut Container,
+    ) -> *mut Container {
         (unsafe {
             let _o: *mut NoCopy = &mut (*_a0).inner;
-            NoCopy::operator_assign_pmutNoCopy(&mut self.inner, _o)
+            NoCopy::operator_assign_pmutNoCopy_rv(&mut self.inner, _o)
         });
         self.tag = (*_a0).tag;
         return &mut (*(self as *mut Container));
@@ -109,17 +112,17 @@ pub fn main() {
 }
 unsafe fn main_0() -> i32 {
     let mut a: NoCopy = NoCopy::NoCopy({ 1 });
-    let mut b: NoCopy = NoCopy::NoCopy_pmutNoCopy({ &mut a });
+    let mut b: NoCopy = NoCopy::NoCopy_pmutNoCopy_rv({ &mut a });
     assert!(((b.v) == (1)) && ((a.v) == (0)));
-    (unsafe { NoCopy::operator_assign_pmutNoCopy(&mut a, &mut b) });
+    (unsafe { NoCopy::operator_assign_pmutNoCopy_rv(&mut a, &mut b) });
     assert!(((a.v) == (1)) && ((b.v) == (0)));
     (unsafe { bump_0((&mut a as *mut NoCopy)) });
     assert!(((a.v) == (2)));
     let mut p: PrivateCopy = PrivateCopy::PrivateCopy();
     p.v = 3;
-    let mut q: PrivateCopy = PrivateCopy::PrivateCopy_pmutPrivateCopy({ &mut p });
+    let mut q: PrivateCopy = PrivateCopy::PrivateCopy_pmutPrivateCopy_rv({ &mut p });
     assert!(((q.v) == (3)) && ((p.v) == (0)));
-    (unsafe { PrivateCopy::operator_assign_pmutPrivateCopy(&mut p, &mut q) });
+    (unsafe { PrivateCopy::operator_assign_pmutPrivateCopy_rv(&mut p, &mut q) });
     assert!(((p.v) == (3)) && ((q.v) == (0)));
     let mut im: Immovable = Immovable::Immovable();
     im.v = 4;
@@ -130,7 +133,7 @@ unsafe fn main_0() -> i32 {
         inner: NoCopy::NoCopy({ 6 }),
         tag: 7,
     };
-    let mut d: Container = Container::Container_pmutContainer({ &mut c });
+    let mut d: Container = Container::Container_pmutContainer_rv({ &mut c });
     assert!((((d.inner.v) == (6)) && ((d.tag) == (7))) && ((c.inner.v) == (0)));
     return 0;
 }
diff --git a/tests/unit/out/unsafe/huffman.rs b/tests/unit/out/unsafe/huffman.rs
index 1434fbba3..30f48541b 100644
--- a/tests/unit/out/unsafe/huffman.rs
+++ b/tests/unit/out/unsafe/huffman.rs
@@ -125,7 +125,7 @@ impl MinHeap {
             i.prefix_dec();
         }
     }
-    pub unsafe fn MinHeap_pmutMinHeap(_a0: *mut MinHeap) -> Self {
+    pub unsafe fn MinHeap_pmutMinHeap_rv(_a0: *mut MinHeap) -> Self {
         let mut this = Self {
             size: (*_a0).size,
             capacity: (*_a0).capacity,
@@ -135,7 +135,7 @@ impl MinHeap {
         };
         this
     }
-    pub unsafe fn operator_assign_pmutMinHeap(&mut self, _a0: *mut MinHeap) -> *mut MinHeap {
+    pub unsafe fn operator_assign_pmutMinHeap_rv(&mut self, _a0: *mut MinHeap) -> *mut MinHeap {
         self.size = (*_a0).size;
         self.capacity = (*_a0).capacity;
         self.arr = (*_a0).arr.take();
diff --git a/tests/unit/out/unsafe/kruskal.rs b/tests/unit/out/unsafe/kruskal.rs
index b80f28003..a3bd414b3 100644
--- a/tests/unit/out/unsafe/kruskal.rs
+++ b/tests/unit/out/unsafe/kruskal.rs
@@ -138,7 +138,7 @@ impl DisjointSet {
                 ((self.rank.as_mut().unwrap()[(xset as usize)]) + (1));
         }
     }
-    pub unsafe fn DisjointSet_pmutDisjointSet(_a0: *mut DisjointSet) -> Self {
+    pub unsafe fn DisjointSet_pmutDisjointSet_rv(_a0: *mut DisjointSet) -> Self {
         let mut this = Self {
             rank: (*_a0).rank.take(),
             parent: (*_a0).parent.take(),
@@ -146,7 +146,7 @@ impl DisjointSet {
         };
         this
     }
-    pub unsafe fn operator_assign_pmutDisjointSet(
+    pub unsafe fn operator_assign_pmutDisjointSet_rv(
         &mut self,
         _a0: *mut DisjointSet,
     ) -> *mut DisjointSet {
@@ -164,7 +164,7 @@ pub struct Graph {
     pub E: i32,
 }
 impl Graph {
-    pub unsafe fn Graph_pmutGraph(_a0: *mut Graph) -> Self {
+    pub unsafe fn Graph_pmutGraph_rv(_a0: *mut Graph) -> Self {
         let mut this = Self {
             edges: (*_a0).edges.take(),
             V: (*_a0).V,
@@ -172,7 +172,7 @@ impl Graph {
         };
         this
     }
-    pub unsafe fn operator_assign_pmutGraph(&mut self, _a0: *mut Graph) -> *mut Graph {
+    pub unsafe fn operator_assign_pmutGraph_rv(&mut self, _a0: *mut Graph) -> *mut Graph {
         self.edges = (*_a0).edges.take();
         self.V = (*_a0).V;
         self.E = (*_a0).E;
diff --git a/tests/unit/out/unsafe/move_assign.rs b/tests/unit/out/unsafe/move_assign.rs
index 60044027b..55a525258 100644
--- a/tests/unit/out/unsafe/move_assign.rs
+++ b/tests/unit/out/unsafe/move_assign.rs
@@ -16,12 +16,12 @@ impl MoveOnly {
         let mut this = Self { v: v };
         this
     }
-    pub unsafe fn MoveOnly_pmutMoveOnly(o: *mut MoveOnly) -> Self {
+    pub unsafe fn MoveOnly_pmutMoveOnly_rv(o: *mut MoveOnly) -> Self {
         let mut this = Self { v: (*o).v };
         (*o).v = 0;
         this
     }
-    pub unsafe fn operator_assign_pmutMoveOnly(&mut self, o: *mut MoveOnly) -> *mut MoveOnly {
+    pub unsafe fn operator_assign_pmutMoveOnly_rv(&mut self, o: *mut MoveOnly) -> *mut MoveOnly {
         if ((self as *mut MoveOnly) == (o)) {
             return &mut (*(self as *mut MoveOnly));
         }
@@ -40,14 +40,14 @@ impl ConstMoveAssign {
         let mut this = Self { mark: 0 };
         this
     }
-    pub unsafe fn operator_assign_pmutConstMoveAssign(
+    pub unsafe fn operator_assign_pmutConstMoveAssign_rv(
         &mut self,
         o: *mut ConstMoveAssign,
     ) -> *mut ConstMoveAssign {
         self.mark = (((*o).mark) + (1));
         return &mut (*(self as *mut ConstMoveAssign));
     }
-    pub unsafe fn operator_assign_pconstConstMoveAssign(
+    pub unsafe fn operator_assign_pconstConstMoveAssign_rv(
         &mut self,
         o: *const ConstMoveAssign,
     ) -> *mut ConstMoveAssign {
@@ -62,7 +62,7 @@ impl Default for ConstMoveAssign {
 }
 pub unsafe fn make_0(mut v: i32) -> MoveOnly {
     let mut m: MoveOnly = MoveOnly::MoveOnly({ v });
-    return MoveOnly::MoveOnly_pmutMoveOnly({ &mut m });
+    return MoveOnly::MoveOnly_pmutMoveOnly_rv({ &mut m });
 }
 pub fn main() {
     unsafe {
@@ -74,47 +74,47 @@ unsafe fn main_0() -> i32 {
     let mut a: MoveOnly = MoveOnly::MoveOnly({ 1 });
     let mut b: MoveOnly = MoveOnly::MoveOnly({ 2 });
     let mut c: MoveOnly = MoveOnly::MoveOnly({ 3 });
-    (unsafe { MoveOnly::operator_assign_pmutMoveOnly(&mut a, &mut b) });
+    (unsafe { MoveOnly::operator_assign_pmutMoveOnly_rv(&mut a, &mut b) });
     assert!(((a.v) == (2)));
     assert!(((b.v) == (0)));
     (unsafe {
         let mut _o: MoveOnly = MoveOnly::MoveOnly({ 3 });
-        MoveOnly::operator_assign_pmutMoveOnly(&mut b, &mut _o)
+        MoveOnly::operator_assign_pmutMoveOnly_rv(&mut b, &mut _o)
     });
     (unsafe {
-        MoveOnly::operator_assign_pmutMoveOnly(
+        MoveOnly::operator_assign_pmutMoveOnly_rv(
             &mut c,
-            &mut (*(unsafe { MoveOnly::operator_assign_pmutMoveOnly(&mut a, &mut b) })),
+            &mut (*(unsafe { MoveOnly::operator_assign_pmutMoveOnly_rv(&mut a, &mut b) })),
         )
     });
     assert!((((b.v) == (0)) && ((a.v) == (0))) && ((c.v) == (3)));
     (unsafe {
         let mut _o: MoveOnly = MoveOnly::MoveOnly({ 5 });
-        MoveOnly::operator_assign_pmutMoveOnly(&mut a, &mut _o)
+        MoveOnly::operator_assign_pmutMoveOnly_rv(&mut a, &mut _o)
     });
     assert!(((a.v) == (5)));
     (unsafe {
         let mut _o: MoveOnly = (unsafe { make_0(6) });
-        MoveOnly::operator_assign_pmutMoveOnly(&mut a, &mut _o)
+        MoveOnly::operator_assign_pmutMoveOnly_rv(&mut a, &mut _o)
     });
     assert!(((a.v) == (6)));
     (unsafe {
         let _o: *mut MoveOnly = &mut a;
-        MoveOnly::operator_assign_pmutMoveOnly(&mut a, _o)
+        MoveOnly::operator_assign_pmutMoveOnly_rv(&mut a, _o)
     });
     assert!(((a.v) == (6)));
     let mut vec_: Vec<MoveOnly> = Vec::new();
     vec_.push(MoveOnly::MoveOnly({ 7 }));
     let mut d: MoveOnly = MoveOnly::MoveOnly({ 8 });
-    (unsafe { MoveOnly::operator_assign_pmutMoveOnly(&mut vec_[(0_usize)], &mut d) });
+    (unsafe { MoveOnly::operator_assign_pmutMoveOnly_rv(&mut vec_[(0_usize)], &mut d) });
     assert!(((vec_[(0_usize)].v) == (8)));
     assert!(((d.v) == (0)));
     let mut m: ConstMoveAssign = ConstMoveAssign::ConstMoveAssign();
     let mut m1: ConstMoveAssign = ConstMoveAssign::ConstMoveAssign();
     let mut m2: ConstMoveAssign = ConstMoveAssign::ConstMoveAssign();
     let cm: ConstMoveAssign = ConstMoveAssign::ConstMoveAssign();
-    (unsafe { ConstMoveAssign::operator_assign_pmutConstMoveAssign(&mut m1, &mut m) });
-    (unsafe { ConstMoveAssign::operator_assign_pconstConstMoveAssign(&mut m2, &cm) });
+    (unsafe { ConstMoveAssign::operator_assign_pmutConstMoveAssign_rv(&mut m1, &mut m) });
+    (unsafe { ConstMoveAssign::operator_assign_pconstConstMoveAssign_rv(&mut m2, &cm) });
     assert!(((m1.mark) == (1)));
     assert!(((m2.mark) == (10)));
     return 0;
diff --git a/tests/unit/out/unsafe/move_ctor.rs b/tests/unit/out/unsafe/move_ctor.rs
index 719ef9304..4eaa7e22e 100644
--- a/tests/unit/out/unsafe/move_ctor.rs
+++ b/tests/unit/out/unsafe/move_ctor.rs
@@ -16,7 +16,7 @@ impl MoveOnly {
         let mut this = Self { v: v };
         this
     }
-    pub unsafe fn MoveOnly_pmutMoveOnly(o: *mut MoveOnly) -> Self {
+    pub unsafe fn MoveOnly_pmutMoveOnly_rv(o: *mut MoveOnly) -> Self {
         let mut this = Self { v: (*o).v };
         (*o).v = 0;
         this
@@ -32,13 +32,13 @@ impl ConstMove {
         let mut this = Self { mark: 0 };
         this
     }
-    pub unsafe fn ConstMove_pmutConstMove(o: *mut ConstMove) -> Self {
+    pub unsafe fn ConstMove_pmutConstMove_rv(o: *mut ConstMove) -> Self {
         let mut this = Self {
             mark: (((*o).mark) + (1)),
         };
         this
     }
-    pub unsafe fn ConstMove_pconstConstMove(o: *const ConstMove) -> Self {
+    pub unsafe fn ConstMove_pconstConstMove_rv(o: *const ConstMove) -> Self {
         let mut this = Self {
             mark: (((*o).mark) + (10)),
         };
@@ -55,7 +55,7 @@ pub unsafe fn by_value_0(mut m: MoveOnly) -> i32 {
 }
 pub unsafe fn make_1(mut v: i32) -> MoveOnly {
     let mut m: MoveOnly = MoveOnly::MoveOnly({ v });
-    return MoveOnly::MoveOnly_pmutMoveOnly({ &mut m });
+    return MoveOnly::MoveOnly_pmutMoveOnly_rv({ &mut m });
 }
 pub fn main() {
     unsafe {
@@ -65,30 +65,30 @@ pub fn main() {
 }
 unsafe fn main_0() -> i32 {
     let mut a: MoveOnly = MoveOnly::MoveOnly({ 1 });
-    let mut b: MoveOnly = MoveOnly::MoveOnly_pmutMoveOnly({ &mut a });
+    let mut b: MoveOnly = MoveOnly::MoveOnly_pmutMoveOnly_rv({ &mut a });
     assert!(((b.v) == (1)));
     assert!(((a.v) == (0)));
-    let mut c: MoveOnly = MoveOnly::MoveOnly_pmutMoveOnly({ &mut b });
+    let mut c: MoveOnly = MoveOnly::MoveOnly_pmutMoveOnly_rv({ &mut b });
     assert!(((c.v) == (1)));
     assert!(((b.v) == (0)));
-    let mut d: MoveOnly = MoveOnly::MoveOnly_pmutMoveOnly({ &mut c });
+    let mut d: MoveOnly = MoveOnly::MoveOnly_pmutMoveOnly_rv({ &mut c });
     assert!(((d.v) == (1)));
     assert!(((c.v) == (0)));
     let mut e: MoveOnly = (unsafe { make_1(5) });
     assert!(((e.v) == (5)));
     assert!(((unsafe { by_value_0(MoveOnly::MoveOnly({ 6 },),) }) == (6)));
-    assert!(((unsafe { by_value_0(MoveOnly::MoveOnly_pmutMoveOnly({ &mut e },),) }) == (5)));
+    assert!(((unsafe { by_value_0(MoveOnly::MoveOnly_pmutMoveOnly_rv({ &mut e },),) }) == (5)));
     assert!(((e.v) == (0)));
     let mut vec_: Vec<MoveOnly> = Vec::new();
     vec_.push(MoveOnly::MoveOnly({ 7 }));
     let mut f: MoveOnly = MoveOnly::MoveOnly({ 8 });
-    vec_.push(MoveOnly::MoveOnly_pmutMoveOnly({ &mut f }));
+    vec_.push(MoveOnly::MoveOnly_pmutMoveOnly_rv({ &mut f }));
     assert!(((vec_[(0_usize)].v) == (7)) && ((vec_[(1_usize)].v) == (8)));
     assert!(((f.v) == (0)));
     let mut m: ConstMove = ConstMove::ConstMove();
-    let mut m1: ConstMove = ConstMove::ConstMove_pmutConstMove({ &mut m });
+    let mut m1: ConstMove = ConstMove::ConstMove_pmutConstMove_rv({ &mut m });
     let cm: ConstMove = ConstMove::ConstMove();
-    let mut m2: ConstMove = ConstMove::ConstMove_pconstConstMove({ &cm });
+    let mut m2: ConstMove = ConstMove::ConstMove_pconstConstMove_rv({ &cm });
     assert!(((m1.mark) == (1)));
     assert!(((m2.mark) == (10)));
     return 0;
diff --git a/tests/unit/out/unsafe/move_this.rs b/tests/unit/out/unsafe/move_this.rs
index df9a774e1..ef67c032e 100644
--- a/tests/unit/out/unsafe/move_this.rs
+++ b/tests/unit/out/unsafe/move_this.rs
@@ -22,7 +22,7 @@ impl Chain {
         };
         this
     }
-    pub unsafe fn Chain_pmutChain(o: *mut Chain) -> Self {
+    pub unsafe fn Chain_pmutChain_rv(o: *mut Chain) -> Self {
         let mut this = Self {
             v: (((*o).v) + (1)),
         };
@@ -38,7 +38,7 @@ impl Chain {
         return &mut (*(self as *mut Chain));
     }
     pub unsafe fn take(&mut self) -> Chain {
-        return Chain::Chain_pmutChain({ &mut (*(self as *mut Chain)) });
+        return Chain::Chain_pmutChain_rv({ &mut (*(self as *mut Chain)) });
     }
     pub unsafe fn copy(&self) -> Chain {
         return Chain::Chain_pconstChain({ &(*(self as *const Chain)) });
@@ -66,7 +66,7 @@ unsafe fn main_0() -> i32 {
     (unsafe { Chain::add_i32_lref(&mut (*(unsafe { Chain::add_i32_lref(&mut a, 1) })), 1) });
     assert!(((a.v) == (3)));
     let mut b0: Chain = Chain::Chain({ 5 });
-    let mut b: Chain = Chain::Chain_pmutChain({
+    let mut b: Chain = Chain::Chain_pmutChain_rv({
         (unsafe { Chain::add_i32_rref(&mut (*(unsafe { Chain::add_i32_rref(&mut b0, 1) })), 1) })
     });
     assert!(((b.v) == (8)) && ((b0.v) == (0)));
@@ -77,7 +77,7 @@ unsafe fn main_0() -> i32 {
     let mut g: Chain = Chain::Chain({ 20 });
     assert!(
         ((unsafe {
-            consume_0(Chain::Chain_pmutChain({
+            consume_0(Chain::Chain_pmutChain_rv({
                 (unsafe { Chain::self_(&mut g) })
             }))
         }) == (21))
diff --git a/tests/unit/out/unsafe/operator_comparison_noncopyable.rs b/tests/unit/out/unsafe/operator_comparison_noncopyable.rs
index 05de5eb85..d2e847700 100644
--- a/tests/unit/out/unsafe/operator_comparison_noncopyable.rs
+++ b/tests/unit/out/unsafe/operator_comparison_noncopyable.rs
@@ -22,7 +22,7 @@ impl S {
         let mut this = Self { data_: data };
         this
     }
-    pub unsafe fn S_pmutS(_a0: *mut S) -> Self {
+    pub unsafe fn S_pmutS_rv(_a0: *mut S) -> Self {
         let mut this = Self {
             data_: (*_a0).data_,
         };
diff --git a/tests/unit/out/unsafe/overload_mangling.rs b/tests/unit/out/unsafe/overload_mangling.rs
index 86108ba01..a93a3b63d 100644
--- a/tests/unit/out/unsafe/overload_mangling.rs
+++ b/tests/unit/out/unsafe/overload_mangling.rs
@@ -6,6 +6,15 @@ use std::collections::BTreeMap;
 use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
+pub unsafe fn inc_0(mut p: *mut i32) {
+    (*p) += 1;
+}
+pub unsafe fn add_1(mut p: *mut i32, mut n: i32) {
+    (*p) += n;
+}
+pub unsafe fn twice_2(mut n: i32) -> i32 {
+    return ((n) * (2));
+}
 #[repr(C)]
 #[derive(Copy, Clone, Default)]
 pub struct S {
@@ -18,6 +27,41 @@ impl S {
     pub unsafe fn plain_i64_const(&self, mut x: i64) -> i32 {
         return (((self.base) + (x as i32)) + (1));
     }
+    pub unsafe fn take_pmuti32_const(&self, x: *mut i32) -> i32 {
+        return (((self.base) + (*x)) + (1));
+    }
+    pub unsafe fn take_pmuti32_rv_const(&self, x: *mut i32) -> i32 {
+        return (((self.base) + (*x)) + (2));
+    }
+    pub unsafe fn pick_i32_i32_const(&self, mut p: (i32, i32)) -> i32 {
+        return ((self.base) + (p.0));
+    }
+    pub unsafe fn pick_i32_i64_const(&self, mut p: (i32, i64)) -> i32 {
+        return ((self.base) + (p.1 as i32));
+    }
+    pub unsafe fn apply_Optionunsafefnpmuti32__i32_const(
+        &self,
+        mut f: Option<unsafe fn(*mut i32)>,
+        mut x: i32,
+    ) -> i32 {
+        (unsafe { (f).unwrap()((&mut x as *mut i32)) });
+        return ((self.base) + (x));
+    }
+    pub unsafe fn apply_Optionunsafefnpmuti32_i32__i32_const(
+        &self,
+        mut f: Option<unsafe fn(*mut i32, i32)>,
+        mut x: i32,
+    ) -> i32 {
+        (unsafe { (f).unwrap()((&mut x as *mut i32), 10) });
+        return ((self.base) + (x));
+    }
+    pub unsafe fn apply_Optionunsafefni32_i32_i32_const(
+        &self,
+        mut f: Option<unsafe fn(i32) -> i32>,
+        mut x: i32,
+    ) -> i32 {
+        return ((self.base) + (unsafe { (f).unwrap()(x) }));
+    }
     pub unsafe fn width_i32__char_const(&self, mut x: i32) -> i32 {
         return ((self.base) + ((x) * (::std::mem::size_of::<libc::c_char>() as i32)));
     }
@@ -58,6 +102,23 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { S::count_i32__int_long_const(&s, 1,) }) == (103)));
     assert!(((unsafe { S::plain_i32_const(&s, 1,) }) == (101)));
     assert!(((unsafe { S::plain_i64_const(&s, 1_i64,) }) == (102)));
+    let mut y: i32 = 1;
+    assert!(((unsafe { S::take_pmuti32_const(&s, &mut y,) }) == (102)));
+    assert!(
+        ((unsafe {
+            let mut _x: i32 = 5;
+            S::take_pmuti32_rv_const(&s, &mut _x)
+        }) == (107))
+    );
+    assert!(((unsafe { S::pick_i32_i32_const(&s, (1.into(), 2.into()),) }) == (101)));
+    assert!(((unsafe { S::pick_i32_i64_const(&s, (1.into(), 2_i64.into()),) }) == (102)));
+    assert!(((unsafe { S::apply_Optionunsafefnpmuti32__i32_const(&s, Some(inc_0), 1,) }) == (102)));
+    assert!(
+        ((unsafe { S::apply_Optionunsafefnpmuti32_i32__i32_const(&s, Some(add_1), 1,) }) == (111))
+    );
+    assert!(
+        ((unsafe { S::apply_Optionunsafefni32_i32_i32_const(&s, Some(twice_2), 3,) }) == (106))
+    );
     let mut b: Box = Box { v: 4 };
     assert!(((b.v) == (4)));
     return 0;
diff --git a/tests/unit/out/unsafe/rule_of_five.rs b/tests/unit/out/unsafe/rule_of_five.rs
index 353246c33..105bd2852 100644
--- a/tests/unit/out/unsafe/rule_of_five.rs
+++ b/tests/unit/out/unsafe/rule_of_five.rs
@@ -46,7 +46,7 @@ impl Buffer {
         (*std::cell::LazyCell::force_mut(&mut *&raw mut copies_1)).prefix_inc();
         this
     }
-    pub unsafe fn Buffer_pmutBuffer(o: *mut Buffer) -> Self {
+    pub unsafe fn Buffer_pmutBuffer_rv(o: *mut Buffer) -> Self {
         let mut this = Self {
             data: [0_i32; 4],
             size: (*o).size,
@@ -75,7 +75,7 @@ impl Buffer {
         (*std::cell::LazyCell::force_mut(&mut *&raw mut copies_1)).prefix_inc();
         return &mut (*(self as *mut Buffer));
     }
-    pub unsafe fn operator_assign_pmutBuffer(&mut self, o: *mut Buffer) -> *mut Buffer {
+    pub unsafe fn operator_assign_pmutBuffer_rv(&mut self, o: *mut Buffer) -> *mut Buffer {
         if ((self as *mut Buffer) == (o)) {
             return &mut (*(self as *mut Buffer));
         }
@@ -107,7 +107,7 @@ impl Default for Buffer {
 pub unsafe fn make_3(mut size: i32) -> Buffer {
     let mut b: Buffer = Buffer::Buffer({ size });
     let _dtor_b = ScopedDestructorUnsafe::new(&raw mut b, Buffer::destructor);
-    return Buffer::Buffer_pmutBuffer({ &mut b });
+    return Buffer::Buffer_pmutBuffer_rv({ &mut b });
 }
 pub fn main() {
     unsafe {
@@ -128,7 +128,7 @@ unsafe fn main_0() -> i32 {
         );
         b.data[(0) as usize] = 100;
         assert!(((a.data[(0) as usize]) == (0)));
-        let mut c: Buffer = Buffer::Buffer_pmutBuffer({ &mut a });
+        let mut c: Buffer = Buffer::Buffer_pmutBuffer_rv({ &mut a });
         let _dtor_c = ScopedDestructorUnsafe::new(&raw mut c, Buffer::destructor);
         assert!(
             ((*std::cell::LazyCell::force_mut(&mut *&raw mut alive_0)) == (3))
@@ -146,14 +146,14 @@ unsafe fn main_0() -> i32 {
             (((d.size) == (4)) && ((d.data[(0) as usize]) == (100)))
                 && ((*std::cell::LazyCell::force_mut(&mut *&raw mut copies_1)) == (2))
         );
-        (unsafe { Buffer::operator_assign_pmutBuffer(&mut d, &mut c) });
+        (unsafe { Buffer::operator_assign_pmutBuffer_rv(&mut d, &mut c) });
         assert!(
             (((d.data[(0) as usize]) == (0)) && ((c.size) == (0)))
                 && ((*std::cell::LazyCell::force_mut(&mut *&raw mut moves_2)) == (3))
         );
         (unsafe {
             let _o: *mut Buffer = &mut d;
-            Buffer::operator_assign_pmutBuffer(&mut d, _o)
+            Buffer::operator_assign_pmutBuffer_rv(&mut d, _o)
         });
         assert!(
             ((d.size) == (4)) && ((*std::cell::LazyCell::force_mut(&mut *&raw mut moves_2)) == (3))
diff --git a/tests/unit/out/unsafe/unique_ptr.rs b/tests/unit/out/unsafe/unique_ptr.rs
index 105a9a3c8..6dc4041d6 100644
--- a/tests/unit/out/unsafe/unique_ptr.rs
+++ b/tests/unit/out/unsafe/unique_ptr.rs
@@ -15,13 +15,13 @@ impl SafePointer {
     pub unsafe fn inc(&mut self) {
         (*self.ptr.as_deref_mut().unwrap()).prefix_inc();
     }
-    pub unsafe fn SafePointer_pmutSafePointer(_a0: *mut SafePointer) -> Self {
+    pub unsafe fn SafePointer_pmutSafePointer_rv(_a0: *mut SafePointer) -> Self {
         let mut this = Self {
             ptr: (*_a0).ptr.take(),
         };
         this
     }
-    pub unsafe fn operator_assign_pmutSafePointer(
+    pub unsafe fn operator_assign_pmutSafePointer_rv(
         &mut self,
         _a0: *mut SafePointer,
     ) -> *mut SafePointer {
diff --git a/tests/unit/out/unsafe/unique_ptr_const_deref.rs b/tests/unit/out/unsafe/unique_ptr_const_deref.rs
index 33856856e..bce521b30 100644
--- a/tests/unit/out/unsafe/unique_ptr_const_deref.rs
+++ b/tests/unit/out/unsafe/unique_ptr_const_deref.rs
@@ -12,13 +12,13 @@ pub struct Holder {
     pub val: Option<Box<i32>>,
 }
 impl Holder {
-    pub unsafe fn Holder_pmutHolder(_a0: *mut Holder) -> Self {
+    pub unsafe fn Holder_pmutHolder_rv(_a0: *mut Holder) -> Self {
         let mut this = Self {
             val: (*_a0).val.take(),
         };
         this
     }
-    pub unsafe fn operator_assign_pmutHolder(&mut self, _a0: *mut Holder) -> *mut Holder {
+    pub unsafe fn operator_assign_pmutHolder_rv(&mut self, _a0: *mut Holder) -> *mut Holder {
         self.val = (*_a0).val.take();
         return &mut (*(self as *mut Holder));
     }
diff --git a/tests/unit/out/unsafe/unique_ptr_nested.rs b/tests/unit/out/unsafe/unique_ptr_nested.rs
index 8f685efe6..5e078f1b9 100644
--- a/tests/unit/out/unsafe/unique_ptr_nested.rs
+++ b/tests/unit/out/unsafe/unique_ptr_nested.rs
@@ -18,13 +18,13 @@ pub struct Outer {
     pub inner: Option<Box<Inner>>,
 }
 impl Outer {
-    pub unsafe fn Outer_pmutOuter(_a0: *mut Outer) -> Self {
+    pub unsafe fn Outer_pmutOuter_rv(_a0: *mut Outer) -> Self {
         let mut this = Self {
             inner: (*_a0).inner.take(),
         };
         this
     }
-    pub unsafe fn operator_assign_pmutOuter(&mut self, _a0: *mut Outer) -> *mut Outer {
+    pub unsafe fn operator_assign_pmutOuter_rv(&mut self, _a0: *mut Outer) -> *mut Outer {
         self.inner = (*_a0).inner.take();
         return &mut (*(self as *mut Outer));
     }
diff --git a/tests/unit/out/unsafe/void_cast.rs b/tests/unit/out/unsafe/void_cast.rs
index 994f7fa48..ece49784a 100644
--- a/tests/unit/out/unsafe/void_cast.rs
+++ b/tests/unit/out/unsafe/void_cast.rs
@@ -37,13 +37,13 @@ pub struct NonCopyable {
     pub value: Option<Box<i32>>,
 }
 impl NonCopyable {
-    pub unsafe fn NonCopyable_pmutNonCopyable(_a0: *mut NonCopyable) -> Self {
+    pub unsafe fn NonCopyable_pmutNonCopyable_rv(_a0: *mut NonCopyable) -> Self {
         let mut this = Self {
             value: (*_a0).value.take(),
         };
         this
     }
-    pub unsafe fn operator_assign_pmutNonCopyable(
+    pub unsafe fn operator_assign_pmutNonCopyable_rv(
         &mut self,
         _a0: *mut NonCopyable,
     ) -> *mut NonCopyable {
diff --git a/tests/unit/overload_mangling.cpp b/tests/unit/overload_mangling.cpp
index 70304c8a2..b407cfb33 100644
--- a/tests/unit/overload_mangling.cpp
+++ b/tests/unit/overload_mangling.cpp
@@ -1,4 +1,9 @@
 #include <cassert>
+#include <utility>
+
+static void inc(int *p) { *p += 1; }
+static void add(int *p, int n) { *p += n; }
+static int twice(int n) { return n * 2; }
 
 struct S {
   int base;
@@ -11,6 +16,19 @@ struct S {
   }
   int plain(int x) const { return base + x; }
   int plain(long x) const { return base + (int)x + 1; }
+  int take(int &x) const { return base + x + 1; }
+  int take(int &&x) const { return base + x + 2; }
+  int pick(std::pair<int, int> p) const { return base + p.first; }
+  int pick(std::pair<int, long> p) const { return base + (int)p.second; }
+  int apply(void (*f)(int *), int x) const {
+    f(&x);
+    return base + x;
+  }
+  int apply(void (*f)(int *, int), int x) const {
+    f(&x, 10);
+    return base + x;
+  }
+  int apply(int (*f)(int), int x) const { return base + f(x); }
 };
 
 struct Box {
@@ -27,6 +45,14 @@ int main() {
   assert((s.count<int, long>(1) == 103));
   assert(s.plain(1) == 101);
   assert(s.plain(1L) == 102);
+  int y = 1;
+  assert(s.take(y) == 102);
+  assert(s.take(5) == 107);
+  assert(s.pick(std::pair<int, int>(1, 2)) == 101);
+  assert(s.pick(std::pair<int, long>(1, 2L)) == 102);
+  assert(s.apply(inc, 1) == 102);
+  assert(s.apply(add, 1) == 111);
+  assert(s.apply(twice, 3) == 106);
   Box b{4};
   assert(b.v == 4);
   return 0;