fix some expected found diagnostic changes

Author: BoxyUwU

compiler/rustc_hir_typeck/src/coercion.rs

@@ -847,7 +847,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
         match b.kind() {
             ty::FnPtr(_, hdr) => {
                 let safety = hdr.safety;
-                let closure_sig = self.sig_for_closure_coercion(a, Some(hdr.safety))?;
+                let closure_sig = self.sig_for_closure_coercion(a, Some(hdr.safety), b)?;
                 let pointer_ty = Ty::new_fn_ptr(self.tcx, closure_sig);
                 debug!("coerce_closure_to_fn(a={:?}, b={:?}, pty={:?})", a, b, pointer_ty);
 
@@ -1014,10 +1014,14 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         })
     }
 
-    fn sig_for_coerce_lub(&self, ty: Ty<'tcx>) -> Result<ty::PolyFnSig<'tcx>, TypeError<'tcx>> {
+    fn sig_for_coerce_lub(
+        &self,
+        ty: Ty<'tcx>,
+        coerce_target_for_diag: Ty<'tcx>,
+    ) -> Result<ty::PolyFnSig<'tcx>, TypeError<'tcx>> {
         match ty.kind() {
             ty::FnDef(..) => self.sig_for_fn_def_coercion(ty, None),
-            ty::Closure(..) => self.sig_for_closure_coercion(ty, None),
+            ty::Closure(..) => self.sig_for_closure_coercion(ty, None, coerce_target_for_diag),
             _ => unreachable!("`sig_for_fn_def_closure_coerce_lub` called with wrong ty: {:?}", ty),
         }
     }
@@ -1069,6 +1073,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         &self,
         closure: Ty<'tcx>,
         expected_safety: Option<hir::Safety>,
+        coerce_target_for_diag: Ty<'tcx>,
     ) -> Result<ty::PolyFnSig<'tcx>, TypeError<'tcx>> {
         let tcx = self.tcx;
 
@@ -1083,7 +1088,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         // All we care here is if any variable is being captured and not the exact paths,
         // so we check `upvars_mentioned` for root variables being captured.
         if !tcx.upvars_mentioned(closure_def.expect_local()).is_none_or(|u| u.is_empty()) {
-            return Err(TypeError::Mismatch);
+            return Err(TypeError::Sorts(ty::error::ExpectedFound::new(
+                closure,
+                coerce_target_for_diag,
+            )));
         }
 
         // We coerce the closure, which has fn type
@@ -1153,15 +1161,15 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 match lubbed_ty {
                     Ok(ok) => return Ok(self.register_infer_ok_obligations(ok)),
                     Err(_) => {
-                        let a_sig = self.sig_for_coerce_lub(prev_ty)?;
-                        let b_sig = self.sig_for_coerce_lub(new_ty)?;
+                        let a_sig = self.sig_for_coerce_lub(prev_ty, new_ty)?;
+                        let b_sig = self.sig_for_coerce_lub(new_ty, prev_ty)?;
                         Some((a_sig, b_sig))
                     }
                 }
             }
             (ty::Closure(..), ty::FnDef(..)) | (ty::FnDef(..), ty::Closure(..)) => {
-                let a_sig = self.sig_for_coerce_lub(prev_ty)?;
-                let b_sig = self.sig_for_coerce_lub(new_ty)?;
+                let a_sig = self.sig_for_coerce_lub(prev_ty, new_ty)?;
+                let b_sig = self.sig_for_coerce_lub(new_ty, prev_ty)?;
                 Some((a_sig, b_sig))
             }
             // ty::FnPtr x ty::FnPtr is fine to just be handled through a normal `unify`