finally remove region_constraints::UndoLog

compiler/rustc_infer/src/infer/mod.rs

@@ -18,7 +18,6 @@ use crate::traits::{self, ObligationCause, PredicateObligations, TraitEngine, Tr
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_data_structures::sync::Lrc;
-use rustc_data_structures::undo_log::Rollback;
 use rustc_data_structures::unify as ut;
 use rustc_errors::{DiagnosticBuilder, ErrorGuaranteed};
 use rustc_hir::def_id::{DefId, LocalDefId};

compiler/rustc_infer/src/infer/region_constraints/mod.rs

@@ -1,9 +1,8 @@
 //! See `README.md`.
 
 use self::CombineMapType::*;
-use self::UndoLog::*;
 
-use super::{InferCtxtUndoLogs, MiscVariable, RegionVariableOrigin, Rollback, SubregionOrigin};
+use super::{InferCtxtUndoLogs, MiscVariable, RegionVariableOrigin, SubregionOrigin};
 
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_data_structures::intern::Interned;
@@ -264,21 +263,6 @@ pub(crate) struct TwoRegions<'tcx> {
     b: Region<'tcx>,
 }
 
-#[derive(Copy, Clone, PartialEq)]
-pub(crate) enum UndoLog<'tcx> {
-    /// We added `RegionVid`.
-    AddVar(RegionVid),
-
-    /// We added the given `constraint`.
-    AddConstraint(usize),
-
-    /// We added the given `verify`.
-    AddVerify(usize),
-
-    /// We added a GLB/LUB "combination variable".
-    AddCombination(CombineMapType, TwoRegions<'tcx>),
-}
-
 #[derive(Copy, Clone, PartialEq)]
 pub(crate) enum CombineMapType {
     Lub,
@@ -314,29 +298,6 @@ impl<'tcx> RegionConstraintStorage<'tcx> {
     ) -> RegionConstraintCollector<'a, 'tcx> {
         RegionConstraintCollector { storage: self, undo_log }
     }
-
-    fn rollback_undo_entry(&mut self, undo_entry: UndoLog<'tcx>) {
-        match undo_entry {
-            AddVar(vid) => {
-                self.var_infos.pop().unwrap();
-                assert_eq!(self.var_infos.len(), vid.index());
-            }
-            AddConstraint(index) => {
-                self.data.constraints.pop().unwrap();
-                assert_eq!(self.data.constraints.len(), index);
-            }
-            AddVerify(index) => {
-                self.data.verifys.pop();
-                assert_eq!(self.data.verifys.len(), index);
-            }
-            AddCombination(Glb, ref regions) => {
-                self.glbs.remove(regions);
-            }
-            AddCombination(Lub, ref regions) => {
-                self.lubs.remove(regions);
-            }
-        }
-    }
 }
 
 impl<'tcx> RegionConstraintCollector<'_, 'tcx> {
@@ -447,7 +408,6 @@ impl<'tcx> RegionConstraintCollector<'_, 'tcx> {
 
         let u_vid = self.unification_table_mut().new_key(UnifiedRegion::new(None));
         assert_eq!(vid, u_vid.vid);
-        self.undo_log.push(AddVar(vid));
         debug!("created new region variable {:?} in {:?} with origin {:?}", vid, universe, origin);
         vid
     }
@@ -465,10 +425,7 @@ impl<'tcx> RegionConstraintCollector<'_, 'tcx> {
     fn add_constraint(&mut self, constraint: Constraint<'tcx>, origin: SubregionOrigin<'tcx>) {
         // cannot add constraints once regions are resolved
         debug!("RegionConstraintCollector: add_constraint({:?})", constraint);
-
-        let index = self.storage.data.constraints.len();
         self.storage.data.constraints.push((constraint, origin));
-        self.undo_log.push(AddConstraint(index));
     }
 
     fn add_verify(&mut self, verify: Verify<'tcx>) {
@@ -482,9 +439,7 @@ impl<'tcx> RegionConstraintCollector<'_, 'tcx> {
             return;
         }
 
-        let index = self.data.verifys.len();
         self.data.verifys.push(verify);
-        self.undo_log.push(AddVerify(index));
     }
 
     pub(super) fn make_eqregion(
@@ -671,7 +626,6 @@ impl<'tcx> RegionConstraintCollector<'_, 'tcx> {
         let c_universe = cmp::max(a_universe, b_universe);
         let c = self.new_region_var(c_universe, MiscVariable(origin.span()));
         self.combine_map(t).insert(vars, c);
-        self.undo_log.push(AddCombination(t, vars));
         let new_r = ty::Region::new_var(tcx, c);
         for old_r in [a, b] {
             match t {
@@ -804,9 +758,3 @@ impl<'tcx> RegionConstraintData<'tcx> {
         constraints.is_empty() && member_constraints.is_empty() && verifys.is_empty()
     }
 }
-
-impl<'tcx> Rollback<UndoLog<'tcx>> for RegionConstraintStorage<'tcx> {
-    fn reverse(&mut self, undo: UndoLog<'tcx>) {
-        self.rollback_undo_entry(undo)
-    }
-}

compiler/rustc_infer/src/infer/undo_log.rs

@@ -7,7 +7,7 @@ use rustc_middle::infer::unify_key::{ConstVidKey, EffectVidKey, RegionVidKey};
 use rustc_middle::ty::{self, OpaqueHiddenType, OpaqueTypeKey};
 
 use crate::{
-    infer::{region_constraints, type_variable, InferCtxtInner},
+    infer::{type_variable, InferCtxtInner},
     traits,
 };
 
@@ -25,7 +25,6 @@ pub(crate) enum UndoLog<'tcx> {
     IntUnificationTable(sv::UndoLog<ut::Delegate<ty::IntVid>>),
     FloatUnificationTable(sv::UndoLog<ut::Delegate<ty::FloatVid>>),
     EffectUnificationTable(sv::UndoLog<ut::Delegate<EffectVidKey<'tcx>>>),
-    RegionConstraintCollector(region_constraints::UndoLog<'tcx>),
     RegionUnificationTable(sv::UndoLog<ut::Delegate<RegionVidKey<'tcx>>>),
     ProjectionCache(traits::UndoLog<'tcx>),
     PushRegionObligation,
@@ -45,7 +44,6 @@ macro_rules! impl_from {
 
 // Upcast from a single kind of "undoable action" to the general enum
 impl_from! {
-    RegionConstraintCollector(region_constraints::UndoLog<'tcx>),
     TypeVariables(type_variable::UndoLog<'tcx>),
 
     TypeVariables(sv::UndoLog<ut::Delegate<type_variable::TyVidEqKey<'tcx>>>),
@@ -72,9 +70,6 @@ impl<'tcx> Rollback<UndoLog<'tcx>> for InferCtxtInner<'tcx> {
             UndoLog::IntUnificationTable(undo) => self.int_unification_storage.reverse(undo),
             UndoLog::FloatUnificationTable(undo) => self.float_unification_storage.reverse(undo),
             UndoLog::EffectUnificationTable(undo) => self.effect_unification_storage.reverse(undo),
-            UndoLog::RegionConstraintCollector(undo) => {
-                self.region_constraint_storage.as_mut().unwrap().reverse(undo)
-            }
             UndoLog::RegionUnificationTable(undo) => {
                 self.region_constraint_storage.as_mut().unwrap().unification_table.reverse(undo)
             }