Rebase on top of undo_log unification

Author: Markus Westerlind

compiler/rustc_data_structures/src/logged_unification_table.rs

@@ -9,10 +9,10 @@ use crate::unify_log as ul;
 
 use ena::undo_log::{Rollback, Snapshots, UndoLogs};
 
-enum UndoLog<K: ut::UnifyKey, I> {
+pub enum UndoLog<K: ut::UnifyKey, I = K> {
     Relation(sv::UndoLog<ut::Delegate<K>>),
     UnifyLog(ul::Undo<I>),
-    ModifiedSet(ms::Undo),
+    ModifiedSet(ms::Undo<I>),
 }
 
 impl<K: ut::UnifyKey, I> From<sv::UndoLog<ut::Delegate<K>>> for UndoLog<K, I> {
@@ -27,8 +27,8 @@ impl<K: ut::UnifyKey, I> From<ul::Undo<I>> for UndoLog<K, I> {
     }
 }
 
-impl<K: ut::UnifyKey, I> From<ms::Undo> for UndoLog<K, I> {
-    fn from(l: ms::Undo) -> Self {
+impl<K: ut::UnifyKey, I> From<ms::Undo<I>> for UndoLog<K, I> {
+    fn from(l: ms::Undo<I>) -> Self {
         UndoLog::ModifiedSet(l)
     }
 }
@@ -56,6 +56,10 @@ where
             self.logs.push(undo.into())
         }
     }
+    fn clear(&mut self) {
+        self.logs.clear();
+        self.num_open_snapshots = 0;
+    }
     fn extend<J>(&mut self, undos: J)
     where
         Self: Sized,
@@ -67,13 +71,7 @@ where
     }
 }
 
-struct RollbackView<'a, K: ut::UnifyKey, I: Idx> {
-    relations: &'a mut ut::UnificationStorage<K>,
-    unify_log: &'a mut ul::UnifyLog<I>,
-    modified_set: &'a mut ms::ModifiedSet<I>,
-}
-
-impl<K: ut::UnifyKey, I: Idx> Rollback<UndoLog<K, I>> for RollbackView<'_, K, I> {
+impl<K: ut::UnifyKey, I: Idx> Rollback<UndoLog<K, I>> for LoggedUnificationTableStorage<K, I> {
     fn reverse(&mut self, undo: UndoLog<K, I>) {
         match undo {
             UndoLog::Relation(undo) => self.relations.reverse(undo),
@@ -93,12 +91,18 @@ impl<K: ut::UnifyKey, I: Idx> Snapshots<UndoLog<K, I>> for Logs<K, I> {
         unreachable!()
     }
 
-    fn rollback_to(&mut self, values: &mut impl Rollback<UndoLog<K, I>>, snapshot: Self::Snapshot) {
+    fn rollback_to<R>(&mut self, values: impl FnOnce() -> R, snapshot: Self::Snapshot)
+    where
+        R: Rollback<UndoLog<K, I>>,
+    {
         debug!("rollback_to({})", snapshot.undo_len);
         self.assert_open_snapshot(&snapshot);
 
-        while self.logs.len() > snapshot.undo_len {
-            values.reverse(self.logs.pop().unwrap());
+        if self.logs.len() > snapshot.undo_len {
+            let mut values = values();
+            while self.logs.len() > snapshot.undo_len {
+                values.reverse(self.logs.pop().unwrap());
+            }
         }
 
         if self.num_open_snapshots == 1 {
@@ -135,14 +139,18 @@ impl<K: ut::UnifyKey, I: Idx> Logs<K, I> {
     }
 }
 
-pub struct LoggedUnificationTable<K: ut::UnifyKey, I: Idx = K> {
-    relations: ut::UnificationStorage<K>,
+pub struct LoggedUnificationTableStorage<K: ut::UnifyKey, I: Idx = K> {
+    relations: ut::UnificationTableStorage<K>,
     unify_log: ul::UnifyLog<I>,
     modified_set: ms::ModifiedSet<I>,
-    undo_log: Logs<K, I>,
 }
 
-impl<K, I> LoggedUnificationTable<K, I>
+pub struct LoggedUnificationTable<'a, K: ut::UnifyKey, I: Idx, L> {
+    storage: &'a mut LoggedUnificationTableStorage<K, I>,
+    undo_log: L,
+}
+
+impl<K, I> LoggedUnificationTableStorage<K, I>
 where
     K: ut::UnifyKey + From<I>,
     I: Idx + From<K>,
@@ -152,14 +160,34 @@ where
             relations: Default::default(),
             unify_log: ul::UnifyLog::new(),
             modified_set: ms::ModifiedSet::new(),
-            undo_log: Logs::default(),
         }
     }
 
+    pub fn with_log<L>(&mut self, undo_log: L) -> LoggedUnificationTable<'_, K, I, L> {
+        LoggedUnificationTable { storage: self, undo_log }
+    }
+}
+
+impl<K, I, L> LoggedUnificationTable<'_, K, I, L>
+where
+    K: ut::UnifyKey,
+    I: Idx,
+{
+    pub fn len(&self) -> usize {
+        self.storage.relations.len()
+    }
+}
+
+impl<K, I, L> LoggedUnificationTable<'_, K, I, L>
+where
+    K: ut::UnifyKey + From<I>,
+    I: Idx + From<K>,
+    L: UndoLogs<ms::Undo<I>> + UndoLogs<ul::Undo<I>> + UndoLogs<sv::UndoLog<ut::Delegate<K>>>,
+{
     fn relations(
         &mut self,
-    ) -> ut::UnificationTable<ut::InPlace<K, &mut ut::UnificationStorage<K>, &mut Logs<K, I>>> {
-        ut::UnificationTable::with_log(&mut self.relations, &mut self.undo_log)
+    ) -> ut::UnificationTable<ut::InPlace<K, &mut ut::UnificationStorage<K>, &mut L>> {
+        ut::UnificationTable::with_log(&mut self.storage.relations, &mut self.undo_log)
     }
 
     pub fn unify(&mut self, a: I, b: I)
@@ -173,9 +201,9 @@ where
     where
         K::Value: ut::UnifyValue<Error = ut::NoError>,
     {
-        if self.unify_log.needs_log(vid) {
+        if self.storage.unify_log.needs_log(vid) {
             warn!("ModifiedSet {:?} => {:?}", vid, ty);
-            self.modified_set.set(&mut self.undo_log, vid);
+            self.storage.modified_set.set(&mut self.undo_log, vid);
         }
         let vid = vid.into();
         let mut relations = self.relations();
@@ -195,8 +223,8 @@ where
         value: K::Value,
     ) -> Result<(), <K::Value as ut::UnifyValue>::Error> {
         let vid = self.find(vid).into();
-        if self.unify_log.needs_log(vid) {
-            self.modified_set.set(&mut self.undo_log, vid);
+        if self.storage.unify_log.needs_log(vid) {
+            self.storage.modified_set.set(&mut self.undo_log, vid);
         }
         self.relations().unify_var_value(vid, value)
     }
@@ -212,9 +240,9 @@ where
         relations.unify_var_var(a, b)?;
 
         if a == relations.find(a) {
-            self.unify_log.unify(&mut self.undo_log, a.into(), b.into());
+            self.storage.unify_log.unify(&mut self.undo_log, a.into(), b.into());
         } else {
-            self.unify_log.unify(&mut self.undo_log, b.into(), a.into());
+            self.storage.unify_log.unify(&mut self.undo_log, b.into(), a.into());
         }
         Ok(())
     }
@@ -240,14 +268,11 @@ where
         self.relations().new_key(value)
     }
 
-    pub fn len(&self) -> usize {
-        self.relations.len()
-    }
-
     pub fn vars_since_snapshot(&mut self, s: &Snapshot<K, I>) -> Range<K> {
         K::from(I::new(s.value_count))..K::from(I::new(self.relations().len()))
     }
 
+    /* FIXME
     pub fn snapshot(&mut self) -> Snapshot<K, I> {
         self.undo_log.num_open_snapshots += 1;
         Snapshot {
@@ -258,44 +283,44 @@ where
     }
 
     pub fn rollback_to(&mut self, snapshot: Snapshot<K, I>) {
-        let Self { relations, unify_log, modified_set, .. } = self;
+        let UnificationTableStorage { relations, unify_log, modified_set, .. } = self.storage;
 
-        self.undo_log
-            .rollback_to(&mut RollbackView { relations, unify_log, modified_set }, snapshot);
+        self.undo_log.rollback_to(|| RollbackView { relations, unify_log, modified_set }, snapshot);
 
         if self.undo_log.num_open_snapshots == 0 {
-            self.modified_set.clear();
+            self.storage.modified_set.clear();
         }
     }
 
     pub fn commit(&mut self, snapshot: Snapshot<K, I>) {
         self.undo_log.commit(snapshot);
 
-        if self.undo_log.num_open_snapshots == 0 {
-            self.modified_set.clear();
+        if self.undo_log.num_open_snapshots() == 0 {
+            self.storage.modified_set.clear();
         }
     }
+    */
 
     pub fn register(&mut self) -> ms::Offset<I> {
-        self.modified_set.register()
+        self.storage.modified_set.register()
     }
 
     pub fn deregister(&mut self, offset: ms::Offset<I>) {
-        self.modified_set.deregister(offset);
+        self.storage.modified_set.deregister(offset);
     }
 
     pub fn watch_variable(&mut self, index: I) {
         debug_assert!(index == self.relations().find(index).into());
-        self.unify_log.watch_variable(index)
+        self.storage.unify_log.watch_variable(index)
     }
 
     pub fn unwatch_variable(&mut self, index: I) {
-        self.unify_log.unwatch_variable(index)
+        self.storage.unify_log.unwatch_variable(index)
     }
 
     pub fn drain_modified_set(&mut self, offset: &ms::Offset<I>, mut f: impl FnMut(I) -> bool) {
-        let unify_log = &self.unify_log;
-        self.modified_set.drain(&mut self.undo_log, offset, |vid| {
+        let unify_log = &self.storage.unify_log;
+        self.storage.modified_set.drain(&mut self.undo_log, offset, |vid| {
             for &unified_vid in unify_log.get(vid) {
                 f(unified_vid);
             }

compiler/rustc_data_structures/src/modified_set.rs

@@ -5,11 +5,14 @@ use rustc_index::vec::Idx;
 use ena::undo_log::{Rollback, UndoLogs};
 
 #[derive(Copy, Clone, Debug)]
-pub enum Undo {
+enum UndoInner {
     Add,
     Drain { index: usize, offset: usize },
 }
 
+#[derive(Copy, Clone, Debug)]
+pub struct Undo<I>(UndoInner, PhantomData<I>);
+
 #[derive(Clone, Debug)]
 pub struct ModifiedSet<T: Idx> {
     modified: Vec<T>,
@@ -27,14 +30,14 @@ impl<T: Idx> ModifiedSet<T> {
         Self::default()
     }
 
-    pub fn set(&mut self, undo_log: &mut impl UndoLogs<Undo>, index: T) {
+    pub fn set(&mut self, undo_log: &mut impl UndoLogs<Undo<T>>, index: T) {
         self.modified.push(index);
-        undo_log.push(Undo::Add);
+        undo_log.push(Undo(UndoInner::Add, PhantomData));
     }
 
     pub fn drain(
         &mut self,
-        undo_log: &mut impl UndoLogs<Undo>,
+        undo_log: &mut impl UndoLogs<Undo<T>>,
         index: &Offset<T>,
         mut f: impl FnMut(T) -> bool,
     ) {
@@ -43,7 +46,8 @@ impl<T: Idx> ModifiedSet<T> {
             for &index in &self.modified[*offset..] {
                 f(index);
             }
-            undo_log.push(Undo::Drain { index: index.index, offset: *offset });
+            undo_log
+                .push(Undo(UndoInner::Drain { index: index.index, offset: *offset }, PhantomData));
             *offset = self.modified.len();
         }
     }
@@ -69,13 +73,13 @@ impl<T: Idx> ModifiedSet<T> {
     }
 }
 
-impl<I: Idx> Rollback<Undo> for ModifiedSet<I> {
-    fn reverse(&mut self, undo: Undo) {
-        match undo {
-            Undo::Add => {
+impl<I: Idx> Rollback<Undo<I>> for ModifiedSet<I> {
+    fn reverse(&mut self, undo: Undo<I>) {
+        match undo.0 {
+            UndoInner::Add => {
                 self.modified.pop();
             }
-            Undo::Drain { index, offset } => {
+            UndoInner::Drain { index, offset } => {
                 if let Some(o) = self.offsets.get_mut(index) {
                     *o = offset;
                 }

compiler/rustc_infer/src/infer/combine.rs

@@ -226,9 +226,11 @@ impl<'infcx, 'tcx> InferCtxt<'infcx, 'tcx> {
     fn unify_const_variable(
         &self,
         param_env: ty::ParamEnv<'tcx>,
-        target_vid: ty::ConstVid<'tcx>,
+        target_vid: ty::ConstVid,
         ct: &'tcx ty::Const<'tcx>,
         vid_is_expected: bool,
+        vid: ty::ConstVid,
+        value: &'tcx ty::Const<'tcx>,
     ) -> RelateResult<'tcx, &'tcx ty::Const<'tcx>> {
         let (for_universe, span) = {
             let mut inner = self.inner.borrow_mut();
@@ -722,10 +724,14 @@ impl TypeRelation<'tcx> for Generalizer<'_, 'tcx> {
                         if self.for_universe.can_name(universe) {
                             Ok(c)
                         } else {
-                            let new_var_id = variable_table.new_key(ConstVarValue {
-                                origin: var_value.origin,
-                                val: ConstVariableValue::Unknown { universe: self.for_universe },
-                            });
+                            let new_var_id = variable_table
+                                .new_key(ConstVarValue {
+                                    origin: var_value.origin,
+                                    val: ConstVariableValue::Unknown {
+                                        universe: self.for_universe,
+                                    },
+                                })
+                                .vid;
                             Ok(self.tcx().mk_const_var(new_var_id, c.ty))
                         }
                     }

compiler/rustc_infer/src/infer/freshen.rs

@@ -46,7 +46,7 @@ pub struct TypeFreshener<'a, 'tcx> {
     ty_freshen_count: u32,
     const_freshen_count: u32,
     ty_freshen_map: FxHashMap<ty::InferTy, Ty<'tcx>>,
-    const_freshen_map: FxHashMap<ty::InferConst<'tcx>, &'tcx ty::Const<'tcx>>,
+    const_freshen_map: FxHashMap<ty::InferConst, &'tcx ty::Const<'tcx>>,
 }
 
 impl<'a, 'tcx> TypeFreshener<'a, 'tcx> {
@@ -88,12 +88,12 @@ impl<'a, 'tcx> TypeFreshener<'a, 'tcx> {
     fn freshen_const<F>(
         &mut self,
         opt_ct: Option<&'tcx ty::Const<'tcx>>,
-        key: ty::InferConst<'tcx>,
+        key: ty::InferConst,
         freshener: F,
         ty: Ty<'tcx>,
     ) -> &'tcx ty::Const<'tcx>
     where
-        F: FnOnce(u32) -> ty::InferConst<'tcx>,
+        F: FnOnce(u32) -> ty::InferConst,
     {
         if let Some(ct) = opt_ct {
             return ct.fold_with(self);