Change return types and check return values in tests.

This allows to verify that we handle
different types as return types,
and that we call the expected functions.

Author: cjgillot

src/test/ui/issue-18952.rs renamed to src/test/run-pass/issue-18952.rs

@@ -9,41 +9,48 @@ struct Foo;
 impl Fn<(isize, isize)> for Foo {
     extern "rust-call" fn call(&self, args: (isize, isize)) -> Self::Output {
         println!("{:?}", args);
+        (args.0 + 1, args.1 + 1)
     }
 }
 
 impl FnMut<(isize, isize)> for Foo {
     extern "rust-call" fn call_mut(&mut self, args: (isize, isize)) -> Self::Output {
         println!("{:?}", args);
+        (args.0 + 1, args.1 + 1)
     }
 }
 
 impl FnOnce<(isize, isize)> for Foo {
-    type Output = ();
+    type Output = (isize, isize);
     extern "rust-call" fn call_once(self, args: (isize, isize)) -> Self::Output {
         println!("{:?}", args);
+        (args.0 + 1, args.1 + 1)
     }
 }
 
 impl Fn<(isize, isize, isize)> for Foo {
     extern "rust-call" fn call(&self, args: (isize, isize, isize)) -> Self::Output {
         println!("{:?}", args);
+        (args.0 + 3, args.1 + 3, args.2 + 3)
     }
 }
 
 impl FnMut<(isize, isize, isize)> for Foo {
     extern "rust-call" fn call_mut(&mut self, args: (isize, isize, isize)) -> Self::Output {
         println!("{:?}", args);
+        (args.0 + 3, args.1 + 3, args.2 + 3)
     }
 }
 impl FnOnce<(isize, isize, isize)> for Foo {
-    type Output = ();
+    type Output = (isize, isize, isize);
     extern "rust-call" fn call_once(self, args: (isize, isize, isize)) -> Self::Output {
         println!("{:?}", args);
+        (args.0 + 3, args.1 + 3, args.2 + 3)
     }
 }
 
 fn main() {
     let foo = Foo;
-    foo(1, 1);
+    assert_eq!(foo(1, 1), (2, 2));
+    assert_eq!(foo(1, 1, 1), (4, 4, 4));
 }

src/test/ui/issue-45510.rs renamed to src/test/run-pass/issue-45510.rs

@@ -4,25 +4,29 @@
 #![feature(fn_traits)]
 #![feature(unboxed_closures)]
 
+#[derive(Debug, PartialEq, Eq)]
 struct Ishmael;
+#[derive(Debug, PartialEq, Eq)]
 struct Maybe;
 struct CallMe;
 
 impl FnOnce<(Ishmael,)> for CallMe {
-    type Output = ();
-    extern "rust-call" fn call_once(self, _args: (Ishmael,)) -> () {
+    type Output = Ishmael;
+    extern "rust-call" fn call_once(self, _args: (Ishmael,)) -> Ishmael {
         println!("Split your lungs with blood and thunder!");
+        Ishmael
     }
 }
 
 impl FnOnce<(Maybe,)> for CallMe {
-    type Output = ();
-    extern "rust-call" fn call_once(self, _args: (Maybe,)) -> () {
+    type Output = Maybe;
+    extern "rust-call" fn call_once(self, _args: (Maybe,)) -> Maybe {
         println!("So we just met, and this is crazy");
+        Maybe
     }
 }
 
 fn main() {
-    CallMe(Ishmael);
-    CallMe(Maybe);
+    assert_eq!(CallMe(Ishmael), Ishmael);
+    assert_eq!(CallMe(Maybe), Maybe);
 }