for<..> fn(..) lub fn(..) should lub to fn(..)

Author: BoxyUwU

compiler/rustc_infer/src/infer/relate/lattice.rs

@@ -26,7 +26,9 @@ use tracing::{debug, instrument};
 
 use super::StructurallyRelateAliases;
 use super::combine::PredicateEmittingRelation;
-use crate::infer::{DefineOpaqueTypes, InferCtxt, SubregionOrigin, TypeTrace};
+use crate::infer::{
+    BoundRegionConversionTime, DefineOpaqueTypes, InferCtxt, SubregionOrigin, TypeTrace,
+};
 use crate::traits::{Obligation, PredicateObligations};
 
 #[derive(Clone, Copy)]
@@ -209,14 +211,31 @@ impl<'tcx> TypeRelation<TyCtxt<'tcx>> for LatticeOp<'_, 'tcx> {
         }
 
         debug!("binders(a={:?}, b={:?})", a, b);
-        if a.skip_binder().has_escaping_bound_vars() || b.skip_binder().has_escaping_bound_vars() {
-            // When higher-ranked types are involved, computing the GLB/LUB is
-            // very challenging, switch to invariance. This is obviously
-            // overly conservative but works ok in practice.
-            self.relate_with_variance(ty::Invariant, ty::VarianceDiagInfo::default(), a, b)?;
-            Ok(a)
-        } else {
-            Ok(ty::Binder::dummy(self.relate(a.skip_binder(), b.skip_binder())?))
+        match (a.no_bound_vars().ok_or(a), b.no_bound_vars().ok_or(b)) {
+            (Err(a), Err(b)) => {
+                // When higher-ranked types are involved, computing the GLB/LUB is
+                // very challenging, switch to invariance. This is obviously
+                // overly conservative but works ok in practice.
+                self.relate_with_variance(ty::Invariant, ty::VarianceDiagInfo::default(), a, b)?;
+                Ok(a)
+            }
+            (Ok(non_hr), Err(hr)) | (Err(hr), Ok(non_hr)) => {
+                // If we only have one type with bound vars then we convert
+                // it to a non higher-ranked signature, This should always
+                // be correct assuming we do not support subtyping of the form:
+                // `fn(&'smallest ()) <: for<'a> fn(&'a ())`
+                // but I don't think we currently do so or intend to start doing so.
+                //
+                // This is a bit of a special case but it was necessary for backwards
+                // compatibility when starting to properly leak checking in coercions.
+                let non_hr_2 = self.infcx.instantiate_binder_with_fresh_vars(
+                    self.span(),
+                    BoundRegionConversionTime::HigherRankedType,
+                    hr,
+                );
+                Ok(ty::Binder::dummy(self.relate(non_hr, non_hr_2)?))
+            }
+            (Ok(a), Ok(b)) => Ok(ty::Binder::dummy(self.relate(a, b)?)),
         }
     }
 }