wip - remove

Author: Zoxc

Cargo.lock

@@ -1967,6 +1967,7 @@ dependencies = [
  "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
  "parking_lot 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)",
  "polonius-engine 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rustc-hash 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "rustc-rayon 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "rustc-rayon-core 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "rustc_apfloat 0.0.0",

src/librustc/Cargo.toml

@@ -20,6 +20,7 @@ log = { version = "0.4", features = ["release_max_level_info", "std"] }
 polonius-engine = "0.5.0"
 rustc-rayon = "0.1.1"
 rustc-rayon-core = "0.1.1"
+rustc-hash = "1.0.1"
 rustc_apfloat = { path = "../librustc_apfloat" }
 rustc_target = { path = "../librustc_target" }
 rustc_data_structures = { path = "../librustc_data_structures" }

src/librustc/dep_graph/graph.rs

@@ -1176,6 +1176,36 @@ pub fn test3(a: &mut SmallVec<[DepNodeIndex; 8]>) {
 pub fn test2(a: &mut DepGraph, dep_node_index: DepNodeIndex) {
     a.read_index(dep_node_index)
 }
+use hir::def_id::DefId;
+use std::hash::{BuildHasher, Hasher};
+use rustc_hash::FxHasher;
+#[no_mangle]
+pub fn test4(a: DefId) -> u64 {
+    let mut hasher = FxHasher::default();
+    a.hash(&mut hasher);
+    hasher.finish()
+}
+use hir::def_id::CrateNum;
+#[no_mangle]
+pub fn test7(a: CrateNum) -> u64 {
+    let mut hasher = FxHasher::default();
+    a.hash(&mut hasher);
+    hasher.finish()
+}
+use syntax::ast::NodeId;
+#[no_mangle]
+pub fn test5(a: NodeId) -> u64 {
+    let mut hasher = FxHasher::default();
+    a.hash(&mut hasher);
+    hasher.finish()
+}
+use hir::HirId;
+#[no_mangle]
+pub fn test6(a: HirId) -> u64 {
+    let mut hasher = FxHasher::default();
+    a.hash(&mut hasher);
+    hasher.finish()
+}
 
 pub struct AnonOpenTask {
     reads: SmallVec<[DepNodeIndex; 8]>,

src/librustc/lib.rs

@@ -73,12 +73,14 @@
 #![feature(transpose_result)]
 #![feature(arbitrary_self_types)]
 #![feature(hash_raw_entry)]
+#![feature(maybe_uninit)]
 
 #![recursion_limit="512"]
 
 #![warn(elided_lifetimes_in_paths)]
 
 extern crate arena;
+extern crate rustc_hash;
 #[macro_use] extern crate bitflags;
 extern crate core;
 extern crate fmt_macros;

src/librustc/ty/query/plumbing.rs

@@ -103,6 +103,75 @@ pub(super) struct JobOwner<'a, 'tcx: 'a, Q: QueryDescription<'tcx> + 'a> {
     layout_depth: usize,
 }
 
+    use std::mem::MaybeUninit;
+#[inline(never)]
+pub fn may_panic<'tcx>(job: Lrc<QueryJob<'tcx>>) {
+    Box::new(job);
+}
+
+#[inline(never)]
+pub fn test_space() {
+}
+
+#[no_mangle]
+fn test_moves2<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, 
+    key: &::hir::def_id::DefId, key_hash: u64,
+        span: Span,
+        parent: &Option<Lrc<QueryJob<'tcx>>>,
+    mut job_storage: MoveSlot<'a, JobOwner<'a, 'tcx, ::ty::query::queries::type_of<'tcx>>>,
+) -> TryGetJob<'a, 'tcx, ::ty::query::queries::type_of<'tcx>> {
+    use ty::query::config::QueryAccessors;
+    let mut job = Lrc::new(MaybeUninit::uninitialized());
+    let parent = parent.clone();
+    let info = QueryInfo {
+        span,
+        query: ::ty::query::queries::type_of::query(*key),
+    };
+    *Lrc::get_mut(&mut job).unwrap() = 
+        MaybeUninit::new(QueryJob::new(info, parent));
+    let job: Lrc<QueryJob<'tcx>> = unsafe { std::mem::transmute(job) };
+    let job_clone = job.clone();
+    may_panic(job);
+    let owner = job_storage.init(JobOwner {
+        cache: ::ty::query::queries::type_of::query_cache(tcx),
+        job: job_clone,
+        key: (*key).clone(),
+        key_hash,
+        layout_depth: 83952,
+    });
+    TryGetJob::NotYetStarted(owner)
+}
+
+#[no_mangle]
+fn test_moves<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, 
+    key: &::hir::def_id::DefId, key_hash: u64,
+        span: Span,
+    mut job_storage: MoveSlot<'a, JobOwner<'a, 'tcx, ::ty::query::queries::type_of<'tcx>>>,
+) -> TryGetJob<'a, 'tcx, ::ty::query::queries::type_of<'tcx>> {
+    use ty::query::config::QueryAccessors;
+    tls::with_related_context(tcx, |icx| {
+        let mut job = Lrc::new(MaybeUninit::uninitialized());
+        let parent = icx.query.clone();
+        let info = QueryInfo {
+            span,
+            query: ::ty::query::queries::type_of::query(*key),
+        };
+        *Lrc::get_mut(&mut job).unwrap() = 
+            MaybeUninit::new(QueryJob::new(info, parent));
+        let job: Lrc<QueryJob<'tcx>> = unsafe { std::mem::transmute(job) };
+        let job_clone = job.clone();
+        may_panic(job);
+        let owner = job_storage.init(JobOwner {
+            cache: ::ty::query::queries::type_of::query_cache(tcx),
+            job: job_clone,
+            key: (*key).clone(),
+            key_hash,
+            layout_depth: icx.layout_depth,
+        });
+        TryGetJob::NotYetStarted(owner)
+    })
+}
+
 impl<'a, 'tcx, Q: QueryDescription<'tcx>> JobOwner<'a, 'tcx, Q> {
     /// Either gets a JobOwner corresponding the query, allowing us to
     /// start executing the query, or it returns with the result of the query.