Add implicitely initialized Inner

Author: lucic71

tests/unit/in_class_field_initializer.cpp

@@ -10,13 +10,16 @@ struct S {
   int a = 1;
   char b = 2;
   Inner c = {};
+  Inner d;
 };
 
 int main() {
-  S s{};
+  S s;
   assert(s.a == 1);
   assert(s.b == 2);
   assert(s.c.x == 3);
   assert(s.c.y == 4);
+  assert(s.d.x == 3);
+  assert(s.d.y == 4);
   return 0;
 };

tests/unit/out/refcount/in_class_field_initializer.rs

@@ -48,13 +48,15 @@ pub struct S {
     pub a: Value<i32>,
     pub b: Value<u8>,
     pub c: Value<Inner>,
+    pub d: Value<Inner>,
 }
 impl Clone for S {
     fn clone(&self) -> Self {
         let mut this = Self {
             a: Rc::new(RefCell::new((*self.a.borrow()))),
             b: Rc::new(RefCell::new((*self.b.borrow()))),
             c: Rc::new(RefCell::new((*self.c.borrow()).clone())),
+            d: Rc::new(RefCell::new((*self.d.borrow()).clone())),
         };
         this
     }
@@ -68,41 +70,39 @@ impl Default for S {
                 x: Rc::new(RefCell::new(3)),
                 y: Rc::new(RefCell::new(4)),
             })),
+            d: <Value<Inner>>::default(),
         }
     }
 }
 impl ByteRepr for S {
     fn byte_size() -> usize {
-        16
+        24
     }
     fn to_bytes(&self, buf: &mut [u8]) {
         (*self.a.borrow()).to_bytes(&mut buf[0..4]);
         (*self.b.borrow()).to_bytes(&mut buf[4..5]);
         (*self.c.borrow()).to_bytes(&mut buf[8..16]);
+        (*self.d.borrow()).to_bytes(&mut buf[16..24]);
     }
     fn from_bytes(buf: &[u8]) -> Self {
         Self {
             a: Rc::new(RefCell::new(<i32>::from_bytes(&buf[0..4]))),
             b: Rc::new(RefCell::new(<u8>::from_bytes(&buf[4..5]))),
             c: Rc::new(RefCell::new(<Inner>::from_bytes(&buf[8..16]))),
+            d: Rc::new(RefCell::new(<Inner>::from_bytes(&buf[16..24]))),
         }
     }
 }
 pub fn main() {
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
-    let s: Value<S> = Rc::new(RefCell::new(S {
-        a: Rc::new(RefCell::new(1)),
-        b: Rc::new(RefCell::new(2_u8)),
-        c: Rc::new(RefCell::new(Inner {
-            x: Rc::new(RefCell::new(3)),
-            y: Rc::new(RefCell::new(4)),
-        })),
-    }));
+    let s: Value<S> = Rc::new(RefCell::new(<S>::default()));
     assert!(((*(*s.borrow()).a.borrow()) == 1));
     assert!((((*(*s.borrow()).b.borrow()) as i32) == 2));
     assert!(((*(*(*s.borrow()).c.borrow()).x.borrow()) == 3));
     assert!(((*(*(*s.borrow()).c.borrow()).y.borrow()) == 4));
+    assert!(((*(*(*s.borrow()).d.borrow()).x.borrow()) == 3));
+    assert!(((*(*(*s.borrow()).d.borrow()).y.borrow()) == 4));
     return 0;
 }

tests/unit/out/unsafe/in_class_field_initializer.rs

@@ -23,13 +23,15 @@ pub struct S {
     pub a: i32,
     pub b: libc::c_char,
     pub c: Inner,
+    pub d: Inner,
 }
 impl Default for S {
     fn default() -> Self {
         S {
             a: 1,
             b: (2 as libc::c_char),
             c: Inner { x: 3, y: 4 },
+            d: <Inner>::default(),
         }
     }
 }
@@ -39,14 +41,12 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut s: S = S {
-        a: 1,
-        b: (2 as libc::c_char),
-        c: Inner { x: 3, y: 4 },
-    };
+    let mut s: S = <S>::default();
     assert!(((s.a) == (1)));
     assert!(((s.b as i32) == (2)));
     assert!(((s.c.x) == (3)));
     assert!(((s.c.y) == (4)));
+    assert!(((s.d.x) == (3)));
+    assert!(((s.d.y) == (4)));
     return 0;
 }