Track the invoking DepNode in the implicit context.

Author: cjgillot

compiler/rustc_data_structures/src/fingerprint.rs

@@ -196,6 +196,10 @@ impl<D: Decoder> Decodable<D> for Fingerprint {
 #[derive(Eq, PartialEq, Ord, PartialOrd, Debug, Clone, Copy, Hash)]
 pub struct PackedFingerprint(Fingerprint);
 
+impl PackedFingerprint {
+    pub const ZERO: PackedFingerprint = PackedFingerprint(Fingerprint::ZERO);
+}
+
 impl std::fmt::Display for PackedFingerprint {
     #[inline]
     fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

compiler/rustc_middle/src/dep_graph/mod.rs

@@ -16,6 +16,7 @@ pub(crate) use dep_node::{make_compile_codegen_unit, make_compile_mono_item};
 
 pub type DepGraph = rustc_query_system::dep_graph::DepGraph<DepKind>;
 
+pub type CurrentDepNode = rustc_query_system::dep_graph::CurrentDepNode<DepKind>;
 pub type TaskDeps = rustc_query_system::dep_graph::TaskDeps<DepKind>;
 pub type TaskDepsRef<'a> = rustc_query_system::dep_graph::TaskDepsRef<'a, DepKind>;
 pub type DepGraphQuery = rustc_query_system::dep_graph::DepGraphQuery<DepKind>;
@@ -48,12 +49,12 @@ impl rustc_query_system::dep_graph::DepKind for DepKind {
         write!(f, ")")
     }
 
-    fn with_deps<OP, R>(task_deps: TaskDepsRef<'_>, op: OP) -> R
+    fn with_deps<OP, R>(current_node: CurrentDepNode, task_deps: TaskDepsRef<'_>, op: OP) -> R
     where
         OP: FnOnce() -> R,
     {
         ty::tls::with_context(|icx| {
-            let icx = ty::tls::ImplicitCtxt { task_deps, ..icx.clone() };
+            let icx = ty::tls::ImplicitCtxt { current_node, task_deps, ..icx.clone() };
 
             ty::tls::enter_context(&icx, op)
         })

compiler/rustc_middle/src/ty/context/tls.rs

@@ -1,6 +1,6 @@
 use super::{GlobalCtxt, TyCtxt};
 
-use crate::dep_graph::TaskDepsRef;
+use crate::dep_graph::{CurrentDepNode, DepNode, TaskDepsRef};
 use crate::query::plumbing::QueryJobId;
 use rustc_data_structures::sync::{self, Lock};
 use rustc_errors::Diagnostic;
@@ -31,6 +31,10 @@ pub struct ImplicitCtxt<'a, 'tcx> {
     /// Used to prevent queries from calling too deeply.
     pub query_depth: usize,
 
+    /// The DepNode of the query being executed. This is updated by the dep-graph. Thisis used to
+    /// know which query created an expansion.
+    pub current_node: CurrentDepNode,
+
     /// The current dep graph task. This is used to add dependencies to queries
     /// when executing them.
     pub task_deps: TaskDepsRef<'a>,
@@ -39,11 +43,17 @@ pub struct ImplicitCtxt<'a, 'tcx> {
 impl<'a, 'tcx> ImplicitCtxt<'a, 'tcx> {
     pub fn new(gcx: &'tcx GlobalCtxt<'tcx>) -> Self {
         let tcx = TyCtxt { gcx };
+        let current_node = if tcx.dep_graph.is_fully_enabled() {
+            CurrentDepNode::Untracked
+        } else {
+            CurrentDepNode::Regular(DepNode::NULL)
+        };
         ImplicitCtxt {
             tcx,
             query: None,
             diagnostics: None,
             query_depth: 0,
+            current_node,
             task_deps: TaskDepsRef::Ignore,
         }
     }

compiler/rustc_query_impl/src/plumbing.rs

@@ -142,6 +142,7 @@ impl QueryContext for QueryCtxt<'_> {
                 query: Some(token),
                 diagnostics,
                 query_depth: current_icx.query_depth + depth_limit as usize,
+                current_node: current_icx.current_node,
                 task_deps: current_icx.task_deps,
             };
 

compiler/rustc_query_system/src/dep_graph/dep_node.rs

@@ -58,6 +58,8 @@ pub struct DepNode<K> {
 }
 
 impl<K: DepKind> DepNode<K> {
+    pub const NULL: DepNode<K> = DepNode { kind: K::NULL, hash: PackedFingerprint::ZERO };
+
     /// Creates a new, parameterless DepNode. This method will assert
     /// that the DepNode corresponding to the given DepKind actually
     /// does not require any parameters.

compiler/rustc_query_system/src/dep_graph/graph.rs

@@ -18,7 +18,7 @@ use std::sync::atomic::Ordering::Relaxed;
 
 use super::query::DepGraphQuery;
 use super::serialized::{GraphEncoder, SerializedDepGraph, SerializedDepNodeIndex};
-use super::{DepContext, DepKind, DepNode, HasDepContext, WorkProductId};
+use super::{CurrentDepNode, DepContext, DepKind, DepNode, HasDepContext, WorkProductId};
 use crate::ich::StableHashingContext;
 use crate::query::{QueryContext, QuerySideEffects};
 
@@ -218,7 +218,7 @@ impl<K: DepKind> DepGraph<K> {
     where
         OP: FnOnce() -> R,
     {
-        K::with_deps(TaskDepsRef::Ignore, op)
+        K::with_deps(CurrentDepNode::Untracked, TaskDepsRef::Ignore, op)
     }
 
     /// Used to wrap the deserialization of a query result from disk,
@@ -271,7 +271,7 @@ impl<K: DepKind> DepGraph<K> {
     where
         OP: FnOnce() -> R,
     {
-        K::with_deps(TaskDepsRef::Forbid, op)
+        K::with_deps(CurrentDepNode::Untracked, TaskDepsRef::Forbid, op)
     }
 
     #[inline(always)]
@@ -354,7 +354,8 @@ impl<K: DepKind> DepGraphData<K> {
                  - dep-node: {key:?}"
         );
 
-        let with_deps = |task_deps| K::with_deps(task_deps, || task(cx, arg));
+        let with_deps =
+            |task_deps| K::with_deps(CurrentDepNode::Regular(key), task_deps, || task(cx, arg));
         let (result, edges) = if cx.dep_context().is_eval_always(key.kind) {
             (with_deps(TaskDepsRef::EvalAlways), smallvec![])
         } else {
@@ -414,7 +415,7 @@ impl<K: DepKind> DepGraphData<K> {
         debug_assert!(!cx.is_eval_always(dep_kind));
 
         let task_deps = Lock::new(TaskDeps::default());
-        let result = K::with_deps(TaskDepsRef::Allow(&task_deps), op);
+        let result = K::with_deps(CurrentDepNode::Anonymous, TaskDepsRef::Allow(&task_deps), op);
         let task_deps = task_deps.into_inner();
         let task_deps = task_deps.reads;
 

compiler/rustc_query_system/src/dep_graph/mod.rs

@@ -137,6 +137,13 @@ impl FingerprintStyle {
     }
 }
 
+#[derive(Copy, Clone, Hash)]
+pub enum CurrentDepNode<K> {
+    Regular(DepNode<K>),
+    Anonymous,
+    Untracked,
+}
+
 /// Describe the different families of dependency nodes.
 pub trait DepKind: Copy + fmt::Debug + Eq + Hash + Send + Encodable<FileEncoder> + 'static {
     /// DepKind to use when incr. comp. is turned off.
@@ -149,7 +156,7 @@ pub trait DepKind: Copy + fmt::Debug + Eq + Hash + Send + Encodable<FileEncoder>
     fn debug_node(node: &DepNode<Self>, f: &mut fmt::Formatter<'_>) -> fmt::Result;
 
     /// Execute the operation with provided dependencies.
-    fn with_deps<OP, R>(deps: TaskDepsRef<'_, Self>, op: OP) -> R
+    fn with_deps<OP, R>(node: CurrentDepNode<Self>, deps: TaskDepsRef<'_, Self>, op: OP) -> R
     where
         OP: FnOnce() -> R;
 

compiler/rustc_query_system/src/query/plumbing.rs

@@ -2,8 +2,8 @@
 //! generate the actual methods on tcx which find and execute the provider,
 //! manage the caches, and so forth.
 
+use crate::dep_graph::{CurrentDepNode, DepGraphData, HasDepContext, TaskDepsRef};
 use crate::dep_graph::{DepContext, DepKind, DepNode, DepNodeIndex, DepNodeParams};
-use crate::dep_graph::{DepGraphData, HasDepContext};
 use crate::ich::StableHashingContext;
 use crate::query::caches::QueryCache;
 #[cfg(parallel_compiler)]
@@ -629,8 +629,12 @@ where
     // recompute.
     let prof_timer = qcx.dep_context().profiler().query_provider();
 
-    // The dep-graph for this computation is already in-place.
-    let result = qcx.dep_context().dep_graph().with_ignore(|| query.compute(qcx, *key));
+    // The dep-graph for this computation is already in-place, but any side effect due to this
+    // query needs to know our DepNode.
+    let result =
+        Qcx::DepKind::with_deps(CurrentDepNode::Regular(*dep_node), TaskDepsRef::Ignore, || {
+            query.compute(qcx, *key)
+        });
 
     prof_timer.finish_with_query_invocation_id(dep_node_index.into());