Move diagnostics out from QueryJob

Author: Zoxc

src/librustc/ty/context.rs

@@ -1623,7 +1623,8 @@ impl<'gcx: 'tcx, 'tcx> GlobalCtxt<'gcx> {
         ty::tls::with_related_context(tcx.global_tcx(), |icx| {
             let new_icx = ty::tls::ImplicitCtxt {
                 tcx,
-                query: icx.query.clone(),
+                query: icx.query,
+                diagnostics: icx.diagnostics,
                 layout_depth: icx.layout_depth,
                 task: icx.task,
             };
@@ -1896,6 +1897,10 @@ pub mod tls {
         /// ty::query::plumbing when executing a query
         pub query: Option<LrcRef<'a, query::QueryJob<'gcx>>>,
 
+        /// Where to store diagnostics for the current query job, if any.
+        /// This is updated by start_job in ty::query::plumbing when executing a query
+        pub diagnostics: Option<&'a Lock<Option<Box<Vec<Diagnostic>>>>>,
+
         /// Used to prevent layout from recursing too deeply.
         pub layout_depth: usize,
 
@@ -1971,8 +1976,8 @@ pub mod tls {
     fn track_diagnostic(diagnostic: &Diagnostic) {
         with_context_opt(|icx| {
             if let Some(icx) = icx {
-                if let Some(ref query) = icx.query {
-                    let mut diagnostics = query.diagnostics.lock();
+                if let Some(ref diagnostics) = icx.diagnostics {
+                    let mut diagnostics = diagnostics.lock();
                     if diagnostics.is_none() {
                         *diagnostics = Some(Box::new(Vec::new()));
                     }
@@ -2042,6 +2047,7 @@ pub mod tls {
             let icx = ImplicitCtxt {
                 tcx,
                 query: None,
+                diagnostics: None,
                 layout_depth: 0,
                 task: &OpenTask::Ignore,
             };
@@ -2070,6 +2076,7 @@ pub mod tls {
         };
         let icx = ImplicitCtxt {
             query: None,
+            diagnostics: None,
             tcx,
             layout_depth: 0,
             task: &OpenTask::Ignore,

src/librustc/ty/query/job.rs

@@ -24,7 +24,6 @@ use ty::query::{
     config::QueryDescription,
 };
 use ty::context::TyCtxt;
-use errors::Diagnostic;
 use std::process;
 use std::{fmt, ptr};
 
@@ -55,9 +54,6 @@ pub struct QueryJob<'tcx> {
     /// The parent query job which created this job and is implicitly waiting on it.
     pub parent: Option<Lrc<QueryJob<'tcx>>>,
 
-    /// Diagnostic messages which are emitted while the query executes
-    pub diagnostics: Lock<Option<Box<Vec<Diagnostic>>>>,
-
     /// The latch which is used to wait on this job
     #[cfg(parallel_queries)]
     latch: QueryLatch<'tcx>,
@@ -67,22 +63,13 @@ impl<'tcx> QueryJob<'tcx> {
     /// Creates a new query job
     pub fn new(info: QueryInfo<'tcx>, parent: Option<Lrc<QueryJob<'tcx>>>) -> Self {
         QueryJob {
-            diagnostics: Lock::new(None),
             info,
             parent,
             #[cfg(parallel_queries)]
             latch: QueryLatch::new(),
         }
     }
 
-    #[inline(always)]
-    pub fn extract_diagnostics(&self) -> Option<Box<Vec<Diagnostic>>> {
-        // FIXME: Find a way to remove this lock access since we should have
-        // ownership of the content back now. Other crates may free the Lrc though
-        // and the, but only after we replace this.
-        mem::replace(&mut *self.diagnostics.lock(), None)
-    }
-
     /// Awaits for the query job to complete.
     ///
     /// For single threaded rustc there's no concurrent jobs running, so if we are waiting for any

src/librustc/ty/query/plumbing.rs

@@ -15,6 +15,7 @@
 use dep_graph::{DepNodeIndex, DepNode, DepKind, DepNodeColor, OpenTask};
 use errors::DiagnosticBuilder;
 use errors::Level;
+use errors::Diagnostic;
 use ty::tls;
 use ty::{TyCtxt};
 use ty::query::Query;
@@ -289,13 +290,15 @@ impl<'a, 'tcx, Q: QueryDescription<'tcx>> JobOwner<'a, 'tcx, Q> {
         &self,
         tcx: TyCtxt<'_, 'tcx, 'tcx>,
         task: &OpenTask,
+        diagnostics: Option<&Lock<Option<Box<Vec<Diagnostic>>>>>,
         key: Q::Key,
     ) -> Q::Value
     {
         // Update the ImplicitCtxt to point to our new query job
         let new_icx = tls::ImplicitCtxt {
             tcx,
             query: Some(LrcRef::new(&self.job)),
+            diagnostics,
             layout_depth: self.layout_depth,
             task,
         };
@@ -305,6 +308,17 @@ impl<'a, 'tcx, Q: QueryDescription<'tcx>> JobOwner<'a, 'tcx, Q> {
             Q::compute(tcx, key)
         })
     }
+
+}
+
+#[inline(always)]
+fn with_diagnostics<F, R>(f: F) -> (R, Option<Box<Vec<Diagnostic>>>)
+where
+    F: FnOnce(Option<&Lock<Option<Box<Vec<Diagnostic>>>>>) -> R
+{
+    let diagnostics = Lock::new(None);
+    let result = f(Some(&diagnostics));
+    (result, diagnostics.into_inner())
 }
 
 impl<'a, 'tcx, Q: QueryDescription<'tcx>> Drop for JobOwner<'a, 'tcx, Q> {
@@ -489,8 +503,10 @@ impl<'a, 'gcx> TyCtxt<'a, 'gcx, 'gcx> {
             profq_msg!(self, ProfileQueriesMsg::ProviderBegin);
             self.sess.profiler(|p| p.start_activity(Q::CATEGORY));
 
-            let res = self.dep_graph.with_anon_open_task(dep_node.kind, |open_task| {
-                job.compute(self, open_task, key)
+            let (res, diag) = with_diagnostics(|diagnostics| {
+                    self.dep_graph.with_anon_open_task(dep_node.kind, |open_task| {
+                    job.compute(self, open_task, diagnostics, key)
+                })
             });
 
             self.sess.profiler(|p| p.end_activity(Q::CATEGORY));
@@ -499,7 +515,7 @@ impl<'a, 'gcx> TyCtxt<'a, 'gcx, 'gcx> {
 
             self.dep_graph.read_index(dep_node_index);
 
-            if let Some(diagnostics) = job.job.extract_diagnostics() {
+            if let Some(diagnostics) = diag {
                 self.queries.on_disk_cache
                     .store_diagnostics_for_anon_node(dep_node_index, diagnostics);
             }
@@ -573,7 +589,7 @@ impl<'a, 'gcx> TyCtxt<'a, 'gcx, 'gcx> {
             // try_mark_green(), so we can ignore them here.
             // The dep-graph for this computation is already in
             // place so we pass OpenTask::Ignore.
-            job.compute(self, &OpenTask::Ignore, key)
+            job.compute(self, &OpenTask::Ignore, None, key)
         };
 
         // If -Zincremental-verify-ich is specified, re-hash results from
@@ -647,15 +663,17 @@ impl<'a, 'gcx> TyCtxt<'a, 'gcx, 'gcx> {
             p.record_query(Q::CATEGORY);
         });
 
-        let (result, dep_node_index) = if dep_node.kind.is_eval_always() {
-            self.dep_graph.with_eval_always_task(self, dep_node, |task| {
-                job.compute(self, task, key)
-            })
-        } else {
-            self.dep_graph.with_query_task(self, dep_node, |task| {
-                job.compute(self, task, key)
-            })
-        };
+        let ((result, dep_node_index), diagnostics) = with_diagnostics(|diagnostics| {
+            if dep_node.kind.is_eval_always() {
+                self.dep_graph.with_eval_always_task(self, dep_node, |task| {
+                    job.compute(self, task, diagnostics, key)
+                })
+            } else {
+                self.dep_graph.with_query_task(self, dep_node, |task| {
+                    job.compute(self, task, diagnostics, key)
+                })
+            }
+        });
 
         self.sess.profiler(|p| p.end_activity(Q::CATEGORY));
         profq_msg!(self, ProfileQueriesMsg::ProviderEnd);
@@ -665,7 +683,7 @@ impl<'a, 'gcx> TyCtxt<'a, 'gcx, 'gcx> {
         }
 
         if dep_node.kind != ::dep_graph::DepKind::Null {
-            if let Some(diagnostics) = job.job.extract_diagnostics() {
+            if let Some(diagnostics) = diagnostics {
                 self.queries.on_disk_cache
                     .store_diagnostics(dep_node_index, diagnostics);
             }