[HACK] also insert in projection_cache for the pre-ReLateBound->RePlaceholder key.

Author: eddyb

compiler/rustc_trait_selection/src/traits/project.rs

@@ -182,6 +182,9 @@ pub(super) fn poly_project_and_unify_type<'cx, 'tcx>(
     selcx: &mut SelectionContext<'cx, 'tcx>,
     obligation: &PolyProjectionObligation<'tcx>,
 ) -> ProjectAndUnifyResult<'tcx> {
+    let pre_bound2placeholder_cache_key =
+        ProjectionCacheKey::from_poly_projection_predicate(selcx, obligation.predicate).unwrap();
+
     let infcx = selcx.infcx();
     let r = infcx.commit_if_ok(|_snapshot| {
         let old_universe = infcx.universe();
@@ -190,7 +193,11 @@ pub(super) fn poly_project_and_unify_type<'cx, 'tcx>(
         let new_universe = infcx.universe();
 
         let placeholder_obligation = obligation.with(placeholder_predicate);
-        match project_and_unify_type(selcx, &placeholder_obligation) {
+        match project_and_unify_type(
+            selcx,
+            &placeholder_obligation,
+            Some(&pre_bound2placeholder_cache_key),
+        ) {
             ProjectAndUnifyResult::MismatchedProjectionTypes(e) => Err(e),
             ProjectAndUnifyResult::Holds(obligations)
                 if old_universe != new_universe
@@ -235,6 +242,7 @@ pub(super) fn poly_project_and_unify_type<'cx, 'tcx>(
 fn project_and_unify_type<'cx, 'tcx>(
     selcx: &mut SelectionContext<'cx, 'tcx>,
     obligation: &ProjectionObligation<'tcx>,
+    pre_bound2placeholder_cache_key: Option<&ProjectionCacheKey<'tcx>>,
 ) -> ProjectAndUnifyResult<'tcx> {
     let mut obligations = vec![];
 
@@ -246,6 +254,7 @@ fn project_and_unify_type<'cx, 'tcx>(
         obligation.cause.clone(),
         obligation.recursion_depth,
         &mut obligations,
+        pre_bound2placeholder_cache_key,
     ) {
         Ok(Some(n)) => n,
         Ok(None) => return ProjectAndUnifyResult::FailedNormalization,
@@ -539,6 +548,7 @@ impl<'a, 'b, 'tcx> TypeFolder<'tcx> for AssocTypeNormalizer<'a, 'b, 'tcx> {
                         self.cause.clone(),
                         self.depth,
                         &mut self.obligations,
+                        None,
                     )
                     .ok()
                     .flatten()
@@ -578,6 +588,7 @@ impl<'a, 'b, 'tcx> TypeFolder<'tcx> for AssocTypeNormalizer<'a, 'b, 'tcx> {
                     self.cause.clone(),
                     self.depth,
                     &mut self.obligations,
+                    None,
                 )
                 .ok()
                 .flatten()
@@ -917,6 +928,7 @@ pub fn normalize_projection_type<'a, 'b, 'tcx>(
         cause.clone(),
         depth,
         obligations,
+        None,
     )
     .ok()
     .flatten()
@@ -950,6 +962,7 @@ fn opt_normalize_projection_type<'a, 'b, 'tcx>(
     cause: ObligationCause<'tcx>,
     depth: usize,
     obligations: &mut Vec<PredicateObligation<'tcx>>,
+    pre_bound2placeholder_cache_key: Option<&ProjectionCacheKey<'tcx>>,
 ) -> Result<Option<Term<'tcx>>, InProgress> {
     let infcx = selcx.infcx();
     // Don't use the projection cache in intercrate mode -
@@ -1069,6 +1082,20 @@ fn opt_normalize_projection_type<'a, 'b, 'tcx>(
 
             if use_cache {
                 infcx.inner.borrow_mut().projection_cache().insert_term(cache_key, result.clone());
+                if let Some(&pre_bound2placeholder_cache_key) = pre_bound2placeholder_cache_key {
+                    if !result.has_placeholders() {
+                        // HACK(eddyb) `pre_bound2placeholder_cache_key` was never started.
+                        let mut infcx_inner = infcx.inner.borrow_mut();
+                        if let Ok(()) = infcx_inner
+                            .projection_cache()
+                            .try_start(pre_bound2placeholder_cache_key)
+                        {
+                            infcx_inner
+                                .projection_cache()
+                                .insert_term(pre_bound2placeholder_cache_key, result.clone());
+                        }
+                    }
+                }
             }
             obligations.extend(result.obligations);
             Ok(Some(result.value))