Auto merge of #71996 - Marwes:detach_undo_log, r=nikomatsakis

bors · bors · commit 664fcd3f046e · 2020-05-27T18:31:45.000Z
perf: Revert accidental inclusion of a part of #69218 This was accidentally included in #69464 after a rebase and given how much `inflate` and `keccak` stresses the obligation forest seems like a likely culprit to the regression in those benchmarks. (It is necessary in #69218 as obligation forest needs to accurately track the root variables or unifications will get lost)
diff --git a/src/librustc_data_structures/snapshot_map/mod.rs b/src/librustc_data_structures/snapshot_map/mod.rs
@@ -37,6 +37,7 @@ pub enum UndoLog<K, V> {
 }
 
 impl<K, V, M, L> SnapshotMap<K, V, M, L> {
+    #[inline]
     pub fn with_log<L2>(&mut self, undo_log: L2) -> SnapshotMap<K, V, &mut M, L2> {
         SnapshotMap { map: &mut self.map, undo_log, _marker: PhantomData }
     }
diff --git a/src/librustc_infer/infer/mod.rs b/src/librustc_infer/infer/mod.rs
@@ -217,18 +217,22 @@ impl<'tcx> InferCtxtInner<'tcx> {
         }
     }
 
+    #[inline]
     pub fn region_obligations(&self) -> &[(hir::HirId, RegionObligation<'tcx>)] {
         &self.region_obligations
     }
 
+    #[inline]
     pub fn projection_cache(&mut self) -> traits::ProjectionCache<'_, 'tcx> {
         self.projection_cache.with_log(&mut self.undo_log)
     }
 
+    #[inline]
     fn type_variables(&mut self) -> type_variable::TypeVariableTable<'_, 'tcx> {
         self.type_variable_storage.with_log(&mut self.undo_log)
     }
 
+    #[inline]
     fn int_unification_table(
         &mut self,
     ) -> ut::UnificationTable<
@@ -241,6 +245,7 @@ impl<'tcx> InferCtxtInner<'tcx> {
         self.int_unification_storage.with_log(&mut self.undo_log)
     }
 
+    #[inline]
     fn float_unification_table(
         &mut self,
     ) -> ut::UnificationTable<
@@ -253,6 +258,7 @@ impl<'tcx> InferCtxtInner<'tcx> {
         self.float_unification_storage.with_log(&mut self.undo_log)
     }
 
+    #[inline]
     fn const_unification_table(
         &mut self,
     ) -> ut::UnificationTable<
@@ -265,6 +271,7 @@ impl<'tcx> InferCtxtInner<'tcx> {
         self.const_unification_storage.with_log(&mut self.undo_log)
     }
 
+    #[inline]
     pub fn unwrap_region_constraints(&mut self) -> RegionConstraintCollector<'_, 'tcx> {
         self.region_constraint_storage
             .as_mut()
@@ -1602,14 +1609,13 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
     /// having to resort to storing full `GenericArg`s in `stalled_on`.
     #[inline(always)]
     pub fn ty_or_const_infer_var_changed(&self, infer_var: TyOrConstInferVar<'tcx>) -> bool {
-        let mut inner = self.inner.borrow_mut();
         match infer_var {
             TyOrConstInferVar::Ty(v) => {
                 use self::type_variable::TypeVariableValue;
 
                 // If `inlined_probe` returns a `Known` value, it never equals
                 // `ty::Infer(ty::TyVar(v))`.
-                match inner.type_variables().inlined_probe(v) {
+                match self.inner.borrow_mut().type_variables().inlined_probe(v) {
                     TypeVariableValue::Unknown { .. } => false,
                     TypeVariableValue::Known { .. } => true,
                 }
@@ -1619,23 +1625,23 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
                 // If `inlined_probe_value` returns a value it's always a
                 // `ty::Int(_)` or `ty::UInt(_)`, which never matches a
                 // `ty::Infer(_)`.
-                inner.int_unification_table().inlined_probe_value(v).is_some()
+                self.inner.borrow_mut().int_unification_table().inlined_probe_value(v).is_some()
             }
 
             TyOrConstInferVar::TyFloat(v) => {
                 // If `probe_value` returns a value it's always a
                 // `ty::Float(_)`, which never matches a `ty::Infer(_)`.
                 //
                 // Not `inlined_probe_value(v)` because this call site is colder.
-                inner.float_unification_table().probe_value(v).is_some()
+                self.inner.borrow_mut().float_unification_table().probe_value(v).is_some()
             }
 
             TyOrConstInferVar::Const(v) => {
                 // If `probe_value` returns a `Known` value, it never equals
                 // `ty::ConstKind::Infer(ty::InferConst::Var(v))`.
                 //
                 // Not `inlined_probe_value(v)` because this call site is colder.
-                match inner.const_unification_table().probe_value(v).val {
+                match self.inner.borrow_mut().const_unification_table().probe_value(v).val {
                     ConstVariableValue::Unknown { .. } => false,
                     ConstVariableValue::Known { .. } => true,
                 }
diff --git a/src/librustc_infer/infer/region_constraints/mod.rs b/src/librustc_infer/infer/region_constraints/mod.rs
@@ -68,12 +68,14 @@ pub struct RegionConstraintCollector<'a, 'tcx> {
 
 impl std::ops::Deref for RegionConstraintCollector<'_, 'tcx> {
     type Target = RegionConstraintStorage<'tcx>;
+    #[inline]
     fn deref(&self) -> &RegionConstraintStorage<'tcx> {
         self.storage
     }
 }
 
 impl std::ops::DerefMut for RegionConstraintCollector<'_, 'tcx> {
+    #[inline]
     fn deref_mut(&mut self) -> &mut RegionConstraintStorage<'tcx> {
         self.storage
     }
@@ -345,6 +347,7 @@ impl<'tcx> RegionConstraintStorage<'tcx> {
         Self::default()
     }
 
+    #[inline]
     pub(crate) fn with_log<'a>(
         &'a mut self,
         undo_log: &'a mut InferCtxtUndoLogs<'tcx>,
@@ -794,6 +797,7 @@ impl<'tcx> RegionConstraintCollector<'_, 'tcx> {
             .unwrap_or(None)
     }
 
+    #[inline]
     fn unification_table(&mut self) -> super::UnificationTable<'_, 'tcx, ty::RegionVid> {
         ut::UnificationTable::with_log(&mut self.storage.unification_table, self.undo_log)
     }
diff --git a/src/librustc_infer/infer/type_variable.rs b/src/librustc_infer/infer/type_variable.rs
@@ -87,11 +87,7 @@ pub struct TypeVariableStorage<'tcx> {
 }
 
 pub struct TypeVariableTable<'a, 'tcx> {
-    values: &'a mut sv::SnapshotVecStorage<Delegate>,
-
-    eq_relations: &'a mut ut::UnificationTableStorage<TyVidEqKey<'tcx>>,
-
-    sub_relations: &'a mut ut::UnificationTableStorage<ty::TyVid>,
+    storage: &'a mut TypeVariableStorage<'tcx>,
 
     undo_log: &'a mut InferCtxtUndoLogs<'tcx>,
 }
@@ -165,12 +161,12 @@ impl<'tcx> TypeVariableStorage<'tcx> {
         }
     }
 
+    #[inline]
     pub(crate) fn with_log<'a>(
         &'a mut self,
         undo_log: &'a mut InferCtxtUndoLogs<'tcx>,
     ) -> TypeVariableTable<'a, 'tcx> {
-        let TypeVariableStorage { values, eq_relations, sub_relations } = self;
-        TypeVariableTable { values, eq_relations, sub_relations, undo_log }
+        TypeVariableTable { storage: self, undo_log }
     }
 }
 
@@ -180,15 +176,15 @@ impl<'tcx> TypeVariableTable<'_, 'tcx> {
     /// Note that this function does not return care whether
     /// `vid` has been unified with something else or not.
     pub fn var_diverges(&self, vid: ty::TyVid) -> bool {
-        self.values.get(vid.index as usize).diverging
+        self.storage.values.get(vid.index as usize).diverging
     }
 
     /// Returns the origin that was given when `vid` was created.
     ///
     /// Note that this function does not return care whether
     /// `vid` has been unified with something else or not.
     pub fn var_origin(&self, vid: ty::TyVid) -> &TypeVariableOrigin {
-        &self.values.get(vid.index as usize).origin
+        &self.storage.values.get(vid.index as usize).origin
     }
 
     /// Records that `a == b`, depending on `dir`.
@@ -265,7 +261,7 @@ impl<'tcx> TypeVariableTable<'_, 'tcx> {
 
     /// Returns the number of type variables created thus far.
     pub fn num_vars(&self) -> usize {
-        self.values.len()
+        self.storage.values.len()
     }
 
     /// Returns the "root" variable of `vid` in the `eq_relations`
@@ -319,18 +315,21 @@ impl<'tcx> TypeVariableTable<'_, 'tcx> {
         }
     }
 
+    #[inline]
     fn values(
         &mut self,
     ) -> sv::SnapshotVec<Delegate, &mut Vec<TypeVariableData>, &mut InferCtxtUndoLogs<'tcx>> {
-        self.values.with_log(self.undo_log)
+        self.storage.values.with_log(self.undo_log)
     }
 
+    #[inline]
     fn eq_relations(&mut self) -> super::UnificationTable<'_, 'tcx, TyVidEqKey<'tcx>> {
-        self.eq_relations.with_log(self.undo_log)
+        self.storage.eq_relations.with_log(self.undo_log)
     }
 
+    #[inline]
     fn sub_relations(&mut self) -> super::UnificationTable<'_, 'tcx, ty::TyVid> {
-        self.sub_relations.with_log(self.undo_log)
+        self.storage.sub_relations.with_log(self.undo_log)
     }
 
     /// Returns a range of the type variables created during the snapshot.
@@ -342,7 +341,7 @@ impl<'tcx> TypeVariableTable<'_, 'tcx> {
         (
             range.start..range.end,
             (range.start.index..range.end.index)
-                .map(|index| self.values.get(index as usize).origin)
+                .map(|index| self.storage.values.get(index as usize).origin)
                 .collect(),
         )
     }
@@ -378,7 +377,7 @@ impl<'tcx> TypeVariableTable<'_, 'tcx> {
                         // quick check to see if this variable was
                         // created since the snapshot started or not.
                         let mut eq_relations = ut::UnificationTable::with_log(
-                            &mut *self.eq_relations,
+                            &mut self.storage.eq_relations,
                             &mut *self.undo_log,
                         );
                         let escaping_type = match eq_relations.probe_value(vid) {
@@ -400,7 +399,7 @@ impl<'tcx> TypeVariableTable<'_, 'tcx> {
     /// Returns indices of all variables that are not yet
     /// instantiated.
     pub fn unsolved_variables(&mut self) -> Vec<ty::TyVid> {
-        (0..self.values.len())
+        (0..self.storage.values.len())
             .filter_map(|i| {
                 let vid = ty::TyVid { index: i as u32 };
                 match self.probe(vid) {
diff --git a/src/librustc_infer/infer/undo_log.rs b/src/librustc_infer/infer/undo_log.rs
@@ -100,10 +100,12 @@ impl<'tcx, T> UndoLogs<T> for InferCtxtUndoLogs<'tcx>
 where
     UndoLog<'tcx>: From<T>,
 {
+    #[inline]
     fn num_open_snapshots(&self) -> usize {
         self.num_open_snapshots
     }
 
+    #[inline]
     fn push(&mut self, undo: T) {
         if self.in_snapshot() {
             self.logs.push(undo.into())
diff --git a/src/librustc_infer/traits/project.rs b/src/librustc_infer/traits/project.rs
@@ -95,6 +95,7 @@ pub enum ProjectionCacheEntry<'tcx> {
 }
 
 impl<'tcx> ProjectionCacheStorage<'tcx> {
+    #[inline]
     pub(crate) fn with_log<'a>(
         &'a mut self,
         undo_log: &'a mut InferCtxtUndoLogs<'tcx>,
@@ -104,6 +105,7 @@ impl<'tcx> ProjectionCacheStorage<'tcx> {
 }
 
 impl<'tcx> ProjectionCache<'_, 'tcx> {
+    #[inline]
     fn map(
         &mut self,
     ) -> SnapshotMapRef<
diff --git a/src/librustc_trait_selection/traits/fulfill.rs b/src/librustc_trait_selection/traits/fulfill.rs
@@ -242,15 +242,9 @@ struct FulfillProcessor<'a, 'b, 'tcx> {
     register_region_obligations: bool,
 }
 
-fn mk_pending(
-    infcx: &InferCtxt<'_, 'tcx>,
-    os: Vec<PredicateObligation<'tcx>>,
-) -> Vec<PendingPredicateObligation<'tcx>> {
+fn mk_pending(os: Vec<PredicateObligation<'tcx>>) -> Vec<PendingPredicateObligation<'tcx>> {
     os.into_iter()
-        .map(|mut o| {
-            o.predicate = infcx.resolve_vars_if_possible(&o.predicate);
-            PendingPredicateObligation { obligation: o, stalled_on: vec![] }
-        })
+        .map(|o| PendingPredicateObligation { obligation: o, stalled_on: vec![] })
         .collect()
 }
 
@@ -344,7 +338,7 @@ impl<'a, 'b, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'b, 'tcx> {
                             "selecting trait `{:?}` at depth {} yielded Ok(Some)",
                             data, obligation.recursion_depth
                         );
-                        ProcessResult::Changed(mk_pending(infcx, vtable.nested_obligations()))
+                        ProcessResult::Changed(mk_pending(vtable.nested_obligations()))
                     }
                     Ok(None) => {
                         debug!(
@@ -438,7 +432,7 @@ impl<'a, 'b, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'b, 'tcx> {
                             trait_ref_infer_vars(self.selcx, data.to_poly_trait_ref(tcx));
                         ProcessResult::Unchanged
                     }
-                    Ok(Some(os)) => ProcessResult::Changed(mk_pending(infcx, os)),
+                    Ok(Some(os)) => ProcessResult::Changed(mk_pending(os)),
                     Err(e) => ProcessResult::Error(CodeProjectionError(e)),
                 }
             }
@@ -477,7 +471,7 @@ impl<'a, 'b, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'b, 'tcx> {
                             vec![TyOrConstInferVar::maybe_from_ty(ty).unwrap()];
                         ProcessResult::Unchanged
                     }
-                    Some(os) => ProcessResult::Changed(mk_pending(infcx, os)),
+                    Some(os) => ProcessResult::Changed(mk_pending(os)),
                 }
             }
 
@@ -495,7 +489,7 @@ impl<'a, 'b, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'b, 'tcx> {
                         ];
                         ProcessResult::Unchanged
                     }
-                    Some(Ok(ok)) => ProcessResult::Changed(mk_pending(infcx, ok.obligations)),
+                    Some(Ok(ok)) => ProcessResult::Changed(mk_pending(ok.obligations)),
                     Some(Err(err)) => {
                         let expected_found = ExpectedFound::new(
                             subtype.skip_binder().a_is_expected,

Original file line number	Diff line number	Diff line change
`@@ -37,6 +37,7 @@ pub enum UndoLog<K, V> {`
`37`	`37`	`}`
`38`	`38`
`39`	`39`	`impl<K, V, M, L> SnapshotMap<K, V, M, L> {`
	`40`	`+ #[inline]`
`40`	`41`	`pub fn with_log<L2>(&mut self, undo_log: L2) -> SnapshotMap<K, V, &mut M, L2> {`
`41`	`42`	`SnapshotMap { map: &mut self.map, undo_log, _marker: PhantomData }`
`42`	`43`	`}`
Original file line number	Diff line number	Diff line change
`@@ -68,12 +68,14 @@ pub struct RegionConstraintCollector<'a, 'tcx> {`
`68`	`68`
`69`	`69`	`impl std::ops::Deref for RegionConstraintCollector<'_, 'tcx> {`
`70`	`70`	`type Target = RegionConstraintStorage<'tcx>;`
	`71`	`+ #[inline]`
`71`	`72`	`fn deref(&self) -> &RegionConstraintStorage<'tcx> {`
`72`	`73`	`self.storage`
`73`	`74`	`}`
`74`	`75`	`}`
`75`	`76`
`76`	`77`	`impl std::ops::DerefMut for RegionConstraintCollector<'_, 'tcx> {`
	`78`	`+ #[inline]`
`77`	`79`	`fn deref_mut(&mut self) -> &mut RegionConstraintStorage<'tcx> {`
`78`	`80`	`self.storage`
`79`	`81`	`}`
`@@ -345,6 +347,7 @@ impl<'tcx> RegionConstraintStorage<'tcx> {`
`345`	`347`	`Self::default()`
`346`	`348`	`}`
`347`	`349`
	`350`	`+ #[inline]`
`348`	`351`	`pub(crate) fn with_log<'a>(`
`349`	`352`	`&'a mut self,`
`350`	`353`	`undo_log: &'a mut InferCtxtUndoLogs<'tcx>,`
`@@ -794,6 +797,7 @@ impl<'tcx> RegionConstraintCollector<'_, 'tcx> {`
`794`	`797`	`.unwrap_or(None)`
`795`	`798`	`}`
`796`	`799`
	`800`	`+ #[inline]`
`797`	`801`	`fn unification_table(&mut self) -> super::UnificationTable<'_, 'tcx, ty::RegionVid> {`
`798`	`802`	`ut::UnificationTable::with_log(&mut self.storage.unification_table, self.undo_log)`
`799`	`803`	`}`
Original file line number	Diff line number	Diff line change
`@@ -87,11 +87,7 @@ pub struct TypeVariableStorage<'tcx> {`
`87`	`87`	`}`
`88`	`88`
`89`	`89`	`pub struct TypeVariableTable<'a, 'tcx> {`
`90`		`- values: &'a mut sv::SnapshotVecStorage<Delegate>,`
`91`		`-`
`92`		`- eq_relations: &'a mut ut::UnificationTableStorage<TyVidEqKey<'tcx>>,`
`93`		`-`
`94`		`- sub_relations: &'a mut ut::UnificationTableStorage<ty::TyVid>,`
	`90`	`+ storage: &'a mut TypeVariableStorage<'tcx>,`
`95`	`91`
`96`	`92`	`undo_log: &'a mut InferCtxtUndoLogs<'tcx>,`
`97`	`93`	`}`
`@@ -165,12 +161,12 @@ impl<'tcx> TypeVariableStorage<'tcx> {`
`165`	`161`	`}`
`166`	`162`	`}`
`167`	`163`
	`164`	`+ #[inline]`
`168`	`165`	`pub(crate) fn with_log<'a>(`
`169`	`166`	`&'a mut self,`
`170`	`167`	`undo_log: &'a mut InferCtxtUndoLogs<'tcx>,`
`171`	`168`	`) -> TypeVariableTable<'a, 'tcx> {`
`172`		`- let TypeVariableStorage { values, eq_relations, sub_relations } = self;`
`173`		`- TypeVariableTable { values, eq_relations, sub_relations, undo_log }`
	`169`	`+ TypeVariableTable { storage: self, undo_log }`
`174`	`170`	`}`
`175`	`171`	`}`
`176`	`172`
`@@ -180,15 +176,15 @@ impl<'tcx> TypeVariableTable<'_, 'tcx> {`
`180`	`176`	`/// Note that this function does not return care whether`
`181`	`177`	/// `vid` has been unified with something else or not.
`182`	`178`	`pub fn var_diverges(&self, vid: ty::TyVid) -> bool {`
`183`		`- self.values.get(vid.index as usize).diverging`
	`179`	`+ self.storage.values.get(vid.index as usize).diverging`
`184`	`180`	`}`
`185`	`181`
`186`	`182`	/// Returns the origin that was given when `vid` was created.
`187`	`183`	`///`
`188`	`184`	`/// Note that this function does not return care whether`
`189`	`185`	/// `vid` has been unified with something else or not.
`190`	`186`	`pub fn var_origin(&self, vid: ty::TyVid) -> &TypeVariableOrigin {`
`191`		`- &self.values.get(vid.index as usize).origin`
	`187`	`+ &self.storage.values.get(vid.index as usize).origin`
`192`	`188`	`}`
`193`	`189`
`194`	`190`	/// Records that `a == b`, depending on `dir`.
`@@ -265,7 +261,7 @@ impl<'tcx> TypeVariableTable<'_, 'tcx> {`
`265`	`261`
`266`	`262`	`/// Returns the number of type variables created thus far.`
`267`	`263`	`pub fn num_vars(&self) -> usize {`
`268`		`- self.values.len()`
	`264`	`+ self.storage.values.len()`
`269`	`265`	`}`
`270`	`266`
`271`	`267`	/// Returns the "root" variable of `vid` in the `eq_relations`
`@@ -319,18 +315,21 @@ impl<'tcx> TypeVariableTable<'_, 'tcx> {`
`319`	`315`	`}`
`320`	`316`	`}`
`321`	`317`
	`318`	`+ #[inline]`
`322`	`319`	`fn values(`
`323`	`320`	`&mut self,`
`324`	`321`	`) -> sv::SnapshotVec<Delegate, &mut Vec<TypeVariableData>, &mut InferCtxtUndoLogs<'tcx>> {`
`325`		`- self.values.with_log(self.undo_log)`
	`322`	`+ self.storage.values.with_log(self.undo_log)`
`326`	`323`	`}`
`327`	`324`
	`325`	`+ #[inline]`
`328`	`326`	`fn eq_relations(&mut self) -> super::UnificationTable<'_, 'tcx, TyVidEqKey<'tcx>> {`
`329`		`- self.eq_relations.with_log(self.undo_log)`
	`327`	`+ self.storage.eq_relations.with_log(self.undo_log)`
`330`	`328`	`}`
`331`	`329`
	`330`	`+ #[inline]`
`332`	`331`	`fn sub_relations(&mut self) -> super::UnificationTable<'_, 'tcx, ty::TyVid> {`
`333`		`- self.sub_relations.with_log(self.undo_log)`
	`332`	`+ self.storage.sub_relations.with_log(self.undo_log)`
`334`	`333`	`}`
`335`	`334`
`336`	`335`	`/// Returns a range of the type variables created during the snapshot.`
`@@ -342,7 +341,7 @@ impl<'tcx> TypeVariableTable<'_, 'tcx> {`
`342`	`341`	`(`
`343`	`342`	`range.start..range.end,`
`344`	`343`	`(range.start.index..range.end.index)`
`345`		`- .map(\|index\| self.values.get(index as usize).origin)`
	`344`	`+ .map(\|index\| self.storage.values.get(index as usize).origin)`
`346`	`345`	`.collect(),`
`347`	`346`	`)`
`348`	`347`	`}`
`@@ -378,7 +377,7 @@ impl<'tcx> TypeVariableTable<'_, 'tcx> {`
`378`	`377`	`// quick check to see if this variable was`
`379`	`378`	`// created since the snapshot started or not.`
`380`	`379`	`let mut eq_relations = ut::UnificationTable::with_log(`
`381`		`- &mut *self.eq_relations,`
	`380`	`+ &mut self.storage.eq_relations,`
`382`	`381`	`&mut *self.undo_log,`
`383`	`382`	`);`
`384`	`383`	`let escaping_type = match eq_relations.probe_value(vid) {`
`@@ -400,7 +399,7 @@ impl<'tcx> TypeVariableTable<'_, 'tcx> {`
`400`	`399`	`/// Returns indices of all variables that are not yet`
`401`	`400`	`/// instantiated.`
`402`	`401`	`pub fn unsolved_variables(&mut self) -> Vec<ty::TyVid> {`
`403`		`- (0..self.values.len())`
	`402`	`+ (0..self.storage.values.len())`
`404`	`403`	`.filter_map(\|i\| {`
`405`	`404`	`let vid = ty::TyVid { index: i as u32 };`
`406`	`405`	`match self.probe(vid) {`
Original file line number	Diff line number	Diff line change
`@@ -100,10 +100,12 @@ impl<'tcx, T> UndoLogs<T> for InferCtxtUndoLogs<'tcx>`
`100`	`100`	`where`
`101`	`101`	`UndoLog<'tcx>: From<T>,`
`102`	`102`	`{`
	`103`	`+ #[inline]`
`103`	`104`	`fn num_open_snapshots(&self) -> usize {`
`104`	`105`	`self.num_open_snapshots`
`105`	`106`	`}`
`106`	`107`
	`108`	`+ #[inline]`
`107`	`109`	`fn push(&mut self, undo: T) {`
`108`	`110`	`if self.in_snapshot() {`
`109`	`111`	`self.logs.push(undo.into())`
Original file line number	Diff line number	Diff line change
`@@ -95,6 +95,7 @@ pub enum ProjectionCacheEntry<'tcx> {`
`95`	`95`	`}`
`96`	`96`
`97`	`97`	`impl<'tcx> ProjectionCacheStorage<'tcx> {`
	`98`	`+ #[inline]`
`98`	`99`	`pub(crate) fn with_log<'a>(`
`99`	`100`	`&'a mut self,`
`100`	`101`	`undo_log: &'a mut InferCtxtUndoLogs<'tcx>,`
`@@ -104,6 +105,7 @@ impl<'tcx> ProjectionCacheStorage<'tcx> {`
`104`	`105`	`}`
`105`	`106`
`106`	`107`	`impl<'tcx> ProjectionCache<'_, 'tcx> {`
	`108`	`+ #[inline]`
`107`	`109`	`fn map(`
`108`	`110`	`&mut self,`
`109`	`111`	`) -> SnapshotMapRef<`
Original file line number	Diff line number	Diff line change
`@@ -242,15 +242,9 @@ struct FulfillProcessor<'a, 'b, 'tcx> {`
`242`	`242`	`register_region_obligations: bool,`
`243`	`243`	`}`
`244`	`244`
`245`		`-fn mk_pending(`
`246`		`- infcx: &InferCtxt<'_, 'tcx>,`
`247`		`- os: Vec<PredicateObligation<'tcx>>,`
`248`		`-) -> Vec<PendingPredicateObligation<'tcx>> {`
	`245`	`+fn mk_pending(os: Vec<PredicateObligation<'tcx>>) -> Vec<PendingPredicateObligation<'tcx>> {`
`249`	`246`	`os.into_iter()`
`250`		`- .map(\|mut o\| {`
`251`		`- o.predicate = infcx.resolve_vars_if_possible(&o.predicate);`
`252`		`- PendingPredicateObligation { obligation: o, stalled_on: vec![] }`
`253`		`- })`
	`247`	`+ .map(\|o\| PendingPredicateObligation { obligation: o, stalled_on: vec![] })`
`254`	`248`	`.collect()`
`255`	`249`	`}`
`256`	`250`
`@@ -344,7 +338,7 @@ impl<'a, 'b, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'b, 'tcx> {`
`344`	`338`	"selecting trait `{:?}` at depth {} yielded Ok(Some)",
`345`	`339`	`data, obligation.recursion_depth`
`346`	`340`	`);`
`347`		`- ProcessResult::Changed(mk_pending(infcx, vtable.nested_obligations()))`
	`341`	`+ ProcessResult::Changed(mk_pending(vtable.nested_obligations()))`
`348`	`342`	`}`
`349`	`343`	`Ok(None) => {`
`350`	`344`	`debug!(`
`@@ -438,7 +432,7 @@ impl<'a, 'b, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'b, 'tcx> {`
`438`	`432`	`trait_ref_infer_vars(self.selcx, data.to_poly_trait_ref(tcx));`
`439`	`433`	`ProcessResult::Unchanged`
`440`	`434`	`}`
`441`		`- Ok(Some(os)) => ProcessResult::Changed(mk_pending(infcx, os)),`
	`435`	`+ Ok(Some(os)) => ProcessResult::Changed(mk_pending(os)),`
`442`	`436`	`Err(e) => ProcessResult::Error(CodeProjectionError(e)),`
`443`	`437`	`}`
`444`	`438`	`}`
`@@ -477,7 +471,7 @@ impl<'a, 'b, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'b, 'tcx> {`
`477`	`471`	`vec![TyOrConstInferVar::maybe_from_ty(ty).unwrap()];`
`478`	`472`	`ProcessResult::Unchanged`
`479`	`473`	`}`
`480`		`- Some(os) => ProcessResult::Changed(mk_pending(infcx, os)),`
	`474`	`+ Some(os) => ProcessResult::Changed(mk_pending(os)),`
`481`	`475`	`}`
`482`	`476`	`}`
`483`	`477`
`@@ -495,7 +489,7 @@ impl<'a, 'b, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'b, 'tcx> {`
`495`	`489`	`];`
`496`	`490`	`ProcessResult::Unchanged`
`497`	`491`	`}`
`498`		`- Some(Ok(ok)) => ProcessResult::Changed(mk_pending(infcx, ok.obligations)),`
	`492`	`+ Some(Ok(ok)) => ProcessResult::Changed(mk_pending(ok.obligations)),`
`499`	`493`	`Some(Err(err)) => {`
`500`	`494`	`let expected_found = ExpectedFound::new(`
`501`	`495`	`subtype.skip_binder().a_is_expected,`