Update tests

Author: lucic71

tests/unit/out/unsafe/bool_condition_logical_c.rs

@@ -46,7 +46,7 @@ unsafe fn main_0() -> i32 {
     let mut p: *mut i32 = (&mut storage as *mut i32);
     let mut np: *mut i32 = std::ptr::null_mut();
     let mut u: u32 = 4_u32;
-    let mut code: Code = Code::from((Code::CODE_OK as i32));
+    let mut code: Code = Code::CODE_OK;
     if ((((n != 0) && (!(p).is_null())) as i32) != 0) {
         assert!((1 != 0));
     }

tests/unit/out/unsafe/c_struct.rs

@@ -82,15 +82,15 @@ unsafe fn main_0() -> i32 {
     assert!((((((*b.next).value) == (1)) as i32) != 0));
     let mut c: Container = Container {
         inner: Inner { a: 5, b: 6 },
-        color: Color::from((Color::GREEN as i32)),
+        color: Color::GREEN,
         count: 42,
     };
     assert!(((((c.inner.a) == (5)) as i32) != 0));
     assert!(((((c.inner.b) == (6)) as i32) != 0));
     assert!(((((c.color as u32) == ((Color::GREEN as i32) as u32)) as i32) != 0));
     assert!(((((c.count) == (42)) as i32) != 0));
     let mut c2: Container = <Container>::default();
-    c2.color = Color::from((Color::BLUE as i32));
+    c2.color = Color::BLUE;
     assert!(((((c2.color as u32) == (2_u32)) as i32) != 0));
     return 0;
 }

tests/unit/out/unsafe/enum_int_interop.rs

@@ -66,6 +66,8 @@ pub struct Entry {
     pub color: Color,
     pub opt: Option,
 }
+// SAFETY: preserves unsafe C semantics; thread-safety is not enforced
+unsafe impl Sync for Entry {}
 pub static mut global_color: Color = Color::GREEN;
 pub static mut global_opt: Option = Option::OPT_B;
 pub static mut global_tag: Tag = Tag::TAG_TWO;

tests/unit/out/unsafe/enum_int_interop_c.rs

@@ -66,6 +66,8 @@ pub struct Entry {
     pub color: Color,
     pub opt: Option,
 }
+// SAFETY: preserves unsafe C semantics; thread-safety is not enforced
+unsafe impl Sync for Entry {}
 pub static mut global_color: Color = Color::GREEN;
 pub static mut global_opt: Option = Option::OPT_B;
 pub static mut global_tag: Tag = Tag::TAG_TWO;

tests/unit/out/unsafe/union_tagged_many_arms.rs

@@ -56,24 +56,24 @@ pub fn main() {
 }
 unsafe fn main_0() -> i32 {
     let mut a: Slot = <Slot>::default();
-    a.tag = Tag::from((Tag::T_NUM_S as i32));
+    a.tag = Tag::T_NUM_S;
     a.payload.signed_n = (-7_i32 as i64);
     assert!(((((a.payload.signed_n) == (-7_i32 as i64)) as i32) != 0));
     let mut b: Slot = <Slot>::default();
-    b.tag = Tag::from((Tag::T_NUM_U as i32));
+    b.tag = Tag::T_NUM_U;
     b.payload.unsigned_n = 3735928559_u64;
     assert!(((((b.payload.unsigned_n) == (3735928559_u64)) as i32) != 0));
     let mut c: Slot = <Slot>::default();
-    c.tag = Tag::from((Tag::T_TEXT as i32));
+    c.tag = Tag::T_TEXT;
     c.payload.text = b"hello\0".as_ptr().cast_mut().cast_const();
     assert!((((((*c.payload.text.offset((0) as isize)) as i32) == ('h' as i32)) as i32) != 0));
     let mut d: Slot = <Slot>::default();
-    d.tag = Tag::from((Tag::T_FLOAT as i32));
+    d.tag = Tag::T_FLOAT;
     d.payload.f = 1.5E+0;
     assert!(((((d.payload.f) == (1.5E+0)) as i32) != 0));
     let mut x: i32 = 0;
     let mut e: Slot = <Slot>::default();
-    e.tag = Tag::from((Tag::T_REF as i32));
+    e.tag = Tag::T_REF;
     e.payload.handle = ((&mut x as *mut i32) as *mut i32 as *mut ::libc::c_void);
     assert!(
         ((((e.payload.handle) == ((&mut x as *mut i32) as *mut i32 as *mut ::libc::c_void))

tests/unit/out/unsafe/union_tagged_simple.rs

@@ -51,13 +51,13 @@ pub fn main() {
 unsafe fn main_0() -> i32 {
     let mut dummy: i32 = 0;
     let mut m1: Event = <Event>::default();
-    m1.kind = Kind::from((Kind::KIND_DONE as i32));
+    m1.kind = Kind::KIND_DONE;
     m1.handle = ((&mut dummy as *mut i32) as *mut i32 as *mut ::libc::c_void);
     m1.payload.code = 42;
     assert!(((((m1.kind as u32) == ((Kind::KIND_DONE as i32) as u32)) as i32) != 0));
     assert!(((((m1.payload.code) == (42)) as i32) != 0));
     let mut m2: Event = <Event>::default();
-    m2.kind = Kind::from((Kind::KIND_NONE as i32));
+    m2.kind = Kind::KIND_NONE;
     m2.handle = ((&mut dummy as *mut i32) as *mut i32 as *mut ::libc::c_void);
     m2.payload.obj = ((&mut dummy as *mut i32) as *mut i32 as *mut ::libc::c_void);
     assert!(

tests/unit/out/unsafe/union_tagged_struct_arms.rs

@@ -80,7 +80,7 @@ unsafe fn main_0() -> i32 {
         b"c\0".as_ptr().cast_mut(),
     ];;
     let mut p_list: Branch = <Branch>::default();
-    p_list.choice = Choice::from((Choice::C_LIST as i32));
+    p_list.choice = Choice::C_LIST;
     p_list.index = 0;
     p_list.v.list.items = items.as_mut_ptr();
     p_list.v.list.count = 3_i64;
@@ -92,15 +92,15 @@ unsafe fn main_0() -> i32 {
             != 0)
     );
     let mut p_letters: Branch = <Branch>::default();
-    p_letters.choice = Choice::from((Choice::C_LETTERS as i32));
+    p_letters.choice = Choice::C_LETTERS;
     p_letters.index = 1;
     p_letters.v.letters.lo = ('a' as i32);
     p_letters.v.letters.hi = ('z' as i32);
     p_letters.v.letters.curr = ('m' as i32);
     p_letters.v.letters.step = 1_u8;
     assert!((((((p_letters.v.letters.hi) - (p_letters.v.letters.lo)) == (25)) as i32) != 0));
     let mut p_integers: Branch = <Branch>::default();
-    p_integers.choice = Choice::from((Choice::C_INTEGERS as i32));
+    p_integers.choice = Choice::C_INTEGERS;
     p_integers.index = 2;
     p_integers.v.integers.lo = 1_i64;
     p_integers.v.integers.hi = 100_i64;

tests/unit/out/unsafe/union_void_ptr_sized_deref.rs

@@ -74,23 +74,23 @@ unsafe fn main_0() -> i32 {
     let mut buf32: i32 = 0;
     let mut buf16: i16 = 0_i16;
     let mut s: Sink = <Sink>::default();
-    s.width = Width::from((Width::W_64 as i32));
+    s.width = Width::W_64;
     s.out.handle = ((&mut buf64 as *mut i64) as *mut i64 as *mut ::libc::c_void);
     (unsafe {
         let _s: *mut Sink = (&mut s as *mut Sink);
         let _count: i64 = 1234605616436508552_i64;
         write_count_0(_s, _count)
     });
     assert!(((((buf64) == (1234605616436508552_i64)) as i32) != 0));
-    s.width = Width::from((Width::W_32 as i32));
+    s.width = Width::W_32;
     s.out.handle = ((&mut buf32 as *mut i32) as *mut i32 as *mut ::libc::c_void);
     (unsafe {
         let _s: *mut Sink = (&mut s as *mut Sink);
         let _count: i64 = 305419896_i64;
         write_count_0(_s, _count)
     });
     assert!(((((buf32) == (305419896)) as i32) != 0));
-    s.width = Width::from((Width::W_16 as i32));
+    s.width = Width::W_16;
     s.out.handle = ((&mut buf16 as *mut i16) as *mut i16 as *mut ::libc::c_void);
     (unsafe {
         let _s: *mut Sink = (&mut s as *mut Sink);