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,15 +211,38 @@ 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() {
+
+        let instantiate_with_infer = |binder| {
+            self.infcx.instantiate_binder_with_fresh_vars(
+                self.span(),
+                BoundRegionConversionTime::HigherRankedType,
+                binder,
+            )
+        };
+        let r = match (a.no_bound_vars(), b.no_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())?))
-        }
+            (None, None) => {
+                self.relate_with_variance(ty::Invariant, ty::VarianceDiagInfo::default(), a, b)?;
+                return Ok(a);
+            }
+
+            // 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.
+            (Some(a), None) => self.relate(a, instantiate_with_infer(b))?,
+            (None, Some(b)) => self.relate(instantiate_with_infer(a), b)?,
+
+            (Some(a), Some(b)) => self.relate(a, b)?,
+        };
+
+        Ok(ty::Binder::dummy(r))
     }
 }