Update tesst

Author: lucic71

tests/unit/out/refcount/structured_binding_array.rs

@@ -12,20 +12,19 @@ pub fn main() {
 }
 fn main_0() -> i32 {
     let arr: Value<Box<[i32]>> = Rc::new(RefCell::new(Box::new([1, 2, 3])));
-    let __decomp_0: Value<Box<[i32]>> =
-        Rc::new(RefCell::new(Box::new(std::array::from_fn::<_, 3, _>(
-            |__i: usize| (*arr.borrow())[(__i) as usize],
-        ))));
-    (*__decomp_0.borrow_mut())[(0) as usize] = 10;
-    assert!(((*__decomp_0.borrow())[(0) as usize] == 10));
-    assert!(((*__decomp_0.borrow())[(1) as usize] == 2));
-    assert!(((*__decomp_0.borrow())[(2) as usize] == 3));
+    let mut __decomp_0: [i32; 3] = Box::new(std::array::from_fn::<_, 3, _>(|__i: usize| {
+        (*arr.borrow())[(__i) as usize]
+    }));
+    __decomp_0[(0) as usize] = 10;
+    assert!((__decomp_0[(0) as usize] == 10));
+    assert!((__decomp_0[(1) as usize] == 2));
+    assert!((__decomp_0[(2) as usize] == 3));
     assert!(((*arr.borrow())[(0) as usize] == 1));
-    let __decomp_1: Ptr<i32> = (arr.as_pointer() as Ptr<i32>);
+    let __decomp_1: Ptr<i32> = arr.as_pointer();
     elem!((__decomp_1), 0).write(7);
     {
-        let _ptr = elem!((__decomp_1), 2);
-        _ptr.write(_ptr.read() + (elem!((__decomp_1), 1).read()))
+        let __rhs = (elem!((__decomp_1), 1).read());
+        elem!((__decomp_1), 2).with_mut(|__v| *__v = *__v + __rhs)
     };
     assert!(((*arr.borrow())[(0) as usize] == 7));
     assert!(((*arr.borrow())[(2) as usize] == 5));

tests/unit/out/refcount/structured_binding_copy_ctor.rs

@@ -18,24 +18,16 @@ pub struct Counted {
     pub y: i32,
 }
 impl Counted {
-    pub fn new(x: i32, y: i32) -> Self {
-        let x: Value<i32> = Rc::new(RefCell::new(x));
-        let y: Value<i32> = Rc::new(RefCell::new(y));
-        let __this: Value<Counted> = Rc::new(RefCell::new(Self {
-            x: (*x.borrow()),
-            y: (*y.borrow()),
-        }));
-        let this: Ptr<Counted> = __this.as_pointer();
-        Rc::try_unwrap(__this).ok().unwrap().into_inner()
+    pub fn new(mut x: i32, mut y: i32) -> Self {
+        Self { x: x, y: y }
     }
     pub fn copy_from(other: Ptr<Counted>) -> Self {
-        let __this: Value<Counted> = Rc::new(RefCell::new(Self {
+        let __this: Counted = Self {
             x: (other.with(|__s| __s.x) * 2),
             y: (other.with(|__s| __s.y) * 2),
-        }));
-        let this: Ptr<Counted> = __this.as_pointer();
+        };
         (*copies_0.with(Value::clone).borrow_mut()).prefix_inc();
-        Rc::try_unwrap(__this).ok().unwrap().into_inner()
+        __this
     }
 }
 impl Clone for Counted {
@@ -56,21 +48,21 @@ pub fn main() {
 }
 fn main_0() -> i32 {
     let s: Value<Counted> = Rc::new(RefCell::new(Counted::new({ 1 }, { 2 })));
-    let __decomp_2: Value<Counted> = Rc::new(RefCell::new(Counted::copy_from({ s.as_pointer() })));
+    let mut __decomp_2: Counted = Counted::copy_from({ s.as_pointer() });
     assert!((copies_0.with(|rc| *rc.borrow()) == 1));
-    assert!(({ (*__decomp_2.borrow()).x } == 2));
-    assert!(({ (*__decomp_2.borrow()).y } == 4));
+    assert!((__decomp_2.x == 2));
+    assert!((__decomp_2.y == 4));
     let __decomp_3: Ptr<Counted> = s.as_pointer();
     assert!((copies_0.with(|rc| *rc.borrow()) == 1));
     assert!((__decomp_3.with(|__s| __s.x) == 1));
     assert!((__decomp_3.with(|__s| __s.y) == 2));
     let __decomp_4: Ptr<Counted> = s.as_pointer();
     assert!((copies_0.with(|rc| *rc.borrow()) == 1));
     assert!((__decomp_4.with(|__s| __s.x) == 1));
-    let __decomp_5: Value<Counted> = Rc::new(RefCell::new(({ make_counted_1() })));
+    let mut __decomp_5: Counted = ({ make_counted_1() });
     assert!((copies_0.with(|rc| *rc.borrow()) == 1));
-    assert!(({ (*__decomp_5.borrow()).x } == 5));
-    assert!(({ (*__decomp_5.borrow()).y } == 6));
+    assert!((__decomp_5.x == 5));
+    assert!((__decomp_5.y == 6));
     return 0;
 }
 pub fn __cpp2rust_init_globals() {

tests/unit/out/refcount/structured_binding_move_ctor.rs

@@ -12,7 +12,7 @@ thread_local!(
 thread_local!(
     pub static moves_1: Value<i32> = Rc::new(RefCell::new(0));
 );
-#[derive(Record, ByteRepr, VaArg, FnPtrArg, Default)]
+#[derive(Record, ByteRepr, VaArg, FnPtrArg, MoveCtor, Default)]
 #[byte_size(8)]
 pub struct Movable {
     #[offset(0)]
@@ -21,35 +21,26 @@ pub struct Movable {
     pub y: i32,
 }
 impl Movable {
-    pub fn new(x: i32, y: i32) -> Self {
-        let x: Value<i32> = Rc::new(RefCell::new(x));
-        let y: Value<i32> = Rc::new(RefCell::new(y));
-        let __this: Value<Movable> = Rc::new(RefCell::new(Self {
-            x: (*x.borrow()),
-            y: (*y.borrow()),
-        }));
-        let this: Ptr<Movable> = __this.as_pointer();
-        Rc::try_unwrap(__this).ok().unwrap().into_inner()
+    pub fn new(mut x: i32, mut y: i32) -> Self {
+        Self { x: x, y: y }
     }
     pub fn copy_from(other: Ptr<Movable>) -> Self {
-        let __this: Value<Movable> = Rc::new(RefCell::new(Self {
+        let __this: Movable = Self {
             x: other.with(|__s| __s.x),
             y: other.with(|__s| __s.y),
-        }));
-        let this: Ptr<Movable> = __this.as_pointer();
+        };
         (*copies_0.with(Value::clone).borrow_mut()).prefix_inc();
-        Rc::try_unwrap(__this).ok().unwrap().into_inner()
+        __this
     }
     pub fn move_from(other: Ptr<Movable>) -> Self {
-        let __this: Value<Movable> = Rc::new(RefCell::new(Self {
+        let __this: Movable = Self {
             x: other.with(|__s| __s.x),
             y: other.with(|__s| __s.y),
-        }));
-        let this: Ptr<Movable> = __this.as_pointer();
+        };
         field!(other, x).write(0);
         field!(other, y).write(0);
         (*moves_1.with(Value::clone).borrow_mut()).prefix_inc();
-        Rc::try_unwrap(__this).ok().unwrap().into_inner()
+        __this
     }
 }
 impl Clone for Movable {
@@ -77,37 +68,22 @@ pub fn main() {
 }
 fn main_0() -> i32 {
     let m: Value<Movable> = Rc::new(RefCell::new(Movable::new({ 3 }, { 4 })));
-    let __decomp_2: Value<Movable> = Rc::new(RefCell::new(Movable::move_from({ m.as_pointer() })));
+    let mut __decomp_2: Movable = Movable::move_from({ m.as_pointer() });
     assert!((moves_1.with(|rc| *rc.borrow()) == 1));
     assert!((copies_0.with(|rc| *rc.borrow()) == 0));
-    assert!(({ (*__decomp_2.borrow()).x } == 3));
-    assert!(({ (*__decomp_2.borrow()).y } == 4));
+    assert!((__decomp_2.x == 3));
+    assert!((__decomp_2.y == 4));
     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])),
     }));
-    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!(
-        ((elem!(
-            ({ (*__decomp_3.borrow()).xs.as_pointer() } as Ptr<i32>),
-            2_usize
-        )
-        .read())
-            == 3)
-    );
-    assert!(
-        ((elem!(
-            ({ (*__decomp_3.borrow()).ys.as_pointer() } as Ptr<i32>),
-            0_usize
-        )
-        .read())
-            == 4)
-    );
+    let mut __decomp_3: Holder = ({ HolderImpl::extract(&h.as_pointer()) });
+    assert!(((*__decomp_3.xs.borrow()).len() == 3_usize));
+    assert!(((*__decomp_3.ys.borrow()).len() == 2_usize));
+    assert!(((elem!((__decomp_3.xs.as_pointer() as Ptr<i32>), 2_usize).read()) == 3));
+    assert!(((elem!((__decomp_3.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());
     return 0;

tests/unit/out/refcount/structured_binding_range_for.rs

@@ -35,25 +35,24 @@ fn main_0() -> i32 {
     ])));
     'loop_: for mut __decomp_0 in arr.as_pointer() as Ptr<Pair> {
         {
-            let _ptr = field!(__decomp_0, first);
-            _ptr.write(_ptr.read() + __decomp_0.with(|__s| __s.second))
+            let __rhs = __decomp_0.with(|__s| __s.second);
+            field!(__decomp_0, first).with_mut(|__v| *__v = *__v + __rhs)
         };
     }
     assert!(({ (*arr.borrow())[(0) as usize].first } == 3));
     assert!(({ (*arr.borrow())[(2) as usize].first } == 11));
     'loop_: for mut __decomp_1 in arr.as_pointer() as Ptr<Pair> {
-        let __decomp_1: Value<Pair> = Rc::new(RefCell::new(__decomp_1.upgrade().deref().clone()));
-        (*__decomp_1.borrow_mut()).first = 0;
-        (*__decomp_1.borrow_mut()).second = 0;
+        let mut __decomp_1: Pair = __decomp_1.upgrade().deref().clone();
+        __decomp_1.first = 0;
+        __decomp_1.second = 0;
     }
     assert!(({ (*arr.borrow())[(1) as usize].first } == 7));
     assert!(({ (*arr.borrow())[(1) as usize].second } == 4));
-    let sum: Value<i32> = Rc::new(RefCell::new(0));
+    let mut sum: i32 = 0;
     'loop_: for mut __decomp_2 in arr.as_pointer() as Ptr<Pair> {
-        (*sum.borrow_mut()) +=
-            (__decomp_2.with(|__s| __s.first) * __decomp_2.with(|__s| __s.second));
+        sum += (__decomp_2.with(|__s| __s.first) * __decomp_2.with(|__s| __s.second));
     }
-    assert!(((*sum.borrow()) == (((3 * 2) + (7 * 4)) + (11 * 6))));
+    assert!((sum == (((3 * 2) + (7 * 4)) + (11 * 6))));
     return 0;
 }
 pub fn __cpp2rust_init_globals() {}

tests/unit/out/refcount/structured_binding_ref.rs

@@ -35,8 +35,7 @@ fn main_0() -> i32 {
     field!(__decomp_2, a).write(11);
     field!(__decomp_2, b).write(true);
     {
-        let _ptr = field!(__decomp_2, c);
-        _ptr.write(_ptr.read() + 1)
+        field!(__decomp_2, c).with_mut(|__v| *__v = *__v + 1)
     };
     assert!(({ (*t.borrow()).a } == 11));
     assert!({ (*t.borrow()).b });

tests/unit/out/refcount/structured_binding_trivial.rs

@@ -19,23 +19,23 @@ pub fn main() {
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
-    let __decomp_0: Value<Pair> = Rc::new(RefCell::new(Pair {
+    let mut __decomp_0: Pair = Pair {
         first: 1,
         second: 2,
-    }));
-    assert!(({ (*__decomp_0.borrow()).first } == 1));
-    assert!(({ (*__decomp_0.borrow()).second } == 2));
-    let p: Value<Pair> = Rc::new(RefCell::new(Pair {
+    };
+    assert!((__decomp_0.first == 1));
+    assert!((__decomp_0.second == 2));
+    let mut p: Pair = Pair {
         first: 10,
         second: 20,
-    }));
-    let __decomp_1: Value<Pair> = Rc::new(RefCell::new((*p.borrow()).clone()));
-    (*__decomp_1.borrow_mut()).first = 11;
-    (*__decomp_1.borrow_mut()).second += 1;
-    assert!(({ (*__decomp_1.borrow()).first } == 11));
-    assert!(({ (*__decomp_1.borrow()).second } == 21));
-    assert!(({ (*p.borrow()).first } == 10));
-    assert!(({ (*p.borrow()).second } == 20));
+    };
+    let mut __decomp_1: Pair = (p).clone();
+    __decomp_1.first = 11;
+    __decomp_1.second += 1;
+    assert!((__decomp_1.first == 11));
+    assert!((__decomp_1.second == 21));
+    assert!((p.first == 10));
+    assert!((p.second == 20));
     return 0;
 }
 pub fn __cpp2rust_init_globals() {}

tests/unit/out/unsafe/structured_binding_copy_ctor.rs

@@ -8,7 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub static mut copies_0: std::cell::LazyCell<i32> = std::cell::LazyCell::new(|| unsafe { 0 });
 #[repr(C)]
-#[derive(VaArg, Default)]
+#[derive(VaArg, FnPtrArg, Default)]
 pub struct Counted {
     pub x: i32,
     pub y: i32,

tests/unit/out/unsafe/structured_binding_move_ctor.rs

@@ -9,7 +9,7 @@ use std::rc::Rc;
 pub static mut copies_0: std::cell::LazyCell<i32> = std::cell::LazyCell::new(|| unsafe { 0 });
 pub static mut moves_1: std::cell::LazyCell<i32> = std::cell::LazyCell::new(|| unsafe { 0 });
 #[repr(C)]
-#[derive(VaArg, Default)]
+#[derive(VaArg, FnPtrArg, MoveCtorUnsafe, Default)]
 pub struct Movable {
     pub x: i32,
     pub y: i32,
@@ -44,7 +44,7 @@ impl Clone for Movable {
     }
 }
 #[repr(C)]
-#[derive(Clone, VaArg, Default)]
+#[derive(Clone, VaArg, FnPtrArg, Default)]
 pub struct Holder {
     pub xs: Vec<i32>,
     pub ys: Vec<i32>,

tests/unit/out/unsafe/structured_binding_range_for.rs

@@ -7,7 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 #[repr(C)]
-#[derive(Copy, Clone, VaArg, Default)]
+#[derive(Copy, Clone, VaArg, FnPtrArg, Default)]
 pub struct Pair {
     pub first: i32,
     pub second: i32,

tests/unit/out/unsafe/structured_binding_ref.rs

@@ -7,7 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 #[repr(C)]
-#[derive(Copy, Clone, VaArg, Default)]
+#[derive(Copy, Clone, VaArg, FnPtrArg, Default)]
 pub struct Triple {
     pub a: i32,
     pub b: bool,