15 files changed, 256 insertions, 776 deletions

diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs
index 962d5a8c1..731cc1fff 100644
--- a/crates/ra_hir/src/code_model.rs
+++ b/crates/ra_hir/src/code_model.rs
@@ -11,7 +11,7 @@ use hir_def::{
     body::scope::ExprScopes,
     builtin_type::BuiltinType,
     type_ref::{Mutability, TypeRef},
-    CrateModuleId, LocalEnumVariantId, LocalStructFieldId, ModuleId, UnionId,
+    CrateModuleId, ImplId, LocalEnumVariantId, LocalStructFieldId, ModuleId, UnionId,
 };
 use hir_expand::{
     diagnostics::DiagnosticSink,
@@ -23,13 +23,12 @@ use ra_syntax::ast::{self, NameOwner, TypeAscriptionOwner};
 use crate::{
     adt::VariantDef,
     db::{AstDatabase, DefDatabase, HirDatabase},
-    expr::{validation::ExprValidator, BindingAnnotation, Body, BodySourceMap, Pat, PatId},
+    expr::{BindingAnnotation, Body, BodySourceMap, ExprValidator, Pat, PatId},
     generics::{GenericDef, HasGenericParams},
     ids::{
         AstItemDef, ConstId, EnumId, FunctionId, MacroDefId, StaticId, StructId, TraitId,
         TypeAliasId,
     },
-    impl_block::ImplBlock,
     resolve::{Resolver, Scope, TypeNs},
     traits::TraitData,
     ty::{InferenceResult, Namespace, TraitRef},
@@ -157,7 +156,7 @@ impl Module {
     }
 
     /// Finds a child module with the specified name.
-    pub fn child(self, db: &impl HirDatabase, name: &Name) -> Option<Module> {
+    pub fn child(self, db: &impl DefDatabase, name: &Name) -> Option<Module> {
         let def_map = db.crate_def_map(self.id.krate);
         let child_id = def_map[self.id.module_id].children.get(name)?;
         Some(self.with_module_id(*child_id))
@@ -243,12 +242,8 @@ impl Module {
     }
 
     pub fn impl_blocks(self, db: &impl DefDatabase) -> Vec<ImplBlock> {
-        let module_impl_blocks = db.impls_in_module(self);
-        module_impl_blocks
-            .impls
-            .iter()
-            .map(|(impl_id, _)| ImplBlock::from_id(self, impl_id))
-            .collect()
+        let def_map = db.crate_def_map(self.id.krate);
+        def_map[self.id.module_id].impls.iter().copied().map(ImplBlock::from).collect()
     }
 
     fn with_module_id(self, module_id: CrateModuleId) -> Module {
@@ -693,8 +688,7 @@ impl Function {
 
     /// The containing impl block, if this is a method.
     pub fn impl_block(self, db: &impl DefDatabase) -> Option<ImplBlock> {
-        let module_impls = db.impls_in_module(self.module(db));
-        ImplBlock::containing(module_impls, self.into())
+        ImplBlock::containing(db, self.into())
     }
 
     /// The containing trait, if this is a trait method definition.
@@ -759,8 +753,7 @@ impl Const {
 
     /// The containing impl block, if this is a method.
     pub fn impl_block(self, db: &impl DefDatabase) -> Option<ImplBlock> {
-        let module_impls = db.impls_in_module(self.module(db));
-        ImplBlock::containing(module_impls, self.into())
+        ImplBlock::containing(db, self.into())
     }
 
     pub fn parent_trait(self, db: &impl DefDatabase) -> Option<Trait> {
@@ -973,8 +966,7 @@ impl TypeAlias {
 
     /// The containing impl block, if this is a method.
     pub fn impl_block(self, db: &impl DefDatabase) -> Option<ImplBlock> {
-        let module_impls = db.impls_in_module(self.module(db));
-        ImplBlock::containing(module_impls, self.into())
+        ImplBlock::containing(db, self.into())
     }
 
     /// The containing trait, if this is a trait method definition.
@@ -1137,3 +1129,8 @@ pub struct GenericParam {
     pub(crate) parent: GenericDef,
     pub(crate) idx: u32,
 }
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct ImplBlock {
+    pub(crate) id: ImplId,
+}
diff --git a/crates/ra_hir/src/db.rs b/crates/ra_hir/src/db.rs
index c60029c01..276b0774f 100644
--- a/crates/ra_hir/src/db.rs
+++ b/crates/ra_hir/src/db.rs
@@ -10,7 +10,6 @@ use crate::{
     debug::HirDebugDatabase,
     generics::{GenericDef, GenericParams},
     ids,
-    impl_block::{ImplBlock, ImplSourceMap, ModuleImplBlocks},
     lang_item::{LangItemTarget, LangItems},
     traits::TraitData,
     ty::{
@@ -18,14 +17,14 @@ use crate::{
         InferenceResult, Namespace, Substs, Ty, TypableDef, TypeCtor,
     },
     type_alias::TypeAliasData,
-    Const, ConstData, Crate, DefWithBody, FnData, Function, Module, Static, StructField, Trait,
-    TypeAlias,
+    Const, ConstData, Crate, DefWithBody, FnData, Function, ImplBlock, Module, Static, StructField,
+    Trait, TypeAlias,
 };
 
 pub use hir_def::db::{
     BodyQuery, BodyWithSourceMapQuery, CrateDefMapQuery, DefDatabase2, DefDatabase2Storage,
-    EnumDataQuery, ExprScopesQuery, InternDatabase, InternDatabaseStorage, RawItemsQuery,
-    RawItemsWithSourceMapQuery, StructDataQuery,
+    EnumDataQuery, ExprScopesQuery, ImplDataQuery, InternDatabase, InternDatabaseStorage,
+    RawItemsQuery, RawItemsWithSourceMapQuery, StructDataQuery,
 };
 pub use hir_expand::db::{
     AstDatabase, AstDatabaseStorage, AstIdMapQuery, MacroArgQuery, MacroDefQuery, MacroExpandQuery,
@@ -42,15 +41,6 @@ pub trait DefDatabase: HirDebugDatabase + DefDatabase2 {
     #[salsa::invoke(crate::traits::TraitItemsIndex::trait_items_index)]
     fn trait_items_index(&self, module: Module) -> crate::traits::TraitItemsIndex;
 
-    #[salsa::invoke(ModuleImplBlocks::impls_in_module_with_source_map_query)]
-    fn impls_in_module_with_source_map(
-        &self,
-        module: Module,
-    ) -> (Arc<ModuleImplBlocks>, Arc<ImplSourceMap>);
-
-    #[salsa::invoke(ModuleImplBlocks::impls_in_module_query)]
-    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>;
 
@@ -128,7 +118,7 @@ pub trait HirDatabase: DefDatabase + AstDatabase {
     #[salsa::interned]
     fn intern_type_ctor(&self, type_ctor: TypeCtor) -> ids::TypeCtorId;
     #[salsa::interned]
-    fn intern_impl(&self, impl_: Impl) -> ids::GlobalImplId;
+    fn intern_chalk_impl(&self, impl_: Impl) -> ids::GlobalImplId;
 
     #[salsa::invoke(crate::ty::traits::chalk::associated_ty_data_query)]
     fn associated_ty_data(&self, id: chalk_ir::TypeId) -> Arc<chalk_rust_ir::AssociatedTyDatum>;
diff --git a/crates/ra_hir/src/expr.rs b/crates/ra_hir/src/expr.rs
index 9262325f2..e3733779e 100644
--- a/crates/ra_hir/src/expr.rs
+++ b/crates/ra_hir/src/expr.rs
@@ -1,12 +1,19 @@
 //! FIXME: write short doc here
 
-pub(crate) mod validation;
-
 use std::sync::Arc;
 
+use hir_def::path::known;
+use hir_expand::diagnostics::DiagnosticSink;
+use ra_syntax::ast;
 use ra_syntax::AstPtr;
+use rustc_hash::FxHashSet;
 
-use crate::{db::HirDatabase, DefWithBody, HasBody, Resolver};
+use crate::{
+    db::HirDatabase,
+    diagnostics::{MissingFields, MissingOkInTailExpr},
+    ty::{ApplicationTy, InferenceResult, Ty, TypeCtor},
+    Adt, DefWithBody, Function, HasBody, Name, Path, Resolver,
+};
 
 pub use hir_def::{
     body::{
@@ -38,196 +45,126 @@ pub(crate) fn resolver_for_scope(
     let scopes = owner.expr_scopes(db);
     let scope_chain = scopes.scope_chain(scope_id).collect::<Vec<_>>();
     for scope in scope_chain.into_iter().rev() {
-        r = r.push_expr_scope(Arc::clone(&scopes), scope);
+        r = r.push_expr_scope(owner, Arc::clone(&scopes), scope);
     }
     r
 }
 
-#[cfg(test)]
-mod tests {
-    use hir_expand::Source;
-    use ra_db::{fixture::WithFixture, SourceDatabase};
-    use ra_syntax::{algo::find_node_at_offset, ast, AstNode};
-    use test_utils::{assert_eq_text, extract_offset};
-
-    use crate::{source_binder::SourceAnalyzer, test_db::TestDB};
-
-    fn do_check(code: &str, expected: &[&str]) {
-        let (off, code) = extract_offset(code);
-        let code = {
-            let mut buf = String::new();
-            let off = u32::from(off) as usize;
-            buf.push_str(&code[..off]);
-            buf.push_str("marker");
-            buf.push_str(&code[off..]);
-            buf
-        };
+pub(crate) struct ExprValidator<'a, 'b: 'a> {
+    func: Function,
+    infer: Arc<InferenceResult>,
+    sink: &'a mut DiagnosticSink<'b>,
+}
 
-        let (db, file_id) = TestDB::with_single_file(&code);
-
-        let file = db.parse(file_id).ok().unwrap();
-        let marker: ast::PathExpr = find_node_at_offset(file.syntax(), off).unwrap();
-        let analyzer = SourceAnalyzer::new(&db, file_id, marker.syntax(), None);
-
-        let scopes = analyzer.scopes();
-        let expr_id = analyzer
-            .body_source_map()
-            .node_expr(Source { file_id: file_id.into(), ast: &marker.into() })
-            .unwrap();
-        let scope = scopes.scope_for(expr_id);
-
-        let actual = scopes
-            .scope_chain(scope)
-            .flat_map(|scope| scopes.entries(scope))
-            .map(|it| it.name().to_string())
-            .collect::<Vec<_>>()
-            .join("\n");
-        let expected = expected.join("\n");
-        assert_eq_text!(&expected, &actual);
+impl<'a, 'b> ExprValidator<'a, 'b> {
+    pub(crate) fn new(
+        func: Function,
+        infer: Arc<InferenceResult>,
+        sink: &'a mut DiagnosticSink<'b>,
+    ) -> ExprValidator<'a, 'b> {
+        ExprValidator { func, infer, sink }
     }
 
-    #[test]
-    fn test_lambda_scope() {
-        do_check(
-            r"
-            fn quux(foo: i32) {
-                let f = |bar, baz: i32| {
-                    <|>
-                };
-            }",
-            &["bar", "baz", "foo"],
-        );
-    }
+    pub(crate) fn validate_body(&mut self, db: &impl HirDatabase) {
+        let body = self.func.body(db);
 
-    #[test]
-    fn test_call_scope() {
-        do_check(
-            r"
-            fn quux() {
-                f(|x| <|> );
-            }",
-            &["x"],
-        );
-    }
+        for e in body.exprs() {
+            if let (id, Expr::RecordLit { path, fields, spread }) = e {
+                self.validate_record_literal(id, path, fields, *spread, db);
+            }
+        }
 
-    #[test]
-    fn test_method_call_scope() {
-        do_check(
-            r"
-            fn quux() {
-                z.f(|x| <|> );
-            }",
-            &["x"],
-        );
+        let body_expr = &body[body.body_expr()];
+        if let Expr::Block { statements: _, tail: Some(t) } = body_expr {
+            self.validate_results_in_tail_expr(body.body_expr(), *t, db);
+        }
     }
 
-    #[test]
-    fn test_loop_scope() {
-        do_check(
-            r"
-            fn quux() {
-                loop {
-                    let x = ();
-                    <|>
-                };
-            }",
-            &["x"],
-        );
-    }
+    fn validate_record_literal(
+        &mut self,
+        id: ExprId,
+        _path: &Option<Path>,
+        fields: &[RecordLitField],
+        spread: Option<ExprId>,
+        db: &impl HirDatabase,
+    ) {
+        if spread.is_some() {
+            return;
+        }
+
+        let struct_def = match self.infer[id].as_adt() {
+            Some((Adt::Struct(s), _)) => s,
+            _ => return,
+        };
 
-    #[test]
-    fn test_match() {
-        do_check(
-            r"
-            fn quux() {
-                match () {
-                    Some(x) => {
-                        <|>
+        let lit_fields: FxHashSet<_> = fields.iter().map(|f| &f.name).collect();
+        let missed_fields: Vec<Name> = struct_def
+            .fields(db)
+            .iter()
+            .filter_map(|f| {
+                let name = f.name(db);
+                if lit_fields.contains(&name) {
+                    None
+                } else {
+                    Some(name)
+                }
+            })
+            .collect();
+        if missed_fields.is_empty() {
+            return;
+        }
+        let source_map = self.func.body_source_map(db);
+
+        if let Some(source_ptr) = source_map.expr_syntax(id) {
+            if let Some(expr) = source_ptr.ast.a() {
+                let root = source_ptr.file_syntax(db);
+                if let ast::Expr::RecordLit(record_lit) = expr.to_node(&root) {
+                    if let Some(field_list) = record_lit.record_field_list() {
+                        self.sink.push(MissingFields {
+                            file: source_ptr.file_id,
+                            field_list: AstPtr::new(&field_list),
+                            missed_fields,
+                        })
                     }
-                };
-            }",
-            &["x"],
-        );
-    }
-
-    #[test]
-    fn test_shadow_variable() {
-        do_check(
-            r"
-            fn foo(x: String) {
-                let x : &str = &x<|>;
-            }",
-            &["x"],
-        );
+                }
+            }
+        }
     }
 
-    fn do_check_local_name(code: &str, expected_offset: u32) {
-        let (off, code) = extract_offset(code);
-
-        let (db, file_id) = TestDB::with_single_file(&code);
-        let file = db.parse(file_id).ok().unwrap();
-        let expected_name = find_node_at_offset::<ast::Name>(file.syntax(), expected_offset.into())
-            .expect("failed to find a name at the target offset");
-        let name_ref: ast::NameRef = find_node_at_offset(file.syntax(), off).unwrap();
-        let analyzer = SourceAnalyzer::new(&db, file_id, name_ref.syntax(), None);
+    fn validate_results_in_tail_expr(
+        &mut self,
+        body_id: ExprId,
+        id: ExprId,
+        db: &impl HirDatabase,
+    ) {
+        // the mismatch will be on the whole block currently
+        let mismatch = match self.infer.type_mismatch_for_expr(body_id) {
+            Some(m) => m,
+            None => return,
+        };
 
-        let local_name_entry = analyzer.resolve_local_name(&name_ref).unwrap();
-        let local_name =
-            local_name_entry.ptr().either(|it| it.syntax_node_ptr(), |it| it.syntax_node_ptr());
-        assert_eq!(local_name.range(), expected_name.syntax().text_range());
-    }
+        let std_result_path = known::std_result_result();
 
-    #[test]
-    fn test_resolve_local_name() {
-        do_check_local_name(
-            r#"
-            fn foo(x: i32, y: u32) {
-                {
-                    let z = x * 2;
-                }
-                {
-                    let t = x<|> * 3;
-                }
-            }"#,
-            21,
-        );
-    }
+        let resolver = self.func.resolver(db);
+        let std_result_enum = match resolver.resolve_known_enum(db, &std_result_path) {
+            Some(it) => it,
+            _ => return,
+        };
 
-    #[test]
-    fn test_resolve_local_name_declaration() {
-        do_check_local_name(
-            r#"
-            fn foo(x: String) {
-                let x : &str = &x<|>;
-            }"#,
-            21,
-        );
-    }
+        let std_result_ctor = TypeCtor::Adt(Adt::Enum(std_result_enum));
+        let params = match &mismatch.expected {
+            Ty::Apply(ApplicationTy { ctor, parameters }) if ctor == &std_result_ctor => parameters,
+            _ => return,
+        };
 
-    #[test]
-    fn test_resolve_local_name_shadow() {
-        do_check_local_name(
-            r"
-            fn foo(x: String) {
-                let x : &str = &x;
-                x<|>
-            }
-            ",
-            53,
-        );
-    }
+        if params.len() == 2 && &params[0] == &mismatch.actual {
+            let source_map = self.func.body_source_map(db);
 
-    #[test]
-    fn ref_patterns_contribute_bindings() {
-        do_check_local_name(
-            r"
-            fn foo() {
-                if let Some(&from) = bar() {
-                    from<|>;
+            if let Some(source_ptr) = source_map.expr_syntax(id) {
+                if let Some(expr) = source_ptr.ast.a() {
+                    self.sink.push(MissingOkInTailExpr { file: source_ptr.file_id, expr });
                 }
             }
-            ",
-            53,
-        );
+        }
     }
 }
diff --git a/crates/ra_hir/src/expr/validation.rs b/crates/ra_hir/src/expr/validation.rs
deleted file mode 100644
index 3054f1dce..000000000
--- a/crates/ra_hir/src/expr/validation.rs
+++ /dev/null
@@ -1,137 +0,0 @@
-//! FIXME: write short doc here
-
-use std::sync::Arc;
-
-use hir_def::path::known;
-use hir_expand::diagnostics::DiagnosticSink;
-use ra_syntax::ast;
-use rustc_hash::FxHashSet;
-
-use crate::{
-    db::HirDatabase,
-    diagnostics::{MissingFields, MissingOkInTailExpr},
-    expr::AstPtr,
-    ty::{ApplicationTy, InferenceResult, Ty, TypeCtor},
-    Adt, Function, Name, Path,
-};
-
-use super::{Expr, ExprId, RecordLitField};
-
-pub(crate) struct ExprValidator<'a, 'b: 'a> {
-    func: Function,
-    infer: Arc<InferenceResult>,
-    sink: &'a mut DiagnosticSink<'b>,
-}
-
-impl<'a, 'b> ExprValidator<'a, 'b> {
-    pub(crate) fn new(
-        func: Function,
-        infer: Arc<InferenceResult>,
-        sink: &'a mut DiagnosticSink<'b>,
-    ) -> ExprValidator<'a, 'b> {
-        ExprValidator { func, infer, sink }
-    }
-
-    pub(crate) fn validate_body(&mut self, db: &impl HirDatabase) {
-        let body = self.func.body(db);
-
-        for e in body.exprs() {
-            if let (id, Expr::RecordLit { path, fields, spread }) = e {
-                self.validate_record_literal(id, path, fields, *spread, db);
-            }
-        }
-
-        let body_expr = &body[body.body_expr()];
-        if let Expr::Block { statements: _, tail: Some(t) } = body_expr {
-            self.validate_results_in_tail_expr(body.body_expr(), *t, db);
-        }
-    }
-
-    fn validate_record_literal(
-        &mut self,
-        id: ExprId,
-        _path: &Option<Path>,
-        fields: &[RecordLitField],
-        spread: Option<ExprId>,
-        db: &impl HirDatabase,
-    ) {
-        if spread.is_some() {
-            return;
-        }
-
-        let struct_def = match self.infer[id].as_adt() {
-            Some((Adt::Struct(s), _)) => s,
-            _ => return,
-        };
-
-        let lit_fields: FxHashSet<_> = fields.iter().map(|f| &f.name).collect();
-        let missed_fields: Vec<Name> = struct_def
-            .fields(db)
-            .iter()
-            .filter_map(|f| {
-                let name = f.name(db);
-                if lit_fields.contains(&name) {
-                    None
-                } else {
-                    Some(name)
-                }
-            })
-            .collect();
-        if missed_fields.is_empty() {
-            return;
-        }
-        let source_map = self.func.body_source_map(db);
-
-        if let Some(source_ptr) = source_map.expr_syntax(id) {
-            if let Some(expr) = source_ptr.ast.a() {
-                let root = source_ptr.file_syntax(db);
-                if let ast::Expr::RecordLit(record_lit) = expr.to_node(&root) {
-                    if let Some(field_list) = record_lit.record_field_list() {
-                        self.sink.push(MissingFields {
-                            file: source_ptr.file_id,
-                            field_list: AstPtr::new(&field_list),
-                            missed_fields,
-                        })
-                    }
-                }
-            }
-        }
-    }
-
-    fn validate_results_in_tail_expr(
-        &mut self,
-        body_id: ExprId,
-        id: ExprId,
-        db: &impl HirDatabase,
-    ) {
-        // the mismatch will be on the whole block currently
-        let mismatch = match self.infer.type_mismatch_for_expr(body_id) {
-            Some(m) => m,
-            None => return,
-        };
-
-        let std_result_path = known::std_result_result();
-
-        let resolver = self.func.resolver(db);
-        let std_result_enum = match resolver.resolve_known_enum(db, &std_result_path) {
-            Some(it) => it,
-            _ => return,
-        };
-
-        let std_result_ctor = TypeCtor::Adt(Adt::Enum(std_result_enum));
-        let params = match &mismatch.expected {
-            Ty::Apply(ApplicationTy { ctor, parameters }) if ctor == &std_result_ctor => parameters,
-            _ => return,
-        };
-
-        if params.len() == 2 && &params[0] == &mismatch.actual {
-            let source_map = self.func.body_source_map(db);
-
-            if let Some(source_ptr) = source_map.expr_syntax(id) {
-                if let Some(expr) = source_ptr.ast.a() {
-                    self.sink.push(MissingOkInTailExpr { file: source_ptr.file_id, expr });
-                }
-            }
-        }
-    }
-}
diff --git a/crates/ra_hir/src/from_id.rs b/crates/ra_hir/src/from_id.rs
index 9633ef586..f2203e995 100644
--- a/crates/ra_hir/src/from_id.rs
+++ b/crates/ra_hir/src/from_id.rs
@@ -3,9 +3,9 @@
 //! It's unclear if we need this long-term, but it's definitelly useful while we
 //! are splitting the hir.
 
-use hir_def::{AdtId, DefWithBodyId, EnumVariantId, ModuleDefId};
+use hir_def::{AdtId, AssocItemId, DefWithBodyId, EnumVariantId, ModuleDefId};
 
-use crate::{Adt, DefWithBody, EnumVariant, ModuleDef};
+use crate::{Adt, AssocItem, DefWithBody, EnumVariant, ModuleDef};
 
 macro_rules! from_id {
     ($(($id:path, $ty:path)),*) => {$(
@@ -27,6 +27,7 @@ from_id![
     (hir_def::StaticId, crate::Static),
     (hir_def::ConstId, crate::Const),
     (hir_def::FunctionId, crate::Function),
+    (hir_def::ImplId, crate::ImplBlock),
     (hir_expand::MacroDefId, crate::MacroDef)
 ];
 
@@ -71,3 +72,13 @@ impl From<DefWithBody> for DefWithBodyId {
         }
     }
 }
+
+impl From<AssocItemId> for AssocItem {
+    fn from(def: AssocItemId) -> Self {
+        match def {
+            AssocItemId::FunctionId(it) => AssocItem::Function(it.into()),
+            AssocItemId::TypeAliasId(it) => AssocItem::TypeAlias(it.into()),
+            AssocItemId::ConstId(it) => AssocItem::Const(it.into()),
+        }
+    }
+}
diff --git a/crates/ra_hir/src/from_source.rs b/crates/ra_hir/src/from_source.rs
index 9793af858..ec56dfa6a 100644
--- a/crates/ra_hir/src/from_source.rs
+++ b/crates/ra_hir/src/from_source.rs
@@ -1,6 +1,6 @@
 //! FIXME: write short doc here
 
-use hir_def::{StructId, StructOrUnionId, UnionId};
+use hir_def::{ModuleId, StructId, StructOrUnionId, UnionId};
 use hir_expand::name::AsName;
 use ra_syntax::{
     ast::{self, AstNode, NameOwner},
@@ -10,9 +10,9 @@ use ra_syntax::{
 use crate::{
     db::{AstDatabase, DefDatabase, HirDatabase},
     ids::{AstItemDef, LocationCtx},
-    AstId, Const, Crate, DefWithBody, Enum, EnumVariant, FieldSource, Function, HasBody, HasSource,
-    ImplBlock, Local, Module, ModuleSource, Source, Static, Struct, StructField, Trait, TypeAlias,
-    Union, VariantDef,
+    Const, DefWithBody, Enum, EnumVariant, FieldSource, Function, HasBody, HasSource, ImplBlock,
+    Local, Module, ModuleSource, Source, Static, Struct, StructField, Trait, TypeAlias, Union,
+    VariantDef,
 };
 
 pub trait FromSource: Sized {
@@ -82,14 +82,8 @@ impl FromSource for TypeAlias {
 impl FromSource for ImplBlock {
     type Ast = ast::ImplBlock;
     fn from_source(db: &(impl DefDatabase + AstDatabase), src: Source<Self::Ast>) -> Option<Self> {
-        let module_src = crate::ModuleSource::from_child_node(
-            db,
-            src.file_id.original_file(db),
-            &src.ast.syntax(),
-        );
-        let module = Module::from_definition(db, Source { file_id: src.file_id, ast: module_src })?;
-        let impls = module.impl_blocks(db);
-        impls.into_iter().find(|b| b.source(db) == src)
+        let id = from_source(db, src)?;
+        Some(ImplBlock { id })
     }
 }
 
@@ -152,44 +146,48 @@ impl Local {
 }
 
 impl Module {
-    pub fn from_declaration(db: &impl HirDatabase, src: Source<ast::Module>) -> Option<Self> {
-        let src_parent = Source {
-            file_id: src.file_id,
-            ast: ModuleSource::new(db, Some(src.file_id.original_file(db)), None),
-        };
-        let parent_module = Module::from_definition(db, src_parent)?;
+    pub fn from_declaration(db: &impl DefDatabase, src: Source<ast::Module>) -> Option<Self> {
+        let parent_declaration = src.ast.syntax().ancestors().skip(1).find_map(ast::Module::cast);
+
+        let parent_module = match parent_declaration {
+            Some(parent_declaration) => {
+                let src_parent = Source { file_id: src.file_id, ast: parent_declaration };
+                Module::from_declaration(db, src_parent)
+            }
+            _ => {
+                let src_parent = Source {
+                    file_id: src.file_id,
+                    ast: ModuleSource::new(db, Some(src.file_id.original_file(db)), None),
+                };
+                Module::from_definition(db, src_parent)
+            }
+        }?;
+
         let child_name = src.ast.name()?;
         parent_module.child(db, &child_name.as_name())
     }
 
-    pub fn from_definition(
-        db: &(impl DefDatabase + AstDatabase),
-        src: Source<ModuleSource>,
-    ) -> Option<Self> {
-        let decl_id = match src.ast {
+    pub fn from_definition(db: &impl DefDatabase, src: Source<ModuleSource>) -> Option<Self> {
+        match src.ast {
             ModuleSource::Module(ref module) => {
                 assert!(!module.has_semi());
-                let ast_id_map = db.ast_id_map(src.file_id);
-                let item_id = AstId::new(src.file_id, ast_id_map.ast_id(module));
-                Some(item_id)
+                return Module::from_declaration(
+                    db,
+                    Source { file_id: src.file_id, ast: module.clone() },
+                );
             }
-            ModuleSource::SourceFile(_) => None,
+            ModuleSource::SourceFile(_) => (),
         };
 
-        db.relevant_crates(src.file_id.original_file(db)).iter().find_map(|&crate_id| {
-            let def_map = db.crate_def_map(crate_id);
-
-            let (module_id, _module_data) =
-                def_map.modules.iter().find(|(_module_id, module_data)| {
-                    if decl_id.is_some() {
-                        module_data.declaration == decl_id
-                    } else {
-                        module_data.definition.map(|it| it.into()) == Some(src.file_id)
-                    }
-                })?;
+        let original_file = src.file_id.original_file(db);
 
-            Some(Module::new(Crate { crate_id }, module_id))
-        })
+        let (krate, module_id) =
+            db.relevant_crates(original_file).iter().find_map(|&crate_id| {
+                let crate_def_map = db.crate_def_map(crate_id);
+                let local_module_id = crate_def_map.modules_for_file(original_file).next()?;
+                Some((crate_id, local_module_id))
+            })?;
+        Some(Module { id: ModuleId { krate, module_id } })
     }
 }
 
diff --git a/crates/ra_hir/src/impl_block.rs b/crates/ra_hir/src/impl_block.rs
index b1a014074..0c2bb8fee 100644
--- a/crates/ra_hir/src/impl_block.rs
+++ b/crates/ra_hir/src/impl_block.rs
@@ -1,88 +1,38 @@
 //! FIXME: write short doc here
 
-use rustc_hash::FxHashMap;
-use std::sync::Arc;
-
-use hir_def::{attr::Attr, type_ref::TypeRef};
-use hir_expand::hygiene::Hygiene;
-use ra_arena::{impl_arena_id, map::ArenaMap, Arena, RawId};
-use ra_cfg::CfgOptions;
-use ra_syntax::{
-    ast::{self, AstNode},
-    AstPtr,
-};
+use hir_def::{type_ref::TypeRef, AstItemDef};
+use ra_syntax::ast::{self};
 
 use crate::{
-    code_model::{Module, ModuleSource},
     db::{AstDatabase, DefDatabase, HirDatabase},
     generics::HasGenericParams,
-    ids::LocationCtx,
-    ids::MacroCallLoc,
     resolve::Resolver,
     ty::Ty,
-    AssocItem, AstId, Const, Function, HasSource, HirFileId, MacroFileKind, Path, Source, TraitRef,
-    TypeAlias,
+    AssocItem, Crate, HasSource, ImplBlock, Module, Source, TraitRef,
 };
 
-#[derive(Debug, Default, PartialEq, Eq)]
-pub struct ImplSourceMap {
-    map: ArenaMap<ImplId, Source<AstPtr<ast::ImplBlock>>>,
-}
-
-impl ImplSourceMap {
-    fn insert(&mut self, impl_id: ImplId, file_id: HirFileId, impl_block: &ast::ImplBlock) {
-        let source = Source { file_id, ast: AstPtr::new(impl_block) };
-        self.map.insert(impl_id, source)
-    }
-
-    pub fn get(&self, db: &impl AstDatabase, impl_id: ImplId) -> Source<ast::ImplBlock> {
-        let src = self.map[impl_id];
-        let root = src.file_syntax(db);
-        src.map(|ptr| ptr.to_node(&root))
-    }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct ImplBlock {
-    module: Module,
-    impl_id: ImplId,
-}
-
 impl HasSource for ImplBlock {
     type Ast = ast::ImplBlock;
     fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<ast::ImplBlock> {
-        let source_map = db.impls_in_module_with_source_map(self.module).1;
-        source_map.get(db, self.impl_id)
+        self.id.source(db)
     }
 }
 
 impl ImplBlock {
-    pub(crate) fn containing(
-        module_impl_blocks: Arc<ModuleImplBlocks>,
-        item: AssocItem,
-    ) -> Option<ImplBlock> {
-        let impl_id = *module_impl_blocks.impls_by_def.get(&item)?;
-        Some(ImplBlock { module: module_impl_blocks.module, impl_id })
-    }
-
-    pub(crate) fn from_id(module: Module, impl_id: ImplId) -> ImplBlock {
-        ImplBlock { module, impl_id }
-    }
-
-    pub fn id(&self) -> ImplId {
-        self.impl_id
-    }
-
-    pub fn module(&self) -> Module {
-        self.module
+    pub(crate) fn containing(db: &impl DefDatabase, item: AssocItem) -> Option<ImplBlock> {
+        let module = item.module(db);
+        let crate_def_map = db.crate_def_map(module.id.krate);
+        crate_def_map[module.id.module_id].impls.iter().copied().map(ImplBlock::from).find(|it| {
+            db.impl_data(it.id).items().iter().copied().map(AssocItem::from).any(|it| it == item)
+        })
     }
 
     pub fn target_trait(&self, db: &impl DefDatabase) -> Option<TypeRef> {
-        db.impls_in_module(self.module).impls[self.impl_id].target_trait().cloned()
+        db.impl_data(self.id).target_trait().cloned()
     }
 
     pub fn target_type(&self, db: &impl DefDatabase) -> TypeRef {
-        db.impls_in_module(self.module).impls[self.impl_id].target_type().clone()
+        db.impl_data(self.id).target_type().clone()
     }
 
     pub fn target_ty(&self, db: &impl HirDatabase) -> Ty {
@@ -95,15 +45,23 @@ impl ImplBlock {
     }
 
     pub fn items(&self, db: &impl DefDatabase) -> Vec<AssocItem> {
-        db.impls_in_module(self.module).impls[self.impl_id].items().to_vec()
+        db.impl_data(self.id).items().iter().map(|it| (*it).into()).collect()
     }
 
     pub fn is_negative(&self, db: &impl DefDatabase) -> bool {
-        db.impls_in_module(self.module).impls[self.impl_id].negative
+        db.impl_data(self.id).is_negative()
+    }
+
+    pub fn module(&self, db: &impl DefDatabase) -> Module {
+        self.id.module(db).into()
+    }
+
+    pub fn krate(&self, db: &impl DefDatabase) -> Crate {
+        Crate { crate_id: self.module(db).id.krate }
     }
 
     pub(crate) fn resolver(&self, db: &impl DefDatabase) -> Resolver {
-        let r = self.module().resolver(db);
+        let r = self.module(db).resolver(db);
         // 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 };
@@ -111,175 +69,3 @@ impl ImplBlock {
         r
     }
 }
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct ImplData {
-    target_trait: Option<TypeRef>,
-    target_type: TypeRef,
-    items: Vec<AssocItem>,
-    negative: bool,
-}
-
-impl ImplData {
-    pub(crate) fn from_ast(
-        db: &(impl DefDatabase + AstDatabase),
-        file_id: HirFileId,
-        module: Module,
-        node: &ast::ImplBlock,
-    ) -> Self {
-        let target_trait = node.target_trait().map(TypeRef::from_ast);
-        let target_type = TypeRef::from_ast_opt(node.target_type());
-        let ctx = LocationCtx::new(db, module.id, file_id);
-        let negative = node.is_negative();
-        let items = if let Some(item_list) = node.item_list() {
-            item_list
-                .impl_items()
-                .map(|item_node| match item_node {
-                    ast::ImplItem::FnDef(it) => Function { id: ctx.to_def(&it) }.into(),
-                    ast::ImplItem::ConstDef(it) => Const { id: ctx.to_def(&it) }.into(),
-                    ast::ImplItem::TypeAliasDef(it) => TypeAlias { id: ctx.to_def(&it) }.into(),
-                })
-                .collect()
-        } else {
-            Vec::new()
-        };
-        ImplData { target_trait, target_type, items, negative }
-    }
-
-    pub fn target_trait(&self) -> Option<&TypeRef> {
-        self.target_trait.as_ref()
-    }
-
-    pub fn target_type(&self) -> &TypeRef {
-        &self.target_type
-    }
-
-    pub fn items(&self) -> &[AssocItem] {
-        &self.items
-    }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct ImplId(pub RawId);
-impl_arena_id!(ImplId);
-
-/// The collection of impl blocks is a two-step process: first we collect the
-/// blocks per-module; then we build an index of all impl blocks in the crate.
-/// This way, we avoid having to do this process for the whole crate whenever
-/// a file is changed; as long as the impl blocks in the file don't change,
-/// we don't need to do the second step again.
-#[derive(Debug, PartialEq, Eq)]
-pub struct ModuleImplBlocks {
-    pub(crate) module: Module,
-    pub(crate) impls: Arena<ImplId, ImplData>,
-    impls_by_def: FxHashMap<AssocItem, ImplId>,
-}
-
-impl ModuleImplBlocks {
-    pub(crate) fn impls_in_module_with_source_map_query(
-        db: &(impl DefDatabase + AstDatabase),
-        module: Module,
-    ) -> (Arc<ModuleImplBlocks>, Arc<ImplSourceMap>) {
-        let mut source_map = ImplSourceMap::default();
-        let crate_graph = db.crate_graph();
-        let cfg_options = crate_graph.cfg_options(module.id.krate);
-
-        let result = ModuleImplBlocks::collect(db, cfg_options, module, &mut source_map);
-        (Arc::new(result), Arc::new(source_map))
-    }
-
-    pub(crate) fn impls_in_module_query(
-        db: &impl DefDatabase,
-        module: Module,
-    ) -> Arc<ModuleImplBlocks> {
-        db.impls_in_module_with_source_map(module).0
-    }
-
-    fn collect(
-        db: &(impl DefDatabase + AstDatabase),
-        cfg_options: &CfgOptions,
-        module: Module,
-        source_map: &mut ImplSourceMap,
-    ) -> Self {
-        let mut m = ModuleImplBlocks {
-            module,
-            impls: Arena::default(),
-            impls_by_def: FxHashMap::default(),
-        };
-
-        let src = m.module.definition_source(db);
-        match &src.ast {
-            ModuleSource::SourceFile(node) => {
-                m.collect_from_item_owner(db, cfg_options, source_map, node, src.file_id)
-            }
-            ModuleSource::Module(node) => {
-                let item_list = node.item_list().expect("inline module should have item list");
-                m.collect_from_item_owner(db, cfg_options, source_map, &item_list, src.file_id)
-            }
-        };
-        m
-    }
-
-    fn collect_from_item_owner(
-        &mut self,
-        db: &(impl DefDatabase + AstDatabase),
-        cfg_options: &CfgOptions,
-        source_map: &mut ImplSourceMap,
-        owner: &dyn ast::ModuleItemOwner,
-        file_id: HirFileId,
-    ) {
-        let hygiene = Hygiene::new(db, file_id);
-        for item in owner.items_with_macros() {
-            match item {
-                ast::ItemOrMacro::Item(ast::ModuleItem::ImplBlock(impl_block_ast)) => {
-                    let attrs = Attr::from_attrs_owner(&impl_block_ast, &hygiene);
-                    if attrs.map_or(false, |attrs| {
-                        attrs.iter().any(|attr| attr.is_cfg_enabled(cfg_options) == Some(false))
-                    }) {
-                        continue;
-                    }
-
-                    let impl_block = ImplData::from_ast(db, file_id, self.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);
-                    }
-
-                    source_map.insert(id, file_id, &impl_block_ast);
-                }
-                ast::ItemOrMacro::Item(_) => (),
-                ast::ItemOrMacro::Macro(macro_call) => {
-                    let attrs = Attr::from_attrs_owner(&macro_call, &hygiene);
-                    if attrs.map_or(false, |attrs| {
-                        attrs.iter().any(|attr| attr.is_cfg_enabled(cfg_options) == Some(false))
-                    }) {
-                        continue;
-                    }
-
-                    //FIXME: we should really cut down on the boilerplate required to process a macro
-                    let ast_id = AstId::new(file_id, db.ast_id_map(file_id).ast_id(&macro_call));
-                    if let Some(path) =
-                        macro_call.path().and_then(|path| Path::from_src(path, &hygiene))
-                    {
-                        if let Some(def) = self.module.resolver(db).resolve_path_as_macro(db, &path)
-                        {
-                            let call_id = db.intern_macro(MacroCallLoc { def: def.id, ast_id });
-                            let file_id = call_id.as_file(MacroFileKind::Items);
-                            if let Some(item_list) =
-                                db.parse_or_expand(file_id).and_then(ast::MacroItems::cast)
-                            {
-                                self.collect_from_item_owner(
-                                    db,
-                                    cfg_options,
-                                    source_map,
-                                    &item_list,
-                                    file_id,
-                                )
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
diff --git a/crates/ra_hir/src/lang_item.rs b/crates/ra_hir/src/lang_item.rs
index e1780ed38..fa2ef8a17 100644
--- a/crates/ra_hir/src/lang_item.rs
+++ b/crates/ra_hir/src/lang_item.rs
@@ -25,7 +25,7 @@ impl LangItemTarget {
         Some(match self {
             LangItemTarget::Enum(e) => e.module(db).krate(),
             LangItemTarget::Function(f) => f.module(db).krate(),
-            LangItemTarget::ImplBlock(i) => i.module().krate(),
+            LangItemTarget::ImplBlock(i) => i.krate(db),
             LangItemTarget::Static(s) => s.module(db).krate(),
             LangItemTarget::Struct(s) => s.module(db).krate(),
             LangItemTarget::Trait(t) => t.module(db).krate(),
diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs
index 5ba847d35..da33c9591 100644
--- a/crates/ra_hir/src/lib.rs
+++ b/crates/ra_hir/src/lib.rs
@@ -54,12 +54,11 @@ mod test_db;
 #[cfg(test)]
 mod marks;
 
-use hir_expand::AstId;
-
-use crate::{ids::MacroFileKind, resolve::Resolver};
+use crate::resolve::Resolver;
 
 pub use crate::{
     adt::VariantDef,
+    code_model::ImplBlock,
     code_model::{
         attrs::{AttrDef, Attrs},
         docs::{DocDef, Docs, Documentation},
@@ -72,7 +71,6 @@ pub use crate::{
     from_source::FromSource,
     generics::GenericDef,
     ids::{HirFileId, MacroCallId, MacroCallLoc, MacroDefId, MacroFile},
-    impl_block::ImplBlock,
     resolve::ScopeDef,
     source_binder::{PathResolution, ScopeEntryWithSyntax, SourceAnalyzer},
     ty::{
diff --git a/crates/ra_hir/src/resolve.rs b/crates/ra_hir/src/resolve.rs
index 2f3e12eb8..79b92180a 100644
--- a/crates/ra_hir/src/resolve.rs
+++ b/crates/ra_hir/src/resolve.rs
@@ -15,9 +15,8 @@ use crate::{
     db::{DefDatabase, HirDatabase},
     expr::{ExprScopes, PatId, ScopeId},
     generics::GenericParams,
-    impl_block::ImplBlock,
-    Adt, Const, Enum, EnumVariant, Function, MacroDef, ModuleDef, PerNs, Static, Struct, Trait,
-    TypeAlias,
+    Adt, Const, DefWithBody, Enum, EnumVariant, Function, ImplBlock, Local, MacroDef, ModuleDef,
+    PerNs, Static, Struct, Trait, TypeAlias,
 };
 
 #[derive(Debug, Clone, Default)]
@@ -34,6 +33,7 @@ pub(crate) struct ModuleItemMap {
 
 #[derive(Debug, Clone)]
 pub(crate) struct ExprScope {
+    owner: DefWithBody,
     expr_scopes: Arc<ExprScopes>,
     scope_id: ScopeId,
 }
@@ -53,7 +53,7 @@ pub(crate) enum Scope {
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum TypeNs {
+pub(crate) enum TypeNs {
     SelfType(ImplBlock),
     GenericParam(u32),
     Adt(Adt),
@@ -68,13 +68,13 @@ pub enum TypeNs {
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum ResolveValueResult {
+pub(crate) enum ResolveValueResult {
     ValueNs(ValueNs),
     Partial(TypeNs, usize),
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum ValueNs {
+pub(crate) enum ValueNs {
     LocalBinding(PatId),
     Function(Function),
     Const(Const),
@@ -399,10 +399,11 @@ impl Resolver {
 
     pub(crate) fn push_expr_scope(
         self,
+        owner: DefWithBody,
         expr_scopes: Arc<ExprScopes>,
         scope_id: ScopeId,
     ) -> Resolver {
-        self.push_scope(Scope::ExprScope(ExprScope { expr_scopes, scope_id }))
+        self.push_scope(Scope::ExprScope(ExprScope { owner, expr_scopes, scope_id }))
     }
 }
 
@@ -413,7 +414,7 @@ pub enum ScopeDef {
     GenericParam(u32),
     ImplSelfType(ImplBlock),
     AdtSelfType(Adt),
-    LocalBinding(PatId),
+    Local(Local),
     Unknown,
 }
 
@@ -467,9 +468,10 @@ impl Scope {
             Scope::AdtScope(i) => {
                 f(name::SELF_TYPE, ScopeDef::AdtSelfType(*i));
             }
-            Scope::ExprScope(e) => {
-                e.expr_scopes.entries(e.scope_id).iter().for_each(|e| {
-                    f(e.name().clone(), ScopeDef::LocalBinding(e.pat()));
+            Scope::ExprScope(scope) => {
+                scope.expr_scopes.entries(scope.scope_id).iter().for_each(|e| {
+                    let local = Local { parent: scope.owner, pat_id: e.pat() };
+                    f(e.name().clone(), ScopeDef::Local(local));
                 });
             }
         }
diff --git a/crates/ra_hir/src/source_binder.rs b/crates/ra_hir/src/source_binder.rs
index ca40e3b54..662d3f880 100644
--- a/crates/ra_hir/src/source_binder.rs
+++ b/crates/ra_hir/src/source_binder.rs
@@ -19,7 +19,6 @@ use ra_syntax::{
     SyntaxKind::*,
     SyntaxNode, SyntaxNodePtr, TextRange, TextUnit,
 };
-use rustc_hash::FxHashSet;
 
 use crate::{
     db::HirDatabase,
@@ -195,14 +194,6 @@ impl SourceAnalyzer {
         Some(self.infer.as_ref()?[pat_id].clone())
     }
 
-    pub fn type_of_pat_by_id(
-        &self,
-        _db: &impl HirDatabase,
-        pat_id: expr::PatId,
-    ) -> Option<crate::Ty> {
-        Some(self.infer.as_ref()?[pat_id].clone())
-    }
-
     pub fn resolve_method_call(&self, call: &ast::MethodCallExpr) -> Option<Function> {
         let expr_id = self.expr_id(&call.clone().into())?;
         self.infer.as_ref()?.method_resolution(expr_id)
@@ -293,23 +284,15 @@ impl SourceAnalyzer {
         self.resolve_hir_path(db, &hir_path)
     }
 
-    pub fn resolve_local_name(&self, name_ref: &ast::NameRef) -> Option<ScopeEntryWithSyntax> {
-        let mut shadowed = FxHashSet::default();
+    fn resolve_local_name(&self, name_ref: &ast::NameRef) -> Option<ScopeEntryWithSyntax> {
         let name = name_ref.as_name();
         let source_map = self.body_source_map.as_ref()?;
         let scopes = self.scopes.as_ref()?;
-        let scope = scope_for(scopes, source_map, self.file_id.into(), name_ref.syntax());
-        let ret = scopes
-            .scope_chain(scope)
-            .flat_map(|scope| scopes.entries(scope).iter())
-            .filter(|entry| shadowed.insert(entry.name()))
-            .filter(|entry| entry.name() == &name)
-            .nth(0);
-        ret.and_then(|entry| {
-            Some(ScopeEntryWithSyntax {
-                name: entry.name().clone(),
-                ptr: source_map.pat_syntax(entry.pat())?.ast,
-            })
+        let scope = scope_for(scopes, source_map, self.file_id.into(), name_ref.syntax())?;
+        let entry = scopes.resolve_name_in_scope(scope, &name)?;
+        Some(ScopeEntryWithSyntax {
+            name: entry.name().clone(),
+            ptr: source_map.pat_syntax(entry.pat())?.ast,
         })
     }
 
@@ -317,9 +300,9 @@ impl SourceAnalyzer {
         self.resolver.process_all_names(db, f)
     }
 
+    // FIXME: we only use this in `inline_local_variable` assist, ideally, we
+    // should switch to general reference search infra there.
     pub fn find_all_refs(&self, pat: &ast::BindPat) -> Vec<ReferenceDescriptor> {
-        // FIXME: at least, this should work with any DefWithBody, but ideally
-        // this should be hir-based altogether
         let fn_def = pat.syntax().ancestors().find_map(ast::FnDef::cast).unwrap();
         let ptr = Either::A(AstPtr::new(&ast::Pat::from(pat.clone())));
         fn_def
@@ -421,11 +404,6 @@ impl SourceAnalyzer {
     pub(crate) fn inference_result(&self) -> Arc<crate::ty::InferenceResult> {
         self.infer.clone().unwrap()
     }
-
-    #[cfg(test)]
-    pub(crate) fn scopes(&self) -> Arc<ExprScopes> {
-        self.scopes.clone().unwrap()
-    }
 }
 
 fn scope_for(
diff --git a/crates/ra_hir/src/test_db.rs b/crates/ra_hir/src/test_db.rs
index 5237b303a..1caa2e875 100644
--- a/crates/ra_hir/src/test_db.rs
+++ b/crates/ra_hir/src/test_db.rs
@@ -81,7 +81,7 @@ impl TestDB {
         let crate_graph = self.crate_graph();
         for krate in crate_graph.iter().next() {
             let crate_def_map = self.crate_def_map(krate);
-            for (module_id, _) in crate_def_map.modules.iter() {
+            for module_id in crate_def_map.modules() {
                 let module_id = ModuleId { krate, module_id };
                 let module = crate::Module::from(module_id);
                 module.diagnostics(
diff --git a/crates/ra_hir/src/ty/method_resolution.rs b/crates/ra_hir/src/ty/method_resolution.rs
index eb5ca6769..9aad2d3fe 100644
--- a/crates/ra_hir/src/ty/method_resolution.rs
+++ b/crates/ra_hir/src/ty/method_resolution.rs
@@ -5,16 +5,14 @@
 use std::sync::Arc;
 
 use arrayvec::ArrayVec;
-use hir_def::CrateModuleId;
 use rustc_hash::FxHashMap;
 
 use crate::{
     db::HirDatabase,
-    impl_block::{ImplBlock, ImplId},
     resolve::Resolver,
     ty::primitive::{FloatBitness, Uncertain},
     ty::{Ty, TypeCtor},
-    AssocItem, Crate, Function, Module, Mutability, Name, Trait,
+    AssocItem, Crate, Function, ImplBlock, Module, Mutability, Name, Trait,
 };
 
 use super::{autoderef, lower, Canonical, InEnvironment, TraitEnvironment, TraitRef};
@@ -39,65 +37,46 @@ impl TyFingerprint {
 
 #[derive(Debug, PartialEq, Eq)]
 pub struct CrateImplBlocks {
-    /// To make sense of the CrateModuleIds, we need the source root.
-    krate: Crate,
-    impls: FxHashMap<TyFingerprint, Vec<(CrateModuleId, ImplId)>>,
-    impls_by_trait: FxHashMap<Trait, Vec<(CrateModuleId, ImplId)>>,
+    impls: FxHashMap<TyFingerprint, Vec<ImplBlock>>,
+    impls_by_trait: FxHashMap<Trait, Vec<ImplBlock>>,
 }
 
 impl CrateImplBlocks {
-    pub fn lookup_impl_blocks<'a>(&'a self, ty: &Ty) -> impl Iterator<Item = ImplBlock> + 'a {
+    pub(crate) fn impls_in_crate_query(
+        db: &impl HirDatabase,
+        krate: Crate,
+    ) -> Arc<CrateImplBlocks> {
+        let mut crate_impl_blocks =
+            CrateImplBlocks { impls: FxHashMap::default(), impls_by_trait: FxHashMap::default() };
+        if let Some(module) = krate.root_module(db) {
+            crate_impl_blocks.collect_recursive(db, module);
+        }
+        Arc::new(crate_impl_blocks)
+    }
+    pub fn lookup_impl_blocks(&self, ty: &Ty) -> impl Iterator<Item = ImplBlock> + '_ {
         let fingerprint = TyFingerprint::for_impl(ty);
-        fingerprint.and_then(|f| self.impls.get(&f)).into_iter().flat_map(|i| i.iter()).map(
-            move |(module_id, impl_id)| {
-                let module = Module::new(self.krate, *module_id);
-                ImplBlock::from_id(module, *impl_id)
-            },
-        )
+        fingerprint.and_then(|f| self.impls.get(&f)).into_iter().flatten().copied()
     }
 
-    pub fn lookup_impl_blocks_for_trait<'a>(
-        &'a self,
-        tr: Trait,
-    ) -> impl Iterator<Item = ImplBlock> + 'a {
-        self.impls_by_trait.get(&tr).into_iter().flat_map(|i| i.iter()).map(
-            move |(module_id, impl_id)| {
-                let module = Module::new(self.krate, *module_id);
-                ImplBlock::from_id(module, *impl_id)
-            },
-        )
+    pub fn lookup_impl_blocks_for_trait(&self, tr: Trait) -> impl Iterator<Item = ImplBlock> + '_ {
+        self.impls_by_trait.get(&tr).into_iter().flatten().copied()
     }
 
     pub fn all_impls<'a>(&'a self) -> impl Iterator<Item = ImplBlock> + 'a {
-        self.impls.values().chain(self.impls_by_trait.values()).flat_map(|i| i.iter()).map(
-            move |(module_id, impl_id)| {
-                let module = Module::new(self.krate, *module_id);
-                ImplBlock::from_id(module, *impl_id)
-            },
-        )
+        self.impls.values().chain(self.impls_by_trait.values()).flatten().copied()
     }
 
     fn collect_recursive(&mut self, db: &impl HirDatabase, module: Module) {
-        let module_impl_blocks = db.impls_in_module(module);
-
-        for (impl_id, _) in module_impl_blocks.impls.iter() {
-            let impl_block = ImplBlock::from_id(module_impl_blocks.module, impl_id);
-
+        for impl_block in module.impl_blocks(db) {
             let target_ty = impl_block.target_ty(db);
 
             if impl_block.target_trait(db).is_some() {
                 if let Some(tr) = impl_block.target_trait_ref(db) {
-                    self.impls_by_trait
-                        .entry(tr.trait_)
-                        .or_insert_with(Vec::new)
-                        .push((module.id.module_id, impl_id));
+                    self.impls_by_trait.entry(tr.trait_).or_default().push(impl_block);
                 }
             } else {
                 if let Some(target_ty_fp) = TyFingerprint::for_impl(&target_ty) {
-                    self.impls
-                        .entry(target_ty_fp)
-                        .or_insert_with(Vec::new)
-                        .push((module.id.module_id, impl_id));
+                    self.impls.entry(target_ty_fp).or_default().push(impl_block);
                 }
             }
         }
@@ -106,21 +85,6 @@ impl CrateImplBlocks {
             self.collect_recursive(db, child);
         }
     }
-
-    pub(crate) fn impls_in_crate_query(
-        db: &impl HirDatabase,
-        krate: Crate,
-    ) -> Arc<CrateImplBlocks> {
-        let mut crate_impl_blocks = CrateImplBlocks {
-            krate,
-            impls: FxHashMap::default(),
-            impls_by_trait: FxHashMap::default(),
-        };
-        if let Some(module) = krate.root_module(db) {
-            crate_impl_blocks.collect_recursive(db, module);
-        }
-        Arc::new(crate_impl_blocks)
-    }
 }
 
 fn def_crates(db: &impl HirDatabase, cur_crate: Crate, ty: &Ty) -> Option<ArrayVec<[Crate; 2]>> {
diff --git a/crates/ra_hir/src/ty/tests.rs b/crates/ra_hir/src/ty/tests.rs
index 8863c3608..fe9346c78 100644
--- a/crates/ra_hir/src/ty/tests.rs
+++ b/crates/ra_hir/src/ty/tests.rs
@@ -254,7 +254,6 @@ fn test(a: u32, b: isize, c: !, d: &str) {
     1.0f32;
 }"#),
         @r###"
-
     [9; 10) 'a': u32
     [17; 18) 'b': isize
     [27; 28) 'c': !
@@ -317,7 +316,6 @@ fn test() {
 }
 "#),
         @r###"
-
     [15; 20) '{ 1 }': u32
     [17; 18) '1': u32
     [48; 53) '{ 1 }': u32
@@ -354,7 +352,7 @@ fn test() {
     [66; 74) 'S::foo()': i32
     [80; 88) '<S>::foo': fn foo() -> i32
     [80; 90) '<S>::foo()': i32
-"###
+    "###
     );
 }
 
@@ -409,7 +407,6 @@ fn test() {
 }
 "#),
         @r###"
-
     [72; 154) '{     ...a.c; }': ()
     [82; 83) 'c': C
     [86; 87) 'C': C(usize) -> C
@@ -443,7 +440,6 @@ fn test() {
   E::V2;
 }"#),
         @r###"
-
     [48; 82) '{   E:...:V2; }': ()
     [52; 70) 'E::V1 ...d: 1 }': E
     [67; 68) '1': u32
@@ -471,7 +467,6 @@ fn test(a: &u32, b: &mut u32, c: *const u32, d: *mut u32) {
 }
 "#),
         @r###"
-
     [9; 10) 'a': &u32
     [18; 19) 'b': &mut u32
     [31; 32) 'c': *const u32
@@ -524,7 +519,6 @@ fn test() {
 }
 "##),
         @r###"
-
     [11; 221) '{     ...o"#; }': ()
     [17; 21) '5i32': i32
     [27; 31) '5f32': f32
@@ -568,7 +562,6 @@ fn test(x: SomeType) {
 }
 "#),
         @r###"
-
     [27; 28) 'x': SomeType
     [40; 272) '{     ...lo"; }': ()
     [50; 51) 'b': bool
@@ -632,7 +625,6 @@ fn test() -> &mut &f64 {
 }
 "#),
         @r###"
-
     [14; 15) 'x': u32
     [22; 24) '{}': ()
     [78; 231) '{     ...t &c }': &mut &f64
@@ -679,7 +671,6 @@ impl S {
 }
 "#),
         @r###"
-
     [34; 38) 'self': &S
     [40; 61) '{     ...     }': ()
     [50; 54) 'self': &S
@@ -719,7 +710,6 @@ fn test() -> bool {
 }
 "#),
         @r###"
-
     [6; 7) 'x': bool
     [22; 34) '{     0i32 }': i32
     [28; 32) '0i32': i32
@@ -802,7 +792,6 @@ fn test2(a1: *const A, a2: *mut A) {
 }
 "#),
         @r###"
-
     [44; 45) 'a': A
     [50; 213) '{     ...5.b; }': ()
     [60; 62) 'a1': A
@@ -970,7 +959,7 @@ fn test(a: A<i32>) {
     [374; 375) 'B': B<A<i32>>(T) -> B<T>
     [374; 378) 'B(a)': B<A<i32>>
     [376; 377) 'a': A<i32>
-"###
+    "###
     );
 }
 
@@ -983,7 +972,6 @@ fn test() {
 }
 "#),
         @r###"
-
     [11; 37) '{    l... {}; }': ()
     [20; 21) 'x': ()
     [24; 34) 'if true {}': ()
@@ -1105,7 +1093,6 @@ fn test(a: A) {
 }
 "#),
         @r###"
-
     [32; 36) 'self': A
     [38; 39) 'x': u32
     [53; 55) '{}': ()
@@ -1142,7 +1129,6 @@ fn test() {
 }
 "#),
         @r###"
-
     [40; 44) 'self': &str
     [53; 55) '{}': ()
     [69; 89) '{     ...o(); }': ()
@@ -1166,7 +1152,6 @@ fn test(x: &str, y: isize) {
 }
 "#),
         @r###"
-
     [9; 10) 'x': &str
     [18; 19) 'y': isize
     [28; 170) '{     ...d"); }': ()
@@ -1367,7 +1352,6 @@ fn test() {
 }
 "#),
     @r###"
-
     [28; 79) '{     ...(1); }': ()
     [38; 42) 'A(n)': A<i32>
     [40; 41) 'n': &i32
@@ -1396,7 +1380,6 @@ fn test() {
 }
 "#),
     @r###"
-
     [11; 57) '{     ...= v; }': ()
     [21; 22) 'v': &(i32, &i32)
     [25; 33) '&(1, &2)': &(i32, &i32)
@@ -1441,7 +1424,6 @@ fn test() {
 }
 "#),
         @r###"
-
     [68; 289) '{     ...  d; }': ()
     [78; 79) 'e': E
     [82; 95) 'E::A { x: 3 }': E
@@ -1488,7 +1470,6 @@ fn test(a1: A<u32>, i: i32) {
 }
 "#),
         @r###"
-
     [36; 38) 'a1': A<u32>
     [48; 49) 'i': i32
     [56; 147) '{     ...3.x; }': ()
@@ -1569,7 +1550,6 @@ fn test(a1: A<u32>, o: Option<u64>) {
 }
 "#),
         @r###"
-
     [79; 81) 'a1': A<u32>
     [91; 92) 'o': Option<u64>
     [107; 244) '{     ...  }; }': ()
@@ -1604,7 +1584,6 @@ fn test() {
 }
 "#),
         @r###"
-
     [10; 11) 't': T
     [21; 26) '{ t }': T
     [23; 24) 't': T
@@ -1652,7 +1631,6 @@ fn test() -> i128 {
 }
 "#),
         @r###"
-
     [74; 78) 'self': A<X, Y>
     [85; 107) '{     ...     }': X
     [95; 99) 'self': A<X, Y>
@@ -1706,7 +1684,6 @@ fn test(o: Option<u32>) {
 }
 "#),
         @r###"
-
     [78; 82) 'self': &Option<T>
     [98; 100) '{}': ()
     [111; 112) 'o': Option<u32>
@@ -1744,7 +1721,6 @@ fn test() -> i128 {
 }
 "#),
         @r###"
-
     [53; 57) 'self': A<T2>
     [65; 87) '{     ...     }': T2
     [75; 79) 'self': A<T2>
@@ -1921,7 +1897,6 @@ fn test() {
 }
 "#),
         @r###"
-
     [56; 64) '{ A {} }': A
     [58; 62) 'A {}': A
     [126; 132) '{ 99 }': u32
@@ -1961,7 +1936,6 @@ fn test() {
 }
 "#),
         @r###"
-
     [64; 67) 'val': T
     [82; 109) '{     ...     }': Gen<T>
     [92; 103) 'Gen { val }': Gen<T>
@@ -2129,7 +2103,6 @@ fn test(x: X) {
 }
 "#),
         @r###"
-
     [20; 21) 'x': X
     [26; 47) '{     ...eld; }': ()
     [32; 33) 'x': X
@@ -2151,7 +2124,6 @@ fn test() {
 }
 "#),
         @r###"
-
     [11; 89) '{     ...   } }': ()
     [17; 21) 'X {}': {unknown}
     [27; 87) 'match ...     }': ()
@@ -2174,7 +2146,6 @@ fn quux() {
 }
 "#),
         @r###"
-
     [11; 41) '{     ...+ y; }': ()
     [21; 22) 'y': i32
     [25; 27) '92': i32
@@ -2300,7 +2271,6 @@ fn write() {
 }
 "#),
         @r###"
-
     [54; 139) '{     ...   } }': ()
     [60; 137) 'match ...     }': ()
     [66; 83) 'someth...nknown': Maybe<{unknown}>
@@ -2322,7 +2292,6 @@ fn test_line_buffer() {
 }
 "#),
         @r###"
-
     [23; 53) '{     ...n']; }': ()
     [29; 50) '&[0, b...b'\n']': &[u8;_]
     [30; 50) '[0, b'...b'\n']': [u8;_]
@@ -2446,7 +2415,6 @@ fn test<R>(query_response: Canonical<QueryResponse<R>>) {
 }
 "#),
         @r###"
-
     [92; 106) 'query_response': Canonical<QueryResponse<R>>
     [137; 167) '{     ...lue; }': ()
     [143; 164) '&query....value': &QueryResponse<R>
@@ -2472,7 +2440,6 @@ pub fn main_loop() {
 }
 "#),
     @r###"
-
     [144; 146) '{}': ()
     [169; 198) '{     ...t(); }': ()
     [175; 193) 'FxHash...efault': fn default<{unknown}, FxHasher>() -> HashSet<T, H>
@@ -2518,7 +2485,6 @@ fn test() {
 }
 "#),
         @r###"
-
     [49; 50) '0': u32
     [80; 83) '101': u32
     [95; 213) '{     ...NST; }': ()
@@ -2549,7 +2515,6 @@ fn test() {
 }
 "#),
         @r###"
-
     [29; 32) '101': u32
     [70; 73) '101': u32
     [85; 280) '{     ...MUT; }': ()
@@ -2588,7 +2553,6 @@ fn test() {
 }
 "#),
         @r###"
-
     [31; 35) 'self': &Self
     [110; 114) 'self': &Self
     [170; 228) '{     ...i128 }': ()
@@ -2636,7 +2600,6 @@ mod bar_test {
 }
 "#),
         @r###"
-
     [63; 67) 'self': &Self
     [169; 173) 'self': &Self
     [300; 337) '{     ...     }': ()
@@ -2664,7 +2627,6 @@ fn test() {
 }
 "#),
         @r###"
-
     [33; 37) 'self': &Self
     [92; 111) '{     ...d(); }': ()
     [98; 99) 'S': S
@@ -2694,7 +2656,6 @@ fn test() {
 }
 "#),
         @r###"
-
     [43; 47) 'self': &Self
     [82; 86) 'self': &Self
     [210; 361) '{     ..., i8 }': ()
@@ -2725,7 +2686,6 @@ fn test() {
 }
 "#),
         @r###"
-
     [33; 37) 'self': &Self
     [102; 127) '{     ...d(); }': ()
     [108; 109) 'S': S<u32>(T) -> S<T>
@@ -3130,7 +3090,6 @@ fn test<T: Iterable<Item=u32>>() {
 }
 "#),
         @r###"
-
     [67; 100) '{     ...own; }': ()
     [77; 78) 'y': {unknown}
     [90; 97) 'unknown': {unknown}
@@ -3146,7 +3105,6 @@ const A: u32 = 1 + 1;
 static B: u64 = { let x = 1; x };
 "#),
         @r###"
-
     [16; 17) '1': u32
     [16; 21) '1 + 1': u32
     [20; 21) '1': u32
@@ -3170,7 +3128,6 @@ fn test() -> u64 {
 }
 "#),
         @r###"
-
     [38; 87) '{     ... a.1 }': u64
     [48; 49) 'a': S
     [52; 53) 'S': S(i32, u64) -> S
@@ -3225,7 +3182,6 @@ fn indexing_arrays() {
     assert_snapshot!(
         infer("fn main() { &mut [9][2]; }"),
         @r###"
-
     [10; 26) '{ &mut...[2]; }': ()
     [12; 23) '&mut [9][2]': &mut {unknown}
     [17; 20) '[9]': [i32;_]
@@ -4822,9 +4778,9 @@ fn main() {
 }
 "#),
         @r###"
-        ![0; 1) '6': i32
-        [64; 88) '{     ...!(); }': ()
-        [74; 75) 'x': i32
+    ![0; 1) '6': i32
+    [64; 88) '{     ...!(); }': ()
+    [74; 75) 'x': i32
     "###
     );
 }
diff --git a/crates/ra_hir/src/ty/traits/chalk.rs b/crates/ra_hir/src/ty/traits/chalk.rs
index 75351c17d..68304b950 100644
--- a/crates/ra_hir/src/ty/traits/chalk.rs
+++ b/crates/ra_hir/src/ty/traits/chalk.rs
@@ -191,11 +191,11 @@ impl ToChalk for Impl {
     type Chalk = chalk_ir::ImplId;
 
     fn to_chalk(self, db: &impl HirDatabase) -> chalk_ir::ImplId {
-        db.intern_impl(self).into()
+        db.intern_chalk_impl(self).into()
     }
 
     fn from_chalk(db: &impl HirDatabase, impl_id: chalk_ir::ImplId) -> Impl {
-        db.lookup_intern_impl(impl_id.into())
+        db.lookup_intern_chalk_impl(impl_id.into())
     }
 }
 
@@ -630,7 +630,7 @@ fn impl_block_datum(
         .target_trait_ref(db)
         .expect("FIXME handle unresolved impl block trait ref")
         .subst(&bound_vars);
-    let impl_type = if impl_block.module().krate() == krate {
+    let impl_type = if impl_block.krate(db) == krate {
         chalk_rust_ir::ImplType::Local
     } else {
         chalk_rust_ir::ImplType::External