Store a reference instead of a Lrc.

Author: cjgillot

compiler/rustc_middle/src/dep_graph/mod.rs

@@ -54,7 +54,8 @@ impl rustc_query_system::dep_graph::DepKind for DepKind {
         OP: FnOnce() -> R,
     {
         ty::tls::with_context(|icx| {
-            let icx = ty::tls::ImplicitCtxt { current_node, task_deps, ..icx.clone() };
+            let icx =
+                ty::tls::ImplicitCtxt { current_node: &current_node, task_deps, ..icx.clone() };
 
             ty::tls::enter_context(&icx, op)
         })

compiler/rustc_middle/src/ty/context.rs

@@ -5,7 +5,7 @@
 pub mod tls;
 
 use crate::arena::Arena;
-use crate::dep_graph::{CurrentDepNode, DepGraph, DepKindStruct};
+use crate::dep_graph::{CurrentDepNode, DepGraph, DepKindStruct, DepNode};
 use crate::infer::canonical::CanonicalVarInfo;
 use crate::lint::struct_lint_level;
 use crate::metadata::ModChild;
@@ -548,7 +548,12 @@ impl<'tcx> GlobalCtxt<'tcx> {
     where
         F: FnOnce(TyCtxt<'tcx>) -> R,
     {
-        let icx = tls::ImplicitCtxt::new(self);
+        let current_node = if self.dep_graph.is_fully_enabled() {
+            CurrentDepNode::Untracked
+        } else {
+            CurrentDepNode::regular(DepNode::NULL)
+        };
+        let icx = tls::ImplicitCtxt::new(self, &current_node);
         tls::enter_context(&icx, || f(icx.tcx))
     }
 }
@@ -905,25 +910,32 @@ impl<'tcx> TyCtxt<'tcx> {
 impl<'tcx> TyCtxt<'tcx> {
     #[instrument(level = "trace", skip(self), ret)]
     pub fn create_expansion(self, expn_data: ExpnData) -> LocalExpnId {
-        let current_node = tls::with_related_context(self, |icx| icx.current_node.clone());
-        let CurrentDepNode::Regular { dep_node, expn_disambiguators } = current_node else {
-            bug!("creating an expansion outside of a query")
-        };
-        self.with_stable_hashing_context(|ctx| {
-            LocalExpnId::create_untracked_expansion(expn_data, dep_node, ctx, &expn_disambiguators)
+        tls::with_related_context(self, |icx| {
+            let CurrentDepNode::Regular { dep_node, expn_disambiguators } = icx.current_node else {
+                bug!("creating an expansion outside of a query")
+            };
+            self.with_stable_hashing_context(|ctx| {
+                LocalExpnId::create_untracked_expansion(
+                    expn_data,
+                    dep_node,
+                    ctx,
+                    &expn_disambiguators,
+                )
+            })
         })
     }
 
     /// Fill an empty expansion. This method must not be used outside of the resolver.
     #[inline]
     #[instrument(level = "trace", skip(self))]
     pub fn finalize_expansion(self, expn_id: LocalExpnId, expn_data: ExpnData) {
-        let current_node = tls::with_related_context(self, |icx| icx.current_node.clone());
-        let CurrentDepNode::Regular { dep_node, expn_disambiguators } = current_node else {
-            bug!("creating an expansion outside of a query")
-        };
-        self.with_stable_hashing_context(|ctx| {
-            expn_id.set_untracked_expn_data(expn_data, dep_node, ctx, &expn_disambiguators)
+        tls::with_related_context(self, |icx| {
+            let CurrentDepNode::Regular { dep_node, expn_disambiguators } = icx.current_node else {
+                bug!("creating an expansion outside of a query")
+            };
+            self.with_stable_hashing_context(|ctx| {
+                expn_id.set_untracked_expn_data(expn_data, dep_node, ctx, &expn_disambiguators)
+            })
         });
     }
 

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

@@ -1,6 +1,6 @@
 use super::{GlobalCtxt, TyCtxt};
 
-use crate::dep_graph::{CurrentDepNode, DepNode, TaskDepsRef};
+use crate::dep_graph::{CurrentDepNode, TaskDepsRef};
 use crate::query::plumbing::QueryJobId;
 use rustc_data_structures::sync::{self, Lock};
 use rustc_errors::Diagnostic;
@@ -33,21 +33,16 @@ pub struct ImplicitCtxt<'a, 'tcx> {
 
     /// The DepNode of the query being executed. This is updated by the dep-graph. This is used to
     /// know which query created an expansion.
-    pub current_node: CurrentDepNode,
+    pub current_node: &'a CurrentDepNode,
 
     /// The current dep graph task. This is used to add dependencies to queries
     /// when executing them.
     pub task_deps: TaskDepsRef<'a>,
 }
 
 impl<'a, 'tcx> ImplicitCtxt<'a, 'tcx> {
-    pub fn new(gcx: &'tcx GlobalCtxt<'tcx>) -> Self {
+    pub fn new(gcx: &'tcx GlobalCtxt<'tcx>, current_node: &'a CurrentDepNode) -> 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,

compiler/rustc_query_impl/src/plumbing.rs

@@ -142,7 +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.clone(),
+                current_node: current_icx.current_node,
                 task_deps: current_icx.task_deps,
             };
 

compiler/rustc_query_system/src/dep_graph/mod.rs

@@ -15,7 +15,7 @@ pub use serialized::{SerializedDepGraph, SerializedDepNodeIndex};
 use crate::ich::StableHashingContext;
 use rustc_data_structures::profiling::SelfProfilerRef;
 use rustc_data_structures::stable_hasher::Hash64;
-use rustc_data_structures::sync::{Lock, Lrc};
+use rustc_data_structures::sync::Lock;
 use rustc_data_structures::unhash::UnhashMap;
 use rustc_serialize::{opaque::FileEncoder, Encodable};
 use rustc_session::Session;
@@ -140,24 +140,20 @@ impl FingerprintStyle {
     }
 }
 
-#[derive(Clone)]
 pub enum CurrentDepNode<K> {
     Regular {
         dep_node: DepNode<K>,
         /// Disambiguation map for expansions created while executing
         /// the query with this `DepNode`.
-        expn_disambiguators: Lrc<Lock<UnhashMap<Hash64, u32>>>,
+        expn_disambiguators: Lock<UnhashMap<Hash64, u32>>,
     },
     Anonymous,
     Untracked,
 }
 
 impl<K> CurrentDepNode<K> {
     pub fn regular(dep_node: DepNode<K>) -> CurrentDepNode<K> {
-        CurrentDepNode::Regular {
-            dep_node,
-            expn_disambiguators: Lrc::new(Lock::new(UnhashMap::default())),
-        }
+        CurrentDepNode::Regular { dep_node, expn_disambiguators: Lock::new(UnhashMap::default()) }
     }
 }