Convert implicit values of decomposition

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -602,6 +602,15 @@ bool Converter::VisitVarDecl(clang::VarDecl *decl) {
   }
   EmitScopedDestructor(decl);
 
+  if (auto *decomp = clang::dyn_cast<clang::DecompositionDecl>(decl)) {
+    for (auto *binding : decomp->bindings()) {
+      if (auto *holding = binding->getHoldingVar()) {
+        StrCat(token::kSemiColon);
+        VisitVarDecl(holding);
+      }
+    }
+  }
+
   return false;
 }
 

tests/unit/out/refcount/structured_binding_element_ctor.rs

@@ -147,6 +147,8 @@ fn main_0() -> i32 {
         Rc::new(RefCell::new((*p.borrow()).0.borrow().clone())),
         Rc::new(RefCell::new((*p.borrow()).1.borrow().clone())),
     )));
+    let x: Ptr<Elem> = ({ get_8((__decomp_7.as_pointer()).clone()) });
+    let y: Ptr<Elem> = ({ get_9((__decomp_7.as_pointer()).clone()) });
     assert!((copies_0.with(|rc| *rc.borrow()) == ((*before_copies.borrow()) + 2)));
     assert!(
         ((*(*x.upgrade().deref()).v.borrow()) == ((*(*(*p.borrow()).0.borrow()).v.borrow()) + 100))

tests/unit/out/refcount/structured_binding_pair.rs

@@ -24,21 +24,27 @@ pub fn main() {
 fn main_0() -> i32 {
     let __decomp_1: Value<(Value<i32>, Value<bool>)> =
         Rc::new(RefCell::new(({ make_std_pair_0(5) })));
+    let value: Ptr<i32> = ({ get_2((__decomp_1.as_pointer()).clone()) });
+    let positive: Ptr<bool> = ({ get_3((__decomp_1.as_pointer()).clone()) });
     assert!(((value.read()) == 5));
     assert!(((positive.read()) as bool));
     let p: Value<(Value<i32>, Value<i32>)> = Rc::new(RefCell::new((
         Rc::new(RefCell::new(1.try_into().expect("failed conversion"))),
         Rc::new(RefCell::new(2.try_into().expect("failed conversion"))),
     )));
-    let __decomp_2: Value<(Value<i32>, Value<i32>)> = Rc::new(RefCell::new((
+    let __decomp_4: Value<(Value<i32>, Value<i32>)> = Rc::new(RefCell::new((
         Rc::new(RefCell::new((*p.borrow()).0.borrow().clone())),
         Rc::new(RefCell::new((*p.borrow()).1.borrow().clone())),
     )));
+    let a: Ptr<i32> = ({ get_5((__decomp_4.as_pointer()).clone()) });
+    let b: Ptr<i32> = ({ get_6((__decomp_4.as_pointer()).clone()) });
     a.write(10);
     assert!(((a.read()) == 10));
     assert!(((b.read()) == 2));
     assert!(((*(*p.borrow()).0.borrow()) == 1));
-    let __decomp_3: Ptr<(Value<i32>, Value<i32>)> = p.as_pointer();
+    let __decomp_7: Ptr<(Value<i32>, Value<i32>)> = p.as_pointer();
+    let x: Ptr<i32> = ({ get_8((__decomp_7).clone()) });
+    let y: Ptr<i32> = ({ get_9((__decomp_7).clone()) });
     x.write(3);
     {
         let _ptr = y.clone();

tests/unit/out/unsafe/structured_binding_element_ctor.rs

@@ -88,6 +88,8 @@ unsafe fn main_0() -> i32 {
     let mut p: (Elem, Elem) = (Elem::new({ 7 }).into(), Elem::new({ 8 }).into());
     before_copies = (*std::cell::LazyCell::force_mut(&mut *&raw mut copies_0));
     let mut __decomp_7: (Elem, Elem) = p.clone();
+    let x: *mut Elem = (unsafe { get_8(&mut __decomp_7) });
+    let y: *mut Elem = (unsafe { get_9(&mut __decomp_7) });
     assert!(
         ((*std::cell::LazyCell::force_mut(&mut *&raw mut copies_0)) == ((before_copies) + (2)))
     );

tests/unit/out/unsafe/structured_binding_pair.rs

@@ -17,15 +17,21 @@ pub fn main() {
 }
 unsafe fn main_0() -> i32 {
     let mut __decomp_1: (i32, bool) = (unsafe { make_std_pair_0(5) });
+    let value: *mut i32 = (unsafe { get_2(&mut __decomp_1) });
+    let positive: *mut bool = (unsafe { get_3(&mut __decomp_1) });
     assert!(((*value) == (5)));
     assert!(((*positive) as bool));
     let mut p: (i32, i32) = (1.into(), 2.into());
-    let mut __decomp_2: (i32, i32) = p.clone();
+    let mut __decomp_4: (i32, i32) = p.clone();
+    let a: *mut i32 = (unsafe { get_5(&mut __decomp_4) });
+    let b: *mut i32 = (unsafe { get_6(&mut __decomp_4) });
     (*a) = 10;
     assert!(((*a) == (10)));
     assert!(((*b) == (2)));
     assert!(((p.0) == (1)));
-    let __decomp_3: *mut (i32, i32) = &mut p;
+    let __decomp_7: *mut (i32, i32) = &mut p;
+    let x: *mut i32 = (unsafe { get_8(__decomp_7) });
+    let y: *mut i32 = (unsafe { get_9(__decomp_7) });
     (*x) = 3;
     (*y) += 4;
     assert!(((p.0) == (3)));