less leak checks

Author: BoxyUwU

compiler/rustc_hir_typeck/src/coercion.rs

@@ -123,7 +123,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
         Coerce { fcx, cause, allow_two_phase, use_lub: false, coerce_never }
     }
 
-    fn unify_raw(&self, a: Ty<'tcx>, b: Ty<'tcx>) -> InferResult<'tcx, Ty<'tcx>> {
+    fn unify_raw(&self, a: Ty<'tcx>, b: Ty<'tcx>, leak_check: bool) -> InferResult<'tcx, Ty<'tcx>> {
         debug!("unify(a: {:?}, b: {:?}, use_lub: {})", a, b, self.use_lub);
         self.commit_if_ok(|snapshot| {
             let outer_universe = self.infcx.universe();
@@ -169,15 +169,17 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
             //
             // FIXME: Ideally the actual `eq/sub/lub` would handle leak checks
             // themselves whenever a binder is entered.
-            self.leak_check(outer_universe, Some(snapshot))?;
+            if leak_check || self.use_lub {
+                self.leak_check(outer_universe, Some(snapshot))?;
+            }
 
             res
         })
     }
 
     /// Unify two types (using sub or lub).
     fn unify(&self, a: Ty<'tcx>, b: Ty<'tcx>) -> CoerceResult<'tcx> {
-        self.unify_raw(a, b)
+        self.unify_raw(a, b, false)
             .and_then(|InferOk { value: ty, obligations }| success(vec![], ty, obligations))
     }
 
@@ -188,8 +190,9 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
         b: Ty<'tcx>,
         adjustments: impl IntoIterator<Item = Adjustment<'tcx>>,
         final_adjustment: Adjust,
+        leak_check: bool,
     ) -> CoerceResult<'tcx> {
-        self.unify_raw(a, b).and_then(|InferOk { value: ty, obligations }| {
+        self.unify_raw(a, b, leak_check).and_then(|InferOk { value: ty, obligations }| {
             success(
                 adjustments
                     .into_iter()
@@ -405,7 +408,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
             // the `Target` type with the pointee of `b`. This is necessary
             // to properly account for the differing variances of the pointees
             // of `&` vs `&mut` references.
-            match self.unify_raw(autorefd_deref_ty, b) {
+            match self.unify_raw(autorefd_deref_ty, b, false) {
                 Ok(ok) => Some(ok),
                 Err(err) => {
                     if first_error.is_none() {
@@ -602,6 +605,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
             target,
             reborrow.into_iter().flat_map(|(deref, autoref)| [deref, autoref]),
             Adjust::Pointer(PointerCoercion::Unsize),
+            false,
         )?;
 
         // Create an obligation for `Source: CoerceUnsized<Target>`.
@@ -816,7 +820,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
 
         // To complete the reborrow, we need to make sure we can unify the inner types, and if so we
         // add the adjustments.
-        self.unify_and(a, b, [], Adjust::ReborrowPin(mut_b))
+        self.unify_and(a, b, [], Adjust::ReborrowPin(mut_b), false)
     }
 
     fn coerce_from_fn_pointer(
@@ -832,7 +836,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
             ty::FnPtr(_, b_hdr) if a_sig.safety().is_safe() && b_hdr.safety.is_unsafe() => {
                 let a = self.tcx.safe_to_unsafe_fn_ty(a_sig);
                 let adjust = Adjust::Pointer(PointerCoercion::UnsafeFnPointer);
-                self.unify_and(a, b, [], adjust)
+                self.unify_and(a, b, [], adjust, true)
             }
             _ => self.unify(a, b),
         }
@@ -854,7 +858,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
                 let a = Ty::new_fn_ptr(self.tcx, a_sig);
 
                 let adjust = Adjust::Pointer(PointerCoercion::ReifyFnPointer(b_hdr.safety));
-                let InferOk { value, obligations: o2 } = self.unify_and(a, b, [], adjust)?;
+                let InferOk { value, obligations: o2 } = self.unify_and(a, b, [], adjust, true)?;
 
                 obligations.extend(o2);
                 Ok(InferOk { value, obligations })
@@ -880,7 +884,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
                 // We don't use `self.coerce_fnptrs` as handling `fn` to `unsafe fn`
                 // was trivial to do so ourselves.
                 let adjust = Adjust::Pointer(PointerCoercion::ClosureFnPointer(safety));
-                self.unify_and(pointer_ty, b, [], adjust)
+                self.unify_and(pointer_ty, b, [], adjust, true)
             }
             _ => self.unify(a, b),
         }
@@ -914,9 +918,10 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
                 b,
                 [Adjustment { kind: Adjust::Deref(None), target: mt_a.ty }],
                 Adjust::Borrow(AutoBorrow::RawPtr(mutbl_b)),
+                false,
             )
         } else if mt_a.mutbl != mutbl_b {
-            self.unify_and(a_raw, b, [], Adjust::Pointer(PointerCoercion::MutToConstPointer))
+            self.unify_and(a_raw, b, [], Adjust::Pointer(PointerCoercion::MutToConstPointer), false)
         } else {
             self.unify(a_raw, b)
         }
@@ -1017,7 +1022,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         // We don't ever need two-phase here since we throw out the result of the coercion.
         let coerce = Coerce::new(self, cause, AllowTwoPhase::No, true);
         coerce.autoderef(DUMMY_SP, expr_ty).find_map(|(ty, steps)| {
-            self.probe(|_| coerce.unify_raw(ty, target)).ok().map(|_| steps)
+            self.probe(|_| coerce.unify_raw(ty, target, false)).ok().map(|_| steps)
         })
     }