Merge pull request #1522 from Nadrieril/hack-closure-lifetimes

Don't erase inner binders in trait resolution

Author: Nadrieril

frontend/exporter/src/traits/resolution.rs

@@ -13,7 +13,7 @@ use rustc_trait_selection::traits::ImplSource;
 
 use crate::{self_predicate, traits::utils::erase_and_norm};
 
-use super::utils::{implied_predicates, required_predicates, ToPolyTraitRef};
+use super::utils::{implied_predicates, normalize_bound_val, required_predicates, ToPolyTraitRef};
 
 #[derive(Debug, Clone)]
 pub enum PathChunk<'tcx> {
@@ -281,7 +281,7 @@ impl<'tcx> PredicateSearcher<'tcx> {
         let mut new_candidates = Vec::new();
         for mut candidate in candidates {
             // Normalize and erase all lifetimes.
-            candidate.pred = erase_and_norm(tcx, self.typing_env, candidate.pred);
+            candidate.pred = normalize_bound_val(tcx, self.typing_env, candidate.pred);
             if let Entry::Vacant(entry) = self.candidates.entry(candidate.pred) {
                 entry.insert(candidate.clone());
                 new_candidates.push(candidate);
@@ -421,7 +421,7 @@ impl<'tcx> PredicateSearcher<'tcx> {
         let tcx = self.tcx;
         let drop_trait = tcx.lang_items().drop_trait().unwrap();
 
-        let erased_tref = erase_and_norm(self.tcx, self.typing_env, *tref);
+        let erased_tref = normalize_bound_val(self.tcx, self.typing_env, *tref);
         let trait_def_id = erased_tref.skip_binder().def_id;
 
         let impl_source = shallow_resolve_trait_ref(tcx, self.typing_env.param_env, erased_tref);

frontend/exporter/src/traits/utils.rs

@@ -167,14 +167,17 @@ pub fn implied_predicates<'tcx>(
     }
 }
 
-/// Erase all regions. Largely copied from `tcx.erase_regions`.
-pub fn erase_all_regions<'tcx, T>(tcx: TyCtxt<'tcx>, value: T) -> T
+/// Erase free regions from the given value. Largely copied from `tcx.erase_regions`, but also
+/// erases bound regions that are bound outside `value`, so we can call this function inside a
+/// `Binder`.
+fn erase_free_regions<'tcx, T>(tcx: TyCtxt<'tcx>, value: T) -> T
 where
     T: TypeFoldable<TyCtxt<'tcx>>,
 {
     use rustc_middle::ty;
     struct RegionEraserVisitor<'tcx> {
         tcx: TyCtxt<'tcx>,
+        depth: u32,
     }
 
     impl<'tcx> TypeFolder<TyCtxt<'tcx>> for RegionEraserVisitor<'tcx> {
@@ -190,33 +193,53 @@ where
         where
             T: TypeFoldable<TyCtxt<'tcx>>,
         {
-            // Empty the binder
-            Binder::dummy(t.skip_binder().fold_with(self))
+            let t = self.tcx.anonymize_bound_vars(t);
+            self.depth += 1;
+            let t = t.super_fold_with(self);
+            self.depth -= 1;
+            t
         }
 
-        fn fold_region(&mut self, _r: ty::Region<'tcx>) -> ty::Region<'tcx> {
-            // We erase bound regions despite it being possibly incorrect. `for<'a> fn(&'a
-            // ())` and `fn(&'free ())` are different types: they may implement different
-            // traits and have a different `TypeId`. It's unclear whether this can cause us
-            // to select the wrong trait reference.
-            self.tcx.lifetimes.re_erased
+        fn fold_region(&mut self, r: ty::Region<'tcx>) -> ty::Region<'tcx> {
+            // We don't erase bound regions that are bound inside the expression we started with,
+            // but we do erase those that point "outside of it".
+            match r.kind() {
+                ty::ReBound(dbid, _) if dbid.as_u32() < self.depth => r,
+                _ => self.tcx.lifetimes.re_erased,
+            }
         }
     }
-    value.fold_with(&mut RegionEraserVisitor { tcx })
+    value.fold_with(&mut RegionEraserVisitor { tcx, depth: 0 })
 }
 
-// Lifetimes are irrelevant when resolving instances.
+// Normalize and erase lifetimes, erasing more lifetimes than normal because we might be already
+// inside a binder and rustc doesn't like that.
 pub fn erase_and_norm<'tcx, T>(tcx: TyCtxt<'tcx>, typing_env: TypingEnv<'tcx>, x: T) -> T
 where
     T: TypeFoldable<TyCtxt<'tcx>> + Copy,
 {
-    erase_all_regions(
+    erase_free_regions(
         tcx,
         tcx.try_normalize_erasing_regions(typing_env, x)
             .unwrap_or(x),
     )
 }
 
+/// Given our currently hacky handling of binders, in order for trait resolution to work we must
+/// empty out the binders of trait refs. Specifically it's so that we can reconnect associated type
+/// constraints with the trait ref they come from, given that the projection in question doesn't
+/// track the right binder currently.
+pub fn normalize_bound_val<'tcx, T>(
+    tcx: TyCtxt<'tcx>,
+    typing_env: TypingEnv<'tcx>,
+    x: Binder<'tcx, T>,
+) -> Binder<'tcx, T>
+where
+    T: TypeFoldable<TyCtxt<'tcx>> + Copy,
+{
+    Binder::dummy(erase_and_norm(tcx, typing_env, x.skip_binder()))
+}
+
 pub trait ToPolyTraitRef<'tcx> {
     fn to_poly_trait_ref(&self) -> PolyTraitRef<'tcx>;
 }