Optimize for the case with on diagnostics

Author: Zoxc

src/librustc/dep_graph/graph.rs

@@ -813,7 +813,7 @@ impl DepGraph {
 
                 // Promote the previous diagnostics to the current session.
                 tcx.queries.on_disk_cache
-                   .store_diagnostics(dep_node_index, diagnostics.clone());
+                   .store_diagnostics(dep_node_index, Box::new(diagnostics.clone()));
 
                 for diagnostic in diagnostics {
                     DiagnosticBuilder::new_diagnostic(handle, diagnostic).emit();

src/librustc/ty/context.rs

@@ -1968,7 +1968,11 @@ pub mod tls {
         with_context_opt(|icx| {
             if let Some(icx) = icx {
                 if let Some(ref query) = icx.query {
-                    query.diagnostics.lock().push(diagnostic.clone());
+                    let mut diagnostics = query.diagnostics.lock();
+                    if diagnostics.is_none() {
+                        *diagnostics = Some(Box::new(Vec::new()));
+                    }
+                    diagnostics.as_mut().unwrap().push(diagnostic.clone());
                 }
             }
         })

src/librustc/ty/query/job.rs

@@ -65,7 +65,7 @@ pub struct QueryJob<'tcx> {
     pub parent: Option<Lrc<QueryJob<'tcx>>>,
 
     /// Diagnostic messages which are emitted while the query executes
-    pub diagnostics: Lock<Vec<Diagnostic>>,
+    pub diagnostics: Lock<Option<Box<Vec<Diagnostic>>>>,
 
     /// The latch which is used to wait on this job
     #[cfg(parallel_queries)]
@@ -76,19 +76,20 @@ 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(Vec::new()),
+            diagnostics: Lock::new(None),
             info,
             parent,
             #[cfg(parallel_queries)]
             latch: QueryLatch::new(),
         }
     }
 
-    pub fn extract_diagnostics(&self) -> Vec<Diagnostic> {
+    #[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(), Vec::new())
+        mem::replace(&mut *self.diagnostics.lock(), None)
     }
 
     /// Awaits for the query job to complete.

src/librustc/ty/query/on_disk_cache.rs

@@ -351,11 +351,13 @@ impl<'sess> OnDiskCache<'sess> {
     /// Store a diagnostic emitted during the current compilation session.
     /// Anything stored like this will be available via `load_diagnostics` in
     /// the next compilation session.
+    #[inline(never)]
+    #[cold]
     pub fn store_diagnostics(&self,
                              dep_node_index: DepNodeIndex,
-                             diagnostics: Vec<Diagnostic>) {
+                             diagnostics: Box<Vec<Diagnostic>>) {
         let mut current_diagnostics = self.current_diagnostics.borrow_mut();
-        let prev = current_diagnostics.insert(dep_node_index, diagnostics);
+        let prev = current_diagnostics.insert(dep_node_index, *diagnostics);
         debug_assert!(prev.is_none());
     }
 
@@ -377,13 +379,15 @@ impl<'sess> OnDiskCache<'sess> {
     /// Since many anonymous queries can share the same `DepNode`, we aggregate
     /// them -- as opposed to regular queries where we assume that there is a
     /// 1:1 relationship between query-key and `DepNode`.
+    #[inline(never)]
+    #[cold]
     pub fn store_diagnostics_for_anon_node(&self,
                                            dep_node_index: DepNodeIndex,
-                                           mut diagnostics: Vec<Diagnostic>) {
+                                           mut diagnostics: Box<Vec<Diagnostic>>) {
         let mut current_diagnostics = self.current_diagnostics.borrow_mut();
 
         let x = current_diagnostics.entry(dep_node_index).or_insert_with(|| {
-            mem::replace(&mut diagnostics, Vec::new())
+            mem::replace(&mut *diagnostics, Vec::new())
         });
 
         x.extend(diagnostics.into_iter());

src/librustc/ty/query/plumbing.rs

@@ -500,8 +500,10 @@ impl<'a, 'gcx> TyCtxt<'a, 'gcx, 'gcx> {
 
             self.dep_graph.read_index(dep_node_index);
 
-            self.queries.on_disk_cache
-                .store_diagnostics_for_anon_node(dep_node_index, job.job.extract_diagnostics());
+            if let Some(diagnostics) = job.job.extract_diagnostics() {
+                self.queries.on_disk_cache
+                    .store_diagnostics_for_anon_node(dep_node_index, diagnostics);
+            }
 
             job.complete(&result, dep_node_index);
 
@@ -664,8 +666,10 @@ impl<'a, 'gcx> TyCtxt<'a, 'gcx, 'gcx> {
         }
 
         if dep_node.kind != ::dep_graph::DepKind::Null {
-            self.queries.on_disk_cache
-                .store_diagnostics(dep_node_index, job.job.extract_diagnostics());
+            if let Some(diagnostics) = job.job.extract_diagnostics() {
+                self.queries.on_disk_cache
+                    .store_diagnostics(dep_node_index, diagnostics);
+            }
         }
 
         job.complete(&result, dep_node_index);