wip

Author: Zoxc

src/Cargo.lock

@@ -126,8 +126,8 @@ pub unsafe fn setup(build: &mut Build) {
     // during startup or terminating abnormally).  This is important for running tests,
     // since some of them use abnormal termination by design.
     // This mode is inherited by all child processes.
-    let mode = SetErrorMode(SEM_NOGPFAULTERRORBOX); // read inherited flags
-    SetErrorMode(mode | SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX);
+    //let mode = SetErrorMode(SEM_NOGPFAULTERRORBOX); // read inherited flags
+    SetErrorMode(0);
 
     // Create a new job object for us to use
     let job = CreateJobObjectW(0 as *mut _, 0 as *const _);

src/bootstrap/job.rs

@@ -16,7 +16,7 @@ graphviz = { path = "../libgraphviz" }
 jobserver = "0.1"
 log = "0.3"
 rayon = { git = "https://github.com/Zoxc/rayon.git", branch = "fiber" }
-rayon-core = { git = "https://github.com/Zoxc/rayon.git", branch = "fiber" }
+rayon-core = { git = "https://github.com/Zoxc/rayon.git", branch = "fiber", features=["debug"] }
 scoped-tls = { git = "https://github.com/Zoxc/scoped-tls.git", features=["nightly"] }
 owning_ref = { git = "https://github.com/Zoxc/owning-ref-rs.git" }
 rustc_back = { path = "../librustc_back" }
@@ -26,6 +26,7 @@ rustc_errors = { path = "../librustc_errors" }
 serialize = { path = "../libserialize" }
 syntax = { path = "../libsyntax" }
 syntax_pos = { path = "../libsyntax_pos" }
+lazy_static = "1.0.0"
 
 # Note that these dependencies are a lie, they're just here to get linkage to
 # work.

src/librustc/Cargo.toml

@@ -435,7 +435,7 @@ impl<'a, 'gcx, 'tcx> InferCtxtBuilder<'a, 'gcx, 'tcx> {
             ref fresh_tables,
         } = *self;
         let in_progress_tables = fresh_tables.as_ref();
-        global_tcx.enter_local(arena, |tcx| f(InferCtxt {
+        global_tcx.enter_local(arena, global_tcx.query(), |tcx| f(InferCtxt {
             tcx,
             in_progress_tables,
             projection_cache: RefCell::new(traits::ProjectionCache::new()),

src/librustc/infer/mod.rs

@@ -51,6 +51,7 @@
 #![feature(i128_type)]
 #![feature(inclusive_range)]
 #![feature(inclusive_range_syntax)]
+#![feature(iterator_step_by)]
 #![cfg_attr(windows, feature(libc))]
 #![feature(macro_vis_matcher)]
 #![feature(match_default_bindings)]
@@ -79,6 +80,7 @@ extern crate libc;
 extern crate owning_ref;
 extern crate rustc_back;
 #[macro_use] extern crate rustc_data_structures;
+#[macro_use] extern crate lazy_static;
 extern crate serialize;
 extern crate rustc_const_math;
 extern crate rustc_errors as errors;

src/librustc/lib.rs

@@ -778,7 +778,8 @@ impl<'tcx> CommonTypes<'tcx> {
 #[derive(Copy, Clone)]
 pub struct TyCtxt<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
     gcx: &'a GlobalCtxt<'gcx>,
-    interners: &'a CtxtInterners<'tcx>
+    interners: &'a CtxtInterners<'tcx>,
+    query: &'a maps::QueryJob<'gcx>,
 }
 
 impl<'a, 'gcx, 'tcx> Deref for TyCtxt<'a, 'gcx, 'tcx> {
@@ -881,18 +882,32 @@ pub struct GlobalCtxt<'tcx> {
     output_filenames: Arc<OutputFilenames>,
 }
 
-impl<'tcx> GlobalCtxt<'tcx> {
-    /// Get the global TyCtxt.
-    pub fn global_tcx<'a>(&'a self) -> TyCtxt<'a, 'tcx, 'tcx> {
+impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
+    pub fn query(self) -> &'a maps::QueryJob<'gcx> {
+        self.query
+    }
+
+    pub fn with_query<'b>(self,
+                          query: &'b maps::QueryJob<'gcx>)
+                         -> TyCtxt<'b, 'gcx, 'tcx>
+        where 'a: 'b
+    {
         TyCtxt {
-            gcx: self,
-            interners: &self.global_interners
+            gcx: self.gcx,
+            interners: self.interners,
+            query,
         }
     }
-}
 
+    /// Get the global TyCtxt.
+    pub fn global_tcx(self) -> TyCtxt<'a, 'gcx, 'gcx> {
+        TyCtxt {
+            gcx: self.gcx,
+            interners: &self.gcx.global_interners,
+            query: self.query,
+        }
+    }
 
-impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
     pub fn alloc_generics(self, generics: ty::Generics) -> &'gcx ty::Generics {
         self.global_arenas.generics.alloc(generics)
     }
@@ -1342,11 +1357,14 @@ impl<'a, 'tcx> TyCtxt<'a, 'tcx, 'tcx> {
 
 impl<'gcx: 'tcx, 'tcx> GlobalCtxt<'gcx> {
     /// Call the closure with a local `TyCtxt` using the given arena.
-    pub fn enter_local<F, R>(&self, arena: &'tcx DroplessArena, f: F) -> R
+    pub fn enter_local<F, R>(&self,
+                             arena: &'tcx DroplessArena,
+                             query: &maps::QueryJob<'gcx>,
+                             f: F) -> R
         where F: for<'a> FnOnce(TyCtxt<'a, 'gcx, 'tcx>) -> R
     {
         let interners = CtxtInterners::new(arena);
-        tls::enter(self, &interners, f)
+        tls::enter(self, &interners, query, f)
     }
 }
 
@@ -1498,16 +1516,20 @@ pub mod tls {
     use std::cell::Cell;
     use std::fmt;
     use syntax_pos;
+    use ty::maps;
+    use errors::{Diagnostic, TRACK_DIAGNOSTICS};
 
     /// Marker types used for the scoped TLS slot.
     /// The type context cannot be used directly because the scoped TLS
     /// in libstd doesn't allow types generic over lifetimes.
     enum ThreadLocalGlobalCtxt {}
     enum ThreadLocalInterners {}
+    enum ThreadLocalQuery {}
 
     thread_local! {
         static TLS_TCX: Cell<Option<(*const ThreadLocalGlobalCtxt,
-                                     *const ThreadLocalInterners)>> = Cell::new(None)
+                                     *const ThreadLocalInterners,
+                                     *const ThreadLocalQuery)>> = Cell::new(None)
     }
 
     fn span_debug(span: syntax_pos::Span, f: &mut fmt::Formatter) -> fmt::Result {
@@ -1516,31 +1538,53 @@ pub mod tls {
         })
     }
 
+    fn track_diagnostic(diagnostic: &Diagnostic) {
+        with(|tcx| {
+            if tcx.query.track_diagnostics {
+                tcx.query.diagnostics.lock().push(diagnostic.clone());
+            }
+        })
+    }
+
     pub fn enter_global<'gcx, F, R>(gcx: &GlobalCtxt<'gcx>, f: F) -> R
         where F: for<'a> FnOnce(TyCtxt<'a, 'gcx, 'gcx>) -> R
     {
         syntax_pos::SPAN_DEBUG.with(|span_dbg| {
             let original_span_debug = span_dbg.get();
             span_dbg.set(span_debug);
-            let result = enter(&gcx, &gcx.global_interners, f);
+
+            let result = TRACK_DIAGNOSTICS.with(|current| {
+                let original = current.get();
+                current.set(track_diagnostic);
+
+                let global_query = maps::QueryJob::new(Vec::new(), false, false);
+                let result = enter(&gcx, &gcx.global_interners, &global_query, f);
+                current.set(original);
+                result
+            });
+
             span_dbg.set(original_span_debug);
             result
         })
     }
 
     pub fn enter<'a, 'gcx: 'tcx, 'tcx, F, R>(gcx: &'a GlobalCtxt<'gcx>,
                                              interners: &'a CtxtInterners<'tcx>,
+                                             query: &'a maps::QueryJob<'gcx>,
                                              f: F) -> R
         where F: FnOnce(TyCtxt<'a, 'gcx, 'tcx>) -> R
     {
+        let tls_query = maps::QueryJob::new(Vec::new(), false, true);
         let gcx_ptr = gcx as *const _ as *const ThreadLocalGlobalCtxt;
         let interners_ptr = interners as *const _ as *const ThreadLocalInterners;
+        let query_ptr = &tls_query as *const _ as *const ThreadLocalQuery;
         TLS_TCX.with(|tls| {
             let prev = tls.get();
-            tls.set(Some((gcx_ptr, interners_ptr)));
+            tls.set(Some((gcx_ptr, interners_ptr, query_ptr)));
             let ret = f(TyCtxt {
                 gcx,
                 interners,
+                query,
             });
             tls.set(prev);
             ret
@@ -1551,12 +1595,14 @@ pub mod tls {
         where F: for<'a, 'gcx, 'tcx> FnOnce(TyCtxt<'a, 'gcx, 'tcx>) -> R
     {
         TLS_TCX.with(|tcx| {
-            let (gcx, interners) = tcx.get().unwrap();
+            let (gcx, interners, query) = tcx.get().unwrap();
             let gcx = unsafe { &*(gcx as *const GlobalCtxt) };
             let interners = unsafe { &*(interners as *const CtxtInterners) };
+            let query = unsafe { &*(query as *const maps::QueryJob) };
             f(TyCtxt {
                 gcx,
                 interners,
+                query,
             })
         })
     }

src/librustc/ty/context.rs

@@ -17,18 +17,33 @@ use rustc_data_structures::sync::{Lock, LockGuard, Lrc};
 use rayon_core::registry::{self, Registry};
 use rayon_core::fiber::WaiterLatch;
 use rayon_core::latch::Latch;
+use syntax_pos::Span;
+use ty::maps::Query;
+use errors::Diagnostic;
 
-pub(super) struct QueryJob {
-    latch: WaiterLatch,
+pub struct QueryJob<'tcx> {
+    pub latch: WaiterLatch,
+    pub stack: Vec<(Span, Query<'tcx>)>,
+    pub track_diagnostics: bool,
+    pub tls: bool,
+    pub diagnostics: Lock<Vec<Diagnostic>>,
 }
 
-impl QueryJob {
-    pub fn new() -> Self {
+impl<'tcx> QueryJob<'tcx> {
+    pub fn new(stack: Vec<(Span, Query<'tcx>)>, track_diagnostics: bool, tls: bool) -> Self {
         QueryJob {
             latch: WaiterLatch::new(),
+            track_diagnostics,
+            diagnostics: Lock::new(Vec::new()),
+            stack,
+            tls,
         }
     }
 
+    pub fn start(&self) {
+        self.latch.start()
+    }
+
     pub fn await(&self) {
         #[cfg(parallel_queries)]
         registry::in_worker(|worker, _| {
@@ -47,7 +62,7 @@ impl QueryJob {
     }
 }
 
-pub(super) enum QueryResult<T> {
-    Started(Lrc<QueryJob>),
+pub(super) enum QueryResult<'tcx, T> {
+    Started(Lrc<QueryJob<'tcx>>),
     Complete(T),
 }

src/librustc/ty/maps/job.rs

@@ -60,6 +60,7 @@ use self::plumbing::*;
 pub use self::plumbing::force_from_dep_node;
 
 mod job;
+pub use self::job::QueryJob;
 use self::job::QueryResult;
 
 mod keys;