Shrink TLS interface.

Consider that an empty registered TLS is equivalent to an empty TLS.

Author: cjgillot

compiler/rustc_interface/src/passes.rs

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

compiler/rustc_interface/src/util.rs

@@ -154,24 +154,22 @@ 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::<qls::ImplicitCtxt<'_>>();
-    let qcx: &qls::ImplicitCtxt<'_> = &*(context as *const qls::ImplicitCtxt<'_>);
+
+    // We do not need to copy the query ImplicitCtxt since this deadlock handler is not part of a
+    // normal query invocation.
 
     let session_globals = rustc_span::with_session_globals(|sg| sg as *const _);
     let session_globals = &*session_globals;
     thread::spawn(move || {
         tls::enter_context(icx, |_| {
-            qls::enter_context(icx, |_| {
-                rustc_span::set_session_globals_then(session_globals, || {
-                    tls::with(|tcx| QueryCtxt::from_tcx(tcx).deadlock(&registry))
-                })
+            rustc_span::set_session_globals_then(session_globals, || {
+                tls::with(|tcx| QueryCtxt::from_tcx(tcx).deadlock(&registry))
             })
         });
     });

compiler/rustc_query_system/src/tls.rs

@@ -13,8 +13,8 @@ use rustc_rayon_core as rayon_core;
 /// This is the implicit state of rustc. It contains the current
 /// query. It is updated when
 /// executing a new query.
-#[derive(Clone)]
-pub struct ImplicitCtxt<'a> {
+#[derive(Clone, Default)]
+struct ImplicitCtxt<'a> {
     /// The current query job, if any. This is updated by `JobOwner::start` in
     /// `ty::query::plumbing` when executing a query.
     query: Option<QueryJobId>,
@@ -28,12 +28,6 @@ pub struct ImplicitCtxt<'a> {
     task_deps: Option<&'a Lock<TaskDeps>>,
 }
 
-impl<'a> ImplicitCtxt<'a> {
-    pub fn new() -> Self {
-        ImplicitCtxt { query: None, diagnostics: None, task_deps: None }
-    }
-}
-
 /// Sets Rayon's thread-local variable, which is preserved for Rayon jobs
 /// to `value` during the call to `f`. It is restored to its previous value after.
 /// This is used to set the pointer to the new `ImplicitCtxt`.
@@ -78,7 +72,7 @@ fn get_tlv() -> usize {
 
 /// Sets `context` as the new current `ImplicitCtxt` for the duration of the function `f`.
 #[inline]
-pub fn enter_context<'a, F, R>(context: &ImplicitCtxt<'a>, f: F) -> R
+fn enter_context<'a, F, R>(context: &ImplicitCtxt<'a>, f: F) -> R
 where
     F: FnOnce(&ImplicitCtxt<'a>) -> R,
 {
@@ -91,26 +85,14 @@ fn with_context_opt<F, R>(f: F) -> R
 where
     F: for<'a> FnOnce(Option<&ImplicitCtxt<'a>>) -> R,
 {
-    let context = get_tlv();
-    if context == 0 {
-        f(None)
-    } else {
-        // We could get a `ImplicitCtxt` pointer from another thread.
-        // Ensure that `ImplicitCtxt` is `Sync`.
-        sync::assert_sync::<ImplicitCtxt<'_>>();
-
-        unsafe { f(Some(&*(context as *const ImplicitCtxt<'_>))) }
-    }
-}
+    // We could get a `ImplicitCtxt` pointer from another thread.
+    // Ensure that `ImplicitCtxt` is `Sync`.
+    sync::assert_sync::<ImplicitCtxt<'_>>();
 
-/// Allows access to the current `ImplicitCtxt`.
-/// Panics if there is no `ImplicitCtxt` available.
-#[inline]
-fn with_context<F, R>(f: F) -> R
-where
-    F: for<'a> FnOnce(&ImplicitCtxt<'a>) -> R,
-{
-    with_context_opt(|opt_context| f(opt_context.expect("no ImplicitCtxt stored in tls")))
+    let context = get_tlv();
+    let context =
+        if context == 0 { None } else { unsafe { Some(&*(context as *const ImplicitCtxt<'_>)) } };
+    f(context)
 }
 
 /// This is a callback from `rustc_ast` as it cannot access the implicit state
@@ -131,8 +113,8 @@ pub fn with_deps<OP, R>(task_deps: Option<&Lock<TaskDeps>>, op: OP) -> R
 where
     OP: FnOnce() -> R,
 {
-    crate::tls::with_context(|icx| {
-        let icx = crate::tls::ImplicitCtxt { task_deps, ..icx.clone() };
+    crate::tls::with_context_opt(|icx| {
+        let icx = crate::tls::ImplicitCtxt { task_deps, ..icx.cloned().unwrap_or_default() };
 
         crate::tls::enter_context(&icx, |_| op())
     })
@@ -142,16 +124,13 @@ pub fn read_deps<OP>(op: OP)
 where
     OP: for<'a> FnOnce(Option<&'a Lock<TaskDeps>>),
 {
-    crate::tls::with_context_opt(|icx| {
-        let icx = if let Some(icx) = icx { icx } else { return };
-        op(icx.task_deps)
-    })
+    crate::tls::with_context_opt(|icx| op(icx.and_then(|icx| icx.task_deps)))
 }
 
 /// Get the query information from the TLS context.
 #[inline(always)]
 pub fn current_query_job() -> Option<QueryJobId> {
-    with_context(|icx| icx.query)
+    with_context_opt(|icx| icx?.query)
 }
 
 /// Executes a job by changing the `ImplicitCtxt` to point to the
@@ -163,10 +142,11 @@ pub fn start_query<R>(
     diagnostics: Option<&Lock<ThinVec<Diagnostic>>>,
     compute: impl FnOnce() -> R,
 ) -> R {
-    with_context(move |current_icx| {
+    with_context_opt(move |current_icx| {
+        let task_deps = current_icx.and_then(|icx| icx.task_deps);
+
         // Update the `ImplicitCtxt` to point to our new query job.
-        let new_icx =
-            ImplicitCtxt { query: Some(token), diagnostics, task_deps: current_icx.task_deps };
+        let new_icx = ImplicitCtxt { query: Some(token), diagnostics, task_deps };
 
         // Use the `ImplicitCtxt` while we execute the query.
         enter_context(&new_icx, |_| rustc_data_structures::stack::ensure_sufficient_stack(compute))