leak check when lubbing fndefs

Author: BoxyUwU

compiler/rustc_hir_typeck/src/coercion.rs

@@ -1156,9 +1156,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     (ty::FnDef(..), ty::FnDef(..)) => {
                         // Don't reify if the function types have a LUB, i.e., they
                         // are the same function and their parameters have a LUB.
-                        match self.commit_if_ok(|_| {
+                        match self.commit_if_ok(|snapshot| {
+                            let outer_universe = self.infcx.universe();
+
                             // We need to eagerly handle nested obligations due to lazy norm.
-                            if self.next_trait_solver() {
+                            let result = if self.next_trait_solver() {
                                 let ocx = ObligationCtxt::new(self);
                                 let value = ocx.lub(cause, self.param_env, prev_ty, new_ty)?;
                                 if ocx.try_evaluate_obligations().is_empty() {
@@ -1171,7 +1173,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                                 }
                             } else {
                                 self.at(cause, self.param_env).lub(prev_ty, new_ty)
-                            }
+                            };
+
+                            self.leak_check(outer_universe, Some(snapshot))?;
+                            result
                         }) {
                             // We have a LUB of prev_ty and new_ty, just return it.
                             Ok(ok) => return Ok(self.register_infer_ok_obligations(ok)),

tests/ui/coercion/leak_check_fndef_lub.rs

@@ -0,0 +1,32 @@
+//@ check-pass
+
+fn foo<T>() {}
+
+fn fndef_lub_leak_check() {
+    macro_rules! lub {
+        ($lhs:expr, $rhs:expr) => {
+            if true { $lhs } else { $rhs }
+        };
+    }
+
+    // These don't current lub but could in theory one day.
+    // If that happens this test should be adjusted to use
+    // fn ptrs that can't be lub'd.
+    let lhs = foo::<for<'a> fn(&'static (), &'a ())>;
+    let rhs = foo::<for<'a> fn(&'a (), &'static ())>;
+
+    // If we leak check then we know we should coerce these
+    // to `fn()`, if we don't leak check we may try to keep
+    // them as `FnDef`s which would result in a borrowck
+    // error.
+    let lubbed = lub!(lhs, rhs);
+
+    // assert that we coerced lhs/rhs to a fn ptr
+    is_fnptr(lubbed);
+}
+
+trait FnPtr {}
+impl FnPtr for fn() {}
+fn is_fnptr<T: FnPtr>(_: T) {}
+
+fn main() {}