Make librustc_query_system compile.

Author: cjgillot

Cargo.lock

@@ -4042,12 +4042,15 @@ version = "0.0.0"
 dependencies = [
  "log",
  "parking_lot 0.9.0",
+ "rustc-rayon-core",
  "rustc_ast",
  "rustc_data_structures",
  "rustc_errors",
  "rustc_hir",
  "rustc_index",
  "rustc_macros",
+ "rustc_session",
+ "rustc_span",
  "serialize",
  "smallvec 1.0.0",
 ]

src/librustc_query_system/Cargo.toml

@@ -11,12 +11,15 @@ doctest = false
 
 [dependencies]
 log = { version = "0.4", features = ["release_max_level_info", "std"] }
+rustc-rayon-core = "0.3.0"
 rustc_ast = { path = "../librustc_ast" }
 rustc_data_structures = { path = "../librustc_data_structures" }
 rustc_errors = { path = "../librustc_errors" }
 rustc_hir = { path = "../librustc_hir" }
 rustc_index = { path = "../librustc_index" }
 rustc_macros = { path = "../librustc_macros" }
 rustc_serialize = { path = "../libserialize", package = "serialize" }
+rustc_session = { path = "../librustc_session" }
+rustc_span = { path = "../librustc_span" }
 parking_lot = "0.9"
 smallvec = { version = "1.0", features = ["union", "may_dangle"] }

src/librustc_query_system/lib.rs

@@ -1,14 +1,20 @@
+#![feature(bool_to_option)]
 #![feature(const_fn)]
 #![feature(const_if_match)]
 #![feature(const_panic)]
 #![feature(core_intrinsics)]
+#![feature(hash_raw_entry)]
 #![feature(specialization)]
 #![feature(stmt_expr_attributes)]
+#![feature(vec_remove_item)]
 
 #[macro_use]
 extern crate log;
+#[macro_use]
+extern crate rustc_data_structures;
 
 pub mod dep_graph;
+pub mod query;
 
 pub trait HashStableContext {
     fn debug_dep_tasks(&self) -> bool;

src/librustc_query_system/query/caches.rs

@@ -1,18 +1,18 @@
 use crate::dep_graph::DepNodeIndex;
-use crate::ty::query::config::QueryContext;
-use crate::ty::query::plumbing::{QueryLookup, QueryState, QueryStateShard};
+use crate::query::config::QueryContext;
+use crate::query::plumbing::{QueryLookup, QueryState, QueryStateShard};
 
 use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::sharded::Sharded;
 use std::default::Default;
 use std::hash::Hash;
 use std::marker::PhantomData;
 
-pub(crate) trait CacheSelector<CTX: QueryContext, K, V> {
+pub trait CacheSelector<CTX: QueryContext, K, V> {
     type Cache: QueryCache<CTX, Key = K, Value = V>;
 }
 
-pub(crate) trait QueryCache<CTX: QueryContext>: Default {
+pub trait QueryCache<CTX: QueryContext>: Default {
     type Key;
     type Value;
     type Sharded: Default;

src/librustc_query_system/query/config.rs

@@ -1,10 +1,11 @@
 //! Query configuration and description traits.
 
 use crate::dep_graph::SerializedDepNodeIndex;
-use crate::ty::query::caches::QueryCache;
-use crate::ty::query::job::{QueryJobId, QueryJobInfo};
-use crate::ty::query::plumbing::CycleError;
-use crate::ty::query::QueryState;
+use crate::dep_graph::{DepContext, DepGraph, DepNode};
+use crate::query::caches::QueryCache;
+use crate::query::job::{QueryJobId, QueryJobInfo};
+use crate::query::plumbing::CycleError;
+use crate::query::QueryState;
 use rustc_data_structures::profiling::ProfileCategory;
 use rustc_hir::def_id::DefId;
 
@@ -14,7 +15,6 @@ use rustc_data_structures::stable_hasher::HashStable;
 use rustc_data_structures::sync::Lock;
 use rustc_data_structures::thin_vec::ThinVec;
 use rustc_errors::Diagnostic;
-use rustc_query_system::dep_graph::{DepContext, DepGraph, DepNode};
 use rustc_session::Session;
 use std::borrow::Cow;
 use std::fmt::Debug;
@@ -58,7 +58,7 @@ pub trait QueryContext: DepContext {
     ) -> R;
 }
 
-pub(crate) trait QueryAccessors<CTX: QueryContext>: QueryConfig<CTX> {
+pub trait QueryAccessors<CTX: QueryContext>: QueryConfig<CTX> {
     const ANON: bool;
     const EVAL_ALWAYS: bool;
     const DEP_KIND: CTX::DepKind;
@@ -81,7 +81,7 @@ pub(crate) trait QueryAccessors<CTX: QueryContext>: QueryConfig<CTX> {
     fn handle_cycle_error(tcx: CTX, error: CycleError<CTX::Query>) -> Self::Value;
 }
 
-pub(crate) trait QueryDescription<CTX: QueryContext>: QueryAccessors<CTX> {
+pub trait QueryDescription<CTX: QueryContext>: QueryAccessors<CTX> {
     fn describe(tcx: CTX, key: Self::Key) -> Cow<'static, str>;
 
     #[inline]
@@ -90,7 +90,7 @@ pub(crate) trait QueryDescription<CTX: QueryContext>: QueryAccessors<CTX> {
     }
 
     fn try_load_from_disk(_: CTX, _: SerializedDepNodeIndex) -> Option<Self::Value> {
-        bug!("QueryDescription::load_from_disk() called for an unsupported query.")
+        panic!("QueryDescription::load_from_disk() called for an unsupported query.")
     }
 }
 
@@ -112,6 +112,6 @@ where
     }
 
     default fn try_load_from_disk(_: CTX, _: SerializedDepNodeIndex) -> Option<Self::Value> {
-        bug!("QueryDescription::load_from_disk() called for an unsupported query.")
+        panic!("QueryDescription::load_from_disk() called for an unsupported query.")
     }
 }

src/librustc_query_system/query/job.rs

@@ -1,10 +1,8 @@
-use crate::ty::query::config::QueryContext;
-use crate::ty::query::plumbing::CycleError;
-#[cfg(parallel_compiler)]
-use crate::ty::tls;
+use crate::dep_graph::{DepKind, DepContext};
+use crate::query::config::QueryContext;
+use crate::query::plumbing::CycleError;
 
 use rustc_data_structures::fx::FxHashMap;
-use rustc_query_system::dep_graph::DepContext;
 use rustc_span::Span;
 
 use std::convert::TryFrom;
@@ -22,7 +20,7 @@ use {
     rustc_rayon_core as rayon_core,
     rustc_span::DUMMY_SP,
     std::iter::FromIterator,
-    std::{mem, process, thread},
+    std::{mem, process},
 };
 
 /// Represents a span and a query key.
@@ -52,7 +50,7 @@ pub struct QueryJobId<K> {
     pub kind: K,
 }
 
-impl<K: rustc_query_system::dep_graph::DepKind> QueryJobId<K> {
+impl<K: DepKind> QueryJobId<K> {
     pub fn new(job: QueryShardJobId, shard: usize, kind: K) -> Self {
         QueryJobId { job, shard: u16::try_from(shard).unwrap(), kind }
     }
@@ -529,38 +527,13 @@ fn remove_cycle<CTX: QueryContext>(
     }
 }
 
-/// Creates a new thread and forwards information in thread locals to it.
-/// The new thread runs the deadlock handler.
-/// Must only be called when a deadlock is about to happen.
-#[cfg(parallel_compiler)]
-pub unsafe fn handle_deadlock() {
-    let registry = rayon_core::Registry::current();
-
-    let gcx_ptr = tls::GCX_PTR.with(|gcx_ptr| gcx_ptr as *const _);
-    let gcx_ptr = &*gcx_ptr;
-
-    let rustc_span_globals =
-        rustc_span::GLOBALS.with(|rustc_span_globals| rustc_span_globals as *const _);
-    let rustc_span_globals = &*rustc_span_globals;
-    let syntax_globals = rustc_ast::attr::GLOBALS.with(|syntax_globals| syntax_globals as *const _);
-    let syntax_globals = &*syntax_globals;
-    thread::spawn(move || {
-        tls::GCX_PTR.set(gcx_ptr, || {
-            rustc_ast::attr::GLOBALS.set(syntax_globals, || {
-                rustc_span::GLOBALS
-                    .set(rustc_span_globals, || tls::with_global(|tcx| deadlock(tcx, &registry)))
-            });
-        })
-    });
-}
-
 /// Detects query cycles by using depth first search over all active query jobs.
 /// If a query cycle is found it will break the cycle by finding an edge which
 /// uses a query latch and then resuming that waiter.
 /// There may be multiple cycles involved in a deadlock, so this searches
 /// all active queries for cycles before finally resuming all the waiters at once.
 #[cfg(parallel_compiler)]
-fn deadlock<CTX: QueryContext>(tcx: CTX, registry: &rayon_core::Registry) {
+pub fn deadlock<CTX: QueryContext>(tcx: CTX, registry: &rayon_core::Registry) {
     let on_panic = OnDrop(|| {
         eprintln!("deadlock handler panicked, aborting process");
         process::abort();