Turn HIR lowering into a query

Author: Zoxc

src/librustc/dep_graph/dep_node.rs

@@ -50,7 +50,7 @@
 //! fingerprint for a given set of node parameters.
 
 use crate::mir::interpret::GlobalId;
-use crate::hir::def_id::{CrateNum, DefId, DefIndex, CRATE_DEF_INDEX};
+use crate::hir::def_id::{CrateNum, LocalCrate, DefId, DefIndex, CRATE_DEF_INDEX};
 use crate::hir::map::DefPathHash;
 use crate::hir::HirId;
 
@@ -309,8 +309,7 @@ macro_rules! define_dep_nodes {
             pub fn extract_def_id(&self, tcx: TyCtxt<'_, '_, '_>) -> Option<DefId> {
                 if self.kind.can_reconstruct_query_key() {
                     let def_path_hash = DefPathHash(self.hash);
-                    tcx.def_path_hash_to_def_id.as_ref()?
-                        .get(&def_path_hash).cloned()
+                    tcx.def_path_hash_to_def_id()?.get(&def_path_hash).cloned()
                 } else {
                     None
                 }
@@ -444,6 +443,12 @@ pub trait RecoverKey<'tcx>: Sized {
     fn recover(tcx: TyCtxt<'_, 'tcx, 'tcx>, dep_node: &DepNode) -> Option<Self>;
 }
 
+impl RecoverKey<'tcx> for LocalCrate {
+    fn recover(_: TyCtxt<'_, 'tcx, 'tcx>, _: &DepNode) -> Option<Self> {
+        Some(LocalCrate)
+    }
+}
+
 impl RecoverKey<'tcx> for CrateNum {
     fn recover(tcx: TyCtxt<'_, 'tcx, 'tcx>, dep_node: &DepNode) -> Option<Self> {
         dep_node.extract_def_id(tcx).map(|id| id.krate)
@@ -537,6 +542,18 @@ impl<'a, 'gcx: 'tcx + 'a, 'tcx: 'a> DepNodeParams<'a, 'gcx, 'tcx> for CrateNum {
     }
 }
 
+impl<'a, 'gcx: 'tcx + 'a, 'tcx: 'a> DepNodeParams<'a, 'gcx, 'tcx> for LocalCrate {
+    const CAN_RECONSTRUCT_QUERY_KEY: bool = false;
+
+    fn to_fingerprint(&self, _: TyCtxt<'_, '_, '_>) -> Fingerprint {
+        Fingerprint::ZERO
+    }
+
+    fn to_debug_str(&self, _: TyCtxt<'a, 'gcx, 'tcx>) -> String {
+        "<local crate>".to_string()
+    }
+}
+
 impl<'a, 'gcx: 'tcx + 'a, 'tcx: 'a> DepNodeParams<'a, 'gcx, 'tcx> for (DefId, DefId) {
     const CAN_RECONSTRUCT_QUERY_KEY: bool = false;
 

src/librustc/dep_graph/graph.rs

@@ -79,14 +79,14 @@ struct DepGraphData {
     loaded_from_cache: Lock<FxHashMap<DepNodeIndex, bool>>,
 }
 
-pub fn hash_result<R>(hcx: &mut StableHashingContext<'_>, result: &R) -> Option<Fingerprint>
+pub fn hash_result<R>(hcx: &mut StableHashingContext<'_>, result: &R) -> Fingerprint
 where
     R: for<'a> HashStable<StableHashingContext<'a>>,
 {
     let mut stable_hasher = StableHasher::new();
     result.hash_stable(hcx, &mut stable_hasher);
 
-    Some(stable_hasher.finish())
+    stable_hasher.finish()
 }
 
 impl DepGraph {
@@ -194,7 +194,7 @@ impl DepGraph {
         cx: C,
         arg: A,
         task: fn(C, A) -> R,
-        hash_result: impl FnOnce(&mut StableHashingContext<'_>, &R) -> Option<Fingerprint>,
+        hash_result: Option<impl FnOnce(&mut StableHashingContext<'_>, &R) -> Fingerprint>,
     ) -> (R, DepNodeIndex)
     where
         C: DepGraphSafe + StableHashingContextProvider<'a>,
@@ -230,7 +230,8 @@ impl DepGraph {
             |data, key, fingerprint, _| {
                 data.borrow_mut().alloc_node(key, SmallVec::new(), fingerprint)
             },
-            hash_result::<R>)
+            Some(hash_result::<R>)
+        )
     }
 
     fn with_task_impl<'a, C, A, R>(
@@ -245,24 +246,21 @@ impl DepGraph {
                                           DepNode,
                                           Fingerprint,
                                           Option<TaskDeps>) -> DepNodeIndex,
-        hash_result: impl FnOnce(&mut StableHashingContext<'_>, &R) -> Option<Fingerprint>,
+        hash_result: Option<impl FnOnce(&mut StableHashingContext<'_>, &R) -> Fingerprint>,
     ) -> (R, DepNodeIndex)
     where
         C: DepGraphSafe + StableHashingContextProvider<'a>,
     {
         if let Some(ref data) = self.data {
             let task_deps = create_task(key).map(|deps| Lock::new(deps));
 
-            // In incremental mode, hash the result of the task. We don't
-            // do anything with the hash yet, but we are computing it
-            // anyway so that
-            //  - we make sure that the infrastructure works and
-            //  - we can get an idea of the runtime cost.
-            let mut hcx = cx.get_stable_hashing_context();
-
-            if cfg!(debug_assertions) {
-                profq_msg(hcx.sess(), ProfileQueriesMsg::TaskBegin(key.clone()))
-            };
+            let hcx = hash_result.as_ref().map(|_| {
+                let hcx = cx.get_stable_hashing_context();
+                if cfg!(debug_assertions) {
+                    profq_msg(hcx.sess(), ProfileQueriesMsg::TaskBegin(key.clone()))
+                };
+                hcx
+            });
 
             let result = if no_tcx {
                 task(cx, arg)
@@ -280,10 +278,12 @@ impl DepGraph {
             };
 
             if cfg!(debug_assertions) {
-                profq_msg(hcx.sess(), ProfileQueriesMsg::TaskEnd)
+                hcx.as_ref().map(|hcx| profq_msg(hcx.sess(), ProfileQueriesMsg::TaskEnd));
             };
 
-            let current_fingerprint = hash_result(&mut hcx, &result);
+            let current_fingerprint = hash_result.map(|hash_result| {
+                hash_result(&mut hcx.unwrap(), &result)
+            });
 
             let dep_node_index = finish_task_and_alloc_depnode(
                 &data.current,
@@ -292,7 +292,9 @@ impl DepGraph {
                 task_deps.map(|lock| lock.into_inner()),
             );
 
-            let print_status = cfg!(debug_assertions) && hcx.sess().opts.debugging_opts.dep_tasks;
+            let print_status = cfg!(debug_assertions) && ty::tls::with_opt(|tcx| {
+                tcx.map(|tcx| tcx.sess.opts.debugging_opts.dep_tasks).unwrap_or(false)
+            });
 
             // Determine the color of the new DepNode.
             if let Some(prev_index) = data.previous.node_to_index_opt(&key) {
@@ -379,7 +381,7 @@ impl DepGraph {
         cx: C,
         arg: A,
         task: fn(C, A) -> R,
-        hash_result: impl FnOnce(&mut StableHashingContext<'_>, &R) -> Option<Fingerprint>,
+        hash_result: Option<impl FnOnce(&mut StableHashingContext<'_>, &R) -> Fingerprint>,
     ) -> (R, DepNodeIndex)
     where
         C: DepGraphSafe + StableHashingContextProvider<'a>,

src/librustc/hir/def_id.rs

@@ -1,6 +1,7 @@
 use crate::ty::{self, TyCtxt};
 use crate::hir::map::definitions::FIRST_FREE_HIGH_DEF_INDEX;
 use rustc_data_structures::indexed_vec::Idx;
+use rustc_macros::HashStable;
 use serialize;
 use std::fmt;
 use std::u32;
@@ -96,6 +97,9 @@ impl fmt::Display for CrateNum {
 impl serialize::UseSpecializedEncodable for CrateNum {}
 impl serialize::UseSpecializedDecodable for CrateNum {}
 
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash, HashStable)]
+pub struct LocalCrate;
+
 /// A DefIndex is an index into the hir-map for a crate, identifying a
 /// particular definition. It should really be considered an interned
 /// shorthand for a particular DefPath.

src/librustc/hir/map/mod.rs

@@ -19,7 +19,6 @@ use crate::hir::itemlikevisit::ItemLikeVisitor;
 use crate::hir::print::Nested;
 use crate::util::nodemap::FxHashMap;
 use crate::util::common::time;
-use crate::ich::StableHashingContext;
 
 use std::io;
 use std::result::Result::Err;
@@ -1231,23 +1230,22 @@ impl Named for TraitItem { fn name(&self) -> Name { self.ident.name } }
 impl Named for ImplItem { fn name(&self) -> Name { self.ident.name } }
 
 pub fn map_crate<'tcx>(tcx: TyCtxt<'_, 'tcx, 'tcx>) -> Map<'tcx> {
+    // FIXME: Error handling here?
+    let hir = tcx.lowered_hir();
+
     // Build the reverse mapping of `node_to_hir_id`.
-    let hir_to_node_id = tcx.hir_defs.node_to_hir_id.iter_enumerated()
+    let hir_to_node_id = hir.defs.node_to_hir_id.iter_enumerated()
         .map(|(node_id, &hir_id)| (hir_id, node_id)).collect();
 
     let (map, crate_hash) = {
-        let krate = tcx.hir_forest.untracked_krate();
-        let hcx = StableHashingContext::new(
-            tcx.sess,
-            krate,
-            &tcx.hir_defs,
-            tcx.cstore
-        );
+        let hcx = tcx.create_stable_hashing_context();
+        let krate = hir.forest.untracked_krate();
+
         let mut collector = NodeCollector::root(
             tcx.sess,
             krate,
             &tcx.dep_graph,
-            &tcx.hir_defs,
+            &hir.defs,
             &hir_to_node_id,
             hcx
         );
@@ -1275,12 +1273,12 @@ pub fn map_crate<'tcx>(tcx: TyCtxt<'_, 'tcx, 'tcx>) -> Map<'tcx> {
     }
 
     let map = Map {
-        forest: &tcx.hir_forest,
+        forest: &hir.forest,
         dep_graph: tcx.dep_graph.clone(),
         crate_hash,
         map,
         hir_to_node_id,
-        definitions: &tcx.hir_defs,
+        definitions: &hir.defs,
     };
 
     time(tcx.sess, "validate hir map", || {

src/librustc/hir/mod.rs

@@ -12,7 +12,9 @@ pub use self::UnsafeSource::*;
 
 use crate::hir::def::Def;
 use crate::hir::def_id::{DefId, DefIndex, LocalDefId, CRATE_DEF_INDEX};
-use crate::util::nodemap::{NodeMap, FxHashSet};
+use crate::hir::map::definitions::DefPathHash;
+use crate::hir::def::Export;
+use crate::util::nodemap::NodeMap;
 use crate::mir::mono::Linkage;
 
 use errors::FatalError;
@@ -30,8 +32,10 @@ use syntax::util::parser::ExprPrecedence;
 use crate::ty::AdtKind;
 use crate::ty::query::Providers;
 
-use rustc_data_structures::sync::{par_for_each_in, Send, Sync};
+use rustc_data_structures::sync::{par_for_each_in, Lrc, Send, Sync};
 use rustc_data_structures::thin_vec::ThinVec;
+use rustc_data_structures::fx::{FxHashMap, FxHashSet};
+use rustc_data_structures::stable_hasher::StableVec;
 use rustc_macros::HashStable;
 
 use serialize::{self, Encoder, Encodable, Decoder, Decodable};
@@ -63,6 +67,40 @@ pub mod map;
 pub mod pat_util;
 pub mod print;
 
+pub struct LoweredHir {
+    pub forest: map::Forest,
+    pub defs: map::Definitions,
+
+    /// Export map produced by name resolution.
+    pub export_map: FxHashMap<DefId, Lrc<Vec<Export>>>,
+
+    // Records the free variables referenced by every closure
+    // expression. Do not track deps for this, just recompute it from
+    // scratch every time.
+    pub freevars: FxHashMap<DefId, Lrc<Vec<Freevar>>>,
+
+    pub maybe_unused_trait_imports: FxHashSet<DefId>,
+    pub maybe_unused_extern_crates: Vec<(DefId, Span)>,
+
+    /// A map of glob use to a set of names it actually imports. Currently only
+    /// used in save-analysis.
+    pub glob_map: FxHashMap<DefId, FxHashSet<ast::Name>>,
+    /// Extern prelude entries. The value is `true` if the entry was introduced
+    /// via `extern crate` item and not `--extern` option or compiler built-in.
+    pub extern_prelude: FxHashMap<ast::Name, bool>,
+
+    /// A map from DefPathHash -> DefId. Includes DefIds from the local crate
+    /// as well as all upstream crates. Only populated in incremental mode.
+    pub def_path_hash_to_def_id: Option<FxHashMap<DefPathHash, DefId>>,
+
+    /// Map indicating what traits are in scope for places where this
+    /// is relevant; generated by resolve.
+    pub trait_map: FxHashMap<DefIndex,
+                                    Lrc<FxHashMap<ItemLocalId,
+                                                  Lrc<StableVec<TraitCandidate>>>>>,
+
+}
+
 /// Uniquely identifies a node in the HIR of the current crate. It is
 /// composed of the `owner`, which is the `DefIndex` of the directly enclosing
 /// `hir::Item`, `hir::TraitItem`, or `hir::ImplItem` (i.e., the closest "item-like"),

src/librustc/query/mod.rs

@@ -3,7 +3,7 @@ use crate::ty::query::queries;
 use crate::ty::{self, ParamEnvAnd, Ty, TyCtxt};
 use crate::ty::subst::SubstsRef;
 use crate::dep_graph::SerializedDepNodeIndex;
-use crate::hir::def_id::{CrateNum, DefId, DefIndex};
+use crate::hir::def_id::{CrateNum, DefId, DefIndex, LocalCrate};
 use crate::mir::interpret::GlobalId;
 use crate::traits;
 use crate::traits::query::{
@@ -30,6 +30,18 @@ use syntax_pos::symbol::InternedString;
 // as they will raise an fatal error on query cycles instead.
 rustc_queries! {
     Other {
+        query prepare_outputs(_: LocalCrate) -> Result<Arc<OutputFilenames>, ErrorReported> {
+            no_hash
+            eval_always
+            desc { "preparing outputs" }
+        }
+
+        query lower_ast_to_hir(_: LocalCrate) -> Result<&'tcx hir::LoweredHir, ErrorReported> {
+            no_hash
+            eval_always
+            desc { "lowering AST to HIR" }
+        }
+
         query hir_map(_: CrateNum) -> &'tcx hir::map::Map<'tcx> {
             no_hash
             eval_always

src/librustc/session/config.rs

@@ -475,6 +475,15 @@ impl BorrowckMode {
     }
 }
 
+#[derive(Clone)]
+pub struct InputsAndOutputs {
+    pub input: Input,
+    pub input_path: Option<PathBuf>,
+    pub output_dir: Option<PathBuf>,
+    pub output_file: Option<PathBuf>,
+}
+
+#[derive(Clone)]
 pub enum Input {
     /// Loads source from file
     File(PathBuf),