8 files changed, 59 insertions, 67 deletions

diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs
index f03b59217..181c5d47a 100644
--- a/crates/ra_hir/src/code_model.rs
+++ b/crates/ra_hir/src/code_model.rs
@@ -28,11 +28,10 @@ use crate::{
         TypeAliasId,
     },
     impl_block::ImplBlock,
-    nameres::{ImportId, Namespace},
     resolve::{Resolver, Scope, TypeNs},
     traits::TraitData,
     ty::{InferenceResult, TraitRef},
-    Either, HasSource, Name, ScopeDef, Ty,
+    Either, HasSource, Name, ScopeDef, Ty, {ImportId, Namespace},
 };
 
 /// hir::Crate describes a single crate. It's the main interface with which
diff --git a/crates/ra_hir/src/db.rs b/crates/ra_hir/src/db.rs
index f45804c7c..eb66325f7 100644
--- a/crates/ra_hir/src/db.rs
+++ b/crates/ra_hir/src/db.rs
@@ -11,14 +11,13 @@ use crate::{
     ids,
     impl_block::{ImplBlock, ImplSourceMap, ModuleImplBlocks},
     lang_item::{LangItemTarget, LangItems},
-    nameres::Namespace,
     traits::TraitData,
     ty::{
         method_resolution::CrateImplBlocks, traits::Impl, CallableDef, FnSig, GenericPredicate,
         InferenceResult, Substs, Ty, TypableDef, TypeCtor,
     },
     type_alias::TypeAliasData,
-    Const, ConstData, Crate, DefWithBody, ExprScopes, FnData, Function, Module, Static,
+    Const, ConstData, Crate, DefWithBody, ExprScopes, FnData, Function, Module, Namespace, Static,
     StructField, Trait, TypeAlias,
 };
 
diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs
index 52bad2228..3ba99d92d 100644
--- a/crates/ra_hir/src/lib.rs
+++ b/crates/ra_hir/src/lib.rs
@@ -34,7 +34,6 @@ pub mod mock;
 pub mod source_binder;
 
 mod ids;
-mod nameres;
 mod adt;
 mod traits;
 mod type_alias;
@@ -73,7 +72,6 @@ pub use crate::{
     generics::{GenericDef, GenericParam, GenericParams, HasGenericParams},
     ids::{HirFileId, MacroCallId, MacroCallLoc, MacroDefId, MacroFile},
     impl_block::ImplBlock,
-    nameres::{ImportId, Namespace, PerNs},
     resolve::ScopeDef,
     source_binder::{PathResolution, ScopeEntryWithSyntax, SourceAnalyzer},
     ty::{
@@ -83,6 +81,10 @@ pub use crate::{
 
 pub use hir_def::{
     builtin_type::BuiltinType,
+    nameres::{
+        per_ns::{Namespace, PerNs},
+        raw::ImportId,
+    },
     path::{Path, PathKind},
     type_ref::Mutability,
 };
diff --git a/crates/ra_hir/src/nameres.rs b/crates/ra_hir/src/nameres.rs
deleted file mode 100644
index 875addc84..000000000
--- a/crates/ra_hir/src/nameres.rs
+++ /dev/null
@@ -1,53 +0,0 @@
-//! This module implements import-resolution/macro expansion algorithm.
-//!
-//! The result of this module is `CrateDefMap`: a data structure which contains:
-//!
-//!   * a tree of modules for the crate
-//!   * for each module, a set of items visible in the module (directly declared
-//!     or imported)
-//!
-//! Note that `CrateDefMap` contains fully macro expanded code.
-//!
-//! Computing `CrateDefMap` can be partitioned into several logically
-//! independent "phases". The phases are mutually recursive though, there's no
-//! strict ordering.
-//!
-//! ## Collecting RawItems
-//!
-//!  This happens in the `raw` module, which parses a single source file into a
-//!  set of top-level items. Nested imports are desugared to flat imports in
-//!  this phase. Macro calls are represented as a triple of (Path, Option<Name>,
-//!  TokenTree).
-//!
-//! ## Collecting Modules
-//!
-//! This happens in the `collector` module. In this phase, we recursively walk
-//! tree of modules, collect raw items from submodules, populate module scopes
-//! with defined items (so, we assign item ids in this phase) and record the set
-//! of unresolved imports and macros.
-//!
-//! While we walk tree of modules, we also record macro_rules definitions and
-//! expand calls to macro_rules defined macros.
-//!
-//! ## Resolving Imports
-//!
-//! We maintain a list of currently unresolved imports. On every iteration, we
-//! try to resolve some imports from this list. If the import is resolved, we
-//! record it, by adding an item to current module scope and, if necessary, by
-//! recursively populating glob imports.
-//!
-//! ## Resolving Macros
-//!
-//! macro_rules from the same crate use a global mutable namespace. We expand
-//! them immediately, when we collect modules.
-//!
-//! Macros from other crates (including proc-macros) can be used with
-//! `foo::bar!` syntax. We handle them similarly to imports. There's a list of
-//! unexpanded macros. On every iteration, we try to resolve each macro call
-//! path and, upon success, we run macro expansion and "collect module" phase
-//! on the result
-
-pub use hir_def::nameres::{
-    per_ns::{Namespace, PerNs},
-    raw::ImportId,
-};
diff --git a/crates/ra_hir/src/resolve.rs b/crates/ra_hir/src/resolve.rs
index 3e3f8c252..b932b0c8c 100644
--- a/crates/ra_hir/src/resolve.rs
+++ b/crates/ra_hir/src/resolve.rs
@@ -19,8 +19,8 @@ use crate::{
     },
     generics::GenericParams,
     impl_block::ImplBlock,
-    nameres::PerNs,
-    Adt, Const, Enum, EnumVariant, Function, MacroDef, ModuleDef, Static, Struct, Trait, TypeAlias,
+    Adt, Const, Enum, EnumVariant, Function, MacroDef, ModuleDef, PerNs, Static, Struct, Trait,
+    TypeAlias,
 };
 
 #[derive(Debug, Clone, Default)]
diff --git a/crates/ra_hir/src/ty/infer/expr.rs b/crates/ra_hir/src/ty/infer/expr.rs
index fed52df39..a09ef5c5d 100644
--- a/crates/ra_hir/src/ty/infer/expr.rs
+++ b/crates/ra_hir/src/ty/infer/expr.rs
@@ -11,12 +11,11 @@ use crate::{
     db::HirDatabase,
     expr::{self, Array, BinaryOp, Expr, ExprId, Literal, Statement, UnaryOp},
     generics::{GenericParams, HasGenericParams},
-    nameres::Namespace,
     ty::{
         autoderef, method_resolution, op, primitive, CallableDef, InferTy, Mutability, Obligation,
         ProjectionPredicate, ProjectionTy, Substs, TraitRef, Ty, TypeCtor, TypeWalk,
     },
-    Adt, Name,
+    Adt, Name, Namespace,
 };
 
 impl<'a, D: HirDatabase> InferenceContext<'a, D> {
diff --git a/crates/ra_hir/src/ty/lower.rs b/crates/ra_hir/src/ty/lower.rs
index 8e2834307..e29ab8492 100644
--- a/crates/ra_hir/src/ty/lower.rs
+++ b/crates/ra_hir/src/ty/lower.rs
@@ -23,15 +23,14 @@ use crate::{
     db::HirDatabase,
     generics::HasGenericParams,
     generics::{GenericDef, WherePredicate},
-    nameres::Namespace,
     resolve::{Resolver, TypeNs},
     ty::{
         primitive::{FloatTy, IntTy},
         Adt,
     },
     util::make_mut_slice,
-    Const, Enum, EnumVariant, Function, ModuleDef, Path, Static, Struct, StructField, Trait,
-    TypeAlias, Union,
+    Const, Enum, EnumVariant, Function, ModuleDef, Namespace, Path, Static, Struct, StructField,
+    Trait, TypeAlias, Union,
 };
 
 impl Ty {
diff --git a/crates/ra_hir_def/src/nameres.rs b/crates/ra_hir_def/src/nameres.rs
index b5c682219..fbd4248e6 100644
--- a/crates/ra_hir_def/src/nameres.rs
+++ b/crates/ra_hir_def/src/nameres.rs
@@ -1,4 +1,51 @@
-//! FIXME: write short doc here
+//! This module implements import-resolution/macro expansion algorithm.
+//!
+//! The result of this module is `CrateDefMap`: a data structure which contains:
+//!
+//!   * a tree of modules for the crate
+//!   * for each module, a set of items visible in the module (directly declared
+//!     or imported)
+//!
+//! Note that `CrateDefMap` contains fully macro expanded code.
+//!
+//! Computing `CrateDefMap` can be partitioned into several logically
+//! independent "phases". The phases are mutually recursive though, there's no
+//! strict ordering.
+//!
+//! ## Collecting RawItems
+//!
+//!  This happens in the `raw` module, which parses a single source file into a
+//!  set of top-level items. Nested imports are desugared to flat imports in
+//!  this phase. Macro calls are represented as a triple of (Path, Option<Name>,
+//!  TokenTree).
+//!
+//! ## Collecting Modules
+//!
+//! This happens in the `collector` module. In this phase, we recursively walk
+//! tree of modules, collect raw items from submodules, populate module scopes
+//! with defined items (so, we assign item ids in this phase) and record the set
+//! of unresolved imports and macros.
+//!
+//! While we walk tree of modules, we also record macro_rules definitions and
+//! expand calls to macro_rules defined macros.
+//!
+//! ## Resolving Imports
+//!
+//! We maintain a list of currently unresolved imports. On every iteration, we
+//! try to resolve some imports from this list. If the import is resolved, we
+//! record it, by adding an item to current module scope and, if necessary, by
+//! recursively populating glob imports.
+//!
+//! ## Resolving Macros
+//!
+//! macro_rules from the same crate use a global mutable namespace. We expand
+//! them immediately, when we collect modules.
+//!
+//! Macros from other crates (including proc-macros) can be used with
+//! `foo::bar!` syntax. We handle them similarly to imports. There's a list of
+//! unexpanded macros. On every iteration, we try to resolve each macro call
+//! path and, upon success, we run macro expansion and "collect module" phase
+//! on the result
 
 // FIXME: review privacy of submodules
 pub mod raw;