Allow closure to extern fn pointer coercion

src/librustc/ty/adjustment.rs

@@ -3,6 +3,7 @@ use crate::hir::def_id::DefId;
 use crate::ty::{self, Ty, TyCtxt};
 use crate::ty::subst::SubstsRef;
 use rustc_macros::HashStable;
+use rustc_target::spec::abi;
 
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, RustcEncodable, RustcDecodable, HashStable)]
@@ -15,7 +16,7 @@ pub enum PointerCast {
 
     /// Go from a non-capturing closure to an fn pointer or an unsafe fn pointer.
     /// It cannot convert a closure that requires unsafe.
-    ClosureFnPointer(hir::Unsafety),
+    ClosureFnPointer(hir::Unsafety, abi::Abi),
 
     /// Go from a mut raw pointer to a const raw pointer.
     MutToConstPointer,

src/librustc/ty/context.rs

@@ -2420,21 +2420,20 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
     /// `hir::Unsafety::Unsafe` in the previous example, then you would get
     /// an `unsafe fn (u32, i32)`.
     /// It cannot convert a closure that requires unsafe.
-    pub fn coerce_closure_fn_ty(self, sig: PolyFnSig<'tcx>, unsafety: hir::Unsafety) -> Ty<'tcx> {
+    pub fn coerce_closure_fn_ty(
+        self,
+        sig: PolyFnSig<'tcx>,
+        unsafety: hir::Unsafety,
+        abi: abi::Abi,
+    ) -> Ty<'tcx> {
         let converted_sig = sig.map_bound(|s| {
             let params_iter = match s.inputs()[0].sty {
                 ty::Tuple(params) => {
                     params.into_iter().map(|k| k.expect_ty())
                 }
                 _ => bug!(),
             };
-            self.mk_fn_sig(
-                params_iter,
-                s.output(),
-                s.c_variadic,
-                unsafety,
-                abi::Abi::Rust,
-            )
+            self.mk_fn_sig(params_iter, s.output(), s.c_variadic, unsafety, abi)
         });
 
         self.mk_fn_ptr(converted_sig)

src/librustc_codegen_ssa/mir/rvalue.rs

@@ -192,7 +192,7 @@ impl<'a, 'tcx: 'a, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                             }
                         }
                     }
-                    mir::CastKind::Pointer(PointerCast::ClosureFnPointer(_)) => {
+                    mir::CastKind::Pointer(PointerCast::ClosureFnPointer(_, _)) => {
                         match operand.layout.ty.sty {
                             ty::Closure(def_id, substs) => {
                                 let instance = Instance::resolve_closure(

src/librustc_mir/borrow_check/nll/type_check/mod.rs

@@ -2011,14 +2011,14 @@ impl<'a, 'gcx, 'tcx> TypeChecker<'a, 'gcx, 'tcx> {
                         }
                     }
 
-                    CastKind::Pointer(PointerCast::ClosureFnPointer(unsafety)) => {
+                    CastKind::Pointer(PointerCast::ClosureFnPointer(unsafety, abi)) => {
                         let sig = match op.ty(body, tcx).sty {
                             ty::Closure(def_id, substs) => {
                                 substs.closure_sig_ty(def_id, tcx).fn_sig(tcx)
                             }
                             _ => bug!(),
                         };
-                        let ty_fn_ptr_from = tcx.coerce_closure_fn_ty(sig, *unsafety);
+                        let ty_fn_ptr_from = tcx.coerce_closure_fn_ty(sig, *unsafety, *abi);
 
                         if let Err(terr) = self.eq_types(
                             ty_fn_ptr_from,

src/librustc_mir/interpret/cast.rs

@@ -104,7 +104,7 @@ impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> InterpretCx<'a, 'mir, 'tcx, M>
                 }
             }
 
-            Pointer(PointerCast::ClosureFnPointer(_)) => {
+            Pointer(PointerCast::ClosureFnPointer(_, _)) => {
                 // The src operand does not matter, just its type
                 match src.layout.ty.sty {
                     ty::Closure(def_id, substs) => {

src/librustc_mir/monomorphize/collector.rs

@@ -569,7 +569,7 @@ impl<'a, 'tcx> MirVisitor<'tcx> for MirNeighborCollector<'a, 'tcx> {
                 visit_fn_use(self.tcx, fn_ty, false, &mut self.output);
             }
             mir::Rvalue::Cast(
-                mir::CastKind::Pointer(PointerCast::ClosureFnPointer(_)), ref operand, _
+                mir::CastKind::Pointer(PointerCast::ClosureFnPointer(_, _)), ref operand, _
             ) => {
                 let source_ty = operand.ty(self.body, self.tcx);
                 let source_ty = self.tcx.subst_and_normalize_erasing_regions(

src/librustc_mir/transform/qualify_min_const_fn.rs

@@ -160,7 +160,7 @@ fn check_rvalue(
             check_operand(operand, span)
         }
         Rvalue::Cast(CastKind::Pointer(PointerCast::UnsafeFnPointer), _, _) |
-        Rvalue::Cast(CastKind::Pointer(PointerCast::ClosureFnPointer(_)), _, _) |
+        Rvalue::Cast(CastKind::Pointer(PointerCast::ClosureFnPointer(_, _)), _, _) |
         Rvalue::Cast(CastKind::Pointer(PointerCast::ReifyFnPointer), _, _) => Err((
             span,
             "function pointer casts are not allowed in const fn".into(),

src/librustc_typeck/check/coercion.rs

@@ -739,11 +739,12 @@ impl<'f, 'gcx, 'tcx> Coerce<'f, 'gcx, 'tcx> {
                 //     `unsafe fn(arg0,arg1,...) -> _`
                 let sig = self.closure_sig(def_id_a, substs_a);
                 let unsafety = fn_ty.unsafety();
-                let pointer_ty = self.tcx.coerce_closure_fn_ty(sig, unsafety);
+                let abi = fn_ty.abi();
+                let pointer_ty = self.tcx.coerce_closure_fn_ty(sig, unsafety, abi);
                 debug!("coerce_closure_to_fn(a={:?}, b={:?}, pty={:?})",
                        a, b, pointer_ty);
                 self.unify_and(pointer_ty, b, simple(
-                    Adjust::Pointer(PointerCast::ClosureFnPointer(unsafety))
+                    Adjust::Pointer(PointerCast::ClosureFnPointer(unsafety, abi))
                 ))
             }
             _ => self.unify_and(a, b, identity),

src/libsyntax/feature_gate.rs

@@ -567,6 +567,9 @@ declare_features! (
     // #[repr(transparent)] on unions.
     (active, transparent_unions, "1.37.0", Some(60405), None),
 
+    // Allows coercing non-capturing closures to fn pointers of non-Rust ABI
+    (active, closure_to_extern_fn_coercion, "1.37.0", Some(44291), None),
+
     // -------------------------------------------------------------------------
     // feature-group-end: actual feature gates
     // -------------------------------------------------------------------------

src/libsyntax_pos/symbol.rs

@@ -175,6 +175,7 @@ symbols! {
         Clone,
         clone_closures,
         clone_from,
+        closure_to_extern_fn_coercion,
         closure_to_fn_coercion,
         cmp,
         cmpxchg16b_target_feature,

src/test/ui/closure-to-extern-fn-ptr-coercion/coerce-closure-extern-c.rs

@@ -0,0 +1,18 @@
+// compile-pass
+
+#![feature(closure_to_extern_fn_coercion)]
+
+fn call_extern_c(func: extern "C" fn()) {
+    func()
+}
+
+unsafe fn call_unsafe_extern_c(func: unsafe extern "C" fn()) {
+    func()
+}
+
+pub fn main() {
+    call_extern_c(|| {});
+    unsafe {
+        call_unsafe_extern_c(|| {});
+    }
+}

src/test/ui/closure-to-extern-fn-ptr-coercion/coerce-closure-unsafe-extern-c.rs

@@ -0,0 +1,6 @@
+#![feature(closure_to_extern_fn_coercion)]
+
+fn main() {
+    let _: unsafe extern "C" fn() = || { ::std::pin::Pin::new_unchecked(&0_u8); }; //~ ERROR E0133
+    let _: unsafe extern "C" fn() = || unsafe { ::std::pin::Pin::new_unchecked(&0_u8); }; // OK
+}

src/test/ui/closure-to-extern-fn-ptr-coercion/coerce-closure-unsafe-extern-c.stderr

@@ -0,0 +1,11 @@
+error[E0133]: call to unsafe function is unsafe and requires unsafe function or block
+  --> $DIR/coerce-closure-unsafe-extern-c.rs:4:42
+   |
+LL |     let _: unsafe extern "C" fn() = || { ::std::pin::Pin::new_unchecked(&0_u8); };
+   |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
+   |
+   = note: consult the function's documentation for information on how to avoid undefined behavior
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0133`.

src/test/ui/closure-to-extern-fn-ptr-coercion/feature-gate-required.rs

@@ -0,0 +1,14 @@
+fn call_extern_c(func: extern "C" fn()) {
+    func()
+}
+
+unsafe fn call_unsafe_extern_c(func: unsafe extern "C" fn()) {
+    func()
+}
+
+pub fn main() {
+    call_extern_c(|| {}); //~ ERROR
+    unsafe {
+        call_unsafe_extern_c(|| {}); //~ ERROR
+    }
+}