Keep std::pair member cells on move and assignment

rules/pair/tgt_refcount.rs

@@ -31,25 +31,39 @@ fn f10<T1, T2>(a0: T1, a1: T2) -> (Value<T1>, Value<T2>) {
     (Rc::new(RefCell::new(a0)), Rc::new(RefCell::new(a1)))
 }
 
-fn f12<T1: Default, T2: Default>(a0: &mut (Value<T1>, Value<T2>)) -> (Value<T1>, Value<T2>) {
-    std::mem::take(&mut *a0)
+fn f12<T1, T2>(a0: &mut (Value<T1>, Value<T2>)) -> (Value<T1>, Value<T2>) {
+    let __first: Ptr<T1> = a0.0.as_pointer();
+    let __second: Ptr<T2> = a0.1.as_pointer();
+    (
+        Rc::new(RefCell::new(cpp_move!(__first))),
+        Rc::new(RefCell::new(cpp_move!(__second))),
+    )
 }
 
 fn f13<T1: Clone + ByteRepr, T2: Clone + ByteRepr>(
     a0: Ptr<(Value<T1>, Value<T2>)>,
     a1: (Value<T1>, Value<T2>),
 ) {
-    a0.write((
-        Rc::new(RefCell::new(a1.0.borrow().clone())),
-        Rc::new(RefCell::new(a1.1.borrow().clone())),
-    ))
+    let __first = a1.0.borrow().clone();
+    let __second = a1.1.borrow().clone();
+    a0.with(|__dst| {
+        *__dst.0.borrow_mut() = __first;
+        *__dst.1.borrow_mut() = __second;
+    })
 }
 
-fn f14<T1: Default + ByteRepr, T2: Default + ByteRepr>(
+fn f14<T1: ByteRepr, T2: ByteRepr>(
     a0: Ptr<(Value<T1>, Value<T2>)>,
     a1: &mut (Value<T1>, Value<T2>),
 ) {
-    a0.write(std::mem::take(&mut *a1))
+    let __src_first: Ptr<T1> = a1.0.as_pointer();
+    let __src_second: Ptr<T2> = a1.1.as_pointer();
+    let __first = cpp_move!(__src_first);
+    let __second = cpp_move!(__src_second);
+    a0.with(|__dst| {
+        *__dst.0.borrow_mut() = __first;
+        *__dst.1.borrow_mut() = __second;
+    })
 }
 
 fn f15<T1, T2>(a0: (Value<T1>, Value<T2>)) -> Value<T2> {
@@ -103,20 +117,24 @@ fn f25<T1: CppFrom<T3> + ByteRepr, T2: CppFrom<T4> + ByteRepr, T3, T4>(
     a0: Ptr<(Value<T1>, Value<T2>)>,
     a1: (Value<T3>, Value<T4>),
 ) {
-    a0.write((
-        Rc::new(RefCell::new(T1::cpp_from(a1.0.as_pointer()))),
-        Rc::new(RefCell::new(T2::cpp_from(a1.1.as_pointer()))),
-    ))
+    let __first = T1::cpp_from(a1.0.as_pointer());
+    let __second = T2::cpp_from(a1.1.as_pointer());
+    a0.with(|__dst| {
+        *__dst.0.borrow_mut() = __first;
+        *__dst.1.borrow_mut() = __second;
+    })
 }
 
 fn f26<T1: CppFrom<T3> + ByteRepr, T2: CppFrom<T4> + ByteRepr, T3, T4>(
     a0: Ptr<(Value<T1>, Value<T2>)>,
     a1: &mut (Value<T3>, Value<T4>),
 ) {
-    a0.write((
-        Rc::new(RefCell::new(T1::cpp_from_move(a1.0.as_pointer()))),
-        Rc::new(RefCell::new(T2::cpp_from_move(a1.1.as_pointer()))),
-    ))
+    let __first = T1::cpp_from_move(a1.0.as_pointer());
+    let __second = T2::cpp_from_move(a1.1.as_pointer());
+    a0.with(|__dst| {
+        *__dst.0.borrow_mut() = __first;
+        *__dst.1.borrow_mut() = __second;
+    })
 }
 
 fn f27<const T1: usize, T2, T3>(a0: (Value<T2>, Value<T3>)) -> Ptr<<(T2, T3) as TupleElement<T1>>::Type>

tests/unit/out/refcount/pair.rs

@@ -62,23 +62,122 @@ fn main_0() -> i32 {
     )))
     .as_pointer(),)
     {
-        (__tmp_1,) => const_ptr_pairs.decay().offset(0_usize).write((
-            Rc::new(RefCell::new(
-                <Ptr<i32> as CppFrom<Ptr<i32>>>::cpp_from_move(
-                    (*__tmp_1.upgrade().deref()).0.as_pointer(),
-                ),
-            )),
-            Rc::new(RefCell::new(
-                (((*__tmp_1.upgrade().deref()).1.as_pointer().read()) as u64),
-            )),
-        )),
+        (__tmp_1,) => {
+            let __first = <Ptr<i32> as CppFrom<Ptr<i32>>>::cpp_from_move(
+                (*__tmp_1.upgrade().deref()).0.as_pointer(),
+            );
+            let __second = (((*__tmp_1.upgrade().deref()).1.as_pointer().read()) as u64);
+            const_ptr_pairs.decay().offset(0_usize).with(|__dst| {
+                *__dst.0.borrow_mut() = __first;
+                *__dst.1.borrow_mut() = __second;
+            })
+        }
     };
     assert!(
         ({
             (((*(*const_ptr_pairs.borrow())[0_usize].0.borrow()).read()) == 2)
                 && ((*(*const_ptr_pairs.borrow())[0_usize].1.borrow()) == 2_u64)
         })
     );
+    let p: Value<(Value<i32>, Value<i32>)> = Rc::new(RefCell::new((
+        Rc::new(RefCell::new(1)),
+        Rc::new(RefCell::new(2)),
+    )));
+    let q: Value<(Value<i32>, Value<i32>)> = Rc::new(RefCell::new((
+        Rc::new(RefCell::new(3)),
+        Rc::new(RefCell::new(4)),
+    )));
+    let mut f: Ptr<i32> = ((*p.borrow()).0.as_pointer());
+    {
+        let __first = (*q.borrow()).0.borrow().clone();
+        let __second = (*q.borrow()).1.borrow().clone();
+        p.as_pointer().with(|__dst| {
+            *__dst.0.borrow_mut() = __first;
+            *__dst.1.borrow_mut() = __second;
+        })
+    };
+    assert!(((f.read()) == 3));
+    let alias: Ptr<(Value<i32>, Value<i32>)> = p.as_pointer();
+    {
+        let __first = (*alias.upgrade().deref()).0.borrow().clone();
+        let __second = (*alias.upgrade().deref()).1.borrow().clone();
+        p.as_pointer().with(|__dst| {
+            *__dst.0.borrow_mut() = __first;
+            *__dst.1.borrow_mut() = __second;
+        })
+    };
+    assert!(((f.read()) == 3));
+    let a: Value<(Value<i32>, Value<i32>)> = Rc::new(RefCell::new((
+        Rc::new(RefCell::new(1)),
+        Rc::new(RefCell::new(2)),
+    )));
+    let mut pa: Ptr<i32> = ((*a.borrow()).0.as_pointer());
+    let b: Value<(Value<i32>, Value<i32>)> = Rc::new(RefCell::new({
+        let __first: Ptr<i32> = (*a.borrow()).0.as_pointer();
+        let __second: Ptr<i32> = (*a.borrow()).1.as_pointer();
+        (
+            Rc::new(RefCell::new(cpp_move!(__first))),
+            Rc::new(RefCell::new(cpp_move!(__second))),
+        )
+    }));
+    pa.write(9);
+    assert!(({ ((*(*b.borrow()).0.borrow()) == 1) }));
+    assert!(({ ((*(*a.borrow()).0.borrow()) == 9) }));
+    let d: Value<(Value<i32>, Value<i32>)> = Rc::new(RefCell::new((
+        Rc::new(RefCell::new(1)),
+        Rc::new(RefCell::new(2)),
+    )));
+    let s: Value<(Value<i32>, Value<i32>)> = Rc::new(RefCell::new((
+        Rc::new(RefCell::new(3)),
+        Rc::new(RefCell::new(4)),
+    )));
+    let mut pd: Ptr<i32> = ((*d.borrow()).0.as_pointer());
+    let mut ps: Ptr<i32> = ((*s.borrow()).0.as_pointer());
+    {
+        let __src_first: Ptr<i32> = (*s.borrow()).0.as_pointer();
+        let __src_second: Ptr<i32> = (*s.borrow()).1.as_pointer();
+        let __first = cpp_move!(__src_first);
+        let __second = cpp_move!(__src_second);
+        d.as_pointer().with(|__dst| {
+            *__dst.0.borrow_mut() = __first;
+            *__dst.1.borrow_mut() = __second;
+        })
+    };
+    assert!(((pd.read()) == 3));
+    ps.write(5);
+    assert!(({ ((*(*d.borrow()).0.borrow()) == 3) }));
+    assert!(({ ((*(*s.borrow()).0.borrow()) == 5) }));
+    let w: Value<(Value<i64>, Value<i64>)> = Rc::new(RefCell::new((
+        Rc::new(RefCell::new((1 as i64))),
+        Rc::new(RefCell::new((2 as i64))),
+    )));
+    let narrow: Value<(Value<i32>, Value<i32>)> = Rc::new(RefCell::new((
+        Rc::new(RefCell::new(3)),
+        Rc::new(RefCell::new(4)),
+    )));
+    let mut pw: Ptr<i64> = ((*w.borrow()).0.as_pointer());
+    {
+        let __first = (((*narrow.borrow()).0.as_pointer().read()) as i64);
+        let __second = (((*narrow.borrow()).1.as_pointer().read()) as i64);
+        w.as_pointer().with(|__dst| {
+            *__dst.0.borrow_mut() = __first;
+            *__dst.1.borrow_mut() = __second;
+        })
+    };
+    assert!(((pw.read()) == 3_i64));
+    let m: Value<(Value<i32>, Value<i32>)> = Rc::new(RefCell::new((
+        Rc::new(RefCell::new(5)),
+        Rc::new(RefCell::new(6)),
+    )));
+    {
+        let __first = (((*m.borrow()).0.as_pointer().read()) as i64);
+        let __second = (((*m.borrow()).1.as_pointer().read()) as i64);
+        w.as_pointer().with(|__dst| {
+            *__dst.0.borrow_mut() = __first;
+            *__dst.1.borrow_mut() = __second;
+        })
+    };
+    assert!(((pw.read()) == 5_i64));
     return 0;
 }
 pub fn __cpp2rust_init_globals() {}

tests/unit/out/unsafe/pair.rs

@@ -40,6 +40,37 @@ unsafe fn main_0() -> i32 {
     assert!(
         ((*const_ptr_pairs[(0_usize)].0) == (2)) && ((const_ptr_pairs[(0_usize)].1) == (2_u64))
     );
+    let mut p: (i32, i32) = (1, 2);
+    let mut q: (i32, i32) = (3, 4);
+    let mut f: *mut i32 = (&mut p.0 as *mut i32);
+    p = q.clone();
+    assert!(((*f) == (3)));
+    let alias: *mut (i32, i32) = &mut p;
+    p = (*alias).clone();
+    assert!(((*f) == (3)));
+    let mut a: (i32, i32) = (1, 2);
+    let mut pa: *mut i32 = (&mut a.0 as *mut i32);
+    let mut b: (i32, i32) = std::mem::take(&mut a);
+    (*pa) = 9;
+    assert!(((b.0) == (1)));
+    assert!(((a.0) == (9)));
+    let mut d: (i32, i32) = (1, 2);
+    let mut s: (i32, i32) = (3, 4);
+    let mut pd: *mut i32 = (&mut d.0 as *mut i32);
+    let mut ps: *mut i32 = (&mut s.0 as *mut i32);
+    d = std::mem::take(&mut s);
+    assert!(((*pd) == (3)));
+    (*ps) = 5;
+    assert!(((d.0) == (3)));
+    assert!(((s.0) == (5)));
+    let mut w: (i64, i64) = ((1 as i64), (2 as i64));
+    let mut narrow: (i32, i32) = (3, 4);
+    let mut pw: *mut i64 = (&mut w.0 as *mut i64);
+    w = (((*&narrow.0) as i64), ((*&narrow.1) as i64));
+    assert!(((*pw) == (3_i64)));
+    let mut m: (i32, i32) = (5, 6);
+    w = (((*&mut m.0) as i64), ((*&mut m.1) as i64));
+    assert!(((*pw) == (5_i64)));
     return 0;
 }
 pub unsafe fn __cpp2rust_init_globals() {}

tests/unit/pair.cpp

@@ -17,5 +17,40 @@ int main() {
   std::vector<std::pair<const int *, size_t>> const_ptr_pairs(1);
   const_ptr_pairs[0] = std::make_pair(arr + 1, n);
   assert(*const_ptr_pairs[0].first == 2 && const_ptr_pairs[0].second == 2);
+
+  std::pair<int, int> p{1, 2};
+  std::pair<int, int> q{3, 4};
+  int *f = &p.first;
+  p = q;
+  assert(*f == 3);
+  std::pair<int, int> &alias = p;
+  p = alias;
+  assert(*f == 3);
+
+  std::pair<int, int> a{1, 2};
+  int *pa = &a.first;
+  std::pair<int, int> b = std::move(a);
+  *pa = 9;
+  assert(b.first == 1);
+  assert(a.first == 9);
+
+  std::pair<int, int> d{1, 2};
+  std::pair<int, int> s{3, 4};
+  int *pd = &d.first;
+  int *ps = &s.first;
+  d = std::move(s);
+  assert(*pd == 3);
+  *ps = 5;
+  assert(d.first == 3);
+  assert(s.first == 5);
+
+  std::pair<long, long> w{1, 2};
+  std::pair<int, int> narrow{3, 4};
+  long *pw = &w.first;
+  w = narrow;
+  assert(*pw == 3);
+  std::pair<int, int> m{5, 6};
+  w = std::move(m);
+  assert(*pw == 5);
   return 0;
 }