Drop the create_def_raw query.

Author: cjgillot

compiler/rustc_hir/src/definitions.rs

@@ -11,7 +11,7 @@ use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::stable_hasher::StableHasher;
 use rustc_hashes::Hash64;
 use rustc_index::IndexVec;
-use rustc_macros::{BlobDecodable, Decodable, Encodable, HashStable, extension};
+use rustc_macros::{BlobDecodable, Decodable, Encodable, extension};
 use rustc_span::def_id::LocalDefIdMap;
 use rustc_span::{Symbol, kw, sym};
 use tracing::{debug, instrument};
@@ -178,7 +178,7 @@ impl DefKey {
 /// between them. This introduces some artificial ordering dependency
 /// but means that if you have, e.g., two impls for the same type in
 /// the same module, they do get distinct `DefId`s.
-#[derive(Copy, Clone, PartialEq, Eq, Debug, Hash, Encodable, BlobDecodable, HashStable)]
+#[derive(Copy, Clone, PartialEq, Eq, Debug, Hash, Encodable, BlobDecodable)]
 pub struct DisambiguatedDefPathData {
     pub data: DefPathData,
     pub disambiguator: u32,
@@ -299,7 +299,7 @@ impl DefPath {
 }
 
 /// New variants should only be added in synchronization with `enum DefKind`.
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, Encodable, BlobDecodable, HashStable)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, Encodable, BlobDecodable)]
 pub enum DefPathData {
     // Root: these should only be used for the root nodes, because
     // they are treated specially by the `def_path` function.

compiler/rustc_middle/src/dep_graph/graph.rs

@@ -739,7 +739,7 @@ impl DepGraphData {
                     tcx.sess.used_features.lock().insert(*symbol, dep_node_index.as_u32());
                 }
                 QuerySideEffect::CreateDef { parent, data } => {
-                    tcx.ensure_done().create_def_raw((*parent, *data));
+                    tcx.untracked().definitions.write().create_def(*parent, *data);
                 }
             }
 

compiler/rustc_middle/src/queries.rs

@@ -67,7 +67,6 @@ use rustc_hir::def::{DefKind, DocLinkResMap};
 use rustc_hir::def_id::{
     CrateNum, DefId, DefIdMap, LocalDefId, LocalDefIdMap, LocalDefIdSet, LocalModDefId,
 };
-use rustc_hir::definitions::DisambiguatedDefPathData;
 use rustc_hir::lang_items::{LangItem, LanguageItems};
 use rustc_hir::{ItemLocalId, ItemLocalMap, PreciseCapturingArgKind, TraitCandidate};
 use rustc_index::IndexVec;
@@ -199,17 +198,6 @@ rustc_queries! {
         desc { "getting the source span" }
     }
 
-    /// Create a new definition.
-    ///
-    /// This query is meant to wrap a side-effect and return the resulting newly created
-    /// definition. In incremental mode, when replaying a query, this query caches the side-effect
-    /// to avoid performing it twice.
-    query create_def_raw(key: (LocalDefId, DisambiguatedDefPathData)) -> LocalDefId {
-        // Accesses untracked data
-        eval_always
-        desc { "create a new definition for `{}::{:?}`", tcx.def_path_str(key.0), key.1 }
-    }
-
     /// Represents crate as a whole (as distinct from the top-level crate module).
     ///
     /// If you call `tcx.hir_crate(())` we will have to assume that any change

compiler/rustc_middle/src/query/keys.rs

@@ -7,7 +7,6 @@ use std::hash::Hash;
 use rustc_ast::tokenstream::TokenStream;
 use rustc_data_structures::stable_hasher::StableHash;
 use rustc_hir::def_id::{CrateNum, DefId, LOCAL_CRATE, LocalDefId, LocalModDefId};
-use rustc_hir::definitions::DisambiguatedDefPathData;
 use rustc_hir::hir_id::OwnerId;
 use rustc_span::{DUMMY_SP, Ident, LocalExpnId, Span, Symbol};
 
@@ -361,11 +360,3 @@ impl<'tcx> QueryKey for (ty::Instance<'tcx>, CollectionMode) {
         self.0.default_span(tcx)
     }
 }
-
-impl QueryKey for (LocalDefId, DisambiguatedDefPathData) {
-    type Cache<V> = DefaultCache<Self, V>;
-
-    fn default_span(&self, _: TyCtxt<'_>) -> Span {
-        DUMMY_SP
-    }
-}

compiler/rustc_middle/src/ty/context.rs

@@ -32,9 +32,7 @@ use rustc_data_structures::sync::{
 use rustc_errors::{Applicability, Diag, DiagCtxtHandle, Diagnostic, MultiSpan};
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::{CrateNum, DefId, LOCAL_CRATE, LocalDefId, StableCrateIdMap};
-use rustc_hir::definitions::{
-    DefPathData, Definitions, DisambiguatedDefPathData, PerParentDisambiguatorState,
-};
+use rustc_hir::definitions::{DefPathData, Definitions, PerParentDisambiguatorState};
 use rustc_hir::intravisit::VisitorExt;
 use rustc_hir::lang_items::LangItem;
 use rustc_hir::limit::Limit;
@@ -1283,23 +1281,6 @@ impl<'tcx> TyCtxt<'tcx> {
     }
 }
 
-#[instrument(level = "trace", skip(tcx), ret)]
-fn create_def_raw_provider<'tcx>(
-    tcx: TyCtxt<'tcx>,
-    (parent, data): (LocalDefId, DisambiguatedDefPathData),
-) -> LocalDefId {
-    // The following call has the side effect of modifying the tables inside `definitions`.
-    // These very tables are relied on by the incr. comp. engine to decode DepNodes and to
-    // decode the on-disk cache.
-    //
-    // Any LocalDefId which is used within queries, either as key or result, either:
-    // - has been created before the construction of the TyCtxt;
-    // - has been created by this call to `create_def`.
-    // As a consequence, this LocalDefId is always re-created before it is needed by the incr.
-    // comp. engine itself.
-    tcx.untracked.definitions.write().create_def(parent, data)
-}
-
 impl<'tcx> TyCtxtAt<'tcx> {
     /// Create a new definition within the incr. comp. engine.
     pub fn create_def(
@@ -1334,22 +1315,28 @@ impl<'tcx> TyCtxt<'tcx> {
         let data = disambiguator.disambiguate(parent, data);
 
         let def_id = ty::tls::with_context(|icx| match icx.task_deps {
-            // `create_def_raw` is a query, so it can be replayed by the dep-graph engine.
-            // However, we may invoke it multiple times with the same `(parent, data)` pair,
-            // and we expect to create *different* definitions from them.
-            //
-            // In order to make this compatible with the general model of queries, we add
-            // additional information which must change at each call.
+            // If we are not tracking dependencies, we can use global mutable state.
+            // This is only an optimization to avoid the cost of registering the dep-node.
+            TaskDepsRef::EvalAlways | TaskDepsRef::Forbid | TaskDepsRef::Ignore => {
+                self.untracked.definitions.write().create_def(parent, data)
+            }
+
+            // We are tracking dependencies, so we need to record a side-effect for the dep-graph
+            // to pick up in next execution.
             TaskDepsRef::Allow(..) => {
                 self.dep_graph
                     .encode_side_effect(self, QuerySideEffect::CreateDef { parent, data });
-                self.create_def_raw((parent, data))
+                self.untracked.definitions.write().create_def(parent, data)
             }
 
-            // If we are not tracking dependencies, we can use global mutable state.
-            // This is only an optimization to avoid the cost of registering the dep-node.
-            TaskDepsRef::EvalAlways | TaskDepsRef::Forbid | TaskDepsRef::Ignore => {
-                self.untracked.definitions.write().create_def(parent, data)
+            // We are in replay mode: the def-id has already been created by
+            // `dep_graph.force_side_effect`. We need to recover it, without creating a new one.
+            TaskDepsRef::Replay => {
+                let parent_hash = self.def_path_hash(parent.to_def_id());
+                let def_path_hash = data.compute_stable_hash(parent_hash);
+                self.def_path_hash_to_def_id(def_path_hash)
+                    .expect("first execution should have created this definition")
+                    .expect_local()
             }
         });
 
@@ -2788,5 +2775,4 @@ pub fn provide(providers: &mut Providers) {
         tcx.lang_items().panic_impl().is_some_and(|did| did.is_local())
     };
     providers.source_span = |tcx, def_id| tcx.untracked.source_span.get(def_id).unwrap_or(DUMMY_SP);
-    providers.create_def_raw = create_def_raw_provider;
 }