79 files changed, 1468 insertions, 860 deletions
diff --git a/Cargo.lock b/Cargo.lock
index 51a07abe3..b1fef2e80 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -107,9 +107,9 @@ checksum = "cf1de2fe8c75bc145a2f577add951f8134889b4795d47466a54a5c846d691693"
 [[package]]
 name = "byteorder"
-version = "1.4.2"
+version = "1.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ae44d1a3d5a19df61dd0c8beb138458ac2a53a7ac09eba97d55592540004306b"
+checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"
 [[package]]
 name = "camino"
@@ -524,7 +524,9 @@ name = "hir_expand"
 version = "0.0.0"
 dependencies = [
 "base_db",
+ "cfg",
 "either",
+ "expect-test",
 "la-arena",
 "log",
 "mbe",
@@ -897,6 +899,16 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0ee1c47aaa256ecabcaea351eae4a9b01ef39ed810004e298d2511ed284b1525"
 [[package]]
+name = "memmap"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6585fd95e7bb50d6cc31e20d4cf9afb4e2ba16c5846fc76793f11218da9c475b"
+dependencies = [
+ "libc",
+ "winapi",
+]
+[[package]]
 name = "memmap2"
 version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -1159,8 +1171,11 @@ dependencies = [
 "crossbeam-channel",
 "jod-thread",
 "log",
+ "memmap",
+ "object",
 "serde",
 "serde_json",
+ "snap",
 "stdx",
 "tt",
 ]
@@ -1375,9 +1390,9 @@ dependencies = [
 [[package]]
 name = "rustc-ap-rustc_lexer"
-version = "709.0.0"
+version = "710.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f69f83314702aaccf29c7401cc63bb0d9fa7869a185a23b8379f08c91514b3f3"
+checksum = "b0bba1ca6787b6d4af505b7a940eae9ecb084dd03e07f03bf3ddbf78e738b617"
 dependencies = [
 "unicode-xid",
 ]
@@ -1546,6 +1561,12 @@ dependencies = [
 ]
 [[package]]
+name = "snap"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc725476a1398f0480d56cd0ad381f6f32acf2642704456f8f59a35df464b59a"
+[[package]]
 name = "socket2"
 version = "0.3.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -1566,9 +1587,9 @@ dependencies = [
 [[package]]
 name = "syn"
-version = "1.0.62"
+version = "1.0.63"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "123a78a3596b24fee53a6464ce52d8ecbf62241e6294c7e7fe12086cd161f512"
+checksum = "8fd9bc7ccc2688b3344c2f48b9b546648b25ce0b20fc717ee7fa7981a8ca9717"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -1761,9 +1782,9 @@ dependencies = [
 [[package]]
 name = "tracing-tree"
-version = "0.1.8"
+version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1a60657cfbf397c603257a8230b3f427e6a2a4e5911a59331b9bb4dffff5b608"
+checksum = "1712b40907f8d9bc2bc66763ab61dec914b7123d7149e59feb0d4e2a95fc4967"
 dependencies = [
 "ansi_term",
 "atty",
diff --git a/crates/hir/src/lib.rs b/crates/hir/src/lib.rs
index d5a3d9034..58adc8fd3 100644
--- a/crates/hir/src/lib.rs
+++ b/crates/hir/src/lib.rs
@@ -305,7 +305,6 @@ impl ModuleDef {
            ModuleDef::Module(it) => it.name(db),
            ModuleDef::Const(it) => it.name(db),
            ModuleDef::Static(it) => it.name(db),
            ModuleDef::BuiltinType(it) => Some(it.name()),
        }
    }
@@ -535,7 +534,7 @@ pub struct Struct {
 impl Struct {
    pub fn module(self, db: &dyn HirDatabase) -> Module {
-        Module { id: self.id.lookup(db.upcast()).container.module(db.upcast()) }
+        Module { id: self.id.lookup(db.upcast()).container }
    }
    pub fn krate(self, db: &dyn HirDatabase) -> Option<Crate> {
@@ -556,11 +555,7 @@ impl Struct {
    }
    pub fn ty(self, db: &dyn HirDatabase) -> Type {
-        Type::from_def(
+        Type::from_def(db, self.id.lookup(db.upcast()).container.krate(), self.id)
-            db,
-            self.id.lookup(db.upcast()).container.module(db.upcast()).krate(),
-            self.id,
-        )
    }
    pub fn repr(self, db: &dyn HirDatabase) -> Option<ReprKind> {
@@ -587,15 +582,11 @@ impl Union {
    }
    pub fn module(self, db: &dyn HirDatabase) -> Module {
-        Module { id: self.id.lookup(db.upcast()).container.module(db.upcast()) }
+        Module { id: self.id.lookup(db.upcast()).container }
    }
    pub fn ty(self, db: &dyn HirDatabase) -> Type {
-        Type::from_def(
+        Type::from_def(db, self.id.lookup(db.upcast()).container.krate(), self.id)
-            db,
-            self.id.lookup(db.upcast()).container.module(db.upcast()).krate(),
-            self.id,
-        )
    }
    pub fn fields(self, db: &dyn HirDatabase) -> Vec<Field> {
@@ -619,7 +610,7 @@ pub struct Enum {
 impl Enum {
    pub fn module(self, db: &dyn HirDatabase) -> Module {
-        Module { id: self.id.lookup(db.upcast()).container.module(db.upcast()) }
+        Module { id: self.id.lookup(db.upcast()).container }
    }
    pub fn krate(self, db: &dyn HirDatabase) -> Option<Crate> {
@@ -635,11 +626,7 @@ impl Enum {
    }
    pub fn ty(self, db: &dyn HirDatabase) -> Type {
-        Type::from_def(
+        Type::from_def(db, self.id.lookup(db.upcast()).container.krate(), self.id)
-            db,
-            self.id.lookup(db.upcast()).container.module(db.upcast()).krate(),
-            self.id,
-        )
    }
 }
@@ -1001,7 +988,7 @@ pub struct Trait {
 impl Trait {
    pub fn module(self, db: &dyn HirDatabase) -> Module {
-        Module { id: self.id.lookup(db.upcast()).container.module(db.upcast()) }
+        Module { id: self.id.lookup(db.upcast()).container }
    }
    pub fn name(self, db: &dyn HirDatabase) -> Name {
@@ -1157,7 +1144,7 @@ where
 {
    match id.lookup(db.upcast()).container {
        AssocContainerId::TraitId(_) | AssocContainerId::ImplId(_) => Some(ctor(DEF::from(id))),
-        AssocContainerId::ContainerId(_) => None,
+        AssocContainerId::ModuleId(_) => None,
    }
 }
@@ -1185,7 +1172,7 @@ impl AssocItem {
        match container {
            AssocContainerId::TraitId(id) => AssocItemContainer::Trait(id.into()),
            AssocContainerId::ImplId(id) => AssocItemContainer::Impl(id.into()),
-            AssocContainerId::ContainerId(_) => panic!("invalid AssocItem"),
+            AssocContainerId::ModuleId(_) => panic!("invalid AssocItem"),
        }
    }
@@ -1296,13 +1283,7 @@ impl Local {
    pub fn is_mut(self, db: &dyn HirDatabase) -> bool {
        let body = db.body(self.parent.into());
-        match &body[self.pat_id] {
+        matches!(&body[self.pat_id], Pat::Bind { mode: BindingAnnotation::Mutable, .. })
-            Pat::Bind { mode, .. } => match mode {
-                BindingAnnotation::Mutable | BindingAnnotation::RefMut => true,
-                _ => false,
-            },
-            _ => false,
-        }
    }
    pub fn parent(self, _db: &dyn HirDatabase) -> DefWithBody {
@@ -1516,7 +1497,7 @@ impl Impl {
    pub fn target_ty(self, db: &dyn HirDatabase) -> Type {
        let impl_data = db.impl_data(self.id);
        let resolver = self.id.resolver(db.upcast());
-        let krate = self.id.lookup(db.upcast()).container.module(db.upcast()).krate();
+        let krate = self.id.lookup(db.upcast()).container.krate();
        let ctx = hir_ty::TyLoweringContext::new(db, &resolver);
        let ty = Ty::from_hir(&ctx, &impl_data.target_type);
        Type::new_with_resolver_inner(db, krate, &resolver, ty)
@@ -1531,7 +1512,7 @@ impl Impl {
    }
    pub fn module(self, db: &dyn HirDatabase) -> Module {
-        self.id.lookup(db.upcast()).container.module(db.upcast()).into()
+        self.id.lookup(db.upcast()).container.into()
    }
    pub fn krate(self, db: &dyn HirDatabase) -> Crate {
@@ -1614,10 +1595,9 @@ impl Type {
    }
    pub fn remove_ref(&self) -> Option<Type> {
-        if let Ty::Ref(.., substs) = &self.ty.value {
+        match &self.ty.value {
-            Some(self.derived(substs[0].clone()))
+            Ty::Ref(.., substs) => Some(self.derived(substs[0].clone())),
-        } else {
+            _ => None,
-            None
        }
    }
diff --git a/crates/hir_def/Cargo.toml b/crates/hir_def/Cargo.toml
index 2f07b6d01..c2d99280f 100644
--- a/crates/hir_def/Cargo.toml
+++ b/crates/hir_def/Cargo.toml
@@ -28,10 +28,10 @@ base_db = { path = "../base_db", version = "0.0.0" }
 syntax = { path = "../syntax", version = "0.0.0" }
 profile = { path = "../profile", version = "0.0.0" }
 hir_expand = { path = "../hir_expand", version = "0.0.0" }
-test_utils = { path = "../test_utils", version = "0.0.0" }
 mbe = { path = "../mbe", version = "0.0.0" }
 cfg = { path = "../cfg", version = "0.0.0" }
 tt = { path = "../tt", version = "0.0.0" }
 [dev-dependencies]
+test_utils = { path = "../test_utils" }
 expect-test = "1.1"
diff --git a/crates/hir_def/src/adt.rs b/crates/hir_def/src/adt.rs
index ed36c3109..efbde17d8 100644
--- a/crates/hir_def/src/adt.rs
+++ b/crates/hir_def/src/adt.rs
@@ -21,8 +21,7 @@ use crate::{
    trace::Trace,
    type_ref::TypeRef,
    visibility::RawVisibility,
-    EnumId, HasModule, LocalEnumVariantId, LocalFieldId, Lookup, ModuleId, StructId, UnionId,
+    EnumId, LocalEnumVariantId, LocalFieldId, Lookup, ModuleId, StructId, UnionId, VariantId,
-    VariantId,
 };
 use cfg::CfgOptions;
@@ -92,10 +91,10 @@ fn parse_repr_tt(tt: &Subtree) -> Option<ReprKind> {
 impl StructData {
    pub(crate) fn struct_data_query(db: &dyn DefDatabase, id: StructId) -> Arc<StructData> {
        let loc = id.lookup(db);
-        let krate = loc.container.module(db).krate;
+        let krate = loc.container.krate;
        let item_tree = db.item_tree(loc.id.file_id);
        let repr = repr_from_value(db, krate, &item_tree, ModItem::from(loc.id.value).into());
-        let cfg_options = db.crate_graph()[loc.container.module(db).krate].cfg_options.clone();
+        let cfg_options = db.crate_graph()[loc.container.krate].cfg_options.clone();
        let strukt = &item_tree[loc.id.value];
        let variant_data = lower_fields(db, krate, &item_tree, &cfg_options, &strukt.fields, None);
@@ -107,10 +106,10 @@ impl StructData {
    }
    pub(crate) fn union_data_query(db: &dyn DefDatabase, id: UnionId) -> Arc<StructData> {
        let loc = id.lookup(db);
-        let krate = loc.container.module(db).krate;
+        let krate = loc.container.krate;
        let item_tree = db.item_tree(loc.id.file_id);
        let repr = repr_from_value(db, krate, &item_tree, ModItem::from(loc.id.value).into());
-        let cfg_options = db.crate_graph()[loc.container.module(db).krate].cfg_options.clone();
+        let cfg_options = db.crate_graph()[loc.container.krate].cfg_options.clone();
        let union = &item_tree[loc.id.value];
        let variant_data = lower_fields(db, krate, &item_tree, &cfg_options, &union.fields, None);
@@ -126,7 +125,7 @@ impl StructData {
 impl EnumData {
    pub(crate) fn enum_data_query(db: &dyn DefDatabase, e: EnumId) -> Arc<EnumData> {
        let loc = e.lookup(db);
-        let krate = loc.container.module(db).krate;
+        let krate = loc.container.krate;
        let item_tree = db.item_tree(loc.id.file_id);
        let cfg_options = db.crate_graph()[krate].cfg_options.clone();
@@ -168,7 +167,7 @@ impl HasChildSource<LocalEnumVariantId> for EnumId {
    ) -> InFile<ArenaMap<LocalEnumVariantId, Self::Value>> {
        let src = self.lookup(db).source(db);
        let mut trace = Trace::new_for_map();
-        lower_enum(db, &mut trace, &src, self.lookup(db).container.module(db));
+        lower_enum(db, &mut trace, &src, self.lookup(db).container);
        src.with_value(trace.into_map())
    }
 }
@@ -238,10 +237,10 @@ impl HasChildSource<LocalFieldId> for VariantId {
                // I don't really like the fact that we call into parent source
                // here, this might add to more queries then necessary.
                let src = it.parent.child_source(db);
-                (src.map(|map| map[it.local_id].kind()), it.parent.lookup(db).container.module(db))
+                (src.map(|map| map[it.local_id].kind()), it.parent.lookup(db).container)
            }
            VariantId::StructId(it) => {
-                (it.lookup(db).source(db).map(|it| it.kind()), it.lookup(db).container.module(db))
+                (it.lookup(db).source(db).map(|it| it.kind()), it.lookup(db).container)
            }
            VariantId::UnionId(it) => (
                it.lookup(db).source(db).map(|it| {
@@ -249,7 +248,7 @@ impl HasChildSource<LocalFieldId> for VariantId {
                        .map(ast::StructKind::Record)
                        .unwrap_or(ast::StructKind::Unit)
                }),
-                it.lookup(db).container.module(db),
+                it.lookup(db).container,
            ),
        };
        let mut expander = CfgExpander::new(db, src.file_id, module_id.krate);
diff --git a/crates/hir_def/src/attr.rs b/crates/hir_def/src/attr.rs
index b716d5f6e..97cdbbb9e 100644
--- a/crates/hir_def/src/attr.rs
+++ b/crates/hir_def/src/attr.rs
@@ -267,7 +267,7 @@ impl Attrs {
        db: &dyn DefDatabase,
        e: EnumId,
    ) -> Arc<ArenaMap<LocalEnumVariantId, Attrs>> {
-        let krate = e.lookup(db).container.module(db).krate;
+        let krate = e.lookup(db).container.krate;
        let src = e.child_source(db);
        let mut res = ArenaMap::default();
diff --git a/crates/hir_def/src/body.rs b/crates/hir_def/src/body.rs
index b1a3fe1cb..19c4eb521 100644
--- a/crates/hir_def/src/body.rs
+++ b/crates/hir_def/src/body.rs
@@ -28,11 +28,10 @@ use crate::{
    db::DefDatabase,
    expr::{Expr, ExprId, Label, LabelId, Pat, PatId},
    item_scope::BuiltinShadowMode,
-    item_scope::ItemScope,
    nameres::DefMap,
    path::{ModPath, Path},
    src::HasSource,
-    AsMacroCall, DefWithBodyId, HasModule, LocalModuleId, Lookup, ModuleId,
+    AsMacroCall, BlockId, DefWithBodyId, HasModule, LocalModuleId, Lookup, ModuleId,
 };
 /// A subset of Expander that only deals with cfg attributes. We only need it to
@@ -226,7 +225,8 @@ pub struct Body {
    pub params: Vec<PatId>,
    /// The `ExprId` of the actual body expression.
    pub body_expr: ExprId,
-    pub item_scope: ItemScope,
+    /// Block expressions in this body that may contain inner items.
+    pub block_scopes: Vec<BlockId>,
    _c: Count<Self>,
 }
@@ -295,7 +295,7 @@ impl Body {
            }
        };
        let expander = Expander::new(db, file_id, module);
-        let (body, source_map) = Body::new(db, def, expander, params, body);
+        let (body, source_map) = Body::new(db, expander, params, body);
        (Arc::new(body), Arc::new(source_map))
    }
@@ -305,12 +305,11 @@ impl Body {
    fn new(
        db: &dyn DefDatabase,
-        def: DefWithBodyId,
        expander: Expander,
        params: Option<ast::ParamList>,
        body: Option<ast::Expr>,
    ) -> (Body, BodySourceMap) {
-        lower::lower(db, def, expander, params, body)
+        lower::lower(db, expander, params, body)
    }
 }
diff --git a/crates/hir_def/src/body/lower.rs b/crates/hir_def/src/body/lower.rs
index d4abe819d..8c8eb8007 100644
--- a/crates/hir_def/src/body/lower.rs
+++ b/crates/hir_def/src/body/lower.rs
@@ -1,17 +1,16 @@
 //! Transforms `ast::Expr` into an equivalent `hir_def::expr::Expr`
 //! representation.
-use std::{any::type_name, mem, sync::Arc};
+use std::mem;
 use either::Either;
 use hir_expand::{
    hygiene::Hygiene,
    name::{name, AsName, Name},
-    ExpandError, HirFileId, MacroDefId, MacroDefKind,
+    ExpandError, HirFileId,
 };
 use la_arena::Arena;
 use profile::Count;
-use rustc_hash::FxHashMap;
 use syntax::{
    ast::{
        self, ArgListOwner, ArrayExprKind, AstChildren, LiteralKind, LoopBodyOwner, NameOwner,
@@ -32,11 +31,9 @@ use crate::{
        Statement,
    },
    item_scope::BuiltinShadowMode,
-    item_tree::{ItemTree, ItemTreeId, ItemTreeNode},
    path::{GenericArgs, Path},
    type_ref::{Mutability, Rawness, TypeRef},
-    AdtId, BlockLoc, ConstLoc, ContainerId, DefWithBodyId, EnumLoc, FunctionLoc, Intern,
+    AdtId, BlockLoc, ModuleDefId,
-    ModuleDefId, StaticLoc, StructLoc, TraitLoc, TypeAliasLoc, UnionLoc,
 };
 use super::{diagnostics::BodyDiagnostic, ExprSource, PatSource};
@@ -60,15 +57,12 @@ impl LowerCtx {
 pub(super) fn lower(
    db: &dyn DefDatabase,
-    def: DefWithBodyId,
    expander: Expander,
    params: Option<ast::ParamList>,
    body: Option<ast::Expr>,
 ) -> (Body, BodySourceMap) {
-    let item_tree = db.item_tree(expander.current_file_id);
    ExprCollector {
        db,
-        def,
        source_map: BodySourceMap::default(),
        body: Body {
            exprs: Arena::default(),
@@ -76,14 +70,9 @@ pub(super) fn lower(
            labels: Arena::default(),
            params: Vec::new(),
            body_expr: dummy_expr_id(),
-            item_scope: Default::default(),
+            block_scopes: Vec::new(),
            _c: Count::new(),
        },
-        item_trees: {
-            let mut map = FxHashMap::default();
-            map.insert(expander.current_file_id, item_tree);
-            map
-        },
        expander,
    }
    .collect(params, body)
@@ -91,12 +80,9 @@ pub(super) fn lower(
 struct ExprCollector<'a> {
    db: &'a dyn DefDatabase,
-    def: DefWithBodyId,
    expander: Expander,
    body: Body,
    source_map: BodySourceMap,
-    item_trees: FxHashMap<HirFileId, Arc<ItemTree>>,
 }
 impl ExprCollector<'_> {
@@ -593,9 +579,6 @@ impl ExprCollector<'_> {
                } else {
                    self.source_map.expansions.insert(macro_call, self.expander.current_file_id);
-                    let item_tree = self.db.item_tree(self.expander.current_file_id);
-                    self.item_trees.insert(self.expander.current_file_id, item_tree);
                    let id = collector(self, Some(expansion));
                    self.expander.exit(self.db, mark);
                    id
@@ -605,32 +588,6 @@ impl ExprCollector<'_> {
        }
    }
-    fn find_inner_item<N: ItemTreeNode>(&self, ast: &N::Source) -> Option<ItemTreeId<N>> {
-        let id = self.expander.ast_id(ast);
-        let tree = &self.item_trees[&id.file_id];
-        // FIXME: This probably breaks with `use` items, since they produce multiple item tree nodes
-        // Root file (non-macro).
-        let item_tree_id = tree
-            .all_inner_items()
-            .chain(tree.top_level_items().iter().copied())
-            .filter_map(|mod_item| mod_item.downcast::<N>())
-            .find(|tree_id| tree[*tree_id].ast_id().upcast() == id.value.upcast())
-            .or_else(|| {
-                log::debug!(
-                    "couldn't find inner {} item for {:?} (AST: `{}` - {:?})",
-                    type_name::<N>(),
-                    id,
-                    ast.syntax(),
-                    ast.syntax(),
-                );
-                None
-            })?;
-        Some(ItemTreeId::new(id.file_id, item_tree_id))
-    }
    fn collect_expr_opt(&mut self, expr: Option<ast::Expr>) -> ExprId {
        if let Some(expr) = expr {
            self.collect_expr(expr)
@@ -662,7 +619,6 @@ impl ExprCollector<'_> {
                            match expansion {
                                Some(expansion) => {
                                    let statements: ast::MacroStmts = expansion;
-                                    this.collect_stmts_items(statements.statements());
                                    statements.statements().for_each(|stmt| {
                                        if let Some(mut r) = this.collect_stmt(stmt) {
@@ -700,6 +656,8 @@ impl ExprCollector<'_> {
        let block_loc =
            BlockLoc { ast_id, module: self.expander.def_map.module_id(self.expander.module) };
        let block_id = self.db.intern_block(block_loc);
+        self.body.block_scopes.push(block_id);
        let opt_def_map = self.db.block_def_map(block_id);
        let has_def_map = opt_def_map.is_some();
        let def_map = opt_def_map.unwrap_or_else(|| self.expander.def_map.clone());
@@ -707,7 +665,6 @@ impl ExprCollector<'_> {
        let prev_def_map = mem::replace(&mut self.expander.def_map, def_map);
        let prev_local_module = mem::replace(&mut self.expander.module, module);
-        self.collect_stmts_items(block.statements());
        let statements =
            block.statements().filter_map(|s| self.collect_stmt(s)).flatten().collect();
        let tail = block.tail_expr().map(|e| self.collect_expr(e));
@@ -722,108 +679,6 @@ impl ExprCollector<'_> {
        expr_id
    }
-    fn collect_stmts_items(&mut self, stmts: ast::AstChildren<ast::Stmt>) {
-        let container = ContainerId::DefWithBodyId(self.def);
-        let items = stmts
-            .filter_map(|stmt| match stmt {
-                ast::Stmt::Item(it) => Some(it),
-                ast::Stmt::LetStmt(_) | ast::Stmt::ExprStmt(_) => None,
-            })
-            .filter_map(|item| {
-                let (def, name): (ModuleDefId, Option<ast::Name>) = match item {
-                    ast::Item::Fn(def) => {
-                        let id = self.find_inner_item(&def)?;
-                        (
-                            FunctionLoc { container: container.into(), id }.intern(self.db).into(),
-                            def.name(),
-                        )
-                    }
-                    ast::Item::TypeAlias(def) => {
-                        let id = self.find_inner_item(&def)?;
-                        (
-                            TypeAliasLoc { container: container.into(), id }.intern(self.db).into(),
-                            def.name(),
-                        )
-                    }
-                    ast::Item::Const(def) => {
-                        let id = self.find_inner_item(&def)?;
-                        (
-                            ConstLoc { container: container.into(), id }.intern(self.db).into(),
-                            def.name(),
-                        )
-                    }
-                    ast::Item::Static(def) => {
-                        let id = self.find_inner_item(&def)?;
-                        (StaticLoc { container, id }.intern(self.db).into(), def.name())
-                    }
-                    ast::Item::Struct(def) => {
-                        let id = self.find_inner_item(&def)?;
-                        (StructLoc { container, id }.intern(self.db).into(), def.name())
-                    }
-                    ast::Item::Enum(def) => {
-                        let id = self.find_inner_item(&def)?;
-                        (EnumLoc { container, id }.intern(self.db).into(), def.name())
-                    }
-                    ast::Item::Union(def) => {
-                        let id = self.find_inner_item(&def)?;
-                        (UnionLoc { container, id }.intern(self.db).into(), def.name())
-                    }
-                    ast::Item::Trait(def) => {
-                        let id = self.find_inner_item(&def)?;
-                        (TraitLoc { container, id }.intern(self.db).into(), def.name())
-                    }
-                    ast::Item::ExternBlock(_) => return None, // FIXME: collect from extern blocks
-                    ast::Item::Impl(_)
-                    | ast::Item::Use(_)
-                    | ast::Item::ExternCrate(_)
-                    | ast::Item::Module(_)
-                    | ast::Item::MacroCall(_) => return None,
-                    ast::Item::MacroRules(def) => {
-                        return Some(Either::Right(ast::Macro::from(def)));
-                    }
-                    ast::Item::MacroDef(def) => {
-                        return Some(Either::Right(ast::Macro::from(def)));
-                    }
-                };
-                Some(Either::Left((def, name)))
-            })
-            .collect::<Vec<_>>();
-        for either in items {
-            match either {
-                Either::Left((def, name)) => {
-                    self.body.item_scope.define_def(def);
-                    if let Some(name) = name {
-                        let vis = crate::visibility::Visibility::Public; // FIXME determine correctly
-                        let has_constructor = match def {
-                            ModuleDefId::AdtId(AdtId::StructId(s)) => {
-                                self.db.struct_data(s).variant_data.kind() != StructKind::Record
-                            }
-                            _ => true,
-                        };
-                        self.body.item_scope.push_res(
-                            name.as_name(),
-                            crate::per_ns::PerNs::from_def(def, vis, has_constructor),
-                        );
-                    }
-                }
-                Either::Right(e) => {
-                    let mac = MacroDefId {
-                        krate: self.expander.def_map.krate(),
-                        ast_id: Some(self.expander.ast_id(&e)),
-                        kind: MacroDefKind::Declarative,
-                        local_inner: false,
-                    };
-                    if let Some(name) = e.name() {
-                        self.body.item_scope.define_legacy_macro(name.as_name(), mac);
-                    }
-                }
-            }
-        }
-    }
    fn collect_block_opt(&mut self, expr: Option<ast::BlockExpr>) -> ExprId {
        if let Some(block) = expr {
            self.collect_block(block)
diff --git a/crates/hir_def/src/child_by_source.rs b/crates/hir_def/src/child_by_source.rs
index 75c2d756b..2a331dcaf 100644
--- a/crates/hir_def/src/child_by_source.rs
+++ b/crates/hir_def/src/child_by_source.rs
@@ -17,13 +17,16 @@ use crate::{
 };
 pub trait ChildBySource {
-    fn child_by_source(&self, db: &dyn DefDatabase) -> DynMap;
-}
-impl ChildBySource for TraitId {
    fn child_by_source(&self, db: &dyn DefDatabase) -> DynMap {
        let mut res = DynMap::default();
+        self.child_by_source_to(db, &mut res);
+        res
+    }
+    fn child_by_source_to(&self, db: &dyn DefDatabase, map: &mut DynMap);
+}
+impl ChildBySource for TraitId {
+    fn child_by_source_to(&self, db: &dyn DefDatabase, res: &mut DynMap) {
        let data = db.trait_data(*self);
        for (_name, item) in data.items.iter() {
            match *item {
@@ -41,15 +44,11 @@ impl ChildBySource for TraitId {
                }
            }
        }
-        res
    }
 }
 impl ChildBySource for ImplId {
-    fn child_by_source(&self, db: &dyn DefDatabase) -> DynMap {
+    fn child_by_source_to(&self, db: &dyn DefDatabase, res: &mut DynMap) {
-        let mut res = DynMap::default();
        let data = db.impl_data(*self);
        for &item in data.items.iter() {
            match item {
@@ -67,25 +66,21 @@ impl ChildBySource for ImplId {
                }
            }
        }
-        res
    }
 }
 impl ChildBySource for ModuleId {
-    fn child_by_source(&self, db: &dyn DefDatabase) -> DynMap {
+    fn child_by_source_to(&self, db: &dyn DefDatabase, res: &mut DynMap) {
        let def_map = self.def_map(db);
        let module_data = &def_map[self.local_id];
-        module_data.scope.child_by_source(db)
+        module_data.scope.child_by_source_to(db, res);
    }
 }
 impl ChildBySource for ItemScope {
-    fn child_by_source(&self, db: &dyn DefDatabase) -> DynMap {
+    fn child_by_source_to(&self, db: &dyn DefDatabase, res: &mut DynMap) {
-        let mut res = DynMap::default();
+        self.declarations().for_each(|item| add_module_def(db, res, item));
-        self.declarations().for_each(|item| add_module_def(db, &mut res, item));
+        self.impls().for_each(|imp| add_impl(db, res, imp));
-        self.impls().for_each(|imp| add_impl(db, &mut res, imp));
-        return res;
        fn add_module_def(db: &dyn DefDatabase, map: &mut DynMap, item: ModuleDefId) {
            match item {
@@ -134,9 +129,7 @@ impl ChildBySource for ItemScope {
 }
 impl ChildBySource for VariantId {
-    fn child_by_source(&self, db: &dyn DefDatabase) -> DynMap {
+    fn child_by_source_to(&self, db: &dyn DefDatabase, res: &mut DynMap) {
-        let mut res = DynMap::default();
        let arena_map = self.child_source(db);
        let arena_map = arena_map.as_ref();
        for (local_id, source) in arena_map.value.iter() {
@@ -150,28 +143,27 @@ impl ChildBySource for VariantId {
                }
            }
        }
-        res
    }
 }
 impl ChildBySource for EnumId {
-    fn child_by_source(&self, db: &dyn DefDatabase) -> DynMap {
+    fn child_by_source_to(&self, db: &dyn DefDatabase, res: &mut DynMap) {
-        let mut res = DynMap::default();
        let arena_map = self.child_source(db);
        let arena_map = arena_map.as_ref();
        for (local_id, source) in arena_map.value.iter() {
            let id = EnumVariantId { parent: *self, local_id };
            res[keys::VARIANT].insert(arena_map.with_value(source.clone()), id)
        }
-        res
    }
 }
 impl ChildBySource for DefWithBodyId {
-    fn child_by_source(&self, db: &dyn DefDatabase) -> DynMap {
+    fn child_by_source_to(&self, db: &dyn DefDatabase, res: &mut DynMap) {
        let body = db.body(*self);
-        body.item_scope.child_by_source(db)
+        for def_map in body.block_scopes.iter().filter_map(|block| db.block_def_map(*block)) {
+            // All block expressions are merged into the same map, because they logically all add
+            // inner items to the containing `DefWithBodyId`.
+            def_map[def_map.root()].scope.child_by_source_to(db, res);
+        }
    }
 }
diff --git a/crates/hir_def/src/data.rs b/crates/hir_def/src/data.rs
index d3380e0f4..aea53d527 100644
--- a/crates/hir_def/src/data.rs
+++ b/crates/hir_def/src/data.rs
@@ -97,7 +97,7 @@ impl TraitData {
        let tr_def = &item_tree[tr_loc.id.value];
        let name = tr_def.name.clone();
        let auto = tr_def.auto;
-        let module_id = tr_loc.container.module(db);
+        let module_id = tr_loc.container;
        let container = AssocContainerId::TraitId(tr);
        let mut expander = Expander::new(db, tr_loc.id.file_id, module_id);
@@ -147,7 +147,7 @@ impl ImplData {
        let target_trait = impl_def.target_trait.map(|id| item_tree[id].clone());
        let target_type = item_tree[impl_def.target_type].clone();
        let is_negative = impl_def.is_negative;
-        let module_id = impl_loc.container.module(db);
+        let module_id = impl_loc.container;
        let container = AssocContainerId::ImplId(id);
        let mut expander = Expander::new(db, impl_loc.id.file_id, module_id);
diff --git a/crates/hir_def/src/generics.rs b/crates/hir_def/src/generics.rs
index 3ace3be1f..a056ab797 100644
--- a/crates/hir_def/src/generics.rs
+++ b/crates/hir_def/src/generics.rs
@@ -421,8 +421,7 @@ impl HasChildSource<LocalConstParamId> for GenericDefId {
 }
 impl ChildBySource for GenericDefId {
-    fn child_by_source(&self, db: &dyn DefDatabase) -> DynMap {
+    fn child_by_source_to(&self, db: &dyn DefDatabase, res: &mut DynMap) {
-        let mut res = DynMap::default();
        let (_, sm) = GenericParams::new(db, *self);
        let sm = sm.as_ref();
@@ -440,6 +439,5 @@ impl ChildBySource for GenericDefId {
            let id = ConstParamId { parent: *self, local_id };
            res[keys::CONST_PARAM].insert(sm.with_value(src.clone()), id);
        }
-        res
    }
 }
diff --git a/crates/hir_def/src/item_scope.rs b/crates/hir_def/src/item_scope.rs
index 919933813..aafd73b60 100644
--- a/crates/hir_def/src/item_scope.rs
+++ b/crates/hir_def/src/item_scope.rs
@@ -168,37 +168,6 @@ impl ItemScope {
        self.unnamed_trait_imports.insert(tr, vis);
    }
-    pub(crate) fn push_res(&mut self, name: Name, def: PerNs) -> bool {
-        let mut changed = false;
-        if let Some(types) = def.types {
-            self.types.entry(name.clone()).or_insert_with(|| {
-                changed = true;
-                types
-            });
-        }
-        if let Some(values) = def.values {
-            self.values.entry(name.clone()).or_insert_with(|| {
-                changed = true;
-                values
-            });
-        }
-        if let Some(macros) = def.macros {
-            self.macros.entry(name.clone()).or_insert_with(|| {
-                changed = true;
-                macros
-            });
-        }
-        if def.is_none() {
-            if self.unresolved.insert(name) {
-                changed = true;
-            }
-        }
-        changed
-    }
    pub(crate) fn push_res_with_import(
        &mut self,
        glob_imports: &mut PerNsGlobImports,
diff --git a/crates/hir_def/src/lib.rs b/crates/hir_def/src/lib.rs
index 4498d94bb..6d11c5be4 100644
--- a/crates/hir_def/src/lib.rs
+++ b/crates/hir_def/src/lib.rs
@@ -108,7 +108,7 @@ pub type LocalModuleId = Idx<nameres::ModuleData>;
 #[derive(Debug)]
 pub struct ItemLoc<N: ItemTreeNode> {
-    pub container: ContainerId,
+    pub container: ModuleId,
    pub id: ItemTreeId<N>,
 }
@@ -279,18 +279,12 @@ pub struct ConstParamId {
 pub type LocalConstParamId = Idx<generics::ConstParamData>;
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub enum ContainerId {
-    ModuleId(ModuleId),
-    DefWithBodyId(DefWithBodyId),
-}
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum AssocContainerId {
-    ContainerId(ContainerId),
+    ModuleId(ModuleId),
    ImplId(ImplId),
    TraitId(TraitId),
 }
-impl_from!(ContainerId for AssocContainerId);
+impl_from!(ModuleId for AssocContainerId);
 /// A Data Type
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
@@ -447,21 +441,12 @@ pub trait HasModule {
    fn module(&self, db: &dyn db::DefDatabase) -> ModuleId;
 }
-impl HasModule for ContainerId {
-    fn module(&self, db: &dyn db::DefDatabase) -> ModuleId {
-        match *self {
-            ContainerId::ModuleId(it) => it,
-            ContainerId::DefWithBodyId(it) => it.module(db),
-        }
-    }
-}
 impl HasModule for AssocContainerId {
    fn module(&self, db: &dyn db::DefDatabase) -> ModuleId {
        match *self {
-            AssocContainerId::ContainerId(it) => it.module(db),
+            AssocContainerId::ModuleId(it) => it,
-            AssocContainerId::ImplId(it) => it.lookup(db).container.module(db),
+            AssocContainerId::ImplId(it) => it.lookup(db).container,
-            AssocContainerId::TraitId(it) => it.lookup(db).container.module(db),
+            AssocContainerId::TraitId(it) => it.lookup(db).container,
        }
    }
 }
@@ -479,16 +464,15 @@ impl HasModule for AdtId {
            AdtId::UnionId(it) => it.lookup(db).container,
            AdtId::EnumId(it) => it.lookup(db).container,
        }
-        .module(db)
    }
 }
 impl HasModule for VariantId {
    fn module(&self, db: &dyn db::DefDatabase) -> ModuleId {
        match self {
-            VariantId::EnumVariantId(it) => it.parent.lookup(db).container.module(db),
+            VariantId::EnumVariantId(it) => it.parent.lookup(db).container,
-            VariantId::StructId(it) => it.lookup(db).container.module(db),
+            VariantId::StructId(it) => it.lookup(db).container,
-            VariantId::UnionId(it) => it.lookup(db).container.module(db),
+            VariantId::UnionId(it) => it.lookup(db).container,
        }
    }
 }
@@ -518,18 +502,18 @@ impl HasModule for GenericDefId {
        match self {
            GenericDefId::FunctionId(it) => it.lookup(db).module(db),
            GenericDefId::AdtId(it) => it.module(db),
-            GenericDefId::TraitId(it) => it.lookup(db).container.module(db),
+            GenericDefId::TraitId(it) => it.lookup(db).container,
            GenericDefId::TypeAliasId(it) => it.lookup(db).module(db),
-            GenericDefId::ImplId(it) => it.lookup(db).container.module(db),
+            GenericDefId::ImplId(it) => it.lookup(db).container,
-            GenericDefId::EnumVariantId(it) => it.parent.lookup(db).container.module(db),
+            GenericDefId::EnumVariantId(it) => it.parent.lookup(db).container,
            GenericDefId::ConstId(it) => it.lookup(db).module(db),
        }
    }
 }
 impl HasModule for StaticLoc {
-    fn module(&self, db: &dyn db::DefDatabase) -> ModuleId {
+    fn module(&self, _db: &dyn db::DefDatabase) -> ModuleId {
-        self.container.module(db)
+        self.container
    }
 }
@@ -542,10 +526,10 @@ impl ModuleDefId {
            ModuleDefId::ModuleId(id) => *id,
            ModuleDefId::FunctionId(id) => id.lookup(db).module(db),
            ModuleDefId::AdtId(id) => id.module(db),
-            ModuleDefId::EnumVariantId(id) => id.parent.lookup(db).container.module(db),
+            ModuleDefId::EnumVariantId(id) => id.parent.lookup(db).container,
            ModuleDefId::ConstId(id) => id.lookup(db).container.module(db),
-            ModuleDefId::StaticId(id) => id.lookup(db).container.module(db),
+            ModuleDefId::StaticId(id) => id.lookup(db).container,
-            ModuleDefId::TraitId(id) => id.lookup(db).container.module(db),
+            ModuleDefId::TraitId(id) => id.lookup(db).container,
            ModuleDefId::TypeAliasId(id) => id.lookup(db).module(db),
            ModuleDefId::BuiltinType(_) => return None,
        })
@@ -559,12 +543,12 @@ impl AttrDefId {
            AttrDefId::FieldId(it) => it.parent.module(db).krate,
            AttrDefId::AdtId(it) => it.module(db).krate,
            AttrDefId::FunctionId(it) => it.lookup(db).module(db).krate,
-            AttrDefId::EnumVariantId(it) => it.parent.lookup(db).container.module(db).krate,
+            AttrDefId::EnumVariantId(it) => it.parent.lookup(db).container.krate,
            AttrDefId::StaticId(it) => it.lookup(db).module(db).krate,
            AttrDefId::ConstId(it) => it.lookup(db).module(db).krate,
-            AttrDefId::TraitId(it) => it.lookup(db).container.module(db).krate,
+            AttrDefId::TraitId(it) => it.lookup(db).container.krate,
            AttrDefId::TypeAliasId(it) => it.lookup(db).module(db).krate,
-            AttrDefId::ImplId(it) => it.lookup(db).container.module(db).krate,
+            AttrDefId::ImplId(it) => it.lookup(db).container.krate,
            AttrDefId::GenericParamId(it) => {
                match it {
                    GenericParamId::TypeParamId(it) => it.parent,
diff --git a/crates/hir_def/src/nameres/collector.rs b/crates/hir_def/src/nameres/collector.rs
index 3bb69d935..9ed48c506 100644
--- a/crates/hir_def/src/nameres/collector.rs
+++ b/crates/hir_def/src/nameres/collector.rs
@@ -37,9 +37,9 @@ use crate::{
    path::{ImportAlias, ModPath, PathKind},
    per_ns::PerNs,
    visibility::{RawVisibility, Visibility},
-    AdtId, AstId, AstIdWithPath, ConstLoc, ContainerId, EnumLoc, EnumVariantId, FunctionLoc,
+    AdtId, AstId, AstIdWithPath, ConstLoc, EnumLoc, EnumVariantId, FunctionLoc, ImplLoc, Intern,
-    ImplLoc, Intern, LocalModuleId, ModuleDefId, StaticLoc, StructLoc, TraitLoc, TypeAliasLoc,
+    LocalModuleId, ModuleDefId, StaticLoc, StructLoc, TraitLoc, TypeAliasLoc, UnionLoc,
-    UnionLoc, UnresolvedMacro,
+    UnresolvedMacro,
 };
 const GLOB_RECURSION_LIMIT: usize = 100;
@@ -1042,7 +1042,6 @@ impl ModCollector<'_, '_> {
                }
            }
            let module = self.def_collector.def_map.module_id(self.module_id);
-            let container = ContainerId::ModuleId(module);
            let mut def = None;
            match item {
@@ -1109,9 +1108,9 @@ impl ModCollector<'_, '_> {
                }
                ModItem::Impl(imp) => {
                    let module = self.def_collector.def_map.module_id(self.module_id);
-                    let container = ContainerId::ModuleId(module);
+                    let impl_id =
-                    let impl_id = ImplLoc { container, id: ItemTreeId::new(self.file_id, imp) }
+                        ImplLoc { container: module, id: ItemTreeId::new(self.file_id, imp) }
-                        .intern(self.def_collector.db);
+                            .intern(self.def_collector.db);
                    self.def_collector.def_map.modules[self.module_id].scope.define_impl(impl_id)
                }
                ModItem::Function(id) => {
@@ -1121,7 +1120,7 @@ impl ModCollector<'_, '_> {
                    def = Some(DefData {
                        id: FunctionLoc {
-                            container: container.into(),
+                            container: module.into(),
                            id: ItemTreeId::new(self.file_id, id),
                        }
                        .intern(self.def_collector.db)
@@ -1140,7 +1139,7 @@ impl ModCollector<'_, '_> {
                    self.collect_derives(&attrs, it.ast_id.upcast());
                    def = Some(DefData {
-                        id: StructLoc { container, id: ItemTreeId::new(self.file_id, id) }
+                        id: StructLoc { container: module, id: ItemTreeId::new(self.file_id, id) }
                            .intern(self.def_collector.db)
                            .into(),
                        name: &it.name,
@@ -1157,7 +1156,7 @@ impl ModCollector<'_, '_> {
                    self.collect_derives(&attrs, it.ast_id.upcast());
                    def = Some(DefData {
-                        id: UnionLoc { container, id: ItemTreeId::new(self.file_id, id) }
+                        id: UnionLoc { container: module, id: ItemTreeId::new(self.file_id, id) }
                            .intern(self.def_collector.db)
                            .into(),
                        name: &it.name,
@@ -1174,7 +1173,7 @@ impl ModCollector<'_, '_> {
                    self.collect_derives(&attrs, it.ast_id.upcast());
                    def = Some(DefData {
-                        id: EnumLoc { container, id: ItemTreeId::new(self.file_id, id) }
+                        id: EnumLoc { container: module, id: ItemTreeId::new(self.file_id, id) }
                            .intern(self.def_collector.db)
                            .into(),
                        name: &it.name,
@@ -1188,7 +1187,7 @@ impl ModCollector<'_, '_> {
                    if let Some(name) = &it.name {
                        def = Some(DefData {
                            id: ConstLoc {
-                                container: container.into(),
+                                container: module.into(),
                                id: ItemTreeId::new(self.file_id, id),
                            }
                            .intern(self.def_collector.db)
@@ -1203,7 +1202,7 @@ impl ModCollector<'_, '_> {
                    let it = &self.item_tree[id];
                    def = Some(DefData {
-                        id: StaticLoc { container, id: ItemTreeId::new(self.file_id, id) }
+                        id: StaticLoc { container: module, id: ItemTreeId::new(self.file_id, id) }
                            .intern(self.def_collector.db)
                            .into(),
                        name: &it.name,
@@ -1215,7 +1214,7 @@ impl ModCollector<'_, '_> {
                    let it = &self.item_tree[id];
                    def = Some(DefData {
-                        id: TraitLoc { container, id: ItemTreeId::new(self.file_id, id) }
+                        id: TraitLoc { container: module, id: ItemTreeId::new(self.file_id, id) }
                            .intern(self.def_collector.db)
                            .into(),
                        name: &it.name,
@@ -1228,7 +1227,7 @@ impl ModCollector<'_, '_> {
                    def = Some(DefData {
                        id: TypeAliasLoc {
-                            container: container.into(),
+                            container: module.into(),
                            id: ItemTreeId::new(self.file_id, id),
                        }
                        .intern(self.def_collector.db)
diff --git a/crates/hir_def/src/nameres/path_resolution.rs b/crates/hir_def/src/nameres/path_resolution.rs
index 8258dcffb..db459b1ed 100644
--- a/crates/hir_def/src/nameres/path_resolution.rs
+++ b/crates/hir_def/src/nameres/path_resolution.rs
@@ -156,7 +156,7 @@ impl DefMap {
        }
    }
-    pub(super) fn resolve_path_fp_with_macro_single(
+    fn resolve_path_fp_with_macro_single(
        &self,
        db: &dyn DefDatabase,
        mode: ResolveMode,
@@ -384,10 +384,16 @@ impl DefMap {
                }
            }
        };
-        let from_extern_prelude = self
+        // Give precedence to names in outer `DefMap`s over the extern prelude; only check prelude
-            .extern_prelude
+        // from the crate DefMap.
-            .get(name)
+        let from_extern_prelude = match self.block {
-            .map_or(PerNs::none(), |&it| PerNs::types(it, Visibility::Public));
+            Some(_) => PerNs::none(),
+            None => self
+                .extern_prelude
+                .get(name)
+                .map_or(PerNs::none(), |&it| PerNs::types(it, Visibility::Public)),
+        };
        let from_prelude = self.resolve_in_prelude(db, name);
        from_legacy_macro.or(from_scope_or_builtin).or(from_extern_prelude).or(from_prelude)
diff --git a/crates/hir_def/src/resolver.rs b/crates/hir_def/src/resolver.rs
index 77ff21739..42736171e 100644
--- a/crates/hir_def/src/resolver.rs
+++ b/crates/hir_def/src/resolver.rs
@@ -19,10 +19,10 @@ use crate::{
    path::{ModPath, PathKind},
    per_ns::PerNs,
    visibility::{RawVisibility, Visibility},
-    AdtId, AssocContainerId, ConstId, ConstParamId, ContainerId, DefWithBodyId, EnumId,
+    AdtId, AssocContainerId, ConstId, ConstParamId, DefWithBodyId, EnumId, EnumVariantId,
-    EnumVariantId, FunctionId, GenericDefId, GenericParamId, HasModule, ImplId, LifetimeParamId,
+    FunctionId, GenericDefId, GenericParamId, HasModule, ImplId, LifetimeParamId, LocalModuleId,
-    LocalModuleId, Lookup, ModuleDefId, ModuleId, StaticId, StructId, TraitId, TypeAliasId,
+    Lookup, ModuleDefId, ModuleId, StaticId, StructId, TraitId, TypeAliasId, TypeParamId,
-    TypeParamId, VariantId,
+    VariantId,
 };
 #[derive(Debug, Clone, Default)]
@@ -342,6 +342,16 @@ impl Resolver {
                    traits.extend(prelude_def_map[prelude.local_id].scope.traits());
                }
                traits.extend(m.def_map[m.module_id].scope.traits());
+                // Add all traits that are in scope because of the containing DefMaps
+                m.def_map.with_ancestor_maps(db, m.module_id, &mut |def_map, module| {
+                    if let Some(prelude) = def_map.prelude() {
+                        let prelude_def_map = prelude.def_map(db);
+                        traits.extend(prelude_def_map[prelude.local_id].scope.traits());
+                    }
+                    traits.extend(def_map[module].scope.traits());
+                    None::<()>
+                });
            }
        }
        traits
@@ -678,19 +688,10 @@ impl HasResolver for DefWithBodyId {
    }
 }
-impl HasResolver for ContainerId {
-    fn resolver(self, db: &dyn DefDatabase) -> Resolver {
-        match self {
-            ContainerId::ModuleId(it) => it.resolver(db),
-            ContainerId::DefWithBodyId(it) => it.module(db).resolver(db),
-        }
-    }
-}
 impl HasResolver for AssocContainerId {
    fn resolver(self, db: &dyn DefDatabase) -> Resolver {
        match self {
-            AssocContainerId::ContainerId(it) => it.resolver(db),
+            AssocContainerId::ModuleId(it) => it.resolver(db),
            AssocContainerId::TraitId(it) => it.resolver(db),
            AssocContainerId::ImplId(it) => it.resolver(db),
        }
diff --git a/crates/hir_expand/Cargo.toml b/crates/hir_expand/Cargo.toml
index 5271110d2..f649ab925 100644
--- a/crates/hir_expand/Cargo.toml
+++ b/crates/hir_expand/Cargo.toml
@@ -16,9 +16,13 @@ rustc-hash = "1.0.0"
 la-arena = { version = "0.2.0", path = "../../lib/arena" }
 base_db = { path = "../base_db", version = "0.0.0" }
+cfg = { path = "../cfg", version = "0.0.0" }
 syntax = { path = "../syntax", version = "0.0.0" }
 parser = { path = "../parser", version = "0.0.0" }
 profile = { path = "../profile", version = "0.0.0" }
 tt = { path = "../tt", version = "0.0.0" }
 mbe = { path = "../mbe", version = "0.0.0" }
-test_utils = { path = "../test_utils", version = "0.0.0" }
+[dev-dependencies]
+test_utils = { path = "../test_utils" }
+expect-test = "1.1"
diff --git a/crates/hir_expand/src/builtin_derive.rs b/crates/hir_expand/src/builtin_derive.rs
index b7f1aae8f..dfdb9cf59 100644
--- a/crates/hir_expand/src/builtin_derive.rs
+++ b/crates/hir_expand/src/builtin_derive.rs
@@ -267,13 +267,14 @@ fn partial_ord_expand(
 #[cfg(test)]
 mod tests {
    use base_db::{fixture::WithFixture, CrateId, SourceDatabase};
+    use expect_test::{expect, Expect};
    use name::{known, Name};
    use crate::{test_db::TestDB, AstId, MacroCallId, MacroCallKind, MacroCallLoc};
    use super::*;
-    fn expand_builtin_derive(s: &str, name: Name) -> String {
+    fn expand_builtin_derive(ra_fixture: &str, name: Name) -> String {
        let expander = BuiltinDeriveExpander::find_by_name(&name).unwrap();
        let fixture = format!(
            r#"//- /main.rs crate:main deps:core
@@ -282,7 +283,7 @@ $0
 //- /lib.rs crate:core
 // empty
 "#,
-            s
+            ra_fixture
        );
        let (db, file_pos) = TestDB::with_position(&fixture);
@@ -314,66 +315,57 @@ $0
        parsed.text().to_string()
    }
+    fn check_derive(ra_fixture: &str, name: Name, expected: Expect) {
+        let expanded = expand_builtin_derive(ra_fixture, name);
+        expected.assert_eq(&expanded);
+    }
    #[test]
    fn test_copy_expand_simple() {
-        let expanded = expand_builtin_derive(
+        check_derive(
            r#"
-        #[derive(Copy)]
+            #[derive(Copy)]
-        struct Foo;
+            struct Foo;
-"#,
+            "#,
            known::Copy,
+            expect![["impl< >core::marker::CopyforFoo< >{}"]],
        );
-        assert_eq!(expanded, "impl< >core::marker::CopyforFoo< >{}");
    }
    #[test]
    fn test_copy_expand_with_type_params() {
-        let expanded = expand_builtin_derive(
+        check_derive(
            r#"
-        #[derive(Copy)]
+            #[derive(Copy)]
-        struct Foo<A, B>;
+            struct Foo<A, B>;
-"#,
+            "#,
            known::Copy,
-        );
+            expect![["impl<T0:core::marker::Copy,T1:core::marker::Copy>core::marker::CopyforFoo<T0,T1>{}"]],
-        assert_eq!(
-            expanded,
-            "impl<T0:core::marker::Copy,T1:core::marker::Copy>core::marker::CopyforFoo<T0,T1>{}"
        );
    }
    #[test]
    fn test_copy_expand_with_lifetimes() {
-        let expanded = expand_builtin_derive(
+        check_derive(
            r#"
-        #[derive(Copy)]
+            #[derive(Copy)]
-        struct Foo<A, B, 'a, 'b>;
+            struct Foo<A, B, 'a, 'b>;
-"#,
+            "#,
            known::Copy,
-        );
+            // We currently just ignore lifetimes
+            expect![["impl<T0:core::marker::Copy,T1:core::marker::Copy>core::marker::CopyforFoo<T0,T1>{}"]],
-        // We currently just ignore lifetimes
-        assert_eq!(
-            expanded,
-            "impl<T0:core::marker::Copy,T1:core::marker::Copy>core::marker::CopyforFoo<T0,T1>{}"
        );
    }
    #[test]
    fn test_clone_expand() {
-        let expanded = expand_builtin_derive(
+        check_derive(
            r#"
-        #[derive(Clone)]
+            #[derive(Clone)]
-        struct Foo<A, B>;
+            struct Foo<A, B>;
-"#,
+            "#,
            known::Clone,
-        );
+            expect![["impl<T0:core::clone::Clone,T1:core::clone::Clone>core::clone::CloneforFoo<T0,T1>{}"]],
-        assert_eq!(
-            expanded,
-            "impl<T0:core::clone::Clone,T1:core::clone::Clone>core::clone::CloneforFoo<T0,T1>{}"
        );
    }
 }
diff --git a/crates/hir_expand/src/builtin_macro.rs b/crates/hir_expand/src/builtin_macro.rs
index eb57ea7d6..2a79c892b 100644
--- a/crates/hir_expand/src/builtin_macro.rs
+++ b/crates/hir_expand/src/builtin_macro.rs
@@ -5,6 +5,7 @@ use crate::{
 };
 use base_db::{AnchoredPath, FileId};
+use cfg::CfgExpr;
 use either::Either;
 use mbe::{parse_exprs_with_sep, parse_to_token_tree, ExpandResult};
 use parser::FragmentKind;
@@ -97,6 +98,7 @@ register_builtin! {
    (format_args_nl, FormatArgsNl) => format_args_expand,
    (llvm_asm, LlvmAsm) => asm_expand,
    (asm, Asm) => asm_expand,
+    (cfg, Cfg) => cfg_expand,
    EAGER:
    (compile_error, CompileError) => compile_error_expand,
@@ -258,6 +260,18 @@ fn asm_expand(
    ExpandResult::ok(expanded)
 }
+fn cfg_expand(
+    db: &dyn AstDatabase,
+    id: LazyMacroId,
+    tt: &tt::Subtree,
+) -> ExpandResult<tt::Subtree> {
+    let loc = db.lookup_intern_macro(id);
+    let expr = CfgExpr::parse(tt);
+    let enabled = db.crate_graph()[loc.krate].cfg_options.check(&expr) != Some(false);
+    let expanded = if enabled { quote!(true) } else { quote!(false) };
+    ExpandResult::ok(expanded)
+}
 fn unquote_str(lit: &tt::Literal) -> Option<String> {
    let lit = ast::make::tokens::literal(&lit.to_string());
    let token = ast::String::cast(lit)?;
@@ -477,6 +491,7 @@ mod tests {
        MacroCallLoc,
    };
    use base_db::{fixture::WithFixture, SourceDatabase};
+    use expect_test::{expect, Expect};
    use std::sync::Arc;
    use syntax::ast::NameOwner;
@@ -560,87 +575,86 @@ mod tests {
        db.parse_or_expand(file_id).unwrap().to_string()
    }
+    fn check_expansion(ra_fixture: &str, expect: Expect) {
+        let expansion = expand_builtin_macro(ra_fixture);
+        expect.assert_eq(&expansion);
+    }
    #[test]
    fn test_column_expand() {
-        let expanded = expand_builtin_macro(
+        check_expansion(
            r#"
            #[rustc_builtin_macro]
            macro_rules! column {() => {}}
            column!()
            "#,
+            expect![["0"]],
        );
-        assert_eq!(expanded, "0");
    }
    #[test]
    fn test_line_expand() {
-        let expanded = expand_builtin_macro(
+        check_expansion(
            r#"
            #[rustc_builtin_macro]
            macro_rules! line {() => {}}
            line!()
            "#,
+            expect![["0"]],
        );
-        assert_eq!(expanded, "0");
    }
    #[test]
    fn test_stringify_expand() {
-        let expanded = expand_builtin_macro(
+        check_expansion(
            r#"
            #[rustc_builtin_macro]
            macro_rules! stringify {() => {}}
            stringify!(a b c)
            "#,
+            expect![["\"a b c\""]],
        );
-        assert_eq!(expanded, "\"a b c\"");
    }
    #[test]
    fn test_env_expand() {
-        let expanded = expand_builtin_macro(
+        check_expansion(
            r#"
            #[rustc_builtin_macro]
            macro_rules! env {() => {}}
            env!("TEST_ENV_VAR")
            "#,
+            expect![["\"__RA_UNIMPLEMENTED__\""]],
        );
-        assert_eq!(expanded, "\"__RA_UNIMPLEMENTED__\"");
    }
    #[test]
    fn test_option_env_expand() {
-        let expanded = expand_builtin_macro(
+        check_expansion(
            r#"
            #[rustc_builtin_macro]
            macro_rules! option_env {() => {}}
            option_env!("TEST_ENV_VAR")
            "#,
+            expect![["std::option::Option::None:: < &str>"]],
        );
-        assert_eq!(expanded, "std::option::Option::None:: < &str>");
    }
    #[test]
    fn test_file_expand() {
-        let expanded = expand_builtin_macro(
+        check_expansion(
            r#"
            #[rustc_builtin_macro]
            macro_rules! file {() => {}}
            file!()
            "#,
+            expect![[r#""""#]],
        );
-        assert_eq!(expanded, "\"\"");
    }
    #[test]
    fn test_assert_expand() {
-        let expanded = expand_builtin_macro(
+        check_expansion(
            r#"
            #[rustc_builtin_macro]
            macro_rules! assert {
@@ -649,14 +663,13 @@ mod tests {
            }
            assert!(true, "{} {:?}", arg1(a, b, c), arg2);
            "#,
+            expect![["{{(&(true), &(\"{} {:?}\"), &(arg1(a,b,c)), &(arg2),);}}"]],
        );
-        assert_eq!(expanded, "{{(&(true), &(\"{} {:?}\"), &(arg1(a,b,c)), &(arg2),);}}");
    }
    #[test]
    fn test_compile_error_expand() {
-        let expanded = expand_builtin_macro(
+        check_expansion(
            r#"
            #[rustc_builtin_macro]
            macro_rules! compile_error {
@@ -665,15 +678,14 @@ mod tests {
            }
            compile_error!("error!");
            "#,
+            // This expands to nothing (since it's in item position), but emits an error.
+            expect![[""]],
        );
-        // This expands to nothing (since it's in item position), but emits an error.
-        assert_eq!(expanded, "");
    }
    #[test]
    fn test_format_args_expand() {
-        let expanded = expand_builtin_macro(
+        check_expansion(
            r#"
            #[rustc_builtin_macro]
            macro_rules! format_args {
@@ -682,17 +694,15 @@ mod tests {
            }
            format_args!("{} {:?}", arg1(a, b, c), arg2);
            "#,
-        );
+            expect![[
+                r#"std::fmt::Arguments::new_v1(&[], &[std::fmt::ArgumentV1::new(&(arg1(a,b,c)),std::fmt::Display::fmt),std::fmt::ArgumentV1::new(&(arg2),std::fmt::Display::fmt),])"#
-        assert_eq!(
+            ]],
-            expanded,
-            r#"std::fmt::Arguments::new_v1(&[], &[std::fmt::ArgumentV1::new(&(arg1(a,b,c)),std::fmt::Display::fmt),std::fmt::ArgumentV1::new(&(arg2),std::fmt::Display::fmt),])"#
        );
    }
    #[test]
    fn test_format_args_expand_with_comma_exprs() {
-        let expanded = expand_builtin_macro(
+        check_expansion(
            r#"
            #[rustc_builtin_macro]
            macro_rules! format_args {
@@ -701,17 +711,15 @@ mod tests {
            }
            format_args!("{} {:?}", a::<A,B>(), b);
            "#,
-        );
+            expect![[
+                r#"std::fmt::Arguments::new_v1(&[], &[std::fmt::ArgumentV1::new(&(a::<A,B>()),std::fmt::Display::fmt),std::fmt::ArgumentV1::new(&(b),std::fmt::Display::fmt),])"#
-        assert_eq!(
+            ]],
-            expanded,
-            r#"std::fmt::Arguments::new_v1(&[], &[std::fmt::ArgumentV1::new(&(a::<A,B>()),std::fmt::Display::fmt),std::fmt::ArgumentV1::new(&(b),std::fmt::Display::fmt),])"#
        );
    }
    #[test]
    fn test_include_bytes_expand() {
-        let expanded = expand_builtin_macro(
+        check_expansion(
            r#"
            #[rustc_builtin_macro]
            macro_rules! include_bytes {
@@ -720,21 +728,19 @@ mod tests {
            }
            include_bytes("foo");
            "#,
+            expect![[r#"b"""#]],
        );
-        assert_eq!(expanded, r#"b"""#);
    }
    #[test]
    fn test_concat_expand() {
-        let expanded = expand_builtin_macro(
+        check_expansion(
            r##"
            #[rustc_builtin_macro]
            macro_rules! concat {}
            concat!("foo", "r", 0, r#"bar"#, false);
            "##,
+            expect![[r#""foor0barfalse""#]],
        );
-        assert_eq!(expanded, r#""foor0barfalse""#);
    }
 }
diff --git a/crates/hir_expand/src/name.rs b/crates/hir_expand/src/name.rs
index c94fb580a..e833e032c 100644
--- a/crates/hir_expand/src/name.rs
+++ b/crates/hir_expand/src/name.rs
@@ -154,6 +154,7 @@ pub mod known {
        macro_rules,
        derive,
        doc,
+        cfg,
        cfg_attr,
        // Components of known path (value or mod name)
        std,
diff --git a/crates/hir_expand/src/quote.rs b/crates/hir_expand/src/quote.rs
index 219bc2097..08bc5aa49 100644
--- a/crates/hir_expand/src/quote.rs
+++ b/crates/hir_expand/src/quote.rs
@@ -188,8 +188,9 @@ macro_rules! impl_to_to_tokentrees {
 impl_to_to_tokentrees! {
    u32 => self { tt::Literal{text: self.to_string().into(), id: tt::TokenId::unspecified()} };
-    usize => self { tt::Literal{text: self.to_string().into(), id: tt::TokenId::unspecified()}};
+    usize => self { tt::Literal{text: self.to_string().into(), id: tt::TokenId::unspecified()} };
-    i32 => self { tt::Literal{text: self.to_string().into(), id: tt::TokenId::unspecified()}};
+    i32 => self { tt::Literal{text: self.to_string().into(), id: tt::TokenId::unspecified()} };
+    bool => self { tt::Ident{text: self.to_string().into(), id: tt::TokenId::unspecified()} };
    tt::Leaf => self { self };
    tt::Literal => self { self };
    tt::Ident => self { self };
diff --git a/crates/hir_ty/Cargo.toml b/crates/hir_ty/Cargo.toml
index 6131ebee8..b9c93f56f 100644
--- a/crates/hir_ty/Cargo.toml
+++ b/crates/hir_ty/Cargo.toml
@@ -29,9 +29,9 @@ hir_expand = { path = "../hir_expand", version = "0.0.0" }
 base_db = { path = "../base_db", version = "0.0.0" }
 profile = { path = "../profile", version = "0.0.0" }
 syntax = { path = "../syntax", version = "0.0.0" }
-test_utils = { path = "../test_utils", version = "0.0.0" }
 [dev-dependencies]
+test_utils = { path = "../test_utils"  }
 expect-test = "1.1"
 tracing = "0.1"
 tracing-subscriber = { version = "0.2", default-features = false, features = ["env-filter", "registry"] }
diff --git a/crates/hir_ty/src/diagnostics.rs b/crates/hir_ty/src/diagnostics.rs
index 6bca7aa0d..86f937e1d 100644
--- a/crates/hir_ty/src/diagnostics.rs
+++ b/crates/hir_ty/src/diagnostics.rs
@@ -706,6 +706,35 @@ fn x(a: S) {
    }
    #[test]
+    fn import_extern_crate_clash_with_inner_item() {
+        // This is more of a resolver test, but doesn't really work with the hir_def testsuite.
+        check_diagnostics(
+            r#"
+//- /lib.rs crate:lib deps:jwt
+mod permissions;
+use permissions::jwt;
+fn f() {
+    fn inner() {}
+    jwt::Claims {}; // should resolve to the local one with 0 fields, and not get a diagnostic
+}
+//- /permissions.rs
+pub mod jwt  {
+    pub struct Claims {}
+}
+//- /jwt/lib.rs crate:jwt
+pub struct Claims {
+    field: u8,
+}
+        "#,
+        );
+    }
+    #[test]
    fn break_outside_of_loop() {
        check_diagnostics(
            r#"
diff --git a/crates/hir_ty/src/diagnostics/decl_check.rs b/crates/hir_ty/src/diagnostics/decl_check.rs
index e230f9765..3605ca581 100644
--- a/crates/hir_ty/src/diagnostics/decl_check.rs
+++ b/crates/hir_ty/src/diagnostics/decl_check.rs
@@ -99,9 +99,14 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
        let body = self.db.body(func.into());
        // Recursively validate inner scope items, such as static variables and constants.
-        for (item_id, _) in body.item_scope.values() {
+        let db = self.db;
-            let mut validator = DeclValidator::new(self.db, self.krate, self.sink);
+        for block_def_map in body.block_scopes.iter().filter_map(|block| db.block_def_map(*block)) {
-            validator.validate_item(item_id);
+            for (_, module) in block_def_map.modules() {
+                for (def_id, _) in module.scope.values() {
+                    let mut validator = DeclValidator::new(self.db, self.krate, self.sink);
+                    validator.validate_item(def_id);
+                }
+            }
        }
        // Check whether non-snake case identifiers are allowed for this function.
diff --git a/crates/hir_ty/src/display.rs b/crates/hir_ty/src/display.rs
index a0882a2a1..ab51cb0a6 100644
--- a/crates/hir_ty/src/display.rs
+++ b/crates/hir_ty/src/display.rs
@@ -6,7 +6,7 @@ use arrayvec::ArrayVec;
 use chalk_ir::Mutability;
 use hir_def::{
    db::DefDatabase, find_path, generics::TypeParamProvenance, item_scope::ItemInNs,
-    AssocContainerId, HasModule, Lookup, ModuleId, TraitId,
+    AssocContainerId, Lookup, ModuleId, TraitId,
 };
 use hir_expand::name::Name;
@@ -611,7 +611,7 @@ impl HirDisplay for CallableSig {
 }
 fn fn_traits(db: &dyn DefDatabase, trait_: TraitId) -> impl Iterator<Item = TraitId> {
-    let krate = trait_.lookup(db).container.module(db).krate();
+    let krate = trait_.lookup(db).container.krate();
    let fn_traits = [
        db.lang_item(krate, "fn".into()),
        db.lang_item(krate, "fn_mut".into()),
diff --git a/crates/hir_ty/src/infer/path.rs b/crates/hir_ty/src/infer/path.rs
index 5d541104e..ae3554bac 100644
--- a/crates/hir_ty/src/infer/path.rs
+++ b/crates/hir_ty/src/infer/path.rs
@@ -260,7 +260,7 @@ impl<'a> InferenceContext<'a> {
                        }));
                        Some(trait_substs)
                    }
-                    AssocContainerId::ContainerId(_) => None,
+                    AssocContainerId::ModuleId(_) => None,
                };
                self.write_assoc_resolution(id, item);
diff --git a/crates/hir_ty/src/lower.rs b/crates/hir_ty/src/lower.rs
index b90fdc382..5fa83567b 100644
--- a/crates/hir_ty/src/lower.rs
+++ b/crates/hir_ty/src/lower.rs
@@ -1130,8 +1130,8 @@ impl CallableDefId {
        let db = db.upcast();
        match self {
            CallableDefId::FunctionId(f) => f.lookup(db).module(db),
-            CallableDefId::StructId(s) => s.lookup(db).container.module(db),
+            CallableDefId::StructId(s) => s.lookup(db).container,
-            CallableDefId::EnumVariantId(e) => e.parent.lookup(db).container.module(db),
+            CallableDefId::EnumVariantId(e) => e.parent.lookup(db).container,
        }
        .krate()
    }
diff --git a/crates/hir_ty/src/method_resolution.rs b/crates/hir_ty/src/method_resolution.rs
index 24db33c49..ccc12c075 100644
--- a/crates/hir_ty/src/method_resolution.rs
+++ b/crates/hir_ty/src/method_resolution.rs
@@ -267,7 +267,7 @@ impl Ty {
                LangItemTarget::ImplDefId(it) => Some(it),
                _ => None,
            })
-            .map(|it| it.lookup(db.upcast()).container.module(db.upcast()).krate())
+            .map(|it| it.lookup(db.upcast()).container.krate())
            .collect();
        Some(res)
    }
@@ -715,7 +715,7 @@ fn transform_receiver_ty(
                .fill_with_unknown()
                .build()
        }
-        AssocContainerId::ContainerId(_) => unreachable!(),
+        AssocContainerId::ModuleId(_) => unreachable!(),
    };
    let sig = db.callable_item_signature(function_id.into());
    Some(sig.value.params()[0].clone().subst_bound_vars(&substs))
diff --git a/crates/hir_ty/src/tests.rs b/crates/hir_ty/src/tests.rs
index 7386a4e7b..fc770ea60 100644
--- a/crates/hir_ty/src/tests.rs
+++ b/crates/hir_ty/src/tests.rs
@@ -13,7 +13,7 @@ use std::{env, sync::Arc};
 use base_db::{fixture::WithFixture, FileRange, SourceDatabase, SourceDatabaseExt};
 use expect_test::Expect;
 use hir_def::{
-    body::{BodySourceMap, SyntheticSyntax},
+    body::{Body, BodySourceMap, SyntheticSyntax},
    child_by_source::ChildBySource,
    db::DefDatabase,
    item_scope::ItemScope,
@@ -234,13 +234,13 @@ fn visit_module(
                    let def = it.into();
                    cb(def);
                    let body = db.body(def);
-                    visit_scope(db, crate_def_map, &body.item_scope, cb);
+                    visit_body(db, &body, cb);
                }
                AssocItemId::ConstId(it) => {
                    let def = it.into();
                    cb(def);
                    let body = db.body(def);
-                    visit_scope(db, crate_def_map, &body.item_scope, cb);
+                    visit_body(db, &body, cb);
                }
                AssocItemId::TypeAliasId(_) => (),
            }
@@ -259,19 +259,19 @@ fn visit_module(
                    let def = it.into();
                    cb(def);
                    let body = db.body(def);
-                    visit_scope(db, crate_def_map, &body.item_scope, cb);
+                    visit_body(db, &body, cb);
                }
                ModuleDefId::ConstId(it) => {
                    let def = it.into();
                    cb(def);
                    let body = db.body(def);
-                    visit_scope(db, crate_def_map, &body.item_scope, cb);
+                    visit_body(db, &body, cb);
                }
                ModuleDefId::StaticId(it) => {
                    let def = it.into();
                    cb(def);
                    let body = db.body(def);
-                    visit_scope(db, crate_def_map, &body.item_scope, cb);
+                    visit_body(db, &body, cb);
                }
                ModuleDefId::TraitId(it) => {
                    let trait_data = db.trait_data(it);
@@ -288,6 +288,14 @@ fn visit_module(
            }
        }
    }
+    fn visit_body(db: &TestDB, body: &Body, cb: &mut dyn FnMut(DefWithBodyId)) {
+        for def_map in body.block_scopes.iter().filter_map(|block| db.block_def_map(*block)) {
+            for (mod_id, _) in def_map.modules() {
+                visit_module(db, &def_map, mod_id, cb);
+            }
+        }
+    }
 }
 fn ellipsize(mut text: String, max_len: usize) -> String {
diff --git a/crates/hir_ty/src/tests/traits.rs b/crates/hir_ty/src/tests/traits.rs
index 528092082..e185b1c0a 100644
--- a/crates/hir_ty/src/tests/traits.rs
+++ b/crates/hir_ty/src/tests/traits.rs
@@ -3174,6 +3174,39 @@ fn f() {
 }
 #[test]
+fn trait_in_scope_with_inner_item() {
+    check_infer(
+        r#"
+mod m {
+    pub trait Tr {
+        fn method(&self) -> u8 { 0 }
+    }
+    impl Tr for () {}
+}
+use m::Tr;
+fn f() {
+    fn inner() {
+        ().method();
+      //^^^^^^^^^^^ u8
+    }
+}
+        "#,
+        expect![[r#"
+            46..50 'self': &Self
+            58..63 '{ 0 }': u8
+            60..61 '0': u8
+            115..185 '{     ...   } }': ()
+            132..183 '{     ...     }': ()
+            142..144 '()': ()
+            142..153 '().method()': u8
+        "#]],
+    );
+}
+#[test]
 fn inner_use_in_block() {
    check_types(
        r#"
diff --git a/crates/hir_ty/src/traits/chalk.rs b/crates/hir_ty/src/traits/chalk.rs
index 4378a9723..565672b6b 100644
--- a/crates/hir_ty/src/traits/chalk.rs
+++ b/crates/hir_ty/src/traits/chalk.rs
@@ -424,7 +424,7 @@ pub(crate) fn trait_datum_query(
    let bound_vars = Substs::bound_vars(&generic_params, DebruijnIndex::INNERMOST);
    let flags = rust_ir::TraitFlags {
        auto: trait_data.auto,
-        upstream: trait_.lookup(db.upcast()).container.module(db.upcast()).krate() != krate,
+        upstream: trait_.lookup(db.upcast()).container.krate() != krate,
        non_enumerable: true,
        coinductive: false, // only relevant for Chalk testing
        // FIXME: set these flags correctly
@@ -548,7 +548,7 @@ fn impl_def_datum(
    let generic_params = generics(db.upcast(), impl_id.into());
    let bound_vars = Substs::bound_vars(&generic_params, DebruijnIndex::INNERMOST);
    let trait_ = trait_ref.trait_;
-    let impl_type = if impl_id.lookup(db.upcast()).container.module(db.upcast()).krate() == krate {
+    let impl_type = if impl_id.lookup(db.upcast()).container.krate() == krate {
        rust_ir::ImplType::Local
    } else {
        rust_ir::ImplType::External
diff --git a/crates/hir_ty/src/utils.rs b/crates/hir_ty/src/utils.rs
index 65b79df0d..7351e4e54 100644
--- a/crates/hir_ty/src/utils.rs
+++ b/crates/hir_ty/src/utils.rs
@@ -259,6 +259,6 @@ fn parent_generic_def(db: &dyn DefDatabase, def: GenericDefId) -> Option<Generic
    match container {
        AssocContainerId::ImplId(it) => Some(it.into()),
        AssocContainerId::TraitId(it) => Some(it.into()),
-        AssocContainerId::ContainerId(_) => None,
+        AssocContainerId::ModuleId(_) => None,
    }
 }
diff --git a/crates/ide/Cargo.toml b/crates/ide/Cargo.toml
index f7c5efaf3..107bd8432 100644
--- a/crates/ide/Cargo.toml
+++ b/crates/ide/Cargo.toml
@@ -27,7 +27,6 @@ text_edit = { path = "../text_edit", version = "0.0.0" }
 ide_db = { path = "../ide_db", version = "0.0.0" }
 cfg = { path = "../cfg", version = "0.0.0" }
 profile = { path = "../profile", version = "0.0.0" }
-test_utils = { path = "../test_utils", version = "0.0.0" }
 ide_assists = { path = "../ide_assists", version = "0.0.0" }
 ide_ssr = { path = "../ide_ssr", version = "0.0.0" }
 ide_completion = { path = "../ide_completion", version = "0.0.0" }
@@ -37,4 +36,5 @@ ide_completion = { path = "../ide_completion", version = "0.0.0" }
 hir = { path = "../hir", version = "0.0.0" }
 [dev-dependencies]
+test_utils = { path = "../test_utils" }
 expect-test = "1.1"
diff --git a/crates/ide/src/display/short_label.rs b/crates/ide/src/display/short_label.rs
index 84b8883de..2df9266b4 100644
--- a/crates/ide/src/display/short_label.rs
+++ b/crates/ide/src/display/short_label.rs
@@ -71,11 +71,7 @@ impl ShortLabel for ast::TypeAlias {
 impl ShortLabel for ast::Const {
    fn short_label(&self) -> Option<String> {
-        let mut new_buf = short_label_from_ty(self, self.ty(), "const ")?;
+        short_label_from_ty(self, self.ty(), "const ")
-        if let Some(expr) = self.body() {
-            format_to!(new_buf, " = {}", expr.syntax());
-        }
-        Some(new_buf)
    }
 }
diff --git a/crates/ide/src/hover.rs b/crates/ide/src/hover.rs
index 5d1cc2052..ea45086ce 100644
--- a/crates/ide/src/hover.rs
+++ b/crates/ide/src/hover.rs
@@ -1,3 +1,4 @@
+use either::Either;
 use hir::{
    Adt, AsAssocItem, AssocItemContainer, FieldSource, GenericParam, HasAttrs, HasSource,
    HirDisplay, Module, ModuleDef, ModuleSource, Semantics,
@@ -366,7 +367,7 @@ fn hover_for_definition(
                .and_then(|fd| hover_for_builtin(fd, it))
                .or_else(|| Some(Markup::fenced_block(&it.name()))),
        },
-        Definition::Local(it) => Some(Markup::fenced_block(&it.ty(db).display(db))),
+        Definition::Local(it) => hover_for_local(it, db),
        Definition::SelfType(impl_def) => {
            impl_def.target_ty(db).as_adt().and_then(|adt| match adt {
                Adt::Struct(it) => from_def_source(db, it, mod_path),
@@ -405,6 +406,29 @@ fn hover_for_definition(
    }
 }
+fn hover_for_local(it: hir::Local, db: &RootDatabase) -> Option<Markup> {
+    let ty = it.ty(db);
+    let ty = ty.display(db);
+    let is_mut = if it.is_mut(db) { "mut " } else { "" };
+    let desc = match it.source(db).value {
+        Either::Left(ident) => {
+            let name = it.name(db).unwrap();
+            let let_kw = if ident
+                .syntax()
+                .parent()
+                .map_or(false, |p| p.kind() == LET_STMT || p.kind() == CONDITION)
+            {
+                "let "
+            } else {
+                ""
+            };
+            format!("{}{}{}: {}", let_kw, is_mut, name, ty)
+        }
+        Either::Right(_) => format!("{}self: {}", is_mut, ty),
+    };
+    hover_markup(None, Some(desc), None)
+}
 fn hover_for_keyword(
    sema: &Semantics<RootDatabase>,
    links_in_hover: bool,
@@ -574,7 +598,7 @@ fn main() {
                *iter*
                ```rust
-                Iter<Scan<OtherStruct<OtherStruct<i32>>, |&mut u32, &u32, &mut u32| -> Option<u32>, u32>>
+                let mut iter: Iter<Scan<OtherStruct<OtherStruct<i32>>, |&mut u32, &u32, &mut u32| -> Option<u32>, u32>>
                ```
            "#]],
        );
@@ -798,7 +822,7 @@ fn main() {
                ```
                ```rust
-                const foo: u32 = 123
+                const foo: u32
                ```
            "#]],
        );
@@ -831,7 +855,7 @@ fn main() {
                *zz*
                ```rust
-                Test<i32, u8>
+                let zz: Test<i32, u8>
                ```
            "#]],
        );
@@ -870,7 +894,7 @@ fn main() { let b$0ar = Some(12); }
                *bar*
                ```rust
-                Option<i32>
+                let bar: Option<i32>
                ```
            "#]],
        );
@@ -938,7 +962,7 @@ fn main() {
                *foo*
                ```rust
-                i32
+                foo: i32
                ```
            "#]],
        )
@@ -952,7 +976,7 @@ fn main() {
                *foo*
                ```rust
-                i32
+                foo: i32
                ```
            "#]],
        )
@@ -966,7 +990,7 @@ fn main() {
                *foo*
                ```rust
-                i32
+                foo: i32
                ```
            "#]],
        )
@@ -980,7 +1004,7 @@ fn main() {
                *foo*
                ```rust
-                i32
+                foo: i32
                ```
            "#]],
        )
@@ -1000,7 +1024,7 @@ fn main() {
                *_x*
                ```rust
-                impl Deref<Target = u8> + DerefMut<Target = u8>
+                _x: impl Deref<Target = u8> + DerefMut<Target = u8>
                ```
            "#]],
        )
@@ -1022,7 +1046,7 @@ fn main() { let foo_$0test = Thing::new(); }
                *foo_test*
                ```rust
-                Thing
+                let foo_test: Thing
                ```
            "#]],
        )
@@ -1081,7 +1105,7 @@ fn main() {
                ```
                ```rust
-                const C: u32 = 1
+                const C: u32
                ```
            "#]],
        )
@@ -1182,7 +1206,7 @@ fn y() {
                *x*
                ```rust
-                i32
+                let x: i32
                ```
            "#]],
        )
@@ -1259,7 +1283,7 @@ fn foo(bar:u32) { let a = id!(ba$0r); }
                *bar*
                ```rust
-                u32
+                bar: u32
                ```
            "#]],
        );
@@ -1277,7 +1301,7 @@ fn foo(bar:u32) { let a = id!(ba$0r); }
                *bar*
                ```rust
-                u32
+                bar: u32
                ```
            "#]],
        );
@@ -3302,7 +3326,7 @@ fn main() {
                *f*
                ```rust
-                &i32
+                f: &i32
                ```
            "#]],
        );
@@ -3321,7 +3345,7 @@ impl Foo {
                *self*
                ```rust
-                &Foo
+                self: &Foo
                ```
            "#]],
        );
@@ -3341,7 +3365,7 @@ impl Foo {
                *self*
                ```rust
-                Arc<Foo>
+                self: Arc<Foo>
                ```
            "#]],
        );
@@ -3537,7 +3561,7 @@ fn foo() {
                ```
                ```rust
-                const FOO: usize = 3
+                const FOO: usize
                ```
                ---
diff --git a/crates/ide/src/lib.rs b/crates/ide/src/lib.rs
index f83ed65d5..0a493d2f3 100644
--- a/crates/ide/src/lib.rs
+++ b/crates/ide/src/lib.rs
@@ -41,6 +41,7 @@ mod parent_module;
 mod references;
 mod fn_references;
 mod runnables;
+mod ssr;
 mod status;
 mod syntax_highlighting;
 mod syntax_tree;
@@ -51,6 +52,7 @@ mod doc_links;
 use std::sync::Arc;
 use cfg::CfgOptions;
 use ide_db::base_db::{
    salsa::{self, ParallelDatabase},
    CheckCanceled, Env, FileLoader, FileSet, SourceDatabase, VfsPath,
@@ -85,7 +87,7 @@ pub use crate::{
 pub use hir::{Documentation, Semantics};
 pub use ide_assists::{Assist, AssistConfig, AssistId, AssistKind};
 pub use ide_completion::{
-    CompletionConfig, CompletionItem, CompletionItemKind, CompletionScore, ImportEdit,
+    CompletionConfig, CompletionItem, CompletionItemKind, CompletionRelevance, ImportEdit,
    InsertTextFormat,
 };
 pub use ide_db::{
@@ -502,7 +504,11 @@ impl Analysis {
        resolve: bool,
        frange: FileRange,
    ) -> Cancelable<Vec<Assist>> {
-        self.with_db(|db| Assist::get(db, config, resolve, frange))
+        self.with_db(|db| {
+            let mut acc = Assist::get(db, config, resolve, frange);
+            ssr::add_ssr_assist(db, &mut acc, resolve, frange);
+            acc
+        })
    }
    /// Computes the set of diagnostics for the given file.
diff --git a/crates/ide/src/references/rename.rs b/crates/ide/src/references/rename.rs
index 05c73de88..1e378279d 100644
--- a/crates/ide/src/references/rename.rs
+++ b/crates/ide/src/references/rename.rs
@@ -21,7 +21,7 @@ use crate::{display::TryToNav, FilePosition, FileSystemEdit, RangeInfo, SourceCh
 type RenameResult<T> = Result<T, RenameError>;
 #[derive(Debug)]
-pub struct RenameError(pub(crate) String);
+pub struct RenameError(String);
 impl fmt::Display for RenameError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -47,16 +47,15 @@ pub(crate) fn prepare_rename(
    let sema = Semantics::new(db);
    let source_file = sema.parse(position.file_id);
    let syntax = source_file.syntax();
-    let range = match &sema
+    let name_like = sema
        .find_node_at_offset_with_descend(&syntax, position.offset)
-        .ok_or_else(|| format_err!("No references found at position"))?
+        .ok_or_else(|| format_err!("No references found at position"))?;
-    {
+    let node = match &name_like {
        ast::NameLike::Name(it) => it.syntax(),
        ast::NameLike::NameRef(it) => it.syntax(),
        ast::NameLike::Lifetime(it) => it.syntax(),
-    }
+    };
-    .text_range();
+    Ok(RangeInfo::new(sema.original_range(node).range, ()))
-    Ok(RangeInfo::new(range, ()))
 }
 // Feature: Rename
@@ -94,6 +93,7 @@ pub(crate) fn rename_with_semantics(
    }
 }
+/// Called by the client when it is about to rename a file.
 pub(crate) fn will_rename_file(
    db: &RootDatabase,
    file_id: FileId,
@@ -545,6 +545,8 @@ mod tests {
    use crate::{fixture, FileId};
+    use super::{RangeInfo, RenameError};
    fn check(new_name: &str, ra_fixture_before: &str, ra_fixture_after: &str) {
        let ra_fixture_after = &trim_indent(ra_fixture_after);
        let (analysis, position) = fixture::position(ra_fixture_before);
@@ -590,6 +592,45 @@ mod tests {
        expect.assert_debug_eq(&source_change)
    }
+    fn check_prepare(ra_fixture: &str, expect: Expect) {
+        let (analysis, position) = fixture::position(ra_fixture);
+        let result = analysis
+            .prepare_rename(position)
+            .unwrap_or_else(|err| panic!("PrepareRename was cancelled: {}", err));
+        match result {
+            Ok(RangeInfo { range, info: () }) => {
+                let source = analysis.file_text(position.file_id).unwrap();
+                expect.assert_eq(&format!("{:?}: {}", range, &source[range]))
+            }
+            Err(RenameError(err)) => expect.assert_eq(&err),
+        };
+    }
+    #[test]
+    fn test_prepare_rename_namelikes() {
+        check_prepare(r"fn name$0<'lifetime>() {}", expect![[r#"3..7: name"#]]);
+        check_prepare(r"fn name<'lifetime$0>() {}", expect![[r#"8..17: 'lifetime"#]]);
+        check_prepare(r"fn name<'lifetime>() { name$0(); }", expect![[r#"23..27: name"#]]);
+    }
+    #[test]
+    fn test_prepare_rename_in_macro() {
+        check_prepare(
+            r"macro_rules! foo {
+    ($ident:ident) => {
+        pub struct $ident;
+    }
+}
+foo!(Foo$0);",
+            expect![[r#"83..86: Foo"#]],
+        );
+    }
+    #[test]
+    fn test_prepare_rename_keyword() {
+        check_prepare(r"struct$0 Foo;", expect![[r#"No references found at position"#]]);
+    }
    #[test]
    fn test_rename_to_underscore() {
        check("_", r#"fn main() { let i$0 = 1; }"#, r#"fn main() { let _ = 1; }"#);
diff --git a/crates/ide/src/ssr.rs b/crates/ide/src/ssr.rs
new file mode 100644
index 000000000..f3638d928
--- /dev/null
+++ b/crates/ide/src/ssr.rs
@@ -0,0 +1,259 @@
+//! This module provides an SSR assist. It is not desirable to include this
+//! assist in ide_assists because that would require the ide_assists crate
+//! depend on the ide_ssr crate.
+use ide_assists::{Assist, AssistId, AssistKind, GroupLabel};
+use ide_db::{base_db::FileRange, label::Label, source_change::SourceChange, RootDatabase};
+pub(crate) fn add_ssr_assist(
+    db: &RootDatabase,
+    base: &mut Vec<Assist>,
+    resolve: bool,
+    frange: FileRange,
+) -> Option<()> {
+    let (match_finder, comment_range) = ide_ssr::ssr_from_comment(db, frange)?;
+    let (source_change_for_file, source_change_for_workspace) = if resolve {
+        let edits = match_finder.edits();
+        let source_change_for_file = {
+            let text_edit_for_file = edits.get(&frange.file_id).cloned().unwrap_or_default();
+            SourceChange::from_text_edit(frange.file_id, text_edit_for_file)
+        };
+        let source_change_for_workspace = SourceChange::from(match_finder.edits());
+        (Some(source_change_for_file), Some(source_change_for_workspace))
+    } else {
+        (None, None)
+    };
+    let assists = vec![
+        ("Apply SSR in file", source_change_for_file),
+        ("Apply SSR in workspace", source_change_for_workspace),
+    ];
+    for (label, source_change) in assists.into_iter() {
+        let assist = Assist {
+            id: AssistId("ssr", AssistKind::RefactorRewrite),
+            label: Label::new(label),
+            group: Some(GroupLabel("Apply SSR".into())),
+            target: comment_range,
+            source_change,
+        };
+        base.push(assist);
+    }
+    Some(())
+}
+#[cfg(test)]
+mod tests {
+    use std::sync::Arc;
+    use expect_test::expect;
+    use ide_assists::Assist;
+    use ide_db::{
+        base_db::{fixture::WithFixture, salsa::Durability, FileRange},
+        symbol_index::SymbolsDatabase,
+        RootDatabase,
+    };
+    use rustc_hash::FxHashSet;
+    use super::add_ssr_assist;
+    fn get_assists(ra_fixture: &str, resolve: bool) -> Vec<Assist> {
+        let (mut db, file_id, range_or_offset) = RootDatabase::with_range_or_offset(ra_fixture);
+        let mut local_roots = FxHashSet::default();
+        local_roots.insert(ide_db::base_db::fixture::WORKSPACE);
+        db.set_local_roots_with_durability(Arc::new(local_roots), Durability::HIGH);
+        let mut assists = vec![];
+        add_ssr_assist(
+            &db,
+            &mut assists,
+            resolve,
+            FileRange { file_id, range: range_or_offset.into() },
+        );
+        assists
+    }
+    #[test]
+    fn not_applicable_comment_not_ssr() {
+        let ra_fixture = r#"
+            //- /lib.rs
+            // This is foo $0
+            fn foo() {}
+            "#;
+        let resolve = true;
+        let assists = get_assists(ra_fixture, resolve);
+        assert_eq!(0, assists.len());
+    }
+    #[test]
+    fn resolve_edits_true() {
+        let resolve = true;
+        let assists = get_assists(
+            r#"
+            //- /lib.rs
+            mod bar;
+            // 2 ==>> 3$0
+            fn foo() { 2 }
+            //- /bar.rs
+            fn bar() { 2 }
+            "#,
+            resolve,
+        );
+        assert_eq!(2, assists.len());
+        let mut assists = assists.into_iter();
+        let apply_in_file_assist = assists.next().unwrap();
+        expect![[r#"
+            Assist {
+                id: AssistId(
+                    "ssr",
+                    RefactorRewrite,
+                ),
+                label: "Apply SSR in file",
+                group: Some(
+                    GroupLabel(
+                        "Apply SSR",
+                    ),
+                ),
+                target: 10..21,
+                source_change: Some(
+                    SourceChange {
+                        source_file_edits: {
+                            FileId(
+                                0,
+                            ): TextEdit {
+                                indels: [
+                                    Indel {
+                                        insert: "3",
+                                        delete: 33..34,
+                                    },
+                                ],
+                            },
+                        },
+                        file_system_edits: [],
+                        is_snippet: false,
+                    },
+                ),
+            }
+        "#]]
+        .assert_debug_eq(&apply_in_file_assist);
+        let apply_in_workspace_assist = assists.next().unwrap();
+        expect![[r#"
+            Assist {
+                id: AssistId(
+                    "ssr",
+                    RefactorRewrite,
+                ),
+                label: "Apply SSR in workspace",
+                group: Some(
+                    GroupLabel(
+                        "Apply SSR",
+                    ),
+                ),
+                target: 10..21,
+                source_change: Some(
+                    SourceChange {
+                        source_file_edits: {
+                            FileId(
+                                0,
+                            ): TextEdit {
+                                indels: [
+                                    Indel {
+                                        insert: "3",
+                                        delete: 33..34,
+                                    },
+                                ],
+                            },
+                            FileId(
+                                1,
+                            ): TextEdit {
+                                indels: [
+                                    Indel {
+                                        insert: "3",
+                                        delete: 11..12,
+                                    },
+                                ],
+                            },
+                        },
+                        file_system_edits: [],
+                        is_snippet: false,
+                    },
+                ),
+            }
+        "#]]
+        .assert_debug_eq(&apply_in_workspace_assist);
+    }
+    #[test]
+    fn resolve_edits_false() {
+        let resolve = false;
+        let assists = get_assists(
+            r#"
+            //- /lib.rs
+            mod bar;
+            // 2 ==>> 3$0
+            fn foo() { 2 }
+            //- /bar.rs
+            fn bar() { 2 }
+            "#,
+            resolve,
+        );
+        assert_eq!(2, assists.len());
+        let mut assists = assists.into_iter();
+        let apply_in_file_assist = assists.next().unwrap();
+        expect![[r#"
+            Assist {
+                id: AssistId(
+                    "ssr",
+                    RefactorRewrite,
+                ),
+                label: "Apply SSR in file",
+                group: Some(
+                    GroupLabel(
+                        "Apply SSR",
+                    ),
+                ),
+                target: 10..21,
+                source_change: None,
+            }
+        "#]]
+        .assert_debug_eq(&apply_in_file_assist);
+        let apply_in_workspace_assist = assists.next().unwrap();
+        expect![[r#"
+            Assist {
+                id: AssistId(
+                    "ssr",
+                    RefactorRewrite,
+                ),
+                label: "Apply SSR in workspace",
+                group: Some(
+                    GroupLabel(
+                        "Apply SSR",
+                    ),
+                ),
+                target: 10..21,
+                source_change: None,
+            }
+        "#]]
+        .assert_debug_eq(&apply_in_workspace_assist);
+    }
+}
diff --git a/crates/ide/src/syntax_highlighting/highlight.rs b/crates/ide/src/syntax_highlighting/highlight.rs
index 24fcbb584..b0cfdd8b7 100644
--- a/crates/ide/src/syntax_highlighting/highlight.rs
+++ b/crates/ide/src/syntax_highlighting/highlight.rs
@@ -330,10 +330,11 @@ fn highlight_def(db: &RootDatabase, def: Definition) -> Highlight {
                HlTag::Symbol(SymbolKind::Local)
            };
            let mut h = Highlight::new(tag);
-            if local.is_mut(db) || local.ty(db).is_mutable_reference() {
+            let ty = local.ty(db);
+            if local.is_mut(db) || ty.is_mutable_reference() {
                h |= HlMod::Mutable;
            }
-            if local.ty(db).as_callable(db).is_some() || local.ty(db).impls_fnonce(db) {
+            if ty.as_callable(db).is_some() || ty.impls_fnonce(db) {
                h |= HlMod::Callable;
            }
            return h;
diff --git a/crates/ide_assists/Cargo.toml b/crates/ide_assists/Cargo.toml
index 3bf0099a9..dd9aa27c6 100644
--- a/crates/ide_assists/Cargo.toml
+++ b/crates/ide_assists/Cargo.toml
@@ -21,7 +21,7 @@ text_edit = { path = "../text_edit", version = "0.0.0" }
 profile = { path = "../profile", version = "0.0.0" }
 ide_db = { path = "../ide_db", version = "0.0.0" }
 hir = { path = "../hir", version = "0.0.0" }
-test_utils = { path = "../test_utils", version = "0.0.0" }
 [dev-dependencies]
+test_utils = { path = "../test_utils" }
 expect-test = "1.1"
diff --git a/crates/ide_assists/src/handlers/add_turbo_fish.rs b/crates/ide_assists/src/handlers/add_turbo_fish.rs
index 3b6efbab4..ee879c151 100644
--- a/crates/ide_assists/src/handlers/add_turbo_fish.rs
+++ b/crates/ide_assists/src/handlers/add_turbo_fish.rs
@@ -56,13 +56,20 @@ pub(crate) fn add_turbo_fish(acc: &mut Assists, ctx: &AssistContext) -> Option<(
    if let Some(let_stmt) = ctx.find_node_at_offset::<ast::LetStmt>() {
        if let_stmt.colon_token().is_none() {
            let type_pos = let_stmt.pat()?.syntax().last_token()?.text_range().end();
+            let semi_pos = let_stmt.syntax().last_token()?.text_range().end();
            acc.add(
                AssistId("add_type_ascription", AssistKind::RefactorRewrite),
                "Add `: _` before assignment operator",
                ident.text_range(),
-                |builder| match ctx.config.snippet_cap {
+                |builder| {
-                    Some(cap) => builder.insert_snippet(cap, type_pos, ": ${0:_}"),
+                    if let_stmt.semicolon_token().is_none() {
-                    None => builder.insert(type_pos, ": _"),
+                        builder.insert(semi_pos, ";");
+                    }
+                    match ctx.config.snippet_cap {
+                        Some(cap) => builder.insert_snippet(cap, type_pos, ": ${0:_}"),
+                        None => builder.insert(type_pos, ": _"),
+                    }
                },
            )?
        } else {
@@ -265,4 +272,24 @@ fn main() {
 "#,
        );
    }
+    #[test]
+    fn add_type_ascription_append_semicolon() {
+        check_assist_by_label(
+            add_turbo_fish,
+            r#"
+fn make<T>() -> T {}
+fn main() {
+    let x = make$0()
+}
+"#,
+            r#"
+fn make<T>() -> T {}
+fn main() {
+    let x: ${0:_} = make();
+}
+"#,
+            "Add `: _` before assignment operator",
+        );
+    }
 }
diff --git a/crates/ide_assists/src/handlers/auto_import.rs b/crates/ide_assists/src/handlers/auto_import.rs
index 7caee8df0..7019039b9 100644
--- a/crates/ide_assists/src/handlers/auto_import.rs
+++ b/crates/ide_assists/src/handlers/auto_import.rs
@@ -1,7 +1,7 @@
 use ide_db::helpers::{
    import_assets::{ImportAssets, ImportCandidate},
    insert_use::{insert_use, ImportScope},
-    item_name, mod_path_to_ast,
+    mod_path_to_ast,
 };
 use syntax::{ast, AstNode, SyntaxNode};
@@ -90,17 +90,13 @@ pub(crate) fn auto_import(acc: &mut Assists, ctx: &AssistContext) -> Option<()>
    }
    let range = ctx.sema.original_range(&syntax_under_caret).range;
-    let group = import_group_message(import_assets.import_candidate());
+    let group_label = group_label(import_assets.import_candidate());
    let scope = ImportScope::find_insert_use_container(&syntax_under_caret, &ctx.sema)?;
    for import in proposed_imports {
-        let name = match item_name(ctx.db(), import.original_item) {
-            Some(name) => name,
-            None => continue,
-        };
        acc.add_group(
-            &group,
+            &group_label,
            AssistId("auto_import", AssistKind::QuickFix),
-            format!("Import `{}`", name),
+            format!("Import `{}`", import.import_path),
            range,
            |builder| {
                let rewriter =
@@ -126,7 +122,7 @@ pub(super) fn find_importable_node(ctx: &AssistContext) -> Option<(ImportAssets,
    }
 }
-fn import_group_message(import_candidate: &ImportCandidate) -> GroupLabel {
+fn group_label(import_candidate: &ImportCandidate) -> GroupLabel {
    let name = match import_candidate {
        ImportCandidate::Path(candidate) => format!("Import {}", candidate.name.text()),
        ImportCandidate::TraitAssocItem(candidate) => {
diff --git a/crates/ide_assists/src/handlers/qualify_path.rs b/crates/ide_assists/src/handlers/qualify_path.rs
index 272874ae3..30b23da6c 100644
--- a/crates/ide_assists/src/handlers/qualify_path.rs
+++ b/crates/ide_assists/src/handlers/qualify_path.rs
@@ -3,7 +3,7 @@ use std::iter;
 use hir::AsAssocItem;
 use ide_db::helpers::{
    import_assets::{ImportCandidate, LocatedImport},
-    item_name, mod_path_to_ast,
+    mod_path_to_ast,
 };
 use ide_db::RootDatabase;
 use syntax::{
@@ -78,7 +78,7 @@ pub(crate) fn qualify_path(acc: &mut Assists, ctx: &AssistContext) -> Option<()>
        acc.add_group(
            &group_label,
            AssistId("qualify_path", AssistKind::QuickFix),
-            label(ctx.db(), candidate, &import),
+            label(candidate, &import),
            range,
            |builder| {
                qualify_candidate.qualify(
@@ -199,21 +199,17 @@ fn group_label(candidate: &ImportCandidate) -> GroupLabel {
    GroupLabel(format!("Qualify {}", name))
 }
-fn label(db: &RootDatabase, candidate: &ImportCandidate, import: &LocatedImport) -> String {
+fn label(candidate: &ImportCandidate, import: &LocatedImport) -> String {
-    let display_path = match item_name(db, import.original_item) {
-        Some(display_path) => display_path.to_string(),
-        None => "{unknown}".to_string(),
-    };
    match candidate {
        ImportCandidate::Path(candidate) => {
            if candidate.qualifier.is_some() {
-                format!("Qualify with `{}`", display_path)
+                format!("Qualify with `{}`", import.import_path)
            } else {
-                format!("Qualify as `{}`", display_path)
+                format!("Qualify as `{}`", import.import_path)
            }
        }
-        ImportCandidate::TraitAssocItem(_) => format!("Qualify `{}`", display_path),
+        ImportCandidate::TraitAssocItem(_) => format!("Qualify `{}`", import.import_path),
-        ImportCandidate::TraitMethod(_) => format!("Qualify with cast as `{}`", display_path),
+        ImportCandidate::TraitMethod(_) => format!("Qualify with cast as `{}`", import.import_path),
    }
 }
diff --git a/crates/ide_completion/Cargo.toml b/crates/ide_completion/Cargo.toml
index 84aa40736..585ecca50 100644
--- a/crates/ide_completion/Cargo.toml
+++ b/crates/ide_completion/Cargo.toml
@@ -22,11 +22,11 @@ text_edit = { path = "../text_edit", version = "0.0.0" }
 base_db = { path = "../base_db", version = "0.0.0" }
 ide_db = { path = "../ide_db", version = "0.0.0" }
 profile = { path = "../profile", version = "0.0.0" }
-test_utils = { path = "../test_utils", version = "0.0.0" }
 # completions crate should depend only on the top-level `hir` package. if you need
 # something from some `hir_xxx` subpackage, reexport the API via `hir`.
 hir = { path = "../hir", version = "0.0.0" }
 [dev-dependencies]
+test_utils = { path = "../test_utils" }
 expect-test = "1.1"
diff --git a/crates/ide_completion/src/completions/attribute.rs b/crates/ide_completion/src/completions/attribute.rs
index cb05e85fc..e846678b4 100644
--- a/crates/ide_completion/src/completions/attribute.rs
+++ b/crates/ide_completion/src/completions/attribute.rs
@@ -45,15 +45,15 @@ fn complete_attribute_start(acc: &mut Completions, ctx: &CompletionContext, attr
            CompletionKind::Attribute,
            ctx.source_range(),
            attr_completion.label,
-        )
+        );
-        .kind(CompletionItemKind::Attribute);
+        item.kind(CompletionItemKind::Attribute);
        if let Some(lookup) = attr_completion.lookup {
-            item = item.lookup_by(lookup);
+            item.lookup_by(lookup);
        }
        if let Some((snippet, cap)) = attr_completion.snippet.zip(ctx.config.snippet_cap) {
-            item = item.insert_snippet(cap, snippet);
+            item.insert_snippet(cap, snippet);
        }
        if attribute.kind() == ast::AttrKind::Inner || !attr_completion.prefer_inner {
@@ -168,16 +168,20 @@ fn complete_derive(acc: &mut Completions, ctx: &CompletionContext, derive_input:
            );
            let lookup = components.join(", ");
            let label = components.iter().rev().join(", ");
-            CompletionItem::new(CompletionKind::Attribute, ctx.source_range(), label)
+            let mut item =
-                .lookup_by(lookup)
+                CompletionItem::new(CompletionKind::Attribute, ctx.source_range(), label);
-                .kind(CompletionItemKind::Attribute)
+            item.lookup_by(lookup).kind(CompletionItemKind::Attribute);
-                .add_to(acc)
+            item.add_to(acc);
        }
        for custom_derive_name in get_derive_names_in_scope(ctx).difference(&existing_derives) {
-            CompletionItem::new(CompletionKind::Attribute, ctx.source_range(), custom_derive_name)
+            let mut item = CompletionItem::new(
-                .kind(CompletionItemKind::Attribute)
+                CompletionKind::Attribute,
-                .add_to(acc)
+                ctx.source_range(),
+                custom_derive_name,
+            );
+            item.kind(CompletionItemKind::Attribute);
+            item.add_to(acc);
        }
    }
 }
@@ -193,14 +197,13 @@ fn complete_lint(
            .into_iter()
            .filter(|completion| !existing_lints.contains(completion.label))
        {
-            CompletionItem::new(
+            let mut item = CompletionItem::new(
                CompletionKind::Attribute,
                ctx.source_range(),
                lint_completion.label,
-            )
+            );
-            .kind(CompletionItemKind::Attribute)
+            item.kind(CompletionItemKind::Attribute).detail(lint_completion.description);
-            .detail(lint_completion.description)
+            item.add_to(acc)
-            .add_to(acc)
        }
    }
 }
diff --git a/crates/ide_completion/src/completions/fn_param.rs b/crates/ide_completion/src/completions/fn_param.rs
index 1bcc8727f..0243dce56 100644
--- a/crates/ide_completion/src/completions/fn_param.rs
+++ b/crates/ide_completion/src/completions/fn_param.rs
@@ -54,10 +54,9 @@ pub(crate) fn complete_fn_param(acc: &mut Completions, ctx: &CompletionContext)
    }
    params.into_iter().for_each(|(label, lookup)| {
-        CompletionItem::new(CompletionKind::Magic, ctx.source_range(), label)
+        let mut item = CompletionItem::new(CompletionKind::Magic, ctx.source_range(), label);
-            .kind(CompletionItemKind::Binding)
+        item.kind(CompletionItemKind::Binding).lookup_by(lookup);
-            .lookup_by(lookup)
+        item.add_to(acc)
-            .add_to(acc)
    });
 }
diff --git a/crates/ide_completion/src/completions/keyword.rs b/crates/ide_completion/src/completions/keyword.rs
index 80aa9fb06..b635e0ca3 100644
--- a/crates/ide_completion/src/completions/keyword.rs
+++ b/crates/ide_completion/src/completions/keyword.rs
@@ -12,21 +12,19 @@ pub(crate) fn complete_use_tree_keyword(acc: &mut Completions, ctx: &CompletionC
    if ctx.use_item_syntax.is_some() {
        if ctx.path_qual.is_none() {
-            CompletionItem::new(CompletionKind::Keyword, source_range, "crate::")
+            let mut item = CompletionItem::new(CompletionKind::Keyword, source_range, "crate::");
-                .kind(CompletionItemKind::Keyword)
+            item.kind(CompletionItemKind::Keyword).insert_text("crate::");
-                .insert_text("crate::")
+            item.add_to(acc);
-                .add_to(acc);
        }
-        CompletionItem::new(CompletionKind::Keyword, source_range, "self")
+        let mut item = CompletionItem::new(CompletionKind::Keyword, source_range, "self");
-            .kind(CompletionItemKind::Keyword)