Buffer panic errors in other threads

Author: Zoxc

src/librustc/lib.rs

@@ -60,6 +60,7 @@
 #![feature(quote)]
 #![feature(refcell_replace_swap)]
 #![feature(rustc_diagnostic_macros)]
+#![feature(set_stdio)]
 #![feature(slice_patterns)]
 #![feature(specialization)]
 #![feature(unboxed_closures)]

src/librustc/ty/context.rs

@@ -63,8 +63,10 @@ use std::hash::{Hash, Hasher};
 use std::mem;
 use std::ops::Deref;
 use std::iter;
+use std::io;
+use std::io::Write;
 use std::sync::mpsc;
-use std::sync::Arc;
+use std::sync::{Mutex, Arc};
 use syntax::abi;
 use syntax::ast::{self, Name, NodeId};
 use syntax::attr;
@@ -882,6 +884,18 @@ pub struct GlobalCtxt<'tcx> {
     output_filenames: Arc<OutputFilenames>,
 }
 
+scoped_thread_local!(pub static PANIC_SINK: Arc<Mutex<Vec<u8>>>);
+
+pub struct Sink(pub Arc<Mutex<Vec<u8>>>);
+impl Write for Sink {
+    fn write(&mut self, data: &[u8]) -> io::Result<usize> {
+        Write::write(&mut *self.0.lock().unwrap(), data)
+    }
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
 impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
     pub fn query(self) -> &'a maps::QueryJob<'gcx> {
         self.query
@@ -1191,19 +1205,26 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
             let (r, pool_end) = try_with(&PROFQ_CHAN, |prof_chan| {
                 try_with(&syntax::GLOBALS, |syntax_globals| {
                     try_with(&syntax_pos::GLOBALS, |syntax_pos_globals| {
-                        let main_handler = move |worker: &mut FnMut()| {
-                            maybe_set(&PROFQ_CHAN, prof_chan, || {
-                                maybe_set(&syntax::GLOBALS, syntax_globals, || {
-                                    maybe_set(&syntax_pos::GLOBALS, syntax_pos_globals, || {
-                                        tls::enter_global(gcx, |_| {
-                                            worker();
+                        try_with(&PANIC_SINK, |panic_sink| {
+                            let main_handler = move |worker: &mut FnMut()| {
+                                maybe_set(&PROFQ_CHAN, prof_chan, || {
+                                    maybe_set(&syntax::GLOBALS, syntax_globals, || {
+                                        maybe_set(&syntax_pos::GLOBALS, syntax_pos_globals, || {
+                                            if let Some(sink_data) = panic_sink {
+                                                let err = Sink(sink_data.clone());
+                                                io::set_panic(Some(box err));
+                                            }
+
+                                            tls::enter_global(gcx, |_| {
+                                                worker();
+                                            })
                                         })
                                     })
                                 })
-                            })
-                        };
+                            };
 
-                        rayon::ThreadPool::scoped_pool(config, main_handler, with_pool).unwrap()
+                            rayon::ThreadPool::scoped_pool(config, main_handler, with_pool).unwrap()
+                        })
                     })
                 })
             });

src/librustc/ty/mod.rs

@@ -78,7 +78,7 @@ pub use self::binding::BindingMode;
 pub use self::binding::BindingMode::*;
 
 pub use self::context::{TyCtxt, GlobalArenas, AllArenas, tls, keep_local};
-pub use self::context::{Lift, TypeckTables};
+pub use self::context::{Lift, TypeckTables, PANIC_SINK, Sink};
 
 pub use self::instance::{Instance, InstanceDef};
 

src/librustc_driver/lib.rs

@@ -73,6 +73,7 @@ use rustc::session::config::nightly_options;
 use rustc::session::{early_error, early_warn};
 use rustc::lint::Lint;
 use rustc::lint;
+use rustc::ty::{PANIC_SINK, Sink};
 use rustc::middle::cstore::CrateStore;
 use rustc_metadata::locator;
 use rustc_metadata::cstore::CStore;
@@ -1212,22 +1213,14 @@ pub fn in_rustc_thread<F, R>(f: F) -> Result<R, Box<Any + Send>>
 /// The diagnostic emitter yielded to the procedure should be used for reporting
 /// errors of the compiler.
 pub fn monitor<F: FnOnce() + Send + 'static>(f: F) {
-    struct Sink(Arc<Mutex<Vec<u8>>>);
-    impl Write for Sink {
-        fn write(&mut self, data: &[u8]) -> io::Result<usize> {
-            Write::write(&mut *self.0.lock().unwrap(), data)
-        }
-        fn flush(&mut self) -> io::Result<()> {
-            Ok(())
-        }
-    }
-
     let data = Arc::new(Mutex::new(Vec::new()));
     let err = Sink(data.clone());
 
     let result = in_rustc_thread(move || {
         io::set_panic(Some(box err));
-        f()
+        PANIC_SINK.set(data.clone(), || {
+            f()
+        })
     });
 
     if let Err(value) = result {