coerce_from_safe_fn is just fnptr->fnptr coercion

Author: BoxyUwU

compiler/rustc_hir_typeck/src/coercion.rs

@@ -797,34 +797,35 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
         self.unify_and(a, b, [], Adjust::ReborrowPin(mut_b))
     }
 
-    fn coerce_from_safe_fn(
+    // Coerces an fnptr `a` to a fnptr `b`, this is only `fn(..)` to `unsafe fn(..)`.
+    // Takes an `adjustment` used to get the `a` fnptr in the first place.
+    fn coerce_fnptrs(
         &self,
-        fn_ty_a: ty::PolyFnSig<'tcx>,
-        b: Ty<'tcx>,
+        a: ty::PolyFnSig<'tcx>,
+        b: ty::PolyFnSig<'tcx>,
         adjustment: Option<Adjust>,
     ) -> CoerceResult<'tcx> {
-        debug_assert!(self.shallow_resolve(b) == b);
-
         self.commit_if_ok(|snapshot| {
             let outer_universe = self.infcx.universe();
 
-            let result = if let ty::FnPtr(_, hdr_b) = b.kind()
-                && fn_ty_a.safety().is_safe()
-                && hdr_b.safety.is_unsafe()
-            {
-                let unsafe_a = self.tcx.safe_to_unsafe_fn_ty(fn_ty_a);
+            let a_ty = Ty::new_fn_ptr(self.tcx, a);
+            let b_ty = Ty::new_fn_ptr(self.tcx, b);
+
+            // Handle coercing `fn(..)` to `unsafe fn(..)`
+            let result = if a.safety().is_safe() && b.safety().is_unsafe() {
+                let unsafe_a_ty = self.tcx.safe_to_unsafe_fn_ty(a);
+                let adjustment = adjustment.map(|kind| Adjustment { kind, target: a_ty });
+
                 self.unify_and(
-                    unsafe_a,
-                    b,
-                    adjustment
-                        .map(|kind| Adjustment { kind, target: Ty::new_fn_ptr(self.tcx, fn_ty_a) }),
+                    unsafe_a_ty,
+                    b_ty,
+                    adjustment,
                     Adjust::Pointer(PointerCoercion::UnsafeFnPointer),
                 )
             } else {
-                let a = Ty::new_fn_ptr(self.tcx, fn_ty_a);
                 match adjustment {
-                    Some(adjust) => self.unify_and(a, b, [], adjust),
-                    None => self.unify(a, b),
+                    Some(adjust) => self.unify_and(a_ty, b_ty, [], adjust),
+                    None => self.unify(a_ty, b_ty),
                 }
             };
 
@@ -842,13 +843,16 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
 
     fn coerce_from_fn_pointer(
         &self,
-        fn_ty_a: ty::PolyFnSig<'tcx>,
+        a_sig: ty::PolyFnSig<'tcx>,
         b: Ty<'tcx>,
     ) -> CoerceResult<'tcx> {
-        debug!(?fn_ty_a, ?b, "coerce_from_fn_pointer");
+        debug!(?a_sig, ?b, "coerce_from_fn_pointer");
         debug_assert!(self.shallow_resolve(b) == b);
 
-        self.coerce_from_safe_fn(fn_ty_a, b, None)
+        match b.kind() {
+            ty::FnPtr(_, _) => self.coerce_fnptrs(a_sig, b.fn_sig(self.tcx), None),
+            _ => self.unify(Ty::new_fn_ptr(self.tcx, a_sig), b),
+        }
     }
 
     fn coerce_from_fn_item(&self, a: Ty<'tcx>, b: Ty<'tcx>) -> CoerceResult<'tcx> {
@@ -892,9 +896,9 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
                 let InferOk { value: a_sig, mut obligations } =
                     self.at(&self.cause, self.param_env).normalize(a_sig);
 
-                let InferOk { value, obligations: o2 } = self.coerce_from_safe_fn(
+                let InferOk { value, obligations: o2 } = self.coerce_fnptrs(
                     a_sig,
-                    b,
+                    b.fn_sig(self.tcx),
                     Some(Adjust::Pointer(PointerCoercion::ReifyFnPointer)),
                 )?;
 
@@ -941,6 +945,9 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
                 let pointer_ty =
                     Ty::new_fn_ptr(self.tcx, self.tcx.signature_unclosure(closure_sig, safety));
                 debug!("coerce_closure_to_fn(a={:?}, b={:?}, pty={:?})", a, b, pointer_ty);
+
+                // We don't use `self.coerce_fnptrs` as handling `fn` to `unsafe fn`
+                // was trivial to do so ourselves.
                 self.unify_and(
                     pointer_ty,
                     b,