Auto merge of #49224 - Centril:feature/shared-fn, r=<try>

impl Fn/FnMut/FnOnce for Arc/Rc

This PR introduces the ability to have `Rc/Arc<F>: Fn(A) -> B where F: Fn(A) -> B` and `Rc/Arc<Fn(A) -> B`.

This was previously tried (and failed) in #34118 (comment) due to breakage with crater. But now that the new edition is approaching we might want to try this in edition 2018. We should probably do a new crater run to see how much the breakage has changed since the previous attempt.

cc @aturon

Author: bors

src/liballoc/arc.rs

@@ -1414,6 +1414,72 @@ impl<T> From<Vec<T>> for Arc<[T]> {
     }
 }
 
+mod fn_impls {
+    use super::Arc;
+
+    #[stable(feature = "shared_fn_impls", since = "1.26.0")]
+    impl<A, F: ?Sized + Fn<A>> Fn<A> for Arc<F> {
+        extern "rust-call" fn call(&self, args: A) -> F::Output {
+            (**self).call(args)
+        }
+    }
+
+    #[stable(feature = "shared_fn_impls", since = "1.26.0")]
+    impl<A, F: ?Sized + Fn<A>> FnMut<A> for Arc<F> {
+        extern "rust-call" fn call_mut(&mut self, args: A) -> F::Output {
+            (**self).call(args)
+        }
+    }
+
+    #[stable(feature = "shared_fn_impls", since = "1.26.0")]
+    impl<A, F: ?Sized + Fn<A>> FnOnce<A> for Arc<F> {
+        type Output = F::Output;
+
+        extern "rust-call" fn call_once(self, args: A) -> F::Output {
+            (&*self).call(args)
+        }
+    }
+
+    #[cfg(test)]
+    mod tests {
+        use super::Arc;
+
+        #[test]
+        fn is_fn() {
+            use_fn(Arc::new(|x| x + 1));
+        }
+
+        #[test]
+        fn is_fn_mut() {
+            use_fn_mut(Arc::new(|x| x + 1));
+        }
+
+        #[test]
+        fn is_fn_once() {
+            use_fn_once(Arc::new(|x| x + 1));
+        }
+
+        #[test]
+        fn can_dyn_dispatch() {
+            let dyn_dispatch: Arc<Fn(u8) -> u8> = Arc::new(|x| x + 1);
+            use_fn(dyn_dispatch);
+        }
+
+        fn use_fn_once<F: FnOnce(u8) -> u8>(fun: F) {
+            assert_eq!(2, fun(1));
+        }
+
+        fn use_fn_mut<F: FnMut(u8) -> u8>(mut fun: F) {
+            assert_eq!(2, fun(1));
+            assert_eq!(3, fun(2));
+        }
+
+        fn use_fn<F: Fn(u8) -> u8>(fun: F) {
+            assert_eq!(2, fun(1));
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use std::boxed::Box;

src/liballoc/lib.rs

@@ -124,8 +124,9 @@
 #![feature(exact_chunks)]
 #![feature(pointer_methods)]
 #![feature(inclusive_range_fields)]
+#![feature(fn_traits)]
 
-#![cfg_attr(not(test), feature(fn_traits, swap_with_slice, i128))]
+#![cfg_attr(not(test), feature(swap_with_slice, i128))]
 #![cfg_attr(test, feature(test))]
 
 // Allow testing this library

src/liballoc/rc.rs

@@ -1389,6 +1389,72 @@ impl<T: ?Sized> RcBoxPtr<T> for Weak<T> {
     }
 }
 
+mod fn_impls {
+    use super::Rc;
+
+    #[stable(feature = "shared_fn_impls", since = "1.26.0")]
+    impl<A, F: ?Sized + Fn<A>> Fn<A> for Rc<F> {
+        extern "rust-call" fn call(&self, args: A) -> F::Output {
+            (**self).call(args)
+        }
+    }
+
+    #[stable(feature = "shared_fn_impls", since = "1.26.0")]
+    impl<A, F: ?Sized + Fn<A>> FnMut<A> for Rc<F> {
+        extern "rust-call" fn call_mut(&mut self, args: A) -> F::Output {
+            (**self).call(args)
+        }
+    }
+
+    #[stable(feature = "shared_fn_impls", since = "1.26.0")]
+    impl<A, F: ?Sized + Fn<A>> FnOnce<A> for Rc<F> {
+        type Output = F::Output;
+
+        extern "rust-call" fn call_once(self, args: A) -> F::Output {
+            (&*self).call(args)
+        }
+    }
+
+    #[cfg(test)]
+    mod tests {
+        use super::Rc;
+
+        #[test]
+        fn is_fn() {
+            use_fn(Rc::new(|x| x + 1));
+        }
+
+        #[test]
+        fn is_fn_mut() {
+            use_fn_mut(Rc::new(|x| x + 1));
+        }
+
+        #[test]
+        fn is_fn_once() {
+            use_fn_once(Rc::new(|x| x + 1));
+        }
+
+        #[test]
+        fn can_dyn_dispatch() {
+            let dyn_dispatch: Rc<Fn(u8) -> u8> = Rc::new(|x| x + 1);
+            use_fn(dyn_dispatch);
+        }
+
+        fn use_fn_once<F: FnOnce(u8) -> u8>(fun: F) {
+            assert_eq!(2, fun(1));
+        }
+
+        fn use_fn_mut<F: FnMut(u8) -> u8>(mut fun: F) {
+            assert_eq!(2, fun(1));
+            assert_eq!(3, fun(2));
+        }
+
+        fn use_fn<F: Fn(u8) -> u8>(fun: F) {
+            assert_eq!(2, fun(1));
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::{Rc, Weak};