Implement prototype

Author: aerooneqq

compiler/rustc_data_structures/src/sharded.rs

@@ -199,6 +199,16 @@ impl<K: Eq + Hash, V> ShardedHashMap<K, V> {
             }
         }
     }
+
+    #[inline]
+    pub fn remove(&self, key: &K) {
+        let hash = make_hash(key);
+        let mut shard = self.lock_shard_by_hash(hash);
+
+        if let Entry::Occupied(e) = table_entry(&mut shard, hash, key) {
+            e.remove();
+        }
+    }
 }
 
 impl<K: Eq + Hash + Copy> ShardedHashMap<K, ()> {

compiler/rustc_data_structures/src/vec_cache.rs

@@ -206,6 +206,24 @@ impl SlotIndex {
 
         index_and_lock.store(extra.checked_add(2).unwrap(), Ordering::Release);
     }
+
+    #[inline]
+    unsafe fn remove<V>(&self, buckets: &[AtomicPtr<Slot<V>>; 21]) {
+        let bucket = &buckets[self.bucket_idx];
+        let ptr = self.bucket_ptr(bucket);
+
+        debug_assert!(self.index_in_bucket < self.bucket_idx.capacity());
+
+        // SAFETY: `bucket` was allocated (so <= isize in total bytes) to hold `entries`, so this
+        // must be inbounds.
+        let slot = unsafe { ptr.add(self.index_in_bucket) };
+
+        // SAFETY: initialized bucket has zeroed all memory within the bucket, so we are valid for
+        // AtomicU32 access.
+        let index_and_lock = unsafe { &(*slot).index_and_lock };
+
+        index_and_lock.store(0, Ordering::Release);
+    }
 }
 
 /// In-memory cache for queries whose keys are densely-numbered IDs
@@ -339,6 +357,39 @@ where
     pub fn len(&self) -> usize {
         self.len.load(Ordering::Acquire)
     }
+
+    pub fn remove(&self, key: &K) {
+        let key = u32::try_from(key.index()).unwrap();
+        let slot_idx = SlotIndex::from_index(key);
+
+        unsafe { slot_idx.remove(&self.buckets) };
+    }
+
+    pub fn invalidate(&self, selector: impl Fn(K) -> bool) {
+        let mut to_remove = vec![];
+        let mut remaining = vec![];
+
+        self.for_each(&mut |key, _, _| {
+            if selector(*key) {
+                to_remove.push(*key);
+            } else {
+                remaining.push(*key);
+            }
+        });
+
+        for key in to_remove {
+            self.remove(&key);
+        }
+
+        for (index, key) in remaining.iter().enumerate() {
+            let slot = SlotIndex::from_index(u32::try_from(index).unwrap());
+            let key = u32::try_from(key.index()).unwrap();
+
+            unsafe { slot.put_unique(&self.present, (), key) };
+        }
+
+        self.len.store(remaining.len(), Ordering::Release);
+    }
 }
 
 /// Index into an array of buckets.

compiler/rustc_hir/src/definitions.rs

@@ -7,6 +7,7 @@
 use std::fmt::{self, Write};
 use std::hash::Hash;
 
+use rustc_data_structures::indexmap::IndexSet;
 use rustc_data_structures::stable_hasher::StableHasher;
 use rustc_data_structures::unord::UnordMap;
 use rustc_hashes::Hash64;
@@ -30,6 +31,7 @@ pub struct DefPathTable {
     // We do only store the local hash, as all the definitions are from the current crate.
     def_path_hashes: IndexVec<DefIndex, Hash64>,
     def_path_hash_to_index: DefPathHashMap,
+    allow_overwrite: IndexSet<DefIndex>,
 }
 
 impl DefPathTable {
@@ -39,38 +41,45 @@ impl DefPathTable {
             index_to_key: Default::default(),
             def_path_hashes: Default::default(),
             def_path_hash_to_index: Default::default(),
+            allow_overwrite: Default::default(),
         }
     }
 
     fn allocate(&mut self, key: DefKey, def_path_hash: DefPathHash) -> DefIndex {
         // Assert that all DefPathHashes correctly contain the local crate's StableCrateId.
         debug_assert_eq!(self.stable_crate_id, def_path_hash.stable_crate_id());
         let local_hash = def_path_hash.local_hash();
-
-        let index = self.index_to_key.push(key);
-        debug!("DefPathTable::insert() - {key:?} <-> {index:?}");
-
-        self.def_path_hashes.push(local_hash);
-        debug_assert!(self.def_path_hashes.len() == self.index_to_key.len());
+        let index = self.index_to_key.next_index();
 
         // Check for hash collisions of DefPathHashes. These should be
         // exceedingly rare.
         if let Some(existing) = self.def_path_hash_to_index.insert(&local_hash, &index) {
-            let def_path1 = DefPath::make(LOCAL_CRATE, existing, |idx| self.def_key(idx));
-            let def_path2 = DefPath::make(LOCAL_CRATE, index, |idx| self.def_key(idx));
-
-            // Continuing with colliding DefPathHashes can lead to correctness
-            // issues. We must abort compilation.
-            //
-            // The likelihood of such a collision is very small, so actually
-            // running into one could be indicative of a poor hash function
-            // being used.
-            //
-            // See the documentation for DefPathHash for more information.
-            panic!(
-                "found DefPathHash collision between {def_path1:#?} and {def_path2:#?}. \
+            if !self.allow_overwrite.is_empty() && self.allow_overwrite.swap_remove(&existing) {
+                self.def_path_hash_to_index.insert(&local_hash, &existing);
+                return existing;
+            } else {
+                let def_path1 = DefPath::make(LOCAL_CRATE, existing, |idx| self.def_key(idx));
+                let def_path2 = DefPath::make(LOCAL_CRATE, index, |idx| self.def_key(idx));
+
+                // Continuing with colliding DefPathHashes can lead to correctness
+                // issues. We must abort compilation.
+                //
+                // The likelihood of such a collision is very small, so actually
+                // running into one could be indicative of a poor hash function
+                // being used.
+                //
+                // See the documentation for DefPathHash for more information.
+                panic!(
+                    "found DefPathHash collision between {def_path1:#?} and {def_path2:#?}. \
                     Compilation cannot continue."
-            );
+                );
+            }
+        } else {
+            self.index_to_key.push(key);
+            debug!("DefPathTable::insert() - {key:?} <-> {index:?}");
+
+            self.def_path_hashes.push(local_hash);
+            debug_assert!(self.def_path_hashes.len() == self.index_to_key.len());
         }
 
         index
@@ -422,6 +431,10 @@ impl Definitions {
         LocalDefId { local_def_index: self.table.allocate(key, def_path_hash) }
     }
 
+    pub fn add_sandbox_def_id(&mut self, id: LocalDefId) {
+        assert_eq!(self.table.allow_overwrite.insert(id.local_def_index), true);
+    }
+
     #[inline(always)]
     /// Returns `None` if the `DefPathHash` does not correspond to a `LocalDefId`
     /// in the current compilation session. This can legitimately happen if the

compiler/rustc_hir/src/intravisit.rs

@@ -226,6 +226,11 @@ pub trait Visitor<'v>: Sized {
     /// or `ControlFlow<T>`.
     type Result: VisitorResult = ();
 
+    #[inline]
+    fn visit_if_delayed(&self, _: LocalDefId) -> bool {
+        true
+    }
+
     /// If `type NestedFilter` is set to visit nested items, this method
     /// must also be overridden to provide a map to retrieve nested items.
     fn maybe_tcx(&mut self) -> Self::MaybeTyCtxt {
@@ -244,18 +249,23 @@ pub trait Visitor<'v>: Sized {
     /// this method is if you want a nested pattern but cannot supply a
     /// `TyCtxt`; see `maybe_tcx` for advice.
     fn visit_nested_item(&mut self, id: ItemId) -> Self::Result {
-        if Self::NestedFilter::INTER {
+        if self.should_visit_maybe_delayed_inter(id.owner_id.def_id) {
             let item = self.maybe_tcx().hir_item(id);
             try_visit!(self.visit_item(item));
         }
         Self::Result::output()
     }
 
+    // Now delayed owners are only delegations, which are either item, trait item or impl item.
+    fn should_visit_maybe_delayed_inter(&mut self, id: LocalDefId) -> bool {
+        Self::NestedFilter::INTER && self.visit_if_delayed(id)
+    }
+
     /// Like `visit_nested_item()`, but for trait items. See
     /// `visit_nested_item()` for advice on when to override this
     /// method.
     fn visit_nested_trait_item(&mut self, id: TraitItemId) -> Self::Result {
-        if Self::NestedFilter::INTER {
+        if self.should_visit_maybe_delayed_inter(id.owner_id.def_id) {
             let item = self.maybe_tcx().hir_trait_item(id);
             try_visit!(self.visit_trait_item(item));
         }
@@ -266,7 +276,7 @@ pub trait Visitor<'v>: Sized {
     /// `visit_nested_item()` for advice on when to override this
     /// method.
     fn visit_nested_impl_item(&mut self, id: ImplItemId) -> Self::Result {
-        if Self::NestedFilter::INTER {
+        if self.should_visit_maybe_delayed_inter(id.owner_id.def_id) {
             let item = self.maybe_tcx().hir_impl_item(id);
             try_visit!(self.visit_impl_item(item));
         }

compiler/rustc_interface/src/passes.rs

@@ -1053,6 +1053,8 @@ pub fn emit_delayed_lints(tcx: TyCtxt<'_>) {
 /// Runs all analyses that we guarantee to run, even if errors were reported in earlier analyses.
 /// This function never fails.
 fn run_required_analyses(tcx: TyCtxt<'_>) {
+    tcx.force_delayed_owners_lowering();
+
     if tcx.sess.opts.unstable_opts.input_stats {
         rustc_passes::input_stats::print_hir_stats(tcx);
     }

compiler/rustc_middle/src/dep_graph/graph.rs

@@ -28,6 +28,7 @@ use super::{DepKind, DepNode, WorkProductId, read_deps, with_deps};
 use crate::dep_graph::edges::EdgesVec;
 use crate::ich::StableHashingContext;
 use crate::ty::TyCtxt;
+use crate::ty::tls::is_sandbox;
 use crate::verify_ich::incremental_verify_ich;
 
 /// Tracks 'side effects' for a particular query.
@@ -187,23 +188,23 @@ impl DepGraph {
 
     #[inline]
     pub fn data(&self) -> Option<&DepGraphData> {
-        self.data.as_deref()
+        self.data.as_deref().filter(|_| !is_sandbox())
     }
 
     /// Returns `true` if we are actually building the full dep-graph, and `false` otherwise.
     #[inline]
     pub fn is_fully_enabled(&self) -> bool {
-        self.data.is_some()
+        self.data().is_some()
     }
 
     pub fn with_retained_dep_graph(&self, f: impl Fn(&RetainedDepGraph)) {
-        if let Some(data) = &self.data {
+        if let Some(data) = self.data() {
             data.current.encoder.with_retained_dep_graph(f)
         }
     }
 
     pub fn assert_ignored(&self) {
-        if let Some(..) = self.data {
+        if let Some(..) = self.data() {
             read_deps(|task_deps| {
                 assert_matches!(
                     task_deps,
@@ -450,7 +451,7 @@ impl DepGraphData {
 impl DepGraph {
     #[inline]
     pub fn read_index(&self, dep_node_index: DepNodeIndex) {
-        if let Some(ref data) = self.data {
+        if let Some(ref data) = self.data() {
             read_deps(|task_deps| {
                 let mut task_deps = match task_deps {
                     TaskDepsRef::Allow(deps) => deps.lock(),
@@ -507,7 +508,7 @@ impl DepGraph {
     /// it with the node, for use in the next session.
     #[inline]
     pub fn record_diagnostic<'tcx>(&self, tcx: TyCtxt<'tcx>, diagnostic: &DiagInner) {
-        if let Some(ref data) = self.data {
+        if let Some(ref data) = self.data() {
             read_deps(|task_deps| match task_deps {
                 TaskDepsRef::EvalAlways | TaskDepsRef::Ignore => return,
                 TaskDepsRef::Forbid | TaskDepsRef::Allow(..) => {
@@ -522,7 +523,7 @@ impl DepGraph {
     /// refer to a node created used `encode_side_effect` in the previous session.
     #[inline]
     pub fn force_side_effect<'tcx>(&self, tcx: TyCtxt<'tcx>, prev_index: SerializedDepNodeIndex) {
-        if let Some(ref data) = self.data {
+        if let Some(ref data) = self.data() {
             data.force_side_effect(tcx, prev_index);
         }
     }
@@ -533,7 +534,7 @@ impl DepGraph {
         tcx: TyCtxt<'tcx>,
         side_effect: QuerySideEffect,
     ) -> DepNodeIndex {
-        if let Some(ref data) = self.data {
+        if let Some(ref data) = self.data() {
             data.encode_side_effect(tcx, side_effect)
         } else {
             self.next_virtual_depnode_index()
@@ -563,7 +564,7 @@ impl DepGraph {
         hash_result: Option<fn(&mut StableHashingContext<'_>, &R) -> Fingerprint>,
         format_value_fn: fn(&R) -> String,
     ) -> DepNodeIndex {
-        if let Some(data) = self.data.as_ref() {
+        if let Some(data) = self.data().as_ref() {
             // The caller query has more dependencies than the node we are creating. We may
             // encounter a case where this created node is marked as green, but the caller query is
             // subsequently marked as red or recomputed. In this case, we will end up feeding a
@@ -808,23 +809,23 @@ impl DepGraph {
     /// Checks whether a previous work product exists for `v` and, if
     /// so, return the path that leads to it. Used to skip doing work.
     pub fn previous_work_product(&self, v: &WorkProductId) -> Option<WorkProduct> {
-        self.data.as_ref().and_then(|data| data.previous_work_products.get(v).cloned())
+        self.data().as_ref().and_then(|data| data.previous_work_products.get(v).cloned())
     }
 
     /// Access the map of work-products created during the cached run. Only
     /// used during saving of the dep-graph.
     pub fn previous_work_products(&self) -> &WorkProductMap {
-        &self.data.as_ref().unwrap().previous_work_products
+        &self.data().as_ref().unwrap().previous_work_products
     }
 
     pub fn debug_was_loaded_from_disk(&self, dep_node: DepNode) -> bool {
-        self.data.as_ref().unwrap().debug_loaded_from_disk.lock().contains(&dep_node)
+        self.data().as_ref().unwrap().debug_loaded_from_disk.lock().contains(&dep_node)
     }
 
     pub fn debug_dep_kind_was_loaded_from_disk(&self, dep_kind: DepKind) -> bool {
         // We only check if we have a dep node corresponding to the given dep kind.
         #[allow(rustc::potential_query_instability)]
-        self.data
+        self.data()
             .as_ref()
             .unwrap()
             .debug_loaded_from_disk
@@ -834,7 +835,7 @@ impl DepGraph {
     }
 
     fn node_color(&self, dep_node: &DepNode) -> DepNodeColor {
-        if let Some(ref data) = self.data {
+        if let Some(ref data) = self.data() {
             return data.node_color(dep_node);
         }
 
@@ -980,7 +981,7 @@ impl DepGraph {
         dep_node: &DepNode,
         msg: impl FnOnce() -> S,
     ) {
-        if let Some(data) = &self.data {
+        if let Some(data) = &self.data() {
             data.assert_dep_node_not_yet_allocated_in_current_session(sess, dep_node, msg)
         }
     }
@@ -996,7 +997,7 @@ impl DepGraph {
     pub fn exec_cache_promotions<'tcx>(&self, tcx: TyCtxt<'tcx>) {
         let _prof_timer = tcx.prof.generic_activity("incr_comp_query_cache_promotion");
 
-        let data = self.data.as_ref().unwrap();
+        let data = self.data().unwrap();
         for prev_index in data.colors.values.indices() {
             match data.colors.get(prev_index) {
                 DepNodeColor::Green(_) => {
@@ -1017,11 +1018,15 @@ impl DepGraph {
     }
 
     pub(crate) fn finish_encoding(&self) -> FileEncodeResult {
-        if let Some(data) = &self.data { data.current.encoder.finish(&data.current) } else { Ok(0) }
+        if let Some(data) = &self.data() {
+            data.current.encoder.finish(&data.current)
+        } else {
+            Ok(0)
+        }
     }
 
     pub fn next_virtual_depnode_index(&self) -> DepNodeIndex {
-        debug_assert!(self.data.is_none());
+        debug_assert!(self.data().is_none() || is_sandbox());
         let index = self.virtual_dep_node_index.fetch_add(1, Ordering::Relaxed);
         DepNodeIndex::from_u32(index)
     }
@@ -1396,7 +1401,7 @@ pub(super) enum TrySetColorResult {
 #[inline(never)]
 #[cold]
 pub(crate) fn print_markframe_trace(graph: &DepGraph, frame: &MarkFrame<'_>) {
-    let data = graph.data.as_ref().unwrap();
+    let data = graph.data().unwrap();
 
     eprintln!("there was a panic while trying to force a dep node");
     eprintln!("try_mark_green dep node stack:");