Remove rustc_hir reexports in rustc::hir.

Cargo.lock

@@ -3368,6 +3368,7 @@ dependencies = [
  "rustc_data_structures",
  "rustc_error_codes",
  "rustc_errors",
+ "rustc_hir",
  "rustc_index",
  "rustc_session",
  "rustc_span",
@@ -3411,6 +3412,7 @@ dependencies = [
  "rustc_expand",
  "rustc_feature",
  "rustc_fs_util",
+ "rustc_hir",
  "rustc_incremental",
  "rustc_index",
  "rustc_llvm",
@@ -3439,6 +3441,7 @@ dependencies = [
  "rustc_error_codes",
  "rustc_errors",
  "rustc_fs_util",
+ "rustc_hir",
  "rustc_incremental",
  "rustc_index",
  "rustc_session",
@@ -3458,6 +3461,7 @@ dependencies = [
  "rustc",
  "rustc-demangle",
  "rustc_data_structures",
+ "rustc_hir",
  "rustc_metadata",
  "rustc_span",
  "rustc_target",
@@ -3502,6 +3506,7 @@ dependencies = [
  "rustc_error_codes",
  "rustc_errors",
  "rustc_feature",
+ "rustc_hir",
  "rustc_interface",
  "rustc_lint",
  "rustc_metadata",
@@ -3590,6 +3595,7 @@ dependencies = [
  "rustc",
  "rustc_data_structures",
  "rustc_fs_util",
+ "rustc_hir",
  "rustc_session",
  "rustc_span",
  "serialize",
@@ -3656,6 +3662,7 @@ dependencies = [
  "rustc_data_structures",
  "rustc_error_codes",
  "rustc_feature",
+ "rustc_hir",
  "rustc_index",
  "rustc_session",
  "rustc_span",
@@ -3707,6 +3714,7 @@ dependencies = [
  "rustc_error_codes",
  "rustc_errors",
  "rustc_expand",
+ "rustc_hir",
  "rustc_index",
  "rustc_parse",
  "rustc_span",
@@ -3733,6 +3741,7 @@ dependencies = [
  "rustc_data_structures",
  "rustc_error_codes",
  "rustc_errors",
+ "rustc_hir",
  "rustc_index",
  "rustc_lexer",
  "rustc_macros",
@@ -3781,6 +3790,7 @@ dependencies = [
  "rustc_error_codes",
  "rustc_errors",
  "rustc_feature",
+ "rustc_hir",
  "rustc_index",
  "rustc_parse",
  "rustc_span",
@@ -3794,6 +3804,7 @@ version = "0.0.0"
 dependencies = [
  "rustc",
  "rustc_error_codes",
+ "rustc_hir",
  "rustc_metadata",
  "rustc_span",
  "syntax",
@@ -3807,6 +3818,7 @@ dependencies = [
  "rustc",
  "rustc_data_structures",
  "rustc_error_codes",
+ "rustc_hir",
  "rustc_span",
  "rustc_typeck",
  "syntax",
@@ -3826,6 +3838,7 @@ dependencies = [
  "rustc_errors",
  "rustc_expand",
  "rustc_feature",
+ "rustc_hir",
  "rustc_metadata",
  "rustc_session",
  "rustc_span",
@@ -3843,6 +3856,7 @@ dependencies = [
  "rustc",
  "rustc_codegen_utils",
  "rustc_data_structures",
+ "rustc_hir",
  "rustc_parse",
  "rustc_span",
  "serde_json",
@@ -3911,6 +3925,7 @@ dependencies = [
  "log",
  "rustc",
  "rustc_data_structures",
+ "rustc_hir",
  "rustc_macros",
  "rustc_span",
  "rustc_target",
@@ -3939,6 +3954,7 @@ dependencies = [
  "rustc_data_structures",
  "rustc_error_codes",
  "rustc_errors",
+ "rustc_hir",
  "rustc_index",
  "rustc_span",
  "rustc_target",

src/librustc/arena.rs

@@ -38,13 +38,13 @@ macro_rules! arena_types {
             [] tables: rustc::ty::TypeckTables<$tcx>,
             [] const_allocs: rustc::mir::interpret::Allocation,
             [] vtable_method: Option<(
-                rustc::hir::def_id::DefId,
+                rustc_hir::def_id::DefId,
                 rustc::ty::subst::SubstsRef<$tcx>
             )>,
-            [few, decode] mir_keys: rustc::hir::def_id::DefIdSet,
+            [few, decode] mir_keys: rustc_hir::def_id::DefIdSet,
             [decode] specialization_graph: rustc::traits::specialization_graph::Graph,
             [] region_scope_tree: rustc::middle::region::ScopeTree,
-            [] item_local_set: rustc::hir::ItemLocalSet,
+            [] item_local_set: rustc_hir::ItemLocalSet,
             [decode] mir_const_qualif: rustc_index::bit_set::BitSet<rustc::mir::Local>,
             [] trait_impls_of: rustc::ty::trait_def::TraitImpls,
             [] dropck_outlives:
@@ -87,75 +87,75 @@ macro_rules! arena_types {
                 >,
             [few] crate_inherent_impls: rustc::ty::CrateInherentImpls,
             [few] upstream_monomorphizations:
-                rustc::hir::def_id::DefIdMap<
+                rustc_hir::def_id::DefIdMap<
                     rustc_data_structures::fx::FxHashMap<
                         rustc::ty::subst::SubstsRef<'tcx>,
-                        rustc::hir::def_id::CrateNum
+                        rustc_hir::def_id::CrateNum
                     >
                 >,
             [few] diagnostic_items: rustc_data_structures::fx::FxHashMap<
                 rustc_span::symbol::Symbol,
-                rustc::hir::def_id::DefId,
+                rustc_hir::def_id::DefId,
             >,
             [few] resolve_lifetimes: rustc::middle::resolve_lifetime::ResolveLifetimes,
             [few] lint_levels: rustc::lint::LintLevelMap,
             [few] stability_index: rustc::middle::stability::Index<'tcx>,
             [few] features: rustc_feature::Features,
-            [few] all_traits: Vec<rustc::hir::def_id::DefId>,
+            [few] all_traits: Vec<rustc_hir::def_id::DefId>,
             [few] privacy_access_levels: rustc::middle::privacy::AccessLevels,
             [few] target_features_whitelist: rustc_data_structures::fx::FxHashMap<
                 String,
                 Option<rustc_span::symbol::Symbol>
             >,
             [few] wasm_import_module_map: rustc_data_structures::fx::FxHashMap<
-                rustc::hir::def_id::DefId,
+                rustc_hir::def_id::DefId,
                 String
             >,
             [few] get_lib_features: rustc::middle::lib_features::LibFeatures,
             [few] defined_lib_features: rustc::middle::lang_items::LanguageItems,
-            [few] visible_parent_map: rustc::hir::def_id::DefIdMap<rustc::hir::def_id::DefId>,
+            [few] visible_parent_map: rustc_hir::def_id::DefIdMap<rustc_hir::def_id::DefId>,
             [few] foreign_module: rustc::middle::cstore::ForeignModule,
             [few] foreign_modules: Vec<rustc::middle::cstore::ForeignModule>,
-            [few] reachable_non_generics: rustc::hir::def_id::DefIdMap<
+            [few] reachable_non_generics: rustc_hir::def_id::DefIdMap<
                 rustc::middle::exported_symbols::SymbolExportLevel
             >,
             [few] crate_variances: rustc::ty::CrateVariancesMap<'tcx>,
             [few] inferred_outlives_crate: rustc::ty::CratePredicatesMap<'tcx>,
-            [] upvars: rustc_data_structures::fx::FxIndexMap<rustc::hir::HirId, rustc::hir::Upvar>,
+            [] upvars: rustc_data_structures::fx::FxIndexMap<rustc_hir::HirId, rustc_hir::Upvar>,
 
             // HIR types
             [few] hir_forest: rustc::hir::map::Forest<$tcx>,
-            [] arm: rustc::hir::Arm<$tcx>,
+            [] arm: rustc_hir::Arm<$tcx>,
             [] attribute: syntax::ast::Attribute,
-            [] block: rustc::hir::Block<$tcx>,
-            [] bare_fn_ty: rustc::hir::BareFnTy<$tcx>,
-            [few] global_asm: rustc::hir::GlobalAsm,
-            [] generic_arg: rustc::hir::GenericArg<$tcx>,
-            [] generic_args: rustc::hir::GenericArgs<$tcx>,
-            [] generic_bound: rustc::hir::GenericBound<$tcx>,
-            [] generic_param: rustc::hir::GenericParam<$tcx>,
-            [] expr: rustc::hir::Expr<$tcx>,
-            [] field: rustc::hir::Field<$tcx>,
-            [] field_pat: rustc::hir::FieldPat<$tcx>,
-            [] fn_decl: rustc::hir::FnDecl<$tcx>,
-            [] foreign_item: rustc::hir::ForeignItem<$tcx>,
-            [] impl_item_ref: rustc::hir::ImplItemRef<$tcx>,
-            [] inline_asm: rustc::hir::InlineAsm<$tcx>,
-            [] local: rustc::hir::Local<$tcx>,
-            [few] macro_def: rustc::hir::MacroDef<$tcx>,
-            [] param: rustc::hir::Param<$tcx>,
-            [] pat: rustc::hir::Pat<$tcx>,
-            [] path: rustc::hir::Path<$tcx>,
-            [] path_segment: rustc::hir::PathSegment<$tcx>,
-            [] poly_trait_ref: rustc::hir::PolyTraitRef<$tcx>,
-            [] qpath: rustc::hir::QPath<$tcx>,
-            [] stmt: rustc::hir::Stmt<$tcx>,
-            [] struct_field: rustc::hir::StructField<$tcx>,
-            [] trait_item_ref: rustc::hir::TraitItemRef,
-            [] ty: rustc::hir::Ty<$tcx>,
-            [] type_binding: rustc::hir::TypeBinding<$tcx>,
-            [] variant: rustc::hir::Variant<$tcx>,
-            [] where_predicate: rustc::hir::WherePredicate<$tcx>,
+            [] block: rustc_hir::Block<$tcx>,
+            [] bare_fn_ty: rustc_hir::BareFnTy<$tcx>,
+            [few] global_asm: rustc_hir::GlobalAsm,
+            [] generic_arg: rustc_hir::GenericArg<$tcx>,
+            [] generic_args: rustc_hir::GenericArgs<$tcx>,
+            [] generic_bound: rustc_hir::GenericBound<$tcx>,
+            [] generic_param: rustc_hir::GenericParam<$tcx>,
+            [] expr: rustc_hir::Expr<$tcx>,
+            [] field: rustc_hir::Field<$tcx>,
+            [] field_pat: rustc_hir::FieldPat<$tcx>,
+            [] fn_decl: rustc_hir::FnDecl<$tcx>,
+            [] foreign_item: rustc_hir::ForeignItem<$tcx>,
+            [] impl_item_ref: rustc_hir::ImplItemRef<$tcx>,
+            [] inline_asm: rustc_hir::InlineAsm<$tcx>,
+            [] local: rustc_hir::Local<$tcx>,
+            [few] macro_def: rustc_hir::MacroDef<$tcx>,
+            [] param: rustc_hir::Param<$tcx>,
+            [] pat: rustc_hir::Pat<$tcx>,
+            [] path: rustc_hir::Path<$tcx>,
+            [] path_segment: rustc_hir::PathSegment<$tcx>,
+            [] poly_trait_ref: rustc_hir::PolyTraitRef<$tcx>,
+            [] qpath: rustc_hir::QPath<$tcx>,
+            [] stmt: rustc_hir::Stmt<$tcx>,
+            [] struct_field: rustc_hir::StructField<$tcx>,
+            [] trait_item_ref: rustc_hir::TraitItemRef,
+            [] ty: rustc_hir::Ty<$tcx>,
+            [] type_binding: rustc_hir::TypeBinding<$tcx>,
+            [] variant: rustc_hir::Variant<$tcx>,
+            [] where_predicate: rustc_hir::WherePredicate<$tcx>,
         ], $tcx);
     )
 }

src/librustc/dep_graph/dep_node.rs

@@ -49,13 +49,10 @@
 //! user of the `DepNode` API of having to know how to compute the expected
 //! fingerprint for a given set of node parameters.
 
-use crate::hir::def_id::{CrateNum, DefId, DefIndex, CRATE_DEF_INDEX};
 use crate::hir::map::DefPathHash;
-use crate::hir::HirId;
+use crate::ich::{Fingerprint, StableHashingContext};
 use crate::mir;
 use crate::mir::interpret::GlobalId;
-
-use crate::ich::{Fingerprint, StableHashingContext};
 use crate::traits;
 use crate::traits::query::{
     CanonicalPredicateGoal, CanonicalProjectionGoal, CanonicalTyGoal,
@@ -64,7 +61,10 @@ use crate::traits::query::{
 };
 use crate::ty::subst::SubstsRef;
 use crate::ty::{self, ParamEnvAnd, Ty, TyCtxt};
+
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
+use rustc_hir::def_id::{CrateNum, DefId, DefIndex, CRATE_DEF_INDEX};
+use rustc_hir::HirId;
 use rustc_span::symbol::Symbol;
 use std::fmt;
 use std::hash::Hash;

src/librustc/dep_graph/safe.rs

@@ -1,8 +1,9 @@
 //! The `DepGraphSafe` trait
 
-use crate::hir::def_id::DefId;
-use crate::hir::BodyId;
 use crate::ty::TyCtxt;
+
+use rustc_hir::def_id::DefId;
+use rustc_hir::BodyId;
 use syntax::ast::NodeId;
 
 /// The `DepGraphSafe` trait is used to specify what kinds of values

src/librustc/hir/check_attr.rs

@@ -4,15 +4,15 @@
 //! conflicts between multiple such attributes attached to the same
 //! item.
 
-use crate::hir::def_id::DefId;
 use crate::hir::intravisit::{self, NestedVisitorMap, Visitor};
-use crate::hir::DUMMY_HIR_ID;
-use crate::hir::{self, HirId, Item, ItemKind, TraitItem, TraitItemKind};
 use crate::lint::builtin::UNUSED_ATTRIBUTES;
 use crate::ty::query::Providers;
 use crate::ty::TyCtxt;
-
 use rustc_error_codes::*;
+use rustc_hir as hir;
+use rustc_hir::def_id::DefId;
+use rustc_hir::DUMMY_HIR_ID;
+use rustc_hir::{self, HirId, Item, ItemKind, TraitItem, TraitItemKind};
 use rustc_span::symbol::sym;
 use rustc_span::Span;
 use syntax::ast::Attribute;

src/librustc/hir/exports.rs

@@ -1,7 +1,7 @@
-use crate::hir::def::Res;
-use crate::hir::def_id::DefIdMap;
 use crate::ty;
 
+use rustc_hir::def::Res;
+use rustc_hir::def_id::DefIdMap;
 use rustc_macros::HashStable;
 use rustc_span::Span;
 use syntax::ast;

src/librustc/hir/intravisit.rs

@@ -31,10 +31,10 @@
 //! This order consistency is required in a few places in rustc, for
 //! example generator inference, and possibly also HIR borrowck.
 
-use crate::hir::itemlikevisit::{ItemLikeVisitor, ParItemLikeVisitor};
 use crate::hir::map::Map;
-use crate::hir::*;
 
+use rustc_hir::itemlikevisit::{ItemLikeVisitor, ParItemLikeVisitor};
+use rustc_hir::*;
 use rustc_span::Span;
 use syntax::ast::{Attribute, Ident, Label, Name};
 

src/librustc/hir/map/blocks.rs

@@ -11,10 +11,10 @@
 //! nested within a uniquely determined `FnLike`), and users can ask
 //! for the `Code` associated with a particular NodeId.
 
-use crate::hir as ast;
 use crate::hir::intravisit::FnKind;
 use crate::hir::map;
-use crate::hir::{Expr, FnDecl, Node};
+use rustc_hir as ast;
+use rustc_hir::{Expr, FnDecl, Node};
 use rustc_span::Span;
 use syntax::ast::{Attribute, Ident};
 

src/librustc/hir/map/collector.rs

@@ -1,13 +1,13 @@
 use super::*;
 use crate::dep_graph::{DepGraph, DepKind, DepNodeIndex};
-use crate::hir;
-use crate::hir::def_id::{CrateNum, DefIndex, LOCAL_CRATE};
 use crate::hir::intravisit::{NestedVisitorMap, Visitor};
 use crate::hir::map::HirEntryMap;
 use crate::ich::Fingerprint;
 use crate::middle::cstore::CrateStore;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::svh::Svh;
+use rustc_hir as hir;
+use rustc_hir::def_id::{CrateNum, DefIndex, LOCAL_CRATE};
 use rustc_index::vec::IndexVec;
 use rustc_session::{CrateDisambiguator, Session};
 use rustc_span::source_map::SourceMap;
@@ -268,7 +268,7 @@ impl<'a, 'hir> NodeCollector<'a, 'hir> {
                     None => format!("{:?}", node),
                 };
 
-                let forgot_str = if hir_id == crate::hir::DUMMY_HIR_ID {
+                let forgot_str = if hir_id == hir::DUMMY_HIR_ID {
                     format!("\nMaybe you forgot to lower the node id {:?}?", node_id)
                 } else {
                     String::new()

src/librustc/hir/map/definitions.rs

@@ -4,12 +4,11 @@
 //! There are also some rather random cases (like const initializer
 //! expressions) that are mostly just leftovers.
 
-use crate::hir;
-use crate::hir::def_id::{CrateNum, DefId, DefIndex, CRATE_DEF_INDEX, LOCAL_CRATE};
 use crate::ich::Fingerprint;
-
 use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::stable_hasher::StableHasher;
+use rustc_hir as hir;
+use rustc_hir::def_id::{CrateNum, DefId, DefIndex, CRATE_DEF_INDEX, LOCAL_CRATE};
 use rustc_index::vec::IndexVec;
 use rustc_session::node_id::NodeMap;
 use rustc_session::CrateDisambiguator;

src/librustc/hir/map/hir_id_validator.rs

@@ -1,10 +1,13 @@
-use crate::hir::def_id::{DefId, DefIndex, CRATE_DEF_INDEX};
-use crate::hir::itemlikevisit::ItemLikeVisitor;
-use crate::hir::{self, intravisit, HirId, ItemLocalId};
+use crate::hir::intravisit;
+use crate::hir::map::Map;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_data_structures::sync::{par_iter, Lock, ParallelIterator};
+use rustc_hir as hir;
+use rustc_hir::def_id::{DefId, DefIndex, CRATE_DEF_INDEX};
+use rustc_hir::itemlikevisit::ItemLikeVisitor;
+use rustc_hir::{HirId, ItemLocalId};
 
-pub fn check_crate(hir_map: &hir::map::Map<'_>) {
+pub fn check_crate(hir_map: &Map<'_>) {
     hir_map.dep_graph.assert_ignored();
 
     let errors = Lock::new(Vec::new());
@@ -26,19 +29,19 @@ pub fn check_crate(hir_map: &hir::map::Map<'_>) {
 }
 
 struct HirIdValidator<'a, 'hir> {
-    hir_map: &'a hir::map::Map<'hir>,
+    hir_map: &'a Map<'hir>,
     owner_def_index: Option<DefIndex>,
     hir_ids_seen: FxHashSet<ItemLocalId>,
     errors: &'a Lock<Vec<String>>,
 }
 
 struct OuterVisitor<'a, 'hir> {
-    hir_map: &'a hir::map::Map<'hir>,
+    hir_map: &'a Map<'hir>,
     errors: &'a Lock<Vec<String>>,
 }
 
 impl<'a, 'hir> OuterVisitor<'a, 'hir> {
-    fn new_inner_visitor(&self, hir_map: &'a hir::map::Map<'hir>) -> HirIdValidator<'a, 'hir> {
+    fn new_inner_visitor(&self, hir_map: &'a Map<'hir>) -> HirIdValidator<'a, 'hir> {
         HirIdValidator {
             hir_map,
             owner_def_index: None,

src/librustc/hir/map/mod.rs

@@ -4,15 +4,16 @@ pub use self::definitions::{
 };
 
 use crate::dep_graph::{DepGraph, DepKind, DepNode, DepNodeIndex};
-use crate::hir::def::{DefKind, Res};
-use crate::hir::def_id::{DefId, DefIndex, LocalDefId, CRATE_DEF_INDEX};
-use crate::hir::itemlikevisit::ItemLikeVisitor;
-use crate::hir::print::Nested;
-use crate::hir::*;
+use crate::hir::intravisit;
 use crate::middle::cstore::CrateStoreDyn;
 use crate::ty::query::Providers;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::svh::Svh;
+use rustc_hir::def::{DefKind, Res};
+use rustc_hir::def_id::{DefId, DefIndex, LocalDefId, CRATE_DEF_INDEX};
+use rustc_hir::itemlikevisit::ItemLikeVisitor;
+use rustc_hir::print::Nested;
+use rustc_hir::*;
 use rustc_index::vec::IndexVec;
 use rustc_span::hygiene::MacroKind;
 use rustc_span::source_map::Spanned;

src/librustc/hir/mod.rs

@@ -8,8 +8,6 @@ pub mod intravisit;
 pub mod map;
 pub mod upvars;
 
-pub use rustc_hir::*;
-
 use crate::ty::query::Providers;
 
 pub fn provide(providers: &mut Providers<'_>) {

src/librustc/hir/upvars.rs

@@ -1,11 +1,12 @@
 //! Upvar (closure capture) collection from cross-body HIR uses of `Res::Local`s.
 
-use crate::hir::def::Res;
 use crate::hir::intravisit::{self, NestedVisitorMap, Visitor};
-use crate::hir::{self, HirId};
 use crate::ty::query::Providers;
 use crate::ty::TyCtxt;
 use rustc_data_structures::fx::{FxHashSet, FxIndexMap};
+use rustc_hir as hir;
+use rustc_hir::def::Res;
+use rustc_hir::{self, HirId};
 use rustc_span::Span;
 
 pub fn provide(providers: &mut Providers<'_>) {

src/librustc/ich/hcx.rs

@@ -1,5 +1,3 @@
-use crate::hir;
-use crate::hir::def_id::{DefId, DefIndex};
 use crate::hir::map::definitions::Definitions;
 use crate::hir::map::DefPathHash;
 use crate::ich::{self, CachingSourceMapView};
@@ -7,17 +5,18 @@ use crate::middle::cstore::CrateStore;
 use crate::session::Session;
 use crate::ty::{fast_reject, TyCtxt};
 
-use std::cmp::Ord;
-
+use rustc_data_structures::fx::{FxHashMap, FxHashSet};
+use rustc_data_structures::stable_hasher::{HashStable, StableHasher, ToStableHashKey};
+use rustc_data_structures::sync::Lrc;
+use rustc_hir as hir;
+use rustc_hir::def_id::{DefId, DefIndex};
 use rustc_span::source_map::SourceMap;
 use rustc_span::symbol::Symbol;
 use rustc_span::{BytePos, SourceFile};
 use syntax::ast;
 
-use rustc_data_structures::fx::{FxHashMap, FxHashSet};
-use rustc_data_structures::stable_hasher::{HashStable, StableHasher, ToStableHashKey};
-use rustc_data_structures::sync::Lrc;
 use smallvec::SmallVec;
+use std::cmp::Ord;
 
 fn compute_ignored_attr_names() -> FxHashSet<Symbol> {
     debug_assert!(ich::IGNORED_ATTRIBUTES.len() > 0);

src/librustc/ich/impls_hir.rs

@@ -1,12 +1,11 @@
 //! This module contains `HashStable` implementations for various HIR data
 //! types in no particular order.
 
-use crate::hir;
-use crate::hir::def_id::{CrateNum, DefId, LocalDefId, CRATE_DEF_INDEX};
 use crate::hir::map::DefPathHash;
 use crate::ich::{Fingerprint, NodeIdHashingMode, StableHashingContext};
-
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher, ToStableHashKey};
+use rustc_hir as hir;
+use rustc_hir::def_id::{CrateNum, DefId, LocalDefId, CRATE_DEF_INDEX};
 use smallvec::SmallVec;
 use std::mem;
 use syntax::attr;

src/librustc/ich/impls_syntax.rs

@@ -3,12 +3,11 @@
 
 use crate::ich::StableHashingContext;
 
+use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
+use rustc_hir::def_id::{CrateNum, DefId, CRATE_DEF_INDEX};
 use rustc_span::SourceFile;
 use syntax::ast;
 
-use crate::hir::def_id::{CrateNum, DefId, CRATE_DEF_INDEX};
-
-use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
 use smallvec::SmallVec;
 
 impl<'ctx> rustc_target::HashStableContext for StableHashingContext<'ctx> {}

src/librustc/infer/combine.rs

@@ -32,7 +32,6 @@ use super::unify_key::{ConstVarValue, ConstVariableValue};
 use super::unify_key::{ConstVariableOrigin, ConstVariableOriginKind};
 use super::{InferCtxt, MiscVariable, TypeTrace};
 
-use crate::hir::def_id::DefId;
 use crate::traits::{Obligation, PredicateObligations};
 use crate::ty::error::TypeError;
 use crate::ty::relate::{self, Relate, RelateResult, TypeRelation};
@@ -40,6 +39,7 @@ use crate::ty::subst::SubstsRef;
 use crate::ty::{self, InferConst, Ty, TyCtxt};
 use crate::ty::{IntType, UintType};
 
+use rustc_hir::def_id::DefId;
 use rustc_span::{Span, DUMMY_SP};
 use syntax::ast;
 

src/librustc/infer/equate.rs

@@ -1,13 +1,13 @@
 use super::combine::{CombineFields, RelationDir};
 use super::Subtype;
 
-use crate::hir::def_id::DefId;
-
 use crate::ty::relate::{self, Relate, RelateResult, TypeRelation};
 use crate::ty::subst::SubstsRef;
 use crate::ty::TyVar;
 use crate::ty::{self, Ty, TyCtxt};
 
+use rustc_hir::def_id::DefId;
+
 /// Ensures `a` is made equal to `b`. Returns `a` on success.
 pub struct Equate<'combine, 'infcx, 'tcx> {
     fields: &'combine mut CombineFields<'infcx, 'tcx>,

src/librustc/infer/error_reporting/mod.rs

@@ -49,9 +49,7 @@ use super::lexical_region_resolve::RegionResolutionError;
 use super::region_constraints::GenericKind;
 use super::{InferCtxt, RegionVariableOrigin, SubregionOrigin, TypeTrace, ValuePairs};
 
-use crate::hir;
-use crate::hir::def_id::DefId;
-use crate::hir::Node;
+use crate::hir::map;
 use crate::infer::opaque_types;
 use crate::infer::{self, SuppressRegionErrors};
 use crate::middle::region;
@@ -64,6 +62,9 @@ use crate::ty::{
     subst::{Subst, SubstsRef},
     Region, Ty, TyCtxt, TypeFoldable,
 };
+use rustc_hir as hir;
+use rustc_hir::def_id::DefId;
+use rustc_hir::Node;
 
 use errors::{Applicability, DiagnosticBuilder, DiagnosticStyledString};
 use rustc_error_codes::*;
@@ -455,7 +456,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
         terr: &TypeError<'tcx>,
     ) {
         use hir::def_id::CrateNum;
-        use hir::map::DisambiguatedDefPathData;
+        use map::DisambiguatedDefPathData;
         use ty::print::Printer;
         use ty::subst::GenericArg;
 
@@ -851,7 +852,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
         sig2: &ty::PolyFnSig<'tcx>,
     ) -> (DiagnosticStyledString, DiagnosticStyledString) {
         let get_lifetimes = |sig| {
-            use crate::hir::def::Namespace;
+            use rustc_hir::def::Namespace;
             let mut s = String::new();
             let (_, (sig, reg)) = ty::print::FmtPrinter::new(self.tcx, &mut s, Namespace::TypeNS)
                 .name_all_regions(sig)

src/librustc/infer/error_reporting/need_type_info.rs

@@ -1,11 +1,13 @@
-use crate::hir::def::{DefKind, Namespace};
 use crate::hir::intravisit::{self, NestedVisitorMap, Visitor};
-use crate::hir::{self, Body, Expr, ExprKind, FunctionRetTy, HirId, Local, Pat};
+use crate::hir::map::Map;
 use crate::infer::type_variable::TypeVariableOriginKind;
 use crate::infer::InferCtxt;
 use crate::ty::print::Print;
 use crate::ty::{self, DefIdTree, Infer, Ty, TyVar};
 use errors::{Applicability, DiagnosticBuilder};
+use rustc_hir as hir;
+use rustc_hir::def::{DefKind, Namespace};
+use rustc_hir::{Body, Expr, ExprKind, FunctionRetTy, HirId, Local, Pat};
 use rustc_span::source_map::DesugaringKind;
 use rustc_span::symbol::kw;
 use rustc_span::Span;
@@ -16,7 +18,7 @@ use rustc_error_codes::*;
 struct FindLocalByTypeVisitor<'a, 'tcx> {
     infcx: &'a InferCtxt<'a, 'tcx>,
     target_ty: Ty<'tcx>,
-    hir_map: &'a hir::map::Map<'tcx>,
+    hir_map: &'a Map<'tcx>,
     found_local_pattern: Option<&'tcx Pat<'tcx>>,
     found_arg_pattern: Option<&'tcx Pat<'tcx>>,
     found_ty: Option<Ty<'tcx>>,
@@ -25,11 +27,7 @@ struct FindLocalByTypeVisitor<'a, 'tcx> {
 }
 
 impl<'a, 'tcx> FindLocalByTypeVisitor<'a, 'tcx> {
-    fn new(
-        infcx: &'a InferCtxt<'a, 'tcx>,
-        target_ty: Ty<'tcx>,
-        hir_map: &'a hir::map::Map<'tcx>,
-    ) -> Self {
+    fn new(infcx: &'a InferCtxt<'a, 'tcx>, target_ty: Ty<'tcx>, hir_map: &'a Map<'tcx>) -> Self {
         Self {
             infcx,
             target_ty,

src/librustc/infer/error_reporting/nice_region_error/find_anon_type.rs

@@ -1,9 +1,9 @@
-use crate::hir;
 use crate::hir::intravisit::{self, NestedVisitorMap, Visitor};
-use crate::hir::Node;
 use crate::infer::error_reporting::nice_region_error::NiceRegionError;
 use crate::middle::resolve_lifetime as rl;
 use crate::ty::{self, Region, TyCtxt};
+use rustc_hir as hir;
+use rustc_hir::Node;
 
 impl<'a, 'tcx> NiceRegionError<'a, 'tcx> {
     /// This function calls the `visit_ty` method for the parameters

src/librustc/infer/error_reporting/nice_region_error/named_anon_conflict.rs

@@ -1,9 +1,9 @@
 //! Error Reporting for Anonymous Region Lifetime Errors
 //! where one region is named and the other is anonymous.
-use crate::hir::{FunctionRetTy, TyKind};
 use crate::infer::error_reporting::nice_region_error::NiceRegionError;
 use crate::ty;
 use errors::{Applicability, DiagnosticBuilder};
+use rustc_hir::{FunctionRetTy, TyKind};
 
 use rustc_error_codes::*;
 

src/librustc/infer/error_reporting/nice_region_error/outlives_closure.rs

@@ -1,13 +1,12 @@
 //! Error Reporting for Anonymous Region Lifetime Errors
 //! where both the regions are anonymous.
 
-use crate::hir::Node;
-use crate::hir::{Expr, ExprKind::Closure};
 use crate::infer::error_reporting::nice_region_error::NiceRegionError;
 use crate::infer::lexical_region_resolve::RegionResolutionError::SubSupConflict;
 use crate::infer::SubregionOrigin;
 use crate::ty::RegionKind;
 use crate::util::common::ErrorReported;
+use rustc_hir::{Expr, ExprKind::Closure, Node};
 
 impl<'a, 'tcx> NiceRegionError<'a, 'tcx> {
     /// Print the error message for lifetime errors when binding escapes a closure.

src/librustc/infer/error_reporting/nice_region_error/placeholder_error.rs

@@ -1,5 +1,3 @@
-use crate::hir::def::Namespace;
-use crate::hir::def_id::DefId;
 use crate::infer::error_reporting::nice_region_error::NiceRegionError;
 use crate::infer::lexical_region_resolve::RegionResolutionError;
 use crate::infer::ValuePairs;
@@ -10,6 +8,8 @@ use crate::ty::print::{FmtPrinter, Print, RegionHighlightMode};
 use crate::ty::subst::SubstsRef;
 use crate::ty::{self, TyCtxt};
 use errors::DiagnosticBuilder;
+use rustc_hir::def::Namespace;
+use rustc_hir::def_id::DefId;
 
 use std::fmt::{self, Write};
 

src/librustc/infer/error_reporting/nice_region_error/util.rs

@@ -1,10 +1,10 @@
 //! Helper functions corresponding to lifetime errors due to
 //! anonymous regions.
 
-use crate::hir;
-use crate::hir::def_id::DefId;
 use crate::infer::error_reporting::nice_region_error::NiceRegionError;
 use crate::ty::{self, DefIdTree, Region, Ty};
+use rustc_hir as hir;
+use rustc_hir::def_id::DefId;
 use rustc_span::Span;
 
 // The struct contains the information about the anonymous region

src/librustc/infer/lexical_region_resolve/graphviz.rs

@@ -9,13 +9,13 @@
 use graphviz as dot;
 
 use super::Constraint;
-use crate::hir::def_id::DefIndex;
 use crate::infer::region_constraints::RegionConstraintData;
 use crate::infer::SubregionOrigin;
 use crate::middle::free_region::RegionRelations;
 use crate::middle::region;
 use crate::ty;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
+use rustc_hir::def_id::DefIndex;
 
 use std::borrow::Cow;
 use std::collections::btree_map::BTreeMap;

src/librustc/infer/lexical_region_resolve/mod.rs

@@ -1,6 +1,5 @@
 //! Lexical region resolution.
 
-use crate::hir::def_id::DefId;
 use crate::infer::region_constraints::Constraint;
 use crate::infer::region_constraints::GenericKind;
 use crate::infer::region_constraints::MemberConstraint;
@@ -19,6 +18,7 @@ use rustc_data_structures::fx::FxHashSet;
 use rustc_data_structures::graph::implementation::{
     Direction, Graph, NodeIndex, INCOMING, OUTGOING,
 };
+use rustc_hir::def_id::DefId;
 use rustc_index::bit_set::BitSet;
 use rustc_index::vec::{Idx, IndexVec};
 use rustc_span::Span;

src/librustc/infer/mod.rs

@@ -7,8 +7,6 @@ pub use self::SubregionOrigin::*;
 pub use self::ValuePairs::*;
 pub use crate::ty::IntVarValue;
 
-use crate::hir;
-use crate::hir::def_id::DefId;
 use crate::infer::canonical::{Canonical, CanonicalVarValues};
 use crate::infer::unify_key::{ConstVarValue, ConstVariableValue};
 use crate::middle::free_region::RegionRelations;
@@ -27,6 +25,8 @@ use errors::DiagnosticBuilder;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_data_structures::sync::Lrc;
 use rustc_data_structures::unify as ut;
+use rustc_hir as hir;
+use rustc_hir::def_id::DefId;
 use rustc_span::symbol::Symbol;
 use rustc_span::Span;
 use std::cell::{Cell, Ref, RefCell, RefMut};

src/librustc/infer/opaque_types/mod.rs

@@ -1,6 +1,3 @@
-use crate::hir;
-use crate::hir::def_id::{DefId, DefIdMap};
-use crate::hir::Node;
 use crate::infer::outlives::free_region_map::FreeRegionRelations;
 use crate::infer::{self, InferCtxt, InferOk, TypeVariableOrigin, TypeVariableOriginKind};
 use crate::middle::region;
@@ -12,6 +9,9 @@ use errors::DiagnosticBuilder;
 use rustc::session::config::nightly_options;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::sync::Lrc;
+use rustc_hir as hir;
+use rustc_hir::def_id::{DefId, DefIdMap};
+use rustc_hir::Node;
 use rustc_span::Span;
 
 use rustc_error_codes::*;

src/librustc/infer/outlives/env.rs

@@ -1,9 +1,9 @@
-use crate::hir;
 use crate::infer::outlives::free_region_map::FreeRegionMap;
 use crate::infer::{GenericKind, InferCtxt};
 use crate::traits::query::outlives_bounds::{self, OutlivesBound};
 use crate::ty::{self, Ty};
 use rustc_data_structures::fx::FxHashMap;
+use rustc_hir as hir;
 use rustc_span::Span;
 
 /// The `OutlivesEnvironment` collects information about what outlives

src/librustc/infer/outlives/obligations.rs

@@ -59,7 +59,6 @@
 //! might later infer `?U` to something like `&'b u32`, which would
 //! imply that `'b: 'a`.
 
-use crate::hir;
 use crate::infer::outlives::env::RegionBoundPairs;
 use crate::infer::outlives::verify::VerifyBoundCx;
 use crate::infer::{self, GenericKind, InferCtxt, RegionObligation, SubregionOrigin, VerifyBound};
@@ -68,6 +67,7 @@ use crate::ty::outlives::Component;
 use crate::ty::subst::GenericArgKind;
 use crate::ty::{self, Region, Ty, TyCtxt, TypeFoldable};
 use rustc_data_structures::fx::FxHashMap;
+use rustc_hir as hir;
 
 impl<'cx, 'tcx> InferCtxt<'cx, 'tcx> {
     /// Registers that the given region obligation must be resolved

src/librustc/infer/outlives/verify.rs

@@ -1,10 +1,10 @@
-use crate::hir::def_id::DefId;
 use crate::infer::outlives::env::RegionBoundPairs;
 use crate::infer::{GenericKind, VerifyBound};
 use crate::traits;
 use crate::ty::subst::{InternalSubsts, Subst};
 use crate::ty::{self, Ty, TyCtxt};
 use crate::util::captures::Captures;
+use rustc_hir::def_id::DefId;
 
 /// The `TypeOutlives` struct has the job of "lowering" a `T: 'a`
 /// obligation into a series of `'a: 'b` constraints and "verifys", as

src/librustc/infer/region_constraints/mod.rs

@@ -6,7 +6,6 @@ use self::UndoLog::*;
 use super::unify_key;
 use super::{MiscVariable, RegionVariableOrigin, SubregionOrigin};
 
-use crate::hir::def_id::DefId;
 use crate::ty::ReStatic;
 use crate::ty::{self, Ty, TyCtxt};
 use crate::ty::{ReLateBound, ReVar};
@@ -14,6 +13,7 @@ use crate::ty::{Region, RegionVid};
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_data_structures::sync::Lrc;
 use rustc_data_structures::unify as ut;
+use rustc_hir::def_id::DefId;
 use rustc_index::vec::IndexVec;
 use rustc_span::Span;
 

src/librustc/infer/type_variable.rs

@@ -1,5 +1,5 @@
-use crate::hir::def_id::DefId;
 use crate::ty::{self, Ty, TyVid};
+use rustc_hir::def_id::DefId;
 use rustc_span::symbol::Symbol;
 use rustc_span::Span;
 

src/librustc/lint/context.rs

@@ -16,8 +16,6 @@
 
 use self::TargetLint::*;
 
-use crate::hir;
-use crate::hir::def_id::{CrateNum, DefId};
 use crate::hir::map::{definitions::DisambiguatedDefPathData, DefPathData};
 use crate::lint::builtin::BuiltinLintDiagnostics;
 use crate::lint::levels::{LintLevelSets, LintLevelsBuilder};
@@ -30,6 +28,8 @@ use crate::ty::{self, print::Printer, subst::GenericArg, Ty, TyCtxt};
 use errors::DiagnosticBuilder;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::sync;
+use rustc_hir as hir;
+use rustc_hir::def_id::{CrateNum, DefId};
 use rustc_span::{symbol::Symbol, MultiSpan, Span};
 use std::slice;
 use syntax::ast;

src/librustc/lint/internal.rs

@@ -1,12 +1,12 @@
 //! Some lints that are only useful in the compiler or crates that use compiler internals, such as
 //! Clippy.
 
-use crate::hir::{GenericArg, HirId, MutTy, Mutability, Path, PathSegment, QPath, Ty, TyKind};
 use crate::lint::{
     EarlyContext, EarlyLintPass, LateContext, LateLintPass, LintArray, LintContext, LintPass,
 };
 use errors::Applicability;
 use rustc_data_structures::fx::FxHashMap;
+use rustc_hir::{GenericArg, HirId, MutTy, Mutability, Path, PathSegment, QPath, Ty, TyKind};
 use rustc_session::declare_tool_lint;
 use rustc_span::symbol::{sym, Symbol};
 use syntax::ast::{Ident, Item, ItemKind};

src/librustc/lint/levels.rs

@@ -1,6 +1,5 @@
 use std::cmp;
 
-use crate::hir::HirId;
 use crate::ich::StableHashingContext;
 use crate::lint::builtin;
 use crate::lint::context::{CheckLintNameResult, LintStore};
@@ -9,6 +8,7 @@ use crate::session::Session;
 use errors::{Applicability, DiagnosticBuilder};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
+use rustc_hir::HirId;
 use rustc_span::source_map::MultiSpan;
 use rustc_span::symbol::{sym, Symbol};
 use syntax::ast;

src/librustc/lint/mod.rs

@@ -23,10 +23,10 @@ pub use self::LintSource::*;
 
 use rustc_data_structures::sync;
 
-use crate::hir;
 use crate::lint::builtin::BuiltinLintDiagnostics;
 use crate::ty::TyCtxt;
 use errors::{DiagnosticBuilder, DiagnosticId};
+use rustc_hir as hir;
 use rustc_session::node_id::NodeMap;
 use rustc_session::{DiagnosticMessageId, Session};
 use rustc_span::hygiene::MacroKind;
@@ -109,13 +109,13 @@ macro_rules! late_lint_methods {
             fn check_where_predicate(a: &$hir hir::WherePredicate<$hir>);
             fn check_poly_trait_ref(a: &$hir hir::PolyTraitRef<$hir>, b: hir::TraitBoundModifier);
             fn check_fn(
-                a: hir::intravisit::FnKind<$hir>,
+                a: $crate::hir::intravisit::FnKind<$hir>,
                 b: &$hir hir::FnDecl<$hir>,
                 c: &$hir hir::Body<$hir>,
                 d: Span,
                 e: hir::HirId);
             fn check_fn_post(
-                a: hir::intravisit::FnKind<$hir>,
+                a: $crate::hir::intravisit::FnKind<$hir>,
                 b: &$hir hir::FnDecl<$hir>,
                 c: &$hir hir::Body<$hir>,
                 d: Span,

src/librustc/middle/cstore.rs

@@ -2,15 +2,15 @@
 //! are *mostly* used as a part of that interface, but these should
 //! probably get a better home if someone can find one.
 
-use crate::hir::def_id::{CrateNum, DefId, LOCAL_CRATE};
 use crate::hir::map as hir_map;
 use crate::hir::map::definitions::{DefKey, DefPathTable};
 use crate::session::search_paths::PathKind;
 use crate::session::{CrateDisambiguator, Session};
 use crate::ty::{self, TyCtxt};
-use rustc_data_structures::svh::Svh;
 
+use rustc_data_structures::svh::Svh;
 use rustc_data_structures::sync::{self, MetadataRef};
+use rustc_hir::def_id::{CrateNum, DefId, LOCAL_CRATE};
 use rustc_macros::HashStable;
 use rustc_span::symbol::Symbol;
 use rustc_span::Span;

src/librustc/middle/exported_symbols.rs

@@ -1,8 +1,8 @@
-use crate::hir::def_id::{DefId, LOCAL_CRATE};
 use crate::ich::StableHashingContext;
 use crate::ty::subst::SubstsRef;
 use crate::ty::{self, TyCtxt};
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
+use rustc_hir::def_id::{DefId, LOCAL_CRATE};
 use std::cmp;
 use std::mem;
 

src/librustc/middle/free_region.rs

@@ -3,10 +3,10 @@
 //! or explicit bounds. In that case, we track the bounds using the `TransitiveRelation` type,
 //! and use that to decide when one free region outlives another, and so forth.
 
-use crate::hir::def_id::DefId;
 use crate::infer::outlives::free_region_map::{FreeRegionMap, FreeRegionRelations};
 use crate::middle::region;
 use crate::ty::{self, Region, TyCtxt};
+use rustc_hir::def_id::DefId;
 
 /// Combines a `region::ScopeTree` (which governs relationships between
 /// scopes) and a `FreeRegionMap` (which governs relationships between

src/librustc/middle/lang_items.rs

@@ -9,15 +9,15 @@
 
 pub use self::LangItem::*;
 
-use crate::hir;
 use crate::hir::check_attr::Target;
-use crate::hir::def_id::DefId;
-use crate::hir::itemlikevisit::ItemLikeVisitor;
 use crate::middle::cstore::ExternCrate;
 use crate::middle::weak_lang_items;
 use crate::ty::{self, TyCtxt};
 
 use rustc_data_structures::fx::FxHashMap;
+use rustc_hir as hir;
+use rustc_hir::def_id::DefId;
+use rustc_hir::itemlikevisit::ItemLikeVisitor;
 use rustc_macros::HashStable;
 use rustc_span::symbol::{sym, Symbol};
 use rustc_span::Span;

src/librustc/middle/privacy.rs

@@ -2,10 +2,9 @@
 //! outside their scopes. This pass will also generate a set of exported items
 //! which are available for use externally when compiled as a library.
 
-use crate::hir::def_id::DefIdSet;
-use crate::hir::HirId;
-
 use rustc_data_structures::fx::FxHashMap;
+use rustc_hir::def_id::DefIdSet;
+use rustc_hir::HirId;
 use rustc_macros::HashStable;
 use std::fmt;
 use std::hash::Hash;

src/librustc/middle/region.rs

@@ -6,11 +6,11 @@
 //!
 //! [rustc guide]: https://rust-lang.github.io/rustc-guide/mir/borrowck.html
 
-use crate::hir;
-use crate::hir::def_id::DefId;
-use crate::hir::Node;
 use crate::ich::{NodeIdHashingMode, StableHashingContext};
 use crate::ty::{self, DefIdTree, TyCtxt};
+use rustc_hir as hir;
+use rustc_hir::def_id::DefId;
+use rustc_hir::Node;
 
 use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};

src/librustc/middle/resolve_lifetime.rs

@@ -1,11 +1,11 @@
 //! Name resolution for lifetimes: type declarations.
 
-use crate::hir::def_id::{DefId, LocalDefId};
-use crate::hir::{GenericParam, ItemLocalId};
-use crate::hir::{GenericParamKind, LifetimeParamKind};
 use crate::ty;
 
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
+use rustc_hir::def_id::{DefId, LocalDefId};
+use rustc_hir::{GenericParam, ItemLocalId};
+use rustc_hir::{GenericParamKind, LifetimeParamKind};
 use rustc_macros::HashStable;
 
 /// The origin of a named lifetime definition.

src/librustc/middle/stability.rs

@@ -3,17 +3,17 @@
 
 pub use self::StabilityLevel::*;
 
-use crate::hir::def::DefKind;
-use crate::hir::def_id::{CrateNum, DefId, CRATE_DEF_INDEX};
-use crate::hir::{self, HirId};
 use crate::lint::builtin::BuiltinLintDiagnostics;
 use crate::lint::{self, in_derive_expansion, Lint};
 use crate::session::{DiagnosticMessageId, Session};
 use crate::ty::{self, TyCtxt};
-
 use errors::DiagnosticBuilder;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_feature::GateIssue;
+use rustc_hir as hir;
+use rustc_hir::def::DefKind;
+use rustc_hir::def_id::{CrateNum, DefId, CRATE_DEF_INDEX};
+use rustc_hir::{self, HirId};
 use rustc_span::symbol::{sym, Symbol};
 use rustc_span::{MultiSpan, Span};
 use syntax::ast::CRATE_NODE_ID;

src/librustc/middle/weak_lang_items.rs

@@ -3,12 +3,12 @@
 use crate::middle::lang_items;
 use crate::session::config;
 
-use crate::hir;
-use crate::hir::def_id::DefId;
 use crate::hir::intravisit;
 use crate::hir::intravisit::{NestedVisitorMap, Visitor};
 use crate::ty::TyCtxt;
 use rustc_data_structures::fx::FxHashSet;
+use rustc_hir as hir;
+use rustc_hir::def_id::DefId;
 use rustc_span::symbol::{sym, Symbol};
 use rustc_span::Span;
 use rustc_target::spec::PanicStrategy;

src/librustc/mir/interpret/error.rs

@@ -1,6 +1,5 @@
 use super::{CheckInAllocMsg, Pointer, RawConst, ScalarMaybeUndef};
 
-use crate::hir;
 use crate::hir::map::definitions::DefPathData;
 use crate::mir;
 use crate::ty::layout::{Align, LayoutError, Size};
@@ -10,6 +9,7 @@ use crate::ty::{self, layout, Ty};
 use backtrace::Backtrace;
 use errors::DiagnosticBuilder;
 use hir::GeneratorKind;
+use rustc_hir as hir;
 use rustc_macros::HashStable;
 use rustc_span::symbol::Symbol;
 use rustc_span::{Pos, Span};

src/librustc/mir/interpret/mod.rs

@@ -115,7 +115,6 @@ pub use self::allocation::{Allocation, AllocationExtra, Relocations, UndefMask};
 
 pub use self::pointer::{CheckInAllocMsg, Pointer, PointerArithmetic};
 
-use crate::hir::def_id::DefId;
 use crate::mir;
 use crate::ty::codec::TyDecoder;
 use crate::ty::layout::{self, Size};
@@ -125,6 +124,7 @@ use byteorder::{BigEndian, LittleEndian, ReadBytesExt, WriteBytesExt};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::sync::{HashMapExt, Lock};
 use rustc_data_structures::tiny_list::TinyList;
+use rustc_hir::def_id::DefId;
 use rustc_macros::HashStable;
 use rustc_serialize::{Decodable, Encodable, Encoder};
 use std::fmt;

src/librustc/mir/interpret/queries.rs

@@ -1,9 +1,9 @@
 use super::{ConstEvalResult, ErrorHandled, GlobalId};
 
-use crate::hir::def_id::DefId;
 use crate::mir;
 use crate::ty::subst::{InternalSubsts, SubstsRef};
 use crate::ty::{self, TyCtxt};
+use rustc_hir::def_id::DefId;
 use rustc_span::Span;
 
 impl<'tcx> TyCtxt<'tcx> {

src/librustc/mir/mod.rs

@@ -4,9 +4,6 @@
 //!
 //! [rustc guide]: https://rust-lang.github.io/rustc-guide/mir/index.html
 
-use crate::hir::def::{CtorKind, Namespace};
-use crate::hir::def_id::DefId;
-use crate::hir::{self, GeneratorKind};
 use crate::mir::interpret::{GlobalAlloc, PanicInfo, Scalar};
 use crate::mir::visit::MirVisitable;
 use crate::ty::adjustment::PointerCast;
@@ -17,6 +14,10 @@ use crate::ty::subst::{Subst, SubstsRef};
 use crate::ty::{
     self, AdtDef, CanonicalUserTypeAnnotations, List, Region, Ty, TyCtxt, UserTypeAnnotationIndex,
 };
+use rustc_hir as hir;
+use rustc_hir::def::{CtorKind, Namespace};
+use rustc_hir::def_id::DefId;
+use rustc_hir::{self, GeneratorKind};
 
 use polonius_engine::Atom;
 use rustc_data_structures::fx::FxHashSet;

src/librustc/mir/mono.rs

@@ -1,6 +1,4 @@
 use crate::dep_graph::{DepConstructor, DepNode, WorkProduct, WorkProductId};
-use crate::hir::def_id::{CrateNum, DefId, LOCAL_CRATE};
-use crate::hir::HirId;
 use crate::ich::{Fingerprint, NodeIdHashingMode, StableHashingContext};
 use crate::session::config::OptLevel;
 use crate::ty::print::obsolete::DefPathBasedNames;
@@ -8,6 +6,8 @@ use crate::ty::{subst::InternalSubsts, Instance, InstanceDef, SymbolName, TyCtxt
 use rustc_data_structures::base_n;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
+use rustc_hir::def_id::{CrateNum, DefId, LOCAL_CRATE};
+use rustc_hir::HirId;
 use rustc_span::source_map::Span;
 use rustc_span::symbol::Symbol;
 use std::fmt;

src/librustc/mir/tcx.rs

@@ -3,12 +3,12 @@
  * building is complete.
  */
 
-use crate::hir;
 use crate::mir::*;
 use crate::ty::layout::VariantIdx;
 use crate::ty::subst::Subst;
 use crate::ty::util::IntTypeExt;
 use crate::ty::{self, Ty, TyCtxt};
+use rustc_hir as hir;
 
 #[derive(Copy, Clone, Debug, TypeFoldable)]
 pub struct PlaceTy<'tcx> {

src/librustc/query/mod.rs

@@ -1,5 +1,4 @@
 use crate::dep_graph::{DepKind, DepNode, RecoverKey, SerializedDepNodeIndex};
-use crate::hir::def_id::{CrateNum, DefId, DefIndex};
 use crate::mir;
 use crate::mir::interpret::GlobalId;
 use crate::traits;
@@ -12,6 +11,7 @@ use crate::ty::query::queries;
 use crate::ty::query::QueryDescription;
 use crate::ty::subst::SubstsRef;
 use crate::ty::{self, ParamEnvAnd, Ty, TyCtxt};
+use rustc_hir::def_id::{CrateNum, DefId, DefIndex};
 
 use rustc_span::symbol::Symbol;
 use std::borrow::Cow;

src/librustc/traits/coherence.rs

@@ -4,7 +4,6 @@
 //! [trait-resolution]: https://rust-lang.github.io/rustc-guide/traits/resolution.html
 //! [trait-specialization]: https://rust-lang.github.io/rustc-guide/traits/specialization.html
 
-use crate::hir::def_id::{DefId, LOCAL_CRATE};
 use crate::infer::{CombinedSnapshot, InferOk};
 use crate::traits::select::IntercrateAmbiguityCause;
 use crate::traits::IntercrateMode;
@@ -12,6 +11,7 @@ use crate::traits::{self, Normalized, Obligation, ObligationCause, SelectionCont
 use crate::ty::fold::TypeFoldable;
 use crate::ty::subst::Subst;
 use crate::ty::{self, Ty, TyCtxt};
+use rustc_hir::def_id::{DefId, LOCAL_CRATE};
 use rustc_span::symbol::sym;
 use rustc_span::DUMMY_SP;
 

src/librustc/traits/engine.rs

@@ -1,7 +1,7 @@
-use crate::hir::def_id::DefId;
 use crate::infer::InferCtxt;
 use crate::traits::Obligation;
 use crate::ty::{self, ToPredicate, Ty, TyCtxt};
+use rustc_hir::def_id::DefId;
 
 use super::{ChalkFulfillmentContext, FulfillmentContext, FulfillmentError};
 use super::{ObligationCause, PredicateObligation};

src/librustc/traits/error_reporting.rs

@@ -6,9 +6,6 @@ use super::{
     TraitNotObjectSafe,
 };
 
-use crate::hir;
-use crate::hir::def_id::DefId;
-use crate::hir::Node;
 use crate::infer::error_reporting::TypeAnnotationNeeded as ErrorCode;
 use crate::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind};
 use crate::infer::{self, InferCtxt};
@@ -21,10 +18,11 @@ use crate::ty::GenericParamDefKind;
 use crate::ty::SubtypePredicate;
 use crate::ty::TypeckTables;
 use crate::ty::{self, AdtKind, DefIdTree, ToPolyTraitRef, ToPredicate, Ty, TyCtxt, TypeFoldable};
-
 use errors::{pluralize, Applicability, DiagnosticBuilder, Style};
-use rustc::hir::def_id::LOCAL_CRATE;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
+use rustc_hir as hir;
+use rustc_hir::def_id::{DefId, LOCAL_CRATE};
+use rustc_hir::Node;
 use rustc_span::source_map::SourceMap;
 use rustc_span::symbol::{kw, sym};
 use rustc_span::{ExpnKind, MultiSpan, Span, DUMMY_SP};

src/librustc/traits/mod.rs

@@ -19,8 +19,6 @@ mod specialize;
 mod structural_impls;
 mod util;
 
-use crate::hir;
-use crate::hir::def_id::DefId;
 use crate::infer::outlives::env::OutlivesEnvironment;
 use crate::infer::{InferCtxt, SuppressRegionErrors};
 use crate::middle::region;
@@ -31,6 +29,8 @@ use crate::ty::subst::{InternalSubsts, SubstsRef};
 use crate::ty::{self, AdtKind, GenericParamDefKind, List, ToPredicate, Ty, TyCtxt};
 use crate::util::common::ErrorReported;
 use chalk_engine;
+use rustc_hir as hir;
+use rustc_hir::def_id::DefId;
 use rustc_macros::HashStable;
 use rustc_span::{Span, DUMMY_SP};
 use syntax::ast;

src/librustc/traits/object_safety.rs

@@ -10,12 +10,12 @@
 
 use super::elaborate_predicates;
 
-use crate::hir;
-use crate::hir::def_id::DefId;
 use crate::lint;
 use crate::traits::{self, Obligation, ObligationCause};
 use crate::ty::subst::{InternalSubsts, Subst};
 use crate::ty::{self, Predicate, ToPredicate, Ty, TyCtxt, TypeFoldable};
+use rustc_hir as hir;
+use rustc_hir::def_id::DefId;
 use rustc_span::symbol::Symbol;
 use rustc_span::{Span, DUMMY_SP};
 use std::borrow::Cow;

src/librustc/traits/on_unimplemented.rs

@@ -1,10 +1,9 @@
 use fmt_macros::{Parser, Piece, Position};
 
-use crate::hir::def_id::DefId;
 use crate::ty::{self, GenericParamDefKind, TyCtxt};
 use crate::util::common::ErrorReported;
-
 use rustc_data_structures::fx::FxHashMap;
+use rustc_hir::def_id::DefId;
 use rustc_span::symbol::{kw, sym, Symbol};
 use rustc_span::Span;
 use syntax::ast::{MetaItem, NestedMetaItem};

src/librustc/traits/project.rs

@@ -12,7 +12,6 @@ use super::SelectionContext;
 use super::SelectionError;
 use super::{VtableClosureData, VtableFnPointerData, VtableGeneratorData, VtableImplData};
 
-use crate::hir::def_id::DefId;
 use crate::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind};
 use crate::infer::{InferCtxt, InferOk, LateBoundRegionConversionTime};
 use crate::ty::fold::{TypeFoldable, TypeFolder};
@@ -20,6 +19,7 @@ use crate::ty::subst::{InternalSubsts, Subst};
 use crate::ty::{self, ToPolyTraitRef, ToPredicate, Ty, TyCtxt};
 use crate::util::common::FN_OUTPUT_NAME;
 use rustc_data_structures::snapshot_map::{Snapshot, SnapshotMap};
+use rustc_hir::def_id::DefId;
 use rustc_macros::HashStable;
 use rustc_span::symbol::sym;
 use rustc_span::DUMMY_SP;

src/librustc/traits/query/outlives_bounds.rs

@@ -1,9 +1,9 @@
-use crate::hir;
 use crate::infer::canonical::OriginalQueryValues;
 use crate::infer::InferCtxt;
 use crate::traits::query::NoSolution;
 use crate::traits::{FulfillmentContext, ObligationCause, TraitEngine, TraitEngineExt};
 use crate::ty::{self, Ty};
+use rustc_hir as hir;
 use rustc_span::source_map::Span;
 
 use crate::ich::StableHashingContext;

src/librustc/traits/query/type_op/ascribe_user_type.rs

@@ -1,8 +1,8 @@
-use crate::hir::def_id::DefId;
 use crate::infer::canonical::{Canonicalized, CanonicalizedQueryResponse};
 use crate::traits::query::Fallible;
 use crate::ty::subst::UserSubsts;
 use crate::ty::{ParamEnvAnd, Ty, TyCtxt};
+use rustc_hir::def_id::DefId;
 
 #[derive(Copy, Clone, Debug, Hash, PartialEq, Eq, HashStable, TypeFoldable, Lift)]
 pub struct AscribeUserType<'tcx> {

src/librustc/traits/select.rs

@@ -30,17 +30,17 @@ use super::{
 };
 
 use crate::dep_graph::{DepKind, DepNodeIndex};
-use crate::hir::def_id::DefId;
 use crate::infer::{CombinedSnapshot, InferCtxt, InferOk, PlaceholderMap, TypeFreshener};
 use crate::middle::lang_items;
 use crate::ty::fast_reject;
 use crate::ty::relate::TypeRelation;
 use crate::ty::subst::{Subst, SubstsRef};
 use crate::ty::{self, ToPolyTraitRef, ToPredicate, Ty, TyCtxt, TypeFoldable};
+use rustc_hir::def_id::DefId;
 
-use crate::hir;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_data_structures::sync::Lock;
+use rustc_hir as hir;
 use rustc_index::bit_set::GrowableBitSet;
 use rustc_span::symbol::sym;
 use rustc_target::spec::abi::Abi;

src/librustc/traits/specialize/mod.rs

@@ -11,7 +11,6 @@
 
 pub mod specialization_graph;
 
-use crate::hir::def_id::DefId;
 use crate::infer::{InferCtxt, InferOk};
 use crate::lint;
 use crate::traits::select::IntercrateAmbiguityCause;
@@ -19,6 +18,7 @@ use crate::traits::{self, coherence, FutureCompatOverlapErrorKind, ObligationCau
 use crate::ty::subst::{InternalSubsts, Subst, SubstsRef};
 use crate::ty::{self, TyCtxt, TypeFoldable};
 use rustc_data_structures::fx::FxHashSet;
+use rustc_hir::def_id::DefId;
 use rustc_span::DUMMY_SP;
 
 use super::util::impl_trait_ref_and_oblig;

src/librustc/traits/specialize/specialization_graph.rs

@@ -1,12 +1,12 @@
 use super::OverlapError;
 
-use crate::hir::def_id::{DefId, DefIdMap};
 use crate::ich::{self, StableHashingContext};
 use crate::traits;
 use crate::ty::fast_reject::{self, SimplifiedType};
 use crate::ty::{self, TyCtxt, TypeFoldable};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
+use rustc_hir::def_id::{DefId, DefIdMap};
 use syntax::ast::Ident;
 
 /// A per-trait graph of impls in specialization order. At the moment, this

src/librustc/traits/util.rs

@@ -2,12 +2,12 @@ use errors::DiagnosticBuilder;
 use rustc_span::Span;
 use smallvec::SmallVec;
 
-use crate::hir;
-use crate::hir::def_id::DefId;
 use crate::ty::outlives::Component;
 use crate::ty::subst::{GenericArg, Subst, SubstsRef};
 use crate::ty::{self, ToPolyTraitRef, ToPredicate, Ty, TyCtxt};
 use rustc_data_structures::fx::FxHashSet;
+use rustc_hir as hir;
+use rustc_hir::def_id::DefId;
 
 use super::{Normalized, Obligation, ObligationCause, PredicateObligation, SelectionContext};
 

src/librustc/ty/adjustment.rs

@@ -1,7 +1,7 @@
-use crate::hir;
-use crate::hir::def_id::DefId;
 use crate::ty::subst::SubstsRef;
 use crate::ty::{self, Ty, TyCtxt};
+use rustc_hir as hir;
+use rustc_hir::def_id::DefId;
 use rustc_macros::HashStable;
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, RustcEncodable, RustcDecodable, HashStable)]

src/librustc/ty/binding.rs

@@ -1,6 +1,6 @@
-use crate::hir::BindingAnnotation;
-use crate::hir::BindingAnnotation::*;
-use crate::hir::Mutability;
+use rustc_hir::BindingAnnotation;
+use rustc_hir::BindingAnnotation::*;
+use rustc_hir::Mutability;
 
 #[derive(Clone, PartialEq, RustcEncodable, RustcDecodable, Debug, Copy, HashStable)]
 pub enum BindingMode {

src/librustc/ty/codec.rs

@@ -7,12 +7,12 @@
 // persisting to incr. comp. caches.
 
 use crate::arena::ArenaAllocatable;
-use crate::hir::def_id::{CrateNum, DefId};
 use crate::infer::canonical::{CanonicalVarInfo, CanonicalVarInfos};
 use crate::mir::{self, interpret::Allocation};
 use crate::ty::subst::SubstsRef;
 use crate::ty::{self, List, Ty, TyCtxt};
 use rustc_data_structures::fx::FxHashMap;
+use rustc_hir::def_id::{CrateNum, DefId};
 use rustc_serialize::{opaque, Decodable, Decoder, Encodable, Encoder};
 use rustc_span::Span;
 use std::hash::Hash;
@@ -353,7 +353,7 @@ macro_rules! implement_ty_decoder {
             use $crate::ty;
             use $crate::ty::codec::*;
             use $crate::ty::subst::SubstsRef;
-            use $crate::hir::def_id::{CrateNum};
+            use rustc_hir::def_id::{CrateNum};
 
             use rustc_span::Span;
 

src/librustc/ty/constness.rs

@@ -1,8 +1,8 @@
-use crate::hir;
-use crate::hir::def_id::DefId;
 use crate::hir::map::blocks::FnLikeNode;
 use crate::ty::query::Providers;
 use crate::ty::TyCtxt;
+use rustc_hir as hir;
+use rustc_hir::def_id::DefId;
 use rustc_span::symbol::Symbol;
 use rustc_target::spec::abi::Abi;
 use syntax::attr;

src/librustc/ty/context.rs

@@ -3,13 +3,9 @@
 use crate::arena::Arena;
 use crate::dep_graph::DepGraph;
 use crate::dep_graph::{self, DepConstructor, DepNode};
-use crate::hir::def::{DefKind, Res};
-use crate::hir::def_id::{CrateNum, DefId, DefIdMap, DefIdSet, DefIndex, LOCAL_CRATE};
 use crate::hir::exports::Export;
 use crate::hir::map as hir_map;
 use crate::hir::map::DefPathHash;
-use crate::hir::{self, HirId, Node, TraitCandidate};
-use crate::hir::{ItemKind, ItemLocalId, ItemLocalMap, ItemLocalSet};
 use crate::ich::{NodeIdHashingMode, StableHashingContext};
 use crate::infer::canonical::{Canonical, CanonicalVarInfo, CanonicalVarInfos};
 use crate::infer::outlives::free_region_map::FreeRegionMap;
@@ -48,6 +44,11 @@ use crate::ty::{ExistentialPredicate, InferTy, ParamTy, PolyFnSig, Predicate, Pr
 use crate::ty::{InferConst, ParamConst};
 use crate::ty::{List, TyKind, TyS};
 use crate::util::common::ErrorReported;
+use rustc_hir as hir;
+use rustc_hir::def::{DefKind, Res};
+use rustc_hir::def_id::{CrateNum, DefId, DefIdMap, DefIdSet, DefIndex, LOCAL_CRATE};
+use rustc_hir::{HirId, Node, TraitCandidate};
+use rustc_hir::{ItemKind, ItemLocalId, ItemLocalMap, ItemLocalSet};
 
 use arena::SyncDroplessArena;
 use errors::DiagnosticBuilder;

src/librustc/ty/error.rs

@@ -1,6 +1,6 @@
-use crate::hir;
-use crate::hir::def_id::DefId;
 use crate::ty::{self, BoundRegion, Region, Ty, TyCtxt};
+use rustc_hir as hir;
+use rustc_hir::def_id::DefId;
 
 use errors::{Applicability, DiagnosticBuilder};
 use rustc_span::Span;

src/librustc/ty/fast_reject.rs

@@ -1,7 +1,7 @@
-use crate::hir::def_id::DefId;
 use crate::ich::StableHashingContext;
 use crate::ty::{self, Ty, TyCtxt};
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
+use rustc_hir::def_id::DefId;
 use std::fmt::Debug;
 use std::hash::Hash;
 use std::mem;

src/librustc/ty/fold.rs

@@ -31,8 +31,8 @@
 //! These methods return true to indicate that the visitor has found what it is
 //! looking for, and does not need to visit anything else.
 
-use crate::hir::def_id::DefId;
 use crate::ty::{self, flags::FlagComputation, Binder, Ty, TyCtxt, TypeFlags};
+use rustc_hir::def_id::DefId;
 
 use rustc_data_structures::fx::FxHashSet;
 use std::collections::BTreeMap;

src/librustc/ty/inhabitedness/def_id_forest.rs

@@ -1,6 +1,6 @@
 use crate::ty::context::TyCtxt;
 use crate::ty::{DefId, DefIdTree};
-use rustc::hir::CRATE_HIR_ID;
+use rustc_hir::CRATE_HIR_ID;
 use smallvec::SmallVec;
 use std::mem;
 

src/librustc/ty/instance.rs

@@ -1,10 +1,10 @@
-use crate::hir::def::Namespace;
-use crate::hir::def_id::DefId;
 use crate::middle::codegen_fn_attrs::CodegenFnAttrFlags;
 use crate::middle::lang_items::DropInPlaceFnLangItem;
 use crate::traits;
 use crate::ty::print::{FmtPrinter, Printer};
 use crate::ty::{self, SubstsRef, Ty, TyCtxt, TypeFoldable};
+use rustc_hir::def::Namespace;
+use rustc_hir::def_id::DefId;
 use rustc_macros::HashStable;
 use rustc_target::spec::abi::Abi;
 

src/librustc/ty/layout.rs

@@ -12,11 +12,11 @@ use std::iter;
 use std::mem;
 use std::ops::Bound;
 
-use crate::hir;
 use crate::ich::StableHashingContext;
 use crate::mir::{GeneratorLayout, GeneratorSavedLocal};
 use crate::ty::subst::Subst;
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
+use rustc_hir as hir;
 use rustc_index::bit_set::BitSet;
 use rustc_index::vec::{Idx, IndexVec};
 

src/librustc/ty/mod.rs

@@ -6,11 +6,9 @@ pub use self::BorrowKind::*;
 pub use self::IntVarValue::*;
 pub use self::Variance::*;
 
-use crate::hir::def::{CtorKind, CtorOf, DefKind, Res};
-use crate::hir::def_id::{CrateNum, DefId, DefIdMap, LocalDefId, CRATE_DEF_INDEX, LOCAL_CRATE};
 use crate::hir::exports::ExportMap;
-use crate::hir::Node;
-use crate::hir::{map as hir_map, GlobMap, TraitMap};
+use crate::hir::map as hir_map;
+
 use crate::ich::Fingerprint;
 use crate::ich::StableHashingContext;
 use crate::infer::canonical::Canonical;
@@ -31,16 +29,23 @@ use crate::ty::walk::TypeWalker;
 use crate::util::captures::Captures;
 use arena::SyncDroplessArena;
 use rustc_data_structures::fx::FxHashMap;
+use rustc_data_structures::fx::FxIndexMap;
+use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
 use rustc_data_structures::svh::Svh;
-use rustc_macros::HashStable;
-use rustc_session::node_id::{NodeMap, NodeSet};
-
 use rustc_data_structures::sync::{self, par_iter, Lrc, ParallelIterator};
+use rustc_hir as hir;
+use rustc_hir::def::{CtorKind, CtorOf, DefKind, Res};
+use rustc_hir::def_id::{CrateNum, DefId, DefIdMap, LocalDefId, CRATE_DEF_INDEX, LOCAL_CRATE};
+use rustc_hir::{GlobMap, Node, TraitMap};
+use rustc_index::vec::{Idx, IndexVec};
+use rustc_macros::HashStable;
 use rustc_serialize::{self, Encodable, Encoder};
+use rustc_session::node_id::{NodeMap, NodeSet};
 use rustc_span::hygiene::ExpnId;
 use rustc_span::symbol::{kw, sym, Symbol};
 use rustc_span::Span;
 use rustc_target::abi::Align;
+use smallvec;
 use std::cell::RefCell;
 use std::cmp::{self, Ordering};
 use std::fmt;
@@ -52,13 +57,6 @@ use std::{mem, ptr};
 use syntax::ast::{self, Ident, Name, NodeId};
 use syntax::attr;
 
-use rustc_data_structures::fx::FxIndexMap;
-use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
-use rustc_index::vec::{Idx, IndexVec};
-use smallvec;
-
-use crate::hir;
-
 pub use self::sty::BoundRegion::*;
 pub use self::sty::InferTy::*;
 pub use self::sty::RegionKind;
@@ -3313,7 +3311,7 @@ fn asyncness(tcx: TyCtxt<'_>, def_id: DefId) -> hir::IsAsync {
 
     let node = tcx.hir().get(hir_id);
 
-    let fn_like = hir::map::blocks::FnLikeNode::from_node(node).unwrap_or_else(|| {
+    let fn_like = hir_map::blocks::FnLikeNode::from_node(node).unwrap_or_else(|| {
         bug!("asyncness: expected fn-like node but got `{:?}`", def_id);
     });
 

src/librustc/ty/print/mod.rs

@@ -1,9 +1,9 @@
-use crate::hir::def_id::{CrateNum, DefId};
 use crate::hir::map::{DefPathData, DisambiguatedDefPathData};
 use crate::ty::subst::{GenericArg, Subst};
 use crate::ty::{self, DefIdTree, Ty, TyCtxt};
 
 use rustc_data_structures::fx::FxHashSet;
+use rustc_hir::def_id::{CrateNum, DefId};
 
 // `pretty` is a separate module only for organization.
 mod pretty;

src/librustc/ty/print/obsolete.rs

@@ -5,10 +5,11 @@
 //! Note: A lot of this could looks very similar to what's already in `ty::print`.
 //! FIXME(eddyb) implement a custom `PrettyPrinter` for this.
 
-use rustc::hir::def_id::DefId;
+use rustc::bug;
 use rustc::ty::subst::SubstsRef;
 use rustc::ty::{self, Const, Instance, Ty, TyCtxt};
-use rustc::{bug, hir};
+use rustc_hir as hir;
+use rustc_hir::def_id::DefId;
 use std::fmt::Write;
 use std::iter;
 

src/librustc/ty/print/pretty.rs

@@ -1,6 +1,3 @@
-use crate::hir;
-use crate::hir::def::{DefKind, Namespace};
-use crate::hir::def_id::{CrateNum, DefId, CRATE_DEF_INDEX, LOCAL_CRATE};
 use crate::hir::map::{DefPathData, DisambiguatedDefPathData};
 use crate::middle::cstore::{ExternCrate, ExternCrateSource};
 use crate::middle::region;
@@ -8,6 +5,9 @@ use crate::mir::interpret::{sign_extend, truncate, ConstValue, Scalar};
 use crate::ty::layout::{Integer, IntegerExt, Size};
 use crate::ty::subst::{GenericArg, GenericArgKind, Subst};
 use crate::ty::{self, DefIdTree, ParamConst, Ty, TyCtxt, TypeFoldable};
+use rustc_hir as hir;
+use rustc_hir::def::{DefKind, Namespace};
+use rustc_hir::def_id::{CrateNum, DefId, CRATE_DEF_INDEX, LOCAL_CRATE};
 
 use rustc_apfloat::ieee::{Double, Single};
 use rustc_apfloat::Float;

src/librustc/ty/query/config.rs

@@ -1,12 +1,12 @@
 use crate::dep_graph::SerializedDepNodeIndex;
 use crate::dep_graph::{DepKind, DepNode};
-use crate::hir::def_id::{CrateNum, DefId};
 use crate::ty::query::plumbing::CycleError;
 use crate::ty::query::queries;
 use crate::ty::query::QueryCache;
 use crate::ty::query::{Query, QueryName};
 use crate::ty::TyCtxt;
 use rustc_data_structures::profiling::ProfileCategory;
+use rustc_hir::def_id::{CrateNum, DefId};
 
 use crate::ich::StableHashingContext;
 use rustc_data_structures::fingerprint::Fingerprint;

src/librustc/ty/query/keys.rs

@@ -1,13 +1,12 @@
 //! Defines the set of legal keys that can be used in queries.
 
-use crate::hir::def_id::{CrateNum, DefId, DefIndex, LOCAL_CRATE};
 use crate::infer::canonical::Canonical;
 use crate::mir;
 use crate::traits;
 use crate::ty::fast_reject::SimplifiedType;
 use crate::ty::subst::SubstsRef;
 use crate::ty::{self, Ty, TyCtxt};
-
+use rustc_hir::def_id::{CrateNum, DefId, DefIndex, LOCAL_CRATE};
 use rustc_span::symbol::Symbol;
 use rustc_span::{Span, DUMMY_SP};
 

src/librustc/ty/query/mod.rs

@@ -1,8 +1,5 @@
 use crate::dep_graph::{self, DepNode};
-use crate::hir::def::DefKind;
-use crate::hir::def_id::{CrateNum, DefId, DefIdMap, DefIdSet, DefIndex};
 use crate::hir::exports::Export;
-use crate::hir::{self, HirIdSet, ItemLocalId, TraitCandidate};
 use crate::infer::canonical::{self, Canonical};
 use crate::lint;
 use crate::middle::codegen_fn_attrs::CodegenFnAttrs;
@@ -38,13 +35,16 @@ use crate::ty::subst::SubstsRef;
 use crate::ty::util::NeedsDrop;
 use crate::ty::{self, AdtSizedConstraint, CrateInherentImpls, ParamEnvAnd, Ty, TyCtxt};
 use crate::util::common::ErrorReported;
-use rustc_data_structures::profiling::ProfileCategory::*;
-
 use rustc_data_structures::fingerprint::Fingerprint;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap};
+use rustc_data_structures::profiling::ProfileCategory::*;
 use rustc_data_structures::stable_hasher::StableVec;
 use rustc_data_structures::svh::Svh;
 use rustc_data_structures::sync::Lrc;
+use rustc_hir as hir;
+use rustc_hir::def::DefKind;
+use rustc_hir::def_id::{CrateNum, DefId, DefIdMap, DefIdSet, DefIndex};
+use rustc_hir::{HirIdSet, ItemLocalId, TraitCandidate};
 use rustc_index::vec::IndexVec;
 use rustc_target::spec::PanicStrategy;
 

src/librustc/ty/query/on_disk_cache.rs

@@ -1,6 +1,4 @@
 use crate::dep_graph::{DepNodeIndex, SerializedDepNodeIndex};
-use crate::hir;
-use crate::hir::def_id::{CrateNum, DefId, DefIndex, LocalDefId, LOCAL_CRATE};
 use crate::hir::map::definitions::DefPathHash;
 use crate::ich::{CachingSourceMapView, Fingerprint};
 use crate::mir::interpret::{AllocDecodingSession, AllocDecodingState};
@@ -9,11 +7,12 @@ use crate::session::{CrateDisambiguator, Session};
 use crate::ty::codec::{self as ty_codec, TyDecoder, TyEncoder};
 use crate::ty::context::TyCtxt;
 use crate::ty::{self, Ty};
-
 use errors::Diagnostic;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::sync::{HashMapExt, Lock, Lrc, Once};
 use rustc_data_structures::thin_vec::ThinVec;
+use rustc_hir as hir;
+use rustc_hir::def_id::{CrateNum, DefId, DefIndex, LocalDefId, LOCAL_CRATE};
 use rustc_index::vec::{Idx, IndexVec};
 use rustc_serialize::{
     opaque, Decodable, Decoder, Encodable, Encoder, SpecializedDecoder, SpecializedEncoder,

src/librustc/ty/relate.rs

@@ -4,13 +4,13 @@
 //! types or regions but can be other things. Examples of type relations are
 //! subtyping, type equality, etc.
 
-use crate::hir as ast;
-use crate::hir::def_id::DefId;
 use crate::mir::interpret::{get_slice_bytes, ConstValue};
 use crate::traits;
 use crate::ty::error::{ExpectedFound, TypeError};
 use crate::ty::subst::{GenericArg, GenericArgKind, SubstsRef};
 use crate::ty::{self, Ty, TyCtxt, TypeFoldable};
+use rustc_hir as ast;
+use rustc_hir::def_id::DefId;
 use rustc_target::spec::abi;
 use std::iter;
 use std::rc::Rc;

src/librustc/ty/structural_impls.rs

@@ -2,17 +2,16 @@
 //! traits for various types in the Rust compiler. Most are written by
 //! hand, though we've recently added some macros and proc-macros to help with the tedium.
 
-use crate::hir::def::Namespace;
-use crate::hir::def_id::CRATE_DEF_INDEX;
 use crate::mir::interpret;
 use crate::mir::ProjectionKind;
 use crate::ty::fold::{TypeFoldable, TypeFolder, TypeVisitor};
 use crate::ty::print::{FmtPrinter, Printer};
 use crate::ty::{self, InferConst, Lift, Ty, TyCtxt};
-
+use rustc_hir::def::Namespace;
+use rustc_hir::def_id::CRATE_DEF_INDEX;
 use rustc_index::vec::{Idx, IndexVec};
-use smallvec::SmallVec;
 
+use smallvec::SmallVec;
 use std::fmt;
 use std::rc::Rc;
 use std::sync::Arc;
@@ -275,12 +274,12 @@ CloneTypeFoldableAndLiftImpls! {
     ::syntax::ast::FloatTy,
     ::syntax::ast::NodeId,
     ::rustc_span::symbol::Symbol,
-    crate::hir::def::Res,
-    crate::hir::def_id::DefId,
-    crate::hir::InlineAsmInner,
-    crate::hir::MatchSource,
-    crate::hir::Mutability,
-    crate::hir::Unsafety,
+    ::rustc_hir::def::Res,
+    ::rustc_hir::def_id::DefId,
+    ::rustc_hir::InlineAsmInner,
+    ::rustc_hir::MatchSource,
+    ::rustc_hir::Mutability,
+    ::rustc_hir::Unsafety,
     ::rustc_target::spec::abi::Abi,
     crate::mir::Local,
     crate::mir::Promoted,

src/librustc/ty/structural_match.rs

@@ -1,15 +1,13 @@
-use crate::hir;
+use crate::ty::fold::{TypeFoldable, TypeVisitor};
+use crate::ty::{self, AdtDef, Ty, TyCtxt};
+
 use rustc::infer::InferCtxt;
 use rustc::traits::ObligationCause;
 use rustc::traits::{self, ConstPatternStructural, TraitEngine};
-
 use rustc_data_structures::fx::FxHashSet;
-
+use rustc_hir as hir;
 use rustc_span::Span;
 
-use crate::ty::fold::{TypeFoldable, TypeVisitor};
-use crate::ty::{self, AdtDef, Ty, TyCtxt};
-
 #[derive(Debug)]
 pub enum NonStructuralMatchTy<'tcx> {
     Adt(&'tcx AdtDef),

src/librustc/ty/sty.rs

@@ -5,8 +5,6 @@
 use self::InferTy::*;
 use self::TyKind::*;
 
-use crate::hir;
-use crate::hir::def_id::DefId;
 use crate::infer::canonical::Canonical;
 use crate::middle::region;
 use crate::mir::interpret::ConstValue;
@@ -16,6 +14,8 @@ use crate::ty::subst::{GenericArg, GenericArgKind, InternalSubsts, Subst, Substs
 use crate::ty::{self, AdtDef, DefIdTree, Discr, Ty, TyCtxt, TypeFlags, TypeFoldable};
 use crate::ty::{List, ParamEnv, ParamEnvAnd, TyS};
 use crate::util::captures::Captures;
+use rustc_hir as hir;
+use rustc_hir::def_id::DefId;
 
 use polonius_engine::Atom;
 use rustc_index::vec::Idx;

src/librustc/ty/subst.rs

@@ -1,11 +1,11 @@
 // Type substitutions.
 
-use crate::hir::def_id::DefId;
 use crate::infer::canonical::Canonical;
 use crate::ty::fold::{TypeFoldable, TypeFolder, TypeVisitor};
 use crate::ty::sty::{ClosureSubsts, GeneratorSubsts};
 use crate::ty::{self, Lift, List, ParamConst, Ty, TyCtxt};
 
+use rustc_hir::def_id::DefId;
 use rustc_macros::HashStable;
 use rustc_serialize::{self, Decodable, Decoder, Encodable, Encoder};
 use rustc_span::{Span, DUMMY_SP};

src/librustc/ty/trait_def.rs

@@ -1,11 +1,11 @@
-use crate::hir;
-use crate::hir::def_id::DefId;
 use crate::hir::map::DefPathHash;
 use crate::ich::{self, StableHashingContext};
 use crate::traits::specialization_graph;
 use crate::ty::fast_reject;
 use crate::ty::fold::TypeFoldable;
 use crate::ty::{Ty, TyCtxt};
+use rustc_hir as hir;
+use rustc_hir::def_id::DefId;
 
 use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};

src/librustc/ty/util.rs

@@ -1,8 +1,5 @@
 //! Miscellaneous type-system utilities that are too small to deserve their own modules.
 
-use crate::hir;
-use crate::hir::def::DefKind;
-use crate::hir::def_id::DefId;
 use crate::hir::map::DefPathData;
 use crate::ich::NodeIdHashingMode;
 use crate::middle::lang_items;
@@ -14,6 +11,9 @@ use crate::ty::subst::{GenericArgKind, InternalSubsts, Subst, SubstsRef};
 use crate::ty::TyKind::*;
 use crate::ty::{self, DefIdTree, GenericParamDefKind, Ty, TyCtxt, TypeFoldable};
 use crate::util::common::ErrorReported;
+use rustc_hir as hir;
+use rustc_hir::def::DefKind;
+use rustc_hir::def_id::DefId;
 
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};

src/librustc/ty/wf.rs

@@ -1,10 +1,10 @@
-use crate::hir;
-use crate::hir::def_id::DefId;
 use crate::infer::InferCtxt;
 use crate::middle::lang_items;
 use crate::traits::{self, AssocTypeBoundData};
 use crate::ty::subst::SubstsRef;
 use crate::ty::{self, ToPredicate, Ty, TyCtxt, TypeFoldable};
+use rustc_hir as hir;
+use rustc_hir::def_id::DefId;
 use rustc_span::symbol::{kw, Ident};
 use rustc_span::Span;
 use std::iter::once;

src/librustc_ast_lowering/Cargo.toml

@@ -12,6 +12,7 @@ doctest = false
 [dependencies]
 log = { version = "0.4", features = ["release_max_level_info", "std"] }
 rustc = { path = "../librustc" }
+rustc_hir = { path = "../librustc_hir" }
 rustc_target = { path = "../librustc_target" }
 rustc_data_structures = { path = "../librustc_data_structures" }
 rustc_index = { path = "../librustc_index" }

src/librustc_ast_lowering/expr.rs

@@ -1,10 +1,10 @@
 use super::{ImplTraitContext, LoweringContext, ParamMode, ParenthesizedGenericArgs};
 
 use rustc::bug;
-use rustc::hir;
-use rustc::hir::def::Res;
 use rustc_data_structures::thin_vec::ThinVec;
 use rustc_error_codes::*;
+use rustc_hir as hir;
+use rustc_hir::def::Res;
 use rustc_span::source_map::{respan, DesugaringKind, Span, Spanned};
 use rustc_span::symbol::{sym, Symbol};
 use syntax::ast::*;

src/librustc_ast_lowering/item.rs

@@ -3,10 +3,10 @@ use super::{ImplTraitContext, ImplTraitPosition, ImplTraitTypeIdVisitor};
 
 use rustc::arena::Arena;
 use rustc::bug;
-use rustc::hir;
-use rustc::hir::def::{DefKind, Res};
-use rustc::hir::def_id::DefId;
 use rustc_error_codes::*;
+use rustc_hir as hir;
+use rustc_hir::def::{DefKind, Res};
+use rustc_hir::def_id::DefId;
 use rustc_session::node_id::NodeMap;
 use rustc_span::source_map::{respan, DesugaringKind};
 use rustc_span::symbol::{kw, sym};

src/librustc_ast_lowering/lib.rs

@@ -36,15 +36,11 @@
 
 use rustc::arena::Arena;
 use rustc::dep_graph::DepGraph;
-use rustc::hir::def::{DefKind, Namespace, PartialRes, PerNS, Res};
-use rustc::hir::def_id::{DefId, DefIdMap, DefIndex, CRATE_DEF_INDEX};
+use rustc::hir::intravisit;
 use rustc::hir::map::{DefKey, DefPathData, Definitions};
-use rustc::hir::{self, ConstArg, GenericArg, ParamName};
 use rustc::lint;
 use rustc::lint::builtin::{self, ELIDED_LIFETIMES_IN_PATHS};
 use rustc::middle::cstore::CrateStore;
-use rustc::session::config::nightly_options;
-use rustc::session::Session;
 use rustc::util::captures::Captures;
 use rustc::util::common::FN_OUTPUT_NAME;
 use rustc::{bug, span_bug};
@@ -52,8 +48,14 @@ use rustc_data_structures::fx::FxHashSet;
 use rustc_data_structures::sync::Lrc;
 use rustc_error_codes::*;
 use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_hir::def::{DefKind, Namespace, PartialRes, PerNS, Res};
+use rustc_hir::def_id::{DefId, DefIdMap, DefIndex, CRATE_DEF_INDEX};
+use rustc_hir::{ConstArg, GenericArg, ParamName};
 use rustc_index::vec::IndexVec;
+use rustc_session::config::nightly_options;
 use rustc_session::node_id::NodeMap;
+use rustc_session::Session;
 use rustc_span::hygiene::ExpnId;
 use rustc_span::source_map::{respan, DesugaringKind, ExpnData, ExpnKind, Spanned};
 use rustc_span::symbol::{kw, sym, Symbol};
@@ -1482,11 +1484,9 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             output_lifetime_params: Vec<hir::GenericParam<'hir>>,
         }
 
-        impl<'r, 'a, 'v, 'hir> hir::intravisit::Visitor<'v> for ImplTraitLifetimeCollector<'r, 'a, 'hir> {
-            fn nested_visit_map<'this>(
-                &'this mut self,
-            ) -> hir::intravisit::NestedVisitorMap<'this, 'v> {
-                hir::intravisit::NestedVisitorMap::None
+        impl<'r, 'a, 'v, 'hir> intravisit::Visitor<'v> for ImplTraitLifetimeCollector<'r, 'a, 'hir> {
+            fn nested_visit_map<'this>(&'this mut self) -> intravisit::NestedVisitorMap<'this, 'v> {
+                intravisit::NestedVisitorMap::None
             }
 
             fn visit_generic_args(&mut self, span: Span, parameters: &'v hir::GenericArgs<'v>) {
@@ -1494,10 +1494,10 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 if parameters.parenthesized {
                     let old_collect_elided_lifetimes = self.collect_elided_lifetimes;
                     self.collect_elided_lifetimes = false;
-                    hir::intravisit::walk_generic_args(self, span, parameters);
+                    intravisit::walk_generic_args(self, span, parameters);
                     self.collect_elided_lifetimes = old_collect_elided_lifetimes;
                 } else {
-                    hir::intravisit::walk_generic_args(self, span, parameters);
+                    intravisit::walk_generic_args(self, span, parameters);
                 }
             }
 
@@ -1510,12 +1510,12 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                     // Record the "stack height" of `for<'a>` lifetime bindings
                     // to be able to later fully undo their introduction.
                     let old_len = self.currently_bound_lifetimes.len();
-                    hir::intravisit::walk_ty(self, t);
+                    intravisit::walk_ty(self, t);
                     self.currently_bound_lifetimes.truncate(old_len);
 
                     self.collect_elided_lifetimes = old_collect_elided_lifetimes;
                 } else {
-                    hir::intravisit::walk_ty(self, t)
+                    intravisit::walk_ty(self, t)
                 }
             }
 
@@ -1527,7 +1527,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 // Record the "stack height" of `for<'a>` lifetime bindings
                 // to be able to later fully undo their introduction.
                 let old_len = self.currently_bound_lifetimes.len();
-                hir::intravisit::walk_poly_trait_ref(self, trait_ref, modifier);
+                intravisit::walk_poly_trait_ref(self, trait_ref, modifier);
                 self.currently_bound_lifetimes.truncate(old_len);
             }
 
@@ -1540,7 +1540,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                     self.currently_bound_lifetimes.push(lt_name);
                 }
 
-                hir::intravisit::walk_generic_param(self, param);
+                intravisit::walk_generic_param(self, param);
             }
 
             fn visit_lifetime(&mut self, lifetime: &'v hir::Lifetime) {
@@ -1621,7 +1621,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         };
 
         for bound in bounds {
-            hir::intravisit::walk_param_bound(&mut lifetime_collector, &bound);
+            intravisit::walk_param_bound(&mut lifetime_collector, &bound);
         }
 
         let ImplTraitLifetimeCollector { output_lifetimes, output_lifetime_params, .. } =

src/librustc_codegen_llvm/Cargo.toml

@@ -23,6 +23,7 @@ rustc_data_structures = { path = "../librustc_data_structures" }
 rustc_errors = { path = "../librustc_errors" }
 rustc_feature = { path = "../librustc_feature" }
 rustc_fs_util = { path = "../librustc_fs_util" }
+rustc_hir = { path = "../librustc_hir" }
 rustc_incremental = { path = "../librustc_incremental" }
 rustc_index = { path = "../librustc_index" }
 rustc_llvm = { path = "../librustc_llvm" }