27 files changed, 929 insertions, 466 deletions

diff --git a/crates/ra_hir/src/adt.rs b/crates/ra_hir/src/adt.rs
index 22bbad964..c549e2126 100644
--- a/crates/ra_hir/src/adt.rs
+++ b/crates/ra_hir/src/adt.rs
@@ -12,7 +12,7 @@ use ra_syntax::{
 use crate::{
     Name, AsName, Struct, Enum, EnumVariant, Crate,
     HirDatabase, HirFileId, StructField, FieldSource,
-    type_ref::TypeRef,
+    type_ref::TypeRef, PersistentHirDatabase,
 };
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
@@ -33,7 +33,7 @@ impl AdtDef {
 }
 
 impl Struct {
-    pub(crate) fn variant_data(&self, db: &impl HirDatabase) -> Arc<VariantData> {
+    pub(crate) fn variant_data(&self, db: &impl PersistentHirDatabase) -> Arc<VariantData> {
         db.struct_data((*self).into()).variant_data.clone()
     }
 }
@@ -52,7 +52,10 @@ impl StructData {
         StructData { name, variant_data }
     }
 
-    pub(crate) fn struct_data_query(db: &impl HirDatabase, struct_: Struct) -> Arc<StructData> {
+    pub(crate) fn struct_data_query(
+        db: &impl PersistentHirDatabase,
+        struct_: Struct,
+    ) -> Arc<StructData> {
         let (_, struct_def) = struct_.source(db);
         Arc::new(StructData::new(&*struct_def))
     }
@@ -68,7 +71,7 @@ fn variants(enum_def: &ast::EnumDef) -> impl Iterator<Item = &ast::EnumVariant>
 impl EnumVariant {
     pub(crate) fn source_impl(
         &self,
-        db: &impl HirDatabase,
+        db: &impl PersistentHirDatabase,
     ) -> (HirFileId, TreeArc<ast::EnumVariant>) {
         let (file_id, enum_def) = self.parent.source(db);
         let var = variants(&*enum_def)
@@ -79,7 +82,7 @@ impl EnumVariant {
             .to_owned();
         (file_id, var)
     }
-    pub(crate) fn variant_data(&self, db: &impl HirDatabase) -> Arc<VariantData> {
+    pub(crate) fn variant_data(&self, db: &impl PersistentHirDatabase) -> Arc<VariantData> {
         db.enum_data(self.parent).variants[self.id]
             .variant_data
             .clone()
@@ -93,7 +96,7 @@ pub struct EnumData {
 }
 
 impl EnumData {
-    pub(crate) fn enum_data_query(db: &impl HirDatabase, e: Enum) -> Arc<EnumData> {
+    pub(crate) fn enum_data_query(db: &impl PersistentHirDatabase, e: Enum) -> Arc<EnumData> {
         let (_file_id, enum_def) = e.source(db);
         let name = enum_def.name().map(|n| n.as_name());
         let variants = variants(&*enum_def)
@@ -191,7 +194,7 @@ impl VariantDef {
             VariantDef::EnumVariant(it) => it.field(db, name),
         }
     }
-    pub(crate) fn variant_data(self, db: &impl HirDatabase) -> Arc<VariantData> {
+    pub(crate) fn variant_data(self, db: &impl PersistentHirDatabase) -> Arc<VariantData> {
         match self {
             VariantDef::Struct(it) => it.variant_data(db),
             VariantDef::EnumVariant(it) => it.variant_data(db),
@@ -200,7 +203,7 @@ impl VariantDef {
 }
 
 impl StructField {
-    pub(crate) fn source_impl(&self, db: &impl HirDatabase) -> (HirFileId, FieldSource) {
+    pub(crate) fn source_impl(&self, db: &impl PersistentHirDatabase) -> (HirFileId, FieldSource) {
         let var_data = self.parent.variant_data(db);
         let fields = var_data.fields().unwrap();
         let ss;
diff --git a/crates/ra_hir/src/code_model_api.rs b/crates/ra_hir/src/code_model_api.rs
index 9405aa8ad..92ab0f692 100644
--- a/crates/ra_hir/src/code_model_api.rs
+++ b/crates/ra_hir/src/code_model_api.rs
@@ -5,18 +5,19 @@ use ra_db::{CrateId, FileId};
 use ra_syntax::{ast::self, TreeArc, SyntaxNode};
 
 use crate::{
-    Name, Path, PerNs, ScopesWithSyntaxMapping, Ty, HirFileId,
+    Name, ScopesWithSyntaxMapping, Ty, HirFileId,
     type_ref::TypeRef,
     nameres::{ModuleScope, lower::ImportId},
-    db::HirDatabase,
-    expr::BodySyntaxMapping,
-    ty::{InferenceResult},
+    HirDatabase, PersistentHirDatabase,
+    expr::{Body, BodySyntaxMapping},
+    ty::InferenceResult,
     adt::{EnumVariantId, StructFieldId, VariantDef},
     generics::GenericParams,
     docs::{Documentation, Docs, docs_from_ast},
     module_tree::ModuleId,
     ids::{FunctionId, StructId, EnumId, AstItemDef, ConstId, StaticId, TraitId, TypeId},
     impl_block::ImplId,
+    resolve::Resolver,
 };
 
 /// hir::Crate describes a single crate. It's the main interface with which
@@ -37,10 +38,10 @@ impl Crate {
     pub fn crate_id(&self) -> CrateId {
         self.crate_id
     }
-    pub fn dependencies(&self, db: &impl HirDatabase) -> Vec<CrateDependency> {
+    pub fn dependencies(&self, db: &impl PersistentHirDatabase) -> Vec<CrateDependency> {
         self.dependencies_impl(db)
     }
-    pub fn root_module(&self, db: &impl HirDatabase) -> Option<Module> {
+    pub fn root_module(&self, db: &impl PersistentHirDatabase) -> Option<Module> {
         self.root_module_impl(db)
     }
 }
@@ -105,7 +106,7 @@ impl Module {
     }
 
     /// Returns a node which defines this module. That is, a file or a `mod foo {}` with items.
-    pub fn definition_source(&self, db: &impl HirDatabase) -> (FileId, ModuleSource) {
+    pub fn definition_source(&self, db: &impl PersistentHirDatabase) -> (FileId, ModuleSource) {
         self.definition_source_impl(db)
     }
 
@@ -140,7 +141,7 @@ impl Module {
     /// Topmost parent of this module. Every module has a `crate_root`, but some
     /// might be missing `krate`. This can happen if a module's file is not included
     /// in the module tree of any target in Cargo.toml.
-    pub fn crate_root(&self, db: &impl HirDatabase) -> Module {
+    pub fn crate_root(&self, db: &impl PersistentHirDatabase) -> Module {
         self.crate_root_impl(db)
     }
 
@@ -150,12 +151,12 @@ impl Module {
     }
 
     /// Iterates over all child modules.
-    pub fn children(&self, db: &impl HirDatabase) -> impl Iterator<Item = Module> {
+    pub fn children(&self, db: &impl PersistentHirDatabase) -> impl Iterator<Item = Module> {
         self.children_impl(db)
     }
 
     /// Finds a parent module.
-    pub fn parent(&self, db: &impl HirDatabase) -> Option<Module> {
+    pub fn parent(&self, db: &impl PersistentHirDatabase) -> Option<Module> {
         self.parent_impl(db)
     }
 
@@ -174,13 +175,14 @@ impl Module {
         db.item_map(self.krate)[self.module_id].clone()
     }
 
-    pub fn resolve_path(&self, db: &impl HirDatabase, path: &Path) -> PerNs<ModuleDef> {
-        db.item_map(self.krate).resolve_path(db, *self, path)
-    }
-
     pub fn problems(&self, db: &impl HirDatabase) -> Vec<(TreeArc<SyntaxNode>, Problem)> {
         self.problems_impl(db)
     }
+
+    pub fn resolver(&self, db: &impl HirDatabase) -> Resolver {
+        let item_map = db.item_map(self.krate);
+        Resolver::default().push_module_scope(item_map, *self)
+    }
 }
 
 impl Docs for Module {
@@ -209,7 +211,7 @@ impl StructField {
             .clone()
     }
 
-    pub fn source(&self, db: &impl HirDatabase) -> (HirFileId, FieldSource) {
+    pub fn source(&self, db: &impl PersistentHirDatabase) -> (HirFileId, FieldSource) {
         self.source_impl(db)
     }
 
@@ -237,7 +239,7 @@ pub struct Struct {
 }
 
 impl Struct {
-    pub fn source(&self, db: &impl HirDatabase) -> (HirFileId, TreeArc<ast::StructDef>) {
+    pub fn source(&self, db: &impl PersistentHirDatabase) -> (HirFileId, TreeArc<ast::StructDef>) {
         self.id.source(db)
     }
 
@@ -275,13 +277,28 @@ impl Struct {
             })
     }
 
-    pub fn generic_params(&self, db: &impl HirDatabase) -> Arc<GenericParams> {
+    pub fn generic_params(&self, db: &impl PersistentHirDatabase) -> Arc<GenericParams> {
         db.generic_params((*self).into())
     }
 
     pub fn ty(&self, db: &impl HirDatabase) -> Ty {
         db.type_for_def((*self).into())
     }
+
+    // TODO move to a more general type
+    /// Builds a resolver for type references inside this struct.
+    pub fn resolver(&self, db: &impl HirDatabase) -> Resolver {
+        // take the outer scope...
+        let r = self.module(db).resolver(db);
+        // ...and add generic params, if present
+        let p = self.generic_params(db);
+        let r = if !p.params.is_empty() {
+            r.push_generic_params_scope(p)
+        } else {
+            r
+        };
+        r
+    }
 }
 
 impl Docs for Struct {
@@ -296,7 +313,7 @@ pub struct Enum {
 }
 
 impl Enum {
-    pub fn source(&self, db: &impl HirDatabase) -> (HirFileId, TreeArc<ast::EnumDef>) {
+    pub fn source(&self, db: &impl PersistentHirDatabase) -> (HirFileId, TreeArc<ast::EnumDef>) {
         self.id.source(db)
     }
 
@@ -316,7 +333,7 @@ impl Enum {
             .collect()
     }
 
-    pub fn variant(&self, db: &impl HirDatabase, name: &Name) -> Option<EnumVariant> {
+    pub fn variant(&self, db: &impl PersistentHirDatabase, name: &Name) -> Option<EnumVariant> {
         db.enum_data(*self)
             .variants
             .iter()
@@ -324,13 +341,28 @@ impl Enum {
             .map(|(id, _)| EnumVariant { parent: *self, id })
     }
 
-    pub fn generic_params(&self, db: &impl HirDatabase) -> Arc<GenericParams> {
+    pub fn generic_params(&self, db: &impl PersistentHirDatabase) -> Arc<GenericParams> {
         db.generic_params((*self).into())
     }
 
     pub fn ty(&self, db: &impl HirDatabase) -> Ty {
         db.type_for_def((*self).into())
     }
+
+    // TODO move to a more general type
+    /// Builds a resolver for type references inside this struct.
+    pub fn resolver(&self, db: &impl HirDatabase) -> Resolver {
+        // take the outer scope...
+        let r = self.module(db).resolver(db);
+        // ...and add generic params, if present
+        let p = self.generic_params(db);
+        let r = if !p.params.is_empty() {
+            r.push_generic_params_scope(p)
+        } else {
+            r
+        };
+        r
+    }
 }
 
 impl Docs for Enum {
@@ -346,13 +378,16 @@ pub struct EnumVariant {
 }
 
 impl EnumVariant {
-    pub fn source(&self, db: &impl HirDatabase) -> (HirFileId, TreeArc<ast::EnumVariant>) {
+    pub fn source(
+        &self,
+        db: &impl PersistentHirDatabase,
+    ) -> (HirFileId, TreeArc<ast::EnumVariant>) {
         self.source_impl(db)
     }
     pub fn module(&self, db: &impl HirDatabase) -> Module {
         self.parent.module(db)
     }
-    pub fn parent_enum(&self, _db: &impl HirDatabase) -> Enum {
+    pub fn parent_enum(&self, _db: &impl PersistentHirDatabase) -> Enum {
         self.parent
     }
 
@@ -430,7 +465,7 @@ impl FnSignature {
 }
 
 impl Function {
-    pub fn source(&self, db: &impl HirDatabase) -> (HirFileId, TreeArc<ast::FnDef>) {
+    pub fn source(&self, db: &impl PersistentHirDatabase) -> (HirFileId, TreeArc<ast::FnDef>) {
         self.id.source(db)
     }
 
@@ -446,6 +481,10 @@ impl Function {
         db.body_syntax_mapping(*self)
     }
 
+    pub fn body(&self, db: &impl HirDatabase) -> Arc<Body> {
+        db.body_hir(*self)
+    }
+
     pub fn scopes(&self, db: &impl HirDatabase) -> ScopesWithSyntaxMapping {
         let scopes = db.expr_scopes(*self);
         let syntax_mapping = db.body_syntax_mapping(*self);
@@ -463,9 +502,27 @@ impl Function {
         db.infer(*self)
     }
 
-    pub fn generic_params(&self, db: &impl HirDatabase) -> Arc<GenericParams> {
+    pub fn generic_params(&self, db: &impl PersistentHirDatabase) -> Arc<GenericParams> {
         db.generic_params((*self).into())
     }
+
+    // TODO move to a more general type for 'body-having' items
+    /// Builds a resolver for code inside this item.
+    pub fn resolver(&self, db: &impl HirDatabase) -> Resolver {
+        // take the outer scope...
+        let r = self
+            .impl_block(db)
+            .map(|ib| ib.resolver(db))
+            .unwrap_or_else(|| self.module(db).resolver(db));
+        // ...and add generic params, if present
+        let p = self.generic_params(db);
+        let r = if !p.params.is_empty() {
+            r.push_generic_params_scope(p)
+        } else {
+            r
+        };
+        r
+    }
 }
 
 impl Docs for Function {
@@ -480,7 +537,7 @@ pub struct Const {
 }
 
 impl Const {
-    pub fn source(&self, db: &impl HirDatabase) -> (HirFileId, TreeArc<ast::ConstDef>) {
+    pub fn source(&self, db: &impl PersistentHirDatabase) -> (HirFileId, TreeArc<ast::ConstDef>) {
         self.id.source(db)
     }
 }
@@ -497,7 +554,7 @@ pub struct Static {
 }
 
 impl Static {
-    pub fn source(&self, db: &impl HirDatabase) -> (HirFileId, TreeArc<ast::StaticDef>) {
+    pub fn source(&self, db: &impl PersistentHirDatabase) -> (HirFileId, TreeArc<ast::StaticDef>) {
         self.id.source(db)
     }
 }
@@ -514,11 +571,11 @@ pub struct Trait {
 }
 
 impl Trait {
-    pub fn source(&self, db: &impl HirDatabase) -> (HirFileId, TreeArc<ast::TraitDef>) {
+    pub fn source(&self, db: &impl PersistentHirDatabase) -> (HirFileId, TreeArc<ast::TraitDef>) {
         self.id.source(db)
     }
 
-    pub fn generic_params(&self, db: &impl HirDatabase) -> Arc<GenericParams> {
+    pub fn generic_params(&self, db: &impl PersistentHirDatabase) -> Arc<GenericParams> {
         db.generic_params((*self).into())
     }
 }
@@ -535,11 +592,11 @@ pub struct Type {
 }
 
 impl Type {
-    pub fn source(&self, db: &impl HirDatabase) -> (HirFileId, TreeArc<ast::TypeDef>) {
+    pub fn source(&self, db: &impl PersistentHirDatabase) -> (HirFileId, TreeArc<ast::TypeDef>) {
         self.id.source(db)
     }
 
-    pub fn generic_params(&self, db: &impl HirDatabase) -> Arc<GenericParams> {
+    pub fn generic_params(&self, db: &impl PersistentHirDatabase) -> Arc<GenericParams> {
         db.generic_params((*self).into())
     }
 }
diff --git a/crates/ra_hir/src/code_model_impl/function.rs b/crates/ra_hir/src/code_model_impl/function.rs
index 422643996..8326c02c7 100644
--- a/crates/ra_hir/src/code_model_impl/function.rs
+++ b/crates/ra_hir/src/code_model_impl/function.rs
@@ -5,14 +5,12 @@ use ra_syntax::ast::{self, NameOwner};
 use crate::{
     HirDatabase, Name, AsName, Function, FnSignature,
     type_ref::{TypeRef, Mutability},
-    expr::Body,
+    PersistentHirDatabase,
     impl_block::ImplBlock,
 };
 
 impl Function {
-    pub(crate) fn body(&self, db: &impl HirDatabase) -> Arc<Body> {
-        db.body_hir(*self)
-    }
+    // TODO impl_block should probably also be part of the code model API?
 
     /// The containing impl block, if this is a method.
     pub(crate) fn impl_block(&self, db: &impl HirDatabase) -> Option<ImplBlock> {
@@ -22,7 +20,10 @@ impl Function {
 }
 
 impl FnSignature {
-    pub(crate) fn fn_signature_query(db: &impl HirDatabase, func: Function) -> Arc<FnSignature> {
+    pub(crate) fn fn_signature_query(
+        db: &impl PersistentHirDatabase,
+        func: Function,
+    ) -> Arc<FnSignature> {
         let (_, node) = func.source(db);
         let name = node
             .name()
diff --git a/crates/ra_hir/src/code_model_impl/krate.rs b/crates/ra_hir/src/code_model_impl/krate.rs
index 86f29d959..1517434b8 100644
--- a/crates/ra_hir/src/code_model_impl/krate.rs
+++ b/crates/ra_hir/src/code_model_impl/krate.rs
@@ -1,10 +1,12 @@
 use crate::{
-    Crate, CrateDependency, AsName, Module,
-    db::HirDatabase,
+    Crate, CrateDependency, AsName, Module, PersistentHirDatabase,
 };
 
 impl Crate {
-    pub(crate) fn dependencies_impl(&self, db: &impl HirDatabase) -> Vec<CrateDependency> {
+    pub(crate) fn dependencies_impl(
+        &self,
+        db: &impl PersistentHirDatabase,
+    ) -> Vec<CrateDependency> {
         let crate_graph = db.crate_graph();
         crate_graph
             .dependencies(self.crate_id)
@@ -17,7 +19,7 @@ impl Crate {
             })
             .collect()
     }
-    pub(crate) fn root_module_impl(&self, db: &impl HirDatabase) -> Option<Module> {
+    pub(crate) fn root_module_impl(&self, db: &impl PersistentHirDatabase) -> Option<Module> {
         let module_tree = db.module_tree(*self);
         let module_id = module_tree.modules().next()?;
 
diff --git a/crates/ra_hir/src/code_model_impl/module.rs b/crates/ra_hir/src/code_model_impl/module.rs
index 4a3901b8b..f487b8532 100644
--- a/crates/ra_hir/src/code_model_impl/module.rs
+++ b/crates/ra_hir/src/code_model_impl/module.rs
@@ -7,7 +7,7 @@ use crate::{
     module_tree::ModuleId,
     impl_block::ImplId,
     nameres::{lower::ImportId},
-    db::HirDatabase,
+    HirDatabase, PersistentHirDatabase,
 };
 
 impl Module {
@@ -24,7 +24,10 @@ impl Module {
         Some(link.name(&module_tree).clone())
     }
 
-    pub(crate) fn definition_source_impl(&self, db: &impl HirDatabase) -> (FileId, ModuleSource) {
+    pub(crate) fn definition_source_impl(
+        &self,
+        db: &impl PersistentHirDatabase,
+    ) -> (FileId, ModuleSource) {
         let module_tree = db.module_tree(self.krate);
         let file_id = self.module_id.file_id(&module_tree);
         let decl_id = self.module_id.decl_id(&module_tree);
@@ -67,7 +70,7 @@ impl Module {
         source_map.get(&source, impl_id)
     }
 
-    pub(crate) fn crate_root_impl(&self, db: &impl HirDatabase) -> Module {
+    pub(crate) fn crate_root_impl(&self, db: &impl PersistentHirDatabase) -> Module {
         let module_tree = db.module_tree(self.krate);
         let module_id = self.module_id.crate_root(&module_tree);
         self.with_module_id(module_id)
@@ -81,7 +84,10 @@ impl Module {
     }
 
     /// Iterates over all child modules.
-    pub(crate) fn children_impl(&self, db: &impl HirDatabase) -> impl Iterator<Item = Module> {
+    pub(crate) fn children_impl(
+        &self,
+        db: &impl PersistentHirDatabase,
+    ) -> impl Iterator<Item = Module> {
         let module_tree = db.module_tree(self.krate);
         let children = self
             .module_id
@@ -91,7 +97,7 @@ impl Module {
         children.into_iter()
     }
 
-    pub(crate) fn parent_impl(&self, db: &impl HirDatabase) -> Option<Module> {
+    pub(crate) fn parent_impl(&self, db: &impl PersistentHirDatabase) -> Option<Module> {
         let module_tree = db.module_tree(self.krate);
         let parent_id = self.module_id.parent(&module_tree)?;
         Some(self.with_module_id(parent_id))
diff --git a/crates/ra_hir/src/db.rs b/crates/ra_hir/src/db.rs
index 189649841..6b21fe744 100644
--- a/crates/ra_hir/src/db.rs
+++ b/crates/ra_hir/src/db.rs
@@ -19,32 +19,20 @@ use crate::{
     ids::SourceFileItemId,
 };
 
-#[salsa::query_group(HirDatabaseStorage)]
-pub trait HirDatabase: SourceDatabase + AsRef<HirInterner> {
+#[salsa::query_group(PersistentHirDatabaseStorage)]
+pub trait PersistentHirDatabase: SourceDatabase + AsRef<HirInterner> {
     #[salsa::invoke(HirFileId::hir_parse)]
     fn hir_parse(&self, file_id: HirFileId) -> TreeArc<SourceFile>;
 
     #[salsa::invoke(crate::macros::expand_macro_invocation)]
     fn expand_macro_invocation(&self, invoc: MacroCallId) -> Option<Arc<MacroExpansion>>;
 
-    #[salsa::invoke(ExprScopes::expr_scopes_query)]
-    fn expr_scopes(&self, func: Function) -> Arc<ExprScopes>;
-
     #[salsa::invoke(crate::adt::StructData::struct_data_query)]
     fn struct_data(&self, s: Struct) -> Arc<StructData>;
 
     #[salsa::invoke(crate::adt::EnumData::enum_data_query)]
     fn enum_data(&self, e: Enum) -> Arc<EnumData>;
 
-    #[salsa::invoke(crate::ty::infer)]
-    fn infer(&self, func: Function) -> Arc<InferenceResult>;
-
-    #[salsa::invoke(crate::ty::type_for_def)]
-    fn type_for_def(&self, def: TypableDef) -> Ty;
-
-    #[salsa::invoke(crate::ty::type_for_field)]
-    fn type_for_field(&self, field: StructField) -> Ty;
-
     #[salsa::invoke(query_definitions::file_items)]
     fn file_items(&self, file_id: HirFileId) -> Arc<SourceFileItems>;
 
@@ -73,20 +61,38 @@ pub trait HirDatabase: SourceDatabase + AsRef<HirInterner> {
     #[salsa::invoke(crate::module_tree::ModuleTree::module_tree_query)]
     fn module_tree(&self, krate: Crate) -> Arc<ModuleTree>;
 
+    #[salsa::invoke(crate::impl_block::impls_in_module)]
+    fn impls_in_module(&self, module: Module) -> Arc<ModuleImplBlocks>;
+
+    #[salsa::invoke(crate::impl_block::impls_in_module_source_map_query)]
+    fn impls_in_module_source_map(&self, module: Module) -> Arc<ImplSourceMap>;
+
     #[salsa::invoke(crate::impl_block::impls_in_module_with_source_map_query)]
     fn impls_in_module_with_source_map(
         &self,
         module: Module,
     ) -> (Arc<ModuleImplBlocks>, Arc<ImplSourceMap>);
 
-    #[salsa::invoke(crate::impl_block::impls_in_module)]
-    fn impls_in_module(&self, module: Module) -> Arc<ModuleImplBlocks>;
+    #[salsa::invoke(crate::generics::GenericParams::generic_params_query)]
+    fn generic_params(&self, def: GenericDef) -> Arc<GenericParams>;
 
-    #[salsa::invoke(crate::impl_block::impls_in_module_source_map_query)]
-    fn impls_in_module_source_map(&self, module: Module) -> Arc<ImplSourceMap>;
+    #[salsa::invoke(crate::FnSignature::fn_signature_query)]
+    fn fn_signature(&self, func: Function) -> Arc<FnSignature>;
+}
 
-    #[salsa::invoke(crate::ty::method_resolution::CrateImplBlocks::impls_in_crate_query)]
-    fn impls_in_crate(&self, krate: Crate) -> Arc<CrateImplBlocks>;
+#[salsa::query_group(HirDatabaseStorage)]
+pub trait HirDatabase: PersistentHirDatabase {
+    #[salsa::invoke(ExprScopes::expr_scopes_query)]
+    fn expr_scopes(&self, func: Function) -> Arc<ExprScopes>;
+
+    #[salsa::invoke(crate::ty::infer)]
+    fn infer(&self, func: Function) -> Arc<InferenceResult>;
+
+    #[salsa::invoke(crate::ty::type_for_def)]
+    fn type_for_def(&self, def: TypableDef) -> Ty;
+
+    #[salsa::invoke(crate::ty::type_for_field)]
+    fn type_for_field(&self, field: StructField) -> Ty;
 
     #[salsa::invoke(crate::expr::body_hir)]
     fn body_hir(&self, func: Function) -> Arc<crate::expr::Body>;
@@ -94,9 +100,6 @@ pub trait HirDatabase: SourceDatabase + AsRef<HirInterner> {
     #[salsa::invoke(crate::expr::body_syntax_mapping)]
     fn body_syntax_mapping(&self, func: Function) -> Arc<crate::expr::BodySyntaxMapping>;
 
-    #[salsa::invoke(crate::generics::GenericParams::generic_params_query)]
-    fn generic_params(&self, def: GenericDef) -> Arc<GenericParams>;
-
-    #[salsa::invoke(crate::FnSignature::fn_signature_query)]
-    fn fn_signature(&self, func: Function) -> Arc<FnSignature>;
+    #[salsa::invoke(crate::ty::method_resolution::CrateImplBlocks::impls_in_crate_query)]
+    fn impls_in_crate(&self, krate: Crate) -> Arc<CrateImplBlocks>;
 }
diff --git a/crates/ra_hir/src/expr.rs b/crates/ra_hir/src/expr.rs
index 37aa24677..f9f702ae2 100644
--- a/crates/ra_hir/src/expr.rs
+++ b/crates/ra_hir/src/expr.rs
@@ -10,7 +10,7 @@ use ra_syntax::{
 };
 
 use crate::{
-    Path, Name, HirDatabase, Function,
+    Path, Name, HirDatabase, Function, Resolver,
     name::AsName,
     type_ref::{Mutability, TypeRef},
 };
@@ -18,7 +18,7 @@ use crate::ty::primitive::{UintTy, UncertainIntTy, UncertainFloatTy};
 
 pub use self::scope::{ExprScopes, ScopesWithSyntaxMapping, ScopeEntryWithSyntax};
 
-mod scope;
+pub(crate) mod scope;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct ExprId(RawId);
@@ -27,6 +27,9 @@ impl_arena_id!(ExprId);
 /// The body of an item (function, const etc.).
 #[derive(Debug, Eq, PartialEq)]
 pub struct Body {
+    // TODO: this should be more general, consts & statics also have bodies
+    /// The Function of the item this body belongs to
+    owner: Function,
     exprs: Arena<ExprId, Expr>,
     pats: Arena<PatId, Pat>,
     /// The patterns for the function's parameters. While the parameter types are
@@ -62,6 +65,34 @@ impl Body {
     pub fn body_expr(&self) -> ExprId {
         self.body_expr
     }
+
+    pub fn owner(&self) -> Function {
+        self.owner
+    }
+
+    pub fn syntax_mapping(&self, db: &impl HirDatabase) -> Arc<BodySyntaxMapping> {
+        db.body_syntax_mapping(self.owner)
+    }
+}
+
+// needs arbitrary_self_types to be a method... or maybe move to the def?
+pub fn resolver_for_expr(body: Arc<Body>, db: &impl HirDatabase, expr_id: ExprId) -> Resolver {
+    let scopes = db.expr_scopes(body.owner);
+    resolver_for_scope(body, db, scopes.scope_for(expr_id))
+}
+
+pub fn resolver_for_scope(
+    body: Arc<Body>,
+    db: &impl HirDatabase,
+    scope_id: Option<scope::ScopeId>,
+) -> Resolver {
+    let mut r = body.owner.resolver(db);
+    let scopes = db.expr_scopes(body.owner);
+    let scope_chain = scopes.scope_chain_for(scope_id).collect::<Vec<_>>();
+    for scope in scope_chain.into_iter().rev() {
+        r = r.push_expr_scope(Arc::clone(&scopes), scope);
+    }
+    r
 }
 
 impl Index<ExprId> for Body {
@@ -448,23 +479,29 @@ pub(crate) fn body_hir(db: &impl HirDatabase, func: Function) -> Arc<Body> {
 }
 
 struct ExprCollector {
+    owner: Function,
     exprs: Arena<ExprId, Expr>,
     pats: Arena<PatId, Pat>,
     expr_syntax_mapping: FxHashMap<SyntaxNodePtr, ExprId>,
     expr_syntax_mapping_back: ArenaMap<ExprId, SyntaxNodePtr>,
     pat_syntax_mapping: FxHashMap<SyntaxNodePtr, PatId>,
     pat_syntax_mapping_back: ArenaMap<PatId, SyntaxNodePtr>,
+    params: Vec<PatId>,
+    body_expr: Option<ExprId>,
 }
 
 impl ExprCollector {
-    fn new() -> Self {
+    fn new(owner: Function) -> Self {
         ExprCollector {
+            owner,
             exprs: Arena::default(),
             pats: Arena::default(),
             expr_syntax_mapping: FxHashMap::default(),
             expr_syntax_mapping_back: ArenaMap::default(),
             pat_syntax_mapping: FxHashMap::default(),
             pat_syntax_mapping_back: ArenaMap::default(),
+            params: Vec::new(),
+            body_expr: None,
         }
     }
 
@@ -902,10 +939,7 @@ impl ExprCollector {
                 });
                 fields.extend(iter);
 
-                Pat::Struct {
-                    path: path,
-                    args: fields,
-                }
+                Pat::Struct { path, args: fields }
             }
 
             // TODO: implement
@@ -923,12 +957,48 @@ impl ExprCollector {
         }
     }
 
-    fn into_body_syntax_mapping(self, params: Vec<PatId>, body_expr: ExprId) -> BodySyntaxMapping {
+    fn collect_fn_body(&mut self, node: &ast::FnDef) {
+        if let Some(param_list) = node.param_list() {
+            if let Some(self_param) = param_list.self_param() {
+                let self_param = SyntaxNodePtr::new(
+                    self_param
+                        .self_kw()
+                        .expect("self param without self keyword")
+                        .syntax(),
+                );
+                let param_pat = self.alloc_pat(
+                    Pat::Bind {
+                        name: Name::self_param(),
+                        mode: BindingAnnotation::Unannotated,
+                        subpat: None,
+                    },
+                    self_param,
+                );
+                self.params.push(param_pat);
+            }
+
+            for param in param_list.params() {
+                let pat = if let Some(pat) = param.pat() {
+                    pat
+                } else {
+                    continue;
+                };
+                let param_pat = self.collect_pat(pat);
+                self.params.push(param_pat);
+            }
+        };
+
+        let body = self.collect_block_opt(node.body());
+        self.body_expr = Some(body);
+    }
+
+    fn into_body_syntax_mapping(self) -> BodySyntaxMapping {
         let body = Body {
+            owner: self.owner,
             exprs: self.exprs,
             pats: self.pats,
-            params,
-            body_expr,
+            params: self.params,
+            body_expr: self.body_expr.expect("A body should have been collected"),
         };
         BodySyntaxMapping {
             body: Arc::new(body),
@@ -940,49 +1010,18 @@ impl ExprCollector {
     }
 }
 
-pub(crate) fn collect_fn_body_syntax(node: &ast::FnDef) -> BodySyntaxMapping {
-    let mut collector = ExprCollector::new();
-
-    let params = if let Some(param_list) = node.param_list() {
-        let mut params = Vec::new();
-
-        if let Some(self_param) = param_list.self_param() {
-            let self_param = SyntaxNodePtr::new(
-                self_param
-                    .self_kw()
-                    .expect("self param without self keyword")
-                    .syntax(),
-            );
-            let param = collector.alloc_pat(
-                Pat::Bind {
-                    name: Name::self_param(),
-                    mode: BindingAnnotation::Unannotated,
-                    subpat: None,
-                },
-                self_param,
-            );
-            params.push(param);
-        }
+pub(crate) fn body_syntax_mapping(db: &impl HirDatabase, func: Function) -> Arc<BodySyntaxMapping> {
+    let mut collector = ExprCollector::new(func);
 
-        for param in param_list.params() {
-            let pat = if let Some(pat) = param.pat() {
-                pat
-            } else {
-                continue;
-            };
-            params.push(collector.collect_pat(pat));
-        }
-        params
-    } else {
-        Vec::new()
-    };
+    // TODO: consts, etc.
+    collector.collect_fn_body(&func.source(db).1);
 
-    let body = collector.collect_block_opt(node.body());
-    collector.into_body_syntax_mapping(params, body)
+    Arc::new(collector.into_body_syntax_mapping())
 }
 
-pub(crate) fn body_syntax_mapping(db: &impl HirDatabase, func: Function) -> Arc<BodySyntaxMapping> {
-    let (_, fn_def) = func.source(db);
-    let body_syntax_mapping = collect_fn_body_syntax(&fn_def);
-    Arc::new(body_syntax_mapping)
+#[cfg(test)]
+pub(crate) fn collect_fn_body_syntax(function: Function, node: &ast::FnDef) -> BodySyntaxMapping {
+    let mut collector = ExprCollector::new(function);
+    collector.collect_fn_body(node);
+    collector.into_body_syntax_mapping()
 }
diff --git a/crates/ra_hir/src/expr/scope.rs b/crates/ra_hir/src/expr/scope.rs
index f8b5ba581..9202e3671 100644
--- a/crates/ra_hir/src/expr/scope.rs
+++ b/crates/ra_hir/src/expr/scope.rs
@@ -12,7 +12,7 @@ use ra_arena::{Arena, RawId, impl_arena_id};
 use crate::{
     Name, AsName, Function,
     expr::{PatId, ExprId, Pat, Expr, Body, Statement, BodySyntaxMapping},
-    db::HirDatabase,
+    HirDatabase,
 };
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
@@ -58,28 +58,19 @@ impl ExprScopes {
         scopes
     }
 
-    pub fn entries(&self, scope: ScopeId) -> &[ScopeEntry] {
-        &self.scopes[scope].entries
+    pub fn body(&self) -> Arc<Body> {
+        self.body.clone()
     }
 
-    pub fn scope_chain_for<'a>(&'a self, expr: ExprId) -> impl Iterator<Item = ScopeId> + 'a {
-        generate(self.scope_for(expr), move |&scope| {
-            self.scopes[scope].parent
-        })
+    pub fn entries(&self, scope: ScopeId) -> &[ScopeEntry] {
+        &self.scopes[scope].entries
     }
 
-    pub fn resolve_local_name<'a>(
+    pub fn scope_chain_for<'a>(
         &'a self,
-        context_expr: ExprId,
-        name: Name,
-    ) -> Option<&'a ScopeEntry> {
-        let mut shadowed = FxHashSet::default();
-        let ret = self
-            .scope_chain_for(context_expr)
-            .flat_map(|scope| self.entries(scope).iter())
-            .filter(|entry| shadowed.insert(entry.name()))
-            .find(|entry| entry.name() == &name);
-        ret
+        scope: Option<ScopeId>,
+    ) -> impl Iterator<Item = ScopeId> + 'a {
+        generate(scope, move |&scope| self.scopes[scope].parent)
     }
 
     fn root_scope(&mut self) -> ScopeId {
@@ -122,7 +113,7 @@ impl ExprScopes {
         self.scope_for.insert(node, scope);
     }
 
-    fn scope_for(&self, expr: ExprId) -> Option<ScopeId> {
+    pub fn scope_for(&self, expr: ExprId) -> Option<ScopeId> {
         self.scope_for.get(&expr).map(|&scope| scope)
     }
 }
@@ -150,18 +141,14 @@ impl ScopeEntryWithSyntax {
 }
 
 impl ScopesWithSyntaxMapping {
-    pub fn scope_chain<'a>(&'a self, node: &SyntaxNode) -> impl Iterator<Item = ScopeId> + 'a {
+    fn scope_chain<'a>(&'a self, node: &SyntaxNode) -> impl Iterator<Item = ScopeId> + 'a {
         generate(self.scope_for(node), move |&scope| {
             self.scopes.scopes[scope].parent
         })
     }
 
-    pub fn scope_chain_for_offset<'a>(
-        &'a self,
-        offset: TextUnit,
-    ) -> impl Iterator<Item = ScopeId> + 'a {
-        let scope = self
-            .scopes
+    pub fn scope_for_offset<'a>(&'a self, offset: TextUnit) -> Option<ScopeId> {
+        self.scopes
             .scope_for
             .iter()
             .filter_map(|(id, scope)| Some((self.syntax_mapping.expr_syntax(*id)?, scope)))
@@ -172,13 +159,12 @@ impl ScopesWithSyntaxMapping {
                     ptr.range().len(),
                 )
             })
-            .map(|(ptr, scope)| self.adjust(ptr, *scope, offset));
-
-        generate(scope, move |&scope| self.scopes.scopes[scope].parent)
+            .map(|(ptr, scope)| self.adjust(ptr, *scope, offset))
     }
 
     // XXX: during completion, cursor might be outside of any particular
     // expression. Try to figure out the correct scope...
+    // TODO: move this to source binder?
     fn adjust(&self, ptr: SyntaxNodePtr, original_scope: ScopeId, offset: TextUnit) -> ScopeId {
         let r = ptr.range();
         let child_scopes = self
@@ -238,7 +224,7 @@ impl ScopesWithSyntaxMapping {
             .collect()
     }
 
-    fn scope_for(&self, node: &SyntaxNode) -> Option<ScopeId> {
+    pub fn scope_for(&self, node: &SyntaxNode) -> Option<ScopeId> {
         node.ancestors()
             .map(SyntaxNodePtr::new)
             .filter_map(|ptr| self.syntax_mapping.syntax_expr(ptr))
@@ -336,6 +322,7 @@ pub struct ReferenceDescriptor {
 mod tests {
     use ra_syntax::{SourceFile, algo::find_node_at_offset};
     use test_utils::{extract_offset, assert_eq_text};
+    use ra_arena::ArenaId;
 
     use crate::expr;
 
@@ -354,7 +341,10 @@ mod tests {
         let file = SourceFile::parse(&code);
         let marker: &ast::PathExpr = find_node_at_offset(file.syntax(), off).unwrap();
         let fn_def: &ast::FnDef = find_node_at_offset(file.syntax(), off).unwrap();
-        let body_hir = expr::collect_fn_body_syntax(fn_def);
+        let irrelevant_function = Function {
+            id: crate::ids::FunctionId::from_raw(0.into()),
+        };
+        let body_hir = expr::collect_fn_body_syntax(irrelevant_function, fn_def);
         let scopes = ExprScopes::new(Arc::clone(body_hir.body()));
         let scopes = ScopesWithSyntaxMapping {
             scopes: Arc::new(scopes),
@@ -454,7 +444,10 @@ mod tests {
         let fn_def: &ast::FnDef = find_node_at_offset(file.syntax(), off).unwrap();
         let name_ref: &ast::NameRef = find_node_at_offset(file.syntax(), off).unwrap();
 
-        let body_hir = expr::collect_fn_body_syntax(fn_def);
+        let irrelevant_function = Function {
+            id: crate::ids::FunctionId::from_raw(0.into()),
+        };
+        let body_hir = expr::collect_fn_body_syntax(irrelevant_function, fn_def);
         let scopes = ExprScopes::new(Arc::clone(body_hir.body()));
         let scopes = ScopesWithSyntaxMapping {
             scopes: Arc::new(scopes),
diff --git a/crates/ra_hir/src/generics.rs b/crates/ra_hir/src/generics.rs
index 64c20a462..a82205f0b 100644
--- a/crates/ra_hir/src/generics.rs
+++ b/crates/ra_hir/src/generics.rs
@@ -7,11 +7,12 @@ use std::sync::Arc;
 
 use ra_syntax::ast::{self, NameOwner, TypeParamsOwner};
 
-use crate::{db::HirDatabase, Name, AsName, Function, Struct, Enum, Trait, Type};
+use crate::{db::PersistentHirDatabase, Name, AsName, Function, Struct, Enum, Trait, Type};
 
 /// Data about a generic parameter (to a function, struct, impl, ...).
 #[derive(Clone, PartialEq, Eq, Debug)]
 pub struct GenericParam {
+    // TODO: give generic params proper IDs
     pub(crate) idx: u32,
     pub(crate) name: Name,
 }
@@ -34,7 +35,7 @@ impl_froms!(GenericDef: Function, Struct, Enum, Trait, Type);
 
 impl GenericParams {
     pub(crate) fn generic_params_query(
-        db: &impl HirDatabase,
+        db: &impl PersistentHirDatabase,
         def: GenericDef,
     ) -> Arc<GenericParams> {
         let mut generics = GenericParams::default();
diff --git a/crates/ra_hir/src/ids.rs b/crates/ra_hir/src/ids.rs
index 0e4dc6261..95678bf70 100644
--- a/crates/ra_hir/src/ids.rs
+++ b/crates/ra_hir/src/ids.rs
@@ -10,6 +10,7 @@ use ra_arena::{Arena, RawId, ArenaId, impl_arena_id};
 use crate::{
     HirDatabase,
     Module,
+    PersistentHirDatabase,
 };
 
 #[derive(Debug, Default)]
@@ -62,7 +63,7 @@ pub struct HirFileId(HirFileIdRepr);
 impl HirFileId {
     /// For macro-expansion files, returns the file original source file the
     /// expansionoriginated from.
-    pub fn original_file(self, db: &impl HirDatabase) -> FileId {
+    pub fn original_file(self, db: &impl PersistentHirDatabase) -> FileId {
         match self.0 {
             HirFileIdRepr::File(file_id) => file_id,
             HirFileIdRepr::Macro(macro_call_id) => {
@@ -86,7 +87,10 @@ impl HirFileId {
         }
     }
 
-    pub(crate) fn hir_parse(db: &impl HirDatabase, file_id: HirFileId) -> TreeArc<SourceFile> {
+    pub(crate) fn hir_parse(
+        db: &impl PersistentHirDatabase,
+        file_id: HirFileId,
+    ) -> TreeArc<SourceFile> {
         match file_id.0 {
             HirFileIdRepr::File(file_id) => db.parse(file_id),
             HirFileIdRepr::Macro(m) => {
@@ -180,7 +184,7 @@ pub(crate) struct LocationCtx<DB> {
     file_id: HirFileId,
 }
 
-impl<'a, DB: HirDatabase> LocationCtx<&'a DB> {
+impl<'a, DB: PersistentHirDatabase> LocationCtx<&'a DB> {
     pub(crate) fn new(db: &'a DB, module: Module, file_id: HirFileId) -> LocationCtx<&'a DB> {
         LocationCtx {
             db,
@@ -199,7 +203,7 @@ impl<'a, DB: HirDatabase> LocationCtx<&'a DB> {
 
 pub(crate) trait AstItemDef<N: AstNode>: ArenaId + Clone {
     fn interner(interner: &HirInterner) -> &LocationIntener<ItemLoc<N>, Self>;
-    fn from_ast(ctx: LocationCtx<&impl HirDatabase>, ast: &N) -> Self {
+    fn from_ast(ctx: LocationCtx<&impl PersistentHirDatabase>, ast: &N) -> Self {
         let items = ctx.db.file_items(ctx.file_id);
         let raw = SourceItemId {
             file_id: ctx.file_id,
@@ -213,7 +217,7 @@ pub(crate) trait AstItemDef<N: AstNode>: ArenaId + Clone {
 
         Self::interner(ctx.db.as_ref()).loc2id(&loc)
     }
-    fn source(self, db: &impl HirDatabase) -> (HirFileId, TreeArc<N>) {
+    fn source(self, db: &impl PersistentHirDatabase) -> (HirFileId, TreeArc<N>) {
         let int = Self::interner(db.as_ref());
         let loc = int.id2loc(self);
         let syntax = db.file_item(loc.raw);
diff --git a/crates/ra_hir/src/impl_block.rs b/crates/ra_hir/src/impl_block.rs
index 5fc26324a..738c58fbe 100644
--- a/crates/ra_hir/src/impl_block.rs
+++ b/crates/ra_hir/src/impl_block.rs
@@ -7,11 +7,13 @@ use ra_syntax::{
 ast::{self, AstNode}};
 
 use crate::{
-    Const, Type,
-    Function, HirFileId,
-    db::HirDatabase,
+    Const, Type, Function, HirFileId,
+    HirDatabase, PersistentHirDatabase,
+    ModuleDef, Trait, Resolution,
     type_ref::TypeRef,
     ids::LocationCtx,
+    resolve::Resolver,
+    ty::Ty,
 };
 
 use crate::code_model_api::{Module, ModuleSource};
@@ -69,7 +71,11 @@ impl ImplBlock {
         &self.module_impl_blocks.impls[self.impl_id]
     }
 
-    pub fn target_trait(&self) -> Option<&TypeRef> {
+    pub fn module(&self) -> Module {
+        self.module_impl_blocks.module.clone()
+    }
+
+    pub fn target_trait_ref(&self) -> Option<&TypeRef> {
         self.impl_data().target_trait()
     }
 
@@ -77,9 +83,32 @@ impl ImplBlock {
         self.impl_data().target_type()
     }
 
+    pub fn target_ty(&self, db: &impl HirDatabase) -> Ty {
+        Ty::from_hir(db, &self.resolver(db), self.target_type())
+    }
+
+    pub fn target_trait(&self, db: &impl HirDatabase) -> Option<Trait> {
+        if let Some(TypeRef::Path(path)) = self.target_trait_ref() {
+            let resolver = self.resolver(db);
+            if let Some(Resolution::Def(ModuleDef::Trait(tr))) =
+                resolver.resolve_path(db, path).take_types()
+            {
+                return Some(tr);
+            }
+        }
+        None
+    }
+
     pub fn items(&self) -> &[ImplItem] {
         self.impl_data().items()
     }
+
+    pub fn resolver(&self, db: &impl HirDatabase) -> Resolver {
+        let r = self.module().resolver(db);
+        // TODO: add generics
+        let r = r.push_impl_block_scope(self.clone());
+        r
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -91,7 +120,7 @@ pub struct ImplData {
 
 impl ImplData {
     pub(crate) fn from_ast(
-        db: &impl HirDatabase,
+        db: &impl PersistentHirDatabase,
         file_id: HirFileId,
         module: Module,
         node: &ast::ImplBlock,
@@ -162,20 +191,24 @@ impl_arena_id!(ImplId);
 /// we don't need to do the second step again.
 #[derive(Debug, PartialEq, Eq)]
 pub struct ModuleImplBlocks {
+    module: Module,
     pub(crate) impls: Arena<ImplId, ImplData>,
     impls_by_def: FxHashMap<ImplItem, ImplId>,
 }
 
 impl ModuleImplBlocks {
-    fn new() -> Self {
-        ModuleImplBlocks {
+    fn collect(
+        db: &impl PersistentHirDatabase,
+        module: Module,
+        source_map: &mut ImplSourceMap,
+    ) -> Self {
+        let mut m = ModuleImplBlocks {
+            module,
             impls: Arena::default(),
             impls_by_def: FxHashMap::default(),
-        }
-    }
+        };
 
-    fn collect(&mut self, db: &impl HirDatabase, module: Module, source_map: &mut ImplSourceMap) {
-        let (file_id, module_source) = module.definition_source(db);
+        let (file_id, module_source) = m.module.definition_source(db);
         let file_id: HirFileId = file_id.into();
         let node = match &module_source {
             ModuleSource::SourceFile(node) => node.syntax(),
@@ -186,35 +219,39 @@ impl ModuleImplBlocks {
         };
 
         for impl_block_ast in node.children().filter_map(ast::ImplBlock::cast) {
-            let impl_block = ImplData::from_ast(db, file_id, module, impl_block_ast);
-            let id = self.impls.alloc(impl_block);
-            for &impl_item in &self.impls[id].items {
-                self.impls_by_def.insert(impl_item, id);
+            let impl_block = ImplData::from_ast(db, file_id, m.module, impl_block_ast);
+            let id = m.impls.alloc(impl_block);
+            for &impl_item in &m.impls[id].items {
+                m.impls_by_def.insert(impl_item, id);
             }
 
             source_map.insert(id, impl_block_ast);
         }
+
+        m
     }
 }
 
 pub(crate) fn impls_in_module_with_source_map_query(
-    db: &impl HirDatabase,
+    db: &impl PersistentHirDatabase,
     module: Module,
 ) -> (Arc<ModuleImplBlocks>, Arc<ImplSourceMap>) {
     let mut source_map = ImplSourceMap::default();
 
-    let mut result = ModuleImplBlocks::new();
-    result.collect(db, module, &mut source_map);
+    let result = ModuleImplBlocks::collect(db, module, &mut source_map);
 
     (Arc::new(result), Arc::new(source_map))
 }
 
-pub(crate) fn impls_in_module(db: &impl HirDatabase, module: Module) -> Arc<ModuleImplBlocks> {
+pub(crate) fn impls_in_module(
+    db: &impl PersistentHirDatabase,
+    module: Module,
+) -> Arc<ModuleImplBlocks> {
     db.impls_in_module_with_source_map(module).0
 }
 
 pub(crate) fn impls_in_module_source_map_query(
-    db: &impl HirDatabase,
+    db: &impl PersistentHirDatabase,
     module: Module,
 ) -> Arc<ImplSourceMap> {
     db.impls_in_module_with_source_map(module).1
diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs
index 0b9ee63bf..54da55598 100644
--- a/crates/ra_hir/src/lib.rs
+++ b/crates/ra_hir/src/lib.rs
@@ -36,6 +36,7 @@ mod impl_block;
 mod expr;
 mod generics;
 mod docs;
+mod resolve;
 
 mod code_model_api;
 mod code_model_impl;
@@ -44,7 +45,7 @@ mod code_model_impl;
 mod marks;
 
 use crate::{
-    db::HirDatabase,
+    db::{HirDatabase, PersistentHirDatabase},
     name::{AsName, KnownName},
     ids::{SourceItemId, SourceFileItems},
 };
@@ -54,12 +55,13 @@ pub use self::{
     name::Name,
     ids::{HirFileId, MacroCallId, MacroCallLoc, HirInterner},
     macros::{MacroDef, MacroInput, MacroExpansion},
-    nameres::{ItemMap, PerNs, Namespace, Resolution},
+    nameres::{ItemMap, PerNs, Namespace},
     ty::Ty,
     impl_block::{ImplBlock, ImplItem},
     docs::{Docs, Documentation},
     adt::AdtDef,
     expr::{ExprScopes, ScopesWithSyntaxMapping},
+    resolve::{Resolver, Resolution},
 };
 
 pub use self::code_model_api::{
diff --git a/crates/ra_hir/src/macros.rs b/crates/ra_hir/src/macros.rs
index 7ca34d434..cb8a9312e 100644
--- a/crates/ra_hir/src/macros.rs
+++ b/crates/ra_hir/src/macros.rs
@@ -14,12 +14,11 @@ use ra_syntax::{
     ast::{self, NameOwner},
 };
 
-use crate::{HirDatabase, MacroCallId};
+use crate::{MacroCallId, PersistentHirDatabase};
 
 // Hard-coded defs for now :-(
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum MacroDef {
-    CTry,
     Vec,
     QueryGroup,
 }
@@ -38,9 +37,7 @@ impl MacroDef {
         let def = {
             let path = macro_call.path()?;
             let name_ref = path.segment()?.name_ref()?;
-            if name_ref.text() == "ctry" {
-                MacroDef::CTry
-            } else if name_ref.text() == "vec" {
+            if name_ref.text() == "vec" {
                 MacroDef::Vec
             } else if name_ref.text() == "query_group" {
                 MacroDef::QueryGroup
@@ -60,35 +57,10 @@ impl MacroDef {
 
     fn expand(self, input: MacroInput) -> Option<MacroExpansion> {
         match self {
-            MacroDef::CTry => self.expand_ctry(input),
             MacroDef::Vec => self.expand_vec(input),
             MacroDef::QueryGroup => self.expand_query_group(input),
         }
     }
-    fn expand_ctry(self, input: MacroInput) -> Option<MacroExpansion> {
-        let text = format!(
-            r"
-                fn dummy() {{
-                    match {} {{
-                        None => return Ok(None),
-                        Some(it) => it,
-                    }}
-                }}",
-            input.text
-        );
-        let file = SourceFile::parse(&text);
-        let match_expr = file.syntax().descendants().find_map(ast::MatchExpr::cast)?;
-        let match_arg = match_expr.expr()?;
-        let ptr = SyntaxNodePtr::new(match_arg.syntax());
-        let src_range = TextRange::offset_len(0.into(), TextUnit::of_str(&input.text));
-        let ranges_map = vec![(src_range, match_arg.syntax().range())];
-        let res = MacroExpansion {
-            text,
-            ranges_map,
-            ptr,
-        };
-        Some(res)
-    }
     fn expand_vec(self, input: MacroInput) -> Option<MacroExpansion> {
         let text = format!(r"fn dummy() {{ {}; }}", input.text);
         let file = SourceFile::parse(&text);
@@ -185,7 +157,7 @@ impl MacroExpansion {
 }
 
 pub(crate) fn expand_macro_invocation(
-    db: &impl HirDatabase,
+    db: &impl PersistentHirDatabase,
     invoc: MacroCallId,
 ) -> Option<Arc<MacroExpansion>> {
     let loc = invoc.loc(db);
diff --git a/crates/ra_hir/src/mock.rs b/crates/ra_hir/src/mock.rs
index 7da15eca0..17bdd48c6 100644
--- a/crates/ra_hir/src/mock.rs
+++ b/crates/ra_hir/src/mock.rs
@@ -11,7 +11,11 @@ use crate::{db, HirInterner};
 
 pub const WORKSPACE: SourceRootId = SourceRootId(0);
 
-#[salsa::database(ra_db::SourceDatabaseStorage, db::HirDatabaseStorage)]
+#[salsa::database(
+    ra_db::SourceDatabaseStorage,
+    db::HirDatabaseStorage,
+    db::PersistentHirDatabaseStorage
+)]
 #[derive(Debug)]
 pub(crate) struct MockDatabase {
     events: Mutex<Option<Vec<salsa::Event<MockDatabase>>>>,
diff --git a/crates/ra_hir/src/module_tree.rs b/crates/ra_hir/src/module_tree.rs
index 1f327eeb2..a1aa3d8ce 100644
--- a/crates/ra_hir/src/module_tree.rs
+++ b/crates/ra_hir/src/module_tree.rs
@@ -13,13 +13,14 @@ use test_utils::tested_by;
 
 use crate::{
     Name, AsName, HirDatabase, SourceItemId, HirFileId, Problem, SourceFileItems, ModuleSource,
+    PersistentHirDatabase,
     Crate,
     ids::SourceFileItemId,
 };
 
 impl ModuleSource {
     pub(crate) fn new(
-        db: &impl HirDatabase,
+        db: &impl PersistentHirDatabase,
         file_id: HirFileId,
         decl_id: Option<SourceFileItemId>,
     ) -> ModuleSource {
@@ -47,7 +48,7 @@ pub struct Submodule {
 
 impl Submodule {
     pub(crate) fn submodules_query(
-        db: &impl HirDatabase,
+        db: &impl PersistentHirDatabase,
         file_id: HirFileId,
         decl_id: Option<SourceFileItemId>,
     ) -> Arc<Vec<Submodule>> {
@@ -133,7 +134,10 @@ struct LinkData {
 }
 
 impl ModuleTree {
-    pub(crate) fn module_tree_query(db: &impl HirDatabase, krate: Crate) -> Arc<ModuleTree> {
+    pub(crate) fn module_tree_query(
+        db: &impl PersistentHirDatabase,
+        krate: Crate,
+    ) -> Arc<ModuleTree> {
         db.check_canceled();
         let mut res = ModuleTree::default();
         res.init_crate(db, krate);
@@ -156,7 +160,7 @@ impl ModuleTree {
         Some(res)
     }
 
-    fn init_crate(&mut self, db: &impl HirDatabase, krate: Crate) {
+    fn init_crate(&mut self, db: &impl PersistentHirDatabase, krate: Crate) {
         let crate_graph = db.crate_graph();
         let file_id = crate_graph.crate_root(krate.crate_id);
         let source_root_id = db.file_source_root(file_id);
@@ -167,7 +171,7 @@ impl ModuleTree {
 
     fn init_subtree(
         &mut self,
-        db: &impl HirDatabase,
+        db: &impl PersistentHirDatabase,
         source_root: &SourceRoot,
         parent: Option<LinkId>,
         file_id: HirFileId,
@@ -287,14 +291,18 @@ impl LinkId {
     pub(crate) fn name(self, tree: &ModuleTree) -> &Name {
         &tree.links[self].name
     }
-    pub(crate) fn source(self, tree: &ModuleTree, db: &impl HirDatabase) -> TreeArc<ast::Module> {
+    pub(crate) fn source(
+        self,
+        tree: &ModuleTree,
+        db: &impl PersistentHirDatabase,
+    ) -> TreeArc<ast::Module> {
         let syntax_node = db.file_item(tree.links[self].source);
         ast::Module::cast(&syntax_node).unwrap().to_owned()
     }
 }
 
 fn resolve_submodule(
-    db: &impl HirDatabase,
+    db: &impl PersistentHirDatabase,
     file_id: HirFileId,
     name: &Name,
     is_root: bool,
diff --git a/crates/ra_hir/src/nameres.rs b/crates/ra_hir/src/nameres.rs
index 4573a72ba..04cc693b3 100644
--- a/crates/ra_hir/src/nameres.rs
+++ b/crates/ra_hir/src/nameres.rs
@@ -24,14 +24,13 @@ use rustc_hash::{FxHashMap, FxHashSet};
 
 use crate::{
     Module, ModuleDef,
-    Path, PathKind,
-    HirDatabase, Crate,
-    Name,
+    Path, PathKind, PersistentHirDatabase,
+    Crate, Name,
     module_tree::{ModuleId, ModuleTree},
     nameres::lower::{ImportId, LoweredModule, ImportData},
 };
 
-/// `ItemMap` is the result of name resolution. It contains, for each
+/// `ItemMap` is the result of module name resolution. It contains, for each
 /// module, the set of visible items.
 #[derive(Default, Debug, PartialEq, Eq)]
 pub struct ItemMap {
@@ -47,7 +46,7 @@ impl std::ops::Index<ModuleId> for ItemMap {
 
 #[derive(Debug, Default, PartialEq, Eq, Clone)]
 pub struct ModuleScope {
-    items: FxHashMap<Name, Resolution>,
+    pub(crate) items: FxHashMap<Name, Resolution>,
 }
 
 impl ModuleScope {
@@ -81,6 +80,15 @@ pub struct PerNs<T> {
     pub values: Option<T>,
 }
 
+impl<T> Default for PerNs<T> {
+    fn default() -> Self {
+        PerNs {
+            types: None,
+            values: None,
+        }
+    }
+}
+
 impl<T> PerNs<T> {
     pub fn none() -> PerNs<T> {
         PerNs {
@@ -114,6 +122,10 @@ impl<T> PerNs<T> {
         self.types.is_none() && self.values.is_none()
     }
 
+    pub fn is_both(&self) -> bool {
+        self.types.is_some() && self.values.is_some()
+    }
+
     pub fn take(self, namespace: Namespace) -> Option<T> {
         match namespace {
             Namespace::Types => self.types,
@@ -140,6 +152,13 @@ impl<T> PerNs<T> {
         }
     }
 
+    pub fn combine(self, other: PerNs<T>) -> PerNs<T> {
+        PerNs {
+            types: self.types.or(other.types),
+            values: self.values.or(other.values),
+        }
+    }
+
     pub fn and_then<U>(self, f: impl Fn(T) -> Option<U>) -> PerNs<U> {
         PerNs {
             types: self.types.and_then(&f),
@@ -166,7 +185,7 @@ struct Resolver<'a, DB> {
 
 impl<'a, DB> Resolver<'a, DB>
 where
-    DB: HirDatabase,
+    DB: PersistentHirDatabase,
 {
     fn new(
         db: &'a DB,
@@ -232,10 +251,14 @@ where
             };
         }
         for (import_id, import_data) in input.imports.iter() {
-            if let Some(segment) = import_data.path.segments.iter().last() {
+            if let Some(last_segment) = import_data.path.segments.iter().last() {
                 if !import_data.is_glob {
+                    let name = import_data
+                        .alias
+                        .clone()
+                        .unwrap_or_else(|| last_segment.name.clone());
                     module_items.items.insert(
-                        segment.name.clone(),
+                        name,
                         Resolution {
                             def: PerNs::none(),
                             import: Some(import_id),
@@ -300,19 +323,18 @@ where
 
         if reached_fixedpoint == ReachedFixedPoint::Yes {
             let last_segment = import.path.segments.last().unwrap();
+            let name = import
+                .alias
+                .clone()
+                .unwrap_or_else(|| last_segment.name.clone());
+            log::debug!("resolved import {:?} ({:?}) to {:?}", name, import, def,);
             self.update(module_id, |items| {
                 let res = Resolution {
                     def,
                     import: Some(import_id),
                 };
-                items.items.insert(last_segment.name.clone(), res);
+                items.items.insert(name, res);
             });
-            log::debug!(
-                "resolved import {:?} ({:?}) cross-source root to {:?}",
-                last_segment.name,
-                import,
-                def,
-            );
         }
         reached_fixedpoint
     }
@@ -330,7 +352,7 @@ enum ReachedFixedPoint {
 }
 
 impl ItemMap {
-    pub(crate) fn item_map_query(db: &impl HirDatabase, krate: Crate) -> Arc<ItemMap> {
+    pub(crate) fn item_map_query(db: &impl PersistentHirDatabase, krate: Crate) -> Arc<ItemMap> {
         let start = time::Instant::now();
         let module_tree = db.module_tree(krate);
         let input = module_tree
@@ -352,7 +374,7 @@ impl ItemMap {
 
     pub(crate) fn resolve_path(
         &self,
-        db: &impl HirDatabase,
+        db: &impl PersistentHirDatabase,
         original_module: Module,
         path: &Path,
     ) -> PerNs<ModuleDef> {
@@ -363,7 +385,7 @@ impl ItemMap {
     // the result.
     fn resolve_path_fp(
         &self,
-        db: &impl HirDatabase,
+        db: &impl PersistentHirDatabase,
         original_module: Module,
         path: &Path,
     ) -> (PerNs<ModuleDef>, ReachedFixedPoint) {
@@ -403,10 +425,11 @@ impl ItemMap {
                     if module.krate != original_module.krate {
                         let path = Path {
                             segments: path.segments[i..].iter().cloned().collect(),
-                            kind: PathKind::Crate,
+                            kind: PathKind::Self_,
                         };
                         log::debug!("resolving {:?} in other crate", path);
-                        let def = module.resolve_path(db, &path);
+                        let item_map = db.item_map(module.krate);
+                        let def = item_map.resolve_path(db, *module, &path);
                         return (def, ReachedFixedPoint::Yes);
                     }
 
diff --git a/crates/ra_hir/src/nameres/lower.rs b/crates/ra_hir/src/nameres/lower.rs
index 8df11a5f4..df87f520f 100644
--- a/crates/ra_hir/src/nameres/lower.rs
+++ b/crates/ra_hir/src/nameres/lower.rs
@@ -8,10 +8,10 @@ use ra_arena::{Arena, RawId, impl_arena_id, map::ArenaMap};
 use rustc_hash::FxHashMap;
 
 use crate::{
-    SourceItemId, Path, ModuleSource, HirDatabase, Name,
+    SourceItemId, Path, ModuleSource, Name,
     HirFileId, MacroCallLoc, AsName, PerNs, Function,
     ModuleDef, Module, Struct, Enum, Const, Static, Trait, Type,
-    ids::LocationCtx,
+    ids::LocationCtx, PersistentHirDatabase,
 };
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -21,6 +21,7 @@ impl_arena_id!(ImportId);
 #[derive(Debug, PartialEq, Eq)]
 pub(super) struct ImportData {
     pub(super) path: Path,
+    pub(super) alias: Option<Name>,
     pub(super) is_glob: bool,
 }
 
@@ -58,21 +59,21 @@ impl ImportSourceMap {
 
 impl LoweredModule {
     pub(crate) fn lower_module_module_query(
-        db: &impl HirDatabase,
+        db: &impl PersistentHirDatabase,
         module: Module,
     ) -> Arc<LoweredModule> {
         db.lower_module(module).0
     }
 
     pub(crate) fn lower_module_source_map_query(
-        db: &impl HirDatabase,
+        db: &impl PersistentHirDatabase,
         module: Module,
     ) -> Arc<ImportSourceMap> {
         db.lower_module(module).1
     }
 
     pub(crate) fn lower_module_query(
-        db: &impl HirDatabase,
+        db: &impl PersistentHirDatabase,
         module: Module,
     ) -> (Arc<LoweredModule>, Arc<ImportSourceMap>) {
         let (file_id, source) = module.definition_source(db);
@@ -105,7 +106,7 @@ impl LoweredModule {
     fn fill(
         &mut self,
         source_map: &mut ImportSourceMap,
-        db: &impl HirDatabase,
+        db: &impl PersistentHirDatabase,
         module: Module,
         file_id: HirFileId,
         items: &mut Iterator<Item = ast::ItemOrMacro>,
@@ -137,7 +138,7 @@ impl LoweredModule {
     fn add_def_id(
         &mut self,
         source_map: &mut ImportSourceMap,
-        db: &impl HirDatabase,
+        db: &impl PersistentHirDatabase,
         module: Module,
         file_id: HirFileId,
         item: &ast::ModuleItem,
@@ -209,9 +210,10 @@ impl LoweredModule {
     }
 
     fn add_use_item(&mut self, source_map: &mut ImportSourceMap, item: &ast::UseItem) {
-        Path::expand_use_item(item, |path, segment| {
+        Path::expand_use_item(item, |path, segment, alias| {
             let import = self.imports.alloc(ImportData {
                 path,
+                alias,
                 is_glob: segment.is_none(),
             });
             if let Some(segment) = segment {
diff --git a/crates/ra_hir/src/nameres/tests.rs b/crates/ra_hir/src/nameres/tests.rs
index 9c5ca097e..81c8a4f12 100644
--- a/crates/ra_hir/src/nameres/tests.rs
+++ b/crates/ra_hir/src/nameres/tests.rs
@@ -5,11 +5,12 @@ use relative_path::RelativePath;
 use test_utils::{assert_eq_text, covers};
 
 use crate::{
-    ItemMap, Resolution,
-    db::HirDatabase,
+    ItemMap,
+    PersistentHirDatabase,
     mock::MockDatabase,
     module_tree::ModuleId,
 };
+use super::Resolution;
 
 fn item_map(fixture: &str) -> (Arc<ItemMap>, ModuleId) {
     let (db, pos) = MockDatabase::with_position(fixture);
@@ -90,6 +91,30 @@ fn item_map_smoke_test() {
 }
 
 #[test]
+fn use_as() {
+    let (item_map, module_id) = item_map(
+        "
+        //- /lib.rs
+        mod foo;
+
+        use crate::foo::Baz as Foo;
+        <|>
+
+        //- /foo/mod.rs
+        pub struct Baz;
+    ",
+    );
+    check_module_item_map(
+        &item_map,
+        module_id,
+        "
+            Foo: t v
+            foo: t
+        ",
+    );
+}
+
+#[test]
 fn use_trees() {
     let (item_map, module_id) = item_map(
         "
diff --git a/crates/ra_hir/src/path.rs b/crates/ra_hir/src/path.rs
index e13d84c57..cb0a04500 100644
--- a/crates/ra_hir/src/path.rs
+++ b/crates/ra_hir/src/path.rs
@@ -1,6 +1,6 @@
 use std::sync::Arc;
 
-use ra_syntax::{ast, AstNode};
+use ra_syntax::{ast::{self, NameOwner}, AstNode};
 
 use crate::{Name, AsName, type_ref::TypeRef};
 
@@ -46,7 +46,7 @@ impl Path {
     /// Calls `cb` with all paths, represented by this use item.
     pub fn expand_use_item<'a>(
         item: &'a ast::UseItem,
-        mut cb: impl FnMut(Path, Option<&'a ast::PathSegment>),
+        mut cb: impl FnMut(Path, Option<&'a ast::PathSegment>, Option<Name>),
     ) {
         if let Some(tree) = item.use_tree() {
             expand_use_tree(None, tree, &mut cb);
@@ -164,7 +164,7 @@ impl From<Name> for Path {
 fn expand_use_tree<'a>(
     prefix: Option<Path>,
     tree: &'a ast::UseTree,
-    cb: &mut impl FnMut(Path, Option<&'a ast::PathSegment>),
+    cb: &mut impl FnMut(Path, Option<&'a ast::PathSegment>, Option<Name>),
 ) {
     if let Some(use_tree_list) = tree.use_tree_list() {
         let prefix = match tree.path() {
@@ -181,6 +181,7 @@ fn expand_use_tree<'a>(
             expand_use_tree(prefix.clone(), child_tree, cb);
         }
     } else {
+        let alias = tree.alias().and_then(|a| a.name()).map(|a| a.as_name());
         if let Some(ast_path) = tree.path() {
             // Handle self in a path.
             // E.g. `use something::{self, <...>}`
@@ -188,7 +189,7 @@ fn expand_use_tree<'a>(
                 if let Some(segment) = ast_path.segment() {
                     if segment.kind() == Some(ast::PathSegmentKind::SelfKw) {
                         if let Some(prefix) = prefix {
-                            cb(prefix, Some(segment));
+                            cb(prefix, Some(segment), alias);
                             return;
                         }
                     }
@@ -196,9 +197,9 @@ fn expand_use_tree<'a>(
             }
             if let Some(path) = convert_path(prefix, ast_path) {
                 if tree.has_star() {
-                    cb(path, None)
+                    cb(path, None, alias)
                 } else if let Some(segment) = ast_path.segment() {
-                    cb(path, Some(segment))
+                    cb(path, Some(segment), alias)
                 };
             }
             // TODO: report errors somewhere
diff --git a/crates/ra_hir/src/query_definitions.rs b/crates/ra_hir/src/query_definitions.rs
index 734a98282..b4d8da1e6 100644
--- a/crates/ra_hir/src/query_definitions.rs
+++ b/crates/ra_hir/src/query_definitions.rs
@@ -6,17 +6,20 @@ use ra_syntax::{
 
 use crate::{
     SourceFileItems, SourceItemId, HirFileId,
-    db::HirDatabase,
+    PersistentHirDatabase,
 };
 
-pub(super) fn file_items(db: &impl HirDatabase, file_id: HirFileId) -> Arc<SourceFileItems> {
+pub(super) fn file_items(
+    db: &impl PersistentHirDatabase,
+    file_id: HirFileId,
+) -> Arc<SourceFileItems> {
     let source_file = db.hir_parse(file_id);
     let res = SourceFileItems::new(file_id, &source_file);
     Arc::new(res)
 }
 
 pub(super) fn file_item(
-    db: &impl HirDatabase,
+    db: &impl PersistentHirDatabase,
     source_item_id: SourceItemId,
 ) -> TreeArc<SyntaxNode> {
     let source_file = db.hir_parse(source_item_id.file_id);
diff --git a/crates/ra_hir/src/resolve.rs b/crates/ra_hir/src/resolve.rs
new file mode 100644
index 000000000..6c87d0df7
--- /dev/null
+++ b/crates/ra_hir/src/resolve.rs
@@ -0,0 +1,226 @@
+//! Name resolution.
+use std::sync::Arc;
+
+use rustc_hash::FxHashMap;
+
+use crate::{
+    ModuleDef, Module,
+    db::HirDatabase,
+    name::{Name, KnownName},
+    nameres::{PerNs, ItemMap},
+    generics::GenericParams,
+    expr::{scope::{ExprScopes, ScopeId}, PatId, Body},
+    impl_block::ImplBlock,
+    path::Path,
+};
+
+#[derive(Debug, Clone, Default)]
+pub struct Resolver {
+    scopes: Vec<Scope>,
+}
+
+// TODO how to store these best
+#[derive(Debug, Clone)]
+pub(crate) struct ModuleItemMap {
+    item_map: Arc<ItemMap>,
+    module: Module,
+}
+
+#[derive(Debug, Clone)]
+pub(crate) struct ExprScope {
+    expr_scopes: Arc<ExprScopes>,
+    scope_id: ScopeId,
+}
+
+#[derive(Debug, Clone)]
+pub(crate) enum Scope {
+    /// All the items and imported names of a module
+    ModuleScope(ModuleItemMap),
+    /// Brings the generic parameters of an item into scope
+    GenericParams(Arc<GenericParams>),
+    /// Brings `Self` into scope
+    ImplBlockScope(ImplBlock),
+    /// Local bindings
+    ExprScope(ExprScope),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Resolution {
+    /// An item
+    Def(ModuleDef),
+    /// A local binding (only value namespace)
+    LocalBinding(PatId),
+    /// A generic parameter
+    GenericParam(u32),
+    SelfType(ImplBlock),
+}
+
+impl Resolver {
+    pub fn resolve_name(&self, name: &Name) -> PerNs<Resolution> {
+        let mut resolution = PerNs::none();
+        for scope in self.scopes.iter().rev() {
+            resolution = resolution.combine(scope.resolve_name(name));
+            if resolution.is_both() {
+                return resolution;
+            }
+        }
+        resolution
+    }
+
+    pub fn resolve_path(&self, db: &impl HirDatabase, path: &Path) -> PerNs<Resolution> {
+        if let Some(name) = path.as_ident() {
+            self.resolve_name(name)
+        } else if path.is_self() {
+            self.resolve_name(&Name::self_param())
+        } else {
+            let (item_map, module) = match self.module() {
+                Some(m) => m,
+                _ => return PerNs::none(),
+            };
+            let module_res = item_map.resolve_path(db, module, path);
+            module_res.map(|def| Resolution::Def(def))
+        }
+    }
+
+    pub fn all_names(&self) -> FxHashMap<Name, PerNs<Resolution>> {
+        let mut names = FxHashMap::default();
+        for scope in self.scopes.iter().rev() {
+            scope.collect_names(&mut |name, res| {
+                let current: &mut PerNs<Resolution> = names.entry(name).or_default();
+                if current.types.is_none() {
+                    current.types = res.types;
+                }
+                if current.values.is_none() {
+                    current.values = res.values;
+                }
+            });
+        }
+        names
+    }
+
+    fn module(&self) -> Option<(&ItemMap, Module)> {
+        self.scopes.iter().rev().find_map(|scope| match scope {
+            Scope::ModuleScope(m) => Some((&*m.item_map, m.module.clone())),
+
+            _ => None,
+        })
+    }
+
+    /// The body from which any `LocalBinding` resolutions in this resolver come.
+    pub fn body(&self) -> Option<Arc<Body>> {
+        self.scopes.iter().rev().find_map(|scope| match scope {
+            Scope::ExprScope(expr_scope) => Some(expr_scope.expr_scopes.body()),
+            _ => None,
+        })
+    }
+}
+
+impl Resolver {
+    pub(crate) fn push_scope(mut self, scope: Scope) -> Resolver {
+        self.scopes.push(scope);
+        self
+    }
+
+    pub(crate) fn push_generic_params_scope(self, params: Arc<GenericParams>) -> Resolver {
+        self.push_scope(Scope::GenericParams(params))
+    }
+
+    pub(crate) fn push_impl_block_scope(self, impl_block: ImplBlock) -> Resolver {
+        self.push_scope(Scope::ImplBlockScope(impl_block))
+    }
+
+    pub(crate) fn push_module_scope(self, item_map: Arc<ItemMap>, module: Module) -> Resolver {
+        self.push_scope(Scope::ModuleScope(ModuleItemMap { item_map, module }))
+    }
+
+    pub(crate) fn push_expr_scope(
+        self,
+        expr_scopes: Arc<ExprScopes>,
+        scope_id: ScopeId,
+    ) -> Resolver {
+        self.push_scope(Scope::ExprScope(ExprScope {
+            expr_scopes,
+            scope_id,
+        }))
+    }
+}
+
+impl Scope {
+    fn resolve_name(&self, name: &Name) -> PerNs<Resolution> {
+        match self {
+            Scope::ModuleScope(m) => {
+                if let Some(KnownName::SelfParam) = name.as_known_name() {
+                    PerNs::types(Resolution::Def(m.module.into()))
+                } else {
+                    match m.item_map[m.module.module_id].get(name) {
+                        Some(res) => res.def.map(Resolution::Def),
+                        None => PerNs::none(),
+                    }
+                }
+            }
+            Scope::GenericParams(gp) => match gp.find_by_name(name) {
+                Some(gp) => PerNs::types(Resolution::GenericParam(gp.idx)),
+                None => PerNs::none(),
+            },
+            Scope::ImplBlockScope(i) => {
+                if name.as_known_name() == Some(KnownName::SelfType) {
+                    PerNs::types(Resolution::SelfType(i.clone()))
+                } else {
+                    PerNs::none()
+                }
+            }
+            Scope::ExprScope(e) => {
+                let entry = e
+                    .expr_scopes
+                    .entries(e.scope_id)
+                    .iter()
+                    .find(|entry| entry.name() == name);
+                match entry {
+                    Some(e) => PerNs::values(Resolution::LocalBinding(e.pat())),
+                    None => PerNs::none(),
+                }
+            }
+        }
+    }
+
+    fn collect_names(&self, f: &mut FnMut(Name, PerNs<Resolution>)) {
+        match self {
+            Scope::ModuleScope(m) => {
+                // TODO: should we provide `self` here?
+                // f(
+                //     Name::self_param(),
+                //     PerNs::types(Resolution::Def {
+                //         def: m.module.into(),
+                //     }),
+                // );
+                m.item_map[m.module.module_id]
+                    .entries()
+                    .for_each(|(name, res)| {
+                        f(name.clone(), res.def.map(Resolution::Def));
+                    })
+            }
+            Scope::GenericParams(gp) => {
+                for param in &gp.params {
+                    f(
+                        param.name.clone(),
+                        PerNs::types(Resolution::GenericParam(param.idx)),
+                    )
+                }
+            }
+            Scope::ImplBlockScope(i) => {
+                f(
+                    Name::self_type(),
+                    PerNs::types(Resolution::SelfType(i.clone())),
+                );
+            }
+            Scope::ExprScope(e) => {
+                e.expr_scopes.entries(e.scope_id).iter().for_each(|e| {
+                    f(
+                        e.name().clone(),
+                        PerNs::values(Resolution::LocalBinding(e.pat())),
+                    );
+                });
+            }
+        }
+    }
+}
diff --git a/crates/ra_hir/src/source_binder.rs b/crates/ra_hir/src/source_binder.rs
index d1eaccf23..59f782277 100644
--- a/crates/ra_hir/src/source_binder.rs
+++ b/crates/ra_hir/src/source_binder.rs
@@ -9,13 +9,14 @@ use ra_db::{FileId, FilePosition};
 use ra_syntax::{
     SmolStr, TextRange, SyntaxNode,
     ast::{self, AstNode, NameOwner},
-    algo::find_node_at_offset,
+    algo::{find_node_at_offset, find_leaf_at_offset},
 };
 
 use crate::{
     HirDatabase, Function, ModuleDef, Struct, Enum,
-    AsName, Module, HirFileId, Crate,
+    AsName, Module, HirFileId, Crate, Trait, Resolver,
     ids::{LocationCtx, SourceFileItemId},
+    expr
 };
 
 /// Locates the module by `FileId`. Picks topmost module in the file.
@@ -151,6 +152,19 @@ pub fn enum_from_module(db: &impl HirDatabase, module: Module, enum_def: &ast::E
     }
 }
 
+pub fn trait_from_module(
+    db: &impl HirDatabase,
+    module: Module,
+    trait_def: &ast::TraitDef,
+) -> Trait {
+    let (file_id, _) = module.definition_source(db);
+    let file_id = file_id.into();
+    let ctx = LocationCtx::new(db, module, file_id);
+    Trait {
+        id: ctx.to_def(trait_def),
+    }
+}
+
 pub fn macro_symbols(db: &impl HirDatabase, file_id: FileId) -> Vec<(SmolStr, TextRange)> {
     let module = match module_from_file_id(db, file_id) {
         Some(it) => it,
@@ -188,3 +202,67 @@ pub fn macro_symbols(db: &impl HirDatabase, file_id: FileId) -> Vec<(SmolStr, Te
 
     res
 }
+
+pub fn resolver_for_position(db: &impl HirDatabase, position: FilePosition) -> Resolver {
+    let file_id = position.file_id;
+    let file = db.parse(file_id);
+    find_leaf_at_offset(file.syntax(), position.offset)
+        .find_map(|node| {
+            node.ancestors().find_map(|node| {
+                if ast::Expr::cast(node).is_some() || ast::Block::cast(node).is_some() {
+                    if let Some(func) = function_from_child_node(db, file_id, node) {
+                        let scopes = func.scopes(db);
+                        let scope = scopes.scope_for_offset(position.offset);
+                        Some(expr::resolver_for_scope(func.body(db), db, scope))
+                    } else {
+                        // TODO const/static/array length
+                        None
+                    }
+                } else if let Some(module) = ast::Module::cast(node) {
+                    Some(module_from_declaration(db, file_id, module)?.resolver(db))
+                } else if let Some(_) = ast::SourceFile::cast(node) {
+                    Some(module_from_source(db, file_id.into(), None)?.resolver(db))
+                } else if let Some(s) = ast::StructDef::cast(node) {
+                    let module = module_from_child_node(db, file_id, s.syntax())?;
+                    Some(struct_from_module(db, module, s).resolver(db))
+                } else if let Some(e) = ast::EnumDef::cast(node) {
+                    let module = module_from_child_node(db, file_id, e.syntax())?;
+                    Some(enum_from_module(db, module, e).resolver(db))
+                } else {
+                    // TODO add missing cases
+                    None
+                }
+            })
+        })
+        .unwrap_or_default()
+}
+
+pub fn resolver_for_node(db: &impl HirDatabase, file_id: FileId, node: &SyntaxNode) -> Resolver {
+    node.ancestors()
+        .find_map(|node| {
+            if ast::Expr::cast(node).is_some() || ast::Block::cast(node).is_some() {
+                if let Some(func) = function_from_child_node(db, file_id, node) {
+                    let scopes = func.scopes(db);
+                    let scope = scopes.scope_for(&node);
+                    Some(expr::resolver_for_scope(func.body(db), db, scope))
+                } else {
+                    // TODO const/static/array length
+                    None
+                }
+            } else if let Some(module) = ast::Module::cast(node) {
+                Some(module_from_declaration(db, file_id, module)?.resolver(db))
+            } else if let Some(_) = ast::SourceFile::cast(node) {
+                Some(module_from_source(db, file_id.into(), None)?.resolver(db))
+            } else if let Some(s) = ast::StructDef::cast(node) {
+                let module = module_from_child_node(db, file_id, s.syntax())?;
+                Some(struct_from_module(db, module, s).resolver(db))
+            } else if let Some(e) = ast::EnumDef::cast(node) {
+                let module = module_from_child_node(db, file_id, e.syntax())?;
+                Some(enum_from_module(db, module, e).resolver(db))
+            } else {
+                // TODO add missing cases
+                None
+            }
+        })
+        .unwrap_or_default()
+}
diff --git a/crates/ra_hir/src/ty.rs b/crates/ra_hir/src/ty.rs
index 60c231e82..cc5afad75 100644
--- a/crates/ra_hir/src/ty.rs
+++ b/crates/ra_hir/src/ty.rs
@@ -33,15 +33,16 @@ use rustc_hash::FxHashMap;
 use test_utils::tested_by;
 
 use crate::{
-    Module, Function, Struct, StructField, Enum, EnumVariant, Path, Name, ImplBlock,
-    FnSignature, ExprScopes, ModuleDef, AdtDef,
-    db::HirDatabase,
+    Function, Struct, StructField, Enum, EnumVariant, Path, Name,
+    FnSignature, ModuleDef, AdtDef,
+    HirDatabase,
     type_ref::{TypeRef, Mutability},
     name::KnownName,
-    expr::{Body, Expr, BindingAnnotation, Literal, ExprId, Pat, PatId, UnaryOp, BinaryOp, Statement, FieldPat},
+    expr::{Body, Expr, BindingAnnotation, Literal, ExprId, Pat, PatId, UnaryOp, BinaryOp, Statement, FieldPat, self},
     generics::GenericParams,
     path::GenericArg,
     adt::VariantDef,
+    resolve::{Resolver, Resolution},
 };
 
 /// The ID of a type variable.
@@ -300,47 +301,38 @@ pub struct FnSig {
 }
 
 impl Ty {
-    pub(crate) fn from_hir(
-        db: &impl HirDatabase,
-        // TODO: the next three parameters basically describe the scope for name
-        // resolution; this should be refactored into something like a general
-        // resolver architecture
-        module: &Module,
-        impl_block: Option<&ImplBlock>,
-        generics: &GenericParams,
-        type_ref: &TypeRef,
-    ) -> Self {
+    pub(crate) fn from_hir(db: &impl HirDatabase, resolver: &Resolver, type_ref: &TypeRef) -> Self {
         match type_ref {
             TypeRef::Never => Ty::Never,
             TypeRef::Tuple(inner) => {
                 let inner_tys = inner
                     .iter()
-                    .map(|tr| Ty::from_hir(db, module, impl_block, generics, tr))
+                    .map(|tr| Ty::from_hir(db, resolver, tr))
                     .collect::<Vec<_>>();
                 Ty::Tuple(inner_tys.into())
             }
-            TypeRef::Path(path) => Ty::from_hir_path(db, module, impl_block, generics, path),
+            TypeRef::Path(path) => Ty::from_hir_path(db, resolver, path),
             TypeRef::RawPtr(inner, mutability) => {
-                let inner_ty = Ty::from_hir(db, module, impl_block, generics, inner);
+                let inner_ty = Ty::from_hir(db, resolver, inner);
                 Ty::RawPtr(Arc::new(inner_ty), *mutability)
             }
             TypeRef::Array(inner) => {
-                let inner_ty = Ty::from_hir(db, module, impl_block, generics, inner);
+                let inner_ty = Ty::from_hir(db, resolver, inner);
                 Ty::Array(Arc::new(inner_ty))
             }
             TypeRef::Slice(inner) => {
-                let inner_ty = Ty::from_hir(db, module, impl_block, generics, inner);
+                let inner_ty = Ty::from_hir(db, resolver, inner);
                 Ty::Slice(Arc::new(inner_ty))
             }
             TypeRef::Reference(inner, mutability) => {
-                let inner_ty = Ty::from_hir(db, module, impl_block, generics, inner);
+                let inner_ty = Ty::from_hir(db, resolver, inner);
                 Ty::Ref(Arc::new(inner_ty), *mutability)
             }
             TypeRef::Placeholder => Ty::Unknown,
             TypeRef::Fn(params) => {
                 let mut inner_tys = params
                     .iter()
-                    .map(|tr| Ty::from_hir(db, module, impl_block, generics, tr))
+                    .map(|tr| Ty::from_hir(db, resolver, tr))
                     .collect::<Vec<_>>();
                 let return_ty = inner_tys
                     .pop()
@@ -355,40 +347,13 @@ impl Ty {
         }
     }
 
-    pub(crate) fn from_hir_opt(
-        db: &impl HirDatabase,
-        module: &Module,
-        impl_block: Option<&ImplBlock>,
-        generics: &GenericParams,
-        type_ref: Option<&TypeRef>,
-    ) -> Self {
-        type_ref.map_or(Ty::Unknown, |t| {
-            Ty::from_hir(db, module, impl_block, generics, t)
-        })
-    }
-
-    pub(crate) fn from_hir_path(
-        db: &impl HirDatabase,
-        module: &Module,
-        impl_block: Option<&ImplBlock>,
-        generics: &GenericParams,
-        path: &Path,
-    ) -> Self {
+    pub(crate) fn from_hir_path(db: &impl HirDatabase, resolver: &Resolver, path: &Path) -> Self {
         if let Some(name) = path.as_ident() {
+            // TODO handle primitive type names in resolver as well?
             if let Some(int_ty) = primitive::UncertainIntTy::from_name(name) {
                 return Ty::Int(int_ty);
             } else if let Some(float_ty) = primitive::UncertainFloatTy::from_name(name) {
                 return Ty::Float(float_ty);
-            } else if name.as_known_name() == Some(KnownName::SelfType) {
-                // TODO pass the impl block's generics?
-                let generics = &GenericParams::default();
-                return Ty::from_hir_opt(
-                    db,
-                    module,
-                    None,
-                    generics,
-                    impl_block.map(|i| i.target_type()),
-                );
             } else if let Some(known) = name.as_known_name() {
                 match known {
                     KnownName::Bool => return Ty::Bool,
@@ -396,25 +361,40 @@ impl Ty {
                     KnownName::Str => return Ty::Str,
                     _ => {}
                 }
-            } else if let Some(generic_param) = generics.find_by_name(&name) {
+            }
+        }
+
+        // Resolve the path (in type namespace)
+        let resolution = resolver.resolve_path(db, path).take_types();
+
+        let def = match resolution {
+            Some(Resolution::Def(def)) => def,
+            Some(Resolution::LocalBinding(..)) => {
+                // this should never happen
+                panic!("path resolved to local binding in type ns");
+            }
+            Some(Resolution::GenericParam(idx)) => {
                 return Ty::Param {
-                    idx: generic_param.idx,
-                    name: generic_param.name.clone(),
+                    idx,
+                    // TODO: maybe return name in resolution?
+                    name: path
+                        .as_ident()
+                        .expect("generic param should be single-segment path")
+                        .clone(),
                 };
             }
-        }
+            Some(Resolution::SelfType(impl_block)) => {
+                return impl_block.target_ty(db);
+            }
+            None => return Ty::Unknown,
+        };
 
-        // Resolve in module (in type namespace)
-        let typable: TypableDef = match module
-            .resolve_path(db, path)
-            .take_types()
-            .and_then(|it| it.into())
-        {
+        let typable: TypableDef = match def.into() {
             None => return Ty::Unknown,
             Some(it) => it,
         };
         let ty = db.type_for_def(typable);
-        let substs = Ty::substs_from_path(db, module, impl_block, generics, path, typable);
+        let substs = Ty::substs_from_path(db, resolver, path, typable);
         ty.apply_substs(substs)
     }
 
@@ -422,10 +402,7 @@ impl Ty {
     /// `create_substs_for_ast_path` and `def_to_ty` in rustc.
     fn substs_from_path(
         db: &impl HirDatabase,
-        // the scope of the segment...
-        module: &Module,
-        impl_block: Option<&ImplBlock>,
-        outer_generics: &GenericParams,
+        resolver: &Resolver,
         path: &Path,
         resolved: TypableDef,
     ) -> Substs {
@@ -462,7 +439,7 @@ impl Ty {
             for arg in generic_args.args.iter().take(param_count) {
                 match arg {
                     GenericArg::Type(type_ref) => {
-                        let ty = Ty::from_hir(db, module, impl_block, outer_generics, type_ref);
+                        let ty = Ty::from_hir(db, resolver, type_ref);
                         substs.push(ty);
                     }
                 }
@@ -666,24 +643,17 @@ impl fmt::Display for Ty {
 /// function body.
 fn type_for_fn(db: &impl HirDatabase, def: Function) -> Ty {
     let signature = def.signature(db);
-    let module = def.module(db);
-    let impl_block = def.impl_block(db);
+    let resolver = def.resolver(db);
     let generics = def.generic_params(db);
+    let name = def.name(db);
     let input = signature
         .params()
         .iter()
-        .map(|tr| Ty::from_hir(db, &module, impl_block.as_ref(), &generics, tr))
+        .map(|tr| Ty::from_hir(db, &resolver, tr))
         .collect::<Vec<_>>();
-    let output = Ty::from_hir(
-        db,
-        &module,
-        impl_block.as_ref(),
-        &generics,
-        signature.ret_type(),
-    );
+    let output = Ty::from_hir(db, &resolver, signature.ret_type());
     let sig = Arc::new(FnSig { input, output });
     let substs = make_substs(&generics);
-    let name = def.name(db);
     Ty::FnDef {
         def,
         sig,
@@ -764,13 +734,13 @@ pub(super) fn type_for_def(db: &impl HirDatabase, def: TypableDef) -> Ty {
 
 pub(super) fn type_for_field(db: &impl HirDatabase, field: StructField) -> Ty {
     let parent_def = field.parent_def(db);
-    let (generics, module) = match parent_def {
-        VariantDef::Struct(it) => (it.generic_params(db), it.module(db)),
-        VariantDef::EnumVariant(it) => (it.parent_enum(db).generic_params(db), it.module(db)),
+    let resolver = match parent_def {
+        VariantDef::Struct(it) => it.resolver(db),
+        VariantDef::EnumVariant(it) => it.parent_enum(db).resolver(db),
     };
     let var_data = parent_def.variant_data(db);
     let type_ref = &var_data.fields().unwrap()[field.id].type_ref;
-    Ty::from_hir(db, &module, None, &generics, type_ref)
+    Ty::from_hir(db, &resolver, type_ref)
 }
 
 /// The result of type inference: A mapping from expressions and patterns to types.
@@ -814,9 +784,7 @@ impl Index<PatId> for InferenceResult {
 struct InferenceContext<'a, D: HirDatabase> {
     db: &'a D,
     body: Arc<Body>,
-    scopes: Arc<ExprScopes>,
-    module: Module,
-    impl_block: Option<ImplBlock>,
+    resolver: Resolver,
     var_unification_table: InPlaceUnificationTable<TypeVarId>,
     method_resolutions: FxHashMap<ExprId, Function>,
     field_resolutions: FxHashMap<ExprId, StructField>,
@@ -905,13 +873,7 @@ fn binary_op_rhs_expectation(op: BinaryOp, lhs_ty: Ty) -> Ty {
 }
 
 impl<'a, D: HirDatabase> InferenceContext<'a, D> {
-    fn new(
-        db: &'a D,
-        body: Arc<Body>,
-        scopes: Arc<ExprScopes>,
-        module: Module,
-        impl_block: Option<ImplBlock>,
-    ) -> Self {
+    fn new(db: &'a D, body: Arc<Body>, resolver: Resolver) -> Self {
         InferenceContext {
             method_resolutions: FxHashMap::default(),
             field_resolutions: FxHashMap::default(),
@@ -921,9 +883,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
             return_ty: Ty::Unknown, // set in collect_fn_signature
             db,
             body,
-            scopes,
-            module,
-            impl_block,
+            resolver,
         }
     }
 
@@ -940,8 +900,8 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
             *ty = resolved;
         }
         InferenceResult {
-            method_resolutions: mem::replace(&mut self.method_resolutions, Default::default()),
-            field_resolutions: mem::replace(&mut self.field_resolutions, Default::default()),
+            method_resolutions: self.method_resolutions,
+            field_resolutions: self.field_resolutions,
             type_of_expr: expr_types,
             type_of_pat: pat_types,
         }
@@ -964,13 +924,10 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
     }
 
     fn make_ty(&mut self, type_ref: &TypeRef) -> Ty {
-        // TODO provide generics of function
-        let generics = GenericParams::default();
         let ty = Ty::from_hir(
             self.db,
-            &self.module,
-            self.impl_block.as_ref(),
-            &generics,
+            // TODO use right resolver for block
+            &self.resolver,
             type_ref,
         );
         let ty = self.insert_type_vars(ty);
@@ -1147,38 +1104,31 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
         })
     }
 
-    fn infer_path_expr(&mut self, expr: ExprId, path: &Path) -> Option<Ty> {
-        if path.is_ident() || path.is_self() {
-            // resolve locally
-            let name = path.as_ident().cloned().unwrap_or_else(Name::self_param);
-            if let Some(scope_entry) = self.scopes.resolve_local_name(expr, name) {
-                let ty = self.type_of_pat.get(scope_entry.pat())?;
+    fn infer_path_expr(&mut self, resolver: &Resolver, path: &Path) -> Option<Ty> {
+        let resolved = resolver.resolve_path(self.db, &path).take_values()?;
+        match resolved {
+            Resolution::Def(def) => {
+                let typable: Option<TypableDef> = def.into();
+                let typable = typable?;
+                let substs = Ty::substs_from_path(self.db, &self.resolver, path, typable);
+                let ty = self.db.type_for_def(typable).apply_substs(substs);
+                let ty = self.insert_type_vars(ty);
+                Some(ty)
+            }
+            Resolution::LocalBinding(pat) => {
+                let ty = self.type_of_pat.get(pat)?;
                 let ty = self.resolve_ty_as_possible(&mut vec![], ty.clone());
-                return Some(ty);
-            };
-        };
-
-        // resolve in module
-        let typable: Option<TypableDef> = self
-            .module
-            .resolve_path(self.db, &path)
-            .take_values()?
-            .into();
-        let typable = typable?;
-        let ty = self.db.type_for_def(typable);
-        let generics = GenericParams::default();
-        let substs = Ty::substs_from_path(
-            self.db,
-            &self.module,
-            self.impl_block.as_ref(),
-            &generics,
-            path,
-            typable,
-        );
-        let ty = ty.apply_substs(substs);
-        let ty = self.insert_type_vars(ty);
-
-        Some(ty)
+                Some(ty)
+            }
+            Resolution::GenericParam(..) => {
+                // generic params can't refer to values... yet
+                None
+            }
+            Resolution::SelfType(_) => {
+                log::error!("path expr {:?} resolved to Self type in values ns", path);
+                None
+            }
+        }
     }
 
     fn resolve_variant(&mut self, path: Option<&Path>) -> (Ty, Option<VariantDef>) {
@@ -1186,26 +1136,30 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
             Some(path) => path,
             None => return (Ty::Unknown, None),
         };
-        let typable: Option<TypableDef> = self
-            .module
-            .resolve_path(self.db, &path)
-            .take_types()
-            .and_then(|it| it.into());
+        let resolver = &self.resolver;
+        let typable: Option<TypableDef> = match resolver.resolve_path(self.db, &path).take_types() {
+            Some(Resolution::Def(def)) => def.into(),
+            Some(Resolution::LocalBinding(..)) => {
+                // this cannot happen
+                log::error!("path resolved to local binding in type ns");
+                return (Ty::Unknown, None);
+            }
+            Some(Resolution::GenericParam(..)) => {
+                // generic params can't be used in struct literals
+                return (Ty::Unknown, None);
+            }
+            Some(Resolution::SelfType(..)) => {
+                // TODO this is allowed in an impl for a struct, handle this
+                return (Ty::Unknown, None);
+            }
+            None => return (Ty::Unknown, None),
+        };
         let def = match typable {
             None => return (Ty::Unknown, None),
             Some(it) => it,
         };
         // TODO remove the duplication between here and `Ty::from_path`?
-        // TODO provide generics of function
-        let generics = GenericParams::default();
-        let substs = Ty::substs_from_path(
-            self.db,
-            &self.module,
-            self.impl_block.as_ref(),
-            &generics,
-            path,
-            def,
-        );
+        let substs = Ty::substs_from_path(self.db, resolver, path, def);
         match def {
             TypableDef::Struct(s) => {
                 let ty = type_for_struct(self.db, s);
@@ -1303,12 +1257,12 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                 path: ref p,
                 args: ref fields,
             } => self.infer_struct_pat(p.as_ref(), fields, expected),
-            Pat::Path(path) => self
-                .module
-                .resolve_path(self.db, &path)
-                .take_values()
-                .and_then(|module_def| module_def.into())
-                .map_or(Ty::Unknown, |resolved| self.db.type_for_def(resolved)),
+            Pat::Path(path) => {
+                // TODO use correct resolver for the surrounding expression
+                let resolver = self.resolver.clone();
+                self.infer_path_expr(&resolver, &path)
+                    .unwrap_or(Ty::Unknown)
+            }
             Pat::Bind {
                 mode,
                 name: _name,
@@ -1496,7 +1450,11 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
 
                 expected.ty
             }
-            Expr::Path(p) => self.infer_path_expr(tgt_expr, p).unwrap_or(Ty::Unknown),
+            Expr::Path(p) => {
+                // TODO this could be more efficient...
+                let resolver = expr::resolver_for_expr(self.body.clone(), self.db, tgt_expr);
+                self.infer_path_expr(&resolver, p).unwrap_or(Ty::Unknown)
+            }
             Expr::Continue => Ty::Never,
             Expr::Break { expr } => {
                 if let Some(expr) = expr {
@@ -1730,10 +1688,8 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
 pub fn infer(db: &impl HirDatabase, func: Function) -> Arc<InferenceResult> {
     db.check_canceled();
     let body = func.body(db);
-    let scopes = db.expr_scopes(func);
-    let module = func.module(db);
-    let impl_block = func.impl_block(db);
-    let mut ctx = InferenceContext::new(db, body, scopes, module, impl_block);
+    let resolver = func.resolver(db);
+    let mut ctx = InferenceContext::new(db, body, resolver);
 
     let signature = func.signature(db);
     ctx.collect_fn_signature(&signature);
diff --git a/crates/ra_hir/src/ty/method_resolution.rs b/crates/ra_hir/src/ty/method_resolution.rs
index 37bc3f38c..2282286b0 100644
--- a/crates/ra_hir/src/ty/method_resolution.rs
+++ b/crates/ra_hir/src/ty/method_resolution.rs
@@ -7,17 +7,16 @@ use std::sync::Arc;
 use rustc_hash::FxHashMap;
 
 use crate::{
-    HirDatabase, module_tree::ModuleId, Module, Crate, Name, Function,
+    HirDatabase, module_tree::ModuleId, Module, Crate, Name, Function, Trait,
+    ids::TraitId,
     impl_block::{ImplId, ImplBlock, ImplItem},
-    generics::GenericParams,
-    ty::{AdtDef, Ty}
+    ty::{AdtDef, Ty},
 };
 
 /// This is used as a key for indexing impls.
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub enum TyFingerprint {
-    Adt(AdtDef),
-    // we'll also want to index impls for primitive types etc.
+    Adt(AdtDef), // we'll also want to index impls for primitive types etc.
 }
 
 impl TyFingerprint {
@@ -37,6 +36,7 @@ pub struct CrateImplBlocks {
     /// To make sense of the ModuleIds, we need the source root.
     krate: Crate,
     impls: FxHashMap<TyFingerprint, Vec<(ModuleId, ImplId)>>,
+    impls_by_trait: FxHashMap<TraitId, Vec<(ModuleId, ImplId)>>,
 }
 
 impl CrateImplBlocks {
@@ -60,30 +60,46 @@ impl CrateImplBlocks {
             })
     }
 
+    pub fn lookup_impl_blocks_for_trait<'a>(
+        &'a self,
+        db: &'a impl HirDatabase,
+        tr: &Trait,
+    ) -> impl Iterator<Item = (Module, ImplBlock)> + 'a {
+        let id = tr.id;
+        self.impls_by_trait
+            .get(&id)
+            .into_iter()
+            .flat_map(|i| i.iter())
+            .map(move |(module_id, impl_id)| {
+                let module = Module {
+                    krate: self.krate,
+                    module_id: *module_id,
+                };
+                let module_impl_blocks = db.impls_in_module(module);
+                (module, ImplBlock::from_id(module_impl_blocks, *impl_id))
+            })
+    }
+
     fn collect_recursive(&mut self, db: &impl HirDatabase, module: &Module) {
         let module_impl_blocks = db.impls_in_module(module.clone());
 
-        for (impl_id, impl_data) in module_impl_blocks.impls.iter() {
+        for (impl_id, _) in module_impl_blocks.impls.iter() {
             let impl_block = ImplBlock::from_id(Arc::clone(&module_impl_blocks), impl_id);
 
-            if let Some(_target_trait) = impl_data.target_trait() {
-                // ignore for now
-            } else {
-                // TODO provide generics of impl
-                let generics = GenericParams::default();
-                let target_ty = Ty::from_hir(
-                    db,
-                    &module,
-                    Some(&impl_block),
-                    &generics,
-                    impl_data.target_type(),
-                );
-                if let Some(target_ty_fp) = TyFingerprint::for_impl(&target_ty) {
-                    self.impls
-                        .entry(target_ty_fp)
-                        .or_insert_with(Vec::new)
-                        .push((module.module_id, impl_id));
-                }
+            let target_ty = impl_block.target_ty(db);
+
+            if let Some(target_ty_fp) = TyFingerprint::for_impl(&target_ty) {
+                self.impls
+                    .entry(target_ty_fp)
+                    .or_insert_with(Vec::new)
+                    .push((module.module_id, impl_id));
+            }
+
+            if let Some(tr) = impl_block.target_trait(db) {
+                self.impls_by_trait
+                    .entry(tr.id)
+                    .or_insert_with(Vec::new)
+                    .push((module.module_id, impl_id));
             }
         }
 
@@ -99,6 +115,7 @@ impl CrateImplBlocks {
         let mut crate_impl_blocks = CrateImplBlocks {
             krate: krate.clone(),
             impls: FxHashMap::default(),
+            impls_by_trait: FxHashMap::default(),
         };
         if let Some(module) = krate.root_module(db) {
             crate_impl_blocks.collect_recursive(db, &module);
diff --git a/crates/ra_hir/src/ty/snapshots/tests__infer_function_generics.snap b/crates/ra_hir/src/ty/snapshots/tests__infer_function_generics.snap
index 8ff6e55a6..91c48897c 100644
--- a/crates/ra_hir/src/ty/snapshots/tests__infer_function_generics.snap
+++ b/crates/ra_hir/src/ty/snapshots/tests__infer_function_generics.snap
@@ -1,12 +1,12 @@
 ---
-created: "2019-01-26T18:16:16.530712344+00:00"
+created: "2019-01-27T14:52:29.934503829+00:00"
 creator: [email protected]
 expression: "&result"
 source: crates/ra_hir/src/ty/tests.rs
 ---
-[10; 11) 't': [unknown]
-[21; 26) '{ t }': [unknown]
-[23; 24) 't': [unknown]
+[10; 11) 't': T
+[21; 26) '{ t }': T
+[23; 24) 't': T
 [38; 98) '{     ...(1); }': ()
 [44; 46) 'id': fn id<u32>(T) -> T
 [44; 52) 'id(1u32)': u32
diff --git a/crates/ra_hir/src/ty/snapshots/tests__infer_generic_chain.snap b/crates/ra_hir/src/ty/snapshots/tests__infer_generic_chain.snap
index f21bffa75..626f31252 100644
--- a/crates/ra_hir/src/ty/snapshots/tests__infer_generic_chain.snap
+++ b/crates/ra_hir/src/ty/snapshots/tests__infer_generic_chain.snap
@@ -1,5 +1,5 @@
 ---
-created: "2019-01-26T17:46:03.866825843+00:00"
+created: "2019-01-27T14:52:29.938713255+00:00"
 creator: [email protected]
 expression: "&result"
 source: crates/ra_hir/src/ty/tests.rs
@@ -8,9 +8,9 @@ source: crates/ra_hir/src/ty/tests.rs
 [65; 87) '{     ...     }': [unknown]
 [75; 79) 'self': A<[unknown]>
 [75; 81) 'self.x': [unknown]
-[99; 100) 't': [unknown]
-[110; 115) '{ t }': [unknown]
-[112; 113) 't': [unknown]
+[99; 100) 't': T
+[110; 115) '{ t }': T
+[112; 113) 't': T
 [135; 261) '{     ....x() }': i128
 [146; 147) 'x': i32
 [150; 151) '1': i32
diff --git a/crates/ra_hir/src/ty/snapshots/tests__infer_type_param.snap b/crates/ra_hir/src/ty/snapshots/tests__infer_type_param.snap
index a99323264..216d1e41f 100644
--- a/crates/ra_hir/src/ty/snapshots/tests__infer_type_param.snap
+++ b/crates/ra_hir/src/ty/snapshots/tests__infer_type_param.snap
@@ -1,15 +1,15 @@
 ---
-created: "2019-01-27T16:54:18.368427685+00:00"
+created: "2019-01-27T20:38:32.153717698+00:00"
 creator: [email protected]
 expression: "&result"
 source: crates/ra_hir/src/ty/tests.rs
 ---
-[10; 11) 'x': [unknown]
-[21; 30) '{     x }': [unknown]
-[27; 28) 'x': [unknown]
-[44; 45) 'x': &[unknown]
-[56; 65) '{     x }': &[unknown]
-[62; 63) 'x': &[unknown]
+[10; 11) 'x': T
+[21; 30) '{     x }': T
+[27; 28) 'x': T
+[44; 45) 'x': &T
+[56; 65) '{     x }': &T
+[62; 63) 'x': &T
 [77; 157) '{     ...(1); }': ()
 [87; 88) 'y': u32
 [91; 96) '10u32': u32