Move ICH to rustc_crate.

Author: cjgillot

compiler/rustc_middle/src/ich/hcx.rs renamed to compiler/rustc_crate/src/ich/hcx.rs

@@ -1,23 +1,19 @@
+use crate::cstore::CrateStore;
 use crate::ich;
-use crate::ty::{fast_reject, TyCtxt};
-use rustc_crate::cstore::CrateStore;
 
 use rustc_ast as ast;
-use rustc_data_structures::fx::{FxHashMap, FxHashSet};
+use rustc_data_structures::fx::FxHashSet;
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
 use rustc_data_structures::sync::Lrc;
 use rustc_hir as hir;
 use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_hir::definitions::{DefPathHash, Definitions};
 use rustc_session::Session;
+use rustc_span::def_id::{CrateNum, CRATE_DEF_INDEX};
 use rustc_span::source_map::SourceMap;
 use rustc_span::symbol::Symbol;
 use rustc_span::{BytePos, CachingSourceMapView, SourceFile};
 
-use rustc_span::def_id::{CrateNum, CRATE_DEF_INDEX};
-use smallvec::SmallVec;
-use std::cmp::Ord;
-
 fn compute_ignored_attr_names() -> FxHashSet<Symbol> {
     debug_assert!(!ich::IGNORED_ATTRIBUTES.is_empty());
     ich::IGNORED_ATTRIBUTES.iter().copied().collect()
@@ -207,12 +203,6 @@ impl<'a, 'b, T: StableHashingContextProvider<'a>> StableHashingContextProvider<'
     }
 }
 
-impl StableHashingContextProvider<'tcx> for TyCtxt<'tcx> {
-    fn get_stable_hashing_context(&self) -> StableHashingContext<'tcx> {
-        (*self).create_stable_hashing_context()
-    }
-}
-
 impl<'a> StableHashingContextProvider<'a> for StableHashingContext<'a> {
     fn get_stable_hashing_context(&self) -> StableHashingContext<'a> {
         self.clone()
@@ -255,40 +245,14 @@ impl<'a> rustc_span::HashStableContext for StableHashingContext<'a> {
     }
 }
 
-impl<'a> rustc_crate::HashStableContext for StableHashingContext<'a> {}
+impl<'a> crate::HashStableContext for StableHashingContext<'a> {}
 
-pub fn hash_stable_trait_impls<'a>(
-    hcx: &mut StableHashingContext<'a>,
-    hasher: &mut StableHasher,
-    blanket_impls: &[DefId],
-    non_blanket_impls: &FxHashMap<fast_reject::SimplifiedType, Vec<DefId>>,
-) {
-    {
-        let mut blanket_impls: SmallVec<[_; 8]> =
-            blanket_impls.iter().map(|&def_id| hcx.def_path_hash(def_id)).collect();
+impl<'a> HashStable<StableHashingContext<'a>> for crate::privacy::AccessLevels {
+    fn hash_stable(&self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher) {
+        hcx.with_node_id_hashing_mode(NodeIdHashingMode::HashDefPath, |hcx| {
+            let crate::privacy::AccessLevels { ref map } = *self;
 
-        if blanket_impls.len() > 1 {
-            blanket_impls.sort_unstable();
-        }
-
-        blanket_impls.hash_stable(hcx, hasher);
-    }
-
-    {
-        let mut keys: SmallVec<[_; 8]> =
-            non_blanket_impls.keys().map(|k| (k, k.map_def(|d| hcx.def_path_hash(d)))).collect();
-        keys.sort_unstable_by(|&(_, ref k1), &(_, ref k2)| k1.cmp(k2));
-        keys.len().hash_stable(hcx, hasher);
-        for (key, ref stable_key) in keys {
-            stable_key.hash_stable(hcx, hasher);
-            let mut impls: SmallVec<[_; 8]> =
-                non_blanket_impls[key].iter().map(|&impl_id| hcx.def_path_hash(impl_id)).collect();
-
-            if impls.len() > 1 {
-                impls.sort_unstable();
-            }
-
-            impls.hash_stable(hcx, hasher);
-        }
+            map.hash_stable(hcx, hasher);
+        });
     }
 }

compiler/rustc_middle/src/ich/impls_hir.rs renamed to compiler/rustc_crate/src/ich/impls_hir.rs

@@ -0,0 +1,19 @@
+//! ICH - Incremental Compilation Hash
+
+pub use self::hcx::{NodeIdHashingMode, StableHashingContext, StableHashingContextProvider};
+use rustc_span::symbol::{sym, Symbol};
+
+mod hcx;
+mod impls_hir;
+mod impls_syntax;
+
+pub const IGNORED_ATTRIBUTES: &[Symbol] = &[
+    sym::cfg,
+    sym::rustc_if_this_changed,
+    sym::rustc_then_this_would_need,
+    sym::rustc_dirty,
+    sym::rustc_clean,
+    sym::rustc_partition_reused,
+    sym::rustc_partition_codegened,
+    sym::rustc_expected_cgu_reuse,
+];

compiler/rustc_middle/src/ich/impls_syntax.rs renamed to compiler/rustc_crate/src/ich/impls_syntax.rs

@@ -1,5 +1,7 @@
 #![feature(int_error_matching)]
+#![feature(min_specialization)]
 #![feature(once_cell)]
+#![feature(option_expect_none)]
 #![feature(or_patterns)]
 
 #[macro_use]
@@ -13,6 +15,7 @@ use rustc_span::symbol::Symbol;
 pub mod codegen_fn_attrs;
 pub mod cstore;
 pub mod dependency_format;
+pub mod ich;
 pub mod limits;
 pub mod privacy;
 pub mod stability;

compiler/rustc_crate/src/ich/mod.rs

@@ -1,7 +1,7 @@
 //! This module contains `HashStable` implementations for various data types
 //! from `rustc_middle::ty` in no particular order.
 
-use crate::ich::{NodeIdHashingMode, StableHashingContext};
+use crate::ich::StableHashingContext;
 use crate::middle::region;
 use crate::mir;
 use crate::ty;
@@ -183,13 +183,3 @@ impl<'a> HashStable<StableHashingContext<'a>> for ty::FloatVid {
         bug!("ty::TyKind::hash_stable() - can't hash a FloatVid {:?}.", *self)
     }
 }
-
-impl<'a> HashStable<StableHashingContext<'a>> for rustc_crate::privacy::AccessLevels {
-    fn hash_stable(&self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher) {
-        hcx.with_node_id_hashing_mode(NodeIdHashingMode::HashDefPath, |hcx| {
-            let rustc_crate::privacy::AccessLevels { ref map } = *self;
-
-            map.hash_stable(hcx, hasher);
-        });
-    }
-}

compiler/rustc_crate/src/lib.rs

@@ -1,23 +1,54 @@
 //! ICH - Incremental Compilation Hash
 
-pub use self::hcx::{
-    hash_stable_trait_impls, NodeIdHashingMode, StableHashingContext, StableHashingContextProvider,
-};
-use rustc_span::symbol::{sym, Symbol};
+use crate::ty::{fast_reject, TyCtxt};
+use rustc_data_structures::fx::FxHashMap;
+use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
+use rustc_hir::def_id::DefId;
+use smallvec::SmallVec;
+use std::cmp::Ord;
 
-mod hcx;
+pub use rustc_crate::ich::{NodeIdHashingMode, StableHashingContext, StableHashingContextProvider};
 
-mod impls_hir;
-mod impls_syntax;
 mod impls_ty;
 
-pub const IGNORED_ATTRIBUTES: &[Symbol] = &[
-    sym::cfg,
-    sym::rustc_if_this_changed,
-    sym::rustc_then_this_would_need,
-    sym::rustc_dirty,
-    sym::rustc_clean,
-    sym::rustc_partition_reused,
-    sym::rustc_partition_codegened,
-    sym::rustc_expected_cgu_reuse,
-];
+impl StableHashingContextProvider<'tcx> for TyCtxt<'tcx> {
+    fn get_stable_hashing_context(&self) -> StableHashingContext<'tcx> {
+        (*self).create_stable_hashing_context()
+    }
+}
+
+pub fn hash_stable_trait_impls<'a>(
+    hcx: &mut StableHashingContext<'a>,
+    hasher: &mut StableHasher,
+    blanket_impls: &[DefId],
+    non_blanket_impls: &FxHashMap<fast_reject::SimplifiedType, Vec<DefId>>,
+) {
+    {
+        let mut blanket_impls: SmallVec<[_; 8]> =
+            blanket_impls.iter().map(|&def_id| hcx.def_path_hash(def_id)).collect();
+
+        if blanket_impls.len() > 1 {
+            blanket_impls.sort_unstable();
+        }
+
+        blanket_impls.hash_stable(hcx, hasher);
+    }
+
+    {
+        let mut keys: SmallVec<[_; 8]> =
+            non_blanket_impls.keys().map(|k| (k, k.map_def(|d| hcx.def_path_hash(d)))).collect();
+        keys.sort_unstable_by(|&(_, ref k1), &(_, ref k2)| k1.cmp(k2));
+        keys.len().hash_stable(hcx, hasher);
+        for (key, ref stable_key) in keys {
+            stable_key.hash_stable(hcx, hasher);
+            let mut impls: SmallVec<[_; 8]> =
+                non_blanket_impls[key].iter().map(|&impl_id| hcx.def_path_hash(impl_id)).collect();
+
+            if impls.len() > 1 {
+                impls.sort_unstable();
+            }
+
+            impls.hash_stable(hcx, hasher);
+        }
+    }
+}