Check if test passes on macOS

Author: lucic71

tests/unit/out/refcount/redundant_copy_in_conversion.rs

@@ -6,6 +6,15 @@ use std::io::prelude::*;
 use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
+pub fn sink_0(it: RefcountMapIter<i32, i32>) -> i32 {
+    let it: Value<RefcountMapIter<i32, i32>> = Rc::new(RefCell::new(it));
+    let cit: Value<RefcountMapIter<i32, i32>> = Rc::new(RefCell::new((*it.borrow()).clone()));
+    return if (*cit.borrow()) == (*it.borrow()).clone() {
+        (*(*it.borrow()).second().borrow())
+    } else {
+        0
+    };
+}
 pub fn main() {
     std::process::exit(main_0());
 }
@@ -21,12 +30,26 @@ fn main_0() -> i32 {
     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),
+    let it0: Value<RefcountMapIter<i32, i32>> = Rc::new(RefCell::new(RefcountMapIter::find_key(
+        (m.as_pointer() as Ptr<BTreeMap<i32, Value<i32>>>),
+        &0,
+    )));
+    let const_it: Value<RefcountMapIter<i32, i32>> = Rc::new(RefCell::new((*it0.borrow()).clone()));
+    let r: Value<i32> = Rc::new(RefCell::new(
+        if (*const_it.borrow()) == (*end.borrow()).clone() {
+            0
+        } else {
+            1
+        },
     ));
-    return if (*const_it.borrow()) == (*end.borrow()) {
+    (*r.borrow_mut()) += ({
+        let _it: RefcountMapIter<i32, i32> = (*it0.borrow()).clone();
+        sink_0(_it)
+    });
+    (*r.borrow_mut()) += if (*end.borrow()) == (*end.borrow()) {
         0
     } else {
         1
     };
+    return (*r.borrow());
 }

tests/unit/out/unsafe/redundant_copy_in_conversion.rs

@@ -6,6 +6,10 @@ use std::collections::BTreeMap;
 use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
+pub unsafe fn sink_0(mut it: UnsafeMapIterator<i32, i32>) -> i32 {
+    let mut cit: UnsafeMapIterator<i32, i32> = it.clone();
+    return if cit == it.clone() { *it.second() } else { 0 };
+}
 pub fn main() {
     unsafe {
         std::process::exit(main_0() as i32);
@@ -16,7 +20,14 @@ unsafe fn main_0() -> i32 {
     (*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> =
+    let mut it0: UnsafeMapIterator<i32, i32> =
         UnsafeMapIterator::find_key(&m as *const BTreeMap<i32, Box<i32>>, &0);
-    return if const_it == end { 0 } else { 1 };
+    let mut const_it: UnsafeMapIterator<i32, i32> = it0.clone();
+    let mut r: i32 = if const_it == end.clone() { 0 } else { 1 };
+    r += (unsafe {
+        let _it: UnsafeMapIterator<i32, i32> = it0.clone();
+        sink_0(_it)
+    });
+    r += if end == end { 0 } else { 1 };
+    return r;
 }

tests/unit/redundant_copy_in_conversion.cpp

@@ -1,10 +1,16 @@
 #include <map>
 
+static int sink(std::map<int, int>::iterator it) {
+  std::map<int, int>::const_iterator cit(it);
+  return cit == it ? it->second : 0;
+}
+
 int main() {
   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);
+  std::map<int, int>::iterator it0 = m.find(0);
+  std::map<int, int>::const_iterator const_it = it0;
   // Comparing const_iterator with iterator forces an implicit conversion of
   // `end` to const_iterator. The AST shape differs between platforms:
   //
@@ -13,5 +19,8 @@ int main() {
   //
   // The extra inner CopyCtor on macOS would emit a redundant .clone() in the
   // generated Rust. cpp2rust suppresses it so the output matches Linux.
-  return const_it == end ? 0 : 1;
+  int r = const_it == end ? 0 : 1;
+  r += sink(it0);
+  r += end == end ? 0 : 1;
+  return r;
 }