Update tests

Author: lucic71

tests/unit/out/refcount/void_cast.rs

@@ -8,7 +8,7 @@ use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn unused_param_0(x: i32) {
     let x: Value<i32> = Rc::new(RefCell::new(x));
-    let _ = (*x.borrow_mut()).clone();
+    (*x.borrow_mut());
 }
 thread_local!(
     pub static side_effect_counter: Value<i32> = Rc::new(RefCell::new(0));
@@ -39,64 +39,58 @@ fn main_0() -> i32 {
         unused_param_0(_x)
     });
     let y: Value<i32> = Rc::new(RefCell::new(5));
-    let _ = (*y.borrow_mut()).clone();
+    (*y.borrow_mut());
     let z: Value<i32> = Rc::new(RefCell::new({
-        let _ = (*y.borrow_mut()).clone();
+        (*y.borrow_mut());
         7
     }));
     assert!(((*z.borrow()) == 7));
     let counter: Value<i32> = Rc::new(RefCell::new(0));
     let w: Value<i32> = Rc::new(RefCell::new({
-        let _ = (*counter.borrow_mut()).clone();
+        (*counter.borrow_mut());
         (*counter.borrow_mut()) = 3;
         (*counter.borrow())
     }));
     assert!(((*w.borrow()) == 3));
     assert!(((*counter.borrow()) == 3));
-    let _ = ({ bump_and_return_1() });
+    ({ bump_and_return_1() });
     assert!(((*side_effect_counter.with(Value::clone).borrow()) == 1));
     let v: Value<i32> = Rc::new(RefCell::new({
-        let _ = ({ bump_and_return_1() });
+        ({ bump_and_return_1() });
         99
     }));
     assert!(((*side_effect_counter.with(Value::clone).borrow()) == 2));
     assert!(((*v.borrow()) == 99));
-    let _ = 0;
-    let _ = (0);
-    let _ = (*y.borrow_mut()).clone();
-    {
-        let _ = 0;
-    };
-    {
-        let _ = (*y.borrow_mut()).clone();
-    };
+    0;
+    (0);
+    (*y.borrow_mut());
+    (0);
+    (*y.borrow_mut());
     let err: Value<i32> = Rc::new(RefCell::new(0));
-    {
-        let _ = ((*err.borrow_mut()) = 42).clone();
-    };
+    ((*err.borrow_mut()) = 42);
     assert!(((*err.borrow()) == 42));
     let chosen: Value<i32> = Rc::new(RefCell::new({
-        let _ = ((*err.borrow_mut()) = 7).clone();
+        ((*err.borrow_mut()) = 7);
         123
     }));
     assert!(((*err.borrow()) == 7));
     assert!(((*chosen.borrow()) == 123));
-    let _ = bump_and_return_1.clone();
+    bump_and_return_1;
     assert!(((*side_effect_counter.with(Value::clone).borrow()) == 2));
-    let _ = (FnPtr::<fn() -> i32>::new(bump_and_return_1));
+    (FnPtr::<fn() -> i32>::new(bump_and_return_1));
     assert!(((*side_effect_counter.with(Value::clone).borrow()) == 2));
-    let _ = ((FnPtr::<fn() -> i32>::new(bump_and_return_1)).cast::<fn() -> i32>(None));
+    ((FnPtr::<fn() -> i32>::new(bump_and_return_1)).cast::<fn() -> i32>(None));
     assert!(((*side_effect_counter.with(Value::clone).borrow()) == 2));
     let storage: Value<i32> = Rc::new(RefCell::new(11));
     let p: Value<Ptr<i32>> = Rc::new(RefCell::new((storage.as_pointer())));
-    let _ = ((*p.borrow()).read()).clone();
+    ((*p.borrow()).read());
     let arr: Value<Box<[i32]>> = Rc::new(RefCell::new(Box::new([1, 2, 3])));
-    let _ = ((*arr.borrow_mut())[(1) as usize]).clone();
+    ((*arr.borrow_mut())[(1) as usize]);
     let h: Value<Holder> = Rc::new(RefCell::new(Holder {
         field: Rc::new(RefCell::new(17)),
     }));
-    let _ = (*(*h.borrow()).field.borrow_mut()).clone();
+    (*(*h.borrow()).field.borrow_mut());
     let hp: Value<Ptr<Holder>> = Rc::new(RefCell::new((h.as_pointer())));
-    let _ = (*(*(*hp.borrow()).upgrade().deref()).field.borrow_mut()).clone();
+    (*(*(*hp.borrow()).upgrade().deref()).field.borrow_mut());
     return 0;
 }

tests/unit/out/unsafe/void_cast.rs

@@ -7,7 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub unsafe fn unused_param_0(mut x: i32) {
-    let _ = x.clone();
+    x;
 }
 pub static mut side_effect_counter: i32 = 0;
 pub unsafe fn bump_and_return_1() -> i32 {
@@ -30,64 +30,58 @@ unsafe fn main_0() -> i32 {
         unused_param_0(_x)
     });
     let mut y: i32 = 5;
-    let _ = y.clone();
+    y;
     let mut z: i32 = {
-        let _ = y.clone();
+        y;
         7
     };
     assert!(((z) == (7)));
     let mut counter: i32 = 0;
     let mut w: i32 = {
-        let _ = counter.clone();
+        counter;
         counter = 3;
         counter
     };
     assert!(((w) == (3)));
     assert!(((counter) == (3)));
-    let _ = (unsafe { bump_and_return_1() });
+    (unsafe { bump_and_return_1() });
     assert!(((side_effect_counter) == (1)));
     let mut v: i32 = {
-        let _ = (unsafe { bump_and_return_1() });
+        (unsafe { bump_and_return_1() });
         99
     };
     assert!(((side_effect_counter) == (2)));
     assert!(((v) == (99)));
-    let _ = 0;
-    let _ = (0);
-    let _ = (y).clone();
-    {
-        let _ = 0;
-    };
-    {
-        let _ = (y).clone();
-    };
+    0;
+    (0);
+    (y);
+    (0);
+    (y);
     let mut err: i32 = 0;
-    {
-        let _ = (err = 42).clone();
-    };
+    (err = 42);
     assert!(((err) == (42)));
     let mut chosen: i32 = {
-        let _ = (err = 7).clone();
+        (err = 7);
         123
     };
     assert!(((err) == (7)));
     assert!(((chosen) == (123)));
-    let _ = bump_and_return_1.clone();
+    bump_and_return_1;
     assert!(((side_effect_counter) == (2)));
-    let _ = (Some(bump_and_return_1));
+    (Some(bump_and_return_1));
     assert!(((side_effect_counter) == (2)));
-    let _ = (std::mem::transmute::<Option<unsafe fn() -> i32>, Option<unsafe fn() -> i32>>(
+    (std::mem::transmute::<Option<unsafe fn() -> i32>, Option<unsafe fn() -> i32>>(
         (Some(bump_and_return_1)),
     ));
     assert!(((side_effect_counter) == (2)));
     let mut storage: i32 = 11;
     let mut p: *mut i32 = (&mut storage as *mut i32);
-    let _ = (*p).clone();
+    (*p);
     let mut arr: [i32; 3] = [1, 2, 3];
-    let _ = (arr[(1) as usize]).clone();
+    (arr[(1) as usize]);
     let mut h: Holder = Holder { field: 17 };
-    let _ = (h.field).clone();
+    (h.field);
     let mut hp: *mut Holder = (&mut h as *mut Holder);
-    let _ = ((*hp).field).clone();
+    ((*hp).field);
     return 0;
 }