Add test where old PtrValueIter did not work

Author: lucic71

rules/vector/tgt_refcount.rs

@@ -55,7 +55,7 @@ fn f92<T1: TryFrom<T2>, T2: Clone + ByteRepr, T3: CppInputIterator<T2>>(a0: T3,
     let mut __v = Vec::new();
     let mut __it = a0;
     while __it != a1 {
-        __v.push(T1::try_from(__it.iter_deref().read()).ok().unwrap());
+        __v.push(<T1>::try_from(__it.iter_deref().read()).ok().unwrap());
         __it.iter_inc();
     }
     __v

rules/vector/tgt_unsafe.rs

@@ -129,7 +129,7 @@ unsafe fn f92<T1: TryFrom<T2>, T2: Clone, T3: UnsafeCppInputIterator<T2>>(a0: T3
     let mut __v = Vec::new();
     let mut __it = a0;
     while __it != a1 {
-        __v.push(T1::try_from((*__it.iter_deref()).clone()).ok().unwrap());
+        __v.push(<T1>::try_from((*__it.iter_deref()).clone()).ok().unwrap());
         __it.iter_inc();
     }
     __v

tests/unit/out/refcount/push_emplace_back.rs

@@ -51,7 +51,7 @@ pub fn push_local_from_field_1(mut jpg: Ptr<JPEGData>, mut cond: bool) {
             let mut __v = Vec::new();
             let mut __it = (head.as_pointer() as Ptr<u8>);
             while __it != (head.as_pointer() as Ptr<u8>).offset((3) as isize) {
-                __v.push(u8::try_from(__it.iter_deref().read()).ok().unwrap());
+                __v.push(<u8>::try_from(__it.iter_deref().read()).ok().unwrap());
                 __it.iter_inc();
             }
             __v
@@ -82,7 +82,7 @@ pub fn emplace_local_from_field_4(mut jpg: Ptr<JPEGData>, mut cond: bool) {
             let mut __v = Vec::new();
             let mut __it = (head.as_pointer() as Ptr<u8>);
             while __it != (head.as_pointer() as Ptr<u8>).offset((3) as isize) {
-                __v.push(u8::try_from(__it.iter_deref().read()).ok().unwrap());
+                __v.push(<u8>::try_from(__it.iter_deref().read()).ok().unwrap());
                 __it.iter_inc();
             }
             __v

tests/unit/out/refcount/vector_iter_range_ctor.rs

@@ -16,7 +16,7 @@ fn main_0() -> i32 {
         let mut __v = Vec::new();
         let mut __it = (src.as_pointer() as Ptr<u32>);
         while __it != (src.as_pointer() as Ptr<u32>).offset((3) as isize) {
-            __v.push(u32::try_from(__it.iter_deref().read()).ok().unwrap());
+            __v.push(<u32>::try_from(__it.iter_deref().read()).ok().unwrap());
             __it.iter_inc();
         }
         __v
@@ -27,7 +27,7 @@ fn main_0() -> i32 {
         let mut __v = Vec::new();
         let mut __it = (src.as_pointer() as Ptr<u32>);
         while __it != (src.as_pointer() as Ptr<u32>).offset((3) as isize) {
-            __v.push(u64::try_from(__it.iter_deref().read()).ok().unwrap());
+            __v.push(<u64>::try_from(__it.iter_deref().read()).ok().unwrap());
             __it.iter_inc();
         }
         __v
@@ -38,7 +38,7 @@ fn main_0() -> i32 {
         let mut __v = Vec::new();
         let mut __it = (src.as_pointer() as Ptr<u32>);
         while __it != (src.as_pointer() as Ptr<u32>).offset((3) as isize) {
-            __v.push(i32::try_from(__it.iter_deref().read()).ok().unwrap());
+            __v.push(<i32>::try_from(__it.iter_deref().read()).ok().unwrap());
             __it.iter_inc();
         }
         __v
@@ -50,7 +50,7 @@ fn main_0() -> i32 {
         let mut __v = Vec::new();
         let mut __it = (src1.as_pointer() as Ptr<u32>);
         while __it != (src1.as_pointer() as Ptr<u32>).to_end() {
-            __v.push(u32::try_from(__it.iter_deref().read()).ok().unwrap());
+            __v.push(<u32>::try_from(__it.iter_deref().read()).ok().unwrap());
             __it.iter_inc();
         }
         __v
@@ -65,13 +65,111 @@ fn main_0() -> i32 {
         let mut __v = Vec::new();
         let mut __it = (start).clone();
         while __it != start.offset((len) as isize) {
-            __v.push(u8::try_from(__it.iter_deref().read()).ok().unwrap());
+            __v.push(<u8>::try_from(__it.iter_deref().read()).ok().unwrap());
             __it.iter_inc();
         }
         __v
     };
     assert!((v5.len() == 5_usize));
     assert!(((v5[0_usize] as i32) == 10) && ((v5[4_usize] as i32) == 50));
+    let m: Value<Map<i32, (Value<i32>, Value<i32>)>> = Rc::new(RefCell::new(Map::new()));
+    (m.as_pointer() as Ptr<Map<i32, (Value<i32>, Value<i32>)>>)
+        .with_mut(|__m: &mut Map<i32, (Value<i32>, Value<i32>)>| {
+            __m.get_or_insert_with(1.clone(), || {
+                (
+                    Rc::new(RefCell::new(1)),
+                    Rc::new(RefCell::new(<i32>::default())),
+                )
+            })
+            .borrow()
+            .1
+            .as_pointer()
+        })
+        .write(10);
+    (m.as_pointer() as Ptr<Map<i32, (Value<i32>, Value<i32>)>>)
+        .with_mut(|__m: &mut Map<i32, (Value<i32>, Value<i32>)>| {
+            __m.get_or_insert_with(2.clone(), || {
+                (
+                    Rc::new(RefCell::new(2)),
+                    Rc::new(RefCell::new(<i32>::default())),
+                )
+            })
+            .borrow()
+            .1
+            .as_pointer()
+        })
+        .write(20);
+    (m.as_pointer() as Ptr<Map<i32, (Value<i32>, Value<i32>)>>)
+        .with_mut(|__m: &mut Map<i32, (Value<i32>, Value<i32>)>| {
+            __m.get_or_insert_with(3.clone(), || {
+                (
+                    Rc::new(RefCell::new(3)),
+                    Rc::new(RefCell::new(<i32>::default())),
+                )
+            })
+            .borrow()
+            .1
+            .as_pointer()
+        })
+        .write(30);
+    let v6: Value<Vec<(Value<i32>, Value<i32>)>> = Rc::new(RefCell::new({
+        let mut __v = Vec::new();
+        let mut __it = (m.as_pointer() as Ptr<Map<i32, (Value<i32>, Value<i32>)>>)
+            .with(|__m: &Map<i32, (Value<i32>, Value<i32>)>| __m.begin());
+        while __it
+            != (m.as_pointer() as Ptr<Map<i32, (Value<i32>, Value<i32>)>>)
+                .with(|__m: &Map<i32, (Value<i32>, Value<i32>)>| __m.end())
+        {
+            __v.push(
+                <(Value<i32>, Value<i32>)>::try_from(__it.iter_deref().read())
+                    .ok()
+                    .unwrap(),
+            );
+            __it.iter_inc();
+        }
+        __v
+    }));
+    assert!(((*v6.borrow()).len() == 3_usize));
+    assert!(
+        ((*(*v6.borrow())[0_usize].0.borrow()) == 1)
+            && ((*(*v6.borrow())[0_usize].1.borrow()) == 10)
+    );
+    assert!(
+        ((*(*v6.borrow())[2_usize].0.borrow()) == 3)
+            && ((*(*v6.borrow())[2_usize].1.borrow()) == 30)
+    );
+    {
+        let start_idx = <RandomAccessIterator<(Value<i32>, Value<i32>)>>::from(
+            RandomAccessIterator::Vec((v6.as_pointer() as Ptr<(Value<i32>, Value<i32>)>))
+                .iter_add(1_isize),
+        )
+        .vec_ptr()
+        .get_offset();
+        let mut temp_vec: Vec<(Value<i32>, Value<i32>)> = Vec::new();
+        let mut __it = (m.as_pointer() as Ptr<Map<i32, (Value<i32>, Value<i32>)>>)
+            .with(|__m: &Map<i32, (Value<i32>, Value<i32>)>| __m.begin());
+        while __it
+            != (m.as_pointer() as Ptr<Map<i32, (Value<i32>, Value<i32>)>>)
+                .with(|__m: &Map<i32, (Value<i32>, Value<i32>)>| __m.end())
+        {
+            temp_vec.push(__it.iter_deref().read());
+            __it.iter_inc();
+        }
+        (v6.as_pointer() as Ptr<Vec<(Value<i32>, Value<i32>)>>).with_mut(
+            |v: &mut Vec<(Value<i32>, Value<i32>)>| {
+                v.splice(start_idx..start_idx, temp_vec);
+            },
+        );
+        RandomAccessIterator::Vec(
+            (v6.as_pointer() as Ptr<Vec<(Value<i32>, Value<i32>)>>).decay() + start_idx,
+        )
+    };
+    assert!(((*v6.borrow()).len() == 6_usize));
+    assert!(
+        (((*(*v6.borrow())[1_usize].0.borrow()) == 1)
+            && ((*(*v6.borrow())[3_usize].0.borrow()) == 3))
+            && ((*(*v6.borrow())[4_usize].0.borrow()) == 2)
+    );
     return 0;
 }
 pub fn __cpp2rust_init_globals() {}

tests/unit/out/refcount/vector_with_allocator.rs

@@ -252,7 +252,7 @@ fn main_0() -> i32 {
         let mut __v = Vec::new();
         let mut __it = (src.as_pointer() as Ptr<u32>);
         while __it != (src.as_pointer() as Ptr<u32>).offset((3) as isize) {
-            __v.push(u32::try_from(__it.iter_deref().read()).ok().unwrap());
+            __v.push(<u32>::try_from(__it.iter_deref().read()).ok().unwrap());
             __it.iter_inc();
         }
         __v
@@ -263,7 +263,7 @@ fn main_0() -> i32 {
         let mut __v = Vec::new();
         let mut __it = (src.as_pointer() as Ptr<u32>);
         while __it != (src.as_pointer() as Ptr<u32>).offset((3) as isize) {
-            __v.push(u64::try_from(__it.iter_deref().read()).ok().unwrap());
+            __v.push(<u64>::try_from(__it.iter_deref().read()).ok().unwrap());
             __it.iter_inc();
         }
         __v
@@ -274,7 +274,7 @@ fn main_0() -> i32 {
         let mut __v = Vec::new();
         let mut __it = (src.as_pointer() as Ptr<u32>);
         while __it != (src.as_pointer() as Ptr<u32>).offset((3) as isize) {
-            __v.push(i32::try_from(__it.iter_deref().read()).ok().unwrap());
+            __v.push(<i32>::try_from(__it.iter_deref().read()).ok().unwrap());
             __it.iter_inc();
         }
         __v
@@ -286,7 +286,7 @@ fn main_0() -> i32 {
         let mut __v = Vec::new();
         let mut __it = (src1.as_pointer() as Ptr<u32>);
         while __it != (src1.as_pointer() as Ptr<u32>).to_end() {
-            __v.push(u32::try_from(__it.iter_deref().read()).ok().unwrap());
+            __v.push(<u32>::try_from(__it.iter_deref().read()).ok().unwrap());
             __it.iter_inc();
         }
         __v
@@ -301,7 +301,7 @@ fn main_0() -> i32 {
         let mut __v = Vec::new();
         let mut __it = (start).clone();
         while __it != start.offset((len) as isize) {
-            __v.push(u8::try_from(__it.iter_deref().read()).ok().unwrap());
+            __v.push(<u8>::try_from(__it.iter_deref().read()).ok().unwrap());
             __it.iter_inc();
         }
         __v

tests/unit/out/unsafe/push_emplace_back.rs

@@ -42,7 +42,7 @@ pub unsafe fn push_local_from_field_1(mut jpg: *mut JPEGData, mut cond: bool) {
             let mut __v = Vec::new();
             let mut __it = head.as_mut_ptr();
             while __it != head.as_mut_ptr().offset((3) as isize) {
-                __v.push(u8::try_from((*__it.iter_deref()).clone()).ok().unwrap());
+                __v.push(<u8>::try_from((*__it.iter_deref()).clone()).ok().unwrap());
                 __it.iter_inc();
             }
             __v
@@ -72,7 +72,7 @@ pub unsafe fn emplace_local_from_field_4(mut jpg: *mut JPEGData, mut cond: bool)
             let mut __v = Vec::new();
             let mut __it = head.as_mut_ptr();
             while __it != head.as_mut_ptr().offset((3) as isize) {
-                __v.push(u8::try_from((*__it.iter_deref()).clone()).ok().unwrap());
+                __v.push(<u8>::try_from((*__it.iter_deref()).clone()).ok().unwrap());
                 __it.iter_inc();
             }
             __v

tests/unit/out/unsafe/vector_iter_range_ctor.rs

@@ -18,7 +18,7 @@ unsafe fn main_0() -> i32 {
         let mut __v = Vec::new();
         let mut __it = src.as_mut_ptr();
         while __it != src.as_mut_ptr().offset((3) as isize) {
-            __v.push(u32::try_from((*__it.iter_deref()).clone()).ok().unwrap());
+            __v.push(<u32>::try_from((*__it.iter_deref()).clone()).ok().unwrap());
             __it.iter_inc();
         }
         __v
@@ -32,7 +32,7 @@ unsafe fn main_0() -> i32 {
         let mut __v = Vec::new();
         let mut __it = src.as_mut_ptr();
         while __it != src.as_mut_ptr().offset((3) as isize) {
-            __v.push(u64::try_from((*__it.iter_deref()).clone()).ok().unwrap());
+            __v.push(<u64>::try_from((*__it.iter_deref()).clone()).ok().unwrap());
             __it.iter_inc();
         }
         __v
@@ -46,7 +46,7 @@ unsafe fn main_0() -> i32 {
         let mut __v = Vec::new();
         let mut __it = src.as_mut_ptr();
         while __it != src.as_mut_ptr().offset((3) as isize) {
-            __v.push(i32::try_from((*__it.iter_deref()).clone()).ok().unwrap());
+            __v.push(<i32>::try_from((*__it.iter_deref()).clone()).ok().unwrap());
             __it.iter_inc();
         }
         __v
@@ -58,7 +58,7 @@ unsafe fn main_0() -> i32 {
         let mut __v = Vec::new();
         let mut __it = src1.as_ptr();
         while __it != src1.as_ptr().add(src1.len()) {
-            __v.push(u32::try_from((*__it.iter_deref()).clone()).ok().unwrap());
+            __v.push(<u32>::try_from((*__it.iter_deref()).clone()).ok().unwrap());
             __it.iter_inc();
         }
         __v
@@ -75,13 +75,52 @@ unsafe fn main_0() -> i32 {
         let mut __v = Vec::new();
         let mut __it = start;
         while __it != start.offset((len) as isize) {
-            __v.push(u8::try_from((*__it.iter_deref()).clone()).ok().unwrap());
+            __v.push(<u8>::try_from((*__it.iter_deref()).clone()).ok().unwrap());
             __it.iter_inc();
         }
         __v
     };
     assert!(((v5.len()) == (5_usize)));
     assert!(((v5[(0_usize)] as i32) == (10)) && ((v5[(4_usize)] as i32) == (50)));
+    let mut m: UnsafeMap<i32, (i32, i32)> = UnsafeMap::new();
+    (*&mut (*m.get_or_insert_with(1.clone(), || (1, <i32>::default()))).1) = 10;
+    (*&mut (*m.get_or_insert_with(2.clone(), || (2, <i32>::default()))).1) = 20;
+    (*&mut (*m.get_or_insert_with(3.clone(), || (3, <i32>::default()))).1) = 30;
+    let mut v6: Vec<(i32, i32)> = {
+        let mut __v = Vec::new();
+        let mut __it = m.begin();
+        while __it != m.end() {
+            __v.push(
+                <(i32, i32)>::try_from((*__it.iter_deref()).clone())
+                    .ok()
+                    .unwrap(),
+            );
+            __it.iter_inc();
+        }
+        __v
+    };
+    assert!(((v6.len()) == (3_usize)));
+    assert!(((v6[(0_usize)].0) == (1)) && ((v6[(0_usize)].1) == (10)));
+    assert!(((v6[(2_usize)].0) == (3)) && ((v6[(2_usize)].1) == (30)));
+    {
+        let __off = <UnsafeRandomAccessIterator<(i32, i32)>>::from(
+            UnsafeRandomAccessIterator::Vec(v6.as_mut_ptr()).iter_add(1_isize),
+        )
+        .vec_ptr()
+        .offset_from(v6.as_ptr()) as usize;
+        let mut __tmp = Vec::new();
+        let mut __it = m.begin();
+        while __it != m.end() {
+            __tmp.push((*__it.iter_deref()).clone());
+            __it.iter_inc();
+        }
+        v6.splice(__off..__off, __tmp);
+        UnsafeRandomAccessIterator::Vec(v6.as_mut_ptr().add(__off))
+    };
+    assert!(((v6.len()) == (6_usize)));
+    assert!(
+        (((v6[(1_usize)].0) == (1)) && ((v6[(3_usize)].0) == (3))) && ((v6[(4_usize)].0) == (2))
+    );
     return 0;
 }
 pub unsafe fn __cpp2rust_init_globals() {}

tests/unit/out/unsafe/vector_with_allocator.rs

@@ -259,7 +259,7 @@ unsafe fn main_0() -> i32 {
         let mut __v = Vec::new();
         let mut __it = src.as_mut_ptr();
         while __it != src.as_mut_ptr().offset((3) as isize) {
-            __v.push(u32::try_from((*__it.iter_deref()).clone()).ok().unwrap());
+            __v.push(<u32>::try_from((*__it.iter_deref()).clone()).ok().unwrap());
             __it.iter_inc();
         }
         __v
@@ -273,7 +273,7 @@ unsafe fn main_0() -> i32 {
         let mut __v = Vec::new();
         let mut __it = src.as_mut_ptr();
         while __it != src.as_mut_ptr().offset((3) as isize) {
-            __v.push(u64::try_from((*__it.iter_deref()).clone()).ok().unwrap());
+            __v.push(<u64>::try_from((*__it.iter_deref()).clone()).ok().unwrap());
             __it.iter_inc();
         }
         __v
@@ -287,7 +287,7 @@ unsafe fn main_0() -> i32 {
         let mut __v = Vec::new();
         let mut __it = src.as_mut_ptr();
         while __it != src.as_mut_ptr().offset((3) as isize) {
-            __v.push(i32::try_from((*__it.iter_deref()).clone()).ok().unwrap());
+            __v.push(<i32>::try_from((*__it.iter_deref()).clone()).ok().unwrap());
             __it.iter_inc();
         }
         __v
@@ -299,7 +299,7 @@ unsafe fn main_0() -> i32 {
         let mut __v = Vec::new();
         let mut __it = src1.as_ptr();
         while __it != src1.as_ptr().add(src1.len()) {
-            __v.push(u32::try_from((*__it.iter_deref()).clone()).ok().unwrap());
+            __v.push(<u32>::try_from((*__it.iter_deref()).clone()).ok().unwrap());
             __it.iter_inc();
         }
         __v
@@ -316,7 +316,7 @@ unsafe fn main_0() -> i32 {
         let mut __v = Vec::new();
         let mut __it = start;
         while __it != start.offset((len) as isize) {
-            __v.push(u8::try_from((*__it.iter_deref()).clone()).ok().unwrap());
+            __v.push(<u8>::try_from((*__it.iter_deref()).clone()).ok().unwrap());
             __it.iter_inc();
         }
         __v