Implement Fn traits for functions of any ABI

This brings the behavior of the language in line with the documentation
in `library/core/src/primitive_docs.rs`.

Author: Jules-Bertholet

compiler/rustc_abi/src/extern_abi.rs

@@ -369,6 +369,43 @@ impl ExternAbi {
             | Self::Swift => true,
         }
     }
+
+    /// Returns whether safe functions with this ABI implement the `Fn` traits.
+    /// `false` only for uncallable or internal ABIs.
+    pub fn is_fn_trait_compatible(self) -> bool {
+        match self {
+            ExternAbi::C { .. }
+            | ExternAbi::System { .. }
+            | ExternAbi::Rust
+            | ExternAbi::RustCold
+            | ExternAbi::RustPreserveNone
+            | ExternAbi::RustTail
+            | ExternAbi::EfiApi
+            | ExternAbi::Swift
+            | ExternAbi::Aapcs { .. }
+            | ExternAbi::CmseNonSecureCall
+            | ExternAbi::CmseNonSecureEntry
+            | ExternAbi::Cdecl { .. }
+            | ExternAbi::Stdcall { .. }
+            | ExternAbi::Fastcall { .. }
+            | ExternAbi::Thiscall { .. }
+            | ExternAbi::Vectorcall { .. }
+            | ExternAbi::SysV64 { .. }
+            | ExternAbi::Win64 { .. } => true,
+            ExternAbi::RustCall
+            | ExternAbi::RustInvalid
+            | ExternAbi::Unadjusted
+            | ExternAbi::Custom
+            | ExternAbi::GpuKernel
+            | ExternAbi::PtxKernel
+            | ExternAbi::AvrInterrupt
+            | ExternAbi::AvrNonBlockingInterrupt
+            | ExternAbi::Msp430Interrupt
+            | ExternAbi::RiscvInterruptM
+            | ExternAbi::RiscvInterruptS
+            | ExternAbi::X86Interrupt => false,
+        }
+    }
 }
 
 pub fn all_names() -> Vec<&'static str> {

compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs

@@ -5,7 +5,6 @@ use std::path::PathBuf;
 use std::{debug_assert_matches, iter};
 
 use itertools::{EitherOrBoth, Itertools};
-use rustc_abi::ExternAbi;
 use rustc_attr_ir::lang_items::{self, LangItem};
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::codes::*;
@@ -5490,9 +5489,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                 ..
             } = fn_ty.fn_sig(tcx).skip_binder()
             // FIXME(splat): this might need to change if the Fn* traits start using/supporting splat
-            && fn_sig.abi() == ExternAbi::Rust
-            && !fn_sig.c_variadic()
-            && fn_sig.safety() == hir::Safety::Safe
+            && fn_sig.is_fn_trait_compatible()
 
             // Extract first param of fn sig with peeled refs, e.g. `fn(&T)` -> `T`
             && let Some(&ty::Ref(_, target_ty, needs_mut)) = fn_sig.inputs().first().map(|t| t.kind())

compiler/rustc_type_ir/src/ty_kind.rs

@@ -1145,7 +1145,7 @@ impl<I: Interner> FnSig<I> {
     }
 
     pub fn is_fn_trait_compatible(self) -> bool {
-        !self.c_variadic() && self.safety().is_safe() && self.abi() == ExternAbi::Rust
+        !self.c_variadic() && self.safety().is_safe() && self.abi().is_fn_trait_compatible()
     }
 
     /// Set the safety flag.

src/tools/miri/tests/pass/fn-traits-abi.rs

@@ -0,0 +1,39 @@
+//! Test implementation of `Fn` traits for functions with non-`Rust` ABI
+
+use std::ops::{Fn, FnMut, FnOnce};
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+struct Foo(i32, i32);
+
+extern "C" fn square(foo: Foo) -> Foo {
+    Foo(foo.0 * foo.1, foo.0 - foo.1)
+}
+
+fn call_it<F: ?Sized + Fn(Foo) -> Foo>(f: &F, i: Foo) -> Foo {
+    f(i)
+}
+
+fn call_it_mut<F: ?Sized + FnMut(Foo) -> Foo>(f: &mut F, i: Foo) -> Foo {
+    f(i)
+}
+
+fn call_it_once<F: FnOnce(Foo) -> Foo>(f: F, i: Foo) -> Foo {
+    f(i)
+}
+
+fn main() {
+    assert_eq!(call_it(&square, Foo(20, 10)), Foo(200, 10));
+    assert_eq!(call_it_mut(&mut square, Foo(21, 9)), Foo(189, 12));
+    assert_eq!(call_it_once(square, Foo(18, -3)), Foo(-54, 21));
+
+    let mut square_ptr: extern "C" fn(Foo) -> Foo = square;
+    assert_eq!(call_it(&square_ptr, Foo(30, 11)), Foo(330, 19));
+    assert_eq!(call_it_mut(&mut square_ptr, Foo(273, -1)), Foo(-273, 274));
+    assert_eq!(call_it_once(square_ptr, Foo(27, 27)), Foo(729, 0));
+
+    let mut square_dyn: Box<dyn Fn(Foo) -> Foo> = Box::new(square);
+    assert_eq!(call_it(&*square_dyn, Foo(1, 3)), Foo(3, -2));
+    assert_eq!(call_it_mut(&mut *square_dyn, Foo(5, 25)), Foo(125, -20));
+    assert_eq!(call_it_once(square_dyn, Foo(9, 2)), Foo(18, 7));
+}

tests/ui/async-await/async-closures/fn-exception.rs

@@ -15,5 +15,5 @@ fn test(f: impl AsyncFn()) {}
 
 fn main() {
     test(unsafety); //~ ERROR the trait bound
-    test(abi); //~ ERROR the trait bound
+    test(abi);
 }

tests/ui/async-await/async-closures/fn-exception.stderr

@@ -12,20 +12,6 @@ note: required by a bound in `test`
 LL | fn test(f: impl AsyncFn()) {}
    |                 ^^^^^^^^^ required by this bound in `test`
 
-error[E0277]: the trait bound `extern "C" fn() -> Pin<Box<(dyn Future<Output = ()> + 'static)>> {abi}: AsyncFn()` is not satisfied
-  --> $DIR/fn-exception.rs:18:10
-   |
-LL |     test(abi);
-   |     ---- ^^^ the trait `AsyncFn()` is not implemented for fn item `extern "C" fn() -> Pin<Box<(dyn Future<Output = ()> + 'static)>> {abi}`
-   |     |
-   |     required by a bound introduced by this call
-   |
-note: required by a bound in `test`
-  --> $DIR/fn-exception.rs:14:17
-   |
-LL | fn test(f: impl AsyncFn()) {}
-   |                 ^^^^^^^^^ required by this bound in `test`
-
-error: aborting due to 2 previous errors
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.

tests/ui/extern/extern-wrong-value-type.rs

@@ -1,11 +1,13 @@
+//@ run-pass
+
 extern "C" fn f() {
 }
 
-fn is_fn<F>(_: F) where F: Fn() {}
+fn is_fn<F>(f: F) where F: Fn() {
+    f();
+}
 
 fn main() {
-    // extern functions are extern "C" fn
     let _x: extern "C" fn() = f; // OK
     is_fn(f);
-    //~^ ERROR expected an `Fn()` closure, found `extern "C" fn() {f}`
 }

tests/ui/extern/extern-wrong-value-type.stderr

@@ -2,19 +2,15 @@ fn produces_string() -> Option<String> {
     Some("my cool string".to_owned())
 }
 
-fn takes_str_but_too_many_refs(_: &&str) -> Option<()> {
+fn takes_str_but_too_many_refs(_: &str) -> Option<()> {
     Some(())
 }
 
 fn no_args() -> Option<()> {
     Some(())
 }
 
-extern "C" fn takes_str_but_wrong_abi(_: &str) -> Option<()> {
-    Some(())
-}
-
-unsafe fn takes_str_but_unsafe(_: &str) -> Option<()> {
+unsafe fn takes_str_but_unsafe(_: String) -> Option<()> {
     Some(())
 }
 
@@ -23,10 +19,8 @@ struct TypeWithoutDeref;
 fn main() {
     let _ = produces_string().and_then(takes_str_but_too_many_refs);
     //~^ ERROR type mismatch in function arguments
-    let _ = produces_string().and_then(takes_str_but_wrong_abi);
-    //~^ ERROR expected an `FnOnce(String)` closure, found `for<'a> extern "C" fn(&'a str) -> Option<()> {takes_str_but_wrong_abi}`
     let _ = produces_string().and_then(takes_str_but_unsafe);
-    //~^ ERROR expected an `FnOnce(String)` closure, found `for<'a> unsafe fn(&'a str) -> Option<()> {takes_str_but_unsafe}`
+    //~^ ERROR expected an `FnOnce(String)` closure, found `unsafe fn(String) -> Option<()> {takes_str_but_unsafe}`
     let _ = produces_string().and_then(no_args);
     //~^ ERROR function is expected to take 1 argument, but it takes 0 arguments
     let _ = Some(TypeWithoutDeref).and_then(takes_str_but_too_many_refs);

tests/ui/mismatched_types/suggest-option-asderef-unfixable.rs

@@ -1,50 +1,42 @@
 error[E0631]: type mismatch in function arguments
-  --> $DIR/suggest-option-asderef-unfixable.rs:24:40
+  --> $DIR/suggest-option-asderef-unfixable.rs:20:40
    |
-LL | fn takes_str_but_too_many_refs(_: &&str) -> Option<()> {
-   | ------------------------------------------------------ found signature defined here
+LL | fn takes_str_but_too_many_refs(_: &str) -> Option<()> {
+   | ----------------------------------------------------- found signature defined here
 ...
 LL |     let _ = produces_string().and_then(takes_str_but_too_many_refs);
    |                               -------- ^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected due to this
    |                               |
    |                               required by a bound introduced by this call
    |
    = note: expected function signature `fn(String) -> _`
-              found function signature `fn(&&str) -> _`
+              found function signature `fn(&str) -> _`
 note: required by a bound in `Option::<T>::and_then`
   --> $SRC_DIR/core/src/option.rs:LL:COL
 help: consider wrapping the function in a closure
    |
-LL |     let _ = produces_string().and_then(|arg0: String| takes_str_but_too_many_refs(/* &&str */));
-   |                                        ++++++++++++++                            +++++++++++++
-
-error[E0277]: expected an `FnOnce(String)` closure, found `for<'a> extern "C" fn(&'a str) -> Option<()> {takes_str_but_wrong_abi}`
-  --> $DIR/suggest-option-asderef-unfixable.rs:26:40
-   |
-LL |     let _ = produces_string().and_then(takes_str_but_wrong_abi);
-   |                               -------- ^^^^^^^^^^^^^^^^^^^^^^^ expected an `FnOnce(String)` closure, found `for<'a> extern "C" fn(&'a str) -> Option<()> {takes_str_but_wrong_abi}`
-   |                               |
-   |                               required by a bound introduced by this call
+LL |     let _ = produces_string().and_then(|arg0: String| takes_str_but_too_many_refs(/* &str */));
+   |                                        ++++++++++++++                            ++++++++++++
+help: call `Option::as_deref()` first
    |
-   = help: the trait `FnOnce(String)` is not implemented for fn item `for<'a> extern "C" fn(&'a str) -> Option<()> {takes_str_but_wrong_abi}`
-note: required by a bound in `Option::<T>::and_then`
-  --> $SRC_DIR/core/src/option.rs:LL:COL
+LL |     let _ = produces_string().as_deref().and_then(takes_str_but_too_many_refs);
+   |                              +++++++++++
 
-error[E0277]: expected an `FnOnce(String)` closure, found `for<'a> unsafe fn(&'a str) -> Option<()> {takes_str_but_unsafe}`
-  --> $DIR/suggest-option-asderef-unfixable.rs:28:40
+error[E0277]: expected an `FnOnce(String)` closure, found `unsafe fn(String) -> Option<()> {takes_str_but_unsafe}`
+  --> $DIR/suggest-option-asderef-unfixable.rs:22:40
    |
 LL |     let _ = produces_string().and_then(takes_str_but_unsafe);
    |                               -------- ^^^^^^^^^^^^^^^^^^^^ call the function in a closure: `|| unsafe { /* code */ }`
    |                               |
    |                               required by a bound introduced by this call
    |
-   = help: the trait `FnOnce(String)` is not implemented for fn item `for<'a> unsafe fn(&'a str) -> Option<()> {takes_str_but_unsafe}`
+   = help: the trait `FnOnce(String)` is not implemented for fn item `unsafe fn(String) -> Option<()> {takes_str_but_unsafe}`
    = note: unsafe function cannot be called generically without an unsafe block
 note: required by a bound in `Option::<T>::and_then`
   --> $SRC_DIR/core/src/option.rs:LL:COL
 
 error[E0593]: function is expected to take 1 argument, but it takes 0 arguments
-  --> $DIR/suggest-option-asderef-unfixable.rs:30:40
+  --> $DIR/suggest-option-asderef-unfixable.rs:24:40
    |
 LL | fn no_args() -> Option<()> {
    | -------------------------- takes 0 arguments
@@ -58,26 +50,26 @@ note: required by a bound in `Option::<T>::and_then`
   --> $SRC_DIR/core/src/option.rs:LL:COL
 
 error[E0631]: type mismatch in function arguments
-  --> $DIR/suggest-option-asderef-unfixable.rs:32:45
+  --> $DIR/suggest-option-asderef-unfixable.rs:26:45
    |
-LL | fn takes_str_but_too_many_refs(_: &&str) -> Option<()> {
-   | ------------------------------------------------------ found signature defined here
+LL | fn takes_str_but_too_many_refs(_: &str) -> Option<()> {
+   | ----------------------------------------------------- found signature defined here
 ...
 LL |     let _ = Some(TypeWithoutDeref).and_then(takes_str_but_too_many_refs);
    |                                    -------- ^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected due to this
    |                                    |
    |                                    required by a bound introduced by this call
    |
    = note: expected function signature `fn(TypeWithoutDeref) -> _`
-              found function signature `fn(&&str) -> _`
+              found function signature `fn(&str) -> _`
 note: required by a bound in `Option::<T>::and_then`
   --> $SRC_DIR/core/src/option.rs:LL:COL
 help: consider wrapping the function in a closure
    |
-LL |     let _ = Some(TypeWithoutDeref).and_then(|arg0: TypeWithoutDeref| takes_str_but_too_many_refs(/* &&str */));
-   |                                             ++++++++++++++++++++++++                            +++++++++++++
+LL |     let _ = Some(TypeWithoutDeref).and_then(|arg0: TypeWithoutDeref| takes_str_but_too_many_refs(/* &str */));
+   |                                             ++++++++++++++++++++++++                            ++++++++++++
 
-error: aborting due to 5 previous errors
+error: aborting due to 4 previous errors
 
 Some errors have detailed explanations: E0277, E0593, E0631.
 For more information about an error, try `rustc --explain E0277`.