From 3076caf5915c2a743849a4f31975c1b0402935ab Mon Sep 17 00:00:00 2001 From: Lucian Popescu Date: Mon, 19 Oct 2026 17:58:13 +0100 Subject: [PATCH 1/9] Switch to the new iterator idiom --- rules/algorithm/src.cpp | 5 ++--- rules/algorithm/tgt_refcount.rs | 12 +++++++---- rules/algorithm/tgt_unsafe.rs | 17 +++++++++------- rules/string/src.cpp | 5 ----- rules/string/tgt_refcount.rs | 16 ++++----------- rules/string/tgt_unsafe.rs | 17 ++++++---------- rules/vector/src.cpp | 11 +++-------- rules/vector/tgt_refcount.rs | 32 ++++++++++++++++-------------- rules/vector/tgt_unsafe.rs | 35 +++++++++++++++++---------------- 9 files changed, 68 insertions(+), 82 deletions(-) diff --git a/rules/algorithm/src.cpp b/rules/algorithm/src.cpp index bfed13eaa..f67220ef8 100644 --- a/rules/algorithm/src.cpp +++ b/rules/algorithm/src.cpp @@ -40,9 +40,8 @@ void f12(T1 first, T1 last, const T2 &value) { return std::fill(first, last, value); } -std::ostream_iterator f13(std::string::iterator a0, - std::string::iterator a1, - std::ostream_iterator a2) { +template +std::ostream_iterator f13(T1 a0, T1 a1, std::ostream_iterator a2) { return std::copy(a0, a1, a2); } diff --git a/rules/algorithm/tgt_refcount.rs b/rules/algorithm/tgt_refcount.rs index 545449a96..2374d6825 100644 --- a/rules/algorithm/tgt_refcount.rs +++ b/rules/algorithm/tgt_refcount.rs @@ -122,10 +122,14 @@ fn f12, T2: Clone + ByteRepr>(a0: T1, a1: T1, a2: T2) { } } -fn f13(a0: Ptr, a1: Ptr, a2: &mut ::std::fs::File) -> ::std::fs::File { - a0.with_slice(a1.get_offset() - a0.get_offset(), |__s| { - CChar::with_u8_slice(__s, |__b| a2.write_all(__b)) - }); +fn f13>(a0: T1, a1: T1, a2: &mut ::std::fs::File) -> ::std::fs::File { + let mut __bytes: Vec = Vec::new(); + let mut __it = a0; + while __it != a1 { + __bytes.push(__it.iter_deref().read() as u8); + __it.iter_inc(); + } + a2.write_all(&__bytes); a2.try_clone().unwrap() } diff --git a/rules/algorithm/tgt_unsafe.rs b/rules/algorithm/tgt_unsafe.rs index f07c3004f..169ec1d20 100644 --- a/rules/algorithm/tgt_unsafe.rs +++ b/rules/algorithm/tgt_unsafe.rs @@ -112,15 +112,18 @@ unsafe fn f12, T2: Clone>(a0: T1, a1: T1, a2: T2) } } -unsafe fn f13( - a0: *const libc::c_char, - a1: *const libc::c_char, +unsafe fn f13>( + a0: T1, + a1: T1, a2: &mut ::std::fs::File, ) -> ::std::fs::File { - let __start = a0 as *const u8; - let __end = a1 as *const u8; - let __len = __end.offset_from(__start) as usize; - a2.write_all(::std::slice::from_raw_parts(__start, __len)); + let mut __bytes: Vec = Vec::new(); + let mut __it = a0; + while __it != a1 { + __bytes.push(*__it.iter_deref() as u8); + __it.iter_inc(); + } + a2.write_all(&__bytes); a2.try_clone().unwrap() } diff --git a/rules/string/src.cpp b/rules/string/src.cpp index a61569193..2ebae94da 100644 --- a/rules/string/src.cpp +++ b/rules/string/src.cpp @@ -6,7 +6,6 @@ #include using t1 = std::string; -using t2 = std::string::iterator; typedef std::string::size_type t3; std::string f1(const std::string &s, std::size_t pos, std::size_t count) { @@ -57,10 +56,6 @@ bool f18(const std::string &a, const char *b) { return a == b; } std::size_t f19(const std::string &s) { return s.length(); } -std::string::iterator f20(std::string::iterator it, std::size_t n) { - return it + n; -} - std::string &f21(std::string &s, std::size_t n, char c) { return s.append(n, c); } diff --git a/rules/string/tgt_refcount.rs b/rules/string/tgt_refcount.rs index 4d96960d2..3b94acee5 100644 --- a/rules/string/tgt_refcount.rs +++ b/rules/string/tgt_refcount.rs @@ -9,10 +9,6 @@ fn t1() -> Vec { vec![0] } -fn t2() -> Ptr { - Ptr::null() -} - fn f1(a0: Vec, a1: usize, a2: usize) -> Vec { let mut __tmp1 = a0[(a1) as usize..::std::cmp::min((a1 + a2) as usize, a0.len().saturating_sub(1))].to_vec(); @@ -62,8 +58,8 @@ fn f11(a0: Ptr) -> Ptr { a0 } -fn f12(a0: Ptr) -> Ptr { - a0 +fn f12(a0: Ptr) -> RandomAccessIterator { + RandomAccessIterator::Vec(a0) } fn f14(a0: Ptr>, a1: usize, a2: usize, a3: Ptr, a4: usize) -> Ptr> { @@ -80,8 +76,8 @@ fn f14(a0: Ptr>, a1: usize, a2: usize, a3: Ptr, a4: usize) -> Ptr) -> Ptr { - a0.to_last() +fn f15(a0: Ptr) -> RandomAccessIterator { + RandomAccessIterator::Vec(a0.to_last()) } fn f16(a0: Vec, a1: Ptr) -> usize { @@ -106,10 +102,6 @@ fn f18(a0: Vec, a1: Ptr) -> bool { a1.with_c_str(|__s| a0[..a0.len().saturating_sub(1)] == *__s) } -fn f20(a0: Ptr, a1: usize) -> Ptr { - a0.offset(a1 as isize) -} - // TODO: This should return a0 fn f21(a0: &mut Vec, a1: usize, a2: i8) -> Vec { a0.pop(); diff --git a/rules/string/tgt_unsafe.rs b/rules/string/tgt_unsafe.rs index a7b7966de..32cacd28c 100644 --- a/rules/string/tgt_unsafe.rs +++ b/rules/string/tgt_unsafe.rs @@ -1,14 +1,12 @@ // Copyright (c) 2022-present INESC-ID. // Distributed under the MIT license that can be found in the LICENSE file. +use libcc2rs::*; + fn t1() -> Vec { vec![0] } -fn t2() -> *mut libc::c_char { - ::std::ptr::null_mut() -} - fn t3() -> usize { 0_usize } @@ -80,8 +78,8 @@ unsafe fn f10(a0: *const libc::c_char) -> Vec { unsafe fn f11(a0: Vec) -> *const libc::c_char { a0.as_ptr() } -unsafe fn f12(a0: &mut Vec) -> *mut libc::c_char { - a0.as_mut_ptr() +unsafe fn f12(a0: &mut Vec) -> UnsafeRandomAccessIterator { + UnsafeRandomAccessIterator::Vec(a0.as_mut_ptr()) } unsafe fn f13(a0: &mut Vec, a1: usize) { a0.pop(); @@ -100,8 +98,8 @@ unsafe fn f14( ::std::slice::from_raw_parts(a3, a4 as usize).to_vec(), ); } -unsafe fn f15(a0: &mut Vec) -> *mut libc::c_char { - a0.as_mut_ptr().add(a0.len() - 1) +unsafe fn f15(a0: &mut Vec) -> UnsafeRandomAccessIterator { + UnsafeRandomAccessIterator::Vec(a0.as_mut_ptr().add(a0.len() - 1)) } unsafe fn f16(a0: Vec, a1: *const libc::c_char) -> usize { match a0.iter().rposition(|&c| { @@ -134,9 +132,6 @@ unsafe fn f18(a0: Vec, a1: *const libc::c_char) -> bool { unsafe fn f19(a0: Vec) -> usize { (a0.len() - 1) } -unsafe fn f20(a0: *mut libc::c_char, a1: usize) -> *mut libc::c_char { - a0.add(a1 as usize) -} unsafe fn f21(a0: &mut Vec, a1: usize, a2: libc::c_char) { a0.splice( a0.len() - 1..a0.len() - 1, diff --git a/rules/vector/src.cpp b/rules/vector/src.cpp index 684733efe..6872777f3 100644 --- a/rules/vector/src.cpp +++ b/rules/vector/src.cpp @@ -136,18 +136,13 @@ void f80(std::vector &o, const T1 &value) { return o.push_back(value); } -template > -std::vector f90(const T1 *first, const T1 *last) { - return std::vector(first, last); -} - template > std::vector f91(const std::initializer_list &a0) { return std::vector(a0); } template , typename T3> -std::vector f92(T3 *first, T3 *last) { +std::vector f92(T3 first, T3 last) { return std::vector(first, last); } @@ -181,10 +176,10 @@ const T1 &f99(const std::vector &o) { return o.back(); } -template > +template , typename T3> typename std::vector::iterator f101(std::vector &o, typename std::vector::const_iterator pos, - const T1 *first, const T1 *last) { + T3 first, T3 last) { return o.insert(pos, first, last); } diff --git a/rules/vector/tgt_refcount.rs b/rules/vector/tgt_refcount.rs index e4f1077f6..3cae8764d 100644 --- a/rules/vector/tgt_refcount.rs +++ b/rules/vector/tgt_refcount.rs @@ -51,16 +51,14 @@ fn f79(a0: &mut Vec, a1: RandomAccessIterator, a2: T1) -> a1 } -fn f90(a0: Ptr, a1: Ptr) -> Vec { - let __count = a1.get_offset() - a0.get_offset(); - PtrValueIter::new(&a0, __count).collect::>() -} - -fn f92, T2: Clone + ByteRepr>(a0: Ptr, a1: Ptr) -> Vec { - let __count = a1.get_offset() - a0.get_offset(); - PtrValueIter::new(&a0, __count) - .map(|item| T1::try_from(item).ok().unwrap()) - .collect::>() +fn f92, T2: Clone + ByteRepr, T3: CppInputIterator>(a0: T3, a1: T3) -> Vec { + let mut __v = Vec::new(); + let mut __it = a0; + while __it != a1 { + __v.push(T1::try_from(__it.iter_deref().read()).ok().unwrap()); + __it.iter_inc(); + } + __v } fn f93(a0: Ptr) -> Ptr { @@ -87,15 +85,19 @@ fn f99(a0: Ptr) -> Ptr { a0.to_last() } -fn f101( +fn f101>( a0: Ptr>, a1: RandomAccessIterator, - a2: Ptr, - a3: Ptr, + a2: T3, + a3: T3, ) -> RandomAccessIterator { let start_idx = a1.vec_ptr().get_offset(); - let count = a3.get_offset() - a2.get_offset(); - let temp_vec: Vec = PtrValueIter::new(&a2, count).collect(); + let mut temp_vec: Vec = Vec::new(); + let mut __it = a2; + while __it != a3 { + temp_vec.push(__it.iter_deref().read()); + __it.iter_inc(); + } a0.with_mut(|v: &mut Vec| { v.splice(start_idx..start_idx, temp_vec); }); diff --git a/rules/vector/tgt_unsafe.rs b/rules/vector/tgt_unsafe.rs index d8c5fa4b2..6fa292e3c 100644 --- a/rules/vector/tgt_unsafe.rs +++ b/rules/vector/tgt_unsafe.rs @@ -121,19 +121,18 @@ unsafe fn f80(a0: &mut Vec, a1: T1) { a0.push(a0_clone) } -unsafe fn f90(a0: *const T1, a1: *const T1) -> Vec { - core::slice::from_raw_parts(a0, (a1).offset_from(a0) as usize).to_vec() -} - unsafe fn f91(a0: Vec) -> Vec { a0 } -unsafe fn f92, T2: Clone>(a0: *mut T2, a1: *mut T2) -> Vec { - core::slice::from_raw_parts(a0, (a1).offset_from(a0) as usize) - .iter() - .map(|x| T1::try_from(x.clone()).ok().unwrap()) - .collect() +unsafe fn f92, T2: Clone, T3: UnsafeCppInputIterator>(a0: T3, a1: T3) -> Vec { + let mut __v = Vec::new(); + let mut __it = a0; + while __it != a1 { + __v.push(T1::try_from((*__it.iter_deref()).clone()).ok().unwrap()); + __it.iter_inc(); + } + __v } unsafe fn f93(a0: &mut Vec) -> *const T1 { @@ -164,18 +163,20 @@ unsafe fn f99(a0: &Vec) -> &T1 { ((a0).last().unwrap()) } -unsafe fn f101( +unsafe fn f101>( a0: &mut Vec, a1: UnsafeRandomAccessIterator, - a2: *const T1, - a3: *const T1, + a2: T3, + a3: T3, ) -> UnsafeRandomAccessIterator { let __off = a1.vec_ptr().offset_from(a0.as_ptr()) as usize; - let count = a3.offset_from(a2) as usize; - a0.splice( - __off..__off, - std::slice::from_raw_parts(a2, count).iter().cloned(), - ); + let mut __tmp = Vec::new(); + let mut __it = a2; + while __it != a3 { + __tmp.push((*__it.iter_deref()).clone()); + __it.iter_inc(); + } + a0.splice(__off..__off, __tmp); UnsafeRandomAccessIterator::Vec(a0.as_mut_ptr().add(__off)) } From da5b26118228eb1dddc45f3561acf0ce3fa05ce9 Mon Sep 17 00:00:00 2001 From: Lucian Popescu Date: Mon, 19 Oct 2026 18:00:39 +0100 Subject: [PATCH 2/9] Update tests --- tests/unit/out/refcount/push_emplace_back.rs | 28 +++---- tests/unit/out/refcount/stdcopy_ostream.rs | 12 +-- .../out/refcount/vector_iter_range_ctor.rs | 61 ++++++++------- .../out/refcount/vector_with_allocator.rs | 61 ++++++++------- tests/unit/out/unsafe/push_emplace_back.rs | 32 ++++---- tests/unit/out/unsafe/stdcopy_ostream.rs | 11 ++- .../unit/out/unsafe/vector_iter_range_ctor.rs | 76 +++++++++++-------- .../unit/out/unsafe/vector_with_allocator.rs | 76 +++++++++++-------- 8 files changed, 206 insertions(+), 151 deletions(-) diff --git a/tests/unit/out/refcount/push_emplace_back.rs b/tests/unit/out/refcount/push_emplace_back.rs index b73fc34d8..34789c5fa 100644 --- a/tests/unit/out/refcount/push_emplace_back.rs +++ b/tests/unit/out/refcount/push_emplace_back.rs @@ -48,13 +48,13 @@ pub fn push_local_from_field_1(mut jpg: Ptr, mut cond: bool) { } { let __a1 = { - let __count = (head.as_pointer() as Ptr) - .offset((3) as isize) - .get_offset() - - (head.as_pointer() as Ptr).get_offset(); - PtrValueIter::new(&(head.as_pointer() as Ptr), __count) - .map(|item| u8::try_from(item).ok().unwrap()) - .collect::>() + let mut __v = Vec::new(); + let mut __it = (head.as_pointer() as Ptr); + while __it != (head.as_pointer() as Ptr).offset((3) as isize) { + __v.push(u8::try_from(__it.iter_deref().read()).ok().unwrap()); + __it.iter_inc(); + } + __v }; dest.with_mut(|__v: &mut Vec>| __v.push(__a1)) }; @@ -79,13 +79,13 @@ pub fn emplace_local_from_field_4(mut jpg: Ptr, mut cond: bool) { } { let __init = { - let __count = (head.as_pointer() as Ptr) - .offset((3) as isize) - .get_offset() - - (head.as_pointer() as Ptr).get_offset(); - PtrValueIter::new(&(head.as_pointer() as Ptr), __count) - .map(|item| u8::try_from(item).ok().unwrap()) - .collect::>() + let mut __v = Vec::new(); + let mut __it = (head.as_pointer() as Ptr); + while __it != (head.as_pointer() as Ptr).offset((3) as isize) { + __v.push(u8::try_from(__it.iter_deref().read()).ok().unwrap()); + __it.iter_inc(); + } + __v }; dest.with_mut(|__v: &mut Vec>| __v.push(__init)) }; diff --git a/tests/unit/out/refcount/stdcopy_ostream.rs b/tests/unit/out/refcount/stdcopy_ostream.rs index 162408ad4..4ba7ca44a 100644 --- a/tests/unit/out/refcount/stdcopy_ostream.rs +++ b/tests/unit/out/refcount/stdcopy_ostream.rs @@ -25,11 +25,13 @@ fn main_0() -> i32 { .expect("Failed to open file"), )); { - (str.as_pointer() as Ptr).with_slice( - (str.as_pointer() as Ptr).to_last().get_offset() - - (str.as_pointer() as Ptr).get_offset(), - |__s| CChar::with_u8_slice(__s, |__b| (*ofs.borrow_mut()).write_all(__b)), - ); + let mut __bytes: Vec = Vec::new(); + let mut __it = RandomAccessIterator::Vec((str.as_pointer() as Ptr)); + while __it != RandomAccessIterator::Vec((str.as_pointer() as Ptr).to_last()) { + __bytes.push(__it.iter_deref().read() as u8); + __it.iter_inc(); + } + (*ofs.borrow_mut()).write_all(&__bytes); (*ofs.borrow_mut()).try_clone().unwrap() }; } diff --git a/tests/unit/out/refcount/vector_iter_range_ctor.rs b/tests/unit/out/refcount/vector_iter_range_ctor.rs index 653ea8d23..3e80d6884 100644 --- a/tests/unit/out/refcount/vector_iter_range_ctor.rs +++ b/tests/unit/out/refcount/vector_iter_range_ctor.rs @@ -13,43 +13,47 @@ pub fn main() { fn main_0() -> i32 { let src: Value> = Rc::new(RefCell::new(Box::new([1_u32, 2_u32, 3_u32]))); let mut v1: Vec = { - let __count = (src.as_pointer() as Ptr) - .offset((3) as isize) - .get_offset() - - (src.as_pointer() as Ptr).get_offset(); - PtrValueIter::new(&(src.as_pointer() as Ptr), __count) - .map(|item| u32::try_from(item).ok().unwrap()) - .collect::>() + let mut __v = Vec::new(); + let mut __it = (src.as_pointer() as Ptr); + while __it != (src.as_pointer() as Ptr).offset((3) as isize) { + __v.push(u32::try_from(__it.iter_deref().read()).ok().unwrap()); + __it.iter_inc(); + } + __v }; assert!((v1.len() == 3_usize)); assert!(((v1[0_usize] == 1_u32) && (v1[1_usize] == 2_u32)) && (v1[2_usize] == 3_u32)); let mut v2: Vec = { - let __count = (src.as_pointer() as Ptr) - .offset((3) as isize) - .get_offset() - - (src.as_pointer() as Ptr).get_offset(); - PtrValueIter::new(&(src.as_pointer() as Ptr), __count) - .map(|item| u64::try_from(item).ok().unwrap()) - .collect::>() + let mut __v = Vec::new(); + let mut __it = (src.as_pointer() as Ptr); + while __it != (src.as_pointer() as Ptr).offset((3) as isize) { + __v.push(u64::try_from(__it.iter_deref().read()).ok().unwrap()); + __it.iter_inc(); + } + __v }; assert!((v2.len() == 3_usize)); assert!(((v2[0_usize] == 1_u64) && (v2[1_usize] == 2_u64)) && (v2[2_usize] == 3_u64)); let mut v3: Vec = { - let __count = (src.as_pointer() as Ptr) - .offset((3) as isize) - .get_offset() - - (src.as_pointer() as Ptr).get_offset(); - PtrValueIter::new(&(src.as_pointer() as Ptr), __count) - .map(|item| i32::try_from(item).ok().unwrap()) - .collect::>() + let mut __v = Vec::new(); + let mut __it = (src.as_pointer() as Ptr); + while __it != (src.as_pointer() as Ptr).offset((3) as isize) { + __v.push(i32::try_from(__it.iter_deref().read()).ok().unwrap()); + __it.iter_inc(); + } + __v }; assert!((v3.len() == 3_usize)); assert!(((v3[0_usize] == 1) && (v3[1_usize] == 2)) && (v3[2_usize] == 3)); let src1: Value> = Rc::new(RefCell::new(Box::new([1_u32, 2_u32, 3_u32]))); let mut v4: Vec = { - let __count = (src1.as_pointer() as Ptr).to_end().get_offset() - - (src1.as_pointer() as Ptr).get_offset(); - PtrValueIter::new(&(src1.as_pointer() as Ptr), __count).collect::>() + let mut __v = Vec::new(); + let mut __it = (src1.as_pointer() as Ptr); + while __it != (src1.as_pointer() as Ptr).to_end() { + __v.push(u32::try_from(__it.iter_deref().read()).ok().unwrap()); + __it.iter_inc(); + } + __v }; assert!((v4.len() == 3_usize)); assert!(((v4[0_usize] == 1_u32) && (v4[1_usize] == 2_u32)) && (v4[2_usize] == 3_u32)); @@ -58,8 +62,13 @@ fn main_0() -> i32 { let mut start: Ptr = (buf.as_pointer() as Ptr); let mut len: usize = 5_usize; let mut v5: Vec = { - let __count = start.offset((len) as isize).get_offset() - start.get_offset(); - PtrValueIter::new(&start, __count).collect::>() + 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()); + __it.iter_inc(); + } + __v }; assert!((v5.len() == 5_usize)); assert!(((v5[0_usize] as i32) == 10) && ((v5[4_usize] as i32) == 50)); diff --git a/tests/unit/out/refcount/vector_with_allocator.rs b/tests/unit/out/refcount/vector_with_allocator.rs index 9af36ebc9..b23bc0c43 100644 --- a/tests/unit/out/refcount/vector_with_allocator.rs +++ b/tests/unit/out/refcount/vector_with_allocator.rs @@ -249,43 +249,47 @@ fn main_0() -> i32 { ({ fn_1(v7.as_pointer(), v8.clone()) }); let src: Value> = Rc::new(RefCell::new(Box::new([1_u32, 2_u32, 3_u32]))); let mut v9: Vec = { - let __count = (src.as_pointer() as Ptr) - .offset((3) as isize) - .get_offset() - - (src.as_pointer() as Ptr).get_offset(); - PtrValueIter::new(&(src.as_pointer() as Ptr), __count) - .map(|item| u32::try_from(item).ok().unwrap()) - .collect::>() + let mut __v = Vec::new(); + let mut __it = (src.as_pointer() as Ptr); + while __it != (src.as_pointer() as Ptr).offset((3) as isize) { + __v.push(u32::try_from(__it.iter_deref().read()).ok().unwrap()); + __it.iter_inc(); + } + __v }; assert!((v9.len() == 3_usize)); assert!(((v9[0_usize] == 1_u32) && (v9[1_usize] == 2_u32)) && (v9[2_usize] == 3_u32)); let mut v10: Vec = { - let __count = (src.as_pointer() as Ptr) - .offset((3) as isize) - .get_offset() - - (src.as_pointer() as Ptr).get_offset(); - PtrValueIter::new(&(src.as_pointer() as Ptr), __count) - .map(|item| u64::try_from(item).ok().unwrap()) - .collect::>() + let mut __v = Vec::new(); + let mut __it = (src.as_pointer() as Ptr); + while __it != (src.as_pointer() as Ptr).offset((3) as isize) { + __v.push(u64::try_from(__it.iter_deref().read()).ok().unwrap()); + __it.iter_inc(); + } + __v }; assert!((v10.len() == 3_usize)); assert!(((v10[0_usize] == 1_u64) && (v10[1_usize] == 2_u64)) && (v10[2_usize] == 3_u64)); let mut v11: Vec = { - let __count = (src.as_pointer() as Ptr) - .offset((3) as isize) - .get_offset() - - (src.as_pointer() as Ptr).get_offset(); - PtrValueIter::new(&(src.as_pointer() as Ptr), __count) - .map(|item| i32::try_from(item).ok().unwrap()) - .collect::>() + let mut __v = Vec::new(); + let mut __it = (src.as_pointer() as Ptr); + while __it != (src.as_pointer() as Ptr).offset((3) as isize) { + __v.push(i32::try_from(__it.iter_deref().read()).ok().unwrap()); + __it.iter_inc(); + } + __v }; assert!((v11.len() == 3_usize)); assert!(((v11[0_usize] == 1) && (v11[1_usize] == 2)) && (v11[2_usize] == 3)); let src1: Value> = Rc::new(RefCell::new(Box::new([1_u32, 2_u32, 3_u32]))); let mut v12: Vec = { - let __count = (src1.as_pointer() as Ptr).to_end().get_offset() - - (src1.as_pointer() as Ptr).get_offset(); - PtrValueIter::new(&(src1.as_pointer() as Ptr), __count).collect::>() + let mut __v = Vec::new(); + let mut __it = (src1.as_pointer() as Ptr); + while __it != (src1.as_pointer() as Ptr).to_end() { + __v.push(u32::try_from(__it.iter_deref().read()).ok().unwrap()); + __it.iter_inc(); + } + __v }; assert!((v12.len() == 3_usize)); assert!(((v12[0_usize] == 1_u32) && (v12[1_usize] == 2_u32)) && (v12[2_usize] == 3_u32)); @@ -294,8 +298,13 @@ fn main_0() -> i32 { let mut start: Ptr = (buf.as_pointer() as Ptr); let mut len: usize = 5_usize; let mut v13: Vec = { - let __count = start.offset((len) as isize).get_offset() - start.get_offset(); - PtrValueIter::new(&start, __count).collect::>() + 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()); + __it.iter_inc(); + } + __v }; assert!((v13.len() == 5_usize)); assert!(((v13[0_usize] as i32) == 10) && ((v13[4_usize] as i32) == 50)); diff --git a/tests/unit/out/unsafe/push_emplace_back.rs b/tests/unit/out/unsafe/push_emplace_back.rs index 22ed160a4..743271cc4 100644 --- a/tests/unit/out/unsafe/push_emplace_back.rs +++ b/tests/unit/out/unsafe/push_emplace_back.rs @@ -38,13 +38,15 @@ pub unsafe fn push_local_from_field_1(mut jpg: *mut JPEGData, mut cond: bool) { dest = (&mut (*jpg).app_data as *mut Vec>); } { - let __a1 = core::slice::from_raw_parts( - head.as_mut_ptr(), - (head.as_mut_ptr().offset((3) as isize)).offset_from(head.as_mut_ptr()) as usize, - ) - .iter() - .map(|x| u8::try_from(x.clone()).ok().unwrap()) - .collect(); + let __a1 = { + 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()); + __it.iter_inc(); + } + __v + }; (*dest).push(__a1) }; } @@ -66,13 +68,15 @@ pub unsafe fn emplace_local_from_field_4(mut jpg: *mut JPEGData, mut cond: bool) dest = (&mut (*jpg).app_data as *mut Vec>); } { - let __init = core::slice::from_raw_parts( - head.as_mut_ptr(), - (head.as_mut_ptr().offset((3) as isize)).offset_from(head.as_mut_ptr()) as usize, - ) - .iter() - .map(|x| u8::try_from(x.clone()).ok().unwrap()) - .collect(); + let __init = { + 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()); + __it.iter_inc(); + } + __v + }; (*dest).push(__init) }; } diff --git a/tests/unit/out/unsafe/stdcopy_ostream.rs b/tests/unit/out/unsafe/stdcopy_ostream.rs index f298bd329..999710e31 100644 --- a/tests/unit/out/unsafe/stdcopy_ostream.rs +++ b/tests/unit/out/unsafe/stdcopy_ostream.rs @@ -23,10 +23,13 @@ unsafe fn main_0() -> i32 { ::std::fs::File::create(::std::ffi::CStr::from_ptr(file.as_ptr()).to_str().unwrap()) .unwrap(); { - let __start = str.as_mut_ptr() as *const u8; - let __end = str.as_mut_ptr().add(str.len() - 1) as *const u8; - let __len = __end.offset_from(__start) as usize; - ofs.write_all(::std::slice::from_raw_parts(__start, __len)); + let mut __bytes: Vec = Vec::new(); + let mut __it = UnsafeRandomAccessIterator::Vec(str.as_mut_ptr()); + while __it != UnsafeRandomAccessIterator::Vec(str.as_mut_ptr().add(str.len() - 1)) { + __bytes.push(*__it.iter_deref() as u8); + __it.iter_inc(); + } + ofs.write_all(&__bytes); ofs.try_clone().unwrap() }; } diff --git a/tests/unit/out/unsafe/vector_iter_range_ctor.rs b/tests/unit/out/unsafe/vector_iter_range_ctor.rs index a9c316f52..d74961a94 100644 --- a/tests/unit/out/unsafe/vector_iter_range_ctor.rs +++ b/tests/unit/out/unsafe/vector_iter_range_ctor.rs @@ -14,45 +14,55 @@ pub fn main() { } unsafe fn main_0() -> i32 { let mut src: [u32; 3] = [1_u32, 2_u32, 3_u32]; - let mut v1: Vec = core::slice::from_raw_parts( - src.as_mut_ptr(), - (src.as_mut_ptr().offset((3) as isize)).offset_from(src.as_mut_ptr()) as usize, - ) - .iter() - .map(|x| u32::try_from(x.clone()).ok().unwrap()) - .collect(); + let mut v1: Vec = { + 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()); + __it.iter_inc(); + } + __v + }; assert!(((v1.len()) == (3_usize))); assert!( (((v1[(0_usize)]) == (1_u32)) && ((v1[(1_usize)]) == (2_u32))) && ((v1[(2_usize)]) == (3_u32)) ); - let mut v2: Vec = core::slice::from_raw_parts( - src.as_mut_ptr(), - (src.as_mut_ptr().offset((3) as isize)).offset_from(src.as_mut_ptr()) as usize, - ) - .iter() - .map(|x| u64::try_from(x.clone()).ok().unwrap()) - .collect(); + let mut v2: Vec = { + 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()); + __it.iter_inc(); + } + __v + }; assert!(((v2.len()) == (3_usize))); assert!( (((v2[(0_usize)]) == (1_u64)) && ((v2[(1_usize)]) == (2_u64))) && ((v2[(2_usize)]) == (3_u64)) ); - let mut v3: Vec = core::slice::from_raw_parts( - src.as_mut_ptr(), - (src.as_mut_ptr().offset((3) as isize)).offset_from(src.as_mut_ptr()) as usize, - ) - .iter() - .map(|x| i32::try_from(x.clone()).ok().unwrap()) - .collect(); + let mut v3: Vec = { + 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()); + __it.iter_inc(); + } + __v + }; assert!(((v3.len()) == (3_usize))); assert!((((v3[(0_usize)]) == (1)) && ((v3[(1_usize)]) == (2))) && ((v3[(2_usize)]) == (3))); let src1: [u32; 3] = [1_u32, 2_u32, 3_u32]; - let mut v4: Vec = core::slice::from_raw_parts( - src1.as_ptr(), - (src1.as_ptr().add(src1.len())).offset_from(src1.as_ptr()) as usize, - ) - .to_vec(); + let mut v4: Vec = { + 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()); + __it.iter_inc(); + } + __v + }; assert!(((v4.len()) == (3_usize))); assert!( (((v4[(0_usize)]) == (1_u32)) && ((v4[(1_usize)]) == (2_u32))) @@ -61,11 +71,15 @@ unsafe fn main_0() -> i32 { let mut buf: [u8; 5] = [10_u8, 20_u8, 30_u8, 40_u8, 50_u8]; let mut start: *const u8 = (buf.as_mut_ptr()).cast_const(); let mut len: usize = 5_usize; - let mut v5: Vec = core::slice::from_raw_parts( - start, - (start.offset((len) as isize)).offset_from(start) as usize, - ) - .to_vec(); + let mut v5: Vec = { + 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()); + __it.iter_inc(); + } + __v + }; assert!(((v5.len()) == (5_usize))); assert!(((v5[(0_usize)] as i32) == (10)) && ((v5[(4_usize)] as i32) == (50))); return 0; diff --git a/tests/unit/out/unsafe/vector_with_allocator.rs b/tests/unit/out/unsafe/vector_with_allocator.rs index d568aece8..730d85ee0 100644 --- a/tests/unit/out/unsafe/vector_with_allocator.rs +++ b/tests/unit/out/unsafe/vector_with_allocator.rs @@ -255,45 +255,55 @@ unsafe fn main_0() -> i32 { }; (unsafe { fn_1(&mut v7, v8.clone()) }); let mut src: [u32; 3] = [1_u32, 2_u32, 3_u32]; - let mut v9: Vec = core::slice::from_raw_parts( - src.as_mut_ptr(), - (src.as_mut_ptr().offset((3) as isize)).offset_from(src.as_mut_ptr()) as usize, - ) - .iter() - .map(|x| u32::try_from(x.clone()).ok().unwrap()) - .collect(); + let mut v9: Vec = { + 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()); + __it.iter_inc(); + } + __v + }; assert!(((v9.len()) == (3_usize))); assert!( (((v9[(0_usize)]) == (1_u32)) && ((v9[(1_usize)]) == (2_u32))) && ((v9[(2_usize)]) == (3_u32)) ); - let mut v10: Vec = core::slice::from_raw_parts( - src.as_mut_ptr(), - (src.as_mut_ptr().offset((3) as isize)).offset_from(src.as_mut_ptr()) as usize, - ) - .iter() - .map(|x| u64::try_from(x.clone()).ok().unwrap()) - .collect(); + let mut v10: Vec = { + 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()); + __it.iter_inc(); + } + __v + }; assert!(((v10.len()) == (3_usize))); assert!( (((v10[(0_usize)]) == (1_u64)) && ((v10[(1_usize)]) == (2_u64))) && ((v10[(2_usize)]) == (3_u64)) ); - let mut v11: Vec = core::slice::from_raw_parts( - src.as_mut_ptr(), - (src.as_mut_ptr().offset((3) as isize)).offset_from(src.as_mut_ptr()) as usize, - ) - .iter() - .map(|x| i32::try_from(x.clone()).ok().unwrap()) - .collect(); + let mut v11: Vec = { + 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()); + __it.iter_inc(); + } + __v + }; assert!(((v11.len()) == (3_usize))); assert!((((v11[(0_usize)]) == (1)) && ((v11[(1_usize)]) == (2))) && ((v11[(2_usize)]) == (3))); let src1: [u32; 3] = [1_u32, 2_u32, 3_u32]; - let mut v12: Vec = core::slice::from_raw_parts( - src1.as_ptr(), - (src1.as_ptr().add(src1.len())).offset_from(src1.as_ptr()) as usize, - ) - .to_vec(); + let mut v12: Vec = { + 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()); + __it.iter_inc(); + } + __v + }; assert!(((v12.len()) == (3_usize))); assert!( (((v12[(0_usize)]) == (1_u32)) && ((v12[(1_usize)]) == (2_u32))) @@ -302,11 +312,15 @@ unsafe fn main_0() -> i32 { let mut buf: [u8; 5] = [10_u8, 20_u8, 30_u8, 40_u8, 50_u8]; let mut start: *const u8 = (buf.as_mut_ptr()).cast_const(); let mut len: usize = 5_usize; - let mut v13: Vec = core::slice::from_raw_parts( - start, - (start.offset((len) as isize)).offset_from(start) as usize, - ) - .to_vec(); + let mut v13: Vec = { + 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()); + __it.iter_inc(); + } + __v + }; assert!(((v13.len()) == (5_usize))); assert!(((v13[(0_usize)] as i32) == (10)) && ((v13[(4_usize)] as i32) == (50))); assert!( From 7c24902d3c8967733d27ee1c781cb2b4f177e26c Mon Sep 17 00:00:00 2001 From: Lucian Popescu Date: Mon, 19 Oct 2026 18:01:01 +0100 Subject: [PATCH 3/9] Declare T2 --- rules/vector/tgt_refcount.rs | 2 +- rules/vector/tgt_unsafe.rs | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/rules/vector/tgt_refcount.rs b/rules/vector/tgt_refcount.rs index 3cae8764d..f1b427b95 100644 --- a/rules/vector/tgt_refcount.rs +++ b/rules/vector/tgt_refcount.rs @@ -85,7 +85,7 @@ fn f99(a0: Ptr) -> Ptr { a0.to_last() } -fn f101>( +fn f101>( a0: Ptr>, a1: RandomAccessIterator, a2: T3, diff --git a/rules/vector/tgt_unsafe.rs b/rules/vector/tgt_unsafe.rs index 6fa292e3c..730f9642e 100644 --- a/rules/vector/tgt_unsafe.rs +++ b/rules/vector/tgt_unsafe.rs @@ -163,7 +163,7 @@ unsafe fn f99(a0: &Vec) -> &T1 { ((a0).last().unwrap()) } -unsafe fn f101>( +unsafe fn f101>( a0: &mut Vec, a1: UnsafeRandomAccessIterator, a2: T3, From d74ba50934f1e7ed3a8c246ef21db3959179071e Mon Sep 17 00:00:00 2001 From: Lucian Popescu Date: Mon, 19 Oct 2026 18:01:38 +0100 Subject: [PATCH 4/9] Delete PrtValueIter --- docs/src/runtime/iterators.md | 12 ++---------- libcc2rs/src/rc.rs | 37 ----------------------------------- 2 files changed, 2 insertions(+), 47 deletions(-) diff --git a/docs/src/runtime/iterators.md b/docs/src/runtime/iterators.md index 7e1861f1a..7f16e4116 100644 --- a/docs/src/runtime/iterators.md +++ b/docs/src/runtime/iterators.md @@ -27,17 +27,9 @@ for x in v.as_pointer() as Ptr { } ``` -Two variants serve special cases. `StringIterator`, returned by +One variant serves a special case. `StringIterator`, returned by `to_string_iterator`, stops before the trailing zero byte, so iterating a -`std::string` visits its characters only. `PtrValueIter` yields copies of the -elements instead of pointers to them; rule bodies use it to feed a range of C -memory to Rust iterator adaptors: - -```rust -// std::accumulate(first, last, init) -let count = (last - first) as usize; -PtrValueIter::new(&first, count).fold(init, |acc, x| acc + x) -``` +`std::string` visits its characters only. ## Stable iterators diff --git a/libcc2rs/src/rc.rs b/libcc2rs/src/rc.rs index f97408a46..f0742fe5f 100644 --- a/libcc2rs/src/rc.rs +++ b/libcc2rs/src/rc.rs @@ -1229,43 +1229,6 @@ impl Iterator for Ptr { } } -// Ptr iterator that yields values instead of pointers. -// It's more efficient and it's useful to implement idiomatic iterator patterns -pub struct PtrValueIter { - ptr: Ptr, - n: usize, -} - -impl PtrValueIter { - pub fn new(ptr: &Ptr, n: usize) -> Self { - Self { - ptr: ptr.clone(), - n, - } - } -} - -impl Iterator for PtrValueIter { - type Item = T; - - fn next(&mut self) -> Option { - if self.n > 0 { - let value = self.ptr.read(); - self.ptr += 1; - self.n -= 1; - Some(value) - } else { - None - } - } - - fn size_hint(&self) -> (usize, Option) { - (self.n, Some(self.n)) - } -} - -impl ExactSizeIterator for PtrValueIter {} - impl Sub for Ptr { type Output = isize; fn sub(self, other: Self) -> Self::Output { From 53590d2711b37ebbabf9d1f7edb85c448bce1a67 Mon Sep 17 00:00:00 2001 From: Lucian Popescu Date: Mon, 19 Oct 2026 18:10:59 +0100 Subject: [PATCH 5/9] Add test where old PtrValueIter did not work --- rules/vector/tgt_refcount.rs | 2 +- rules/vector/tgt_unsafe.rs | 2 +- tests/unit/out/refcount/push_emplace_back.rs | 4 +- .../out/refcount/vector_iter_range_ctor.rs | 108 +++++++++++++++++- .../out/refcount/vector_with_allocator.rs | 10 +- tests/unit/out/unsafe/push_emplace_back.rs | 4 +- .../unit/out/unsafe/vector_iter_range_ctor.rs | 49 +++++++- .../unit/out/unsafe/vector_with_allocator.rs | 10 +- tests/unit/vector_iter_range_ctor.cpp | 13 +++ 9 files changed, 176 insertions(+), 26 deletions(-) diff --git a/rules/vector/tgt_refcount.rs b/rules/vector/tgt_refcount.rs index f1b427b95..520a633f6 100644 --- a/rules/vector/tgt_refcount.rs +++ b/rules/vector/tgt_refcount.rs @@ -55,7 +55,7 @@ fn f92, T2: Clone + ByteRepr, T3: CppInputIterator>(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(::try_from(__it.iter_deref().read()).ok().unwrap()); __it.iter_inc(); } __v diff --git a/rules/vector/tgt_unsafe.rs b/rules/vector/tgt_unsafe.rs index 730f9642e..49af011e6 100644 --- a/rules/vector/tgt_unsafe.rs +++ b/rules/vector/tgt_unsafe.rs @@ -129,7 +129,7 @@ unsafe fn f92, T2: Clone, T3: UnsafeCppInputIterator>(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(::try_from((*__it.iter_deref()).clone()).ok().unwrap()); __it.iter_inc(); } __v diff --git a/tests/unit/out/refcount/push_emplace_back.rs b/tests/unit/out/refcount/push_emplace_back.rs index 34789c5fa..b5904e411 100644 --- a/tests/unit/out/refcount/push_emplace_back.rs +++ b/tests/unit/out/refcount/push_emplace_back.rs @@ -51,7 +51,7 @@ pub fn push_local_from_field_1(mut jpg: Ptr, mut cond: bool) { let mut __v = Vec::new(); let mut __it = (head.as_pointer() as Ptr); while __it != (head.as_pointer() as Ptr).offset((3) as isize) { - __v.push(u8::try_from(__it.iter_deref().read()).ok().unwrap()); + __v.push(::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, mut cond: bool) { let mut __v = Vec::new(); let mut __it = (head.as_pointer() as Ptr); while __it != (head.as_pointer() as Ptr).offset((3) as isize) { - __v.push(u8::try_from(__it.iter_deref().read()).ok().unwrap()); + __v.push(::try_from(__it.iter_deref().read()).ok().unwrap()); __it.iter_inc(); } __v diff --git a/tests/unit/out/refcount/vector_iter_range_ctor.rs b/tests/unit/out/refcount/vector_iter_range_ctor.rs index 3e80d6884..9f4a6220c 100644 --- a/tests/unit/out/refcount/vector_iter_range_ctor.rs +++ b/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); while __it != (src.as_pointer() as Ptr).offset((3) as isize) { - __v.push(u32::try_from(__it.iter_deref().read()).ok().unwrap()); + __v.push(::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); while __it != (src.as_pointer() as Ptr).offset((3) as isize) { - __v.push(u64::try_from(__it.iter_deref().read()).ok().unwrap()); + __v.push(::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); while __it != (src.as_pointer() as Ptr).offset((3) as isize) { - __v.push(i32::try_from(__it.iter_deref().read()).ok().unwrap()); + __v.push(::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); while __it != (src1.as_pointer() as Ptr).to_end() { - __v.push(u32::try_from(__it.iter_deref().read()).ok().unwrap()); + __v.push(::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(::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, Value)>> = Rc::new(RefCell::new(Map::new())); + (m.as_pointer() as Ptr, Value)>>) + .with_mut(|__m: &mut Map, Value)>| { + __m.get_or_insert_with(1.clone(), || { + ( + Rc::new(RefCell::new(1)), + Rc::new(RefCell::new(::default())), + ) + }) + .borrow() + .1 + .as_pointer() + }) + .write(10); + (m.as_pointer() as Ptr, Value)>>) + .with_mut(|__m: &mut Map, Value)>| { + __m.get_or_insert_with(2.clone(), || { + ( + Rc::new(RefCell::new(2)), + Rc::new(RefCell::new(::default())), + ) + }) + .borrow() + .1 + .as_pointer() + }) + .write(20); + (m.as_pointer() as Ptr, Value)>>) + .with_mut(|__m: &mut Map, Value)>| { + __m.get_or_insert_with(3.clone(), || { + ( + Rc::new(RefCell::new(3)), + Rc::new(RefCell::new(::default())), + ) + }) + .borrow() + .1 + .as_pointer() + }) + .write(30); + let v6: Value, Value)>> = Rc::new(RefCell::new({ + let mut __v = Vec::new(); + let mut __it = (m.as_pointer() as Ptr, Value)>>) + .with(|__m: &Map, Value)>| __m.begin()); + while __it + != (m.as_pointer() as Ptr, Value)>>) + .with(|__m: &Map, Value)>| __m.end()) + { + __v.push( + <(Value, Value)>::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 = , Value)>>::from( + RandomAccessIterator::Vec((v6.as_pointer() as Ptr<(Value, Value)>)) + .iter_add(1_isize), + ) + .vec_ptr() + .get_offset(); + let mut temp_vec: Vec<(Value, Value)> = Vec::new(); + let mut __it = (m.as_pointer() as Ptr, Value)>>) + .with(|__m: &Map, Value)>| __m.begin()); + while __it + != (m.as_pointer() as Ptr, Value)>>) + .with(|__m: &Map, Value)>| __m.end()) + { + temp_vec.push(__it.iter_deref().read()); + __it.iter_inc(); + } + (v6.as_pointer() as Ptr, Value)>>).with_mut( + |v: &mut Vec<(Value, Value)>| { + v.splice(start_idx..start_idx, temp_vec); + }, + ); + RandomAccessIterator::Vec( + (v6.as_pointer() as Ptr, Value)>>).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() {} diff --git a/tests/unit/out/refcount/vector_with_allocator.rs b/tests/unit/out/refcount/vector_with_allocator.rs index b23bc0c43..e32bcf50e 100644 --- a/tests/unit/out/refcount/vector_with_allocator.rs +++ b/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); while __it != (src.as_pointer() as Ptr).offset((3) as isize) { - __v.push(u32::try_from(__it.iter_deref().read()).ok().unwrap()); + __v.push(::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); while __it != (src.as_pointer() as Ptr).offset((3) as isize) { - __v.push(u64::try_from(__it.iter_deref().read()).ok().unwrap()); + __v.push(::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); while __it != (src.as_pointer() as Ptr).offset((3) as isize) { - __v.push(i32::try_from(__it.iter_deref().read()).ok().unwrap()); + __v.push(::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); while __it != (src1.as_pointer() as Ptr).to_end() { - __v.push(u32::try_from(__it.iter_deref().read()).ok().unwrap()); + __v.push(::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(::try_from(__it.iter_deref().read()).ok().unwrap()); __it.iter_inc(); } __v diff --git a/tests/unit/out/unsafe/push_emplace_back.rs b/tests/unit/out/unsafe/push_emplace_back.rs index 743271cc4..6a5ccdbc8 100644 --- a/tests/unit/out/unsafe/push_emplace_back.rs +++ b/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(::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(::try_from((*__it.iter_deref()).clone()).ok().unwrap()); __it.iter_inc(); } __v diff --git a/tests/unit/out/unsafe/vector_iter_range_ctor.rs b/tests/unit/out/unsafe/vector_iter_range_ctor.rs index d74961a94..045f03c98 100644 --- a/tests/unit/out/unsafe/vector_iter_range_ctor.rs +++ b/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(::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(::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(::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(::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(::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 = UnsafeMap::new(); + (*&mut (*m.get_or_insert_with(1.clone(), || (1, ::default()))).1) = 10; + (*&mut (*m.get_or_insert_with(2.clone(), || (2, ::default()))).1) = 20; + (*&mut (*m.get_or_insert_with(3.clone(), || (3, ::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 = >::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() {} diff --git a/tests/unit/out/unsafe/vector_with_allocator.rs b/tests/unit/out/unsafe/vector_with_allocator.rs index 730d85ee0..7fc34466a 100644 --- a/tests/unit/out/unsafe/vector_with_allocator.rs +++ b/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(::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(::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(::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(::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(::try_from((*__it.iter_deref()).clone()).ok().unwrap()); __it.iter_inc(); } __v diff --git a/tests/unit/vector_iter_range_ctor.cpp b/tests/unit/vector_iter_range_ctor.cpp index 84d113c1e..03a7868a4 100644 --- a/tests/unit/vector_iter_range_ctor.cpp +++ b/tests/unit/vector_iter_range_ctor.cpp @@ -1,6 +1,7 @@ #include #include #include +#include #include int main() { @@ -33,5 +34,17 @@ int main() { assert(v5.size() == 5); assert(v5[0] == 10 && v5[4] == 50); + std::map m; + m[1] = 10; + m[2] = 20; + m[3] = 30; + std::vector> v6(m.begin(), m.end()); + assert(v6.size() == 3); + assert(v6[0].first == 1 && v6[0].second == 10); + assert(v6[2].first == 3 && v6[2].second == 30); + v6.insert(v6.begin() + 1, m.begin(), m.end()); + assert(v6.size() == 6); + assert(v6[1].first == 1 && v6[3].first == 3 && v6[4].first == 2); + return 0; } From dae0e6a057ab3fa3cc25428bf937891c67f5c0dd Mon Sep 17 00:00:00 2001 From: Lucian Popescu Date: Mon, 19 Oct 2026 18:37:51 +0100 Subject: [PATCH 6/9] Add rules for the rest of insert's --- rules/vector/src.cpp | 14 ++++ rules/vector/tgt_refcount.rs | 12 ++++ rules/vector/tgt_unsafe.rs | 12 ++++ tests/unit/out/refcount/vector.rs | 107 ++++++++++++++++++++++++++++++ tests/unit/out/unsafe/vector.rs | 103 ++++++++++++++++++++++++++++ tests/unit/vector.cpp | 34 ++++++++++ 6 files changed, 282 insertions(+) diff --git a/rules/vector/src.cpp b/rules/vector/src.cpp index 6872777f3..e6d62263b 100644 --- a/rules/vector/src.cpp +++ b/rules/vector/src.cpp @@ -226,3 +226,17 @@ auto f114(std::vector &o, Init &&...args) -> decltype(o.emplace_back(std::forward(args)...)) { return o.emplace_back(std::forward(args)...); } + +template > +typename std::vector::iterator +f115(std::vector &o, typename std::vector::const_iterator pos, + std::size_t n, const T1 &value) { + return o.insert(pos, n, value); +} + +template > +typename std::vector::iterator +f116(std::vector &o, typename std::vector::const_iterator pos, + std::initializer_list l) { + return o.insert(pos, l); +} diff --git a/rules/vector/tgt_refcount.rs b/rules/vector/tgt_refcount.rs index 520a633f6..6f44c6d26 100644 --- a/rules/vector/tgt_refcount.rs +++ b/rules/vector/tgt_refcount.rs @@ -115,3 +115,15 @@ fn f104(a0: Ptr) -> RandomAccessIterator { fn f105(a0: Ptr>, a1: Vec) { a0.write(a1) } + +fn f115(a0: &mut Vec, a1: RandomAccessIterator, a2: usize, a3: T1) -> RandomAccessIterator { + let __off = a1.vec_ptr().get_offset(); + a0.splice(__off..__off, std::iter::repeat_n(a3, a2)); + a1 +} + +fn f116(a0: &mut Vec, a1: RandomAccessIterator, a2: Vec) -> RandomAccessIterator { + let __off = a1.vec_ptr().get_offset(); + a0.splice(__off..__off, a2); + a1 +} diff --git a/rules/vector/tgt_unsafe.rs b/rules/vector/tgt_unsafe.rs index 49af011e6..e3319d04f 100644 --- a/rules/vector/tgt_unsafe.rs +++ b/rules/vector/tgt_unsafe.rs @@ -213,3 +213,15 @@ unsafe fn f114(a0: &mut Vec, init: T1) { let __init = init; a0.push(__init) } + +unsafe fn f115(a0: &mut Vec, a1: UnsafeRandomAccessIterator, a2: usize, a3: T1) -> UnsafeRandomAccessIterator { + let __off = a1.vec_ptr().offset_from(a0.as_ptr()) as usize; + a0.splice(__off..__off, std::iter::repeat_n(a3, a2)); + UnsafeRandomAccessIterator::Vec(a0.as_mut_ptr().add(__off)) +} + +unsafe fn f116(a0: &mut Vec, a1: UnsafeRandomAccessIterator, a2: Vec) -> UnsafeRandomAccessIterator { + let __off = a1.vec_ptr().offset_from(a0.as_ptr()) as usize; + a0.splice(__off..__off, a2); + UnsafeRandomAccessIterator::Vec(a0.as_mut_ptr().add(__off)) +} diff --git a/tests/unit/out/refcount/vector.rs b/tests/unit/out/refcount/vector.rs index 9cb8df477..efa6b63ab 100644 --- a/tests/unit/out/refcount/vector.rs +++ b/tests/unit/out/refcount/vector.rs @@ -80,6 +80,113 @@ fn main_0() -> i32 { assert!(({ (*v2.borrow())[0_usize] } == 100)); assert!(({ (*v2.borrow())[1_usize] } == 2)); assert!(({ (*v2.borrow())[2_usize] } == 3)); + let mut x: i32 = 7; + { + let __off = >::from( + RandomAccessIterator::Vec((v2.as_pointer() as Ptr)).iter_add(1_isize), + ) + .vec_ptr() + .get_offset(); + (*v2.borrow_mut()).insert(__off, x); + >::from( + RandomAccessIterator::Vec((v2.as_pointer() as Ptr)).iter_add(1_isize), + ) + }; + assert!(((*v2.borrow()).len() == 4_usize)); + assert!(({ (*v2.borrow())[0_usize] } == 100)); + assert!(({ (*v2.borrow())[1_usize] } == 7)); + assert!(({ (*v2.borrow())[2_usize] } == 2)); + { + let __off = >::from(RandomAccessIterator::Vec( + (v2.as_pointer() as Ptr).to_end(), + )) + .vec_ptr() + .get_offset(); + (*v2.borrow_mut()).splice(__off..__off, std::iter::repeat_n(9, 2_usize)); + >::from(RandomAccessIterator::Vec( + (v2.as_pointer() as Ptr).to_end(), + )) + }; + assert!(((*v2.borrow()).len() == 6_usize)); + assert!(({ (*v2.borrow())[4_usize] } == 9)); + assert!(({ (*v2.borrow())[5_usize] } == 9)); + { + let __off = >::from( + RandomAccessIterator::Vec((v2.as_pointer() as Ptr)).iter_add(2_isize), + ) + .vec_ptr() + .get_offset(); + (*v2.borrow_mut()).splice(__off..__off, vec![11, 12, 13]); + >::from( + RandomAccessIterator::Vec((v2.as_pointer() as Ptr)).iter_add(2_isize), + ) + }; + assert!(((*v2.borrow()).len() == 9_usize)); + assert!(({ (*v2.borrow())[1_usize] } == 7)); + assert!(({ (*v2.borrow())[2_usize] } == 11)); + assert!(({ (*v2.borrow())[3_usize] } == 12)); + assert!(({ (*v2.borrow())[4_usize] } == 13)); + assert!(({ (*v2.borrow())[5_usize] } == 2)); + assert!(({ (*v2.borrow())[8_usize] } == 9)); + let src: Value> = Rc::new(RefCell::new(vec![21, 22])); + { + let start_idx = >::from(RandomAccessIterator::Vec( + (v2.as_pointer() as Ptr), + )) + .vec_ptr() + .get_offset(); + let mut temp_vec: Vec = Vec::new(); + let mut __it = RandomAccessIterator::Vec((src.as_pointer() as Ptr)); + while __it != RandomAccessIterator::Vec((src.as_pointer() as Ptr).to_end()) { + temp_vec.push(__it.iter_deref().read()); + __it.iter_inc(); + } + (v2.as_pointer() as Ptr>).with_mut(|v: &mut Vec| { + v.splice(start_idx..start_idx, temp_vec); + }); + RandomAccessIterator::Vec((v2.as_pointer() as Ptr>).decay() + start_idx) + }; + assert!(((*v2.borrow()).len() == 11_usize)); + assert!(({ (*v2.borrow())[0_usize] } == 21)); + assert!(({ (*v2.borrow())[1_usize] } == 22)); + assert!(({ (*v2.borrow())[2_usize] } == 100)); + { + let idx = >::from(RandomAccessIterator::Vec( + (v2.as_pointer() as Ptr), + )) + .vec_ptr() + .get_offset(); + (v2.as_pointer() as Ptr>).with_mut(|__v: &mut Vec| __v.remove(idx)); + RandomAccessIterator::Vec((v2.as_pointer() as Ptr>).decay()) + }; + { + let idx = >::from(RandomAccessIterator::Vec( + (v2.as_pointer() as Ptr), + )) + .vec_ptr() + .get_offset(); + (v2.as_pointer() as Ptr>).with_mut(|__v: &mut Vec| __v.remove(idx)); + RandomAccessIterator::Vec((v2.as_pointer() as Ptr>).decay()) + }; + let mut i: i32 = 0; + 'loop_: while (i < 4) { + { + let idx = >::from( + RandomAccessIterator::Vec((v2.as_pointer() as Ptr)).iter_add(1_isize), + ) + .vec_ptr() + .get_offset(); + (v2.as_pointer() as Ptr>).with_mut(|__v: &mut Vec| __v.remove(idx)); + RandomAccessIterator::Vec((v2.as_pointer() as Ptr>).decay()) + }; + i.prefix_inc(); + } + (*v2.borrow_mut()).pop(); + (*v2.borrow_mut()).pop(); + assert!(((*v2.borrow()).len() == 3_usize)); + assert!(({ (*v2.borrow())[0_usize] } == 100)); + assert!(({ (*v2.borrow())[1_usize] } == 2)); + assert!(({ (*v2.borrow())[2_usize] } == 3)); let mut s2: usize = (*v2.borrow()).len(); let v3: Value> = Rc::new(RefCell::new(vec![1; 100_usize as usize])); assert!(((*v3.borrow()).len() == 100_usize)); diff --git a/tests/unit/out/unsafe/vector.rs b/tests/unit/out/unsafe/vector.rs index 06cdf633c..a098d6d64 100644 --- a/tests/unit/out/unsafe/vector.rs +++ b/tests/unit/out/unsafe/vector.rs @@ -81,6 +81,109 @@ unsafe fn main_0() -> i32 { assert!(((v2[(0_usize)]) == (100))); assert!(((v2[(1_usize)]) == (2))); assert!(((v2[(2_usize)]) == (3))); + let mut x: i32 = 7; + { + let pos = >::from( + UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr()).iter_add(1_isize), + ) + .vec_ptr() + .offset_from(v2.as_ptr()) as usize; + v2.insert(pos, x); + >::from( + UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr()).iter_add(1_isize), + ) + }; + assert!(((v2.len()) == (4_usize))); + assert!(((v2[(0_usize)]) == (100))); + assert!(((v2[(1_usize)]) == (7))); + assert!(((v2[(2_usize)]) == (2))); + { + let __off = >::from(UnsafeRandomAccessIterator::Vec( + v2.as_mut_ptr().add(v2.len()), + )) + .vec_ptr() + .offset_from(v2.as_ptr()) as usize; + v2.splice(__off..__off, std::iter::repeat_n(9, 2_usize)); + UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr().add(__off)) + }; + assert!(((v2.len()) == (6_usize))); + assert!(((v2[(4_usize)]) == (9))); + assert!(((v2[(5_usize)]) == (9))); + { + let __off = >::from( + UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr()).iter_add(2_isize), + ) + .vec_ptr() + .offset_from(v2.as_ptr()) as usize; + v2.splice(__off..__off, vec![11, 12, 13]); + UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr().add(__off)) + }; + assert!(((v2.len()) == (9_usize))); + assert!(((v2[(1_usize)]) == (7))); + assert!(((v2[(2_usize)]) == (11))); + assert!(((v2[(3_usize)]) == (12))); + assert!(((v2[(4_usize)]) == (13))); + assert!(((v2[(5_usize)]) == (2))); + assert!(((v2[(8_usize)]) == (9))); + let mut src: Vec = vec![21, 22]; + { + let __off = >::from(UnsafeRandomAccessIterator::Vec( + v2.as_mut_ptr(), + )) + .vec_ptr() + .offset_from(v2.as_ptr()) as usize; + let mut __tmp = Vec::new(); + let mut __it = UnsafeRandomAccessIterator::Vec(src.as_mut_ptr()); + while __it != UnsafeRandomAccessIterator::Vec(src.as_mut_ptr().add(src.len())) { + __tmp.push((*__it.iter_deref()).clone()); + __it.iter_inc(); + } + v2.splice(__off..__off, __tmp); + UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr().add(__off)) + }; + assert!(((v2.len()) == (11_usize))); + assert!(((v2[(0_usize)]) == (21))); + assert!(((v2[(1_usize)]) == (22))); + assert!(((v2[(2_usize)]) == (100))); + { + let pos = >::from(UnsafeRandomAccessIterator::Vec( + v2.as_mut_ptr(), + )) + .vec_ptr() + .offset_from(v2.as_ptr()) as usize; + v2.remove(pos); + >::from(UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr())) + }; + { + let pos = >::from(UnsafeRandomAccessIterator::Vec( + v2.as_mut_ptr(), + )) + .vec_ptr() + .offset_from(v2.as_ptr()) as usize; + v2.remove(pos); + >::from(UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr())) + }; + let mut i: i32 = 0; + 'loop_: while ((i) < (4)) { + { + let pos = >::from( + UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr()).iter_add(1_isize), + ) + .vec_ptr() + .offset_from(v2.as_ptr()) as usize; + v2.remove(pos); + >::from( + UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr()).iter_add(1_isize), + ) + }; + i.prefix_inc(); + } + v2.pop(); + v2.pop(); + assert!(((v2.len()) == (3_usize))); + assert!(((v2[(0_usize)]) == (100))); + assert!(((v2[(1_usize)]) == (2))); + assert!(((v2[(2_usize)]) == (3))); let mut s2: usize = v2.len(); let mut v3: Vec = vec![1; 100_usize as usize]; assert!(((v3.len()) == (100_usize))); diff --git a/tests/unit/vector.cpp b/tests/unit/vector.cpp index b908ae949..82935676c 100644 --- a/tests/unit/vector.cpp +++ b/tests/unit/vector.cpp @@ -39,6 +39,40 @@ int main() { assert(v2[0] == 100); assert(v2[1] == 2); assert(v2[2] == 3); + int x = 7; + v2.insert(v2.begin() + 1, x); + assert(v2.size() == 4); + assert(v2[0] == 100); + assert(v2[1] == 7); + assert(v2[2] == 2); + v2.insert(v2.end(), 2, 9); + assert(v2.size() == 6); + assert(v2[4] == 9); + assert(v2[5] == 9); + v2.insert(v2.begin() + 2, {11, 12, 13}); + assert(v2.size() == 9); + assert(v2[1] == 7); + assert(v2[2] == 11); + assert(v2[3] == 12); + assert(v2[4] == 13); + assert(v2[5] == 2); + assert(v2[8] == 9); + std::vector src{21, 22}; + v2.insert(v2.begin(), src.begin(), src.end()); + assert(v2.size() == 11); + assert(v2[0] == 21); + assert(v2[1] == 22); + assert(v2[2] == 100); + v2.erase(v2.begin()); + v2.erase(v2.begin()); + for (int i = 0; i < 4; ++i) + v2.erase(v2.begin() + 1); + v2.pop_back(); + v2.pop_back(); + assert(v2.size() == 3); + assert(v2[0] == 100); + assert(v2[1] == 2); + assert(v2[2] == 3); auto s2 = v2.size(); std::vector v3(100, 1); assert(v3.size() == 100); From eeb99bd562a999966cde307afab3942af93c8f0b Mon Sep 17 00:00:00 2001 From: Lucian Popescu Date: Mon, 19 Oct 2026 18:39:50 +0100 Subject: [PATCH 7/9] vec_ptr -> ptr --- rules/iterator_category/shim.rs | 4 ++-- rules/vector/tgt_refcount.rs | 12 ++++++------ rules/vector/tgt_unsafe.rs | 12 ++++++------ .../refcount/unboxed_conditional_iterator.rs | 2 +- tests/unit/out/refcount/vector.rs | 18 +++++++++--------- .../out/refcount/vector_iter_range_ctor.rs | 2 +- .../unit/out/refcount/vector_with_allocator.rs | 4 ++-- .../out/unsafe/unboxed_conditional_iterator.rs | 2 +- tests/unit/out/unsafe/vector.rs | 18 +++++++++--------- .../unit/out/unsafe/vector_iter_range_ctor.rs | 2 +- tests/unit/out/unsafe/vector_with_allocator.rs | 4 ++-- 11 files changed, 40 insertions(+), 40 deletions(-) diff --git a/rules/iterator_category/shim.rs b/rules/iterator_category/shim.rs index 3994c5093..58413acb5 100644 --- a/rules/iterator_category/shim.rs +++ b/rules/iterator_category/shim.rs @@ -339,7 +339,7 @@ macro_rules! random_access_iterator { } impl $name { - pub fn vec_ptr(&self) -> $ptr { + pub fn ptr(&self) -> $ptr { match self { Self::Vec(p) => p.clone(), } @@ -354,7 +354,7 @@ macro_rules! random_access_iterator { impl Clone for $name { fn clone(&self) -> Self { - Self::Vec(self.vec_ptr()) + Self::Vec(self.ptr()) } } diff --git a/rules/vector/tgt_refcount.rs b/rules/vector/tgt_refcount.rs index 6f44c6d26..36b707849 100644 --- a/rules/vector/tgt_refcount.rs +++ b/rules/vector/tgt_refcount.rs @@ -10,7 +10,7 @@ fn f40(a0: Ptr) -> Ptr { } fn f60(a0: Ptr>, a1: RandomAccessIterator) -> RandomAccessIterator { - let idx = a1.vec_ptr().get_offset(); + let idx = a1.ptr().get_offset(); a0.with_mut(|__v: &mut Vec| __v.remove(idx)); RandomAccessIterator::Vec(a0.decay()) } @@ -40,13 +40,13 @@ fn f76(a0: Ptr) -> RandomAccessIterator { } fn f77(a0: &mut Vec, a1: RandomAccessIterator, a2: T1) -> RandomAccessIterator { - let __off = a1.vec_ptr().get_offset(); + let __off = a1.ptr().get_offset(); a0.insert(__off, a2); a1 } fn f79(a0: &mut Vec, a1: RandomAccessIterator, a2: T1) -> RandomAccessIterator { - let __off = a1.vec_ptr().get_offset(); + let __off = a1.ptr().get_offset(); a0.insert(__off, a2); a1 } @@ -91,7 +91,7 @@ fn f101>( a2: T3, a3: T3, ) -> RandomAccessIterator { - let start_idx = a1.vec_ptr().get_offset(); + let start_idx = a1.ptr().get_offset(); let mut temp_vec: Vec = Vec::new(); let mut __it = a2; while __it != a3 { @@ -117,13 +117,13 @@ fn f105(a0: Ptr>, a1: Vec) { } fn f115(a0: &mut Vec, a1: RandomAccessIterator, a2: usize, a3: T1) -> RandomAccessIterator { - let __off = a1.vec_ptr().get_offset(); + let __off = a1.ptr().get_offset(); a0.splice(__off..__off, std::iter::repeat_n(a3, a2)); a1 } fn f116(a0: &mut Vec, a1: RandomAccessIterator, a2: Vec) -> RandomAccessIterator { - let __off = a1.vec_ptr().get_offset(); + let __off = a1.ptr().get_offset(); a0.splice(__off..__off, a2); a1 } diff --git a/rules/vector/tgt_unsafe.rs b/rules/vector/tgt_unsafe.rs index e3319d04f..a15171e16 100644 --- a/rules/vector/tgt_unsafe.rs +++ b/rules/vector/tgt_unsafe.rs @@ -24,7 +24,7 @@ unsafe fn f47(a0: Vec) -> Vec { } unsafe fn f60(a0: &mut Vec, a1: UnsafeRandomAccessIterator) -> UnsafeRandomAccessIterator { - let pos = a1.vec_ptr().offset_from(a0.as_ptr()) as usize; + let pos = a1.ptr().offset_from(a0.as_ptr()) as usize; a0.remove(pos); a1 } @@ -101,7 +101,7 @@ unsafe fn f76(a0: &mut Vec) -> UnsafeRandomAccessIterator { } unsafe fn f77(a0: &mut Vec, a1: UnsafeRandomAccessIterator, a2: T1) -> UnsafeRandomAccessIterator { - let pos = a1.vec_ptr().offset_from(a0.as_ptr()) as usize; + let pos = a1.ptr().offset_from(a0.as_ptr()) as usize; a0.insert(pos, a2); a1 } @@ -111,7 +111,7 @@ unsafe fn f78(a0: usize, a1: T1) -> Vec { } unsafe fn f79(a0: &mut Vec, a1: UnsafeRandomAccessIterator, a2: T1) -> UnsafeRandomAccessIterator { - let pos = a1.vec_ptr().offset_from(a0.as_ptr()) as usize; + let pos = a1.ptr().offset_from(a0.as_ptr()) as usize; a0.insert(pos, a2); a1 } @@ -169,7 +169,7 @@ unsafe fn f101>( a2: T3, a3: T3, ) -> UnsafeRandomAccessIterator { - let __off = a1.vec_ptr().offset_from(a0.as_ptr()) as usize; + let __off = a1.ptr().offset_from(a0.as_ptr()) as usize; let mut __tmp = Vec::new(); let mut __it = a2; while __it != a3 { @@ -215,13 +215,13 @@ unsafe fn f114(a0: &mut Vec, init: T1) { } unsafe fn f115(a0: &mut Vec, a1: UnsafeRandomAccessIterator, a2: usize, a3: T1) -> UnsafeRandomAccessIterator { - let __off = a1.vec_ptr().offset_from(a0.as_ptr()) as usize; + let __off = a1.ptr().offset_from(a0.as_ptr()) as usize; a0.splice(__off..__off, std::iter::repeat_n(a3, a2)); UnsafeRandomAccessIterator::Vec(a0.as_mut_ptr().add(__off)) } unsafe fn f116(a0: &mut Vec, a1: UnsafeRandomAccessIterator, a2: Vec) -> UnsafeRandomAccessIterator { - let __off = a1.vec_ptr().offset_from(a0.as_ptr()) as usize; + let __off = a1.ptr().offset_from(a0.as_ptr()) as usize; a0.splice(__off..__off, a2); UnsafeRandomAccessIterator::Vec(a0.as_mut_ptr().add(__off)) } diff --git a/tests/unit/out/refcount/unboxed_conditional_iterator.rs b/tests/unit/out/refcount/unboxed_conditional_iterator.rs index 21fae41de..563802e74 100644 --- a/tests/unit/out/refcount/unboxed_conditional_iterator.rs +++ b/tests/unit/out/refcount/unboxed_conditional_iterator.rs @@ -67,7 +67,7 @@ pub fn lehmer_2(mut sigma: Ptr, mut len: u32, mut code: Ptr) { elem!(code, i).write(__rhs); { let idx = >::from((*it.borrow()).clone()) - .vec_ptr() + .ptr() .get_offset(); (items.as_pointer() as Ptr>).with_mut(|__v: &mut Vec| __v.remove(idx)); RandomAccessIterator::Vec((items.as_pointer() as Ptr>).decay()) diff --git a/tests/unit/out/refcount/vector.rs b/tests/unit/out/refcount/vector.rs index efa6b63ab..a3f77c115 100644 --- a/tests/unit/out/refcount/vector.rs +++ b/tests/unit/out/refcount/vector.rs @@ -58,7 +58,7 @@ fn main_0() -> i32 { let idx = >::from(RandomAccessIterator::Vec( (v2.as_pointer() as Ptr), )) - .vec_ptr() + .ptr() .get_offset(); (v2.as_pointer() as Ptr>).with_mut(|__v: &mut Vec| __v.remove(idx)); RandomAccessIterator::Vec((v2.as_pointer() as Ptr>).decay()) @@ -70,7 +70,7 @@ fn main_0() -> i32 { let __off = >::from(RandomAccessIterator::Vec( (v2.as_pointer() as Ptr), )) - .vec_ptr() + .ptr() .get_offset(); (*v2.borrow_mut()).insert(__off, 100); >::from(RandomAccessIterator::Vec((v2.as_pointer() as Ptr))) @@ -85,7 +85,7 @@ fn main_0() -> i32 { let __off = >::from( RandomAccessIterator::Vec((v2.as_pointer() as Ptr)).iter_add(1_isize), ) - .vec_ptr() + .ptr() .get_offset(); (*v2.borrow_mut()).insert(__off, x); >::from( @@ -100,7 +100,7 @@ fn main_0() -> i32 { let __off = >::from(RandomAccessIterator::Vec( (v2.as_pointer() as Ptr).to_end(), )) - .vec_ptr() + .ptr() .get_offset(); (*v2.borrow_mut()).splice(__off..__off, std::iter::repeat_n(9, 2_usize)); >::from(RandomAccessIterator::Vec( @@ -114,7 +114,7 @@ fn main_0() -> i32 { let __off = >::from( RandomAccessIterator::Vec((v2.as_pointer() as Ptr)).iter_add(2_isize), ) - .vec_ptr() + .ptr() .get_offset(); (*v2.borrow_mut()).splice(__off..__off, vec![11, 12, 13]); >::from( @@ -133,7 +133,7 @@ fn main_0() -> i32 { let start_idx = >::from(RandomAccessIterator::Vec( (v2.as_pointer() as Ptr), )) - .vec_ptr() + .ptr() .get_offset(); let mut temp_vec: Vec = Vec::new(); let mut __it = RandomAccessIterator::Vec((src.as_pointer() as Ptr)); @@ -154,7 +154,7 @@ fn main_0() -> i32 { let idx = >::from(RandomAccessIterator::Vec( (v2.as_pointer() as Ptr), )) - .vec_ptr() + .ptr() .get_offset(); (v2.as_pointer() as Ptr>).with_mut(|__v: &mut Vec| __v.remove(idx)); RandomAccessIterator::Vec((v2.as_pointer() as Ptr>).decay()) @@ -163,7 +163,7 @@ fn main_0() -> i32 { let idx = >::from(RandomAccessIterator::Vec( (v2.as_pointer() as Ptr), )) - .vec_ptr() + .ptr() .get_offset(); (v2.as_pointer() as Ptr>).with_mut(|__v: &mut Vec| __v.remove(idx)); RandomAccessIterator::Vec((v2.as_pointer() as Ptr>).decay()) @@ -174,7 +174,7 @@ fn main_0() -> i32 { let idx = >::from( RandomAccessIterator::Vec((v2.as_pointer() as Ptr)).iter_add(1_isize), ) - .vec_ptr() + .ptr() .get_offset(); (v2.as_pointer() as Ptr>).with_mut(|__v: &mut Vec| __v.remove(idx)); RandomAccessIterator::Vec((v2.as_pointer() as Ptr>).decay()) diff --git a/tests/unit/out/refcount/vector_iter_range_ctor.rs b/tests/unit/out/refcount/vector_iter_range_ctor.rs index 9f4a6220c..c89f499ae 100644 --- a/tests/unit/out/refcount/vector_iter_range_ctor.rs +++ b/tests/unit/out/refcount/vector_iter_range_ctor.rs @@ -143,7 +143,7 @@ fn main_0() -> i32 { RandomAccessIterator::Vec((v6.as_pointer() as Ptr<(Value, Value)>)) .iter_add(1_isize), ) - .vec_ptr() + .ptr() .get_offset(); let mut temp_vec: Vec<(Value, Value)> = Vec::new(); let mut __it = (m.as_pointer() as Ptr, Value)>>) diff --git a/tests/unit/out/refcount/vector_with_allocator.rs b/tests/unit/out/refcount/vector_with_allocator.rs index e32bcf50e..6f5a2ec3f 100644 --- a/tests/unit/out/refcount/vector_with_allocator.rs +++ b/tests/unit/out/refcount/vector_with_allocator.rs @@ -103,7 +103,7 @@ fn main_0() -> i32 { let idx = >::from(RandomAccessIterator::Vec( (v2.as_pointer() as Ptr), )) - .vec_ptr() + .ptr() .get_offset(); (v2.as_pointer() as Ptr>).with_mut(|__v: &mut Vec| __v.remove(idx)); RandomAccessIterator::Vec((v2.as_pointer() as Ptr>).decay()) @@ -115,7 +115,7 @@ fn main_0() -> i32 { let __off = >::from(RandomAccessIterator::Vec( (v2.as_pointer() as Ptr), )) - .vec_ptr() + .ptr() .get_offset(); (*v2.borrow_mut()).insert(__off, 100); >::from(RandomAccessIterator::Vec((v2.as_pointer() as Ptr))) diff --git a/tests/unit/out/unsafe/unboxed_conditional_iterator.rs b/tests/unit/out/unsafe/unboxed_conditional_iterator.rs index 6cbbacdec..f0126da19 100644 --- a/tests/unit/out/unsafe/unboxed_conditional_iterator.rs +++ b/tests/unit/out/unsafe/unboxed_conditional_iterator.rs @@ -57,7 +57,7 @@ pub unsafe fn lehmer_2(mut sigma: *const u32, mut len: u32, mut code: *mut u32) (it.iter_distance(&UnsafeRandomAccessIterator::Vec(items.as_mut_ptr())) as u32); { let pos = >::from((it).clone()) - .vec_ptr() + .ptr() .offset_from(items.as_ptr()) as usize; items.remove(pos); >::from((it).clone()) diff --git a/tests/unit/out/unsafe/vector.rs b/tests/unit/out/unsafe/vector.rs index a098d6d64..daee94b5a 100644 --- a/tests/unit/out/unsafe/vector.rs +++ b/tests/unit/out/unsafe/vector.rs @@ -59,7 +59,7 @@ unsafe fn main_0() -> i32 { let pos = >::from(UnsafeRandomAccessIterator::Vec( v2.as_mut_ptr(), )) - .vec_ptr() + .ptr() .offset_from(v2.as_ptr()) as usize; v2.remove(pos); >::from(UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr())) @@ -71,7 +71,7 @@ unsafe fn main_0() -> i32 { let pos = >::from(UnsafeRandomAccessIterator::Vec( v2.as_mut_ptr(), )) - .vec_ptr() + .ptr() .offset_from(v2.as_ptr()) as usize; v2.insert(pos, 100); >::from(UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr())) @@ -86,7 +86,7 @@ unsafe fn main_0() -> i32 { let pos = >::from( UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr()).iter_add(1_isize), ) - .vec_ptr() + .ptr() .offset_from(v2.as_ptr()) as usize; v2.insert(pos, x); >::from( @@ -101,7 +101,7 @@ unsafe fn main_0() -> i32 { let __off = >::from(UnsafeRandomAccessIterator::Vec( v2.as_mut_ptr().add(v2.len()), )) - .vec_ptr() + .ptr() .offset_from(v2.as_ptr()) as usize; v2.splice(__off..__off, std::iter::repeat_n(9, 2_usize)); UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr().add(__off)) @@ -113,7 +113,7 @@ unsafe fn main_0() -> i32 { let __off = >::from( UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr()).iter_add(2_isize), ) - .vec_ptr() + .ptr() .offset_from(v2.as_ptr()) as usize; v2.splice(__off..__off, vec![11, 12, 13]); UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr().add(__off)) @@ -130,7 +130,7 @@ unsafe fn main_0() -> i32 { let __off = >::from(UnsafeRandomAccessIterator::Vec( v2.as_mut_ptr(), )) - .vec_ptr() + .ptr() .offset_from(v2.as_ptr()) as usize; let mut __tmp = Vec::new(); let mut __it = UnsafeRandomAccessIterator::Vec(src.as_mut_ptr()); @@ -149,7 +149,7 @@ unsafe fn main_0() -> i32 { let pos = >::from(UnsafeRandomAccessIterator::Vec( v2.as_mut_ptr(), )) - .vec_ptr() + .ptr() .offset_from(v2.as_ptr()) as usize; v2.remove(pos); >::from(UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr())) @@ -158,7 +158,7 @@ unsafe fn main_0() -> i32 { let pos = >::from(UnsafeRandomAccessIterator::Vec( v2.as_mut_ptr(), )) - .vec_ptr() + .ptr() .offset_from(v2.as_ptr()) as usize; v2.remove(pos); >::from(UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr())) @@ -169,7 +169,7 @@ unsafe fn main_0() -> i32 { let pos = >::from( UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr()).iter_add(1_isize), ) - .vec_ptr() + .ptr() .offset_from(v2.as_ptr()) as usize; v2.remove(pos); >::from( diff --git a/tests/unit/out/unsafe/vector_iter_range_ctor.rs b/tests/unit/out/unsafe/vector_iter_range_ctor.rs index 045f03c98..4d8e9ffac 100644 --- a/tests/unit/out/unsafe/vector_iter_range_ctor.rs +++ b/tests/unit/out/unsafe/vector_iter_range_ctor.rs @@ -106,7 +106,7 @@ unsafe fn main_0() -> i32 { let __off = >::from( UnsafeRandomAccessIterator::Vec(v6.as_mut_ptr()).iter_add(1_isize), ) - .vec_ptr() + .ptr() .offset_from(v6.as_ptr()) as usize; let mut __tmp = Vec::new(); let mut __it = m.begin(); diff --git a/tests/unit/out/unsafe/vector_with_allocator.rs b/tests/unit/out/unsafe/vector_with_allocator.rs index 7fc34466a..043c3f180 100644 --- a/tests/unit/out/unsafe/vector_with_allocator.rs +++ b/tests/unit/out/unsafe/vector_with_allocator.rs @@ -134,7 +134,7 @@ unsafe fn main_0() -> i32 { let pos = >::from(UnsafeRandomAccessIterator::Vec( v2.as_mut_ptr(), )) - .vec_ptr() + .ptr() .offset_from(v2.as_ptr()) as usize; v2.remove(pos); >::from(UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr())) @@ -146,7 +146,7 @@ unsafe fn main_0() -> i32 { let pos = >::from(UnsafeRandomAccessIterator::Vec( v2.as_mut_ptr(), )) - .vec_ptr() + .ptr() .offset_from(v2.as_ptr()) as usize; v2.insert(pos, 100); >::from(UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr())) From 1cc35a97bf265fed59c105476729dcc8cd85e193 Mon Sep 17 00:00:00 2001 From: Lucian Popescu Date: Mon, 19 Oct 2026 18:47:17 +0100 Subject: [PATCH 8/9] Add RandomAccessIterator::index --- rules/iterator_category/shim.rs | 20 +++--- rules/vector/tgt_refcount.rs | 16 ++--- rules/vector/tgt_unsafe.rs | 12 ++-- .../refcount/unboxed_conditional_iterator.rs | 10 +-- tests/unit/out/refcount/vector.rs | 61 ++++++++++--------- .../out/refcount/vector_iter_range_ctor.rs | 5 +- .../out/refcount/vector_with_allocator.rs | 14 ++--- .../unsafe/unboxed_conditional_iterator.rs | 4 +- tests/unit/out/unsafe/vector.rs | 36 +++++------ .../unit/out/unsafe/vector_iter_range_ctor.rs | 4 +- .../unit/out/unsafe/vector_with_allocator.rs | 8 +-- 11 files changed, 97 insertions(+), 93 deletions(-) diff --git a/rules/iterator_category/shim.rs b/rules/iterator_category/shim.rs index 58413acb5..30b0811ea 100644 --- a/rules/iterator_category/shim.rs +++ b/rules/iterator_category/shim.rs @@ -338,14 +338,6 @@ macro_rules! random_access_iterator { Vec($ptr), } - impl $name { - pub fn ptr(&self) -> $ptr { - match self { - Self::Vec(p) => p.clone(), - } - } - } - impl Default for $name { fn default() -> Self { Self::Vec($null) @@ -354,7 +346,9 @@ macro_rules! random_access_iterator { impl Clone for $name { fn clone(&self) -> Self { - Self::Vec(self.ptr()) + match self { + Self::Vec(p) => Self::Vec(p.clone()), + } } } @@ -442,6 +436,14 @@ random_access_iterator!( Ptr::null() ); +impl RandomAccessIterator { + pub fn index(&self) -> usize { + match self { + Self::Vec(p) => p.get_offset(), + } + } +} + random_access_iterator!( UnsafeRandomAccessIterator, *mut T, diff --git a/rules/vector/tgt_refcount.rs b/rules/vector/tgt_refcount.rs index 36b707849..79cb3144b 100644 --- a/rules/vector/tgt_refcount.rs +++ b/rules/vector/tgt_refcount.rs @@ -10,9 +10,9 @@ fn f40(a0: Ptr) -> Ptr { } fn f60(a0: Ptr>, a1: RandomAccessIterator) -> RandomAccessIterator { - let idx = a1.ptr().get_offset(); - a0.with_mut(|__v: &mut Vec| __v.remove(idx)); - RandomAccessIterator::Vec(a0.decay()) + let __off = a1.iter_distance(&RandomAccessIterator::Vec(a0.decay())) as usize; + a0.with_mut(|__v: &mut Vec| __v.remove(__off)); + RandomAccessIterator::Vec(a0.decay() + __off) } fn f65(a0: Ptr) -> Ptr { @@ -40,13 +40,13 @@ fn f76(a0: Ptr) -> RandomAccessIterator { } fn f77(a0: &mut Vec, a1: RandomAccessIterator, a2: T1) -> RandomAccessIterator { - let __off = a1.ptr().get_offset(); + let __off = a1.index(); a0.insert(__off, a2); a1 } fn f79(a0: &mut Vec, a1: RandomAccessIterator, a2: T1) -> RandomAccessIterator { - let __off = a1.ptr().get_offset(); + let __off = a1.index(); a0.insert(__off, a2); a1 } @@ -91,7 +91,7 @@ fn f101>( a2: T3, a3: T3, ) -> RandomAccessIterator { - let start_idx = a1.ptr().get_offset(); + let start_idx = a1.iter_distance(&RandomAccessIterator::Vec(a0.decay())) as usize; let mut temp_vec: Vec = Vec::new(); let mut __it = a2; while __it != a3 { @@ -117,13 +117,13 @@ fn f105(a0: Ptr>, a1: Vec) { } fn f115(a0: &mut Vec, a1: RandomAccessIterator, a2: usize, a3: T1) -> RandomAccessIterator { - let __off = a1.ptr().get_offset(); + let __off = a1.index(); a0.splice(__off..__off, std::iter::repeat_n(a3, a2)); a1 } fn f116(a0: &mut Vec, a1: RandomAccessIterator, a2: Vec) -> RandomAccessIterator { - let __off = a1.ptr().get_offset(); + let __off = a1.index(); a0.splice(__off..__off, a2); a1 } diff --git a/rules/vector/tgt_unsafe.rs b/rules/vector/tgt_unsafe.rs index a15171e16..b194103e5 100644 --- a/rules/vector/tgt_unsafe.rs +++ b/rules/vector/tgt_unsafe.rs @@ -24,7 +24,7 @@ unsafe fn f47(a0: Vec) -> Vec { } unsafe fn f60(a0: &mut Vec, a1: UnsafeRandomAccessIterator) -> UnsafeRandomAccessIterator { - let pos = a1.ptr().offset_from(a0.as_ptr()) as usize; + let pos = a1.iter_distance(&UnsafeRandomAccessIterator::Vec(a0.as_mut_ptr())) as usize; a0.remove(pos); a1 } @@ -101,7 +101,7 @@ unsafe fn f76(a0: &mut Vec) -> UnsafeRandomAccessIterator { } unsafe fn f77(a0: &mut Vec, a1: UnsafeRandomAccessIterator, a2: T1) -> UnsafeRandomAccessIterator { - let pos = a1.ptr().offset_from(a0.as_ptr()) as usize; + let pos = a1.iter_distance(&UnsafeRandomAccessIterator::Vec(a0.as_mut_ptr())) as usize; a0.insert(pos, a2); a1 } @@ -111,7 +111,7 @@ unsafe fn f78(a0: usize, a1: T1) -> Vec { } unsafe fn f79(a0: &mut Vec, a1: UnsafeRandomAccessIterator, a2: T1) -> UnsafeRandomAccessIterator { - let pos = a1.ptr().offset_from(a0.as_ptr()) as usize; + let pos = a1.iter_distance(&UnsafeRandomAccessIterator::Vec(a0.as_mut_ptr())) as usize; a0.insert(pos, a2); a1 } @@ -169,7 +169,7 @@ unsafe fn f101>( a2: T3, a3: T3, ) -> UnsafeRandomAccessIterator { - let __off = a1.ptr().offset_from(a0.as_ptr()) as usize; + let __off = a1.iter_distance(&UnsafeRandomAccessIterator::Vec(a0.as_mut_ptr())) as usize; let mut __tmp = Vec::new(); let mut __it = a2; while __it != a3 { @@ -215,13 +215,13 @@ unsafe fn f114(a0: &mut Vec, init: T1) { } unsafe fn f115(a0: &mut Vec, a1: UnsafeRandomAccessIterator, a2: usize, a3: T1) -> UnsafeRandomAccessIterator { - let __off = a1.ptr().offset_from(a0.as_ptr()) as usize; + let __off = a1.iter_distance(&UnsafeRandomAccessIterator::Vec(a0.as_mut_ptr())) as usize; a0.splice(__off..__off, std::iter::repeat_n(a3, a2)); UnsafeRandomAccessIterator::Vec(a0.as_mut_ptr().add(__off)) } unsafe fn f116(a0: &mut Vec, a1: UnsafeRandomAccessIterator, a2: Vec) -> UnsafeRandomAccessIterator { - let __off = a1.ptr().offset_from(a0.as_ptr()) as usize; + let __off = a1.iter_distance(&UnsafeRandomAccessIterator::Vec(a0.as_mut_ptr())) as usize; a0.splice(__off..__off, a2); UnsafeRandomAccessIterator::Vec(a0.as_mut_ptr().add(__off)) } diff --git a/tests/unit/out/refcount/unboxed_conditional_iterator.rs b/tests/unit/out/refcount/unboxed_conditional_iterator.rs index 563802e74..f46e1a1aa 100644 --- a/tests/unit/out/refcount/unboxed_conditional_iterator.rs +++ b/tests/unit/out/refcount/unboxed_conditional_iterator.rs @@ -66,11 +66,11 @@ pub fn lehmer_2(mut sigma: Ptr, mut len: u32, mut code: Ptr) { as u32); elem!(code, i).write(__rhs); { - let idx = >::from((*it.borrow()).clone()) - .ptr() - .get_offset(); - (items.as_pointer() as Ptr>).with_mut(|__v: &mut Vec| __v.remove(idx)); - RandomAccessIterator::Vec((items.as_pointer() as Ptr>).decay()) + let __off = >::from((*it.borrow()).clone()).iter_distance( + &RandomAccessIterator::Vec((items.as_pointer() as Ptr>).decay()), + ) as usize; + (items.as_pointer() as Ptr>).with_mut(|__v: &mut Vec| __v.remove(__off)); + RandomAccessIterator::Vec((items.as_pointer() as Ptr>).decay() + __off) }; i.prefix_inc(); } diff --git a/tests/unit/out/refcount/vector.rs b/tests/unit/out/refcount/vector.rs index a3f77c115..66ab1d61b 100644 --- a/tests/unit/out/refcount/vector.rs +++ b/tests/unit/out/refcount/vector.rs @@ -55,13 +55,14 @@ fn main_0() -> i32 { }; assert!(((*v2.borrow()).len() == 3_usize)); { - let idx = >::from(RandomAccessIterator::Vec( + let __off = >::from(RandomAccessIterator::Vec( (v2.as_pointer() as Ptr), )) - .ptr() - .get_offset(); - (v2.as_pointer() as Ptr>).with_mut(|__v: &mut Vec| __v.remove(idx)); - RandomAccessIterator::Vec((v2.as_pointer() as Ptr>).decay()) + .iter_distance(&RandomAccessIterator::Vec( + (v2.as_pointer() as Ptr>).decay(), + )) as usize; + (v2.as_pointer() as Ptr>).with_mut(|__v: &mut Vec| __v.remove(__off)); + RandomAccessIterator::Vec((v2.as_pointer() as Ptr>).decay() + __off) }; assert!(((*v2.borrow()).len() == 2_usize)); assert!(({ (*v2.borrow())[0_usize] } == 2)); @@ -70,8 +71,7 @@ fn main_0() -> i32 { let __off = >::from(RandomAccessIterator::Vec( (v2.as_pointer() as Ptr), )) - .ptr() - .get_offset(); + .index(); (*v2.borrow_mut()).insert(__off, 100); >::from(RandomAccessIterator::Vec((v2.as_pointer() as Ptr))) }; @@ -85,8 +85,7 @@ fn main_0() -> i32 { let __off = >::from( RandomAccessIterator::Vec((v2.as_pointer() as Ptr)).iter_add(1_isize), ) - .ptr() - .get_offset(); + .index(); (*v2.borrow_mut()).insert(__off, x); >::from( RandomAccessIterator::Vec((v2.as_pointer() as Ptr)).iter_add(1_isize), @@ -100,8 +99,7 @@ fn main_0() -> i32 { let __off = >::from(RandomAccessIterator::Vec( (v2.as_pointer() as Ptr).to_end(), )) - .ptr() - .get_offset(); + .index(); (*v2.borrow_mut()).splice(__off..__off, std::iter::repeat_n(9, 2_usize)); >::from(RandomAccessIterator::Vec( (v2.as_pointer() as Ptr).to_end(), @@ -114,8 +112,7 @@ fn main_0() -> i32 { let __off = >::from( RandomAccessIterator::Vec((v2.as_pointer() as Ptr)).iter_add(2_isize), ) - .ptr() - .get_offset(); + .index(); (*v2.borrow_mut()).splice(__off..__off, vec![11, 12, 13]); >::from( RandomAccessIterator::Vec((v2.as_pointer() as Ptr)).iter_add(2_isize), @@ -133,8 +130,9 @@ fn main_0() -> i32 { let start_idx = >::from(RandomAccessIterator::Vec( (v2.as_pointer() as Ptr), )) - .ptr() - .get_offset(); + .iter_distance(&RandomAccessIterator::Vec( + (v2.as_pointer() as Ptr>).decay(), + )) as usize; let mut temp_vec: Vec = Vec::new(); let mut __it = RandomAccessIterator::Vec((src.as_pointer() as Ptr)); while __it != RandomAccessIterator::Vec((src.as_pointer() as Ptr).to_end()) { @@ -151,33 +149,36 @@ fn main_0() -> i32 { assert!(({ (*v2.borrow())[1_usize] } == 22)); assert!(({ (*v2.borrow())[2_usize] } == 100)); { - let idx = >::from(RandomAccessIterator::Vec( + let __off = >::from(RandomAccessIterator::Vec( (v2.as_pointer() as Ptr), )) - .ptr() - .get_offset(); - (v2.as_pointer() as Ptr>).with_mut(|__v: &mut Vec| __v.remove(idx)); - RandomAccessIterator::Vec((v2.as_pointer() as Ptr>).decay()) + .iter_distance(&RandomAccessIterator::Vec( + (v2.as_pointer() as Ptr>).decay(), + )) as usize; + (v2.as_pointer() as Ptr>).with_mut(|__v: &mut Vec| __v.remove(__off)); + RandomAccessIterator::Vec((v2.as_pointer() as Ptr>).decay() + __off) }; { - let idx = >::from(RandomAccessIterator::Vec( + let __off = >::from(RandomAccessIterator::Vec( (v2.as_pointer() as Ptr), )) - .ptr() - .get_offset(); - (v2.as_pointer() as Ptr>).with_mut(|__v: &mut Vec| __v.remove(idx)); - RandomAccessIterator::Vec((v2.as_pointer() as Ptr>).decay()) + .iter_distance(&RandomAccessIterator::Vec( + (v2.as_pointer() as Ptr>).decay(), + )) as usize; + (v2.as_pointer() as Ptr>).with_mut(|__v: &mut Vec| __v.remove(__off)); + RandomAccessIterator::Vec((v2.as_pointer() as Ptr>).decay() + __off) }; let mut i: i32 = 0; 'loop_: while (i < 4) { { - let idx = >::from( + let __off = >::from( RandomAccessIterator::Vec((v2.as_pointer() as Ptr)).iter_add(1_isize), ) - .ptr() - .get_offset(); - (v2.as_pointer() as Ptr>).with_mut(|__v: &mut Vec| __v.remove(idx)); - RandomAccessIterator::Vec((v2.as_pointer() as Ptr>).decay()) + .iter_distance(&RandomAccessIterator::Vec( + (v2.as_pointer() as Ptr>).decay(), + )) as usize; + (v2.as_pointer() as Ptr>).with_mut(|__v: &mut Vec| __v.remove(__off)); + RandomAccessIterator::Vec((v2.as_pointer() as Ptr>).decay() + __off) }; i.prefix_inc(); } diff --git a/tests/unit/out/refcount/vector_iter_range_ctor.rs b/tests/unit/out/refcount/vector_iter_range_ctor.rs index c89f499ae..5c583251e 100644 --- a/tests/unit/out/refcount/vector_iter_range_ctor.rs +++ b/tests/unit/out/refcount/vector_iter_range_ctor.rs @@ -143,8 +143,9 @@ fn main_0() -> i32 { RandomAccessIterator::Vec((v6.as_pointer() as Ptr<(Value, Value)>)) .iter_add(1_isize), ) - .ptr() - .get_offset(); + .iter_distance(&RandomAccessIterator::Vec( + (v6.as_pointer() as Ptr, Value)>>).decay(), + )) as usize; let mut temp_vec: Vec<(Value, Value)> = Vec::new(); let mut __it = (m.as_pointer() as Ptr, Value)>>) .with(|__m: &Map, Value)>| __m.begin()); diff --git a/tests/unit/out/refcount/vector_with_allocator.rs b/tests/unit/out/refcount/vector_with_allocator.rs index 6f5a2ec3f..a66aec15e 100644 --- a/tests/unit/out/refcount/vector_with_allocator.rs +++ b/tests/unit/out/refcount/vector_with_allocator.rs @@ -100,13 +100,14 @@ fn main_0() -> i32 { }; assert!(((*v2.borrow()).len() == 3_usize)); { - let idx = >::from(RandomAccessIterator::Vec( + let __off = >::from(RandomAccessIterator::Vec( (v2.as_pointer() as Ptr), )) - .ptr() - .get_offset(); - (v2.as_pointer() as Ptr>).with_mut(|__v: &mut Vec| __v.remove(idx)); - RandomAccessIterator::Vec((v2.as_pointer() as Ptr>).decay()) + .iter_distance(&RandomAccessIterator::Vec( + (v2.as_pointer() as Ptr>).decay(), + )) as usize; + (v2.as_pointer() as Ptr>).with_mut(|__v: &mut Vec| __v.remove(__off)); + RandomAccessIterator::Vec((v2.as_pointer() as Ptr>).decay() + __off) }; assert!(((*v2.borrow()).len() == 2_usize)); assert!(({ (*v2.borrow())[0_usize] } == 2)); @@ -115,8 +116,7 @@ fn main_0() -> i32 { let __off = >::from(RandomAccessIterator::Vec( (v2.as_pointer() as Ptr), )) - .ptr() - .get_offset(); + .index(); (*v2.borrow_mut()).insert(__off, 100); >::from(RandomAccessIterator::Vec((v2.as_pointer() as Ptr))) }; diff --git a/tests/unit/out/unsafe/unboxed_conditional_iterator.rs b/tests/unit/out/unsafe/unboxed_conditional_iterator.rs index f0126da19..76eff4570 100644 --- a/tests/unit/out/unsafe/unboxed_conditional_iterator.rs +++ b/tests/unit/out/unsafe/unboxed_conditional_iterator.rs @@ -57,8 +57,8 @@ pub unsafe fn lehmer_2(mut sigma: *const u32, mut len: u32, mut code: *mut u32) (it.iter_distance(&UnsafeRandomAccessIterator::Vec(items.as_mut_ptr())) as u32); { let pos = >::from((it).clone()) - .ptr() - .offset_from(items.as_ptr()) as usize; + .iter_distance(&UnsafeRandomAccessIterator::Vec(items.as_mut_ptr())) + as usize; items.remove(pos); >::from((it).clone()) }; diff --git a/tests/unit/out/unsafe/vector.rs b/tests/unit/out/unsafe/vector.rs index daee94b5a..91779b4d3 100644 --- a/tests/unit/out/unsafe/vector.rs +++ b/tests/unit/out/unsafe/vector.rs @@ -59,8 +59,8 @@ unsafe fn main_0() -> i32 { let pos = >::from(UnsafeRandomAccessIterator::Vec( v2.as_mut_ptr(), )) - .ptr() - .offset_from(v2.as_ptr()) as usize; + .iter_distance(&UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr())) + as usize; v2.remove(pos); >::from(UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr())) }; @@ -71,8 +71,8 @@ unsafe fn main_0() -> i32 { let pos = >::from(UnsafeRandomAccessIterator::Vec( v2.as_mut_ptr(), )) - .ptr() - .offset_from(v2.as_ptr()) as usize; + .iter_distance(&UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr())) + as usize; v2.insert(pos, 100); >::from(UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr())) }; @@ -86,8 +86,8 @@ unsafe fn main_0() -> i32 { let pos = >::from( UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr()).iter_add(1_isize), ) - .ptr() - .offset_from(v2.as_ptr()) as usize; + .iter_distance(&UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr())) + as usize; v2.insert(pos, x); >::from( UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr()).iter_add(1_isize), @@ -101,8 +101,8 @@ unsafe fn main_0() -> i32 { let __off = >::from(UnsafeRandomAccessIterator::Vec( v2.as_mut_ptr().add(v2.len()), )) - .ptr() - .offset_from(v2.as_ptr()) as usize; + .iter_distance(&UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr())) + as usize; v2.splice(__off..__off, std::iter::repeat_n(9, 2_usize)); UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr().add(__off)) }; @@ -113,8 +113,8 @@ unsafe fn main_0() -> i32 { let __off = >::from( UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr()).iter_add(2_isize), ) - .ptr() - .offset_from(v2.as_ptr()) as usize; + .iter_distance(&UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr())) + as usize; v2.splice(__off..__off, vec![11, 12, 13]); UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr().add(__off)) }; @@ -130,8 +130,8 @@ unsafe fn main_0() -> i32 { let __off = >::from(UnsafeRandomAccessIterator::Vec( v2.as_mut_ptr(), )) - .ptr() - .offset_from(v2.as_ptr()) as usize; + .iter_distance(&UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr())) + as usize; let mut __tmp = Vec::new(); let mut __it = UnsafeRandomAccessIterator::Vec(src.as_mut_ptr()); while __it != UnsafeRandomAccessIterator::Vec(src.as_mut_ptr().add(src.len())) { @@ -149,8 +149,8 @@ unsafe fn main_0() -> i32 { let pos = >::from(UnsafeRandomAccessIterator::Vec( v2.as_mut_ptr(), )) - .ptr() - .offset_from(v2.as_ptr()) as usize; + .iter_distance(&UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr())) + as usize; v2.remove(pos); >::from(UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr())) }; @@ -158,8 +158,8 @@ unsafe fn main_0() -> i32 { let pos = >::from(UnsafeRandomAccessIterator::Vec( v2.as_mut_ptr(), )) - .ptr() - .offset_from(v2.as_ptr()) as usize; + .iter_distance(&UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr())) + as usize; v2.remove(pos); >::from(UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr())) }; @@ -169,8 +169,8 @@ unsafe fn main_0() -> i32 { let pos = >::from( UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr()).iter_add(1_isize), ) - .ptr() - .offset_from(v2.as_ptr()) as usize; + .iter_distance(&UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr())) + as usize; v2.remove(pos); >::from( UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr()).iter_add(1_isize), diff --git a/tests/unit/out/unsafe/vector_iter_range_ctor.rs b/tests/unit/out/unsafe/vector_iter_range_ctor.rs index 4d8e9ffac..b7fef3955 100644 --- a/tests/unit/out/unsafe/vector_iter_range_ctor.rs +++ b/tests/unit/out/unsafe/vector_iter_range_ctor.rs @@ -106,8 +106,8 @@ unsafe fn main_0() -> i32 { let __off = >::from( UnsafeRandomAccessIterator::Vec(v6.as_mut_ptr()).iter_add(1_isize), ) - .ptr() - .offset_from(v6.as_ptr()) as usize; + .iter_distance(&UnsafeRandomAccessIterator::Vec(v6.as_mut_ptr())) + as usize; let mut __tmp = Vec::new(); let mut __it = m.begin(); while __it != m.end() { diff --git a/tests/unit/out/unsafe/vector_with_allocator.rs b/tests/unit/out/unsafe/vector_with_allocator.rs index 043c3f180..d137ba514 100644 --- a/tests/unit/out/unsafe/vector_with_allocator.rs +++ b/tests/unit/out/unsafe/vector_with_allocator.rs @@ -134,8 +134,8 @@ unsafe fn main_0() -> i32 { let pos = >::from(UnsafeRandomAccessIterator::Vec( v2.as_mut_ptr(), )) - .ptr() - .offset_from(v2.as_ptr()) as usize; + .iter_distance(&UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr())) + as usize; v2.remove(pos); >::from(UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr())) }; @@ -146,8 +146,8 @@ unsafe fn main_0() -> i32 { let pos = >::from(UnsafeRandomAccessIterator::Vec( v2.as_mut_ptr(), )) - .ptr() - .offset_from(v2.as_ptr()) as usize; + .iter_distance(&UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr())) + as usize; v2.insert(pos, 100); >::from(UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr())) }; From 4ca6ef0314a07caeaa33cba1d350792e29eadbcd Mon Sep 17 00:00:00 2001 From: Lucian Popescu Date: Mon, 19 Oct 2026 18:49:44 +0100 Subject: [PATCH 9/9] Use more index --- rules/vector/tgt_refcount.rs | 4 ++-- .../refcount/unboxed_conditional_iterator.rs | 4 +--- tests/unit/out/refcount/vector.rs | 20 +++++-------------- .../out/refcount/vector_iter_range_ctor.rs | 4 +--- .../out/refcount/vector_with_allocator.rs | 4 +--- 5 files changed, 10 insertions(+), 26 deletions(-) diff --git a/rules/vector/tgt_refcount.rs b/rules/vector/tgt_refcount.rs index 79cb3144b..9640256cd 100644 --- a/rules/vector/tgt_refcount.rs +++ b/rules/vector/tgt_refcount.rs @@ -10,7 +10,7 @@ fn f40(a0: Ptr) -> Ptr { } fn f60(a0: Ptr>, a1: RandomAccessIterator) -> RandomAccessIterator { - let __off = a1.iter_distance(&RandomAccessIterator::Vec(a0.decay())) as usize; + let __off = a1.index(); a0.with_mut(|__v: &mut Vec| __v.remove(__off)); RandomAccessIterator::Vec(a0.decay() + __off) } @@ -91,7 +91,7 @@ fn f101>( a2: T3, a3: T3, ) -> RandomAccessIterator { - let start_idx = a1.iter_distance(&RandomAccessIterator::Vec(a0.decay())) as usize; + let start_idx = a1.index(); let mut temp_vec: Vec = Vec::new(); let mut __it = a2; while __it != a3 { diff --git a/tests/unit/out/refcount/unboxed_conditional_iterator.rs b/tests/unit/out/refcount/unboxed_conditional_iterator.rs index f46e1a1aa..af439be5e 100644 --- a/tests/unit/out/refcount/unboxed_conditional_iterator.rs +++ b/tests/unit/out/refcount/unboxed_conditional_iterator.rs @@ -66,9 +66,7 @@ pub fn lehmer_2(mut sigma: Ptr, mut len: u32, mut code: Ptr) { as u32); elem!(code, i).write(__rhs); { - let __off = >::from((*it.borrow()).clone()).iter_distance( - &RandomAccessIterator::Vec((items.as_pointer() as Ptr>).decay()), - ) as usize; + let __off = >::from((*it.borrow()).clone()).index(); (items.as_pointer() as Ptr>).with_mut(|__v: &mut Vec| __v.remove(__off)); RandomAccessIterator::Vec((items.as_pointer() as Ptr>).decay() + __off) }; diff --git a/tests/unit/out/refcount/vector.rs b/tests/unit/out/refcount/vector.rs index 66ab1d61b..1c837f767 100644 --- a/tests/unit/out/refcount/vector.rs +++ b/tests/unit/out/refcount/vector.rs @@ -58,9 +58,7 @@ fn main_0() -> i32 { let __off = >::from(RandomAccessIterator::Vec( (v2.as_pointer() as Ptr), )) - .iter_distance(&RandomAccessIterator::Vec( - (v2.as_pointer() as Ptr>).decay(), - )) as usize; + .index(); (v2.as_pointer() as Ptr>).with_mut(|__v: &mut Vec| __v.remove(__off)); RandomAccessIterator::Vec((v2.as_pointer() as Ptr>).decay() + __off) }; @@ -130,9 +128,7 @@ fn main_0() -> i32 { let start_idx = >::from(RandomAccessIterator::Vec( (v2.as_pointer() as Ptr), )) - .iter_distance(&RandomAccessIterator::Vec( - (v2.as_pointer() as Ptr>).decay(), - )) as usize; + .index(); let mut temp_vec: Vec = Vec::new(); let mut __it = RandomAccessIterator::Vec((src.as_pointer() as Ptr)); while __it != RandomAccessIterator::Vec((src.as_pointer() as Ptr).to_end()) { @@ -152,9 +148,7 @@ fn main_0() -> i32 { let __off = >::from(RandomAccessIterator::Vec( (v2.as_pointer() as Ptr), )) - .iter_distance(&RandomAccessIterator::Vec( - (v2.as_pointer() as Ptr>).decay(), - )) as usize; + .index(); (v2.as_pointer() as Ptr>).with_mut(|__v: &mut Vec| __v.remove(__off)); RandomAccessIterator::Vec((v2.as_pointer() as Ptr>).decay() + __off) }; @@ -162,9 +156,7 @@ fn main_0() -> i32 { let __off = >::from(RandomAccessIterator::Vec( (v2.as_pointer() as Ptr), )) - .iter_distance(&RandomAccessIterator::Vec( - (v2.as_pointer() as Ptr>).decay(), - )) as usize; + .index(); (v2.as_pointer() as Ptr>).with_mut(|__v: &mut Vec| __v.remove(__off)); RandomAccessIterator::Vec((v2.as_pointer() as Ptr>).decay() + __off) }; @@ -174,9 +166,7 @@ fn main_0() -> i32 { let __off = >::from( RandomAccessIterator::Vec((v2.as_pointer() as Ptr)).iter_add(1_isize), ) - .iter_distance(&RandomAccessIterator::Vec( - (v2.as_pointer() as Ptr>).decay(), - )) as usize; + .index(); (v2.as_pointer() as Ptr>).with_mut(|__v: &mut Vec| __v.remove(__off)); RandomAccessIterator::Vec((v2.as_pointer() as Ptr>).decay() + __off) }; diff --git a/tests/unit/out/refcount/vector_iter_range_ctor.rs b/tests/unit/out/refcount/vector_iter_range_ctor.rs index 5c583251e..450485c99 100644 --- a/tests/unit/out/refcount/vector_iter_range_ctor.rs +++ b/tests/unit/out/refcount/vector_iter_range_ctor.rs @@ -143,9 +143,7 @@ fn main_0() -> i32 { RandomAccessIterator::Vec((v6.as_pointer() as Ptr<(Value, Value)>)) .iter_add(1_isize), ) - .iter_distance(&RandomAccessIterator::Vec( - (v6.as_pointer() as Ptr, Value)>>).decay(), - )) as usize; + .index(); let mut temp_vec: Vec<(Value, Value)> = Vec::new(); let mut __it = (m.as_pointer() as Ptr, Value)>>) .with(|__m: &Map, Value)>| __m.begin()); diff --git a/tests/unit/out/refcount/vector_with_allocator.rs b/tests/unit/out/refcount/vector_with_allocator.rs index a66aec15e..4498f9b09 100644 --- a/tests/unit/out/refcount/vector_with_allocator.rs +++ b/tests/unit/out/refcount/vector_with_allocator.rs @@ -103,9 +103,7 @@ fn main_0() -> i32 { let __off = >::from(RandomAccessIterator::Vec( (v2.as_pointer() as Ptr), )) - .iter_distance(&RandomAccessIterator::Vec( - (v2.as_pointer() as Ptr>).decay(), - )) as usize; + .index(); (v2.as_pointer() as Ptr>).with_mut(|__v: &mut Vec| __v.remove(__off)); RandomAccessIterator::Vec((v2.as_pointer() as Ptr>).decay() + __off) };