Translate decompositions

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -3012,6 +3012,10 @@ std::string Converter::ConvertDeclRef(clang::Expr *expr,
 }
 
 bool Converter::VisitDeclRefExpr(clang::DeclRefExpr *expr) {
+  if (auto *binding = clang::dyn_cast<clang::BindingDecl>(expr->getDecl())) {
+    Convert(binding->getBinding());
+    return false;
+  }
   ConvertDeclRefValue(expr, expr->getDecl());
   return false;
 }

cpp2rust/converter/converter_lib.cpp

@@ -781,6 +781,13 @@ std::string GetNamedDeclAsString(const clang::NamedDecl *decl) {
     name = GetFunctionBaseName(fn);
   }
 
+  if (clang::isa<clang::DecompositionDecl>(decl)) {
+    return std::format(
+        "__decomp_{}",
+        type_mapping.try_emplace(GetID(decl), type_mapping.size())
+            .first->second);
+  }
+
   // Anonymous record or enum
   if (name.empty() && (clang::isa<clang::RecordDecl>(decl) ||
                        clang::isa<clang::FieldDecl>(decl) ||

tests/unit/out/refcount/structured_binding_array.rs

@@ -0,0 +1,34 @@
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::io::prelude::*;
+use std::io::{Read, Seek, Write};
+use std::os::fd::AsFd;
+use std::rc::{Rc, Weak};
+pub fn main() {
+    __cpp2rust_init_globals();
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let arr: Value<Box<[i32]>> = Rc::new(RefCell::new(Box::new([1, 2, 3])));
+    let __decomp_0: Value<Box<[i32]>> =
+        Rc::new(RefCell::new(Box::new(std::array::from_fn::<_, 3, _>(
+            |__i: usize| (*arr.borrow())[(__i) as usize],
+        ))));
+    (*__decomp_0.borrow_mut())[(0) as usize] = 10;
+    assert!(((*__decomp_0.borrow())[(0) as usize] == 10));
+    assert!(((*__decomp_0.borrow())[(1) as usize] == 2));
+    assert!(((*__decomp_0.borrow())[(2) as usize] == 3));
+    assert!(((*arr.borrow())[(0) as usize] == 1));
+    let __decomp_1: Ptr<i32> = (arr.as_pointer() as Ptr<i32>);
+    (__decomp_1).offset((0) as isize).write(7);
+    {
+        let _ptr = (__decomp_1).offset((2) as isize);
+        _ptr.write(_ptr.read() + ((__decomp_1).offset((1) as isize).read()))
+    };
+    assert!(((*arr.borrow())[(0) as usize] == 7));
+    assert!(((*arr.borrow())[(2) as usize] == 5));
+    return 0;
+}
+pub fn __cpp2rust_init_globals() {}

tests/unit/out/refcount/structured_binding_copy_ctor.rs

@@ -0,0 +1,90 @@
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::io::prelude::*;
+use std::io::{Read, Seek, Write};
+use std::os::fd::AsFd;
+use std::rc::{Rc, Weak};
+thread_local!(
+    pub static copies_0: Value<i32> = Rc::new(RefCell::new(0));
+);
+#[derive(VaArg, FnPtrArg, Default)]
+pub struct Counted {
+    pub x: Value<i32>,
+    pub y: Value<i32>,
+}
+impl Counted {
+    pub fn new(x: i32, y: i32) -> Self {
+        let x: Value<i32> = Rc::new(RefCell::new(x));
+        let y: Value<i32> = Rc::new(RefCell::new(y));
+        let __this: Value<Counted> = Rc::new(RefCell::new(Self {
+            x: Rc::new(RefCell::new((*x.borrow()))),
+            y: Rc::new(RefCell::new((*y.borrow()))),
+        }));
+        let this: Ptr<Counted> = __this.as_pointer();
+        Rc::try_unwrap(__this).ok().unwrap().into_inner()
+    }
+    pub fn copy_from(other: Ptr<Counted>) -> Self {
+        let __this: Value<Counted> = Rc::new(RefCell::new(Self {
+            x: Rc::new(RefCell::new(((*(*other.upgrade().deref()).x.borrow()) * 2))),
+            y: Rc::new(RefCell::new(((*(*other.upgrade().deref()).y.borrow()) * 2))),
+        }));
+        let this: Ptr<Counted> = __this.as_pointer();
+        (*copies_0.with(Value::clone).borrow_mut()).prefix_inc();
+        Rc::try_unwrap(__this).ok().unwrap().into_inner()
+    }
+}
+impl Clone for Counted {
+    fn clone(&self) -> Self {
+        let __src: Value<Counted> = Rc::new(RefCell::new(Counted {
+            x: self.x.clone(),
+            y: self.y.clone(),
+        }));
+        Counted::copy_from(__src.as_pointer())
+    }
+}
+impl ByteRepr for Counted {
+    fn byte_size() -> usize {
+        8
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.x.borrow()).to_bytes(&mut buf[0..4]);
+        (*self.y.borrow()).to_bytes(&mut buf[4..8]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            x: Rc::new(RefCell::new(<i32>::from_bytes(&buf[0..4]))),
+            y: Rc::new(RefCell::new(<i32>::from_bytes(&buf[4..8]))),
+        }
+    }
+}
+pub fn make_counted_1() -> Counted {
+    return Counted::new({ 5 }, { 6 });
+}
+pub fn main() {
+    __cpp2rust_init_globals();
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let s: Value<Counted> = Rc::new(RefCell::new(Counted::new({ 1 }, { 2 })));
+    let __decomp_2: Value<Counted> = Rc::new(RefCell::new(Counted::copy_from({ s.as_pointer() })));
+    assert!((copies_0.with(|rc| *rc.borrow()) == 1));
+    assert!(((*(*__decomp_2.borrow()).x.borrow()) == 2));
+    assert!(((*(*__decomp_2.borrow()).y.borrow()) == 4));
+    let __decomp_3: Ptr<Counted> = s.as_pointer();
+    assert!((copies_0.with(|rc| *rc.borrow()) == 1));
+    assert!(((*(*__decomp_3.upgrade().deref()).x.borrow()) == 1));
+    assert!(((*(*__decomp_3.upgrade().deref()).y.borrow()) == 2));
+    let __decomp_4: Ptr<Counted> = s.as_pointer();
+    assert!((copies_0.with(|rc| *rc.borrow()) == 1));
+    assert!(((*(*__decomp_4.upgrade().deref()).x.borrow()) == 1));
+    let __decomp_5: Value<Counted> = Rc::new(RefCell::new(({ make_counted_1() })));
+    assert!((copies_0.with(|rc| *rc.borrow()) == 1));
+    assert!(((*(*__decomp_5.borrow()).x.borrow()) == 5));
+    assert!(((*(*__decomp_5.borrow()).y.borrow()) == 6));
+    return 0;
+}
+pub fn __cpp2rust_init_globals() {
+    let _ = copies_0.with(|_| ());
+}

tests/unit/out/refcount/structured_binding_element_ctor.rs

@@ -0,0 +1,162 @@
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::io::prelude::*;
+use std::io::{Read, Seek, Write};
+use std::os::fd::AsFd;
+use std::rc::{Rc, Weak};
+thread_local!(
+    pub static copies_0: Value<i32> = Rc::new(RefCell::new(0));
+);
+thread_local!(
+    pub static moves_1: Value<i32> = Rc::new(RefCell::new(0));
+);
+#[derive(VaArg, FnPtrArg, Default)]
+pub struct Elem {
+    pub v: Value<i32>,
+}
+impl Elem {
+    pub fn new(v: i32) -> Self {
+        let v: Value<i32> = Rc::new(RefCell::new(v));
+        let __this: Value<Elem> = Rc::new(RefCell::new(Self {
+            v: Rc::new(RefCell::new((*v.borrow()))),
+        }));
+        let this: Ptr<Elem> = __this.as_pointer();
+        Rc::try_unwrap(__this).ok().unwrap().into_inner()
+    }
+    pub fn copy_from(other: Ptr<Elem>) -> Self {
+        let __this: Value<Elem> = Rc::new(RefCell::new(Self {
+            v: Rc::new(RefCell::new(
+                ((*(*other.upgrade().deref()).v.borrow()) + 100),
+            )),
+        }));
+        let this: Ptr<Elem> = __this.as_pointer();
+        (*copies_0.with(Value::clone).borrow_mut()).prefix_inc();
+        Rc::try_unwrap(__this).ok().unwrap().into_inner()
+    }
+    pub fn move_from(other: Ptr<Elem>) -> Self {
+        let __this: Value<Elem> = Rc::new(RefCell::new(Self {
+            v: Rc::new(RefCell::new(
+                ((*(*other.upgrade().deref()).v.borrow()) + 1000),
+            )),
+        }));
+        let this: Ptr<Elem> = __this.as_pointer();
+        (*(*other.upgrade().deref()).v.borrow_mut()) = -1_i32;
+        (*moves_1.with(Value::clone).borrow_mut()).prefix_inc();
+        Rc::try_unwrap(__this).ok().unwrap().into_inner()
+    }
+}
+impl Clone for Elem {
+    fn clone(&self) -> Self {
+        let __src: Value<Elem> = Rc::new(RefCell::new(Elem { v: self.v.clone() }));
+        Elem::copy_from(__src.as_pointer())
+    }
+}
+impl ByteRepr for Elem {
+    fn byte_size() -> usize {
+        4
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.v.borrow()).to_bytes(&mut buf[0..4]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            v: Rc::new(RefCell::new(<i32>::from_bytes(&buf[0..4]))),
+        }
+    }
+}
+#[derive(VaArg, FnPtrArg, Default)]
+pub struct Two {
+    pub a: Value<Elem>,
+    pub b: Value<Elem>,
+}
+impl Clone for Two {
+    fn clone(&self) -> Self {
+        let __this: Value<Two> = Rc::new(RefCell::new(Self {
+            a: Rc::new(RefCell::new(Elem::copy_from({ self.a.as_pointer() }))),
+            b: Rc::new(RefCell::new(Elem::copy_from({ self.b.as_pointer() }))),
+        }));
+        let this: Ptr<Two> = __this.as_pointer();
+        Rc::try_unwrap(__this).ok().unwrap().into_inner()
+    }
+}
+impl ByteRepr for Two {
+    fn byte_size() -> usize {
+        8
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.a.borrow()).to_bytes(&mut buf[0..4]);
+        (*self.b.borrow()).to_bytes(&mut buf[4..8]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            a: Rc::new(RefCell::new(<Elem>::from_bytes(&buf[0..4]))),
+            b: Rc::new(RefCell::new(<Elem>::from_bytes(&buf[4..8]))),
+        }
+    }
+}
+pub fn make_two_2() -> Two {
+    return Two {
+        a: Rc::new(RefCell::new(Elem::new({ 1 }))),
+        b: Rc::new(RefCell::new(Elem::new({ 2 }))),
+    };
+}
+pub fn main() {
+    __cpp2rust_init_globals();
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let t: Value<Two> = Rc::new(RefCell::new(Two {
+        a: Rc::new(RefCell::new(Elem::new({ 1 }))),
+        b: Rc::new(RefCell::new(Elem::new({ 2 }))),
+    }));
+    let base_copies: Value<i32> = Rc::new(RefCell::new(copies_0.with(|rc| *rc.borrow())));
+    let base_moves: Value<i32> = Rc::new(RefCell::new(moves_1.with(|rc| *rc.borrow())));
+    let __decomp_3: Value<Two> = Rc::new(RefCell::new((*t.borrow()).clone()));
+    assert!((copies_0.with(|rc| *rc.borrow()) == ((*base_copies.borrow()) + 2)));
+    assert!((moves_1.with(|rc| *rc.borrow()) == (*base_moves.borrow())));
+    assert!(((*(*(*__decomp_3.borrow()).a.borrow()).v.borrow()) == 101));
+    assert!(((*(*(*__decomp_3.borrow()).b.borrow()).v.borrow()) == 102));
+    let __decomp_4: Ptr<Two> = t.as_pointer();
+    assert!((copies_0.with(|rc| *rc.borrow()) == ((*base_copies.borrow()) + 2)));
+    assert!(((*(*(*__decomp_4.upgrade().deref()).a.borrow()).v.borrow()) == 1));
+    (*(*(*__decomp_4.upgrade().deref()).a.borrow()).v.borrow_mut()) = 50;
+    assert!(((*(*(*t.borrow()).a.borrow()).v.borrow()) == 50));
+    let __decomp_5: Value<Two> = Rc::new(RefCell::new((*t.borrow()).clone()));
+    assert!((moves_1.with(|rc| *rc.borrow()) == ((*base_moves.borrow()) + 2)));
+    assert!(((*(*(*__decomp_5.borrow()).a.borrow()).v.borrow()) == 1050));
+    assert!(((*(*(*__decomp_5.borrow()).b.borrow()).v.borrow()) == 1002));
+    assert!(((*(*(*t.borrow()).a.borrow()).v.borrow()) == -1_i32));
+    let before_copies: Value<i32> = Rc::new(RefCell::new(copies_0.with(|rc| *rc.borrow())));
+    let before_moves: Value<i32> = Rc::new(RefCell::new(moves_1.with(|rc| *rc.borrow())));
+    let __decomp_6: Value<Two> = Rc::new(RefCell::new(({ make_two_2() })));
+    assert!((copies_0.with(|rc| *rc.borrow()) == (*before_copies.borrow())));
+    assert!((moves_1.with(|rc| *rc.borrow()) == (*before_moves.borrow())));
+    assert!(((*(*(*__decomp_6.borrow()).a.borrow()).v.borrow()) == 1));
+    let p: Value<(Value<Elem>, Value<Elem>)> = Rc::new(RefCell::new((
+        Rc::new(RefCell::new(
+            Elem::new({ 7 }).try_into().expect("failed conversion"),
+        )),
+        Rc::new(RefCell::new(
+            Elem::new({ 8 }).try_into().expect("failed conversion"),
+        )),
+    )));
+    (*before_copies.borrow_mut()) = copies_0.with(|rc| *rc.borrow());
+    let __decomp_7: Value<(Value<Elem>, Value<Elem>)> = Rc::new(RefCell::new((
+        Rc::new(RefCell::new((*p.borrow()).0.borrow().clone())),
+        Rc::new(RefCell::new((*p.borrow()).1.borrow().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))
+    );
+    assert!(
+        ((*(*y.upgrade().deref()).v.borrow()) == ((*(*(*p.borrow()).1.borrow()).v.borrow()) + 100))
+    );
+    return 0;
+}
+pub fn __cpp2rust_init_globals() {
+    let _ = copies_0.with(|_| ());
+    let _ = moves_1.with(|_| ());
+}