Update tests

Author: lucic71

tests/unit/out/refcount/copy_ctor.rs

@@ -141,13 +141,20 @@ impl Clone for Box_int_ {
         Box_int_::copy_from(__src.as_pointer())
     }
 }
-#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)]
+#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, MoveCtor, Default)]
 #[byte_size(4)]
 pub struct Owner {
     #[offset(0)]
     #[byte_size(4)]
     pub box_: Box_int_,
 }
+impl Owner {
+    pub fn move_from(_a0: Ptr<Owner>) -> Self {
+        Self {
+            box_: Box_int_::move_from({ field_ptr!(_a0, box_) }),
+        }
+    }
+}
 #[derive(Record, ByteRepr, VaArg, FnPtrArg, Default)]
 #[byte_size(4)]
 pub struct OutOfLine {
@@ -255,7 +262,7 @@ fn main_0() -> i32 {
     let o: Value<Owner> = Rc::new(RefCell::new(Owner {
         box_: Box_int_::new({ 3 }),
     }));
-    let mut o2: Owner = (*o.borrow()).clone();
+    let mut o2: Owner = Owner::move_from({ o.as_pointer() });
     assert!((o2.box_.val == 3));
     let ol1: Value<OutOfLine> = Rc::new(RefCell::new(OutOfLine::new({ 5 })));
     let mut ol2: OutOfLine = OutOfLine::copy_from({ ol1.as_pointer() });

tests/unit/out/refcount/structured_binding_move_ctor.rs

@@ -52,15 +52,15 @@ impl Clone for Movable {
         Movable::copy_from(__src.as_pointer())
     }
 }
-#[derive(DeepClone, Record, ByteRepr, VaArg, FnPtrArg, Default)]
+#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)]
 #[byte_size(48)]
 pub struct Holder {
     #[offset(0)]
     #[byte_size(24)]
-    pub xs: Value<Vec<i32>>,
+    pub xs: Vec<i32>,
     #[offset(24)]
     #[byte_size(24)]
-    pub ys: Value<Vec<i32>>,
+    pub ys: Vec<i32>,
 }
 pub fn main() {
     __cpp2rust_init_globals();
@@ -76,31 +76,31 @@ fn main_0() -> i32 {
     assert!(({ (*m.borrow()).x } == 0));
     assert!(({ (*m.borrow()).y } == 0));
     let h: Value<Holder> = Rc::new(RefCell::new(Holder {
-        xs: Rc::new(RefCell::new(vec![1, 2, 3])),
-        ys: Rc::new(RefCell::new(vec![4, 5])),
+        xs: Vec::from([1, 2, 3]),
+        ys: Vec::from([4, 5]),
     }));
     let __decomp_3: Value<Holder> =
         Rc::new(RefCell::new(({ HolderImpl::extract(&h.as_pointer()) })));
-    assert!(((*{ (*__decomp_3.borrow()).xs.clone() }.borrow()).len() == 3_usize));
-    assert!(((*{ (*__decomp_3.borrow()).ys.clone() }.borrow()).len() == 2_usize));
+    assert!(((*__decomp_3.borrow()).xs.len() == 3_usize));
+    assert!(((*__decomp_3.borrow()).ys.len() == 2_usize));
     assert!(
         ((elem!(
-            ({ (*__decomp_3.borrow()).xs.as_pointer() } as Ptr<i32>),
+            (field_ref!(__decomp_3.as_pointer(), xs).as_pointer() as Ptr<i32>),
             2_usize
         )
         .read())
             == 3)
     );
     assert!(
         ((elem!(
-            ({ (*__decomp_3.borrow()).ys.as_pointer() } as Ptr<i32>),
+            (field_ref!(__decomp_3.as_pointer(), ys).as_pointer() as Ptr<i32>),
             0_usize
         )
         .read())
             == 4)
     );
-    assert!((*{ (*h.borrow()).xs.clone() }.borrow()).is_empty());
-    assert!((*{ (*h.borrow()).ys.clone() }.borrow()).is_empty());
+    assert!((*h.borrow()).xs.is_empty());
+    assert!((*h.borrow()).ys.is_empty());
     return 0;
 }
 pub trait HolderImpl {
@@ -109,12 +109,8 @@ pub trait HolderImpl {
 impl HolderImpl for Ptr<Holder> {
     fn extract(&self) -> Holder {
         return Holder {
-            xs: Rc::new(RefCell::new(std::mem::take(
-                &mut (*(*self).with(|__s| __s.xs.clone()).borrow_mut()),
-            ))),
-            ys: Rc::new(RefCell::new(std::mem::take(
-                &mut (*(*self).with(|__s| __s.ys.clone()).borrow_mut()),
-            ))),
+            xs: field!((*self), xs).with_mut(std::mem::take),
+            ys: field!((*self), ys).with_mut(std::mem::take),
         };
     }
 }

tests/unit/out/unsafe/structured_binding_move_ctor.rs

@@ -73,8 +73,8 @@ unsafe fn main_0() -> i32 {
     assert!(((m.x) == (0)));
     assert!(((m.y) == (0)));
     let mut h: Holder = Holder {
-        xs: vec![1, 2, 3],
-        ys: vec![4, 5],
+        xs: Vec::from([1, 2, 3]),
+        ys: Vec::from([4, 5]),
     };
     let mut __decomp_3: Holder = (unsafe { Holder::extract(&mut h) });
     assert!(((__decomp_3.xs.len()) == (3_usize)));