Update tests

Author: lucic71

tests/unit/out/unsafe/static_var_in_class.rs

@@ -6,7 +6,7 @@ use std::collections::BTreeMap;
 use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
-static mut C_inner_const: i32 = 1;
+static mut C_inner_const: i32 = unsafe { 1 };
 #[repr(C)]
 #[derive(Copy, Clone, Default)]
 pub struct C {}
@@ -15,7 +15,7 @@ impl C {
         return C_inner_const;
     }
 }
-pub static mut S_inner_const: i32 = 2;
+pub static mut S_inner_const: i32 = unsafe { 2 };
 #[repr(C)]
 #[derive(Copy, Clone, Default)]
 pub struct S {}

tests/unit/out/unsafe/void_cast.rs

@@ -7,10 +7,21 @@ 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) {
-    x;
+    &(x);
+}
+#[repr(C)]
+#[derive(Clone, Default)]
+pub struct NonTrivial {
+    pub data: Vec<i32>,
+}
+pub unsafe fn unused_ref_param_1(x: *const NonTrivial) {
+    &(*x);
+}
+pub unsafe fn unused_ptr_param_2(mut p: *const NonTrivial) {
+    &(*p);
 }
 pub static mut side_effect_counter: i32 = unsafe { 0 };
-pub unsafe fn bump_and_return_1() -> i32 {
+pub unsafe fn bump_and_return_3() -> i32 {
     side_effect_counter.prefix_inc();
     return side_effect_counter;
 }
@@ -30,59 +41,68 @@ unsafe fn main_0() -> i32 {
         unused_param_0(_x)
     });
     let mut y: i32 = 5;
-    y;
+    &(y);
     let mut z: i32 = {
-        y;
+        &(y);
         7
     };
     assert!(((z) == (7)));
     let mut counter: i32 = 0;
     let mut w: i32 = {
-        counter;
+        &(counter);
         counter = 3;
         counter
     };
     assert!(((w) == (3)));
     assert!(((counter) == (3)));
-    (unsafe { bump_and_return_1() });
+    &(unsafe { bump_and_return_3() });
     assert!(((side_effect_counter) == (1)));
     let mut v: i32 = {
-        (unsafe { bump_and_return_1() });
+        &(unsafe { bump_and_return_3() });
         99
     };
     assert!(((side_effect_counter) == (2)));
     assert!(((v) == (99)));
-    0;
-    (0);
-    (y);
-    (0);
-    (y);
+    &(0);
+    &(0);
+    &(y);
+    (&(0));
+    (&(y));
     let mut err: i32 = 0;
-    (err = 42);
+    (&(err = 42));
     assert!(((err) == (42)));
     let mut chosen: i32 = {
-        (err = 7);
+        &(err = 7);
         123
     };
     assert!(((err) == (7)));
     assert!(((chosen) == (123)));
-    bump_and_return_1;
+    &(bump_and_return_3);
     assert!(((side_effect_counter) == (2)));
-    (Some(bump_and_return_1));
+    &(Some(bump_and_return_3));
     assert!(((side_effect_counter) == (2)));
-    (std::mem::transmute::<Option<unsafe fn() -> i32>, Option<unsafe fn() -> i32>>(
-        (Some(bump_and_return_1)),
+    &(std::mem::transmute::<Option<unsafe fn() -> i32>, Option<unsafe fn() -> i32>>(
+        (Some(bump_and_return_3)),
     ));
     assert!(((side_effect_counter) == (2)));
     let mut storage: i32 = 11;
     let mut p: *mut i32 = (&mut storage as *mut i32);
-    (*p);
-    (p);
+    &(*p);
+    &(p);
     let mut arr: [i32; 3] = [1, 2, 3];
-    (arr[(1) as usize]);
+    &(arr[(1) as usize]);
     let mut h: Holder = Holder { field: 17 };
-    (h.field);
+    &(h.field);
     let mut hp: *mut Holder = (&mut h as *mut Holder);
-    ((*hp).field);
+    &((*hp).field);
+    let mut nt: NonTrivial = <NonTrivial>::default();
+    (unsafe {
+        let _x: *const NonTrivial = &nt as *const NonTrivial;
+        unused_ref_param_1(_x)
+    });
+    (unsafe {
+        let _p: *const NonTrivial = (&mut nt as *mut NonTrivial).cast_const();
+        unused_ptr_param_2(_p)
+    });
     return 0;
 }