Update tests

Author: lucic71

tests/ub/out/refcount/ctor_ref_member.rs

@@ -6,7 +6,7 @@ use std::io::prelude::*;
 use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
-#[derive(Default)]
+#[derive(Clone, Default)]
 pub struct S {
     pub r: Ptr<i32>,
 }
@@ -17,15 +17,6 @@ impl S {
         Rc::try_unwrap(__this).ok().unwrap().into_inner()
     }
 }
-impl Clone for S {
-    fn clone(&self) -> Self {
-        let __this: Value<S> = Rc::new(RefCell::new(Self {
-            r: (self.r).clone(),
-        }));
-        let this: Ptr<S> = __this.as_pointer();
-        Rc::try_unwrap(__this).ok().unwrap().into_inner()
-    }
-}
 impl ByteRepr for S {}
 pub fn main() {
     __cpp2rust_init_globals();

tests/ub/out/refcount/ub6.rs

@@ -6,21 +6,11 @@ use std::io::prelude::*;
 use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
-#[derive(Default)]
+#[derive(Clone, Default)]
 pub struct Pair {
     pub x1: Ptr<i32>,
     pub x2: Ptr<i32>,
 }
-impl Clone for Pair {
-    fn clone(&self) -> Self {
-        let __this: Value<Pair> = Rc::new(RefCell::new(Self {
-            x1: (self.x1).clone(),
-            x2: (self.x2).clone(),
-        }));
-        let this: Ptr<Pair> = __this.as_pointer();
-        Rc::try_unwrap(__this).ok().unwrap().into_inner()
-    }
-}
 impl ByteRepr for Pair {}
 pub fn mkPair_0(x1: Ptr<i32>, x2: Ptr<i32>) -> Pair {
     return Pair {

tests/unit/out/refcount/complex_function.rs

@@ -43,19 +43,10 @@ impl ByteRepr for X1 {
         }
     }
 }
-#[derive(Default)]
+#[derive(Clone, Default)]
 pub struct X2 {
     pub v: Ptr<X1>,
 }
-impl Clone for X2 {
-    fn clone(&self) -> Self {
-        let __this: Value<X2> = Rc::new(RefCell::new(Self {
-            v: (self.v).clone(),
-        }));
-        let this: Ptr<X2> = __this.as_pointer();
-        Rc::try_unwrap(__this).ok().unwrap().into_inner()
-    }
-}
 impl ByteRepr for X2 {}
 #[derive(Default)]
 pub struct X3 {

tests/unit/out/refcount/destructor.rs

@@ -9,15 +9,8 @@ use std::rc::{Rc, Weak};
 thread_local!(
     pub static global_0: Value<i32> = Rc::new(RefCell::new(0));
 );
-#[derive(Default)]
+#[derive(Clone, Default)]
 pub struct S {}
-impl Clone for S {
-    fn clone(&self) -> Self {
-        let __this: Value<S> = Rc::new(RefCell::new(Self {}));
-        let this: Ptr<S> = __this.as_pointer();
-        Rc::try_unwrap(__this).ok().unwrap().into_inner()
-    }
-}
 impl ByteRepr for S {
     fn byte_size() -> usize {
         1

tests/unit/out/refcount/fn_ptr_default_arg.rs

@@ -27,13 +27,36 @@ fn main_0() -> i32 {
     assert!((({ apply_1(5, None,) }) == 5));
     assert!((({ apply_1(5, Some(FnPtr::<fn(i32) -> i32>::null()),) }) == 5));
     assert!((({ apply_1(5, Some(FnPtr::<fn(i32) -> i32>::new(identity_0)),) }) == 5));
-    let negate: Value<FnPtr<fn(i32) -> i32>> = Rc::new(RefCell::new(FnPtr::new(
-        (|x: i32| {
-            let x: Value<i32> = Rc::new(RefCell::new(x));
-            return -(*x.borrow());
-        }),
-    )));
+    let negate: Value<FnPtr<fn(i32) -> i32>> =
+        Rc::new(RefCell::new(({ (lambda_2 {}).to_free_function() })));
     assert!((({ apply_1(5, Some((*negate.borrow()).clone()),) }) == -5_i32));
     return 0;
 }
+#[derive(Clone, Default)]
+pub struct lambda_2 {}
+impl lambda_2 {
+    pub fn operator_call(x: i32) -> i32 {
+        let x: Value<i32> = Rc::new(RefCell::new(x));
+        return -(*x.borrow());
+    }
+}
+impl ByteRepr for lambda_2 {
+    fn byte_size() -> usize {
+        1
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {}
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {}
+    }
+}
+impl Callable1<i32, i32> for lambda_2 {
+    fn call(&self, a1: i32) -> i32 {
+        { lambda_2::operator_call(a1) }
+    }
+}
+impl lambda_2 {
+    pub fn to_free_function(&self) -> FnPtr<fn(i32) -> i32> {
+        FnPtr::new(lambda_2::operator_call)
+    }
+}
 pub fn __cpp2rust_init_globals() {}

tests/unit/out/refcount/function_overloading.rs

@@ -36,15 +36,8 @@ pub fn foo_3(x: Ptr<i32>, y: Ptr<i32>, z: Ptr<i32>) -> i32 {
 pub fn bar_4(x: Ptr<i32>) -> i32 {
     return (x.read());
 }
-#[derive(Default)]
+#[derive(Clone, Default)]
 pub struct Foo {}
-impl Clone for Foo {
-    fn clone(&self) -> Self {
-        let __this: Value<Foo> = Rc::new(RefCell::new(Self {}));
-        let this: Ptr<Foo> = __this.as_pointer();
-        Rc::try_unwrap(__this).ok().unwrap().into_inner()
-    }
-}
 impl ByteRepr for Foo {
     fn byte_size() -> usize {
         1

tests/unit/out/refcount/global_init_side_effect.rs

@@ -9,7 +9,7 @@ use std::rc::{Rc, Weak};
 thread_local!(
     pub static total_0: Value<i32> = Rc::new(RefCell::new(0));
 );
-#[derive(Default)]
+#[derive(Clone, Default)]
 pub struct S {}
 impl S {
     pub fn S(x: i32) -> Self {
@@ -20,13 +20,6 @@ impl S {
         Rc::try_unwrap(__this).ok().unwrap().into_inner()
     }
 }
-impl Clone for S {
-    fn clone(&self) -> Self {
-        let __this: Value<S> = Rc::new(RefCell::new(Self {}));
-        let this: Ptr<S> = __this.as_pointer();
-        Rc::try_unwrap(__this).ok().unwrap().into_inner()
-    }
-}
 impl ByteRepr for S {
     fn byte_size() -> usize {
         1

tests/unit/out/refcount/global_non_const_init.rs

@@ -99,15 +99,8 @@ thread_local!(
 thread_local!(
     pub static inline_member_11: Value<Ctor> = Rc::new(RefCell::new(Ctor::Ctor2({ 5 })));
 );
-#[derive(Default)]
+#[derive(Clone, Default)]
 pub struct Holder {}
-impl Clone for Holder {
-    fn clone(&self) -> Self {
-        let __this: Value<Holder> = Rc::new(RefCell::new(Self {}));
-        let this: Ptr<Holder> = __this.as_pointer();
-        Rc::try_unwrap(__this).ok().unwrap().into_inner()
-    }
-}
 impl ByteRepr for Holder {
     fn byte_size() -> usize {
         1

tests/unit/out/refcount/lambda_as_template_argument.rs

@@ -30,6 +30,7 @@ pub fn apply_twice_6(fn_: lambda_3, x: i32) -> i32 {
     });
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -131,3 +132,4 @@ impl lambda_5 {
         FnPtr::new(lambda_5::operator_call)
     }
 }
+pub fn __cpp2rust_init_globals() {}

tests/unit/out/refcount/lambda_basic.rs

@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -157,3 +158,4 @@ impl Callable0<i32> for lambda_4 {
         { lambda_4::operator_call(self) }
     }
 }
+pub fn __cpp2rust_init_globals() {}