5 files changed, 90 insertions, 50 deletions

diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs
index 45e31095c..c5cfd875f 100644
--- a/crates/ra_hir/src/code_model.rs
+++ b/crates/ra_hir/src/code_model.rs
@@ -10,7 +10,7 @@ use hir_def::{
     docs::Documentation,
     expr::{BindingAnnotation, Pat, PatId},
     per_ns::PerNs,
-    resolver::HasResolver,
+    resolver::{HasResolver, Resolver},
     type_ref::{Mutability, TypeRef},
     AdtId, AssocContainerId, ConstId, DefWithBodyId, EnumId, FunctionId, GenericDefId, HasModule,
     ImplId, LocalEnumVariantId, LocalModuleId, LocalStructFieldId, Lookup, ModuleId, StaticId,
@@ -33,7 +33,11 @@ use ra_syntax::{
 };
 use rustc_hash::FxHashSet;
 
-use crate::{db::HirDatabase, has_source::HasSource, CallableDef, HirDisplay, InFile, Name};
+use crate::{
+    db::{DefDatabase, HirDatabase},
+    has_source::HasSource,
+    CallableDef, HirDisplay, InFile, Name,
+};
 
 /// hir::Crate describes a single crate. It's the main interface with which
 /// a crate's dependencies interact. Mostly, it should be just a proxy for the
@@ -274,20 +278,10 @@ impl Module {
     /// this module, if possible.
     pub fn find_use_path(
         self,
-        db: &dyn HirDatabase,
-        item: ModuleDef,
+        db: &dyn DefDatabase,
+        item: impl Into<ItemInNs>,
     ) -> Option<hir_def::path::ModPath> {
-        // FIXME expose namespace choice
-        hir_def::find_path::find_path(db.upcast(), determine_item_namespace(item), self.into())
-    }
-}
-
-fn determine_item_namespace(module_def: ModuleDef) -> ItemInNs {
-    match module_def {
-        ModuleDef::Static(_) | ModuleDef::Const(_) | ModuleDef::Function(_) => {
-            ItemInNs::Values(module_def.into())
-        }
-        _ => ItemInNs::Types(module_def.into()),
+        hir_def::find_path::find_path(db, item.into(), self.into())
     }
 }
 
@@ -912,10 +906,8 @@ impl Local {
         let def = DefWithBodyId::from(self.parent);
         let infer = db.infer(def);
         let ty = infer[self.pat_id].clone();
-        let resolver = def.resolver(db.upcast());
         let krate = def.module(db.upcast()).krate;
-        let environment = TraitEnvironment::lower(db, &resolver);
-        Type { krate, ty: InEnvironment { value: ty, environment } }
+        Type::new(db, krate, def, ty)
     }
 
     pub fn source(self, db: &dyn HirDatabase) -> InFile<Either<ast::BindPat, ast::SelfParam>> {
@@ -1020,11 +1012,21 @@ impl ImplDef {
 
 #[derive(Clone, PartialEq, Eq, Debug)]
 pub struct Type {
-    pub(crate) krate: CrateId,
-    pub(crate) ty: InEnvironment<Ty>,
+    krate: CrateId,
+    ty: InEnvironment<Ty>,
 }
 
 impl Type {
+    pub(crate) fn new_with_resolver(
+        db: &dyn HirDatabase,
+        resolver: &Resolver,
+        ty: Ty,
+    ) -> Option<Type> {
+        let krate = resolver.krate()?;
+        let environment = TraitEnvironment::lower(db, &resolver);
+        Some(Type { krate, ty: InEnvironment { value: ty, environment } })
+    }
+
     fn new(db: &dyn HirDatabase, krate: CrateId, lexical_env: impl HasResolver, ty: Ty) -> Type {
         let resolver = lexical_env.resolver(db.upcast());
         let environment = TraitEnvironment::lower(db, &resolver);
@@ -1042,30 +1044,18 @@ impl Type {
     }
 
     pub fn is_bool(&self) -> bool {
-        match &self.ty.value {
-            Ty::Apply(a_ty) => match a_ty.ctor {
-                TypeCtor::Bool => true,
-                _ => false,
-            },
-            _ => false,
-        }
+        matches!(self.ty.value, Ty::Apply(ApplicationTy { ctor: TypeCtor::Bool, .. }))
     }
 
     pub fn is_mutable_reference(&self) -> bool {
-        match &self.ty.value {
-            Ty::Apply(a_ty) => match a_ty.ctor {
-                TypeCtor::Ref(Mutability::Mut) => true,
-                _ => false,
-            },
-            _ => false,
-        }
+        matches!(
+            self.ty.value,
+            Ty::Apply(ApplicationTy { ctor: TypeCtor::Ref(Mutability::Mut), .. })
+        )
     }
 
     pub fn is_unknown(&self) -> bool {
-        match &self.ty.value {
-            Ty::Unknown => true,
-            _ => false,
-        }
+        matches!(self.ty.value, Ty::Unknown)
     }
 
     /// Checks that particular type `ty` implements `std::future::Future`.
diff --git a/crates/ra_hir/src/from_id.rs b/crates/ra_hir/src/from_id.rs
index c179b13c6..62fb52e72 100644
--- a/crates/ra_hir/src/from_id.rs
+++ b/crates/ra_hir/src/from_id.rs
@@ -9,8 +9,8 @@ use hir_def::{
 };
 
 use crate::{
-    Adt, AssocItem, AttrDef, DefWithBody, EnumVariant, GenericDef, Local, ModuleDef, StructField,
-    VariantDef,
+    code_model::ItemInNs, Adt, AssocItem, AttrDef, DefWithBody, EnumVariant, GenericDef, Local,
+    MacroDef, ModuleDef, StructField, VariantDef,
 };
 
 macro_rules! from_id {
@@ -228,3 +228,20 @@ impl From<(DefWithBodyId, PatId)> for Local {
         Local { parent, pat_id }
     }
 }
+
+impl From<MacroDef> for ItemInNs {
+    fn from(macro_def: MacroDef) -> Self {
+        ItemInNs::Macros(macro_def.into())
+    }
+}
+
+impl From<ModuleDef> for ItemInNs {
+    fn from(module_def: ModuleDef) -> Self {
+        match module_def {
+            ModuleDef::Static(_) | ModuleDef::Const(_) | ModuleDef::Function(_) => {
+                ItemInNs::Values(module_def.into())
+            }
+            _ => ItemInNs::Types(module_def.into()),
+        }
+    }
+}
diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs
index 9f59d590c..713d45f48 100644
--- a/crates/ra_hir/src/lib.rs
+++ b/crates/ra_hir/src/lib.rs
@@ -4,6 +4,18 @@
 //! The principal difference between HIR and syntax trees is that HIR is bound
 //! to a particular crate instance. That is, it has cfg flags and features
 //! applied. So, the relation between syntax and HIR is many-to-one.
+//!
+//! HIR is the public API of the all of the compiler logic above syntax trees.
+//! It is written in "OO" style. Each type is self contained (as in, it knows it's
+//! parents and full context). It should be "clean code".
+//!
+//! `ra_hir_*` crates are the implementation of the compiler logic.
+//! They are written in "ECS" style, with relatively little abstractions.
+//! Many types are not self-contained, and explicitly use local indexes, arenas, etc.
+//!
+//! `ra_hir` is what insulates the "we don't know how to actually write an incremental compiler"
+//! from the ide with completions, hovers, etc. It is a (soft, internal) boundary:
+//! https://www.tedinski.com/2018/02/06/system-boundaries.html.
 
 #![recursion_limit = "512"]
 
diff --git a/crates/ra_hir/src/semantics.rs b/crates/ra_hir/src/semantics.rs
index 55e634528..d982f6ffa 100644
--- a/crates/ra_hir/src/semantics.rs
+++ b/crates/ra_hir/src/semantics.rs
@@ -12,7 +12,8 @@ use hir_expand::ExpansionInfo;
 use ra_db::{FileId, FileRange};
 use ra_prof::profile;
 use ra_syntax::{
-    algo::skip_trivia_token, ast, AstNode, Direction, SyntaxNode, SyntaxToken, TextRange, TextUnit,
+    algo::{find_node_at_offset, skip_trivia_token},
+    ast, AstNode, Direction, SyntaxNode, SyntaxToken, TextRange, TextUnit,
 };
 use rustc_hash::{FxHashMap, FxHashSet};
 
@@ -108,6 +109,17 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
         token.value
     }
 
+    pub fn descend_node_at_offset<N: ast::AstNode>(
+        &self,
+        node: &SyntaxNode,
+        offset: TextUnit,
+    ) -> Option<N> {
+        // Handle macro token cases
+        node.token_at_offset(offset)
+            .map(|token| self.descend_into_macros(token))
+            .find_map(|it| self.ancestors_with_macros(it.parent()).find_map(N::cast))
+    }
+
     pub fn original_range(&self, node: &SyntaxNode) -> FileRange {
         let node = self.find_file(node.clone());
         original_range(self.db, node.as_ref())
@@ -129,6 +141,8 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
             .kmerge_by(|node1, node2| node1.text_range().len() < node2.text_range().len())
     }
 
+    /// Find a AstNode by offset inside SyntaxNode, if it is inside *Macrofile*,
+    /// search up until it is of the target AstNode type
     pub fn find_node_at_offset_with_macros<N: AstNode>(
         &self,
         node: &SyntaxNode,
@@ -137,6 +151,19 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
         self.ancestors_at_offset_with_macros(node, offset).find_map(N::cast)
     }
 
+    /// Find a AstNode by offset inside SyntaxNode, if it is inside *MacroCall*,
+    /// descend it and find again
+    pub fn find_node_at_offset_with_descend<N: AstNode>(
+        &self,
+        node: &SyntaxNode,
+        offset: TextUnit,
+    ) -> Option<N> {
+        if let Some(it) = find_node_at_offset(&node, offset) {
+            return Some(it);
+        }
+        self.descend_node_at_offset(&node, offset)
+    }
+
     pub fn type_of_expr(&self, expr: &ast::Expr) -> Option<Type> {
         self.analyze(expr.syntax()).type_of(self.db, &expr)
     }
diff --git a/crates/ra_hir/src/source_analyzer.rs b/crates/ra_hir/src/source_analyzer.rs
index e8afef328..10c12c910 100644
--- a/crates/ra_hir/src/source_analyzer.rs
+++ b/crates/ra_hir/src/source_analyzer.rs
@@ -17,7 +17,7 @@ use hir_def::{
     AsMacroCall, DefWithBodyId,
 };
 use hir_expand::{hygiene::Hygiene, name::AsName, HirFileId, InFile};
-use hir_ty::{InEnvironment, InferenceResult, TraitEnvironment};
+use hir_ty::InferenceResult;
 use ra_syntax::{
     ast::{self, AstNode},
     SyntaxNode, SyntaxNodePtr, TextUnit,
@@ -103,10 +103,6 @@ impl SourceAnalyzer {
         Some(res)
     }
 
-    fn trait_env(&self, db: &dyn HirDatabase) -> Arc<TraitEnvironment> {
-        TraitEnvironment::lower(db, &self.resolver)
-    }
-
     pub(crate) fn type_of(&self, db: &dyn HirDatabase, expr: &ast::Expr) -> Option<Type> {
         let expr_id = match expr {
             ast::Expr::MacroCall(call) => {
@@ -117,15 +113,13 @@ impl SourceAnalyzer {
         }?;
 
         let ty = self.infer.as_ref()?[expr_id].clone();
-        let environment = self.trait_env(db);
-        Some(Type { krate: self.resolver.krate()?, ty: InEnvironment { value: ty, environment } })
+        Type::new_with_resolver(db, &self.resolver, ty)
     }
 
     pub(crate) fn type_of_pat(&self, db: &dyn HirDatabase, pat: &ast::Pat) -> Option<Type> {
         let pat_id = self.pat_id(pat)?;
         let ty = self.infer.as_ref()?[pat_id].clone();
-        let environment = self.trait_env(db);
-        Some(Type { krate: self.resolver.krate()?, ty: InEnvironment { value: ty, environment } })
+        Type::new_with_resolver(db, &self.resolver, ty)
     }
 
     pub(crate) fn resolve_method_call(&self, call: &ast::MethodCallExpr) -> Option<Function> {