Add more get overloads

Author: lucic71

rules/pair/src.cpp

@@ -64,3 +64,11 @@ template <typename T1, typename T2> const T1 &f19(const std::pair<T1, T2> &a0) {
 template <typename T1, typename T2> const T2 &f20(const std::pair<T1, T2> &a0) {
   return std::get<1>(a0);
 }
+
+template <typename T1, typename T2> T1 &&f21(std::pair<T1, T2> &&a0) {
+  return std::get<0>(std::move(a0));
+}
+
+template <typename T1, typename T2> T2 &&f22(std::pair<T1, T2> &&a0) {
+  return std::get<1>(std::move(a0));
+}

rules/pair/tgt_refcount.rs

@@ -84,3 +84,11 @@ fn f19<T1, T2>(a0: (Value<T1>, Value<T2>)) -> Ptr<T1> {
 fn f20<T1, T2>(a0: (Value<T1>, Value<T2>)) -> Ptr<T2> {
     a0.1.as_pointer()
 }
+
+fn f21<T1, T2>(a0: (Value<T1>, Value<T2>)) -> Ptr<T1> {
+    a0.0.as_pointer()
+}
+
+fn f22<T1, T2>(a0: (Value<T1>, Value<T2>)) -> Ptr<T2> {
+    a0.1.as_pointer()
+}

rules/pair/tgt_unsafe.rs

@@ -53,3 +53,11 @@ unsafe fn f19<T1, T2>(a0: &(T1, T2)) -> *const T1 {
 unsafe fn f20<T1, T2>(a0: &(T1, T2)) -> *const T2 {
     &a0.1
 }
+
+unsafe fn f21<T1, T2>(a0: &mut (T1, T2)) -> *mut T1 {
+    &mut a0.0
+}
+
+unsafe fn f22<T1, T2>(a0: &mut (T1, T2)) -> *mut T2 {
+    &mut a0.1
+}

tests/unit/out/refcount/structured_binding_element_ctor.rs

@@ -105,8 +105,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()) });
-    let y: Ptr<Elem> = ({ get_9(__decomp_7.as_pointer()) });
+    let x: Ptr<Elem> = (*__decomp_7.borrow()).0.as_pointer();
+    let y: Ptr<Elem> = (*__decomp_7.borrow()).1.as_pointer();
     assert!((copies_0.with(|rc| *rc.borrow()) == (before_copies + 2)));
     assert!(({ (*x.upgrade().deref()).v } == ({ (*(*p.borrow()).0.borrow()).v } + 100)));
     assert!(({ (*y.upgrade().deref()).v } == ({ (*(*p.borrow()).1.borrow()).v } + 100)));

tests/unit/out/refcount/structured_binding_pair.rs

@@ -19,27 +19,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()) });
-    let positive: Ptr<bool> = ({ get_3(__decomp_1.as_pointer()) });
+    let value: Ptr<i32> = (*__decomp_1.borrow()).0.as_pointer();
+    let positive: Ptr<bool> = (*__decomp_1.borrow()).1.as_pointer();
     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_4: Value<(Value<i32>, Value<i32>)> = Rc::new(RefCell::new((
+    let __decomp_2: 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()) });
-    let b: Ptr<i32> = ({ get_6(__decomp_4.as_pointer()) });
+    let a: Ptr<i32> = (*__decomp_2.borrow()).0.as_pointer();
+    let b: Ptr<i32> = (*__decomp_2.borrow()).1.as_pointer();
     a.write(10);
     assert!(((a.read()) == 10));
     assert!(((b.read()) == 2));
     assert!(((*(*p.borrow()).0.borrow()) == 1));
-    let __decomp_7: Ptr<(Value<i32>, Value<i32>)> = p.as_pointer();
-    let x: Ptr<i32> = (*__decomp_7.upgrade().deref()).0.as_pointer();
-    let y: Ptr<i32> = (*__decomp_7.upgrade().deref()).1.as_pointer();
+    let __decomp_3: Ptr<(Value<i32>, Value<i32>)> = p.as_pointer();
+    let x: Ptr<i32> = (*__decomp_3.upgrade().deref()).0.as_pointer();
+    let y: Ptr<i32> = (*__decomp_3.upgrade().deref()).1.as_pointer();
     x.write(3);
     {
         y.with_mut(|__v| *__v = *__v + 4)

tests/unit/out/unsafe/structured_binding_element_ctor.rs

@@ -88,8 +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) });
+    let x: *mut Elem = &mut __decomp_7.0;
+    let y: *mut Elem = &mut __decomp_7.1;
     assert!(
         ((*std::cell::LazyCell::force_mut(&mut *&raw mut copies_0)) == ((before_copies) + (2)))
     );

tests/unit/out/unsafe/structured_binding_pair.rs

@@ -17,21 +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) });
+    let value: *mut i32 = &mut __decomp_1.0;
+    let positive: *mut bool = &mut __decomp_1.1;
     assert!(((*value) == (5)));
     assert!(((*positive) as bool));
     let mut p: (i32, i32) = (1.into(), 2.into());
-    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) });
+    let mut __decomp_2: (i32, i32) = p.clone();
+    let a: *mut i32 = &mut __decomp_2.0;
+    let b: *mut i32 = &mut __decomp_2.1;
     (*a) = 10;
     assert!(((*a) == (10)));
     assert!(((*b) == (2)));
     assert!(((p.0) == (1)));
-    let __decomp_7: *mut (i32, i32) = &mut p;
-    let x: *mut i32 = &mut (*__decomp_7).0;
-    let y: *mut i32 = &mut (*__decomp_7).1;
+    let __decomp_3: *mut (i32, i32) = &mut p;
+    let x: *mut i32 = &mut (*__decomp_3).0;
+    let y: *mut i32 = &mut (*__decomp_3).1;
     (*x) = 3;
     (*y) += 4;
     assert!(((p.0) == (3)));