After-rebase fixes

Author: aerooneqq

compiler/rustc_hir/src/definitions.rs

@@ -53,7 +53,7 @@ pub struct Definitions {
     // We do only store the local hash, as all the definitions are from the current crate.
     def_path_hashes: IndexVec<LocalDefId, Hash64>,
     def_path_hash_to_index: DefPathHashMap,
-    allow_overwrite: IndexSet<DefIndex>,
+    allow_overwrite: IndexSet<LocalDefId>,
 }
 
 /// A unique identifier that we can use to lookup a definition
@@ -304,27 +304,36 @@ impl Definitions {
         };
 
         // Create the root definition.
-        let root = defs.allocate(key, def_path_hash);
+        let root = defs.allocate(key, def_path_hash, false);
         assert_eq!(root.local_def_index, CRATE_DEF_INDEX);
 
         defs
     }
 
-    fn allocate(&mut self, key: DefKey, def_path_hash: DefPathHash) -> LocalDefId {
+    fn allocate(
+        &mut self,
+        key: DefKey,
+        def_path_hash: DefPathHash,
+        in_sandbox: bool,
+    ) -> LocalDefId {
         // 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.next_index();
+        let def_id = self.def_id_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) {
+        if let Some(existing) =
+            self.def_path_hash_to_index.insert(&local_hash, &def_id.local_def_index)
+        {
+            let existing = LocalDefId { local_def_index: existing };
+
             if !in_sandbox && self.allow_overwrite.swap_remove(&existing) {
-                self.def_path_hash_to_index.insert(&local_hash, &existing);
+                self.def_path_hash_to_index.insert(&local_hash, &existing.local_def_index);
                 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));
+                let def_path1 = self.def_path(existing);
+                let def_path2 = self.def_path(def_id);
 
                 // Continuing with colliding DefPathHashes can lead to correctness
                 // issues. We must abort compilation.
@@ -340,14 +349,14 @@ impl Definitions {
                 );
             }
         } else {
-            self.index_to_key.push(key);
-            debug!("DefPathTable::insert() - {key:?} <-> {index:?}");
+            self.def_id_to_key.push(key);
+            debug!("def_id_to_key.push() - {key:?} <-> {:?}", def_id.local_def_index);
 
             self.def_path_hashes.push(local_hash);
-            debug_assert!(self.def_path_hashes.len() == self.index_to_key.len());
+            debug_assert!(self.def_path_hashes.len() == self.def_id_to_key.len());
         }
 
-        index
+        def_id
     }
 
     pub fn enumerated_keys_and_path_hashes(
@@ -404,14 +413,12 @@ impl Definitions {
 
         debug!("create_def: after disambiguation, key = {:?}", key);
 
-        let local_def_index = self.table.allocate(key, def_path_hash, in_sandbox);
-
+        let def_id = self.allocate(key, def_path_hash, in_sandbox);
         if in_sandbox {
-            assert_eq!(self.table.allow_overwrite.insert(local_def_index), true);
+            assert_eq!(self.allow_overwrite.insert(def_id), true);
         }
 
-        // Create the definition.
-        LocalDefId { local_def_index }
+        def_id
     }
 
     #[inline(always)]

compiler/rustc_middle/src/dep_graph/graph.rs

@@ -222,7 +222,7 @@ impl DepGraph {
     }
 
     pub fn assert_eval_always(&self) {
-        if self.data.is_some() {
+        if self.data().is_some() {
             read_deps(|deps| {
                 assert_matches!(deps, TaskDepsRef::EvalAlways, "expected eval always context")
             });

compiler/rustc_middle/src/hir/mod.rs

@@ -520,7 +520,7 @@ impl<'tcx> ProjectedMaybeOwner<'tcx> {
             }),
             MaybeOwner::NonOwner(hir_id) => ProjectedMaybeOwner::NonOwner(hir_id),
             // Can't debug fmt `def_id` since it doesn't exist.
-            MaybeOwner::Phantom => bug!("No HirId for {:?}", def_id.local_def_index),
+            MaybeOwner::Phantom => bug!("No HirId for {:?}", def_id),
         }
     }
 

compiler/rustc_query_impl/src/lib.rs

@@ -67,7 +67,7 @@ fn enter_sandbox<'tcx, C: QueryCache>(query: &'tcx QueryVTable<'tcx, C>) {
 
 fn leave_sandbox<'tcx, C: QueryCache>(query: &'tcx QueryVTable<'tcx, C>) {
     if query.name == "lower_delayed_owner"
-        || query.name == "delayed_owner"
+        || query.name == "hir_delayed_owner"
         || query.name == "def_kind"
     {
         return;

tests/ui/delegation/query-cycle-oom.rs

@@ -48,7 +48,7 @@ mod test_3 {
 
     impl () { //~ ERROR: cannot define inherent `impl` for primitive types
         reuse Trait::*;
-        //~^ ERROR: no method named `foo` found for reference `&()` in the current scope
+        //~^ ERROR: the trait bound `(): test_3::Trait` is not satisfied
     }
 }
 

tests/ui/delegation/query-cycle-oom.stderr

@@ -90,20 +90,19 @@ LL -         reuse Trait::* { &self.0 }
 LL +         reuse Trait::&self.0 }
    |
 
-error[E0599]: no method named `foo` found for reference `&()` in the current scope
+error[E0277]: the trait bound `(): test_3::Trait` is not satisfied
   --> $DIR/query-cycle-oom.rs:50:22
    |
 LL |         reuse Trait::*;
-   |                      ^ method not found in `&()`
-   |
-   = help: items from traits can only be used if the trait is implemented and in scope
-   = note: the following traits define an item `foo`, perhaps you need to implement one of them:
-           candidate #1: `test_1::Trait`
-           candidate #2: `test_2::Trait`
-           candidate #3: `test_3::Trait`
-           candidate #4: `test_4::Trait`
+   |                      ^ the trait `test_3::Trait` is not implemented for `()`
+   |
+help: this trait has no implementations, consider adding one
+  --> $DIR/query-cycle-oom.rs:43:5
+   |
+LL |     trait Trait {
+   |     ^^^^^^^^^^^
 
 error: aborting due to 10 previous errors
 
-Some errors have detailed explanations: E0046, E0061, E0107, E0121, E0220, E0390, E0433, E0599.
+Some errors have detailed explanations: E0046, E0061, E0107, E0121, E0220, E0277, E0390, E0433.
 For more information about an error, try `rustc --explain E0046`.