Move query TLS to rustc_query_system.

Author: cjgillot

Cargo.lock

@@ -4019,6 +4019,7 @@ dependencies = [
  "rustc_plugin_impl",
  "rustc_privacy",
  "rustc_query_impl",
+ "rustc_query_system",
  "rustc_resolve",
  "rustc_serialize",
  "rustc_session",

compiler/rustc_interface/Cargo.toml

@@ -42,6 +42,7 @@ rustc_lint = { path = "../rustc_lint" }
 rustc_errors = { path = "../rustc_errors" }
 rustc_plugin_impl = { path = "../rustc_plugin_impl" }
 rustc_privacy = { path = "../rustc_privacy" }
+rustc_query_system = { path = "../rustc_query_system" }
 rustc_query_impl = { path = "../rustc_query_impl" }
 rustc_resolve = { path = "../rustc_resolve" }
 rustc_trait_selection = { path = "../rustc_trait_selection" }

compiler/rustc_interface/src/callbacks.rs

@@ -9,7 +9,6 @@
 //! The functions in this file should fall back to the default set in their
 //! origin crate when the `TyCtxt` is not present in TLS.
 
-use rustc_errors::{Diagnostic, TRACK_DIAGNOSTICS};
 use rustc_middle::ty::tls;
 use std::fmt;
 
@@ -35,20 +34,6 @@ fn track_span_parent(def_id: rustc_span::def_id::LocalDefId) {
     })
 }
 
-/// This is a callback from `rustc_ast` as it cannot access the implicit state
-/// in `rustc_middle` otherwise. It is used to when diagnostic messages are
-/// emitted and stores them in the current query, if there is one.
-fn track_diagnostic(diagnostic: &Diagnostic) {
-    tls::with_context_opt(|icx| {
-        if let Some(icx) = icx {
-            if let Some(diagnostics) = icx.diagnostics {
-                let mut diagnostics = diagnostics.lock();
-                diagnostics.extend(Some(diagnostic.clone()));
-            }
-        }
-    })
-}
-
 /// This is a callback from `rustc_hir` as it cannot access the implicit state
 /// in `rustc_middle` otherwise.
 fn def_id_debug(def_id: rustc_hir::def_id::DefId, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -68,5 +53,5 @@ pub fn setup_callbacks() {
     rustc_span::SPAN_DEBUG.swap(&(span_debug as fn(_, &mut fmt::Formatter<'_>) -> _));
     rustc_span::SPAN_TRACK.swap(&(track_span_parent as fn(_)));
     rustc_hir::def_id::DEF_ID_DEBUG.swap(&(def_id_debug as fn(_, &mut fmt::Formatter<'_>) -> _));
-    TRACK_DIAGNOSTICS.swap(&(track_diagnostic as fn(&_)));
+    rustc_errors::TRACK_DIAGNOSTICS.swap(&(rustc_query_system::tls::track_diagnostic as fn(&_)));
 }

compiler/rustc_interface/src/interface.rs

@@ -231,7 +231,7 @@ pub fn try_print_query_stack(handler: &Handler, num_frames: Option<usize>) {
     // state if it was responsible for triggering the panic.
     let i = ty::tls::with_context_opt(|icx| {
         if let Some(icx) = icx {
-            QueryCtxt::from_tcx(icx.tcx).try_print_query_stack(icx.query, handler, num_frames)
+            QueryCtxt::from_tcx(icx.tcx).try_print_query_stack(handler, num_frames)
         } else {
             0
         }

compiler/rustc_interface/src/passes.rs

@@ -781,7 +781,10 @@ impl<'tcx> QueryContext<'tcx> {
         F: FnOnce(TyCtxt<'tcx>) -> R,
     {
         let icx = ty::tls::ImplicitCtxt::new(self.gcx);
-        ty::tls::enter_context(&icx, |_| f(icx.tcx))
+        let qcx = rustc_query_system::tls::ImplicitCtxt::<rustc_middle::dep_graph::DepKind>::new();
+        ty::tls::enter_context(&icx, |_| {
+            rustc_query_system::tls::enter_context(&qcx, |_| f(icx.tcx))
+        })
     }
 }
 

compiler/rustc_interface/src/util.rs

@@ -154,19 +154,24 @@ pub fn setup_callbacks_and_run_in_thread_pool_with_globals<F: FnOnce() -> R + Se
 /// Must only be called when a deadlock is about to happen.
 #[cfg(parallel_compiler)]
 unsafe fn handle_deadlock() {
+    use rustc_query_system::tls as qls;
     let registry = rustc_rayon_core::Registry::current();
 
     let context = tls::get_tlv();
     assert!(context != 0);
-    rustc_data_structures::sync::assert_sync::<tls::ImplicitCtxt<'_, '_>>();
-    let icx: &tls::ImplicitCtxt<'_, '_> = &*(context as *const tls::ImplicitCtxt<'_, '_>);
+    rustc_data_structures::sync::assert_sync::<tls::ImplicitCtxt<'_>>();
+    let icx: &tls::ImplicitCtxt<'_> = &*(context as *const tls::ImplicitCtxt<'_>);
+    rustc_data_structures::sync::assert_sync::<qls::ImplicitCtxt<'_>>();
+    let qcx: &qls::ImplicitCtxt<'_> = &*(context as *const qls::ImplicitCtxt<'_>);
 
     let session_globals = rustc_span::with_session_globals(|sg| sg as *const _);
     let session_globals = &*session_globals;
     thread::spawn(move || {
         tls::enter_context(icx, |_| {
-            rustc_span::set_session_globals_then(session_globals, || {
-                tls::with(|tcx| QueryCtxt::from_tcx(tcx).deadlock(&registry))
+            qls::enter_context(icx, |_| {
+                rustc_span::set_session_globals_then(session_globals, || {
+                    tls::with(|tcx| QueryCtxt::from_tcx(tcx).deadlock(&registry))
+                })
             })
         });
     });

compiler/rustc_middle/src/dep_graph/dep_node.rs

@@ -216,6 +216,8 @@ static_assert_size!(DepNode, 18);
 #[cfg(not(any(target_arch = "x86", target_arch = "x86_64")))]
 static_assert_size!(DepNode, 24);
 
+static_assert_size!(DepKind, 2);
+
 pub trait DepNodeExt: Sized {
     /// Construct a DepNode from the given DepKind and DefPathHash. This
     /// method will assert that the given DepKind actually requires a

compiler/rustc_middle/src/dep_graph/mod.rs

@@ -1,6 +1,5 @@
 use crate::ty::{self, TyCtxt};
 use rustc_data_structures::profiling::SelfProfilerRef;
-use rustc_data_structures::sync::Lock;
 use rustc_query_system::ich::StableHashingContext;
 use rustc_session::Session;
 
@@ -44,27 +43,6 @@ impl rustc_query_system::dep_graph::DepKind for DepKind {
 
         write!(f, ")")
     }
-
-    fn with_deps<OP, R>(task_deps: Option<&Lock<TaskDeps>>, op: OP) -> R
-    where
-        OP: FnOnce() -> R,
-    {
-        ty::tls::with_context(|icx| {
-            let icx = ty::tls::ImplicitCtxt { task_deps, ..icx.clone() };
-
-            ty::tls::enter_context(&icx, |_| op())
-        })
-    }
-
-    fn read_deps<OP>(op: OP)
-    where
-        OP: for<'a> FnOnce(Option<&'a Lock<TaskDeps>>),
-    {
-        ty::tls::with_context_opt(|icx| {
-            let icx = if let Some(icx) = icx { icx } else { return };
-            op(icx.task_deps)
-        })
-    }
 }
 
 impl<'tcx> DepContext for TyCtxt<'tcx> {

compiler/rustc_middle/src/ty/context.rs

@@ -1685,12 +1685,7 @@ CloneLiftImpls! { for<'tcx> { Constness, traits::WellFormedLoc, } }
 
 pub mod tls {
     use super::{GlobalCtxt, TyCtxt};
-
-    use crate::dep_graph::{DepKind, TaskDeps};
-    use crate::ty::query;
-    use rustc_data_structures::sync::{self, Lock};
-    use rustc_data_structures::thin_vec::ThinVec;
-    use rustc_errors::Diagnostic;
+    use rustc_data_structures::sync;
 
     #[cfg(not(parallel_compiler))]
     use std::cell::Cell;
@@ -1704,30 +1699,18 @@ pub mod tls {
     /// you should also have access to an `ImplicitCtxt` through the functions
     /// in this module.
     #[derive(Clone)]
-    pub struct ImplicitCtxt<'a, 'tcx> {
+    pub struct ImplicitCtxt<'tcx> {
         /// The current `TyCtxt`.
         pub tcx: TyCtxt<'tcx>,
 
-        /// The current query job, if any. This is updated by `JobOwner::start` in
-        /// `ty::query::plumbing` when executing a query.
-        pub query: Option<query::QueryJobId<DepKind>>,
-
-        /// Where to store diagnostics for the current query job, if any.
-        /// This is updated by `JobOwner::start` in `ty::query::plumbing` when executing a query.
-        pub diagnostics: Option<&'a Lock<ThinVec<Diagnostic>>>,
-
         /// Used to prevent layout from recursing too deeply.
         pub layout_depth: usize,
-
-        /// The current dep graph task. This is used to add dependencies to queries
-        /// when executing them.
-        pub task_deps: Option<&'a Lock<TaskDeps>>,
     }
 
-    impl<'a, 'tcx> ImplicitCtxt<'a, 'tcx> {
+    impl<'tcx> ImplicitCtxt<'tcx> {
         pub fn new(gcx: &'tcx GlobalCtxt<'tcx>) -> Self {
             let tcx = TyCtxt { gcx };
-            ImplicitCtxt { tcx, query: None, diagnostics: None, layout_depth: 0, task_deps: None }
+            ImplicitCtxt { tcx, layout_depth: 0 }
         }
     }
 
@@ -1775,9 +1758,9 @@ pub mod tls {
 
     /// Sets `context` as the new current `ImplicitCtxt` for the duration of the function `f`.
     #[inline]
-    pub fn enter_context<'a, 'tcx, F, R>(context: &ImplicitCtxt<'a, 'tcx>, f: F) -> R
+    pub fn enter_context<'tcx, F, R>(context: &ImplicitCtxt<'tcx>, f: F) -> R
     where
-        F: FnOnce(&ImplicitCtxt<'a, 'tcx>) -> R,
+        F: FnOnce(&ImplicitCtxt<'tcx>) -> R,
     {
         set_tlv(context as *const _ as usize, || f(&context))
     }
@@ -1786,17 +1769,17 @@ pub mod tls {
     #[inline]
     pub fn with_context_opt<F, R>(f: F) -> R
     where
-        F: for<'a, 'tcx> FnOnce(Option<&ImplicitCtxt<'a, 'tcx>>) -> R,
+        F: for<'tcx> FnOnce(Option<&ImplicitCtxt<'tcx>>) -> R,
     {
         let context = get_tlv();
         if context == 0 {
             f(None)
         } else {
             // We could get an `ImplicitCtxt` pointer from another thread.
             // Ensure that `ImplicitCtxt` is `Sync`.
-            sync::assert_sync::<ImplicitCtxt<'_, '_>>();
+            sync::assert_sync::<ImplicitCtxt<'_>>();
 
-            unsafe { f(Some(&*(context as *const ImplicitCtxt<'_, '_>))) }
+            unsafe { f(Some(&*(context as *const ImplicitCtxt<'_>))) }
         }
     }
 
@@ -1805,7 +1788,7 @@ pub mod tls {
     #[inline]
     pub fn with_context<F, R>(f: F) -> R
     where
-        F: for<'a, 'tcx> FnOnce(&ImplicitCtxt<'a, 'tcx>) -> R,
+        F: for<'tcx> FnOnce(&ImplicitCtxt<'tcx>) -> R,
     {
         with_context_opt(|opt_context| f(opt_context.expect("no ImplicitCtxt stored in tls")))
     }

compiler/rustc_middle/src/ty/query.rs

@@ -60,7 +60,6 @@ use std::ops::Deref;
 use std::path::PathBuf;
 use std::sync::Arc;
 
-pub(crate) use rustc_query_system::query::QueryJobId;
 use rustc_query_system::query::*;
 
 #[derive(Copy, Clone)]

compiler/rustc_query_impl/src/plumbing.rs

@@ -3,17 +3,11 @@
 //! manage the caches, and so forth.
 
 use crate::{on_disk_cache, queries, Queries};
-use rustc_middle::dep_graph::{DepKind, DepNodeIndex, SerializedDepNodeIndex};
-use rustc_middle::ty::tls::{self, ImplicitCtxt};
+use rustc_errors::Handler;
+use rustc_middle::dep_graph::{DepNodeIndex, SerializedDepNodeIndex};
 use rustc_middle::ty::{self, TyCtxt};
 use rustc_query_system::dep_graph::HasDepContext;
-use rustc_query_system::query::{
-    QueryContext, QueryDescription, QueryJobId, QueryMap, QuerySideEffects,
-};
-
-use rustc_data_structures::sync::Lock;
-use rustc_data_structures::thin_vec::ThinVec;
-use rustc_errors::{Diagnostic, Handler};
+use rustc_query_system::query::{QueryContext, QueryDescription, QueryMap, QuerySideEffects};
 use rustc_serialize::opaque;
 use rustc_span::def_id::LocalDefId;
 
@@ -45,10 +39,6 @@ impl HasDepContext for QueryCtxt<'tcx> {
 }
 
 impl QueryContext for QueryCtxt<'tcx> {
-    fn current_query_job(&self) -> Option<QueryJobId<Self::DepKind>> {
-        tls::with_context(|icx| icx.query)
-    }
-
     fn try_collect_active_jobs(&self) -> Option<QueryMap<Self::DepKind>> {
         self.queries.try_collect_active_jobs(**self)
     }
@@ -77,36 +67,6 @@ impl QueryContext for QueryCtxt<'tcx> {
             c.store_side_effects_for_anon_node(dep_node_index, side_effects)
         }
     }
-
-    /// Executes a job by changing the `ImplicitCtxt` to point to the
-    /// new query job while it executes. It returns the diagnostics
-    /// captured during execution and the actual result.
-    #[inline(always)]
-    fn start_query<R>(
-        &self,
-        token: QueryJobId<Self::DepKind>,
-        diagnostics: Option<&Lock<ThinVec<Diagnostic>>>,
-        compute: impl FnOnce() -> R,
-    ) -> R {
-        // The `TyCtxt` stored in TLS has the same global interner lifetime
-        // as `self`, so we use `with_context` to relate the 'tcx lifetimes
-        // when accessing the `ImplicitCtxt`.
-        tls::with_context(move |current_icx| {
-            // Update the `ImplicitCtxt` to point to our new query job.
-            let new_icx = ImplicitCtxt {
-                tcx: **self,
-                query: Some(token),
-                diagnostics,
-                layout_depth: current_icx.layout_depth,
-                task_deps: current_icx.task_deps,
-            };
-
-            // Use the `ImplicitCtxt` while we execute the query.
-            tls::enter_context(&new_icx, |_| {
-                rustc_data_structures::stack::ensure_sufficient_stack(compute)
-            })
-        })
-    }
 }
 
 impl<'tcx> QueryCtxt<'tcx> {
@@ -153,13 +113,8 @@ impl<'tcx> QueryCtxt<'tcx> {
         Ok(())
     }
 
-    pub fn try_print_query_stack(
-        self,
-        query: Option<QueryJobId<DepKind>>,
-        handler: &Handler,
-        num_frames: Option<usize>,
-    ) -> usize {
-        rustc_query_system::query::print_query_stack(self, query, handler, num_frames)
+    pub fn try_print_query_stack(self, handler: &Handler, num_frames: Option<usize>) -> usize {
+        rustc_query_system::query::print_query_stack(self, handler, num_frames)
     }
 }
 

compiler/rustc_query_system/src/dep_graph/graph.rs

@@ -158,7 +158,7 @@ impl<K: DepKind> DepGraph<K> {
 
     pub fn assert_ignored(&self) {
         if let Some(..) = self.data {
-            K::read_deps(|task_deps| {
+            crate::tls::read_deps::<K, _>(|task_deps| {
                 assert!(task_deps.is_none(), "expected no task dependency tracking");
             })
         }
@@ -168,7 +168,7 @@ impl<K: DepKind> DepGraph<K> {
     where
         OP: FnOnce() -> R,
     {
-        K::with_deps(None, op)
+        crate::tls::with_deps::<K, _, _>(None, op)
     }
 
     /// Starts a new dep-graph task. Dep-graph tasks are specified
@@ -253,7 +253,7 @@ impl<K: DepKind> DepGraph<K> {
                 phantom_data: PhantomData,
             }))
         };
-        let result = K::with_deps(task_deps.as_ref(), || task(cx, arg));
+        let result = crate::tls::with_deps(task_deps.as_ref(), || task(cx, arg));
         let edges = task_deps.map_or_else(|| smallvec![], |lock| lock.into_inner().reads);
 
         let dcx = cx.dep_context();
@@ -305,8 +305,8 @@ impl<K: DepKind> DepGraph<K> {
         debug_assert!(!cx.is_eval_always(dep_kind));
 
         if let Some(ref data) = self.data {
-            let task_deps = Lock::new(TaskDeps::default());
-            let result = K::with_deps(Some(&task_deps), op);
+            let task_deps = Lock::new(TaskDeps::<K>::default());
+            let result = crate::tls::with_deps(Some(&task_deps), op);
             let task_deps = task_deps.into_inner();
             let task_deps = task_deps.reads;
 
@@ -358,7 +358,7 @@ impl<K: DepKind> DepGraph<K> {
     #[inline]
     pub fn read_index(&self, dep_node_index: DepNodeIndex) {
         if let Some(ref data) = self.data {
-            K::read_deps(|task_deps| {
+            crate::tls::read_deps(|task_deps| {
                 if let Some(task_deps) = task_deps {
                     let mut task_deps = task_deps.lock();
                     let task_deps = &mut *task_deps;

compiler/rustc_query_system/src/dep_graph/mod.rs

@@ -11,7 +11,6 @@ pub use serialized::{SerializedDepGraph, SerializedDepNodeIndex};
 
 use crate::ich::StableHashingContext;
 use rustc_data_structures::profiling::SelfProfilerRef;
-use rustc_data_structures::sync::Lock;
 use rustc_serialize::{opaque::FileEncoder, Encodable};
 use rustc_session::Session;
 
@@ -88,14 +87,4 @@ pub trait DepKind: Copy + fmt::Debug + Eq + Hash + Send + Encodable<FileEncoder>
 
     /// Implementation of `std::fmt::Debug` for `DepNode`.
     fn debug_node(node: &DepNode<Self>, f: &mut fmt::Formatter<'_>) -> fmt::Result;
-
-    /// Execute the operation with provided dependencies.
-    fn with_deps<OP, R>(deps: Option<&Lock<TaskDeps<Self>>>, op: OP) -> R
-    where
-        OP: FnOnce() -> R;
-
-    /// Access dependencies from current implicit context.
-    fn read_deps<OP>(op: OP)
-    where
-        OP: for<'a> FnOnce(Option<&'a Lock<TaskDeps<Self>>>);
 }