Clear the modified set once no snapshots exist

Author: Markus Westerlind

compiler/rustc_data_structures/src/logged_unification_table.rs

@@ -1,13 +1,11 @@
-use std::{marker::PhantomData, ops::Range};
-
 use rustc_index::vec::Idx;
 
 use crate::modified_set as ms;
 use crate::snapshot_vec as sv;
 use crate::unify as ut;
 use crate::unify_log as ul;
 
-use ena::undo_log::{Rollback, Snapshots, UndoLogs};
+use ena::undo_log::{Rollback, UndoLogs};
 
 pub enum UndoLog<K: ut::UnifyKey, I = K> {
     Relation(sv::UndoLog<ut::Delegate<K>>),
@@ -33,44 +31,6 @@ impl<K: ut::UnifyKey, I> From<ms::Undo<I>> for UndoLog<K, I> {
     }
 }
 
-struct Logs<K: ut::UnifyKey, I> {
-    logs: Vec<UndoLog<K, I>>,
-    num_open_snapshots: usize,
-}
-
-impl<K: ut::UnifyKey, I> Default for Logs<K, I> {
-    fn default() -> Self {
-        Self { logs: Default::default(), num_open_snapshots: Default::default() }
-    }
-}
-
-impl<T, K: ut::UnifyKey, I> UndoLogs<T> for Logs<K, I>
-where
-    UndoLog<K, I>: From<T>,
-{
-    fn num_open_snapshots(&self) -> usize {
-        self.num_open_snapshots
-    }
-    fn push(&mut self, undo: T) {
-        if self.in_snapshot() {
-            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,
-        J: IntoIterator<Item = T>,
-    {
-        if self.in_snapshot() {
-            self.logs.extend(undos.into_iter().map(UndoLog::from))
-        }
-    }
-}
-
 impl<K: ut::UnifyKey, I: Idx> Rollback<UndoLog<K, I>> for LoggedUnificationTableStorage<K, I> {
     fn reverse(&mut self, undo: UndoLog<K, I>) {
         match undo {
@@ -81,64 +41,6 @@ impl<K: ut::UnifyKey, I: Idx> Rollback<UndoLog<K, I>> for LoggedUnificationTable
     }
 }
 
-impl<K: ut::UnifyKey, I: Idx> Snapshots<UndoLog<K, I>> for Logs<K, I> {
-    type Snapshot = Snapshot<K, I>;
-    fn actions_since_snapshot(&self, snapshot: &Self::Snapshot) -> &[UndoLog<K, I>] {
-        &self.logs[snapshot.undo_len..]
-    }
-
-    fn start_snapshot(&mut self) -> Self::Snapshot {
-        unreachable!()
-    }
-
-    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);
-
-        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 {
-            // The root snapshot. It's safe to clear the undo log because
-            // there's no snapshot further out that we might need to roll back
-            // to.
-            assert!(snapshot.undo_len == 0);
-            self.logs.clear();
-        }
-
-        self.num_open_snapshots -= 1;
-    }
-
-    fn commit(&mut self, snapshot: Self::Snapshot) {
-        debug!("commit({})", snapshot.undo_len);
-
-        if self.num_open_snapshots == 1 {
-            // The root snapshot. It's safe to clear the undo log because
-            // there's no snapshot further out that we might need to roll back
-            // to.
-            assert!(snapshot.undo_len == 0);
-            self.logs.clear();
-        }
-
-        self.num_open_snapshots -= 1;
-    }
-}
-
-impl<K: ut::UnifyKey, I: Idx> Logs<K, I> {
-    fn assert_open_snapshot(&self, snapshot: &Snapshot<K, I>) {
-        // Failures here may indicate a failure to follow a stack discipline.
-        assert!(self.logs.len() >= snapshot.undo_len);
-        assert!(self.num_open_snapshots > 0);
-    }
-}
-
 pub struct LoggedUnificationTableStorage<K: ut::UnifyKey, I: Idx = K> {
     relations: ut::UnificationTableStorage<K>,
     unify_log: ul::UnifyLog<I>,
@@ -268,39 +170,10 @@ where
         self.relations().new_key(value)
     }
 
-    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()))
+    pub fn clear_modified_set(&mut self) {
+        self.storage.modified_set.clear();
     }
 
-    /* FIXME
-    pub fn snapshot(&mut self) -> Snapshot<K, I> {
-        self.undo_log.num_open_snapshots += 1;
-        Snapshot {
-            undo_len: self.undo_log.logs.len(),
-            value_count: self.relations().len(),
-            _marker: PhantomData,
-        }
-    }
-
-    pub fn rollback_to(&mut self, snapshot: Snapshot<K, I>) {
-        let UnificationTableStorage { relations, unify_log, modified_set, .. } = self.storage;
-
-        self.undo_log.rollback_to(|| RollbackView { relations, unify_log, modified_set }, snapshot);
-
-        if self.undo_log.num_open_snapshots == 0 {
-            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.storage.modified_set.clear();
-        }
-    }
-    */
-
     pub fn register(&mut self) -> ms::Offset<I> {
         self.storage.modified_set.register()
     }
@@ -329,9 +202,3 @@ where
         })
     }
 }
-
-pub struct Snapshot<K: ut::UnifyKey, I: Idx = K> {
-    undo_len: usize,
-    value_count: usize,
-    _marker: PhantomData<(K, I)>,
-}

compiler/rustc_infer/src/infer/mod.rs

@@ -14,7 +14,7 @@ use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_data_structures::logged_unification_table as lut;
 use rustc_data_structures::modified_set as ms;
 use rustc_data_structures::sync::Lrc;
-use rustc_data_structures::undo_log::Rollback;
+use rustc_data_structures::undo_log::{Rollback, UndoLogs};
 use rustc_data_structures::unify as ut;
 use rustc_errors::DiagnosticBuilder;
 use rustc_hir as hir;
@@ -763,6 +763,13 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
         let mut inner = self.inner.borrow_mut();
         inner.rollback_to(undo_snapshot);
         inner.unwrap_region_constraints().rollback_to(region_constraints_snapshot);
+
+        if UndoLogs::<UndoLog<'_>>::num_open_snapshots(&inner.undo_log) == 0 {
+            inner.type_variables().clear_modified_set();
+            inner.int_unification_table().clear_modified_set();
+            inner.float_unification_table().clear_modified_set();
+            inner.const_unification_table().clear_modified_set();
+        }
     }
 
     fn commit_from(&self, snapshot: CombinedSnapshot<'a, 'tcx>) {

compiler/rustc_infer/src/infer/type_variable.rs

@@ -433,6 +433,10 @@ impl<'tcx> TypeVariableTable<'_, 'tcx> {
             .collect()
     }
 
+    pub fn clear_modified_set(&mut self) {
+        self.eq_relations().clear_modified_set();
+    }
+
     pub fn drain_modified_set(
         &mut self,
         offset: &ms::Offset<ty::TyVid>,