Use std::map::iterator

Author: lucic71

tests/unit/out/refcount/redundant_copy_in_conversion.rs

@@ -6,54 +6,27 @@ use std::io::prelude::*;
 use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
-#[derive(Default)]
-pub struct iter {
-    pub p: Value<Ptr<i32>>,
-}
-impl Clone for iter {
-    fn clone(&self) -> Self {
-        let mut this = Self {
-            p: Rc::new(RefCell::new((*self.p.borrow()).clone())),
-        };
-        this
-    }
-}
-impl ByteRepr for iter {}
-#[derive(Default)]
-pub struct const_iter {
-    pub p: Value<Ptr<i32>>,
-}
-impl const_iter {
-    pub fn const_iter(o: Ptr<iter>) -> Self {
-        let mut this = Self {
-            p: Rc::new(RefCell::new((*(*o.upgrade().deref()).p.borrow()).clone())),
-        };
-        this
-    }
-}
-impl Clone for const_iter {
-    fn clone(&self) -> Self {
-        let mut this = Self {
-            p: Rc::new(RefCell::new(Ptr::<i32>::null())),
-        };
-        this
-    }
-}
-impl ByteRepr for const_iter {}
-pub fn sink_0(i: const_iter) {
-    let i: Value<const_iter> = Rc::new(RefCell::new(i));
-}
 pub fn main() {
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
-    let buf: Value<Box<[i32]>> = Rc::new(RefCell::new(Box::new([0, 0])));
-    let it: Value<iter> = Rc::new(RefCell::new(iter {
-        p: Rc::new(RefCell::new((buf.as_pointer() as Ptr<i32>))),
-    }));
-    ({
-        let _i: const_iter = const_iter::const_iter(it.as_pointer());
-        sink_0(_i)
-    });
-    return 0;
+    let m: Value<BTreeMap<i32, Value<i32>>> = Rc::new(RefCell::new(BTreeMap::new()));
+    (m.as_pointer() as Ptr<BTreeMap<i32, Value<i32>>>)
+        .with_mut(|__v: &mut BTreeMap<i32, Value<i32>>| {
+            __v.entry(0.clone())
+                .or_insert_with(|| Rc::new(RefCell::new(<i32>::default())))
+                .as_pointer()
+        })
+        .write(1);
+    let end: Value<RefcountMapIter<i32, i32>> = Rc::new(RefCell::new(RefcountMapIter::end(
+        (m.as_pointer() as Ptr<BTreeMap<i32, Value<i32>>>),
+    )));
+    let const_it: Value<RefcountMapIter<i32, i32>> = Rc::new(RefCell::new(
+        RefcountMapIter::find_key((m.as_pointer() as Ptr<BTreeMap<i32, Value<i32>>>), &0),
+    ));
+    return if (*const_it.borrow()) == (*end.borrow()) {
+        0
+    } else {
+        1
+    };
 }

tests/unit/out/unsafe/redundant_copy_in_conversion.rs

@@ -6,38 +6,17 @@ use std::collections::BTreeMap;
 use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
-#[repr(C)]
-#[derive(Copy, Clone, Default)]
-pub struct iter {
-    pub p: *mut i32,
-}
-#[repr(C)]
-#[derive(Copy, Clone, Default)]
-pub struct const_iter {
-    pub p: *const i32,
-}
-impl const_iter {
-    pub unsafe fn const_iter(o: *const iter) -> Self {
-        let mut this = Self {
-            p: (*o).p.cast_const(),
-        };
-        this
-    }
-}
-pub unsafe fn sink_0(mut i: const_iter) {}
 pub fn main() {
     unsafe {
         std::process::exit(main_0() as i32);
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut buf: [i32; 2] = [0, 0];
-    let mut it: iter = iter {
-        p: buf.as_mut_ptr(),
-    };
-    (unsafe {
-        let _i: const_iter = const_iter::const_iter(&it as *const iter);
-        sink_0(_i)
-    });
-    return 0;
+    let mut m: BTreeMap<i32, Box<i32>> = BTreeMap::new();
+    (*m.entry(0).or_default().as_mut()) = 1;
+    let mut end: UnsafeMapIterator<i32, i32> =
+        UnsafeMapIterator::end(&m as *const BTreeMap<i32, Box<i32>>);
+    let mut const_it: UnsafeMapIterator<i32, i32> =
+        UnsafeMapIterator::find_key(&m as *const BTreeMap<i32, Box<i32>>, &0);
+    return if const_it == end { 0 } else { 1 };
 }

tests/unit/redundant_copy_in_conversion.cpp

@@ -1,20 +1,9 @@
-struct iter {
-  using iterator_category = int;
-  int *p;
-};
-
-struct const_iter {
-  using iterator_category = int;
-  const int *p;
-  const_iter(const iter &o) : p(o.p) {}
-  const_iter(const const_iter &) = default;
-};
-
-static void sink(const_iter i) {}
+#include <map>
 
 int main() {
-  int buf[2] = {0, 0};
-  iter it{buf};
-  sink(it);
-  return 0;
+  std::map<int, int> m;
+  m[0] = 1;
+  std::map<int, int>::iterator end = m.end();
+  std::map<int, int>::const_iterator const_it = m.find(0);
+  return const_it == end ? 0 : 1;
 }