Fix hoisted initialization outside goto_block

Author: lucic71

cpp2rust/converter/models/converter_refcount.cpp

@@ -726,7 +726,7 @@ void ConverterRefCount::EmitHoistedInArmAssignment(clang::VarDecl *decl) {
   PushConversionKind push(*this, ConversionKind::Unboxed);
   StrCat(token::kStar, GetNamedDeclAsString(decl), ".borrow_mut()",
          token::kAssign);
-  Convert(decl->getInit());
+  StrCat(ConvertFreshRValue(decl->getInit(), decl->getType()));
   StrCat(token::kSemiColon);
 }
 

tests/unit/goto_cleanup.c

@@ -41,12 +41,32 @@ static int from_switch(int n) {
   return ret;
 }
 
+struct wrapper {
+  int *item;
+};
+
+static int via_pointer(struct wrapper *w, int fail) {
+  int ret = 0;
+  int *item = w->item;
+  if (fail) {
+    ret = -1;
+    goto out;
+  }
+  ret = *item;
+out:
+  return ret;
+}
+
 int main(void) {
   assert(early(-1) == -1);
   assert(early(5) == 100);
   assert(from_loop(2) == 999);
   assert(from_loop(10) == 7);
   assert(from_switch(1) == 10);
   assert(from_switch(2) == 999);
+  int value = 42;
+  struct wrapper w = {&value};
+  assert(via_pointer(&w, 0) == 42);
+  assert(via_pointer(&w, 1) == -1);
   return 0;
 }

tests/unit/out/refcount/goto_cleanup.rs

@@ -77,6 +77,52 @@ pub fn from_switch_2(n: i32) -> i32 {
     });
     panic!("ub: non-void function does not return a value")
 }
+#[derive(Default)]
+pub struct wrapper {
+    pub item: Value<Ptr<i32>>,
+}
+impl Clone for wrapper {
+    fn clone(&self) -> Self {
+        Self {
+            item: Rc::new(RefCell::new((*self.item.borrow()).clone())),
+        }
+    }
+}
+impl ByteRepr for wrapper {
+    fn byte_size() -> usize {
+        8
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.item.borrow()).to_bytes(&mut buf[0..8]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            item: Rc::new(RefCell::new(<Ptr<i32>>::from_bytes(&buf[0..8]))),
+        }
+    }
+}
+pub fn via_pointer_3(w: Ptr<wrapper>, fail: i32) -> i32 {
+    let w: Value<Ptr<wrapper>> = Rc::new(RefCell::new(w));
+    let fail: Value<i32> = Rc::new(RefCell::new(fail));
+    let ret: Value<i32> = <Value<i32>>::default();
+    let item: Value<Ptr<i32>> = Rc::new(RefCell::new(Ptr::<i32>::null()));
+    goto_block!({
+        '__entry: {
+            *ret.borrow_mut() = 0;
+            *item.borrow_mut() = (*(*(*w.borrow()).upgrade().deref()).item.borrow()).clone();
+            if ((*fail.borrow()) != 0) {
+                (*ret.borrow_mut()) = -1_i32;
+                goto!('out);
+            }
+            let __rhs = ((*item.borrow()).read());
+            (*ret.borrow_mut()) = __rhs;
+        }
+        'out: {
+            return (*ret.borrow());
+        }
+    });
+    panic!("ub: non-void function does not return a value")
+}
 pub fn main() {
     std::process::exit(main_0());
 }
@@ -87,5 +133,11 @@ fn main_0() -> i32 {
     assert!((((({ from_loop_1(10,) }) == 7) as i32) != 0));
     assert!((((({ from_switch_2(1,) }) == 10) as i32) != 0));
     assert!((((({ from_switch_2(2,) }) == 999) as i32) != 0));
+    let value: Value<i32> = Rc::new(RefCell::new(42));
+    let w: Value<wrapper> = Rc::new(RefCell::new(wrapper {
+        item: Rc::new(RefCell::new((value.as_pointer()))),
+    }));
+    assert!((((({ via_pointer_3((w.as_pointer()), 0,) }) == 42) as i32) != 0));
+    assert!((((({ via_pointer_3((w.as_pointer()), 1,) }) == -1_i32) as i32) != 0));
     return 0;
 }

tests/unit/out/unsafe/goto_cleanup.rs

@@ -73,6 +73,30 @@ pub unsafe fn from_switch_2(mut n: i32) -> i32 {
     });
     panic!("ub: non-void function does not return a value")
 }
+#[repr(C)]
+#[derive(Copy, Clone, Default)]
+pub struct wrapper {
+    pub item: *mut i32,
+}
+pub unsafe fn via_pointer_3(mut w: *mut wrapper, mut fail: i32) -> i32 {
+    let mut ret: i32 = 0_i32;
+    let mut item: *mut i32 = std::ptr::null_mut();
+    goto_block!({
+        '__entry: {
+            ret = 0;
+            item = (*w).item;
+            if (fail != 0) {
+                ret = -1_i32;
+                goto!('out);
+            }
+            ret = (*item);
+        }
+        'out: {
+            return ret;
+        }
+    });
+    panic!("ub: non-void function does not return a value")
+}
 pub fn main() {
     unsafe {
         std::process::exit(main_0() as i32);
@@ -85,5 +109,11 @@ unsafe fn main_0() -> i32 {
     assert!(((((unsafe { from_loop_1(10,) }) == (7)) as i32) != 0));
     assert!(((((unsafe { from_switch_2(1,) }) == (10)) as i32) != 0));
     assert!(((((unsafe { from_switch_2(2,) }) == (999)) as i32) != 0));
+    let mut value: i32 = 42;
+    let mut w: wrapper = wrapper {
+        item: (&mut value as *mut i32),
+    };
+    assert!(((((unsafe { via_pointer_3((&mut w as *mut wrapper), 0,) }) == (42)) as i32) != 0));
+    assert!(((((unsafe { via_pointer_3((&mut w as *mut wrapper), 1,) }) == (-1_i32)) as i32) != 0));
     return 0;
 }